fast-xml-parser 4.3.4 → 4.3.6

package/src/v5/OutputBuilders/ParserOptionsBuilder.js

@@ -0,0 +1,96 @@
+const trimParser = require("../valueParsers/trim")
+const booleanParser = require("../valueParsers/booleanParser")
+const currencyParser = require("../valueParsers/currency")
+const numberParser = require("../valueParsers/number")
+
+const defaultOptions={
+  nameFor:{
+    text: "#text",
+    comment: "",
+    cdata: "",
+  },
+  // onTagClose: () => {},
+  // onAttribute: () => {},
+  piTag: false,
+  declaration: false, //"?xml"
+  tags: {
+    valueParsers: [
+      // "trim",
+      // "boolean",
+      // "number",
+      // "currency",
+      // "date",
+    ]
+  },
+  attributes:{
+    prefix: "@_",
+    suffix: "",
+    groupBy: "",
+    
+    valueParsers: [
+      // "trim",
+      // "boolean",
+      // "number",
+      // "currency",
+      // "date",
+    ]
+  }
+}
+
+//TODO
+const withJoin = ["trim","join", /*"entities",*/"number","boolean","currency"/*, "date"*/]
+const withoutJoin = ["trim", /*"entities",*/"number","boolean","currency"/*, "date"*/]
+
+function buildOptions(options){
+  //clone
+  const finalOptions = { ... defaultOptions};
+
+  //add config missed in cloning
+  finalOptions.tags.valueParsers.push(...withJoin)
+  if(!this.preserveOrder)
+    finalOptions.tags.valueParsers.push(...withoutJoin);
+
+  //add config missed in cloning
+  finalOptions.attributes.valueParsers.push(...withJoin)
+
+  //override configuration
+  copyProperties(finalOptions,options);
+  return finalOptions;
+}
+
+function copyProperties(target, source) {
+  for (let key in source) {
+    if (source.hasOwnProperty(key)) {
+      if (typeof source[key] === 'object' && !Array.isArray(source[key])) {
+        // Recursively copy nested properties
+        if (typeof target[key] === 'undefined') {
+          target[key] = {};
+        }
+        copyProperties(target[key], source[key]);
+      } else {
+        // Copy non-nested properties
+        target[key] = source[key];
+      }
+    }
+  }
+}
+
+function registerCommonValueParsers(){
+  return {
+    "trim": new trimParser(),
+    // "join": this.entityParser.parse,
+    "boolean": new booleanParser(),
+    "number": new numberParser({
+          hex: true,
+          leadingZeros: true,
+          eNotation: true
+        }),
+    "currency": new currencyParser(),
+    // "date": this.entityParser.parse,
+  }
+}
+
+module.exports = {
+  buildOptions : buildOptions,
+  registerCommonValueParsers: registerCommonValueParsers
+}

package/src/v5/TagPath.js

@@ -0,0 +1,81 @@
+class TagPath{
+  constructor(pathStr){
+    let text = "";
+    let tName = "";
+    let pos;
+    let aName = "";
+    let aVal = "";
+    this.stack = []
+
+    for (let i = 0; i < pathStr.length; i++) {
+      let ch = pathStr[i];
+      if(ch === " ") {
+        if(text.length === 0) continue;        
+        tName = text; text = "";
+      }else if(ch === "["){
+        if(tName.length === 0){
+          tName = text; text = "";
+        }
+        i++;
+        for (; i < pathStr.length; i++) {
+          ch = pathStr[i];
+          if(ch=== "=") continue;
+          else if(ch=== "]") {aName = text.trim(); text=""; break; i--;}
+          else if(ch === "'" || ch === '"'){
+            let attrEnd = pathStr.indexOf(ch,i+1);
+            aVal = pathStr.substring(i+1, attrEnd);
+            i = attrEnd;
+          }else{
+            text +=ch;
+          }
+        }
+      }else if(ch !== " " && text.length === 0 && tName.length > 0){//reading tagName
+        //save previous tag
+        this.stack.push(new TagPathNode(tName,pos,aName,aVal));
+        text = ch; tName = ""; aName = ""; aVal = "";
+      }else{
+        text+=ch;
+      }
+    }
+
+    //last tag in the path
+    if(tName.length >0 || text.length>0){
+      this.stack.push(new TagPathNode(text||tName,pos,aName,aVal));
+    }
+  }
+
+  match(tagStack,node){
+    if(this.stack[0].name !== "*"){
+      if(this.stack.length !== tagStack.length +1) return false;
+  
+      //loop through tagPath and tagStack and match
+      for (let i = 0; i < this.tagStack.length; i++) {
+        if(!this.stack[i].match(tagStack[i])) return false;
+      }
+    }
+    if(!this.stack[this.stack.length - 1].match(node)) return false;
+    return true;
+  }
+}
+
+class TagPathNode{
+  constructor(name,position,attrName,attrVal){
+    this.name = name;
+    this.position = position;
+    this.attrName = attrName,
+    this.attrVal = attrVal;
+  }
+
+  match(node){
+    let matching = true;
+    matching = node.name === this.name;
+    if(this.position) matching = node.position === this.position;
+    if(this.attrName) matching = node.attrs[this.attrName !== undefined];
+    if(this.attrVal) matching = node.attrs[this.attrName !== this.attrVal];
+    return matching;
+  }
+}
+
+// console.log((new TagPath("* b[b]")).stack);
+// console.log((new TagPath("a[a] b[b] c")).stack);
+// console.log((new TagPath(" b [ b= 'cf  sdadwa' ] a  ")).stack);

package/src/v5/TagPathMatcher.js

@@ -0,0 +1,15 @@
+const TagPath = require("./TagPath");
+
+class TagPathMatcher{
+  constructor(stack,node){
+    this.stack = stack;
+    this.node= node;
+  }
+
+  match(path){
+    const tagPath = new TagPath(path);
+    return tagPath.match(this.stack, this.node);
+  }
+}
+
+module.exports = TagPathMatcher;

package/src/v5/XMLParser.js

@@ -0,0 +1,85 @@
+const { buildOptions} = require("./OptionsBuilder");
+const Xml2JsParser = require("./Xml2JsParser");
+
+class XMLParser{
+    
+    constructor(options){
+        this.externalEntities = {};
+        this.options = buildOptions(options);
+        // console.log(this.options)
+    }
+    /**
+     * Parse XML data string to JS object 
+     * @param {string|Buffer} xmlData 
+     * @param {boolean|Object} validationOption 
+     */
+    parse(xmlData){
+        if(Array.isArray(xmlData) && xmlData.byteLength !== undefined){
+            return this.parse(xmlData);
+        }else if( xmlData.toString){
+            xmlData = xmlData.toString();
+        }else{
+            throw new Error("XML data is accepted in String or Bytes[] form.")
+        }
+        // if( validationOption){
+        //     if(validationOption === true) validationOption = {}; //validate with default options
+            
+        //     const result = validator.validate(xmlData, validationOption);
+        //     if (result !== true) {
+        //       throw Error( `${result.err.msg}:${result.err.line}:${result.err.col}` )
+        //     }
+        //   }
+        const parser = new Xml2JsParser(this.options);
+        parser.entityParser.addExternalEntities(this.externalEntities);
+        return parser.parse(xmlData);
+    }
+    /**
+     * Parse XML data buffer to JS object 
+     * @param {string|Buffer} xmlData 
+     * @param {boolean|Object} validationOption 
+     */
+    parseBytesArr(xmlData){
+        if(Array.isArray(xmlData) && xmlData.byteLength !== undefined){
+        }else{
+            throw new Error("XML data is accepted in Bytes[] form.")
+        }
+        const parser = new Xml2JsParser(this.options);
+        parser.entityParser.addExternalEntities(this.externalEntities);
+        return parser.parseBytesArr(xmlData);
+    }
+    /**
+     * Parse XML data stream to JS object 
+     * @param {fs.ReadableStream} xmlDataStream 
+     */
+    parseStream(xmlDataStream){
+        if(!isStream(xmlDataStream)) throw new Error("FXP: Invalid stream input");
+        
+        const orderedObjParser = new Xml2JsParser(this.options);
+        orderedObjParser.entityParser.addExternalEntities(this.externalEntities);
+        return orderedObjParser.parseStream(xmlDataStream);
+    }
+
+    /**
+     * Add Entity which is not by default supported by this library
+     * @param {string} key 
+     * @param {string} value 
+     */
+    addEntity(key, value){
+        if(value.indexOf("&") !== -1){
+            throw new Error("Entity value can't have '&'")
+        }else if(key.indexOf("&") !== -1 || key.indexOf(";") !== -1){
+            throw new Error("An entity must be set without '&' and ';'. Eg. use '#xD' for '
'")
+        }else if(value === "&"){
+            throw new Error("An entity with value '&' is not permitted");
+        }else{
+            this.externalEntities[key] = value;
+        }
+    }
+}
+
+function isStream(stream){
+    if(stream && typeof stream.read === "function" && typeof stream.on === "function" && typeof stream.readableEnded === "boolean") return true;
+    return false;
+}
+
+module.exports = XMLParser;

package/src/v5/Xml2JsParser.js

@@ -0,0 +1,237 @@
+const StringSource = require("./inputSource/StringSource");
+const BufferSource = require("./inputSource/BufferSource");
+const {readTagExp,readClosingTagName} = require("./XmlPartReader");
+const {readComment, readCdata,readDocType,readPiTag} = require("./XmlSpecialTagsReader");
+const TagPath = require("./TagPath");
+const TagPathMatcher = require("./TagPathMatcher");
+const EntitiesParser = require('./EntitiesParser');
+
+//To hold the data of current tag
+//This is usually used to compare jpath expression against current tag
+class TagDetail{
+  constructor(name){
+    this.name = name;
+    this.position = 0;
+    // this.attributes = {};
+  }
+}
+
+class Xml2JsParser {
+    constructor(options) {
+      this.options = options;
+      
+      this.currentTagDetail = null;
+      this.tagTextData = "";
+      this.tagsStack = [];
+      this.entityParser = new EntitiesParser(options.htmlEntities);
+      this.stopNodes = [];
+      for (let i = 0; i < this.options.stopNodes.length; i++) {
+        this.stopNodes.push(new TagPath(this.options.stopNodes[i]));
+      }
+    }
+
+    parse(strData) {
+        this.source = new StringSource(strData);
+        this.parseXml();
+        return this.outputBuilder.getOutput();
+    }
+    parseBytesArr(data) {
+        this.source = new BufferSource(data );
+        this.parseXml();
+        return this.outputBuilder.getOutput();
+    }
+  
+    parseXml() {
+      //TODO: Separate TagValueParser as separate class. So no scope issue in node builder class 
+
+      //OutputBuilder should be set in XML Parser
+      this.outputBuilder = this.options.OutputBuilder.getInstance(this.options);
+      this.root = { root: true};
+      this.currentTagDetail = this.root;
+
+      while(this.source.canRead()){
+        let ch = this.source.readCh();
+        if (ch === "") break;
+        
+        if(ch === "<"){//tagStart
+          let nextChar = this.source.readChAt(0);
+          if (nextChar === "" ) throw new Error("Unexpected end of source");
+          
+        
+          if(nextChar === "!" || nextChar === "?"){
+            this.source.updateBufferBoundary();
+            //previously collected text should be added to current node
+            this.addTextNode(); 
+            
+            this.readSpecialTag(nextChar);// Read DOCTYPE, comment, CDATA, PI tag
+          }else if(nextChar === "/"){
+            this.source.updateBufferBoundary();
+            this.readClosingTag();
+            // console.log(this.source.buffer.length, this.source.readable);
+            // console.log(this.tagsStack.length);
+          }else{//opening tag
+            this.readOpeningTag();
+          }
+        }else{
+          this.tagTextData += ch;
+        }
+      }//End While loop
+      if(this.tagsStack.length > 0 || ( this.tagTextData !== "undefined" && this.tagTextData.trimEnd().length > 0) ) throw new Error("Unexpected data in the end of document");
+    }
+  
+    /**
+     * read closing paired tag. Set parent tag in scope.
+     * skip a node on user's choice
+     */
+    readClosingTag(){
+      const tagName = this.processTagName(readClosingTagName(this.source));
+      // console.log(tagName, this.tagsStack.length);
+      this.validateClosingTag(tagName);
+      // All the text data collected, belongs to current tag.
+      if(!this.currentTagDetail.root) this.addTextNode();
+      this.outputBuilder.closeTag();
+      // Since the tag is closed now, parent tag comes in scope
+      this.currentTagDetail = this.tagsStack.pop(); 
+    }
+
+    validateClosingTag(tagName){
+      // This can't be unpaired tag, or a stop tag.
+      if(this.isUnpaired(tagName) || this.isStopNode(tagName)) throw new Error(`Unexpected closing tag '${tagName}'`);
+      // This must match with last opening tag
+      else if(tagName !== this.currentTagDetail.name) 
+        throw new Error(`Unexpected closing tag '${tagName}' expecting '${this.currentTagDetail.name}'`)
+    }
+
+    /**
+     * Read paired, unpaired, self-closing, stop and special tags.
+     * Create a new node
+     * Push paired tag in stack.
+     */
+    readOpeningTag(){
+      //save previously collected text data to current node
+      this.addTextNode();
+
+      //create new tag
+      let tagExp = readTagExp(this, ">" );
+      
+      // process and skip from tagsStack For unpaired tag, self closing tag, and stop node
+      const tagDetail = new TagDetail(tagExp.tagName);
+      if(this.isUnpaired(tagExp.tagName)) {
+        //TODO: this will lead 2 extra stack operation
+        this.outputBuilder.addTag(tagDetail);
+        this.outputBuilder.closeTag();
+      } else if(tagExp.selfClosing){
+        this.outputBuilder.addTag(tagDetail);
+        this.outputBuilder.closeTag();
+      } else if(this.isStopNode(this.currentTagDetail)){
+        // TODO: let's user set a stop node boundary detector for complex contents like script tag
+        //TODO: pass tag name only to avoid string operations
+        const content = source.readUptoCloseTag(`</${tagExp.tagName}`);
+        this.outputBuilder.addTag(tagDetail);
+        this.outputBuilder.addValue(content);
+        this.outputBuilder.closeTag();
+      }else{//paired tag
+        //set new nested tag in scope.
+        this.tagsStack.push(this.currentTagDetail);
+        this.outputBuilder.addTag(tagDetail);
+        this.currentTagDetail = tagDetail;
+      }
+      // console.log(tagExp.tagName,this.tagsStack.length);
+      // this.options.onClose()
+
+    }
+
+    readSpecialTag(startCh){
+      if(startCh == "!"){
+        let nextChar = this.source.readCh();
+        if (nextChar === null || nextChar === undefined) throw new Error("Unexpected ending of the source");
+        
+        if(nextChar === "-"){//comment
+          readComment(this);
+        }else if(nextChar === "["){//CDATA
+          readCdata(this);
+        }else if(nextChar === "D"){//DOCTYPE
+          readDocType(this);
+        }
+      }else if(startCh === "?"){
+        readPiTag(this);
+      }else{
+        throw new Error(`Invalid tag '<${startCh}' at ${this.source.line}:${this.source.col}`)
+      }
+    }
+    addTextNode = function() {
+      // if(this.currentTagDetail){
+        //save text as child node
+        // if(this.currentTagDetail.tagname !== '!xml')
+        if (this.tagTextData !== undefined && this.tagTextData !== "") { //store previously collected data as textNode
+          if(this.tagTextData.trim().length > 0){
+            //TODO: shift parsing to output builder
+
+            this.outputBuilder.addValue(this.replaceEntities(this.tagTextData));
+          }
+          this.tagTextData = "";
+        }
+      // }
+    }
+
+    processAttrName(name){
+      if(name === "__proto__") name  = "#__proto__";
+      name = resolveNameSpace(name, this.removeNSPrefix);
+      return name;
+    }
+    
+    processTagName(name){
+      if(name === "__proto__") name  = "#__proto__";
+      name = resolveNameSpace(name, this.removeNSPrefix);
+      return name;
+    }
+
+    /**
+     * Generate tags path from tagsStack
+     */
+    tagsPath(tagName){
+      //TODO: return TagPath Object. User can call match method with path
+      return "";
+    }
+
+    isUnpaired(tagName){
+      return this.options.tags.unpaired.indexOf(tagName) !== -1;
+    }
+
+    /**
+     * valid expressions are 
+     * tag nested
+     * * nested
+     * tag nested[attribute]
+     * tag nested[attribute=""]
+     * tag nested[attribute!=""]
+     * tag nested:0 //for future
+     * @param {string} tagName 
+     * @returns 
+     */
+    isStopNode(node){
+      for (let i = 0; i < this.stopNodes.length; i++) {
+        const givenPath = this.stopNodes[i];
+        if(givenPath.match(this.tagsStack, node)) return true;
+      }
+      return false 
+    }
+
+    replaceEntities(text){
+      //TODO: if option is set then replace entities
+      return this.entityParser.parse(text)
+    }
+}
+
+function resolveNameSpace(name, removeNSPrefix) {
+  if (removeNSPrefix) {
+    const parts = name.split(':');
+    if(parts.length === 2){
+      if (parts[0] === 'xmlns') return '';
+      else return parts[1];
+    }else reportError(`Multiple namespaces ${name}`)
+  }
+  return name;
+}
+
+module.exports = Xml2JsParser;