fast-xml-parser 3.21.0 → 4.0.0-beta.3

package/src/fxp.d.ts

@@ -0,0 +1,77 @@
+type X2jOptions = {
+  preserveOrder: boolean;
+  attributeNamePrefix: string;
+  attributesGroupName: false | string;
+  textNodeName: string;
+  ignoreAttributes: boolean;
+  removeNSPrefix: boolean;
+  allowBooleanAttributes: boolean;
+  parseTagValue: boolean;
+  parseAttributeValue: boolean;
+  trimValues: boolean;
+  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;
+  processEntities: boolean;
+  htmlEntities: boolean;
+};
+type strnumOptions = {
+  hex: boolean;
+  leadingZeros: boolean,
+  skipLike?: RegExp
+}
+type X2jOptionsOptional = Partial<X2jOptions>;
+type validationOptions = {
+  allowBooleanAttributes: boolean;
+  unpairedTags: string[];
+};
+type validationOptionsOptional = Partial<validationOptions>;
+
+type XmlBuilderOptions = {
+  attributeNamePrefix: string;
+  attributesGroupName: false | string;
+  textNodeName: string;
+  ignoreAttributes: boolean;
+  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;
+  processEntities: boolean;
+};
+type XmlBuilderOptionsOptional = Partial<XmlBuilderOptions>;
+
+type ESchema = string | object | Array<string|object>;
+
+type ValidationError = {
+  err: { 
+    code: string;
+    msg: string,
+    line: number,
+    col: number 
+  };
+};
+
+export class XMLParser {
+  constructor(options?: X2jOptionsOptional);
+  parse(xmlData: string | Buffer ,validationOptions?: validationOptionsOptional | boolean): any;
+}
+
+export class XMLValidator{
+  static validate(  xmlData: string,  options?: validationOptionsOptional): true | ValidationError;
+}
+export class XMLBuilder {
+  constructor(options: XmlBuilderOptionsOptional);
+  build(jObj: any): any;
+}

package/src/fxp.js

@@ -0,0 +1,11 @@
+'use strict';
+
+const validator = require('./validator');
+const XMLParser = require('./xmlparser/XMLParser');
+const XMLBuilder = require('./xmlbuilder/json2xml');
+
+module.exports = {
+  XMLParser: XMLParser,
+  XMLValidator: validator,
+  XMLBuilder: XMLBuilder
+}

package/src/util.js

@@ -67,7 +67,7 @@ exports.getValue = function(v) {
 // const fakeCall = function(a) {return a;};
 // const fakeCallNoReturn = function() {};
 
-exports.buildOptions = function(options, defaultOptions, props) {
+const buildOptions = function(options, defaultOptions, props) {
   let newOptions = {};
   if (!options) {
     return defaultOptions; //if there are not options
@@ -83,26 +83,7 @@ exports.buildOptions = function(options, defaultOptions, props) {
   return newOptions;
 };
 
-/**
- * Check if a tag name should be treated as array
- *
- * @param tagName the node tagname
- * @param arrayMode the array mode option
- * @param parentTagName the parent tag name
- * @returns {boolean} true if node should be parsed as array
- */
-exports.isTagNameInArrayMode = function (tagName, arrayMode, parentTagName) {
-  if (arrayMode === false) {
-    return false;
-  } else if (arrayMode instanceof RegExp) {
-    return arrayMode.test(tagName);
-  } else if (typeof arrayMode === 'function') {
-    return !!arrayMode(tagName, parentTagName);
-  }
-
-  return arrayMode === "strict";
-}
-
+exports.buildOptions = buildOptions;
 exports.isName = isName;
 exports.getAllMatches = getAllMatches;
 exports.nameRegexp = nameRegexp;

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) {
@@ -25,7 +29,7 @@ exports.validate = function (xmlData, options) {
     // check for byte order mark (BOM)
     xmlData = xmlData.substr(1);
   }
-
+  
   for (let i = 0; i < xmlData.length; i++) {
 
     if (xmlData[i] === '<' && xmlData[i+1] === '?') {
@@ -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});
           }
@@ -156,6 +162,10 @@ exports.validate = function (xmlData, options) {
             if (afterAmp == -1)
               return getErrorObject('InvalidChar', "char '&' is not expected.", getLineNumberForPosition(xmlData, i));
             i = afterAmp;
+          }else{
+            if (reachedRoot === true && !isWhiteSpace(xmlData[i])) {
+              return getErrorObject('InvalidXml', "Extra text at the end", getLineNumberForPosition(xmlData, i));
+            }
           }
         } //end of reading tag text value
         if (xmlData[i] === '<') {
@@ -163,7 +173,7 @@ exports.validate = function (xmlData, options) {
         }
       }
     } else {
-      if (xmlData[i] === ' ' || xmlData[i] === '\t' || xmlData[i] === '\n' || xmlData[i] === '\r') {
+      if ( isWhiteSpace(xmlData[i])) {
         continue;
       }
       return getErrorObject('InvalidChar', "char '"+xmlData[i]+"' is not expected.", getLineNumberForPosition(xmlData, i));
@@ -183,6 +193,9 @@ exports.validate = function (xmlData, options) {
   return true;
 };
 
+function isWhiteSpace(char){
+  return char === ' ' || char === '\t' || char === '\n'  || char === '\r';
+}
 /**
  * Read Processing insstructions and skip
  * @param {*} xmlData

package/src/xmlbuilder/json2xml.js

@@ -0,0 +1,263 @@
+'use strict';
+//parse Empty Node as self closing node
+const buildOptions = require('../util').buildOptions;
+const buildFromOrderedJs = require('./orderedJs2Xml');
+
+const defaultOptions = {
+  attributeNamePrefix: '@_',
+  attributesGroupName: false,
+  textNodeName: '#text',
+  ignoreAttributes: true,
+  cdataPropName: false,
+  format: false,
+  indentBy: '  ',
+  suppressEmptyNode: false,
+  tagValueProcessor: function(key, a) {
+    return a;
+  },
+  attributeValueProcessor: function(attrName, a) {
+    return a;
+  },
+  preserveOrder: false,
+  commentPropName: false,
+  unpairedTags: [],
+  entities: {
+    ">" : { regex: new RegExp(">", "g"), val: ">" },
+    "<" : { regex: new RegExp("<", "g"), val: "&lt;" },
+    "sQuot" : { regex: new RegExp("\'", "g"), val: "&apos;" },
+    "dQuot" : { regex: new RegExp("\"", "g"), val: "&quot;" }
+  },
+  processEntities: true
+};
+
+const props = [
+  'attributeNamePrefix',
+  'attributesGroupName',
+  'textNodeName',
+  'ignoreAttributes',
+  'cdataPropName',
+  'format',
+  'indentBy',
+  'suppressEmptyNode',
+  'tagValueProcessor',
+  'attributeValueProcessor',
+  'arrayNodeName', //when array as root
+  'preserveOrder',
+  "commentPropName",
+  "unpairedTags",
+  "entities",
+  "processEntities",
+  // 'rootNodeName', //when jsObject have multiple properties on root level
+];
+
+function Builder(options) {
+  this.options = buildOptions(options, defaultOptions, props);
+  if (this.options.ignoreAttributes || this.options.attributesGroupName) {
+    this.isAttribute = function(/*a*/) {
+      return false;
+    };
+  } else {
+    this.attrPrefixLen = this.options.attributeNamePrefix.length;
+    this.isAttribute = isAttribute;
+  }
+
+  this.processTextOrObjNode = processTextOrObjNode
+
+  if (this.options.format) {
+    this.indentate = indentate;
+    this.tagEndChar = '>\n';
+    this.newLine = '\n';
+  } else {
+    this.indentate = function() {
+      return '';
+    };
+    this.tagEndChar = '>';
+    this.newLine = '';
+  }
+
+  if (this.options.suppressEmptyNode) {
+    this.buildTextNode = buildEmptyTextNode;
+    this.buildObjNode = buildEmptyObjNode;
+  } else {
+    this.buildTextNode = buildTextValNode;
+    this.buildObjNode = buildObjectNode;
+  }
+
+  this.buildTextValNode = buildTextValNode;
+  this.buildObjectNode = buildObjectNode;
+
+  this.replaceEntitiesValue = replaceEntitiesValue;
+}
+
+Builder.prototype.build = function(jObj) {
+  if(this.options.preserveOrder){
+    return buildFromOrderedJs(jObj, this.options);
+  }else {
+    if(Array.isArray(jObj) && this.options.arrayNodeName && this.options.arrayNodeName.length > 1){
+      jObj = {
+        [this.options.arrayNodeName] : jObj
+      }
+    }
+    return this.j2x(jObj, 0).val;
+  }
+};
+
+Builder.prototype.j2x = function(jObj, level) {
+  let attrStr = '';
+  let val = '';
+  for (let key in jObj) {
+    if (typeof jObj[key] === 'undefined') {
+      // supress undefined node
+    } else if (jObj[key] === null) {
+      val += this.indentate(level) + '<' + key + '/' + this.tagEndChar;
+    } else if (jObj[key] instanceof Date) {
+      val += this.buildTextNode(jObj[key], key, '', level);
+    } else if (typeof jObj[key] !== 'object') {
+      //premitive type
+      const attr = this.isAttribute(key);
+      if (attr) {
+        let val = this.options.attributeValueProcessor(attr, '' + jObj[key]);
+        val = this.replaceEntitiesValue(val);
+        attrStr += ' ' + attr + '="' + val + '"';
+      }else {
+        //tag value
+        if (key === this.options.textNodeName) {
+          let newval = this.options.tagValueProcessor(key, '' + jObj[key]);
+          val += this.replaceEntitiesValue(newval);
+        } else {
+          val += this.buildTextNode(jObj[key], key, '', level);
+        }
+      }
+    } else if (Array.isArray(jObj[key])) {
+      //repeated nodes
+      const arrLen = jObj[key].length;
+      for (let j = 0; j < arrLen; j++) {
+        const item = jObj[key][j];
+        if (typeof item === 'undefined') {
+          // supress undefined node
+        } else if (item === null) {
+          val += this.indentate(level) + '<' + key + '/' + this.tagEndChar;
+        } else if (typeof item === 'object') {
+          val += this.processTextOrObjNode(item, key, level)
+        } else {
+          val += this.buildTextNode(item, key, '', level);
+        }
+      }
+    } else {
+      //nested node
+      if (this.options.attributesGroupName && key === this.options.attributesGroupName) {
+        const Ks = Object.keys(jObj[key]);
+        const L = Ks.length;
+        for (let j = 0; j < L; j++) {
+          let val = this.options.attributeValueProcessor(Ks[j], '' + jObj[key][Ks[j]]);
+          val = this.replaceEntitiesValue(val);
+          attrStr += ' ' + Ks[j] + '="' + val + '"';
+        }
+      } else {
+        val += this.processTextOrObjNode(jObj[key], key, level)
+      }
+    }
+  }
+  return {attrStr: attrStr, val: val};
+};
+
+function processTextOrObjNode (object, key, level) {
+  const result = this.j2x(object, level + 1);
+  if (object[this.options.textNodeName] !== undefined && Object.keys(object).length === 1) {
+    return this.buildTextNode(result.val, key, result.attrStr, level);
+  } else {
+    return this.buildObjNode(result.val, key, result.attrStr, level);
+  }
+}
+
+function buildObjectNode(val, key, attrStr, level) {
+  if (attrStr && val.indexOf('<') === -1) {
+    return (
+      this.indentate(level) +
+      '<' +
+      key +
+      attrStr +
+      '>' +
+      val +
+      //+ this.newLine
+      // + this.indentate(level)
+      '</' +
+      key +
+      this.tagEndChar
+    );
+  } else {
+    return (
+      this.indentate(level) +
+      '<' +
+      key +
+      attrStr +
+      this.tagEndChar +
+      val +
+      //+ this.newLine
+      this.indentate(level) +
+      '</' +
+      key +
+      this.tagEndChar
+    );
+  }
+}
+
+function buildEmptyObjNode(val, key, attrStr, level) {
+  if (val !== '') {
+    return this.buildObjectNode(val, key, attrStr, level);
+  } else {
+    return this.indentate(level) + '<' + key + attrStr + '/' + this.tagEndChar;
+    //+ this.newLine
+  }
+}
+
+function buildTextValNode(val, key, attrStr, level) {
+  let textValue = this.options.tagValueProcessor(key, val);
+  textValue = this.replaceEntitiesValue(textValue);
+  
+  return (
+    this.indentate(level) +
+    '<' +
+    key +
+    attrStr +
+    '>' +
+     textValue +
+    '</' +
+    key +
+    this.tagEndChar
+  );
+}
+
+function replaceEntitiesValue(textValue){
+  if(textValue && textValue.length > 0 && this.options.processEntities){
+    for (const entityName in this.options.entities) {
+      const entity = this.options.entities[entityName];
+      textValue = textValue.replace(entity.regex, entity.val);
+    }
+  }
+  return textValue;
+}
+
+function buildEmptyTextNode(val, key, attrStr, level) {
+  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;
+  }
+}
+
+function indentate(level) {
+  return this.options.indentBy.repeat(level);
+}
+
+function isAttribute(name /*, options*/) {
+  if (name.startsWith(this.options.attributeNamePrefix)) {
+    return name.substr(this.attrPrefixLen);
+  } else {
+    return false;
+  }
+}
+
+module.exports = Builder;

package/src/xmlbuilder/orderedJs2Xml.js

@@ -0,0 +1,84 @@
+const {EOL} = require('os');
+
+/**
+ * 
+ * @param {array} jArray 
+ * @param {any} options 
+ * @returns 
+ */
+function toXml(jArray, options){
+    return arrToStr( jArray, options, 0);
+}
+
+function arrToStr(arr, options, level){
+    let xmlStr = "";
+
+    let indentation = "";
+    if(options.format && options.indentBy.length > 0){//TODO: this logic can be avoided for each call
+        indentation = EOL + "" + options.indentBy.repeat(level);
+    }
+
+    for (let i = 0; i < arr.length; i++) {
+        const tagObj = arr[i];
+        const tagName = propName(tagObj);
+
+        if(tagName === options.textNodeName){
+            let tagText = options.tagValueProcessor( tagName, tagObj[tagName]);
+            tagText = replaceEntitiesValue(tagText, options);
+            xmlStr += indentation + tagText;
+            continue;
+        }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){ 
+            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}>` ;
+        }
+    }
+    
+    return xmlStr;
+}
+
+function propName(obj){
+    const keys = Object.keys(obj);
+    for (let i = 0; i < keys.length; i++) {
+      const key = keys[i];
+      if(key !== "attributes") return key;
+    }
+  }
+
+function attr_to_str(attrMap, options){
+    let attrStr = "";
+    if(attrMap && !options.ignoreAttributes){
+        for( attr in attrMap){
+            let attrVal = options.attributeValueProcessor(attr, attrMap[attr]);
+            attrVal = replaceEntitiesValue(attrVal, options);
+            attrStr+= ` ${attr.substr(options.attributeNamePrefix.length)}="${attrVal}"`;
+        }
+    }
+    return attrStr;
+}
+
+function replaceEntitiesValue(textValue, options){
+    if(textValue && textValue.length > 0 && options.processEntities){
+      for (const entityName in options.entities) {
+        const entity = options.entities[entityName];
+        textValue = textValue.replace(entity.regex, entity.val);
+      }
+    }
+    return textValue;
+  }
+module.exports = toXml;

package/src/xmlparser/DocTypeReader.js

@@ -0,0 +1,92 @@
+//TODO: handle comments
+function readDocType(xmlData, i){
+    
+    const entities = {};
+    if( xmlData[i + 3] === 'O' &&
+         xmlData[i + 4] === 'C' &&
+         xmlData[i + 5] === 'T' &&
+         xmlData[i + 6] === 'Y' &&
+         xmlData[i + 7] === 'P' &&
+         xmlData[i + 8] === 'E')
+    {    
+        i = i+9;
+        let angleBracketsCount = 1;
+        let hasBody = false, entity = false, comment = false;
+        let exp = "";
+        for(;i<xmlData.length;i++){
+            if (xmlData[i] === '<') {
+                if( hasBody && 
+                     xmlData[i+1] === '!' &&
+                     xmlData[i+2] === 'E' &&
+                     xmlData[i+3] === 'N' &&
+                     xmlData[i+4] === 'T' &&
+                     xmlData[i+5] === 'I' &&
+                     xmlData[i+6] === 'T' &&
+                     xmlData[i+7] === 'Y'
+                ){
+                    i += 7;
+                    entity = true;
+                }else if( hasBody && 
+                    xmlData[i+1] === '!' &&
+                     xmlData[i+2] === 'E' &&
+                     xmlData[i+3] === 'L' &&
+                     xmlData[i+4] === 'E' &&
+                     xmlData[i+5] === 'M' &&
+                     xmlData[i+6] === 'E' &&
+                     xmlData[i+7] === 'N' &&
+                     xmlData[i+8] === 'T'
+                ){
+                    //Not supported
+                    i += 8;
+                }else if( //comment
+                    xmlData[i+1] === '!' &&
+                    xmlData[i+2] === '-' &&
+                    xmlData[i+3] === '-'
+                ){
+                    comment = true;
+                }else{
+                    throw new Error("Invalid DOCTYPE");
+                }
+                angleBracketsCount++;
+                exp = "";
+            } else if (xmlData[i] === '>') {
+                if(comment){
+                    if( xmlData[i - 1] === "-" && xmlData[i - 2] === "-"){
+                        comment = false;
+                    }else{
+                        throw new Error(`Invalid XML comment in DOCTYPE`);
+                    }
+                }else if(entity){
+                    parseEntityExp(exp, entities);
+                    entity = false;
+                }
+                angleBracketsCount--;
+                if (angleBracketsCount === 0) {
+                  break;
+                }
+            }else if( xmlData[i] === '['){
+                hasBody = true;
+            }else{
+                exp += xmlData[i];
+            }
+        }
+        if(angleBracketsCount !== 0){
+            throw new Error(`Unclosed DOCTYPE`);
+        }
+    }else{
+        throw new Error(`Invalid Tag instead of DOCTYPE`);
+    }
+    return {entities, i};
+}
+
+const entityRegex = RegExp("^\\s([a-zA-z0-0]+)[ \t](['\"])([^&]+)\\2");
+function parseEntityExp(exp, entities){
+    const match = entityRegex.exec(exp);
+    if(match){
+        entities[ match[1] ] = {
+            regx : RegExp( `&${match[1]};`,"g"),
+            val: match[3]
+        };
+    }
+}
+module.exports = readDocType;

package/src/xmlparser/OptionsBuilder.js

@@ -0,0 +1,66 @@
+
+const defaultOptions = {
+    preserveOrder: false,
+    attributeNamePrefix: '@_',
+    attributesGroupName: false,
+    textNodeName: '#text',
+    ignoreAttributes: true,
+    removeNSPrefix: false, // remove NS from tag name or attribute name if true
+    allowBooleanAttributes: false, //a tag can have attributes without any value
+    //ignoreRootElement : false,
+    parseTagValue: true,
+    parseAttributeValue: false,
+    trimValues: true, //Trim string values of tag and attributes
+    cdataPropName: false,
+    numberParseOptions: {
+      hex: true,
+      leadingZeros: true
+    },
+    tagValueProcessor: function(tagName, val) {
+      return val;
+    },
+    attributeValueProcessor: function(attrName, val) {
+      return val;
+    },
+    stopNodes: [], //nested tags will not be parsed even for errors
+    alwaysCreateTextNode: false,
+    isArray: () => false,
+    commentPropName: false,
+    unpairedTags: [],
+    processEntities: true,
+    htmlEntities: false,
+};
+   
+const props = [
+    'preserveOrder',
+    'attributeNamePrefix',
+    'attributesGroupName',
+    'textNodeName',
+    'ignoreAttributes',
+    'removeNSPrefix',
+    'allowBooleanAttributes',
+    'parseTagValue',
+    'parseAttributeValue',
+    'trimValues',
+    'cdataPropName',
+    'tagValueProcessor',
+    'attributeValueProcessor',
+    'numberParseOptions',
+    'stopNodes',
+    'alwaysCreateTextNode',
+    'isArray',
+    'commentPropName',
+    'unpairedTags',
+    'processEntities',
+    'htmlEntities'
+];
+  
+const util = require('../util');
+
+const buildOptions = function(options) {
+    return util.buildOptions(options, defaultOptions, props);
+};
+
+exports.buildOptions = buildOptions;
+exports.defaultOptions = defaultOptions;
+exports.props = props;