@vbarbarosh/node-helpers 3.26.0 → 3.28.0

package/package.json

@@ -2,7 +2,7 @@
     "author": "Vladimir Barbarosh <vladimir.barbarosh@gmail.com>",
     "license": "MIT",
     "name": "@vbarbarosh/node-helpers",
-    "version": "3.26.0",
+    "version": "3.28.0",
     "description": "A set of helpers for JavaScript/Node.js",
     "files": [
         "src"
@@ -26,6 +26,7 @@
         "axios": "^1.3.2",
         "bluebird": "^3.7.2",
         "form-data": "^4.0.0",
+        "htmlparser2": "^9.1.0",
         "json-stable-stringify": "^1.0.2",
         "sanitize-filename": "^1.6.3",
         "split": "^1.0.1",

package/src/const_type.js

@@ -0,0 +1,17 @@
+const const_type = {
+    null: 'null',
+    undefined: 'undefined',
+    boolean: 'boolean',
+    number: 'number',
+    bigint: 'bigint',
+    nan: 'nan',
+    neg_inf: '-inf',
+    pos_inf: '+inf',
+    string: 'string',
+    symbol: 'symbol',
+    function: 'function',
+    object: 'object',
+    array: 'array',
+};
+
+module.exports = const_type;

package/src/gettype.js

@@ -0,0 +1,26 @@
+const const_type = require('./const_type');
+
+/**
+ * @similar https://github.com/locutusjs/locutus/tree/master/src/php/var
+ */
+function gettype(value)
+{
+    if (value === null) {
+        return const_type.null;
+    }
+    if (Array.isArray(value)) {
+        return const_type.array;
+    }
+    if (Number.isNaN(value)) {
+        return const_type.nan;
+    }
+    if (value === Number.NEGATIVE_INFINITY) {
+        return const_type.neg_inf;
+    }
+    if (value === Number.POSITIVE_INFINITY) {
+        return const_type.pos_inf;
+    }
+    return typeof value;
+}
+
+module.exports = gettype;

package/src/gettype.test.js

@@ -0,0 +1,27 @@
+const assert = require('assert');
+const const_type = require('./const_type');
+const gettype = require('./gettype');
+
+const items = [
+    ['null', null, const_type.null],
+    ['undefined', undefined, const_type.undefined],
+    ['boolean', true, const_type.boolean],
+    ['number', 1, const_type.number],
+    ['bigint', 1n, const_type.bigint],
+    ['nan', NaN, const_type.nan],
+    ['-inf', Number.NEGATIVE_INFINITY, const_type.neg_inf],
+    ['+inf', Number.POSITIVE_INFINITY, const_type.pos_inf],
+    ['string', 's', const_type.string],
+    ['symbol', Symbol(), const_type.symbol],
+    ['function', () => 1, const_type.function],
+    ['object', {}, const_type.object],
+    ['array', [], const_type.array],
+];
+
+describe('gettype', function () {
+    items.forEach(function ([title, input, expected]) {
+        it(title, function () {
+            assert.deepStrictEqual(gettype(input), expected);
+        });
+    });
+});

package/src/object_walk_preorder.js

@@ -0,0 +1,23 @@
+function object_walk_preorder(value, fn, path = [])
+{
+    if (path.length) {
+        fn(value, path);
+    }
+    if (value === null) {
+        return;
+    }
+    if (Array.isArray(value)) {
+        for (let i = 0, end = value.length; i < end; ++i) {
+            object_walk_preorder(value[i], fn, path.concat('*'));
+        }
+    }
+    else if (typeof value === 'object') {
+        const keys = Object.keys(value);
+        for (let i = 0, end = keys.length; i < end; ++i) {
+            const key = keys[i];
+            object_walk_preorder(value[key], fn, path.concat(key));
+        }
+    }
+}
+
+module.exports = object_walk_preorder;

package/src/object_walk_preorder.test.js

@@ -0,0 +1,17 @@
+const assert = require('assert');
+const object_walk_preorder = require('./object_walk_preorder');
+
+describe('object_walk_preorder', function () {
+    it('basic 1', function () {
+        const actual = [];
+        const expected = ['aaa', 'bbb', 'ccc'];
+        object_walk_preorder({aaa: 1, bbb: 2, ccc: 3}, (v,p) => actual.push(p.join('/')));
+        assert.deepStrictEqual(actual, expected);
+    });
+    it('basic 2', function () {
+        const actual = [];
+        const expected = ['aaa', 'aaa/foo', 'aaa/foo/bar', 'aaa/foo/bar/baz', 'bbb', 'ccc'];
+        object_walk_preorder({aaa: {foo: {bar: {baz: 1}}}, bbb: 2, ccc: 3}, (v,p) => actual.push(p.join('/')));
+        assert.deepStrictEqual(actual, expected);
+    });
+});

package/src/stream_parse_xml.js

@@ -0,0 +1,67 @@
+const stream = require('stream');
+const htmlparser2 = require('htmlparser2');
+
+/**
+ * Parse XML stream and produce objects.
+ */
+function stream_parse_xml(selector, mapper = stream_parse_xml.makeobj)
+{
+    let out;
+    let elem = {name: '#doc', parent: null, attrs: {}, text: [], children: [], raw: []};
+
+    const path = [];
+    const selector_str = selector.join('>');
+    let path_str = '';
+
+    const options = {xmlMode: true};
+    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);
+            }
+            path.push(elem.name);
+            path_str = path.join('>');
+        },
+        onclosetag: function (name) {
+            if (path_str === selector_str) {
+                out.push(mapper(elem));
+            }
+            elem = elem.parent;
+            path.pop();
+            path_str = path.join('>');
+        },
+        ontext: function (text) {
+            elem.raw.push(text);
+            elem.text.push(text);
+        },
+        onend: function () {
+            if (selector_str === '') {
+                out.push(mapper(elem));
+            }
+        },
+    };
+
+    const parser = new htmlparser2.Parser(events, options);
+    return out = new stream.Transform({
+        objectMode: true,
+        transform: function (buf, encoding, next) {
+            parser.write(buf.toString());
+            next();
+        },
+    });
+}
+
+stream_parse_xml.makeobj = function (node) {
+    if (node.children.length === 0) {
+        return node.text.join('').trim();
+    }
+    const out = {};
+    node.children.forEach(function (child) {
+        out[child.name] = stream_parse_xml.makeobj(child);
+    });
+    return out;
+}
+
+module.exports = stream_parse_xml;

package/src/stream_progress.js

@@ -4,6 +4,8 @@ const stream = require('stream');
 
 /**
  * Monitor the progress of data through a pipe. Similar to UNIX `pv` command.
+ *
+ * @similar https://www.npmjs.com/package/progress-stream
  */
 function stream_progress({total, user_friendly_status = s => console.log(s)})
 {