node-red-contrib-tak-registration 0.7.2 → 0.8.0

package/node_modules/fast-xml-parser/{cli.js → src/cli/cli.js}

@@ -3,26 +3,19 @@
 /*eslint-disable no-console*/
 const fs = require('fs');
 const path = require('path');
-const parser = require('./src/parser');
-const readToEnd = require('./src/read').readToEnd;
+const {XMLParser, XMLValidator} = require("../fxp");
+const readToEnd = require('./read').readToEnd;
 
+const version = require('./../../package.json').version;
 if (process.argv[2] === '--help' || process.argv[2] === '-h') {
-  console.log('Fast XML Parser ' + require(path.join(__dirname + '/package.json')).version);
-  console.log('----------------');
-  console.log('xml2js [-ns|-a|-c|-v|-V] <filename> [-o outputfile.json]');
-  console.log('cat xmlfile.xml | xml2js [-ns|-a|-c|-v|-V] [-o outputfile.json]');
-  console.log('-ns: remove namespace from tag and atrribute name.');
-  console.log("-a: don't parse attributes.");
-  console.log('-c: parse values to premitive type.');
-  console.log('-v: validate before parsing.');
-  console.log('-V: validate only.');
+  console.log(require("./man"));
 } else if (process.argv[2] === '--version') {
-  console.log(require(path.join(__dirname + '/package.json')).version);
+  console.log(version);
 } else {
   const options = {
-    ignoreNameSpace: true,
+    removeNSPrefix: true,
     ignoreAttributes: false,
-    parseNodeValue: true,
+    parseTagValue: true,
     parseAttributeValue: true,
   };
   let fileName = '';
@@ -31,11 +24,11 @@ if (process.argv[2] === '--help' || process.argv[2] === '-h') {
   let validateOnly = false;
   for (let i = 2; i < process.argv.length; i++) {
     if (process.argv[i] === '-ns') {
-      options.ignoreNameSpace = false;
+      options.removeNSPrefix = false;
     } else if (process.argv[i] === '-a') {
       options.ignoreAttributes = true;
     } else if (process.argv[i] === '-c') {
-      options.parseNodeValue = false;
+      options.parseTagValue = false;
       options.parseAttributeValue = false;
     } else if (process.argv[i] === '-o') {
       outputFileName = process.argv[++i];
@@ -48,20 +41,18 @@ if (process.argv[2] === '--help' || process.argv[2] === '-h') {
       fileName = process.argv[i];
     }
   }
+  
   const callback = function(xmlData) {
     let output = '';
     if (validate) {
-      const result = parser.validate(xmlData);
-      if (result === true) {
-        output = JSON.stringify(parser.parse(xmlData, options), null, 4);
-      } else {
-        output = result;
-      }
+      const parser = new XMLParser(options);
+      output = parser.parse(xmlData,validate);
     } else if (validateOnly) {
-      output = parser.validate(xmlData);
+      output = XMLValidator.validate(xmlData);
       process.exitCode = output === true ? 0 : 1;
     } else {
-      output = JSON.stringify(parser.parse(xmlData, options), null, 4);
+      const parser = new XMLParser(options);
+      output = JSON.stringify(parser.parse(xmlData,validate), null, 4);
     }
     if (outputFileName) {
       writeToFile(outputFileName, output);
@@ -71,6 +62,7 @@ if (process.argv[2] === '--help' || process.argv[2] === '-h') {
   };
 
   try {
+    
     if (!fileName) {
       readToEnd(process.stdin, function(err, data) {
         if (err) {

package/node_modules/fast-xml-parser/src/cli/man.js

@@ -0,0 +1,12 @@
+module.exports = `Fast XML Parser 4.0.0
+----------------
+$ fxparser [-ns|-a|-c|-v|-V] <filename> [-o outputfile.json]
+$ cat xmlfile.xml | fxparser [-ns|-a|-c|-v|-V] [-o outputfile.json]
+
+Options
+----------------
+-ns: remove namespace from tag and atrribute name.
+-a: don't parse attributes.
+-c: parse values to premitive type.
+-v: validate before parsing.
+-V: validate only.`

package/node_modules/fast-xml-parser/src/fxp.d.ts

@@ -0,0 +1,108 @@
+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;
+    /**
+Control how tag value should be parsed. Called only if tag value is not empty
+
+@returns {undefined|null} `undefined` or `null` to set original value.
+@returns {unknown} 
+1. Different value or value with different data type to set new value. <br>
+2. Same value to set parsed value if `parseTagValue: true`.
+   */
+  tagValueProcessor: (tagName: string, tagValue: string, jPath: string, hasAttributes: boolean, isLeafNode: boolean) => unknown;
+  attributeValueProcessor: (attrName: string, attrValue: string, jPath: string) => unknown;
+  numberParseOptions: strnumOptions;
+  stopNodes: string[];
+  unpairedTags: string[];
+  alwaysCreateTextNode: boolean;
+  isArray: (tagName: string, jPath: string, isLeafNode: boolean, isAttribute: boolean) => boolean;
+  processEntities: boolean;
+  htmlEntities: boolean;
+  ignoreDeclaration: boolean;
+  ignorePiTags: boolean;
+  transformTagName: ((tagName: string) => string) | false;
+  transformAttributeName: ((attributeName: string) => string) | false;
+    /**
+Change the tag name when a different name is returned. Skip the tag from parsed result when false is returned. 
+Modify `attrs` object to control attributes for the given tag.
+
+@returns {string} new tag name.
+@returns false to skip the tag
+   */
+  updateTag: (tagName: string, jPath: string, attrs: {[k: string]: string}) =>  string | boolean;
+};
+type strnumOptions = {
+  hex: boolean;
+  leadingZeros: boolean,
+  skipLike?: RegExp,
+  eNotation?: boolean
+}
+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;
+  suppressUnpairedNode: boolean;
+  suppressBooleanAttributes: boolean;
+  preserveOrder: boolean;
+  unpairedTags: string[];
+  stopNodes: string[];
+  tagValueProcessor: (name: string, value: unknown) => string;
+  attributeValueProcessor: (name: string, value: unknown) => string;
+  processEntities: boolean;
+  oneListGroup: 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;
+  /**
+   * Add Entity which is not by default supported by this library
+   * @param entityIndentifier {string} Eg: 'ent' for &ent;
+   * @param entityValue {string} Eg: '\r'
+   */
+  addEntity(entityIndentifier: string, entityValue: string): void;
+}
+
+export class XMLValidator{
+  static validate(  xmlData: string,  options?: validationOptionsOptional): true | ValidationError;
+}
+export class XMLBuilder {
+  constructor(options?: XmlBuilderOptionsOptional);
+  build(jObj: any): any;
+}

package/node_modules/fast-xml-parser/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/node_modules/fast-xml-parser/src/util.js

@@ -67,42 +67,6 @@ exports.getValue = function(v) {
 // const fakeCall = function(a) {return a;};
 // const fakeCallNoReturn = function() {};
 
-exports.buildOptions = function(options, defaultOptions, props) {
-  let newOptions = {};
-  if (!options) {
-    return defaultOptions; //if there are not options
-  }
-
-  for (let i = 0; i < props.length; i++) {
-    if (options[props[i]] !== undefined) {
-      newOptions[props[i]] = options[props[i]];
-    } else {
-      newOptions[props[i]] = defaultOptions[props[i]];
-    }
-  }
-  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.isName = isName;
 exports.getAllMatches = getAllMatches;
 exports.nameRegexp = nameRegexp;

package/node_modules/fast-xml-parser/src/validator.js

@@ -4,13 +4,12 @@ const util = require('./util');
 
 const defaultOptions = {
   allowBooleanAttributes: false, //A tag can have attributes without any value
+  unpairedTags: []
 };
 
-const props = ['allowBooleanAttributes'];
-
 //const tagsPattern = new RegExp("<\\/?([\\w:\\-_\.]+)\\s*\/?>","g");
 exports.validate = function (xmlData, options) {
-  options = util.buildOptions(options, defaultOptions, props);
+  options = Object.assign({}, defaultOptions, options);
 
   //xmlData = xmlData.replace(/(\r\n|\n|\r)/gm,"");//make it single line
   //xmlData = xmlData.replace(/(^\s*<\?xml.*?\?>)/g,"");//Remove XML starting tag
@@ -25,7 +24,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 +129,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 +157,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 +168,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 +188,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
@@ -318,6 +326,8 @@ function validateAttributeString(attrStr, options) {
     if (matches[i][1].length === 0) {
       //nospace before attribute name: a="sd"b="saf"
       return getErrorObject('InvalidAttr', "Attribute '"+matches[i][2]+"' has no space in starting.", getPositionFromMatch(matches[i]))
+    } else if (matches[i][3] !== undefined && matches[i][4] === undefined) {
+      return getErrorObject('InvalidAttr', "Attribute '"+matches[i][2]+"' is without value.", getPositionFromMatch(matches[i]));
     } else if (matches[i][3] === undefined && !options.allowBooleanAttributes) {
       //independent attribute: ab
       return getErrorObject('InvalidAttr', "boolean attribute '"+matches[i][2]+"' is not allowed.", getPositionFromMatch(matches[i]));

package/node_modules/fast-xml-parser/src/xmlbuilder/json2xml.js

@@ -0,0 +1,269 @@
+'use strict';
+//parse Empty Node as self closing node
+const buildFromOrderedJs = require('./orderedJs2Xml');
+
+const defaultOptions = {
+  attributeNamePrefix: '@_',
+  attributesGroupName: false,
+  textNodeName: '#text',
+  ignoreAttributes: true,
+  cdataPropName: false,
+  format: false,
+  indentBy: '  ',
+  suppressEmptyNode: false,
+  suppressUnpairedNode: true,
+  suppressBooleanAttributes: true,
+  tagValueProcessor: function(key, a) {
+    return a;
+  },
+  attributeValueProcessor: function(attrName, a) {
+    return a;
+  },
+  preserveOrder: false,
+  commentPropName: false,
+  unpairedTags: [],
+  entities: [
+    { regex: new RegExp("&", "g"), val: "&" },//it must be on top
+    { regex: new RegExp(">", "g"), val: ">" },
+    { regex: new RegExp("<", "g"), val: "&lt;" },
+    { regex: new RegExp("\'", "g"), val: "&apos;" },
+    { regex: new RegExp("\"", "g"), val: "&quot;" }
+  ],
+  processEntities: true,
+  stopNodes: [],
+  // transformTagName: false,
+  // transformAttributeName: false,
+  oneListGroup: false
+};
+
+function Builder(options) {
+  this.options = Object.assign({}, defaultOptions, options);
+  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 = '';
+  }
+}
+
+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 only if it is not an attribute
+      if (this.isAttribute(key)) {
+        val += '';
+      }
+    } else if (jObj[key] === null) {
+      // null attribute should be ignored by the attribute list, but should not cause the tag closing
+      if (this.isAttribute(key)) {
+        val += '';
+      } else if (key[0] === '?') {
+        val += this.indentate(level) + '<' + key + '?' + this.tagEndChar;
+      } else {
+        val += this.indentate(level) + '<' + key + '/' + this.tagEndChar;
+      }
+      // val += this.indentate(level) + '<' + key + '/' + this.tagEndChar;
+    } else if (jObj[key] instanceof Date) {
+      val += this.buildTextValNode(jObj[key], key, '', level);
+    } else if (typeof jObj[key] !== 'object') {
+      //premitive type
+      const attr = this.isAttribute(key);
+      if (attr) {
+        attrStr += this.buildAttrPairStr(attr, '' + jObj[key]);
+      }else {
+        //tag value
+        if (key === this.options.textNodeName) {
+          let newval = this.options.tagValueProcessor(key, '' + jObj[key]);
+          val += this.replaceEntitiesValue(newval);
+        } else {
+          val += this.buildTextValNode(jObj[key], key, '', level);
+        }
+      }
+    } else if (Array.isArray(jObj[key])) {
+      //repeated nodes
+      const arrLen = jObj[key].length;
+      let listTagVal = "";
+      for (let j = 0; j < arrLen; j++) {
+        const item = jObj[key][j];
+        if (typeof item === 'undefined') {
+          // supress undefined node
+        } else if (item === null) {
+          if(key[0] === "?") val += this.indentate(level) + '<' + key + '?' + this.tagEndChar;
+          else val += this.indentate(level) + '<' + key + '/' + this.tagEndChar;
+          // val += this.indentate(level) + '<' + key + '/' + this.tagEndChar;
+        } else if (typeof item === 'object') {
+          if(this.options.oneListGroup ){
+            listTagVal += this.j2x(item, level + 1).val;
+          }else{
+            listTagVal += this.processTextOrObjNode(item, key, level)
+          }
+        } else {
+          listTagVal += this.buildTextValNode(item, key, '', level);
+        }
+      }
+      if(this.options.oneListGroup){
+        listTagVal = this.buildObjectNode(listTagVal, key, '', level);
+      }
+      val += listTagVal;
+    } 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++) {
+          attrStr += this.buildAttrPairStr(Ks[j], '' + jObj[key][Ks[j]]);
+        }
+      } else {
+        val += this.processTextOrObjNode(jObj[key], key, level)
+      }
+    }
+  }
+  return {attrStr: attrStr, val: val};
+};
+
+Builder.prototype.buildAttrPairStr = function(attrName, val){
+  val = this.options.attributeValueProcessor(attrName, '' + val);
+  val = this.replaceEntitiesValue(val);
+  if (this.options.suppressBooleanAttributes && val === "true") {
+    return ' ' + attrName;
+  } else return ' ' + attrName + '="' + 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.buildTextValNode(object[this.options.textNodeName], key, result.attrStr, level);
+  } else {
+    return this.buildObjectNode(result.val, key, result.attrStr, level);
+  }
+}
+
+Builder.prototype.buildObjectNode = function(val, key, attrStr, level) {
+  if(val === ""){
+    if(key[0] === "?") return  this.indentate(level) + '<' + key + attrStr+ '?' + this.tagEndChar;
+    else {
+      return this.indentate(level) + '<' + key + attrStr + this.closeTag(key) + this.tagEndChar;
+    }
+  }else{
+
+    let tagEndExp = '</' + key + this.tagEndChar;
+    let piClosingChar = "";
+    
+    if(key[0] === "?") {
+      piClosingChar = "?";
+      tagEndExp = "";
+    }
+  
+    // attrStr is an empty string in case the attribute came as undefined or null
+    if ((attrStr || attrStr === '') && val.indexOf('<') === -1) {
+      return ( this.indentate(level) + '<' +  key + attrStr + piClosingChar + '>' + val + tagEndExp );
+    } else if (this.options.commentPropName !== false && key === this.options.commentPropName && piClosingChar.length === 0) {
+      return this.indentate(level) + `<!--${val}-->` + this.newLine;
+    }else {
+      return (
+        this.indentate(level) + '<' + key + attrStr + piClosingChar + this.tagEndChar +
+        val +
+        this.indentate(level) + tagEndExp    );
+    }
+  }
+}
+
+Builder.prototype.closeTag = function(key){
+  let closeTag = "";
+  if(this.options.unpairedTags.indexOf(key) !== -1){ //unpaired
+    if(!this.options.suppressUnpairedNode) closeTag = "/"
+  }else if(this.options.suppressEmptyNode){ //empty
+    closeTag = "/";
+  }else{
+    closeTag = `></${key}`
+  }
+  return closeTag;
+}
+
+function buildEmptyObjNode(val, key, attrStr, level) {
+  if (val !== '') {
+    return this.buildObjectNode(val, key, attrStr, level);
+  } else {
+    if(key[0] === "?") return  this.indentate(level) + '<' + key + attrStr+ '?' + this.tagEndChar;
+    else {
+      return  this.indentate(level) + '<' + key + attrStr + '/' + this.tagEndChar;
+      // return this.buildTagStr(level,key, attrStr);
+    }
+  }
+}
+
+Builder.prototype.buildTextValNode = function(val, key, attrStr, level) {
+  if (this.options.cdataPropName !== false && key === this.options.cdataPropName) {
+    return this.indentate(level) + `<![CDATA[${val}]]>` +  this.newLine;
+  }else if (this.options.commentPropName !== false && key === this.options.commentPropName) {
+    return this.indentate(level) + `<!--${val}-->` +  this.newLine;
+  }else if(key[0] === "?") {//PI tag
+    return  this.indentate(level) + '<' + key + attrStr+ '?' + this.tagEndChar; 
+  }else{
+    let textValue = this.options.tagValueProcessor(key, val);
+    textValue = this.replaceEntitiesValue(textValue);
+  
+    if( textValue === ''){
+      return this.indentate(level) + '<' + key + attrStr + this.closeTag(key) + this.tagEndChar;
+    }else{
+      return this.indentate(level) + '<' + key + attrStr + '>' +
+         textValue +
+        '</' + key + this.tagEndChar;
+    }
+  }
+}
+
+Builder.prototype.replaceEntitiesValue = function(textValue){
+  if(textValue && textValue.length > 0 && this.options.processEntities){
+    for (let i=0; i<this.options.entities.length; i++) {
+      const entity = this.options.entities[i];
+      textValue = textValue.replace(entity.regex, entity.val);
+    }
+  }
+  return textValue;
+}
+
+function indentate(level) {
+  return this.options.indentBy.repeat(level);
+}
+
+function isAttribute(name /*, options*/) {
+  if (name.startsWith(this.options.attributeNamePrefix) && name !== this.options.textNodeName) {
+    return name.substr(this.attrPrefixLen);
+  } else {
+    return false;
+  }
+}
+
+module.exports = Builder;