Template precedence (#56)

* New methods to work with transformed node elements.
* Remaining adjustments to resolve problems with template precedence.
* Testing XML to JSON.
* - Disregarding empty text for XML output;
- Debugging `<xsl:element>` case.
* Not printing an element if a transformed name was not assigned.
* Logic for `xsl:for-each`.
* Transformed prefix.
* Avoiding node to be printed twice.
* Adjusting `xsl:attribute`.
* Final fixes for `value-of`.

Author: leonelsanchesdasilva

.vscode/launch.json

@@ -11,7 +11,7 @@
             "runtimeArgs": [
                 "--inspect-brk",
                 "${workspaceRoot}/node_modules/jest/bin/jest.js",
-                // "root-element.test",
+                // "xslt.test",
                 "--runInBand"
             ],
             "skipFiles": ["<node_internals>/**", "node_modules/**"],

src/dom/functions.ts

@@ -36,16 +36,28 @@ export function domGetAttributeValue(node: any, name: any) {
     return node.getAttributeValue(name);
 }
 
-export function domSetAttribute(node: any, name: any, value: any) {
+export function domSetAttribute(node: XNode, name: any, value: any) {
     return node.setAttribute(name, value);
 }
 
+export function domSetTransformedAttribute(node: XNode, name: any, value: any) {
+    return node.setTransformedAttribute(name, value);
+}
+
 export function domAppendChild(node: XNode, child: any) {
     return node.appendChild(child);
 }
 
-export function domCreateTextNode(doc: any, text: any) {
-    return doc.createTextNode(text);
+export function domAppendTransformedChild(node: XNode, child: any) {
+    return node.appendTransformedChild(child);
+}
+
+export function domCreateTextNode(node: XDocument, text: string) {
+    return node.createTextNode(text);
+}
+
+export function domCreateTransformedTextNode(node: XDocument, text: string) {
+    return node.createTransformedTextNode(text);
 }
 
 export function domCreateElement(doc: any, name: any) {

src/dom/xdocument.ts

@@ -45,6 +45,12 @@ export class XDocument extends XNode {
         return XNode.create(DOM_TEXT_NODE, '#text', value, this);
     }
 
+    createTransformedTextNode(value: any) {
+        const node = XNode.create(DOM_TEXT_NODE, '#text', value, this);
+        node.transformedNodeValue = value;
+        return node;
+    }
+
     createAttribute(name: any) {
         return XNode.create(DOM_ATTRIBUTE_NODE, name, null, this);
     }

src/dom/xml-functions.ts

@@ -11,6 +11,7 @@ import {
 } from '../constants';
 import { domGetAttributeValue } from './functions';
 import { XNode } from './xnode';
+import { XDocument } from './xdocument';
 
 // Returns the text value of a node; for nodes without children this
 // is the nodeValue, for nodes with children this is the concatenation
@@ -21,6 +22,48 @@ export function xmlValue(node: any, disallowBrowserSpecificOptimization: boolean
         return '';
     }
 
+    let ret = '';
+    if (node.nodeType == DOM_TEXT_NODE || node.nodeType == DOM_CDATA_SECTION_NODE) {
+        ret += node.nodeValue;
+    } else if (node.nodeType == DOM_ATTRIBUTE_NODE) {
+        ret += node.nodeValue;
+    } else if (
+        node.nodeType == DOM_ELEMENT_NODE ||
+        node.nodeType == DOM_DOCUMENT_NODE ||
+        node.nodeType == DOM_DOCUMENT_FRAGMENT_NODE
+    ) {
+        if (!disallowBrowserSpecificOptimization) {
+            // IE, Safari, Opera, and friends
+            const innerText = node.innerText;
+            if (innerText != undefined) {
+                return innerText;
+            }
+            // Firefox
+            const textContent = node.textContent;
+            if (textContent != undefined) {
+                return textContent;
+            }
+        }
+
+        if (node.transformedChildNodes.length > 0) {
+            for (let i = 0; i < node.transformedChildNodes.length; ++i) {
+                ret += xmlValue(node.transformedChildNodes[i]);
+            }
+        } else {
+            for (let i = 0; i < node.childNodes.length; ++i) {
+                ret += xmlValue(node.childNodes[i]);
+            }
+        }
+    }
+    return ret;
+}
+
+// TODO: Give a better name to this.
+export function xmlValue2(node: any, disallowBrowserSpecificOptimization: boolean = false) {
+    if (!node) {
+        return '';
+    }
+
     let ret = '';
     if (node.nodeType == DOM_TEXT_NODE || node.nodeType == DOM_CDATA_SECTION_NODE) {
         ret += node.nodeValue;
@@ -44,22 +87,27 @@ export function xmlValue(node: any, disallowBrowserSpecificOptimization: boolean
             }
         }
         // pobrecito!
-        const len = node.childNodes.length;
+        const len = node.transformedChildNodes.length;
         for (let i = 0; i < len; ++i) {
-            ret += xmlValue(node.childNodes[i]);
+            ret += xmlValue(node.transformedChildNodes[i]);
         }
     }
     return ret;
 }
 
-// Returns the representation of a node as XML text.
-export function xmlText(node: any, opt_cdata: boolean = false) {
+/**
+ * Returns the representation of a node as XML text.
+ * @param node The starting node.
+ * @param opt_cdata If using CDATA configuration.
+ * @returns The XML string.
+ */
+export function xmlText(node: XNode, opt_cdata: boolean = false) {
     const buf = [];
     xmlTextRecursive(node, buf, opt_cdata);
     return buf.join('');
 }
 
-function xmlTextRecursive(node: any, buf: any[], cdata: any) {
+function xmlTextRecursive(node: XNode, buf: any[], cdata: any) {
     if (node.nodeType == DOM_TEXT_NODE) {
         buf.push(xmlEscapeText(node.nodeValue));
     } else if (node.nodeType == DOM_CDATA_SECTION_NODE) {
@@ -95,12 +143,111 @@ function xmlTextRecursive(node: any, buf: any[], cdata: any) {
     }
 }
 
-function xmlFullNodeName(n: any) {
-    if (n.prefix && n.nodeName.indexOf(`${n.prefix}:`) != 0) {
-        return `${n.prefix}:${n.nodeName}`;
+/**
+ * Returns the representation of a node as XML text.
+ * @param node The starting node.
+ * @param opt_cdata If using CDATA configuration.
+ * @returns The XML string.
+ */
+export function xmlTransformedText(node: XNode, opt_cdata: boolean = false) {
+    const buffer = [];
+    xmlTransformedTextRecursive(node, buffer, opt_cdata);
+    return buffer.join('');
+}
+
+function xmlTransformedTextRecursive(node: XNode, buffer: any[], cdata: boolean) {
+    if (node.printed) return;
+    const nodeType = node.transformedNodeType || node.nodeType;
+    const nodeValue = node.transformedNodeValue || node.nodeValue;
+    if (nodeType == DOM_TEXT_NODE) {
+        if (node.transformedNodeValue && node.transformedNodeValue.trim() !== '') {
+            buffer.push(xmlEscapeText(node.transformedNodeValue));
+        }
+    } else if (nodeType == DOM_CDATA_SECTION_NODE) {
+        if (cdata) {
+            buffer.push(nodeValue);
+        } else {
+            buffer.push(`<![CDATA[${nodeValue}]]>`);
+        }
+    } else if (nodeType == DOM_COMMENT_NODE) {
+        buffer.push(`<!--${nodeValue}-->`);
+    } else if (nodeType == DOM_ELEMENT_NODE) {
+        // If node didn't have a transformed name, but its children
+        // had transformations, children should be present at output.
+        // This is called here "muted logic".
+        if (node.transformedNodeName !== null && node.transformedNodeName !== undefined) {
+            xmlElementLogicTrivial(node, buffer, cdata);
+        } else {
+            xmlElementLogicMuted(node, buffer, cdata);
+        }
+    } else if (nodeType == DOM_DOCUMENT_NODE || nodeType == DOM_DOCUMENT_FRAGMENT_NODE) {
+        const childNodes = node.transformedChildNodes.concat(node.childNodes);
+        // const childNodes = node.transformedChildNodes.length > 0 ? node.transformedChildNodes : node.childNodes;
+        for (let i = 0; i < childNodes.length; ++i) {
+            xmlTransformedTextRecursive(childNodes[i], buffer, cdata);
+        }
+    }
+
+    node.printed = true;
+}
+
+/**
+ * XML element output, trivial logic.
+ * @param node The XML node.
+ * @param buffer The XML buffer.
+ * @param cdata If using CDATA configuration.
+ */
+function xmlElementLogicTrivial(node: XNode, buffer: any[], cdata: boolean) {
+    buffer.push(`<${xmlFullNodeName(node)}`);
+
+    const attributes = node.transformedAttributes || node.attributes;
+    for (let i = 0; i < attributes.length; ++i) {
+        const attribute = attributes[i];
+        if (!attribute) {
+            continue;
+        }
+
+        const attributeNodeName = attribute.transformedNodeName || attribute.nodeName;
+        const attributeNodeValue = attribute.transformedNodeValue || attribute.nodeValue;
+        if (attributeNodeName && attributeNodeValue) {
+            buffer.push(` ${xmlFullNodeName(attribute)}="${xmlEscapeAttr(attributeNodeValue)}"`);
+        }
+    }
+
+    const childNodes = node.transformedChildNodes.length > 0 ? node.transformedChildNodes : node.childNodes;
+    if (childNodes.length == 0) {
+        buffer.push('/>');
+    } else {
+        buffer.push('>');
+        for (let i = 0; i < childNodes.length; ++i) {
+            xmlTransformedTextRecursive(childNodes[i], buffer, cdata);
+        }
+        buffer.push(`</${xmlFullNodeName(node)}>`);
+    }
+}
+
+/**
+ * XML element output, muted logic.
+ * In other words, this element should not be printed, but its
+ * children can be printed if they have transformed values.
+ * @param node The XML node.
+ * @param buffer The XML buffer.
+ * @param cdata If using CDATA configuration.
+ */
+function xmlElementLogicMuted(node: XNode, buffer: any[], cdata: boolean) {
+    const childNodes = node.transformedChildNodes.length > 0 ? node.transformedChildNodes : node.childNodes;
+    for (let i = 0; i < childNodes.length; ++i) {
+        xmlTransformedTextRecursive(childNodes[i], buffer, cdata);
     }
+}
 
-    return n.nodeName;
+function xmlFullNodeName(node: XNode) {
+    const nodeName = node.transformedNodeName || node.nodeName;
+    if (node.transformedPrefix && nodeName.indexOf(`${node.transformedPrefix}:`) != 0) {
+        return `${node.transformedPrefix}:${nodeName}`;
+    }
+
+    return nodeName;
 }
 
 /**
@@ -157,13 +304,17 @@ export function xmlGetAttribute(node: XNode, name: string) {
  * and other nodes: for the document node, the owner document is the
  * node itself, for all others it's the ownerDocument property.
  *
- * @param {Node} node
- * @return {Document}
+ * @param {XNode} node
+ * @return {XDocument}
  */
-export function xmlOwnerDocument(node: any) {
-    if (node.nodeType == DOM_DOCUMENT_NODE) {
-        return node;
+export function xmlOwnerDocument(node: XNode): XDocument {
+    if (node === null || node === undefined) {
+        throw new Error('Node has no valid owner document.');
+    }
+
+    if (node.nodeType === DOM_DOCUMENT_NODE) {
+        return node as XDocument;
     }
 
-    return node.ownerDocument;
+    return xmlOwnerDocument(node.ownerDocument);
 }

src/dom/xnode.ts

@@ -14,24 +14,42 @@ export class XNode {
     nodeType: any;
     nodeName: string;
     nodeValue: any;
-    transformedNodeType: any;
-    transformedNodeName: string;
-    transformedNodeValue: any;
+    firstChild: XNode;
+    lastChild: XNode;
+    nextSibling: XNode;
+    previousSibling: XNode;
+
     ownerDocument: any;
     namespaceURI: any;
     prefix: any;
-    localName: any;
-    firstChild: any;
-    lastChild: any;
-    nextSibling: any;
-    previousSibling: any;
-    parentNode: any;
+    localName: string;
+
+    parentNode: XNode;
+
+    transformedAttributes: XNode[];
+    transformedChildNodes: XNode[];
+    transformedNodeType: any;
+    transformedNodeName: string;
+    transformedNodeValue: any;
+    transformedFirstChild: XNode;
+    transformedLastChild: XNode;
+    transformedNextSibling: XNode;
+    transformedPreviousSibling: XNode;
+    transformedPrefix: any;
+    transformedLocalName: string;
+
+    transformedParentNode: XNode;
+
+    printed: boolean;
 
     static _unusedXNodes: any[] = [];
 
     constructor(type: any, name: any, opt_value: any, opt_owner: any, opt_namespace?: any) {
         this.attributes = [];
         this.childNodes = [];
+        this.transformedAttributes = [];
+        this.transformedChildNodes = [];
+        this.printed = false;
 
         this.init(type, name, opt_value, opt_owner, opt_namespace);
     }
@@ -118,7 +136,7 @@ export class XNode {
         return newNode;
     }
 
-    appendChild(node: any) {
+    appendChild(node: XNode) {
         // firstChild
         if (this.childNodes.length == 0) {
             this.firstChild = node;
@@ -143,6 +161,31 @@ export class XNode {
         this.childNodes.push(node);
     }
 
+    appendTransformedChild(node: XNode) {
+        // firstChild
+        if (this.transformedChildNodes.length == 0) {
+            this.transformedFirstChild = node;
+        }
+
+        // previousSibling
+        node.transformedPreviousSibling = this.lastChild;
+
+        // nextSibling
+        node.transformedNextSibling = null;
+        if (this.transformedLastChild) {
+            this.transformedLastChild.transformedNextSibling = node;
+        }
+
+        // parentNode
+        node.transformedParentNode = this;
+
+        // lastChild
+        this.transformedLastChild = node;
+
+        // childNodes
+        this.transformedChildNodes.push(node);
+    }
+
     replaceChild(newNode: any, oldNode: any) {
         if (oldNode == newNode) {
             return;
@@ -262,6 +305,17 @@ export class XNode {
         this.attributes.push(XNode.create(DOM_ATTRIBUTE_NODE, name, value, this));
     }
 
+    setTransformedAttribute(name: any, value: any) {
+        for (let i = 0; i < this.transformedAttributes.length; ++i) {
+            if (this.transformedAttributes[i].nodeName == name) {
+                this.transformedAttributes[i].nodeValue = `${value}`;
+                return;
+            }
+        }
+
+        this.transformedAttributes.push(XNode.create(DOM_ATTRIBUTE_NODE, name, value, this));
+    }
+
     setAttributeNS(namespace: any, name: any, value: any) {
         for (let i = 0; i < this.attributes.length; ++i) {
             if (