@vbarbarosh/node-helpers 3.25.1 → 3.27.0

package/package.json

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

package/src/array_permutations.js

@@ -0,0 +1,27 @@
+// https://stackoverflow.com/a/37580979/23502239
+function array_permutations(array)
+{
+    var length = array.length,
+        out = [array.slice()],
+        c = new Array(length).fill(0),
+        i = 1, k, p;
+
+    while (i < length) {
+        if (c[i] < i) {
+            k = i % 2 && c[i];
+            p = array[i];
+            array[i] = array[k];
+            array[k] = p;
+            ++c[i];
+            i = 1;
+            out.push(array.slice());
+        }
+        else {
+            c[i] = 0;
+            ++i;
+        }
+    }
+    return out;
+}
+
+module.exports = array_permutations;

package/src/array_permutations.test.js

@@ -0,0 +1,10 @@
+const array_permutations = require('./array_permutations');
+const assert = require('assert');
+
+describe('array_permutations', function () {
+    it('should handle basic input', function () {
+        assert.deepStrictEqual(array_permutations([]), [[]]);
+        assert.deepStrictEqual(array_permutations([1,2]), [[1,2],[2,1]]);
+        assert.deepStrictEqual(array_permutations([1,2,3]), [[1,2,3],[2,1,3],[3,1,2],[1,3,2],[2,3,1],[3,2,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,28 @@
+const const_type = require('./const_type');
+
+/**
+ *
+ * @param value
+ * @return {"undefined"|"object"|"boolean"|"number"|"string"|"function"|"symbol"|"bigint"|string}
+ */
+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_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)})
 {

package/src/stream_strpbrk.js

@@ -11,7 +11,20 @@ function stream_strpbrk(chars = '\r\n')
         transform: function (str, encoding, next) {
             str = Buffer.isBuffer(str) ? str.toString() : str;
 
-            for (let off = 0; off < str.length; ) {
+            let off = 0;
+            // leading delimiters
+            while (off < str.length) {
+                if (!chars.includes(str[off])) {
+                    break;
+                }
+                off++;
+            }
+
+            if (off && pending.length) {
+                this.push(''.concat(...pending.splice(0)));
+            }
+
+            while (off < str.length) {
                 // skip consecutive delimiters
                 while (off < str.length) {
                     let stop = true;

package/src/stream_strpbrk.test.js

@@ -14,6 +14,7 @@ const items = [
     ['a|||b → a,b', '|', ['a|||b'], ['a', 'b']],
     ['abc → abc', '|', ['a', 'b', 'c'], ['abc']],
     ['a|b;c', '|;', ['a|b;c'], ['a', 'b', 'c']],
+    ['a|b;c', '|;', ['a|b', ';c'], ['a', 'b', 'c']],
     ['Buffer(a) → a', '|', ['a'].map(Buffer.from), ['a']],
     ['Buffer(a|b) → a,b', '|', ['a|b'].map(Buffer.from), ['a', 'b']],
 ];