@wener/utils 1.1.51 → 1.1.54

package/lib/langs/deepFreeze.js

@@ -3,18 +3,37 @@
  *
  * @param {T} obj - The object to freeze.
  * @returns {T} - The frozen object.
- */ export function deepFreeze(obj) {
-    if (obj === null || typeof obj !== 'object') {
+ */ function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+export function deepFreeze(obj) {
+    if (obj === null || (typeof obj === "undefined" ? "undefined" : _type_of(obj)) !== 'object') {
         return obj;
     }
-    const props = Object.getOwnPropertyNames(obj);
-    for (const prop of props){
-        const value = obj[prop];
-        if (value && typeof value === 'object') {
-            deepFreeze(value);
+    var props = Object.getOwnPropertyNames(obj);
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = props[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var prop = _step.value;
+            var value = obj[prop];
+            if (value && (typeof value === "undefined" ? "undefined" : _type_of(value)) === 'object') {
+                deepFreeze(value);
+            }
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
         }
     }
     return Object.freeze(obj);
 }
-
-//# sourceMappingURL=deepFreeze.js.map

package/lib/langs/getGlobalStates.js

@@ -1,18 +1,24 @@
-import { computeIfAbsent } from '../objects/computeIfAbsent.js';
-import { getGlobalThis } from '../web/getGlobalThis.js';
-let _holder;
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+import { computeIfAbsent } from "../objects/computeIfAbsent.js";
+import { getGlobalThis } from "../web/getGlobalThis.js";
+var _holder;
 export function setGlobalStates(a, b) {
-    if (typeof a === 'string') {
-        let s = getGlobalStates();
-        const last = s[a];
+    if (typeof a === "string") {
+        var s = getGlobalStates();
+        var last = s[a];
         s[a] = b;
         return last;
-    } else if (typeof a === 'object') {
+    }
+    else if ((typeof a === "undefined" ? "undefined" : _type_of(a)) === "object") {
         _holder = a;
     }
 }
 export function getGlobalStates(key, create) {
-    _holder ||= getGlobalThis().__GLOBAL_STATES__ ||= {};
+    var _getGlobalThis;
+    _holder || (_holder = (_getGlobalThis = getGlobalThis()).__GLOBAL_STATES__ || (_getGlobalThis.__GLOBAL_STATES__ = {}));
     if (key) {
         if (!create) {
             return _holder[key];
@@ -21,5 +27,3 @@ export function getGlobalStates(key, create) {
     }
     return _holder;
 }
-
-//# sourceMappingURL=getGlobalStates.js.map

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

@@ -1,5 +1,3 @@
 export function ifPresent(value, fn) {
     return value ? fn(value) : undefined;
 }
-
-//# sourceMappingURL=ifPresent.js.map

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/parseDate.js

@@ -0,0 +1,20 @@
+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 parseDate(value) {
+    if (!value) {
+        return undefined;
+    }
+    if (_instanceof(value, Date)) {
+        return value;
+    }
+    var parsed = new Date(value);
+    if (isNaN(parsed.getTime())) {
+        return undefined;
+    }
+    return parsed;
+}

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