devbrain-cli 0.1.0 → 0.3.0

package/dist/temp-prefix/node_modules/devbrain-cli/node_modules/fast-xml-parser/src/v6/OutputBuilders/JsObjBuilder.js

@@ -0,0 +1,154 @@
+
+
+import { buildOptions, registerCommonValueParsers } from './ParserOptionsBuilder.js';
+
+export default class OutputBuilder {
+  constructor(builderOptions) {
+    this.options = buildOptions(builderOptions);
+    this.registeredParsers = registerCommonValueParsers(this.options);
+  }
+
+  registerValueParser(name, parserInstance) {//existing name will override the parser without warning
+    this.registeredParsers[name] = parserInstance;
+  }
+
+  getInstance(parserOptions) {
+    return new JsObjBuilder(parserOptions, this.options, this.registeredParsers);
+  }
+}
+
+import BaseOutputBuilder from './BaseOutputBuilder.js';
+const rootName = '^';
+
+class JsObjBuilder extends BaseOutputBuilder {
+
+  constructor(parserOptions, builderOptions, registeredParsers) {
+    super();
+    //hold the raw detail of a tag and sequence with reference to the output
+    this.tagsStack = [];
+    this.parserOptions = parserOptions;
+    this.options = builderOptions;
+    this.registeredParsers = registeredParsers;
+
+    this.root = {};
+    this.parent = this.root;
+    this.tagName = rootName;
+    this.value = {};
+    this.textValue = "";
+    this.attributes = {};
+  }
+
+  addTag(tag) {
+
+    let value = "";
+    if (!isEmpty(this.attributes)) {
+      value = {};
+      if (this.options.attributes.groupBy) {
+        value[this.options.attributes.groupBy] = this.attributes;
+      } else {
+        value = this.attributes;
+      }
+    }
+
+    this.tagsStack.push([this.tagName, this.textValue, this.value]); //parent tag, parent text value, parent tag value (jsobj)
+    this.tagName = tag.name;
+    this.value = value;
+    this.textValue = "";
+    this.attributes = {};
+  }
+
+  /**
+   * Check if the node should be added by checking user's preference
+   * @param {Node} node 
+   * @returns boolean: true if the node should not be added
+   */
+  closeTag() {
+    const tagName = this.tagName;
+    let value = this.value;
+    let textValue = this.textValue;
+
+    //update tag text value
+    if (typeof value !== "object" && !Array.isArray(value)) {
+      value = this.parseValue(textValue.trim(), this.options.tags.valueParsers);
+    } else if (textValue.length > 0) {
+      value[this.options.nameFor.text] = this.parseValue(textValue.trim(), this.options.tags.valueParsers);
+    }
+
+
+    let resultTag = {
+      tagName: tagName,
+      value: value
+    };
+
+    if (this.options.onTagClose !== undefined) {
+      //TODO TagPathMatcher 
+      resultTag = this.options.onClose(tagName, value, this.textValue, new TagPathMatcher(this.tagsStack, node));
+
+      if (!resultTag) return;
+    }
+
+    //set parent node in scope
+    let arr = this.tagsStack.pop();
+    let parentTag = arr[2];
+    parentTag = this._addChildTo(resultTag.tagName, resultTag.value, parentTag);
+
+    this.tagName = arr[0];
+    this.textValue = arr[1];
+    this.value = parentTag;
+  }
+
+  _addChild(key, val) {
+    if (typeof this.value === "string") {
+      this.value = { [this.options.nameFor.text]: this.value };
+    }
+
+    this._addChildTo(key, val, this.value);
+    // this.currentNode.leafType = false;
+    this.attributes = {};
+  }
+
+  _addChildTo(key, val, node) {
+    if (typeof node === 'string') node = {};
+    if (!node[key]) {
+      node[key] = val;
+    } else { //Repeated
+      if (!Array.isArray(node[key])) { //but not stored as array
+        node[key] = [node[key]];
+      }
+      node[key].push(val);
+    }
+    return node;
+  }
+
+
+  /**
+   * Add text value child node 
+   * @param {string} text 
+   */
+  addValue(text) {
+    //TODO: use bytes join
+    if (this.textValue.length > 0) this.textValue += " " + text;
+    else this.textValue = text;
+  }
+
+  addPi(name) {
+    let value = "";
+    if (!isEmpty(this.attributes)) {
+      value = {};
+      if (this.options.attributes.groupBy) {
+        value[this.options.attributes.groupBy] = this.attributes;
+      } else {
+        value = this.attributes;
+      }
+    }
+    this._addChild(name, value);
+
+  }
+  getOutput() {
+    return this.value;
+  }
+}
+
+function isEmpty(obj) {
+  return Object.keys(obj).length === 0;
+}

package/dist/temp-prefix/node_modules/devbrain-cli/node_modules/fast-xml-parser/src/v6/OutputBuilders/ParserOptionsBuilder.js

@@ -0,0 +1,94 @@
+import trimParser from "../valueParsers/trim.js";
+import booleanParser from "../valueParsers/booleanParser.js";
+import currencyParser from "../valueParsers/currency.js";
+import numberParser from "../valueParsers/number.js";
+
+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",
+    ]
+  },
+  dataType: {
+
+  }
+}
+
+//TODO
+const withJoin = ["trim", "join", /*"entities",*/"number", "boolean", "currency"/*, "date"*/]
+const withoutJoin = ["trim", /*"entities",*/"number", "boolean", "currency"/*, "date"*/]
+
+export 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 (Object.prototype.hasOwnProperty.call(source, 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];
+      }
+    }
+  }
+}
+
+export function registerCommonValueParsers(options) {
+  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,
+  }
+}

package/dist/temp-prefix/node_modules/devbrain-cli/node_modules/fast-xml-parser/src/v6/TagPath.js

@@ -0,0 +1,81 @@
+export default 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/dist/temp-prefix/node_modules/devbrain-cli/node_modules/fast-xml-parser/src/v6/TagPathMatcher.js

@@ -0,0 +1,13 @@
+import {TagPath} from './TagPath.js';
+
+export default 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);
+  }
+}

package/dist/temp-prefix/node_modules/devbrain-cli/node_modules/fast-xml-parser/src/v6/XMLParser.js

@@ -0,0 +1,83 @@
+import { buildOptions } from './OptionsBuilder.js';
+import Xml2JsParser from './Xml2JsParser.js';
+
+export default 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;
+}

package/dist/temp-prefix/node_modules/devbrain-cli/node_modules/fast-xml-parser/src/v6/Xml2JsParser.js

@@ -0,0 +1,235 @@
+import StringSource from './inputSource/StringSource.js';
+import BufferSource from './inputSource/BufferSource.js';
+import {readTagExp,readClosingTagName} from './XmlPartReader.js';
+import {readComment, readCdata,readDocType,readPiTag} from './XmlSpecialTagsReader.js';
+import TagPath from './TagPath.js';
+import TagPathMatcher from './TagPathMatcher.js';
+import EntitiesParser from './EntitiesParser.js';
+
+//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 = {};
+  }
+}
+
+export default 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;
+}