Options argument in Xslt class constructor. (#59)

* Escape option in `Xslt` object, to turn off XML escape if needed.
* Updating README.md.

Author: leonelsanchesdasilva

.eslintrc.js

@@ -175,7 +175,6 @@ module.exports = {
         'no-whitespace-before-property': 'error',
         'no-with': 'error',
         'nonblock-statement-body-position': 'error',
-        'object-curly-newline': 'error',
         'object-property-newline': 'error',
         'object-shorthand': 'error',
         'one-var': 'off',

README.md

@@ -59,6 +59,19 @@ const xPath = new XPath();
 
 If you write pre-2015 JS code, make adjustments as needed.
 
+### `Xslt` class options
+
+You can pass an `options` object to `Xslt` class:
+
+```js
+const options = {
+  escape: false
+};
+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). 
+
 ### Direct use in browsers
 
 You can simply add a tag like this:

src/dom/index.ts

@@ -1,4 +1,5 @@
 export * from './functions';
 export * from './xdocument';
 export * from './xml-functions';
+export * from './xml-output-options';
 export * from './xnode';

src/dom/xml-functions.ts

@@ -12,6 +12,7 @@ import {
 import { domGetAttributeValue } from './functions';
 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
@@ -145,29 +146,35 @@ function xmlTextRecursive(node: XNode, buf: any[], cdata: any) {
 
 /**
  * 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 xmlTransformedText(node: XNode, opt_cdata: boolean = false) {
+export function xmlTransformedText(
+    node: XNode,
+    options: XmlOutputOptions = {
+        cData: false,
+        escape: true
+    }
+) {
     const buffer = [];
-    xmlTransformedTextRecursive(node, buffer, opt_cdata);
+    xmlTransformedTextRecursive(node, buffer, options);
     return buffer.join('');
 }
 
-function xmlTransformedTextRecursive(node: XNode, buffer: any[], cdata: boolean) {
+function xmlTransformedTextRecursive(node: XNode, buffer: any[], options: XmlOutputOptions) {
     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() !== '') {
-            const finalText = node.escape ?
+            const finalText = node.escape && options.escape?
                 xmlEscapeText(node.transformedNodeValue) :
                 node.transformedNodeValue;
             buffer.push(finalText);
         }
     } else if (nodeType == DOM_CDATA_SECTION_NODE) {
-        if (cdata) {
+        if (options.cData) {
             buffer.push(nodeValue);
         } else {
             buffer.push(`<![CDATA[${nodeValue}]]>`);
@@ -179,15 +186,15 @@ function xmlTransformedTextRecursive(node: XNode, buffer: any[], cdata: boolean)
         // 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);
+            xmlElementLogicTrivial(node, buffer, options);
         } else {
-            xmlElementLogicMuted(node, buffer, cdata);
+            xmlElementLogicMuted(node, buffer, options);
         }
     } 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);
+            xmlTransformedTextRecursive(childNodes[i], buffer, options);
         }
     }
 
@@ -200,7 +207,7 @@ function xmlTransformedTextRecursive(node: XNode, buffer: any[], cdata: boolean)
  * @param buffer The XML buffer.
  * @param cdata If using CDATA configuration.
  */
-function xmlElementLogicTrivial(node: XNode, buffer: any[], cdata: boolean) {
+function xmlElementLogicTrivial(node: XNode, buffer: any[], options: XmlOutputOptions) {
     buffer.push(`<${xmlFullNodeName(node)}`);
 
     const attributes = node.transformedAttributes || node.attributes;
@@ -223,7 +230,7 @@ function xmlElementLogicTrivial(node: XNode, buffer: any[], cdata: boolean) {
     } else {
         buffer.push('>');
         for (let i = 0; i < childNodes.length; ++i) {
-            xmlTransformedTextRecursive(childNodes[i], buffer, cdata);
+            xmlTransformedTextRecursive(childNodes[i], buffer, options);
         }
         buffer.push(`</${xmlFullNodeName(node)}>`);
     }
@@ -237,10 +244,10 @@ function xmlElementLogicTrivial(node: XNode, buffer: any[], cdata: boolean) {
  * @param buffer The XML buffer.
  * @param cdata If using CDATA configuration.
  */
-function xmlElementLogicMuted(node: XNode, buffer: any[], cdata: boolean) {
+function xmlElementLogicMuted(node: XNode, buffer: any[], options: XmlOutputOptions) {
     const childNodes = node.transformedChildNodes.length > 0 ? node.transformedChildNodes : node.childNodes;
     for (let i = 0; i < childNodes.length; ++i) {
-        xmlTransformedTextRecursive(childNodes[i], buffer, cdata);
+        xmlTransformedTextRecursive(childNodes[i], buffer, options);
     }
 }
 

src/dom/xml-output-options.ts

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

src/index.ts

@@ -1,4 +1,4 @@
 export { XPath } from './xpath';
-export { Xslt } from './xslt';
+export { Xslt, XsltOptions } from './xslt';
 export { xmlParse, xmlEscapeText } from './dom';
 export { ExprContext } from './xpath';

src/xslt/index.ts

@@ -0,0 +1,2 @@
+export * from './xslt-options';
+export * from './xslt';

src/xslt/xslt-options.ts

@@ -0,0 +1,3 @@
+export type XsltOptions = {
+    escape: boolean
+}

src/xslt.ts renamed to src/xslt/xslt.ts

@@ -27,8 +27,8 @@ import {
     xmlTransformedText,
     xmlValue,
     xmlValue2
-} from './dom';
-import { ExprContext, XPath } from './xpath';
+} from '../dom';
+import { ExprContext, XPath } from '../xpath';
 
 import {
     DOM_ATTRIBUTE_NODE,
@@ -38,10 +38,11 @@ import {
     DOM_DOCUMENT_NODE,
     DOM_ELEMENT_NODE,
     DOM_TEXT_NODE
-} from './constants';
-import { Expression } from './xpath/expressions/expression';
-import { StringValue, NodeSetValue } from './xpath/values';
-import { LocationExpr } from './xpath/expressions';
+} from '../constants';
+import { Expression } from '../xpath/expressions/expression';
+import { StringValue, NodeSetValue } from '../xpath/values';
+import { LocationExpr } from '../xpath/expressions';
+import { XsltOptions } from './xslt-options';
 
 /**
  * The main class for XSL-T processing. The implementation is NOT
@@ -69,11 +70,13 @@ import { LocationExpr } from './xpath/expressions';
  */
 export class Xslt {
     xPath: XPath;
+    options: XsltOptions;
     outputMethod: string;
     outputOmitXmlDeclaration: string;
 
-    constructor() {
+    constructor(options: XsltOptions = { escape: true }) {
         this.xPath = new XPath();
+        this.options = options
         this.outputMethod = "xml";
         this.outputOmitXmlDeclaration = "no";
     }
@@ -97,7 +100,13 @@ export class Xslt {
         }
 
         this.xsltProcessContext(expressionContext, stylesheet, output, parameters);
-        const ret = xmlTransformedText(output);
+        const ret = xmlTransformedText(
+            output,
+            {
+                cData: false,
+                escape: this.options.escape
+            }
+        );
         return ret;
     }