@wener/utils 1.1.51 → 1.1.53

package/lib/libs/ms.js

@@ -1,20 +1,24 @@
 // Helpers.
-const s = 1000;
-const m = s * 60;
-const h = m * 60;
-const d = h * 24;
-const w = d * 7;
-const y = d * 365.25;
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+var s = 1000;
+var m = s * 60;
+var h = m * 60;
+var d = h * 24;
+var w = d * 7;
+var y = d * 365.25;
 function msFn(value, options) {
     try {
         if (typeof value === 'string' && value.length > 0) {
             return parse(value);
         } else if (typeof value === 'number' && isFinite(value)) {
-            return options?.long ? fmtLong(value) : fmtShort(value);
+            return (options === null || options === void 0 ? void 0 : options.long) ? fmtLong(value) : fmtShort(value);
         }
         throw new Error('Value is not a string or number.');
     } catch (error) {
-        const message = isError(error) ? `${error.message}. value=${JSON.stringify(value)}` : 'An unknown error has occurred.';
+        var message = isError(error) ? "".concat(error.message, ". value=").concat(JSON.stringify(value)) : 'An unknown error has occurred.';
         throw new Error(message);
     }
 }
@@ -28,15 +32,15 @@ function msFn(value, options) {
     if (str.length > 100) {
         throw new Error('Value exceeds the maximum length of 100 characters.');
     }
-    const match = /^(?<value>-?(?:\d+)?\.?\d+) *(?<type>milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(str);
+    var match = RegExp("^(?<value>-?(?:\\d+)?\\.?\\d+) *(?<type>milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$", "i").exec(str);
     // Named capture groups need to be manually typed today.
     // https://github.com/microsoft/TypeScript/issues/32098
-    const groups = match?.groups;
+    var groups = match === null || match === void 0 ? void 0 : match.groups;
     if (!groups) {
         return NaN;
     }
-    const n = parseFloat(groups.value);
-    const type = (groups.type || 'ms').toLowerCase();
+    var n = parseFloat(groups.value);
+    var type = (groups.type || 'ms').toLowerCase();
     switch(type){
         case 'years':
         case 'year':
@@ -78,7 +82,7 @@ function msFn(value, options) {
             return n;
         default:
             // This should never occur.
-            throw new Error(`The unit ${type} was matched, but no matching case exists.`);
+            throw new Error("The unit ".concat(type, " was matched, but no matching case exists."));
     }
 }
 // eslint-disable-next-line import/no-default-export
@@ -86,25 +90,25 @@ export default msFn;
 /**
  * Short format for `ms`.
  */ function fmtShort(ms) {
-    const msAbs = Math.abs(ms);
+    var msAbs = Math.abs(ms);
     if (msAbs >= d) {
-        return `${Math.round(ms / d)}d`;
+        return "".concat(Math.round(ms / d), "d");
     }
     if (msAbs >= h) {
-        return `${Math.round(ms / h)}h`;
+        return "".concat(Math.round(ms / h), "h");
     }
     if (msAbs >= m) {
-        return `${Math.round(ms / m)}m`;
+        return "".concat(Math.round(ms / m), "m");
     }
     if (msAbs >= s) {
-        return `${Math.round(ms / s)}s`;
+        return "".concat(Math.round(ms / s), "s");
     }
-    return `${ms}ms`;
+    return "".concat(ms, "ms");
 }
 /**
  * Long format for `ms`.
  */ function fmtLong(ms) {
-    const msAbs = Math.abs(ms);
+    var msAbs = Math.abs(ms);
     if (msAbs >= d) {
         return plural(ms, msAbs, d, 'day');
     }
@@ -117,13 +121,13 @@ export default msFn;
     if (msAbs >= s) {
         return plural(ms, msAbs, s, 'second');
     }
-    return `${ms} ms`;
+    return "".concat(ms, " ms");
 }
 /**
  * Pluralization helper.
  */ function plural(ms, msAbs, n, name) {
-    const isPlural = msAbs >= n * 1.5;
-    return `${Math.round(ms / n)} ${name}${isPlural ? 's' : ''}`;
+    var isPlural = msAbs >= n * 1.5;
+    return "".concat(Math.round(ms / n), " ").concat(name).concat(isPlural ? 's' : '');
 }
 /**
  * A type guard for errors.
@@ -131,7 +135,5 @@ export default msFn;
  * @param value - The value to test
  * @returns A boolean `true` if the provided value is an Error-like object
  */ function isError(value) {
-    return typeof value === 'object' && value !== null && 'message' in value;
+    return (typeof value === "undefined" ? "undefined" : _type_of(value)) === 'object' && value !== null && 'message' in value;
 }
-
-//# sourceMappingURL=ms.js.map

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