fast-xml-parser 4.0.0-beta.0 → 4.0.0-beta.2

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 Note: If you find missing information about particular minor version, that version must have been changed without any functional change in this library.
 
+**⚠️ 4.0.0-beta.2 / 2021-11-19**
+* rename `attrMap` to `attibutes` in parser output when `preserveOrder:true`
+* supports unpairedTags
+
+**⚠️ 4.0.0-beta.1 / 2021-11-18**
+* Parser returns an array now
+  * to make the structure common
+  * and to return root level detail
+* renamed `cdataTagName` to `cdataPropName`
+* Added `commentPropName`
+* fix typings
+
 **⚠️ 4.0.0-beta.0 / 2021-11-16**
 * Name change of many configuration properties.
   * `attrNodeName` to `attributesGroupName`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fast-xml-parser",
-  "version": "4.0.0-beta.0",
+  "version": "4.0.0-beta.2",
   "description": "Validate XML, Parse XML, Build XML without C/C++ based libraries",
   "main": "./src/fxp.js",
   "scripts": {

package/src/fxp.d.ts

@@ -9,11 +9,13 @@ type X2jOptions = {
   parseTagValue: boolean;
   parseAttributeValue: boolean;
   trimValues: boolean;
-  cdataTagName: false | string;
+  cdataPropName: false | string;
+  commentPropName: false | string;
   tagValueProcessor: (tagName: string, tagValue: string, jPath: string, hasAttributes: boolean, isLeafNode: boolean) => string;
   attributeValueProcessor: (attrName: string, attrValue: string, jPath: string) => string;
   numberParseOptions: strnumOptions;
   stopNodes: string[];
+  unpairedTags: string[];
   alwaysCreateTextNode: boolean;
   isArray: (tagName: string, jPath: string, isLeafNode: boolean, isAttribute: boolean) => boolean;
 };
@@ -25,6 +27,7 @@ type strnumOptions = {
 type X2jOptionsOptional = Partial<X2jOptions>;
 type validationOptions = {
   allowBooleanAttributes: boolean;
+  unpairedTags: string[];
 };
 type validationOptionsOptional = Partial<validationOptions>;
 
@@ -33,12 +36,14 @@ type XmlBuilderOptions = {
   attributesGroupName: false | string;
   textNodeName: string;
   ignoreAttributes: boolean;
-  cdataTagName: false | string;
+  cdataPropName: false | string;
+  commentPropName: false | string;
   format: boolean;
   indentBy: string;
   arrayNodeName: string;
   suppressEmptyNode: boolean;
   preserveOrder: boolean;
+  unpairedTags: string[];
   tagValueProcessor: (name: string, value: string) => string;
   attributeValueProcessor: (name: string, value: string) => string;
 };
@@ -57,14 +62,12 @@ type ValidationError = {
 
 export class XMLParser {
   constructor(options?: X2jOptionsOptional);
-  parse(xmlData: string | Buffer ,validationOptions?: validationOptionsOptional | boolean);
+  parse(xmlData: string | Buffer ,validationOptions?: validationOptionsOptional | boolean): any;
 }
 
-export function XMLValidator(
-  xmlData: string,
-  options?: validationOptionsOptional
-): true | ValidationError;
-
+export class XMLValidator{
+  static validate(  xmlData: string,  options?: validationOptionsOptional): true | ValidationError;
+}
 export class XMLBuilder {
   constructor(options: XmlBuilderOptionsOptional);
   parse(options: any): any;

package/src/validator.js

@@ -4,9 +4,13 @@ const util = require('./util');
 
 const defaultOptions = {
   allowBooleanAttributes: false, //A tag can have attributes without any value
+  unpairedTags: []
 };
 
-const props = ['allowBooleanAttributes'];
+const props = [
+  'allowBooleanAttributes',
+  'unpairedTags'
+];
 
 //const tagsPattern = new RegExp("<\\/?([\\w:\\-_\.]+)\\s*\/?>","g");
 exports.validate = function (xmlData, options) {
@@ -130,6 +134,8 @@ exports.validate = function (xmlData, options) {
           //if the root level has been reached before ...
           if (reachedRoot === true) {
             return getErrorObject('InvalidXml', 'Multiple possible root nodes found.', getLineNumberForPosition(xmlData, i));
+          } else if(options.unpairedTags.indexOf(tagName) !== -1){
+            //don't push into stack
           } else {
             tags.push({tagName, tagStartPos});
           }

package/src/xmlbuilder/json2xml.js

@@ -8,7 +8,7 @@ const defaultOptions = {
   attributesGroupName: false,
   textNodeName: '#text',
   ignoreAttributes: true,
-  cdataTagName: false,
+  cdataPropName: false,
   format: false,
   indentBy: '  ',
   suppressEmptyNode: false,
@@ -18,7 +18,9 @@ const defaultOptions = {
   attributeValueProcessor: function(attrName, a) {
     return a;
   },
-  preserveOrder: false
+  preserveOrder: false,
+  commentPropName: false,
+  unpairedTags: [],
 };
 
 const props = [
@@ -26,7 +28,7 @@ const props = [
   'attributesGroupName',
   'textNodeName',
   'ignoreAttributes',
-  'cdataTagName',
+  'cdataPropName',
   'format',
   'indentBy',
   'suppressEmptyNode',
@@ -34,6 +36,8 @@ const props = [
   'attributeValueProcessor',
   'arrayNodeName', //when array as root
   'preserveOrder',
+  "commentPropName",
+  "unpairedTags",
   // 'rootNodeName', //when jsObject have multiple properties on root level
 ];
 
@@ -206,7 +210,9 @@ function buildTextValNode(val, key, attrStr, level) {
 }
 
 function buildEmptyTextNode(val, key, attrStr, level) {
-  if (val !== '') {
+  if( val === '' && this.options.unpairedTags.indexOf(key) !== -1){
+    return this.indentate(level) + '<' + key + attrStr + this.tagEndChar;
+  }else if (val !== '') {
     return this.buildTextValNode(val, key, attrStr, level);
   } else {
     return this.indentate(level) + '<' + key + attrStr + '/' + this.tagEndChar;
@@ -225,8 +231,4 @@ function isAttribute(name /*, options*/) {
   }
 }
 
-//formatting
-//indentation
-//\n after each closing or self closing tag
-
 module.exports = Builder;

package/src/xmlbuilder/orderedJs2Xml.js

@@ -1,7 +1,13 @@
 const {EOL} = require('os');
 
-function toXml(jObj, options){
-    return arrToStr( [jObj], options, 0);
+/**
+ * 
+ * @param {array} jArray 
+ * @param {any} options 
+ * @returns 
+ */
+function toXml(jArray, options){
+    return arrToStr( jArray, options, 0);
 }
 
 function arrToStr(arr, options, level){
@@ -19,15 +25,22 @@ function arrToStr(arr, options, level){
         if(tagName === options.textNodeName){
             xmlStr += indentation + options.tagValueProcessor( tagName, tagObj[tagName]);
             continue;
-        }else if( tagName === options.cdataTagName){
+        }else if( tagName === options.cdataPropName){
             xmlStr += indentation + `<![CDATA[${tagObj[tagName][0][options.textNodeName]}]]>`;
             continue;
+        }else if( tagName === options.commentPropName){
+            xmlStr += indentation + `<!--${tagObj[tagName][0][options.textNodeName]}-->`;
+            continue;
         }
         const attStr = attr_to_str(tagObj.attributes, options);
         let tagStart =  indentation + `<${tagName}${attStr}`;
         let tagValue = arrToStr(tagObj[tagName], options, level + 1);
         if( (!tagValue || tagValue.length === 0) && options.suppressEmptyNode){ 
-            xmlStr += tagStart + "/>"; 
+            if(options.unpairedTags.indexOf(tagName) !== -1){
+                xmlStr += tagStart + ">"; 
+            }else{
+                xmlStr += tagStart + "/>"; 
+            }
         }else{ 
             //TODO: node with only text value should not parse the text value in next line
             xmlStr += tagStart + `>${tagValue}${indentation}</${tagName}>` ;

package/src/xmlparser/OptionsBuilder.js

@@ -11,7 +11,7 @@ const defaultOptions = {
     parseTagValue: true,
     parseAttributeValue: false,
     trimValues: true, //Trim string values of tag and attributes
-    cdataTagName: false,
+    cdataPropName: false,
     numberParseOptions: {
       hex: true,
       leadingZeros: true
@@ -24,7 +24,9 @@ const defaultOptions = {
     },
     stopNodes: [], //nested tags will not be parsed even for errors
     alwaysCreateTextNode: false,
-    isArray: () => false
+    isArray: () => false,
+    commentPropName: false,
+    unpairedTags: [],
 };
    
 const props = [
@@ -38,13 +40,15 @@ const props = [
     'parseTagValue',
     'parseAttributeValue',
     'trimValues',
-    'cdataTagName',
+    'cdataPropName',
     'tagValueProcessor',
     'attributeValueProcessor',
     'numberParseOptions',
     'stopNodes',
     'alwaysCreateTextNode',
     'isArray',
+    'commentPropName',
+    'unpairedTags',
 ];
   
 const util = require('../util');

package/src/xmlparser/OrderedObjParser.js

@@ -141,7 +141,7 @@ function buildAttributesMap(attrStr, jPath, options) {
 }
 
 const parseToOrderedJsObj = function(xmlData, options) {
-  xmlData = xmlData.replace(/\r\n?/g, "\n");
+  xmlData = xmlData.replace(/\r\n?/g, "\n"); //TODO: remove this line
   const xmlObj = new xmlNode('!xml');
   let currentNode = xmlObj;
   let textData = "";
@@ -170,7 +170,7 @@ const parseToOrderedJsObj = function(xmlData, options) {
             , currentNode.tagname
             , jPath
             ,false
-            , currentNode.attrsMap ? Object.keys(currentNode.attrsMap).length !== 0 : false
+            , currentNode.attributes ? Object.keys(currentNode.attributes).length !== 0 : false
             , Object.keys(currentNode.child).length === 0);
           if(textData !== undefined &&  textData !== "") currentNode.add(options.textNodeName, textData);
           textData = "";
@@ -190,7 +190,26 @@ const parseToOrderedJsObj = function(xmlData, options) {
       } else if( xmlData[i+1] === '?') {
         i = findClosingIndex(xmlData, "?>", i, "Pi Tag is not closed.")
       } else if(xmlData.substr(i + 1, 3) === '!--') {
-        i = findClosingIndex(xmlData, "-->", i, "Comment is not closed.")
+        const endIndex = findClosingIndex(xmlData, "-->", i, "Comment is not closed.")
+        if(options.commentPropName){
+          const comment = xmlData.substring(i + 4, endIndex - 2);
+
+          //TODO: remove repeated code
+          if(textData){ //store previously collected data as textNode
+            textData = parseValue(textData
+              , options
+              , currentNode.tagname
+              , jPath
+              ,false
+              , currentNode.attributes ? Object.keys(currentNode.attributes).length !== 0 : false
+              , Object.keys(currentNode.child).length === 0);
+  
+            if(textData !== undefined &&  textData !== "") currentNode.add(options.textNodeName, textData);
+            textData = "";
+          }
+          currentNode.add(options.commentPropName, [ { [options.textNodeName] : comment } ]);
+        }
+        i = endIndex;
       } else if( xmlData.substr(i + 1, 2) === '!D') {
         const closeIndex = findClosingIndex(xmlData, ">", i, "DOCTYPE is not closed.")
         const tagExp = xmlData.substring(i, closeIndex);
@@ -209,7 +228,7 @@ const parseToOrderedJsObj = function(xmlData, options) {
             , currentNode.tagname
             , jPath
             ,false
-            , currentNode.attrsMap ? Object.keys(currentNode.attrsMap).length !== 0 : false
+            , currentNode.attributes ? Object.keys(currentNode.attributes).length !== 0 : false
             , Object.keys(currentNode.child).length === 0);
 
           if(textData !== undefined &&  textData !== "") currentNode.add(options.textNodeName, textData);
@@ -217,10 +236,10 @@ const parseToOrderedJsObj = function(xmlData, options) {
         }
 
         //cdata should be set even if it is 0 length string
-        if(options.cdataTagName){
-          let val = parseValue(tagExp, options, options.cdataTagName, jPath + "." + options.cdataTagName, true, false, true);
+        if(options.cdataPropName){
+          let val = parseValue(tagExp, options, options.cdataPropName, jPath + "." + options.cdataPropName, true, false, true);
           if(!val) val = "";
-          currentNode.add(options.cdataTagName, [ { [options.textNodeName] : val } ]);
+          currentNode.add(options.cdataPropName, [ { [options.textNodeName] : val } ]);
         }else{
           let val = parseValue(tagExp, options, currentNode.tagname, jPath, true, false, true);
           if(!val) val = "";
@@ -257,7 +276,7 @@ const parseToOrderedJsObj = function(xmlData, options) {
               , currentNode.tagname
               , jPath
               , false
-              , currentNode.attrsMap ? Object.keys(currentNode.attrsMap).length !== 0 : false
+              , currentNode.attributes ? Object.keys(currentNode.attributes).length !== 0 : false
               , false);
             if(textData !== undefined &&  textData !== "") currentNode.add(options.textNodeName, textData);
             textData = "";
@@ -268,7 +287,8 @@ const parseToOrderedJsObj = function(xmlData, options) {
           jPath += jPath ? "." + tagName : tagName;
         }
 
-        if(tagExp.length > 0 && tagExp.lastIndexOf("/") === tagExp.length - 1){//selfClosing tag
+  //selfClosing tag
+        if(tagExp.length > 0 && tagExp.lastIndexOf("/") === tagExp.length - 1){
           
           if(tagName[tagName.length - 1] === "/"){ //remove trailing '/'
             tagName = tagName.substr(0, tagName.length - 1);
@@ -279,12 +299,26 @@ const parseToOrderedJsObj = function(xmlData, options) {
 
           const childNode = new xmlNode(tagName);
           if(tagName !== tagExp && shouldBuildAttributesMap){
-            childNode.attrsMap = buildAttributesMap(tagExp, jPath , options);
+            childNode.attributes = buildAttributesMap(tagExp, jPath , options);
           }
           jPath = jPath.substr(0, jPath.lastIndexOf("."));
           // tagsNodeStack.push(currentNode);
           currentNode.addChild(childNode);
-        }else{//opening tag
+        }
+  //boolean tags
+        else if(options.unpairedTags.indexOf(tagName) !== -1){
+            // tagExp = tagExp.substr(0, tagExp.length - 1);
+
+          const childNode = new xmlNode(tagName);
+          if(tagName !== tagExp && shouldBuildAttributesMap){
+            childNode.attributes = buildAttributesMap(tagExp, jPath , options);
+          }
+          jPath = jPath.substr(0, jPath.lastIndexOf("."));
+          // tagsNodeStack.push(currentNode);
+          currentNode.addChild(childNode);
+        }
+  //opening tag
+        else{
           
           const childNode = new xmlNode( tagName);
           tagsNodeStack.push(currentNode);
@@ -292,7 +326,7 @@ const parseToOrderedJsObj = function(xmlData, options) {
           childNode.startIndex=closeIndex; //for further processing
           
           if(tagName !== tagExp && shouldBuildAttributesMap){
-            childNode.attrsMap = buildAttributesMap(tagExp, jPath, options);
+            childNode.attributes = buildAttributesMap(tagExp, jPath, options);
           }
           currentNode.addChild(childNode);
           currentNode = childNode;
@@ -304,7 +338,7 @@ const parseToOrderedJsObj = function(xmlData, options) {
       textData += xmlData[i];
     }
   }
-  return xmlObj.child[0];
+  return xmlObj.child;
 }
 
 //TODO: use jPath to simplify the logic

package/src/xmlparser/node2json.js

@@ -1,7 +1,13 @@
 'use strict';
 
+/**
+ * 
+ * @param {array} node 
+ * @param {any} options 
+ * @returns 
+ */
 function prettify(node, options){
-  return compress( [node], options);
+  return compress( node, options);
 }
 
 /**

package/src/xmlparser/xmlNode.js

@@ -4,15 +4,15 @@ class XmlNode{
   constructor(tagname) {
     this.tagname = tagname;
     this.child = []; //nested tags, text, cdata, comments in order
-    this.attrsMap = {}; //attributes map
+    this.attributes = {}; //attributes map
   }
   add(key,val){
     // this.child.push( {name : key, val: val, isCdata: isCdata });
     this.child.push( {[key]: val });
   }
   addChild(node) {
-    if(node.attrsMap && Object.keys(node.attrsMap).length > 0){
-      this.child.push( { [node.tagname]: node.child, attributes: node.attrsMap });
+    if(node.attributes && Object.keys(node.attributes).length > 0){
+      this.child.push( { [node.tagname]: node.child, attributes: node.attributes });
     }else{
       this.child.push( { [node.tagname]: node.child });
     }