@wener/utils 1.1.51 → 1.1.54

package/lib/maths/clamp.test.js

@@ -0,0 +1,186 @@
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length)
+        len = arr.length;
+    for (var i = 0, arr2 = new Array(len); i < len; i++)
+        arr2[i] = arr[i];
+    return arr2;
+}
+function _array_with_holes(arr) {
+    if (Array.isArray(arr))
+        return arr;
+}
+function _iterable_to_array_limit(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null)
+        return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) {
+            _arr.push(_s.value);
+            if (i && _arr.length === i)
+                break;
+        }
+    }
+    catch (err) {
+        _d = true;
+        _e = err;
+    }
+    finally {
+        try {
+            if (!_n && _i["return"] != null)
+                _i["return"]();
+        }
+        finally {
+            if (_d)
+                throw _e;
+        }
+    }
+    return _arr;
+}
+function _non_iterable_rest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _sliced_to_array(arr, i) {
+    return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o)
+        return;
+    if (typeof o === "string")
+        return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor)
+        n = o.constructor.name;
+    if (n === "Map" || n === "Set")
+        return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n))
+        return _array_like_to_array(o, minLen);
+}
+import { expect, test } from "vitest";
+import { clamp } from "./clamp.js";
+test("clamp", function () {
+    for (var _i = 0, _iter = [
+        [
+            [
+                null,
+                0,
+                0
+            ],
+            0
+        ],
+        [
+            [
+                null,
+                1,
+                10
+            ],
+            1
+        ],
+        [
+            [
+                undefined,
+                1,
+                10
+            ],
+            1
+        ],
+        [
+            [
+                undefined,
+                1,
+                10,
+                5
+            ],
+            5
+        ],
+        [
+            [
+                2,
+                1,
+                10,
+                5
+            ],
+            2
+        ],
+        [
+            [
+                11,
+                1,
+                10,
+                5
+            ],
+            10
+        ],
+        [
+            [
+                11,
+                {
+                    min: 1,
+                    max: 10
+                }
+            ],
+            10
+        ],
+        [
+            [
+                null,
+                {
+                    min: 1,
+                    max: 10
+                }
+            ],
+            1
+        ],
+        [
+            [
+                null,
+                {
+                    min: 1,
+                    max: 10,
+                    default: 5
+                }
+            ],
+            5
+        ],
+        [
+            [
+                2n,
+                1,
+                10,
+                5
+            ],
+            2n
+        ],
+        [
+            [
+                1,
+                2
+            ],
+            2
+        ],
+        [
+            [
+                1,
+                undefined,
+                0
+            ],
+            0
+        ],
+        [
+            [],
+            undefined
+        ],
+        [
+            [
+                null
+            ],
+            undefined
+        ]
+    ]; _i < _iter.length; _i++) {
+        var _iter__i = _sliced_to_array(_iter[_i], 2), a = _iter__i[0], b = _iter__i[1];
+        expect(clamp.apply(null, a), "".concat(a, " -> ").concat(b)).toBe(b);
+    }
+});

package/lib/maths/createRandom.test.js

@@ -0,0 +1,36 @@
+import { expect, test } from "vitest";
+import { createRandom } from "./random.js";
+test("createRandom", function () {
+    var random = createRandom(0);
+    expect(random.random(100)).toBe(47);
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for (var _iterator = random[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+            var a = _step.value;
+            expect(a).toBe(0.557133817113936);
+            break;
+        }
+    }
+    catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    }
+    finally {
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        }
+        finally {
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+    expect(random.randomBytes(4)).toEqual(Uint8Array.from([
+        163,
+        85,
+        196,
+        62
+    ]));
+});

package/lib/maths/random.js

@@ -1,17 +1,166 @@
-/// javascript pseudo random
-export function createRandom(o = {}) {
-    let seed = typeof o.seed === 'string' ? 0 : o.seed ?? 0;
-    if (typeof o.seed === 'string') {
-        let sum = 0;
-        for(let i = 0; i < o.seed.length; i++){
-            sum += o.seed.charCodeAt(i);
+// LCG pseudo random
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _ts_generator(thisArg, body) {
+    var f, y, t, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    }, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+        return this;
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(g && (g = 0, op[0] && (_ = 0)), _)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
         }
-        seed = sum;
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
     }
-    return ()=>{
-        const x = Math.sin(seed++) * 10000;
-        return x - Math.floor(x);
+}
+export function createRandom() {
+    var _seed = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : Date.now();
+    var seed = 0;
+    if (typeof _seed === 'string') {
+        for(var i = 0; i < _seed.length; i++){
+            seed = Math.imul(31, seed) + _seed.charCodeAt(i) | 0;
+        }
+    } else if (typeof _seed === 'number') {
+        seed = _seed;
+    }
+    // int32
+    seed = seed >>> 0;
+    // alternative 梅森旋转算法 (Mersenne Twister), Xorshift
+    // LCG
+    var m = 0x80000000; // 2^31
+    var a = 1664525;
+    var c = 1013904223;
+    var random = function(n) {
+        seed = (a * seed + c) % m;
+        var r = seed / m;
+        if (n) {
+            r = Math.floor(r * n);
+        }
+        return r;
+    };
+    var randomBytes = function(length) {
+        var bytes = new Uint8Array(length);
+        for(var i = 0; i < length; i++){
+            bytes[i] = Math.floor(random() * 256);
+        }
+        return bytes;
     };
+    return _define_property({
+        random: random,
+        randomBytes: randomBytes
+    }, Symbol.iterator, function() {
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    if (!true) return [
+                        3,
+                        2
+                    ];
+                    return [
+                        4,
+                        random()
+                    ];
+                case 1:
+                    _state.sent();
+                    return [
+                        3,
+                        0
+                    ];
+                case 2:
+                    return [
+                        2
+                    ];
+            }
+        });
+    });
 }
-
-//# sourceMappingURL=random.js.map

package/lib/modules/isModule.js

@@ -3,5 +3,3 @@
  */ export function isModule(o) {
     return o && o[Symbol.toStringTag] === 'Module';
 }
-
-//# sourceMappingURL=isModule.js.map

package/lib/modules/parseModuleId.js

@@ -1,5 +1,5 @@
 // https://regex101.com/r/eMcXQ9/1
-const regModuleId = /^(?<n>(?:@(?<org>[a-z0-9-~][a-z0-9-._~]*)\/)?(?<pkg>[a-z0-9-~][a-z0-9-._~]*))(?:@(?<v>[-a-z0-9><=_.^~]+))?(?<p>\/[^\r\n]*)?$/;
+var regModuleId = RegExp("^(?<n>(?:@(?<org>[a-z0-9-~][a-z0-9-._~]*)\\/)?(?<pkg>[a-z0-9-~][a-z0-9-._~]*))(?:@(?<v>[-a-z0-9><=_.^~]+))?(?<p>\\/[^\\r\\n]*)?$");
 /**
  * Parse NPM module id
  *
@@ -7,21 +7,22 @@ const regModuleId = /^(?<n>(?:@(?<org>[a-z0-9-~][a-z0-9-._~]*)\/)?(?<pkg>[a-z0-9
  * parseModuleId('@wener/reaction@latest/index.js')
  * // { id: '@wener/reaction@latest', name: '@wener/reaction', version: 'latest', range: 'latest', pkg: 'reaction', path: '/index.js', scoped: true, org: 'wener' }
  */ export function parseModuleId(s) {
-    const groups = s.match(regModuleId)?.groups;
+    var _s_match;
+    var groups = (_s_match = s.match(regModuleId)) === null || _s_match === void 0 ? void 0 : _s_match.groups;
     if (!groups) {
         return undefined;
     }
-    const { n: name, v: version, p: path, org, pkg } = groups;
-    const scoped = Boolean(org);
-    const v = /^\d+\.\d+\.\d+/.test(version) ? version : undefined;
-    const range = version || 'latest';
-    const o = {
-        id: `${name}@${range}`,
-        name,
-        range,
-        scoped,
-        pkg,
-        org,
+    var name = groups.n, version = groups.v, path = groups.p, org = groups.org, pkg = groups.pkg;
+    var scoped = Boolean(org);
+    var v = /^\d+\.\d+\.\d+/.test(version) ? version : undefined;
+    var range = version || 'latest';
+    var o = {
+        id: "".concat(name, "@").concat(range),
+        name: name,
+        range: range,
+        scoped: scoped,
+        pkg: pkg,
+        org: org,
         versioned: Boolean(version)
     };
     if (v) {
@@ -35,5 +36,3 @@ const regModuleId = /^(?<n>(?:@(?<org>[a-z0-9-~][a-z0-9-._~]*)\/)?(?<pkg>[a-z0-9
     }
     return o;
 }
-
-//# sourceMappingURL=parseModuleId.js.map

package/lib/modules/parseModuleId.test.js

@@ -0,0 +1,153 @@
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length)
+        len = arr.length;
+    for (var i = 0, arr2 = new Array(len); i < len; i++)
+        arr2[i] = arr[i];
+    return arr2;
+}
+function _array_with_holes(arr) {
+    if (Array.isArray(arr))
+        return arr;
+}
+function _iterable_to_array_limit(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null)
+        return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) {
+            _arr.push(_s.value);
+            if (i && _arr.length === i)
+                break;
+        }
+    }
+    catch (err) {
+        _d = true;
+        _e = err;
+    }
+    finally {
+        try {
+            if (!_n && _i["return"] != null)
+                _i["return"]();
+        }
+        finally {
+            if (_d)
+                throw _e;
+        }
+    }
+    return _arr;
+}
+function _non_iterable_rest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _sliced_to_array(arr, i) {
+    return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o)
+        return;
+    if (typeof o === "string")
+        return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor)
+        n = o.constructor.name;
+    if (n === "Map" || n === "Set")
+        return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n))
+        return _array_like_to_array(o, minLen);
+}
+import { expect, test } from "vitest";
+import { parseModuleId } from "./parseModuleId.js";
+test("parseModuleId", function () {
+    var tests = {
+        "@wener/reaction": {
+            id: "@wener/reaction@latest",
+            name: "@wener/reaction",
+            range: "latest",
+            scoped: true,
+            org: "wener",
+            pkg: "reaction",
+            versioned: false
+        },
+        reaction: {
+            id: "reaction@latest",
+            name: "reaction",
+            range: "latest",
+            pkg: "reaction",
+            scoped: false,
+            versioned: false
+        },
+        "reaction@1": {
+            id: "reaction@1",
+            name: "reaction",
+            range: "1",
+            pkg: "reaction",
+            scoped: false,
+            versioned: true
+        },
+        "reaction@1.1.1": {
+            id: "reaction@1.1.1",
+            name: "reaction",
+            version: "1.1.1",
+            range: "1.1.1",
+            pkg: "reaction",
+            scoped: false,
+            versioned: true
+        },
+        "reaction@1.1.1-alpha": {
+            id: "reaction@1.1.1-alpha",
+            name: "reaction",
+            version: "1.1.1-alpha",
+            range: "1.1.1-alpha",
+            pkg: "reaction",
+            versioned: true,
+            scoped: false
+        },
+        "reaction@1.1.1/index.js": {
+            id: "reaction@1.1.1",
+            name: "reaction",
+            version: "1.1.1",
+            range: "1.1.1",
+            scoped: false,
+            pkg: "reaction",
+            versioned: true,
+            path: "/index.js"
+        },
+        "reaction@1.1.1/": {
+            id: "reaction@1.1.1",
+            name: "reaction",
+            version: "1.1.1",
+            range: "1.1.1",
+            scoped: false,
+            pkg: "reaction",
+            path: "/",
+            versioned: true
+        }
+    };
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for (var _iterator = Object.entries(tests)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+            var _step_value = _sliced_to_array(_step.value, 2), k = _step_value[0], v = _step_value[1];
+            expect(parseModuleId(k)).toStrictEqual(v);
+        }
+    }
+    catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    }
+    finally {
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        }
+        finally {
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+});

package/lib/objects/computeIfAbsent.js

@@ -1,5 +1,12 @@
+function _instanceof(left, right) {
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else {
+        return left instanceof right;
+    }
+}
 export function computeIfAbsent(map, key, fn) {
-    if (map instanceof Map || map instanceof WeakMap) {
+    if (_instanceof(map, Map) || _instanceof(map, WeakMap)) {
         if (!map.has(key)) {
             map.set(key, fn());
         }
@@ -10,5 +17,3 @@ export function computeIfAbsent(map, key, fn) {
     }
     return map[key];
 }
-
-//# sourceMappingURL=computeIfAbsent.js.map

package/lib/objects/get.js

@@ -1,16 +1,34 @@
-import { parseObjectPath } from './parseObjectPath.js';
+import { parseObjectPath } from "./parseObjectPath.js";
 /**
  * get by path
  *
  * {@link https://github.com/developit/dlv dlv}
  */ export function get(obj, key, def) {
-    const undef = undefined;
-    const path = parseObjectPath(key);
-    let out = obj;
-    for (const i of path){
-        out = out ? out[i] : undef;
+    var undef = undefined;
+    var path = parseObjectPath(key);
+    var out = obj;
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for (var _iterator = path[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+            var i = _step.value;
+            out = out ? out[i] : undef;
+        }
+    }
+    catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    }
+    finally {
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        }
+        finally {
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
     }
     return out === undef ? def : out;
 }
-
-//# sourceMappingURL=get.js.map