@vbarbarosh/node-helpers 3.29.0 → 3.29.1

package/package.json

@@ -2,7 +2,7 @@
     "author": "Vladimir Barbarosh <vladimir.barbarosh@gmail.com>",
     "license": "MIT",
     "name": "@vbarbarosh/node-helpers",
-    "version": "3.29.0",
+    "version": "3.29.1",
     "description": "A set of helpers for JavaScript/Node.js",
     "files": [
         "src"

package/src/const_stream.js

@@ -0,0 +1,8 @@
+// Since Node.js streams cannot emit `null` values (it's an eof mark),
+// this is a workaround.
+
+const const_stream = {
+    null: Symbol('stream[null]'),
+};
+
+module.exports = const_stream;

package/src/object_schema.js

@@ -0,0 +1,22 @@
+const const_type = require('./const_type');
+const gettype = require('./gettype');
+const json_stringify_stable = require('./json_stringify_stable');
+
+function object_schema(obj)
+{
+    const type = gettype(obj);
+    switch (type) {
+    case const_type.array:
+        return obj.map(object_schema).map(v => json_stringify_stable(v)).sort().filter((v,i,a) => a[i-1] !== v).map(v => JSON.parse(v));
+    case const_type.object:
+        const out = {};
+        Object.keys(obj).forEach(function (key) {
+            out[key] = object_schema(obj[key]);
+        });
+        return out;
+    default:
+        return type;
+    }
+}
+
+module.exports = object_schema;

package/src/object_schema.test.js

@@ -0,0 +1,15 @@
+const assert = require('assert');
+const object_schema = require('./object_schema');
+
+describe('object_schema', function () {
+    it('basic 1', function () {
+        const actual = object_schema({aaa: 1, bbb: 2});
+        const expected = {aaa: 'number', bbb: 'number'};
+        assert.deepStrictEqual(actual, expected);
+    });
+    it('basic 2', function () {
+        const actual = object_schema({aaa: 1, bbb: [1, 2, 3, 4, 'str']});
+        const expected = {aaa: 'number', bbb: ['number', 'string']};
+        assert.deepStrictEqual(actual, expected);
+    });
+});

package/src/stream_parse_xml.js

@@ -1,10 +1,11 @@
-const stream = require('stream');
+const const_stream = require('./const_stream');
 const htmlparser2 = require('htmlparser2');
+const stream = require('stream');
 
 /**
- * Parse XML stream and produce objects.
+ * Consume XML, produce objects.
  */
-function stream_parse_xml(selector, mapper = stream_parse_xml.makeobj)
+function stream_parse_xml(selector, mapper = stream_parse_xml.guess)
 {
     let out;
     let elem = {name: '#doc', parent: null, attrs: {}, text: [], children: [], raw: []};
@@ -17,16 +18,15 @@ function stream_parse_xml(selector, mapper = stream_parse_xml.makeobj)
     const events = {
         onopentag: function (name, attrs) {
             elem = {name, parent: elem, attrs, text: [], children: [], raw: []};
-            if (path.length > 1) {
-                elem.parent.raw.push(elem);
-                elem.parent.children.push(elem);
-            }
+            elem.parent.raw.push(elem);
+            elem.parent.children.push(elem);
             path.push(elem.name);
             path_str = path.join('>');
         },
         onclosetag: function (name) {
             if (path_str === selector_str) {
-                out.push(mapper(elem));
+                const tmp = mapper(elem);
+                out.push((tmp === null ? const_stream.null : tmp));
             }
             elem = elem.parent;
             path.pop();
@@ -38,7 +38,8 @@ function stream_parse_xml(selector, mapper = stream_parse_xml.makeobj)
         },
         onend: function () {
             if (selector_str === '') {
-                out.push(mapper(elem));
+                const tmp = mapper(elem);
+                out.push((tmp === null ? const_stream.null : tmp));
             }
         },
     };
@@ -50,18 +51,71 @@ function stream_parse_xml(selector, mapper = stream_parse_xml.makeobj)
             parser.write(buf.toString());
             next();
         },
+        flush: function (next) {
+            parser.end();
+            next();
+        },
     });
 }
 
-stream_parse_xml.makeobj = function (node) {
-    if (node.children.length === 0) {
-        return node.text.join('').trim();
+function guess(node)
+{
+    const attrs = Object.keys(node.attrs);
+
+    if (attrs.length === 0) {
+        if (node.raw.length === 0) {
+            return null;
+        }
+        if (node.children.length === 0) {
+            return node.text.join('').trim();
+        }
+        if (node.children.length > 1) {
+            const tmp = node.children[0].name;
+            if (node.children.every(v => v.name === tmp)) {
+                return node.children.map(v => stream_parse_xml.guess);
+            }
+        }
+    }
+
+    const out = {...node.attrs};
+
+    if (node.text.length) {
+        const tmp = node.text.join('').trim();
+        if (tmp) {
+            out.value = tmp;
+        }
     }
-    const out = {};
+
     node.children.forEach(function (child) {
-        out[child.name] = stream_parse_xml.makeobj(child);
+        const tmp = stream_parse_xml.guess(child);
+        if (child.name in out) {
+            if (Array.isArray(out[child.name])) {
+                out[child.name].push(tmp);
+            }
+            else {
+                out[child.name] = [out[child.name], tmp];
+            }
+        }
+        else  {
+            out[child.name] = tmp;
+        }
     });
+
     return out;
 }
 
+function ashtml(node)
+{
+    return node.raw.map(fn).filter(v => v).join('').trim();
+    function fn(item) {
+        if (typeof item === 'string') {
+            return item.replace(/\s+/g, ' ');
+        }
+        return `<${item.name}>${ashtml(item)}</${item.name}>` ;
+    }
+}
+
+stream_parse_xml.guess = guess;
+stream_parse_xml.ashtml = ashtml;
+
 module.exports = stream_parse_xml;

package/src/stream_progress.js

@@ -7,7 +7,7 @@ const stream = require('stream');
  *
  * @similar https://www.npmjs.com/package/progress-stream
  */
-function stream_progress({total, user_friendly_status = s => console.log(s)})
+function stream_progress({total, user_friendly_status = s => console.log(s)} = {})
 {
     let done = 0;
     const timer = setInterval(tick, 1000);