XmlXPath to hold namespace information

Author: jameslan

src/document.mts

@@ -1,8 +1,8 @@
 import {
     XmlError, xmlDocGetRootElement, xmlFreeDoc, xmlNewDoc,
 } from './libxml2.mjs';
-import { NamespaceMap, XmlElement, XmlNode } from './nodes.mjs';
-import XmlXPath from './xpath.mjs';
+import { XmlElement, XmlNode } from './nodes.mjs';
+import { XmlXPath, NamespaceMap } from './xpath.mjs';
 
 export default class XmlDocument {
     /** @internal */
@@ -30,6 +30,8 @@ export default class XmlDocument {
         xmlFreeDoc(this._docPtr);
     }
 
+    get(xpath: XmlXPath): XmlNode | null;
+    get(xpath: string, namespaces?: NamespaceMap): XmlNode | null;
     /**
      * Find the first descendant node of root element matching the given xpath selector.
      * @param xpath XPath selector
@@ -43,6 +45,8 @@ export default class XmlDocument {
         return this.root.get(xpath, namespaces);
     }
 
+    find(xpath: XmlXPath): XmlNode[];
+    find(xpath: string, namespaces?: NamespaceMap): XmlNode[];
     /**
      * Find all the descendant nodes of root element matching the given xpath selector.
      * @param xpath XPath selector

src/index.mts

@@ -9,15 +9,14 @@ import {
 } from './libxml2.mjs';
 import type { XmlDocPtr } from './libxml2raw';
 
-export { default as XmlXPath } from './xpath.mjs';
+export { XmlXPath, NamespaceMap } from './xpath.mjs';
 export {
     XmlNode,
     XmlAttribute,
     XmlComment,
     XmlElement,
     XmlText,
     XmlCData,
-    NamespaceMap,
 } from './nodes.mjs';
 export { default as XmlDocument } from './document.mjs';
 export { XmlParseError, XmlError } from './libxml2.mjs';

src/nodes.mts

@@ -1,31 +1,24 @@
 import {
     XmlError,
-    xmlHasNsProp,
     xmlGetNsList,
+    xmlHasNsProp,
     XmlNamedNodeStruct,
     xmlNodeGetContent,
     XmlNodeSetStruct,
     XmlNodeStruct,
     XmlNsStruct,
     xmlSearchNs,
+    xmlXPathCompiledEval,
     xmlXPathFreeContext,
     xmlXPathFreeObject,
     xmlXPathNewContext,
     XmlXPathObjectStruct,
     xmlXPathRegisterNs,
-    xmlXPathCompiledEval,
     xmlXPathSetContextNode,
 } from './libxml2.mjs';
 import type XmlDocument from './document.mjs';
 import type { XmlNodePtr } from './libxml2raw.js';
-import XmlXPath from './xpath.mjs';
-
-/**
- * Map between the prefix and the uri of the namespace
- */
-export interface NamespaceMap {
-    [prefix: string]: string;
-}
+import { XmlXPath, NamespaceMap } from './xpath.mjs';
 
 export abstract class XmlNode {
     protected _doc: XmlDocument;
@@ -156,6 +149,9 @@ export abstract class XmlNode {
         return ns ? XmlNsStruct.href(ns) : null;
     }
 
+    get(xpath: XmlXPath): XmlNode | null;
+    get(xpath: string, namespaces?: NamespaceMap): XmlNode | null;
+    get(xpath: string | XmlXPath, namespaces?: NamespaceMap): XmlNode | null;
     /**
      * Find the first descendant node matching the given xpath selector
      *
@@ -186,18 +182,18 @@ export abstract class XmlNode {
     }
 
     private xpathEval(xpath: string | XmlXPath, namespaces?: NamespaceMap) {
-        const xpathCompiled = xpath instanceof XmlXPath ? xpath : new XmlXPath(xpath);
-        const ret = this.compiledXPathEval(xpathCompiled, namespaces);
+        const xpathCompiled = xpath instanceof XmlXPath ? xpath : new XmlXPath(xpath, namespaces);
+        const ret = this.compiledXPathEval(xpathCompiled);
         if (!(xpath instanceof XmlXPath)) {
             xpathCompiled.dispose();
         }
         return ret;
     }
 
-    private compiledXPathEval(xpath: XmlXPath, namespaces?: NamespaceMap) {
+    private compiledXPathEval(xpath: XmlXPath) {
         const context = xmlXPathNewContext(this._doc._docPtr);
-        if (namespaces) {
-            Object.entries(namespaces)
+        if (xpath._namespaces) {
+            Object.entries(xpath._namespaces)
                 .forEach(([prefix, uri]) => {
                     xmlXPathRegisterNs(context, prefix, uri);
                 });
@@ -208,6 +204,9 @@ export abstract class XmlNode {
         return xpathObj;
     }
 
+    find(xpath: XmlXPath): XmlNode[];
+    find(xpath: string, namespaces?: NamespaceMap): XmlNode[];
+    find(xpath: string | XmlXPath, namespaces?: NamespaceMap): XmlNode[];
     /**
      * Find all the descendant nodes matching the given xpath selector.
      * @param xpath XPath selector

src/xpath.mts

@@ -4,11 +4,21 @@ import {
 } from './libxml2.mjs';
 import type { XmlXPathCompExprPtr } from './libxml2raw.js';
 
-export default class XmlXPath {
+/**
+ * Map between the prefix and the uri of the namespace
+ */
+export interface NamespaceMap {
+    [prefix: string]: string;
+}
+
+export class XmlXPath {
     _xpath: XmlXPathCompExprPtr;
 
-    constructor(xpath: string) {
+    _namespaces: NamespaceMap | undefined;
+
+    constructor(xpath: string, namespaces?: NamespaceMap) {
         this._xpath = xmlXPathCtxtCompile(0, xpath);
+        this._namespaces = namespaces;
     }
 
     dispose() {

test/xpath.spec.mts

@@ -1,6 +1,6 @@
 import { expect } from 'chai';
 import { parseXmlString } from '../lib/index.mjs';
-import XmlXPath from '../lib/xpath.mjs';
+import { XmlXPath } from '../lib/xpath.mjs';
 
 describe('XPath', () => {
     const doc1 = parseXmlString('<book><title>Harry Potter</title></book>');
@@ -24,4 +24,13 @@ describe('XPath', () => {
         const xpath = new XmlXPath(null!);
         xpath.dispose();
     });
+
+    it('handles namespace', () => {
+        const doc = parseXmlString(
+            '<book xmlns:t="http://foo"><t:title>Harry Potter</t:title></book>',
+        );
+        const xpath = new XmlXPath('/book/m:title', { m: 'http://foo' });
+        expect(doc.get(xpath)?.content).to.equal('Harry Potter');
+        expect(doc.find(xpath).map((node) => node.content)).to.deep.equal(['Harry Potter']);
+    });
 });