Working with HTML tags that don't need to be closed.

leonelsanchesdasilva · leonelsanchesdasilva · commit d310e56488ed · 2023-09-16T09:36:38.000-07:00
diff --git a/src/dom/xml-functions.ts b/src/dom/xml-functions.ts
@@ -6,6 +6,7 @@ import {
     DOM_COMMENT_NODE,
     DOM_DOCUMENT_FRAGMENT_NODE,
     DOM_DOCUMENT_NODE,
+    DOM_DOCUMENT_TYPE_NODE,
     DOM_ELEMENT_NODE,
     DOM_TEXT_NODE
 } from '../constants';
@@ -14,49 +15,57 @@ import { XNode } from './xnode';
 import { XDocument } from './xdocument';
 import { XmlOutputOptions } from './xml-output-options';
 
-// Returns the text value of a node; for nodes without children this
-// is the nodeValue, for nodes with children this is the concatenation
-// of the value of all children. Browser-specific optimizations are used by
-// default; they can be disabled by passing "true" in as the second parameter.
-export function xmlValue(node: any, disallowBrowserSpecificOptimization: boolean = false) {
+
+/**
+ * Returns the text value of a node; for nodes without children this
+ * is the nodeValue, for nodes with children this is the concatenation
+ * of the value of all children. Browser-specific optimizations are used by
+ * default; they can be disabled by passing "true" in as the second parameter.
+ * @param node The Node (not exactly a `XNode` here).
+ * @param disallowBrowserSpecificOptimization A boolean, to avoid browser optimization.
+ * @returns The XML value as a string.
+ */
+export function xmlValue(node: any, disallowBrowserSpecificOptimization: boolean = false): string {
     if (!node) {
         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;
+    switch (node.nodeType) {
+        case DOM_DOCUMENT_TYPE_NODE:
+            return `<!DOCTYPE ${node.nodeValue}>`
+        case DOM_TEXT_NODE:
+        case DOM_CDATA_SECTION_NODE:
+        case DOM_ATTRIBUTE_NODE:
+            return node.nodeValue;
+        case DOM_ELEMENT_NODE:
+        case DOM_DOCUMENT_NODE:
+        case 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]);
+            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;
     }
-    return ret;
 }
 
 // TODO: Give a better name to this.
@@ -98,14 +107,17 @@ export function xmlValue2(node: any, disallowBrowserSpecificOptimization: boolea
 
 /**
  * Returns the representation of a node as XML text.
+ * In general it is not used by XSLT, that uses `xmlTransformedText` instead.
  * @param {XNode} node The starting node.
  * @param {XmlOutputOptions} options XML output options.
  * @returns The XML string.
+ * @see xmlTransformedText
  */
 export function xmlText(node: XNode, options: XmlOutputOptions = {
     cData: false,
     escape: true,
-    selfClosingTags: true
+    selfClosingTags: true,
+    outputMethod: 'xml'
 }) {
     const buffer: string[] = [];
     xmlTextRecursive(node, buffer, options);
@@ -133,7 +145,7 @@ function xmlTextRecursive(node: XNode, buffer: string[], options: XmlOutputOptio
         }
 
         if (node.childNodes.length === 0) {
-            if (options.selfClosingTags) {
+            if (options.selfClosingTags || (options.outputMethod === 'html' && ['hr', 'link'].includes(node.nodeName))) {
                 buffer.push('/>');
             } else {
                 buffer.push(`></${xmlFullNodeName(node)}>`);
@@ -163,7 +175,8 @@ export function xmlTransformedText(
     options: XmlOutputOptions = {
         cData: false,
         escape: true,
-        selfClosingTags: true
+        selfClosingTags: true,
+        outputMethod: 'xml'
     }
 ) {
     const buffer: string[] = [];
@@ -175,14 +188,14 @@ function xmlTransformedTextRecursive(node: XNode, buffer: any[], options: XmlOut
     if (node.visited) return;
     const nodeType = node.transformedNodeType || node.nodeType;
     const nodeValue = node.transformedNodeValue || node.nodeValue;
-    if (nodeType == DOM_TEXT_NODE) {
+    if (nodeType === DOM_TEXT_NODE) {
         if (node.transformedNodeValue && node.transformedNodeValue.trim() !== '') {
             const finalText = node.escape && options.escape?
                 xmlEscapeText(node.transformedNodeValue) :
                 node.transformedNodeValue;
             buffer.push(finalText);
         }
-    } else if (nodeType == DOM_CDATA_SECTION_NODE) {
+    } else if (nodeType === DOM_CDATA_SECTION_NODE) {
         if (options.cData) {
             buffer.push(nodeValue);
         } else {
@@ -199,7 +212,7 @@ function xmlTransformedTextRecursive(node: XNode, buffer: any[], options: XmlOut
         } else {
             xmlElementLogicMuted(node, buffer, options);
         }
-    } else if (nodeType == DOM_DOCUMENT_NODE || nodeType == DOM_DOCUMENT_FRAGMENT_NODE) {
+    } else if (nodeType === DOM_DOCUMENT_NODE || nodeType === DOM_DOCUMENT_FRAGMENT_NODE) {
         const childNodes = node.transformedChildNodes.concat(node.childNodes);
         childNodes.sort((a, b) => a.siblingPosition - b.siblingPosition);
 
@@ -235,7 +248,7 @@ function xmlElementLogicTrivial(node: XNode, buffer: string[], options: XmlOutpu
     let childNodes = node.transformedChildNodes.length > 0 ? node.transformedChildNodes : node.childNodes;
     childNodes = childNodes.sort((a, b) => a.siblingPosition - b.siblingPosition);
     if (childNodes.length === 0) {
-        if (options.selfClosingTags) {
+        if (options.selfClosingTags || (options.outputMethod === 'html' && ['hr', 'link'].includes(node.nodeName))) {
             buffer.push('/>');
         } else {
             buffer.push(`></${xmlFullNodeName(node)}>`);
diff --git a/src/dom/xml-output-options.ts b/src/dom/xml-output-options.ts
@@ -2,4 +2,5 @@ export type XmlOutputOptions = {
     cData: boolean;
     escape: boolean;
     selfClosingTags: boolean;
+    outputMethod: 'xml' | 'html'
 }
diff --git a/src/dom/xml-parser.ts b/src/dom/xml-parser.ts
@@ -36,7 +36,7 @@ export class XmlParser {
     XML11_TAGNAME_REGEXP = new RegExp(`^(${XML11_NAME})`);
     XML11_ATTRIBUTE_REGEXP = new RegExp(XML11_ATTRIBUTE, 'g');
 
-    lenientHtmlTags = ['link'];
+    lenientHtmlTags = ['hr', 'link'];
 
     /**
      * The entry point for this parser.
@@ -46,7 +46,7 @@ export class XmlParser {
      * @returns A DOM document.
      */
     xmlParse(xmlOrHtml: string): XDocument {
-        if (xmlOrHtml.toUpperCase().includes('<!DOCTYPE HTML')) {
+        if (xmlOrHtml.toUpperCase().startsWith('<!DOCTYPE HTML')) {
             return this.htmlParse(xmlOrHtml);
         }
 
@@ -61,7 +61,7 @@ export class XmlParser {
      */
     private namespaceMapAt(node: XNode): { [prefix: string]: string } {
         const map = {
-            // reserved namespaces https://www.w3.org/TR/REC-xml-names/#xmlReserved
+            // reserved namespaces: https://www.w3.org/TR/REC-xml-names/#xmlReserved
             xmlns: 'http://www.w3.org/2000/xmlns/',
             xml: 'http://www.w3.org/XML/1998/namespace'
         };
@@ -138,23 +138,6 @@ export class XmlParser {
                             parent = node;
                             stack.push(node);
                         }
-
-                        const namespaceMap = this.namespaceMapAt(node);
-                        if (node.prefix !== null) {
-                            if (node.prefix in namespaceMap) node.namespaceUri = namespaceMap[node.prefix];
-                            // else, prefix is undefined. do anything?
-                        } else {
-                            if ('' in namespaceMap) node.namespaceUri = namespaceMap[''];
-                        }
-                        for (let i = 0; i < node.attributes.length; ++i) {
-                            if (node.attributes[i].prefix !== null) {
-                                if (node.attributes[i].prefix in namespaceMap) {
-                                    node.attributes[i].namespaceUri = namespaceMap[node.attributes[i].prefix];
-                                }
-                                // else, prefix undefined.
-                            }
-                            // elements with no prefix always have no namespace, so do nothing here.
-                        }
                     }
 
                     start = i + 1;
@@ -223,8 +206,8 @@ export class XmlParser {
             regexAttribute = this.XML10_ATTRIBUTE_REGEXP;
         }
 
-        const xmlDoc = new XDocument();
-        const root = xmlDoc;
+        const xmlDocument = new XDocument();
+        const root = xmlDocument;
         const stack = [];
 
         let parent: XNode = root;
@@ -253,7 +236,7 @@ export class XmlParser {
                 } else {
                     const empty = text.match(this.regexEmpty);
                     const tagname = regexTagname.exec(text)[1];
-                    let node = domCreateElement(xmlDoc, tagname);
+                    let node = domCreateElement(xmlDocument, tagname);
 
                     let attribute;
                     while ((attribute = regexAttribute.exec(text))) {
@@ -292,22 +275,32 @@ export class XmlParser {
             } else if (!tag && char === '<') {
                 let text = xml.slice(start, i);
                 if (text && parent !== root) {
-                    domAppendChild(parent, domCreateTextNode(xmlDoc, text));
+                    domAppendChild(parent, domCreateTextNode(xmlDocument, text));
                 }
                 if (xml.slice(i + 1, i + 4) === '!--') {
                     let endTagIndex = xml.slice(i + 4).indexOf('-->');
                     if (endTagIndex) {
-                        let node = domCreateComment(xmlDoc, xml.slice(i + 4, i + endTagIndex + 4));
+                        let node = domCreateComment(xmlDocument, xml.slice(i + 4, i + endTagIndex + 4));
                         domAppendChild(parent, node);
                         i += endTagIndex + 6;
                     }
                 } else if (xml.slice(i + 1, i + 9) === '![CDATA[') {
                     let endTagIndex = xml.slice(i + 9).indexOf(']]>');
                     if (endTagIndex) {
-                        let node = domCreateCDATASection(xmlDoc, xml.slice(i + 9, i + endTagIndex + 9));
+                        let node = domCreateCDATASection(xmlDocument, xml.slice(i + 9, i + endTagIndex + 9));
                         domAppendChild(parent, node);
                         i += endTagIndex + 11;
                     }
+                } else if (xml.slice(i + 1, i + 9) === '!DOCTYPE') { // "!DOCTYPE" can be used in a XSLT template.
+                    let endTagIndex = xml.slice(i + 9).indexOf('>');
+                    if (endTagIndex) {
+                        const dtdValue = xml.slice(i + 9, i + endTagIndex + 9).trimStart();
+                        // TODO: Not sure if this is a good solution.
+                        // Trying to implement this: https://github.com/DesignLiquido/xslt-processor/issues/30
+                        const node = domCreateDTDSection(xmlDocument, dtdValue);
+                        domAppendChild(parent, node);
+                        i += endTagIndex + dtdValue.length + 5;
+                    }
                 } else {
                     tag = true;
                 }
diff --git a/src/xslt/xslt.ts b/src/xslt/xslt.ts
@@ -74,7 +74,7 @@ export class Xslt {
     decimalFormatSettings: XsltDecimalFormatSettings;
 
     outputDocument: XDocument;
-    outputMethod: string;
+    outputMethod: 'xml' | 'html';
     outputOmitXmlDeclaration: string;
     version: string;
 
@@ -129,8 +129,10 @@ export class Xslt {
         const transformedOutputXml = xmlTransformedText(outputDocument, {
             cData: false,
             escape: this.options.escape,
-            selfClosingTags: this.options.selfClosingTags
+            selfClosingTags: this.options.selfClosingTags,
+            outputMethod: this.outputMethod
         });
+
         return transformedOutputXml;
     }
 
diff --git a/tests/xml/html.test.tsx b/tests/xml/html.test.tsx

Original file line number	Diff line number	Diff line change
`@@ -2,4 +2,5 @@ export type XmlOutputOptions = {`
`2`	`2`	`cData: boolean;`
`3`	`3`	`escape: boolean;`
`4`	`4`	`selfClosingTags: boolean;`
	`5`	`+ outputMethod: 'xml' \| 'html'`
`5`	`6`	`}`