test: tests for safeSelect helper fn

also add safeSelectFirst variant

Author: phette23

collection-export/strict-mods.test.js

@@ -4,7 +4,7 @@ import xpath from 'xpath'
 import { DOMParser as xmldom } from '@xmldom/xmldom'
 
 import { removeBadNameUsageAttrs, unwrapSimpleElement, fixTitleAttributes, unwrapDateCreated, unwrapDateOther, fixDateCreatedKeyDate, fixDateCreatedQualifer, renameElement, removeElement, removeEmptyElements, removeAttribute, convertAuthorityElement, moveClassificationToSubject, wrapElement, wrapTextWithChild, moveAndRenameElement, convertNamePartDate, convertSubNameWrapper, wrapCopyInformation, removeEmptyClassifications, convertSpeakerReleaseDetail, convertArchivesWrapper, toStrictMODS } from './strict-mods.js'
-import { hasDirectTextContent } from './xml-helpers.js'
+import { hasDirectTextContent, safeSelect, safeSelectFirst } from './xml-helpers.js'
 
 // Test fixtures
 const fixtures = {
@@ -4279,5 +4279,64 @@ describe('Strict MODS Conversion', () => {
                 assert.strictEqual(hasDirectTextContent(location), false)
             })
         })
+
+        describe('safeSelect', () => {
+            it('should return empty array for null document', () => {
+                const result = safeSelect('//mods', null)
+                assert.deepStrictEqual(result, [])
+            })
+
+            it('should return empty array for undefined document', () => {
+                const result = safeSelect('//mods', undefined)
+                assert.deepStrictEqual(result, [])
+            })
+
+            it('should return empty array for XPath with no matches', () => {
+                const parser = new xmldom()
+                const doc = parser.parseFromString('<xml><mods/></xml>', 'text/xml')
+                const result = safeSelect('//invalid_xpath', doc)
+                assert.deepStrictEqual(result, [])
+            })
+
+            it('should return matching elements for valid XPath', () => {
+                const parser = new xmldom()
+                const doc = parser.parseFromString('<xml><mods/><mods/></xml>', 'text/xml')
+                const result = safeSelect('//mods', doc)
+                assert.strictEqual(result.length, 2)
+            })
+
+            it('should not return elements without parents', () => {
+                const parser = new xmldom()
+                const doc = parser.parseFromString('<mods><child/></mods>', 'text/xml')
+                const child = xpath.select1("//child", doc)
+                // Manually remove the parent to simulate an orphaned element
+                child.parentNode.parentNode.removeChild(child.parentNode)
+                assert.deepStrictEqual(safeSelect('//child', doc), [])
+            })
+        })
+
+        describe('safeSelectFirst', () => {
+            it('should return null for null document', () => {
+                const result = safeSelectFirst('//mods', null)
+                assert.strictEqual(result, null)
+            })
+
+            it('should return null for XPath with no matches', () => {
+                const parser = new xmldom()
+                const doc = parser.parseFromString('<xml><mods/></xml>', 'text/xml')
+                const result = safeSelectFirst('//invalid_xpath', doc)
+                assert.strictEqual(result, null)
+            })
+
+            it('should return the first matching element for valid XPath', () => {
+                const parser = new xmldom()
+                const doc = parser.parseFromString('<xml><mods/><mods/></xml>', 'text/xml')
+                const modsElements = xpath.select('//mods', doc)
+                const firstMods = safeSelectFirst('//mods', doc)
+                assert.ok(firstMods)
+                assert.strictEqual(firstMods.nodeName, 'mods')
+                assert.deepEqual(firstMods, modsElements[0])
+            })
+        })
     })
 })

collection-export/xml-helpers.js

@@ -15,12 +15,30 @@ import xpath from 'xpath'
  * @returns {Element[]} Array of elements with valid parents
  */
 export function safeSelect(xpathExpression, context, namespaces = {}) {
+    if (!context) return []
     const select = xpath.useNamespaces(namespaces)
     const elements = select(xpathExpression, context)
     // Filter out elements without parents upfront to avoid null checks in loops
     return Array.from(elements).filter(el => el && el.parentNode)
 }
 
+/**
+ * Like safeSelect but returns only the first element with a valid parent
+ *
+ * @param {string} xpathExpression - XPath expression to select elements
+ * @param {Document|Element} context - DOM context to search within
+ * @param {Object} [namespaces={}] - Optional namespace mapping
+ * @returns {Element|null} First element with a valid parent, or null if none found
+ */
+export function safeSelectFirst(xpathExpression, context, namespaces = {}) {
+    if (!context) return null
+    const select = xpath.useNamespaces(namespaces)
+    const elements = select(xpathExpression, context)
+    // Filter out elements without parents upfront to avoid null checks in loops
+    const filtered = Array.from(elements).filter(el => el && el.parentNode)
+    return filtered.length > 0 ? filtered[0] : null
+}
+
 /**
  * Copy all attributes from source element to target element
  * Optionally skip certain attribute names