@wener/utils 1.1.50 → 1.1.53

package/lib/libs/ms.test.js

@@ -0,0 +1,301 @@
+import { describe, expect, it } from "vitest";
+import ms from "./ms.js";
+describe("ms(string)", function () {
+    it("should not throw an error", function () {
+        expect(function () {
+            ms("1m");
+        }).not.toThrowError();
+    });
+    it("should preserve ms", function () {
+        expect(ms("100")).toBe(100);
+    });
+    it("should convert from m to ms", function () {
+        expect(ms("1m")).toBe(60000);
+    });
+    it("should convert from h to ms", function () {
+        expect(ms("1h")).toBe(3600000);
+    });
+    it("should convert d to ms", function () {
+        expect(ms("2d")).toBe(172800000);
+    });
+    it("should convert w to ms", function () {
+        expect(ms("3w")).toBe(1814400000);
+    });
+    it("should convert s to ms", function () {
+        expect(ms("1s")).toBe(1000);
+    });
+    it("should convert ms to ms", function () {
+        expect(ms("100ms")).toBe(100);
+    });
+    it("should convert y to ms", function () {
+        expect(ms("1y")).toBe(31557600000);
+    });
+    it("should work with decimals", function () {
+        expect(ms("1.5h")).toBe(5400000);
+    });
+    it("should work with multiple spaces", function () {
+        expect(ms("1   s")).toBe(1000);
+    });
+    it("should return NaN if invalid", function () {
+        // @ts-expect-error - We expect this to fail.
+        expect(isNaN(ms("\u2603"))).toBe(true);
+        // @ts-expect-error - We expect this to fail.
+        expect(isNaN(ms("10-.5"))).toBe(true);
+        // @ts-expect-error - We expect this to fail.
+        expect(isNaN(ms("ms"))).toBe(true);
+    });
+    it("should be case-insensitive", function () {
+        expect(ms("1.5H")).toBe(5400000);
+    });
+    it("should work with numbers starting with .", function () {
+        expect(ms(".5ms")).toBe(0.5);
+    });
+    it("should work with negative integers", function () {
+        expect(ms("-100ms")).toBe(-100);
+    });
+    it("should work with negative decimals", function () {
+        expect(ms("-1.5h")).toBe(-5400000);
+        expect(ms("-10.5h")).toBe(-37800000);
+    });
+    it("should work with negative decimals starting with \".\"", function () {
+        expect(ms("-.5h")).toBe(-1800000);
+    });
+});
+// long strings
+describe("ms(long string)", function () {
+    it("should not throw an error", function () {
+        expect(function () {
+            ms("53 milliseconds");
+        }).not.toThrowError();
+    });
+    it("should convert milliseconds to ms", function () {
+        expect(ms("53 milliseconds")).toBe(53);
+    });
+    it("should convert msecs to ms", function () {
+        expect(ms("17 msecs")).toBe(17);
+    });
+    it("should convert sec to ms", function () {
+        expect(ms("1 sec")).toBe(1000);
+    });
+    it("should convert from min to ms", function () {
+        expect(ms("1 min")).toBe(60000);
+    });
+    it("should convert from hr to ms", function () {
+        expect(ms("1 hr")).toBe(3600000);
+    });
+    it("should convert days to ms", function () {
+        expect(ms("2 days")).toBe(172800000);
+    });
+    it("should convert weeks to ms", function () {
+        expect(ms("1 week")).toBe(604800000);
+    });
+    it("should convert years to ms", function () {
+        expect(ms("1 year")).toBe(31557600000);
+    });
+    it("should work with decimals", function () {
+        expect(ms("1.5 hours")).toBe(5400000);
+    });
+    it("should work with negative integers", function () {
+        expect(ms("-100 milliseconds")).toBe(-100);
+    });
+    it("should work with negative decimals", function () {
+        expect(ms("-1.5 hours")).toBe(-5400000);
+    });
+    it("should work with negative decimals starting with \".\"", function () {
+        expect(ms("-.5 hr")).toBe(-1800000);
+    });
+});
+// numbers
+describe("ms(number, { long: true })", function () {
+    it("should not throw an error", function () {
+        expect(function () {
+            ms(500, {
+                long: true
+            });
+        }).not.toThrowError();
+    });
+    it("should support milliseconds", function () {
+        expect(ms(500, {
+            long: true
+        })).toBe("500 ms");
+        expect(ms(-500, {
+            long: true
+        })).toBe("-500 ms");
+    });
+    it("should support seconds", function () {
+        expect(ms(1000, {
+            long: true
+        })).toBe("1 second");
+        expect(ms(1200, {
+            long: true
+        })).toBe("1 second");
+        expect(ms(10000, {
+            long: true
+        })).toBe("10 seconds");
+        expect(ms(-1000, {
+            long: true
+        })).toBe("-1 second");
+        expect(ms(-1200, {
+            long: true
+        })).toBe("-1 second");
+        expect(ms(-10000, {
+            long: true
+        })).toBe("-10 seconds");
+    });
+    it("should support minutes", function () {
+        expect(ms(60 * 1000, {
+            long: true
+        })).toBe("1 minute");
+        expect(ms(60 * 1200, {
+            long: true
+        })).toBe("1 minute");
+        expect(ms(60 * 10000, {
+            long: true
+        })).toBe("10 minutes");
+        expect(ms(-1 * 60 * 1000, {
+            long: true
+        })).toBe("-1 minute");
+        expect(ms(-1 * 60 * 1200, {
+            long: true
+        })).toBe("-1 minute");
+        expect(ms(-1 * 60 * 10000, {
+            long: true
+        })).toBe("-10 minutes");
+    });
+    it("should support hours", function () {
+        expect(ms(60 * 60 * 1000, {
+            long: true
+        })).toBe("1 hour");
+        expect(ms(60 * 60 * 1200, {
+            long: true
+        })).toBe("1 hour");
+        expect(ms(60 * 60 * 10000, {
+            long: true
+        })).toBe("10 hours");
+        expect(ms(-1 * 60 * 60 * 1000, {
+            long: true
+        })).toBe("-1 hour");
+        expect(ms(-1 * 60 * 60 * 1200, {
+            long: true
+        })).toBe("-1 hour");
+        expect(ms(-1 * 60 * 60 * 10000, {
+            long: true
+        })).toBe("-10 hours");
+    });
+    it("should support days", function () {
+        expect(ms(24 * 60 * 60 * 1000, {
+            long: true
+        })).toBe("1 day");
+        expect(ms(24 * 60 * 60 * 1200, {
+            long: true
+        })).toBe("1 day");
+        expect(ms(24 * 60 * 60 * 10000, {
+            long: true
+        })).toBe("10 days");
+        expect(ms(-1 * 24 * 60 * 60 * 1000, {
+            long: true
+        })).toBe("-1 day");
+        expect(ms(-1 * 24 * 60 * 60 * 1200, {
+            long: true
+        })).toBe("-1 day");
+        expect(ms(-1 * 24 * 60 * 60 * 10000, {
+            long: true
+        })).toBe("-10 days");
+    });
+    it("should round", function () {
+        expect(ms(234234234, {
+            long: true
+        })).toBe("3 days");
+        expect(ms(-234234234, {
+            long: true
+        })).toBe("-3 days");
+    });
+});
+// numbers
+describe("ms(number)", function () {
+    it("should not throw an error", function () {
+        expect(function () {
+            ms(500);
+        }).not.toThrowError();
+    });
+    it("should support milliseconds", function () {
+        expect(ms(500)).toBe("500ms");
+        expect(ms(-500)).toBe("-500ms");
+    });
+    it("should support seconds", function () {
+        expect(ms(1000)).toBe("1s");
+        expect(ms(10000)).toBe("10s");
+        expect(ms(-1000)).toBe("-1s");
+        expect(ms(-10000)).toBe("-10s");
+    });
+    it("should support minutes", function () {
+        expect(ms(60 * 1000)).toBe("1m");
+        expect(ms(60 * 10000)).toBe("10m");
+        expect(ms(-1 * 60 * 1000)).toBe("-1m");
+        expect(ms(-1 * 60 * 10000)).toBe("-10m");
+    });
+    it("should support hours", function () {
+        expect(ms(60 * 60 * 1000)).toBe("1h");
+        expect(ms(60 * 60 * 10000)).toBe("10h");
+        expect(ms(-1 * 60 * 60 * 1000)).toBe("-1h");
+        expect(ms(-1 * 60 * 60 * 10000)).toBe("-10h");
+    });
+    it("should support days", function () {
+        expect(ms(24 * 60 * 60 * 1000)).toBe("1d");
+        expect(ms(24 * 60 * 60 * 10000)).toBe("10d");
+        expect(ms(-1 * 24 * 60 * 60 * 1000)).toBe("-1d");
+        expect(ms(-1 * 24 * 60 * 60 * 10000)).toBe("-10d");
+    });
+    it("should round", function () {
+        expect(ms(234234234)).toBe("3d");
+        expect(ms(-234234234)).toBe("-3d");
+    });
+});
+// invalid inputs
+describe("ms(invalid inputs)", function () {
+    it("should throw an error, when ms(\"\")", function () {
+        expect(function () {
+            // @ts-expect-error - We expect this to throw.
+            ms("");
+        }).toThrowError();
+    });
+    it("should throw an error, when ms(undefined)", function () {
+        expect(function () {
+            // @ts-expect-error - We expect this to throw.
+            ms(undefined);
+        }).toThrowError();
+    });
+    it("should throw an error, when ms(null)", function () {
+        expect(function () {
+            // @ts-expect-error - We expect this to throw.
+            ms(null);
+        }).toThrowError();
+    });
+    it("should throw an error, when ms([])", function () {
+        expect(function () {
+            // @ts-expect-error - We expect this to throw.
+            ms([]);
+        }).toThrowError();
+    });
+    it("should throw an error, when ms({})", function () {
+        expect(function () {
+            // @ts-expect-error - We expect this to throw.
+            ms({});
+        }).toThrowError();
+    });
+    it("should throw an error, when ms(NaN)", function () {
+        expect(function () {
+            ms(NaN);
+        }).toThrowError();
+    });
+    it("should throw an error, when ms(Infinity)", function () {
+        expect(function () {
+            ms(Infinity);
+        }).toThrowError();
+    });
+    it("should throw an error, when ms(-Infinity)", function () {
+        expect(function () {
+            ms(-Infinity);
+        }).toThrowError();
+    });
+});

package/lib/logger/const.js

@@ -0,0 +1,15 @@
+export var logger = console;
+export function setLogger(l) {
+    logger = l;
+}
+export function createNoopLogger() {
+    var noop = function() {};
+    return {
+        log: noop,
+        info: noop,
+        warn: noop,
+        error: noop,
+        debug: noop,
+        trace: noop
+    };
+}

package/lib/logger/index.js

@@ -0,0 +1 @@
+export { logger, setLogger, createNoopLogger } from "./const.js";

package/lib/logger/types.js

@@ -0,0 +1 @@
+export { };

package/lib/maths/clamp.js

@@ -1,13 +1,84 @@
-import { isDefined } from '../langs/isDefined.js';
-import { isNullish } from '../langs/isNullish.js';
-export function clamp(value, ...o) {
-    let min, max, def;
-    if (o.length === 1 && o[0] && typeof o[0] === 'object') {
-        ({ min, max, default: def = min } = o[0]);
-    } else {
-        [min, max, def = min] = o;
-    }
-    if (isNullish(value)) {
+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 _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+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 { isDefined } from "../langs/isDefined.js";
+import { isNil } from "../langs/isNil.js";
+export function clamp(value) {
+    for (var _len = arguments.length, o = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+        o[_key - 1] = arguments[_key];
+    }
+    var min, max, def;
+    if (o.length === 1 && o[0] && _type_of(o[0]) === "object") {
+        var ref, ref1;
+        ref = o[0], min = ref.min, max = ref.max, ref1 = ref.default, def = ref1 === void 0 ? min : ref1, ref;
+    }
+    else {
+        var ref2, ref3;
+        ref2 = _sliced_to_array(o, 3), min = ref2[0], max = ref2[1], ref3 = ref2[2], def = ref3 === void 0 ? min : ref3, ref2;
+    }
+    if (isNil(value)) {
         return def;
     }
     if (isDefined(min) && value < min) {
@@ -18,5 +89,3 @@ export function clamp(value, ...o) {
     }
     return value;
 }
-
-//# sourceMappingURL=clamp.js.map

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
+    ]));
+});