befly 0.1.26

package/libs/xml/node2json.js

@@ -0,0 +1,114 @@
+'use strict';
+
+import XmlNode from './xmlNode.js';
+
+const METADATA_SYMBOL = XmlNode.getMetaDataSymbol();
+
+/**
+ *
+ * @param {array} node
+ * @param {any} options
+ * @returns
+ */
+export default function prettify(node, options) {
+    return compress(node, options);
+}
+
+/**
+ *
+ * @param {array} arr
+ * @param {object} options
+ * @param {string} jPath
+ * @returns object
+ */
+function compress(arr, options, jPath) {
+    let text;
+    const compressedObj = {};
+    for (let i = 0; i < arr.length; i++) {
+        const tagObj = arr[i];
+        const property = propName(tagObj);
+        let newJpath = '';
+        if (jPath === undefined) newJpath = property;
+        else newJpath = jPath + '.' + property;
+
+        if (property === options.textNodeName) {
+            if (text === undefined) text = tagObj[property];
+            else text += '' + tagObj[property];
+        } else if (property === undefined) {
+            continue;
+        } else if (tagObj[property]) {
+            let val = compress(tagObj[property], options, newJpath);
+            const isLeaf = isLeafTag(val, options);
+            if (tagObj[METADATA_SYMBOL] !== undefined) {
+                val[METADATA_SYMBOL] = tagObj[METADATA_SYMBOL]; // copy over metadata
+            }
+
+            if (tagObj[':@']) {
+                assignAttributes(val, tagObj[':@'], newJpath, options);
+            } else if (Object.keys(val).length === 1 && val[options.textNodeName] !== undefined && !options.alwaysCreateTextNode) {
+                val = val[options.textNodeName];
+            } else if (Object.keys(val).length === 0) {
+                if (options.alwaysCreateTextNode) val[options.textNodeName] = '';
+                else val = '';
+            }
+
+            if (compressedObj[property] !== undefined && compressedObj.hasOwnProperty(property)) {
+                if (!Array.isArray(compressedObj[property])) {
+                    compressedObj[property] = [compressedObj[property]];
+                }
+                compressedObj[property].push(val);
+            } else {
+                //TODO: if a node is not an array, then check if it should be an array
+                //also determine if it is a leaf node
+                if (options.isArray(property, newJpath, isLeaf)) {
+                    compressedObj[property] = [val];
+                } else {
+                    compressedObj[property] = val;
+                }
+            }
+        }
+    }
+    // if(text && text.length > 0) compressedObj[options.textNodeName] = text;
+    if (typeof text === 'string') {
+        if (text.length > 0) compressedObj[options.textNodeName] = text;
+    } else if (text !== undefined) compressedObj[options.textNodeName] = text;
+    return compressedObj;
+}
+
+function propName(obj) {
+    const keys = Object.keys(obj);
+    for (let i = 0; i < keys.length; i++) {
+        const key = keys[i];
+        if (key !== ':@') return key;
+    }
+}
+
+function assignAttributes(obj, attrMap, jpath, options) {
+    if (attrMap) {
+        const keys = Object.keys(attrMap);
+        const len = keys.length; //don't make it inline
+        for (let i = 0; i < len; i++) {
+            const atrrName = keys[i];
+            if (options.isArray(atrrName, jpath + '.' + atrrName, true, true)) {
+                obj[atrrName] = [attrMap[atrrName]];
+            } else {
+                obj[atrrName] = attrMap[atrrName];
+            }
+        }
+    }
+}
+
+function isLeafTag(obj, options) {
+    const { textNodeName } = options;
+    const propCount = Object.keys(obj).length;
+
+    if (propCount === 0) {
+        return true;
+    }
+
+    if (propCount === 1 && (obj[textNodeName] || typeof obj[textNodeName] === 'boolean' || obj[textNodeName] === 0)) {
+        return true;
+    }
+
+    return false;
+}

package/libs/xml/strnum.js

@@ -0,0 +1,134 @@
+const hexRegex = /^[-+]?0x[a-fA-F0-9]+$/;
+const numRegex = /^([\-\+])?(0*)([0-9]*(\.[0-9]*)?)$/;
+// const octRegex = /^0x[a-z0-9]+/;
+// const binRegex = /0x[a-z0-9]+/;
+
+const consider = {
+    hex: true,
+    // oct: false,
+    leadingZeros: true,
+    decimalPoint: '.',
+    eNotation: true
+    //skipLike: /regex/
+};
+
+export default function toNumber(str, options = {}) {
+    options = Object.assign({}, consider, options);
+    if (!str || typeof str !== 'string') return str;
+
+    let trimmedStr = str.trim();
+
+    if (options.skipLike !== undefined && options.skipLike.test(trimmedStr)) return str;
+    else if (str === '0') return 0;
+    else if (options.hex && hexRegex.test(trimmedStr)) {
+        return parse_int(trimmedStr, 16);
+        // }else if (options.oct && octRegex.test(str)) {
+        //     return Number.parseInt(val, 8);
+    } else if (trimmedStr.search(/.+[eE].+/) !== -1) {
+        //eNotation
+        return resolveEnotation(str, trimmedStr, options);
+        // }else if (options.parseBin && binRegex.test(str)) {
+        //     return Number.parseInt(val, 2);
+    } else {
+        //separate negative sign, leading zeros, and rest number
+        const match = numRegex.exec(trimmedStr);
+        // +00.123 => [ , '+', '00', '.123', ..
+        if (match) {
+            const sign = match[1] || '';
+            const leadingZeros = match[2];
+            let numTrimmedByZeros = trimZeros(match[3]); //complete num without leading zeros
+            const decimalAdjacentToLeadingZeros = sign // 0., -00., 000.
+                ? str[leadingZeros.length + 1] === '.'
+                : str[leadingZeros.length] === '.';
+
+            //trim ending zeros for floating number
+            if (
+                !options.leadingZeros && //leading zeros are not allowed
+                (leadingZeros.length > 1 || (leadingZeros.length === 1 && !decimalAdjacentToLeadingZeros))
+            ) {
+                // 00, 00.3, +03.24, 03, 03.24
+                return str;
+            } else {
+                //no leading zeros or leading zeros are allowed
+                const num = Number(trimmedStr);
+                const parsedStr = String(num);
+
+                if (num === 0) return num;
+                if (parsedStr.search(/[eE]/) !== -1) {
+                    //given number is long and parsed to eNotation
+                    if (options.eNotation) return num;
+                    else return str;
+                } else if (trimmedStr.indexOf('.') !== -1) {
+                    //floating number
+                    if (parsedStr === '0') return num; //0.0
+                    else if (parsedStr === numTrimmedByZeros) return num; //0.456. 0.79000
+                    else if (parsedStr === `${sign}${numTrimmedByZeros}`) return num;
+                    else return str;
+                }
+
+                let n = leadingZeros ? numTrimmedByZeros : trimmedStr;
+                if (leadingZeros) {
+                    // -009 => -9
+                    return n === parsedStr || sign + n === parsedStr ? num : str;
+                } else {
+                    // +9
+                    return n === parsedStr || n === sign + parsedStr ? num : str;
+                }
+            }
+        } else {
+            //non-numeric string
+            return str;
+        }
+    }
+}
+
+const eNotationRegx = /^([-+])?(0*)(\d*(\.\d*)?[eE][-\+]?\d+)$/;
+function resolveEnotation(str, trimmedStr, options) {
+    if (!options.eNotation) return str;
+    const notation = trimmedStr.match(eNotationRegx);
+    if (notation) {
+        let sign = notation[1] || '';
+        const eChar = notation[3].indexOf('e') === -1 ? 'E' : 'e';
+        const leadingZeros = notation[2];
+        const eAdjacentToLeadingZeros = sign // 0E.
+            ? str[leadingZeros.length + 1] === eChar
+            : str[leadingZeros.length] === eChar;
+
+        if (leadingZeros.length > 1 && eAdjacentToLeadingZeros) return str;
+        else if (leadingZeros.length === 1 && (notation[3].startsWith(`.${eChar}`) || notation[3][0] === eChar)) {
+            return Number(trimmedStr);
+        } else if (options.leadingZeros && !eAdjacentToLeadingZeros) {
+            //accept with leading zeros
+            //remove leading 0s
+            trimmedStr = (notation[1] || '') + notation[3];
+            return Number(trimmedStr);
+        } else return str;
+    } else {
+        return str;
+    }
+}
+
+/**
+ *
+ * @param {string} numStr without leading zeros
+ * @returns
+ */
+function trimZeros(numStr) {
+    if (numStr && numStr.indexOf('.') !== -1) {
+        //float
+        numStr = numStr.replace(/0+$/, ''); //remove ending zeros
+        if (numStr === '.') numStr = '0';
+        else if (numStr[0] === '.') numStr = '0' + numStr;
+        else if (numStr[numStr.length - 1] === '.') numStr = numStr.substring(0, numStr.length - 1);
+        return numStr;
+    }
+    return numStr;
+}
+
+function parse_int(numStr, base) {
+    //polyfill
+    if (parseInt) return parseInt(numStr, base);
+    else if (Number.parseInt) return Number.parseInt(numStr, base);
+    else if (window && window.parseInt) return window.parseInt(numStr, base);
+    else throw new Error('parseInt, Number.parseInt, window.parseInt are not supported');
+}

package/libs/xml/util.js

@@ -0,0 +1,68 @@
+'use strict';
+
+const nameStartChar = ':A-Za-z_\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD';
+const nameChar = nameStartChar + '\\-.\\d\\u00B7\\u0300-\\u036F\\u203F-\\u2040';
+export const nameRegexp = '[' + nameStartChar + '][' + nameChar + ']*';
+const regexName = new RegExp('^' + nameRegexp + '$');
+
+export function getAllMatches(string, regex) {
+  const matches = [];
+  let match = regex.exec(string);
+  while (match) {
+    const allmatches = [];
+    allmatches.startIndex = regex.lastIndex - match[0].length;
+    const len = match.length;
+    for (let index = 0; index < len; index++) {
+      allmatches.push(match[index]);
+    }
+    matches.push(allmatches);
+    match = regex.exec(string);
+  }
+  return matches;
+}
+
+export const isName = function(string) {
+  const match = regexName.exec(string);
+  return !(match === null || typeof match === 'undefined');
+}
+
+export function isExist(v) {
+  return typeof v !== 'undefined';
+}
+
+export function isEmptyObject(obj) {
+  return Object.keys(obj).length === 0;
+}
+
+/**
+ * Copy all the properties of a into b.
+ * @param {*} target
+ * @param {*} a
+ */
+export function merge(target, a, arrayMode) {
+  if (a) {
+    const keys = Object.keys(a); // will return an array of own properties
+    const len = keys.length; //don't make it inline
+    for (let i = 0; i < len; i++) {
+      if (arrayMode === 'strict') {
+        target[keys[i]] = [ a[keys[i]] ];
+      } else {
+        target[keys[i]] = a[keys[i]];
+      }
+    }
+  }
+}
+/* exports.merge =function (b,a){
+  return Object.assign(b,a);
+} */
+
+export function getValue(v) {
+  if (exports.isExist(v)) {
+    return v;
+  } else {
+    return '';
+  }
+}
+
+// const fakeCall = function(a) {return a;};
+// const fakeCallNoReturn = function() {};