@wener/utils 1.1.50 → 1.1.53

package/lib/langs/getObjectId.js

@@ -1,18 +1,16 @@
-import { getGlobalStates } from './getGlobalStates.js';
+import { getGlobalStates } from "./getGlobalStates.js";
 export function getObjectId(k) {
-    const state = getGlobalStates('ObjectId', ()=>{
+    var state = getGlobalStates("ObjectId", function () {
         return {
             id: 1,
             map: new WeakMap()
         };
     });
-    const { map } = state;
+    var map = state.map;
     if (map.has(k)) {
         return map.get(k);
     }
-    const id = state.id++;
+    var id = state.id++;
     map.set(k, id);
     return id;
 }
-
-//# sourceMappingURL=getObjectId.js.map

package/lib/langs/ifPresent.js

@@ -0,0 +1,3 @@
+export function ifPresent(value, fn) {
+    return value ? fn(value) : undefined;
+}

package/lib/langs/isClass.js

@@ -1,5 +1,3 @@
 export function isClass(func) {
     return typeof func === 'function' && /^class\s/.test(Function.prototype.toString.call(func));
 }
-
-//# sourceMappingURL=isClass.js.map

package/lib/langs/isDefined.js

@@ -1,5 +1,3 @@
 export function isDefined(v) {
     return v !== null && v !== undefined;
 }
-
-//# sourceMappingURL=isDefined.js.map

package/lib/langs/isEmptyObject.js

@@ -1,6 +1,4 @@
-import { isPlainObject } from './isPlainObject.js';
+import { isPlainObject } from "./isPlainObject.js";
 export function isEmptyObject(o) {
     return isPlainObject(o) && Object.keys(o).length === 0;
 }
-
-//# sourceMappingURL=isEmptyObject.js.map

package/lib/langs/isFunction.js

@@ -1,5 +1,3 @@
 export function isFunction(value) {
     return typeof value === 'function';
 }
-
-//# sourceMappingURL=isFunction.js.map

package/lib/langs/isNil.js

@@ -0,0 +1,3 @@
+export function isNil(value) {
+    return value === null || value === undefined;
+}

package/lib/langs/isPlainObject.js

@@ -1,10 +1,8 @@
-import { classOf } from './classOf.js';
+import { classOf } from "./classOf.js";
 // see: https://github.com/mesqueeb/is-what/blob/88d6e4ca92fb2baab6003c54e02eedf4e729e5ab/src/index.ts
 export function isPlainObject(value) {
-    if (classOf(value) !== 'Object') {
+    if (classOf(value) !== "Object") {
         return false;
     }
     return value.constructor === Object && Object.getPrototypeOf(value) === Object.prototype;
 }
-
-//# sourceMappingURL=isPlainObject.js.map

package/lib/langs/langs.test.js

@@ -0,0 +1,126 @@
+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 { classOf } from "./classOf.js";
+test("classOf", function () {
+    for (var _i = 0, _iter = [
+        [
+            0,
+            "Number"
+        ],
+        [
+            "",
+            "String"
+        ],
+        [
+            true,
+            "Boolean"
+        ],
+        [
+            null,
+            "Null"
+        ],
+        [
+            undefined,
+            "Undefined"
+        ],
+        [
+            {},
+            "Object"
+        ],
+        [
+            [],
+            "Array"
+        ],
+        [
+            new ArrayBuffer(0),
+            "ArrayBuffer"
+        ],
+        [
+            new Map(),
+            "Map"
+        ],
+        [
+            new Set(),
+            "Set"
+        ],
+        [
+            new Date(),
+            "Date"
+        ],
+        [
+            new RegExp(""),
+            "RegExp"
+        ],
+        [
+            new DataView(new ArrayBuffer(0)),
+            "DataView"
+        ],
+        [
+            new Int8Array(0),
+            "Int8Array"
+        ]
+    ]; _i < _iter.length; _i++) {
+        var _iter__i = _sliced_to_array(_iter[_i], 2), k = _iter__i[0], v = _iter__i[1];
+        expect(classOf(k)).toBe(v);
+    }
+});

package/lib/langs/memoize.js

@@ -1,15 +1,21 @@
 // https://github.com/angus-c/just/blob/master/packages/function-memoize/index.mjs
-export function memoize(callback, { resolver = (...args)=>JSON.stringify(args) } = {}) {
+export function memoize(callback) {
+    var _ref = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}, _ref_resolver = _ref.resolver, resolver = _ref_resolver === void 0 ? function() {
+        for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
+            args[_key] = arguments[_key];
+        }
+        return JSON.stringify(args);
+    } : _ref_resolver;
     if (typeof callback !== 'function') {
         throw new Error('`callback` should be a function');
     }
     if (resolver !== undefined && typeof resolver !== 'function') {
         throw new Error('`resolver` should be a function');
     }
-    const cache = {};
-    const memoized = function() {
-        const args = Array.prototype.slice.call(arguments); // to simplify JSON.stringify
-        const key = resolver.apply(this, args);
+    var cache = {};
+    var memoized = function memoized() {
+        var args = Array.prototype.slice.call(arguments); // to simplify JSON.stringify
+        var key = resolver.apply(this, args);
         if (!(key in cache)) {
             cache[key] = callback.apply(this, args);
         }
@@ -18,5 +24,3 @@ export function memoize(callback, { resolver = (...args)=>JSON.stringify(args) }
     memoized.cache = cache;
     return memoized;
 }
-
-//# sourceMappingURL=memoize.js.map

package/lib/langs/mixin.js

@@ -15,8 +15,11 @@
  * @example ```ts
  * class Dog extends mixin(Animal, FourLegged, Carnivore, PackHunting, Barking, Domesticated) {}
  * ```
- */ export function mixin(Base, ...mixins) {
-    return mixins.reduce((mix, applyMixin)=>applyMixin(mix), Base);
+ */ export function mixin(Base) {
+    for(var _len = arguments.length, mixins = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++){
+        mixins[_key - 1] = arguments[_key];
+    }
+    return mixins.reduce(function(mix, applyMixin) {
+        return applyMixin(mix);
+    }, Base);
 } // https://github.com/1nVitr0/lib-ts-mixin-extended
-
-//# sourceMappingURL=mixin.js.map

package/lib/langs/mixin.test.js

@@ -0,0 +1,135 @@
+function _assert_this_initialized(self) {
+    if (self === void 0) {
+        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+    }
+    return self;
+}
+function _call_super(_this, derived, args) {
+    derived = _get_prototype_of(derived);
+    return _possible_constructor_return(_this, _is_native_reflect_construct() ? Reflect.construct(derived, args || [], _get_prototype_of(_this).constructor) : derived.apply(_this, args));
+}
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+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 _get_prototype_of(o) {
+    _get_prototype_of = Object.setPrototypeOf ? Object.getPrototypeOf : function getPrototypeOf(o) {
+        return o.__proto__ || Object.getPrototypeOf(o);
+    };
+    return _get_prototype_of(o);
+}
+function _inherits(subClass, superClass) {
+    if (typeof superClass !== "function" && superClass !== null) {
+        throw new TypeError("Super expression must either be null or a function");
+    }
+    subClass.prototype = Object.create(superClass && superClass.prototype, {
+        constructor: {
+            value: subClass,
+            writable: true,
+            configurable: true
+        }
+    });
+    if (superClass)
+        _set_prototype_of(subClass, superClass);
+}
+function _possible_constructor_return(self, call) {
+    if (call && (_type_of(call) === "object" || typeof call === "function")) {
+        return call;
+    }
+    return _assert_this_initialized(self);
+}
+function _set_prototype_of(o, p) {
+    _set_prototype_of = Object.setPrototypeOf || function setPrototypeOf(o, p) {
+        o.__proto__ = p;
+        return o;
+    };
+    return _set_prototype_of(o, p);
+}
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function _is_native_reflect_construct() {
+    try {
+        var result = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () { }));
+    }
+    catch (_) { }
+    return (_is_native_reflect_construct = function () {
+        return !!result;
+    })();
+}
+import { expect, test } from "vitest";
+import { mixin } from "./mixin.js";
+test("mixin", function () {
+    // @ts-ignore
+    var User = /*#__PURE__*/ function (_mixin) {
+        "use strict";
+        _inherits(User, _mixin);
+        function User() {
+            _class_call_check(this, User);
+            return _call_super(this, User, arguments);
+        }
+        return User;
+    }(mixin(BaseResource, createBarFields()));
+    var usr = new User();
+    // type not working
+    // @ts-ignore
+    expect(usr.foo, "foo");
+    expect(usr).toEqual({
+        foo: "foo",
+        bar: "bar",
+        id: ""
+    });
+});
+var BaseResource = function BaseResource() {
+    "use strict";
+    _class_call_check(this, BaseResource);
+    _define_property(this, "id", "");
+};
+function createBarFields() {
+    return function (Base) {
+        // nested type not working
+        // @ts-ignore
+        var HasBarMixin = /*#__PURE__*/ function (_mixin) {
+            "use strict";
+            _inherits(HasBarMixin, _mixin);
+            function HasBarMixin() {
+                _class_call_check(this, HasBarMixin);
+                var _this;
+                _this = _call_super(this, HasBarMixin, arguments), _define_property(_this, "bar", "bar");
+                return _this;
+            }
+            return HasBarMixin;
+        }(mixin(Base, withFooFields));
+        return HasBarMixin;
+    };
+}
+function withFooFields(Base) {
+    var HasFieldFooMixin = /*#__PURE__*/ function (Base) {
+        "use strict";
+        _inherits(HasFieldFooMixin, Base);
+        function HasFieldFooMixin() {
+            _class_call_check(this, HasFieldFooMixin);
+            var _this;
+            _this = _call_super(this, HasFieldFooMixin, arguments), _define_property(_this, "foo", "foo");
+            return _this;
+        }
+        return HasFieldFooMixin;
+    }(Base);
+    return HasFieldFooMixin;
+}

package/lib/langs/parseBoolean.js

@@ -1,17 +1,22 @@
-export function parseBoolean(s, strict = false) {
+export function parseBoolean(s) {
+    var strict = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : false;
     if (typeof s === 'boolean') {
         return s;
     }
     if (typeof s === 'string') {
         switch(s.toLowerCase()){
-            case 'f':
+            case 'yes':
+            case 'y':
+            case 'true':
+            case 't':
+            case '1':
+                return true;
+            case 'no':
+            case 'n':
             case 'false':
+            case 'f':
             case '0':
                 return false;
-            case '1':
-            case 't':
-            case 'true':
-                return true;
         }
     } else if (typeof s === 'number') {
         switch(s){
@@ -26,5 +31,3 @@ export function parseBoolean(s, strict = false) {
     }
     return Boolean(s);
 }
-
-//# sourceMappingURL=parseBoolean.js.map

package/lib/langs/shallowClone.js

@@ -1,3 +1,7 @@
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
 export function shallowClone(obj) {
     if (!obj) {
         return obj;
@@ -5,11 +9,9 @@ export function shallowClone(obj) {
     if (Array.isArray(obj)) {
         return obj.slice();
     }
-    if (typeof obj === 'object') {
+    if ((typeof obj === "undefined" ? "undefined" : _type_of(obj)) === 'object') {
         return Object.assign({}, obj);
     }
     // skip Map, Set, WeakMap, WeakSet, Date, RegExp, etc.
     return obj;
 }
-
-//# sourceMappingURL=shallowClone.js.map

package/lib/langs/shallowEqual.js

@@ -2,23 +2,25 @@
  * shallow compare - support object, array
  *
  * @see {@link https://github.com/pmndrs/zustand/blob/main/src/shallow.ts zustand/src/shallow.ts}
- */ export function shallowEqual(objA, objB) {
+ */ function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+export function shallowEqual(objA, objB) {
     if (Object.is(objA, objB)) {
         return true;
     }
-    if (typeof objA !== 'object' || objA === null || typeof objB !== 'object' || objB === null) {
+    if ((typeof objA === "undefined" ? "undefined" : _type_of(objA)) !== 'object' || objA === null || (typeof objB === "undefined" ? "undefined" : _type_of(objB)) !== 'object' || objB === null) {
         return false;
     }
-    const keysA = Object.keys(objA);
+    var keysA = Object.keys(objA);
     if (keysA.length !== Object.keys(objB).length) {
         return false;
     }
-    for(let i = 0; i < keysA.length; i++){
+    for(var i = 0; i < keysA.length; i++){
         if (!Object.prototype.hasOwnProperty.call(objB, keysA[i]) || !Object.is(objA[keysA[i]], objB[keysA[i]])) {
             return false;
         }
     }
     return true;
 }
-
-//# sourceMappingURL=shallowEqual.js.map

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