Self closing tag (#63)

* Implementing self-closing tag option.
* Updating README.md.

Author: leonelsanchesdasilva

README.md

@@ -66,12 +66,14 @@ You can pass an `options` object to `Xslt` class:
 ```js
 const options = {
   escape: false,
+  selfClosingTags: true,
   properties: [{ name: 'myparam', value: '123' }]
 };
 const xslt = new Xslt(options);
 ```
 
 - `escape` (`boolean`, default `true`): replaces symbols like `<`, `>`, `&` and `"` by the corresponding [XML entities](https://www.tutorialspoint.com/xml/xml_character_entities.htm).
+- `selfClosingTags` (`boolean`, default `true`): Self-closes tags that don't have inner elements, if `true`. For instance, `<test></test>` becomes `<test />`.
 - `parameters` (`array`, default `[]`): external parameters that you want to use.
     - `name`: the parameter name;
     - `namespaceUri` (optional): the namespace;
@@ -82,7 +84,7 @@ const xslt = new Xslt(options);
 You can simply add a tag like this:
 
 ```html
-<script type="application/javascript" src="https://www.unpkg.com/xslt-processor@1.1.4/umd/xslt-processor.js"></script>
+<script type="application/javascript" src="https://www.unpkg.com/xslt-processor@1.1.6/umd/xslt-processor.js"></script>
 ```
 
 All the exports will live under `globalThis.XsltProcessor`. [See a usage example here](https://github.com/DesignLiquido/xslt-processor/blob/main/interactive-tests/xslt.html). 

src/dom/xml-functions.ts

@@ -98,48 +98,56 @@ export function xmlValue2(node: any, disallowBrowserSpecificOptimization: boolea
 
 /**
  * Returns the representation of a node as XML text.
- * @param node The starting node.
- * @param opt_cdata If using CDATA configuration.
+ * @param {XNode} node The starting node.
+ * @param {XmlOutputOptions} options XML output options.
  * @returns The XML string.
  */
-export function xmlText(node: XNode, opt_cdata: boolean = false) {
-    const buf = [];
-    xmlTextRecursive(node, buf, opt_cdata);
-    return buf.join('');
+export function xmlText(node: XNode, options: XmlOutputOptions = {
+    cData: false,
+    escape: true,
+    selfClosingTags: true
+}) {
+    const buffer: string[] = [];
+    xmlTextRecursive(node, buffer, options);
+    return buffer.join('');
 }
 
-function xmlTextRecursive(node: XNode, buf: any[], cdata: any) {
+function xmlTextRecursive(node: XNode, buffer: string[], options: XmlOutputOptions) {
     if (node.nodeType == DOM_TEXT_NODE) {
-        buf.push(xmlEscapeText(node.nodeValue));
+        buffer.push(xmlEscapeText(node.nodeValue));
     } else if (node.nodeType == DOM_CDATA_SECTION_NODE) {
-        if (cdata) {
-            buf.push(node.nodeValue);
+        if (options.cData) {
+            buffer.push(node.nodeValue);
         } else {
-            buf.push(`<![CDATA[${node.nodeValue}]]>`);
+            buffer.push(`<![CDATA[${node.nodeValue}]]>`);
         }
     } else if (node.nodeType == DOM_COMMENT_NODE) {
-        buf.push(`<!--${node.nodeValue}-->`);
+        buffer.push(`<!--${node.nodeValue}-->`);
     } else if (node.nodeType == DOM_ELEMENT_NODE) {
-        buf.push(`<${xmlFullNodeName(node)}`);
+        buffer.push(`<${xmlFullNodeName(node)}`);
         for (let i = 0; i < node.attributes.length; ++i) {
             const a = node.attributes[i];
             if (a && a.nodeName && a.nodeValue) {
-                buf.push(` ${xmlFullNodeName(a)}="${xmlEscapeAttr(a.nodeValue)}"`);
+                buffer.push(` ${xmlFullNodeName(a)}="${xmlEscapeAttr(a.nodeValue)}"`);
             }
         }
 
-        if (node.childNodes.length == 0) {
-            buf.push('/>');
+        if (node.childNodes.length === 0) {
+            if (options.selfClosingTags) {
+                buffer.push('/>');
+            } else {
+                buffer.push(`></${xmlFullNodeName(node)}>`);
+            }
         } else {
-            buf.push('>');
+            buffer.push('>');
             for (let i = 0; i < node.childNodes.length; ++i) {
-                xmlTextRecursive(node.childNodes[i], buf, cdata);
+                xmlTextRecursive(node.childNodes[i], buffer, options);
             }
-            buf.push(`</${xmlFullNodeName(node)}>`);
+            buffer.push(`</${xmlFullNodeName(node)}>`);
         }
     } else if (node.nodeType == DOM_DOCUMENT_NODE || node.nodeType == DOM_DOCUMENT_FRAGMENT_NODE) {
         for (let i = 0; i < node.childNodes.length; ++i) {
-            xmlTextRecursive(node.childNodes[i], buf, cdata);
+            xmlTextRecursive(node.childNodes[i], buffer, options);
         }
     }
 }
@@ -154,10 +162,11 @@ export function xmlTransformedText(
     node: XNode,
     options: XmlOutputOptions = {
         cData: false,
-        escape: true
+        escape: true,
+        selfClosingTags: true
     }
 ) {
-    const buffer = [];
+    const buffer: string[] = [];
     xmlTransformedTextRecursive(node, buffer, options);
     return buffer.join('');
 }
@@ -224,7 +233,11 @@ function xmlElementLogicTrivial(node: XNode, buffer: string[], options: XmlOutpu
 
     const childNodes = node.transformedChildNodes.length > 0 ? node.transformedChildNodes : node.childNodes;
     if (childNodes.length === 0) {
-        buffer.push('/>');
+        if (options.selfClosingTags) {
+            buffer.push('/>');
+        } else {
+            buffer.push(`></${xmlFullNodeName(node)}>`);
+        }
     } else {
         buffer.push('>');
         for (let i = 0; i < childNodes.length; ++i) {

src/dom/xml-output-options.ts

@@ -1,4 +1,5 @@
 export type XmlOutputOptions = {
     cData: boolean;
     escape: boolean;
+    selfClosingTags: boolean;
 }

src/xslt/xslt-options.ts

@@ -2,5 +2,6 @@ import { XsltParameter } from "./xslt-parameter"
 
 export type XsltOptions = {
     escape: boolean,
+    selfClosingTags: boolean,
     parameters?: XsltParameter[]
 }

src/xslt/xslt.ts

@@ -75,7 +75,7 @@ export class Xslt {
     outputMethod: string;
     outputOmitXmlDeclaration: string;
 
-    constructor(options: XsltOptions = { escape: true }) {
+    constructor(options: XsltOptions = { escape: true, selfClosingTags: true }) {
         this.xPath = new XPath();
         this.options = options;
         this.outputMethod = 'xml';
@@ -103,7 +103,8 @@ export class Xslt {
         this.xsltProcessContext(expressionContext, stylesheet, output, parameters || []);
         const ret = xmlTransformedText(output, {
             cData: false,
-            escape: this.options.escape
+            escape: this.options.escape,
+            selfClosingTags: this.options.selfClosingTags
         });
         return ret;
     }

tests/xml/xml.test.tsx

@@ -0,0 +1,26 @@
+import assert from 'assert';
+
+import { dom } from 'isomorphic-jsx';
+import React from 'react';
+
+import { xmlParse, xmlText } from '../../src/dom';
+
+// Just touching the `dom`, otherwise Babel prunes the import.
+console.log(dom);
+describe('General XML', () => {
+    it('Self-closing tags disabled', () => {
+        const xmlString = (
+            <root>
+                <typeA />
+                <typeB />
+            </root>
+        );
+
+        const outXmlString = xmlText(xmlParse(xmlString), {
+            cData: false,
+            selfClosingTags: false,
+            escape: true
+        });
+        assert.equal(outXmlString, '<root><typeA></typeA><typeB></typeB></root>');
+    });
+});