@wener/utils 1.1.51 → 1.1.54

package/lib/objects/get.test-d.js

@@ -1,33 +1,31 @@
-import { expectTypeOf, test } from 'vitest';
-import { get } from './get.js';
-test('get typing', ()=>{
+import { expectTypeOf, test } from "vitest";
+import { get } from "./get.js";
+test("get typing", function () {
     // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    const obj = {};
-    expectTypeOf(get(obj, 'nested.a', null)).toMatchTypeOf();
-    expectTypeOf(get(obj, 'normal', null)).toMatchTypeOf();
-    expectTypeOf(get(obj, 'nested.a')).toMatchTypeOf();
-    expectTypeOf(get(obj, 'nested.b.c')).toMatchTypeOf();
-    expectTypeOf(get(obj, 'arr')).toMatchTypeOf();
-    expectTypeOf(get(obj, 'arr[13]')).toMatchTypeOf();
+    var obj = {};
+    expectTypeOf(get(obj, "nested.a", null)).toMatchTypeOf();
+    expectTypeOf(get(obj, "normal", null)).toMatchTypeOf();
+    expectTypeOf(get(obj, "nested.a")).toMatchTypeOf();
+    expectTypeOf(get(obj, "nested.b.c")).toMatchTypeOf();
+    expectTypeOf(get(obj, "arr")).toMatchTypeOf();
+    expectTypeOf(get(obj, "arr[13]")).toMatchTypeOf();
     // @ts-ignore
-    expectTypeOf(get(obj, 'arr.13')).toMatchTypeOf();
-    expectTypeOf(get(obj, 'nestedArr[3].other')).toMatchTypeOf();
+    expectTypeOf(get(obj, "arr.13")).toMatchTypeOf();
+    expectTypeOf(get(obj, "nestedArr[3].other")).toMatchTypeOf();
     // @ts-ignore
-    expectTypeOf(get(obj, 'deep.deep')).toMatchTypeOf();
-    expectTypeOf(get(obj, 'deep.arr[333]')).toMatchTypeOf();
-    expectTypeOf(get(obj, 'deep.arr[333].length')).toMatchTypeOf();
+    expectTypeOf(get(obj, "deep.deep")).toMatchTypeOf();
+    expectTypeOf(get(obj, "deep.arr[333]")).toMatchTypeOf();
+    expectTypeOf(get(obj, "deep.arr[333].length")).toMatchTypeOf();
     // @ts-ignore
-    expectTypeOf(get(obj, 'nested["b"]["c"]')).toMatchTypeOf();
+    expectTypeOf(get(obj, "nested[\"b\"][\"c\"]")).toMatchTypeOf();
     // @ts-ignore
-    expectTypeOf(get(obj, '')).toMatchTypeOf();
-    expectTypeOf(get(obj, '', 3)).toMatchTypeOf();
+    expectTypeOf(get(obj, "")).toMatchTypeOf();
+    expectTypeOf(get(obj, "", 3)).toMatchTypeOf();
     // @ts-ignore
-    expectTypeOf(get(obj, 'nested.asdfasdf')).toMatchTypeOf();
-    expectTypeOf(get(obj, 'deeplvl1[1].deeplvl2.deeplvl3[88].deeplvl4.value')).toMatchTypeOf();
+    expectTypeOf(get(obj, "nested.asdfasdf")).toMatchTypeOf();
+    expectTypeOf(get(obj, "deeplvl1[1].deeplvl2.deeplvl3[88].deeplvl4.value")).toMatchTypeOf();
     // @ts-ignore
-    expectTypeOf(get(obj, 'deeplvl1[1].deeplvl2.deeplvl1[88].deeplvl4.value')).toMatchTypeOf();
-    expectTypeOf(get(obj, 'deeplvl1[1].deeplvl2.deeplvl1[88].deeplvl4.value', obj)).toMatchTypeOf();
-    expectTypeOf(get(obj, 'nested["dd"]', '')).toMatchTypeOf();
+    expectTypeOf(get(obj, "deeplvl1[1].deeplvl2.deeplvl1[88].deeplvl4.value")).toMatchTypeOf();
+    expectTypeOf(get(obj, "deeplvl1[1].deeplvl2.deeplvl1[88].deeplvl4.value", obj)).toMatchTypeOf();
+    expectTypeOf(get(obj, "nested[\"dd\"]", "")).toMatchTypeOf();
 });
-
-//# sourceMappingURL=get.test-d.js.map

package/lib/objects/merge/index.js

@@ -1,3 +1 @@
-export { merge } from './merge.js';
-
-//# sourceMappingURL=index.js.map
+export { merge } from "./merge.js";

package/lib/objects/merge/isMergeableObject.js

@@ -1,9 +1,13 @@
 // https://github.com/TehShrike/is-mergeable-object/blob/master/index.js
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
 export function isMergeableObject(value) {
     return isNonNullObject(value) && !isSpecial(value);
 }
 function isNonNullObject(value) {
-    return !!value && typeof value === 'object';
+    return !!value && (typeof value === "undefined" ? "undefined" : _type_of(value)) === 'object';
 }
 function isSpecial(value) {
     var stringValue = Object.prototype.toString.call(value);
@@ -15,5 +19,3 @@ var REACT_ELEMENT_TYPE = canUseSymbol ? Symbol.for('react.element') : 0xeac7;
 function isReactElement(value) {
     return value.$$typeof === REACT_ELEMENT_TYPE;
 }
-
-//# sourceMappingURL=isMergeableObject.js.map

package/lib/objects/merge/merge.js

@@ -1,5 +1,59 @@
 // https://github.com/TehShrike/deepmerge/blob/master/index.js
-import { isMergeableObject as defaultIsMergeableObject } from './isMergeableObject.js';
+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 _object_spread(target) {
+    for (var i = 1; i < arguments.length; i++) {
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function (key) {
+            _define_property(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function ownKeys(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        if (enumerableOnly) {
+            symbols = symbols.filter(function (sym) {
+                return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+            });
+        }
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _object_spread_props(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    }
+    else {
+        ownKeys(Object(source)).forEach(function (key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+    }
+    return target;
+}
+import { isMergeableObject as defaultIsMergeableObject } from "./isMergeableObject.js";
 function emptyTarget(val) {
     return Array.isArray(val) ? [] : {};
 }
@@ -7,7 +61,7 @@ function cloneUnlessOtherwiseSpecified(value, options) {
     return options.clone !== false && options.isMergeableObject(value) ? merge(emptyTarget(value), value, options) : value;
 }
 function defaultArrayMerge(target, source, options) {
-    return target.concat(source).map(function(element) {
+    return target.concat(source).map(function (element) {
         return cloneUnlessOtherwiseSpecified(element, options);
     });
 }
@@ -16,10 +70,10 @@ function getMergeFunction(key, options) {
         return merge;
     }
     var customMerge = options.customMerge(key);
-    return typeof customMerge === 'function' ? customMerge : merge;
+    return typeof customMerge === "function" ? customMerge : merge;
 }
 function getEnumerableOwnPropertySymbols(target) {
-    return Object.getOwnPropertySymbols ? Object.getOwnPropertySymbols(target).filter(function(symbol) {
+    return Object.getOwnPropertySymbols ? Object.getOwnPropertySymbols(target).filter(function (symbol) {
         return Object.propertyIsEnumerable.call(target, symbol);
     }) : [];
 }
@@ -29,62 +83,64 @@ function getKeys(target) {
 function propertyIsOnObject(object, property) {
     try {
         return property in object;
-    } catch (_) {
+    }
+    catch (_) {
         return false;
     }
 }
 // Protects from prototype poisoning and unexpected merging up the prototype chain.
 function propertyIsUnsafe(target, key) {
-    return propertyIsOnObject(target, key) && // Properties are safe to merge if they don't exist in the target yet,
-    !(Object.hasOwnProperty.call(target, key) && // unsafe if they exist up the prototype chain,
-    Object.propertyIsEnumerable.call(target, key)); // and also unsafe if they're nonenumerable.
+    return propertyIsOnObject(target, key) // Properties are safe to merge if they don't exist in the target yet,
+        && !(Object.hasOwnProperty.call(target, key) // unsafe if they exist up the prototype chain,
+            && Object.propertyIsEnumerable.call(target, key)); // and also unsafe if they're nonenumerable.
 }
 function mergeObject(target, source, options) {
-    const destination = {};
+    var destination = {};
     if (options.isMergeableObject(target)) {
-        getKeys(target).forEach((key)=>{
+        getKeys(target).forEach(function (key) {
             destination[key] = cloneUnlessOtherwiseSpecified(target[key], options);
         });
     }
-    getKeys(source).forEach((key)=>{
+    getKeys(source).forEach(function (key) {
         if (propertyIsUnsafe(target, key)) {
             return;
         }
         if (propertyIsOnObject(target, key) && options.isMergeableObject(source[key])) {
             destination[key] = getMergeFunction(key, options)(target[key], source[key], options);
-        } else {
+        }
+        else {
             destination[key] = cloneUnlessOtherwiseSpecified(source[key], options);
         }
     });
     return destination;
 }
 export function merge(target, source, opts) {
-    const options = {
+    var options = _object_spread_props(_object_spread({
         arrayMerge: defaultArrayMerge,
-        isMergeableObject: defaultIsMergeableObject,
-        ...opts,
+        isMergeableObject: defaultIsMergeableObject
+    }, opts), {
         // cloneUnlessOtherwiseSpecified is added to `options` so that custom arrayMerge()
         // implementations can use it. The caller may not replace it.
-        cloneUnlessOtherwiseSpecified
-    };
-    let sourceIsArray = Array.isArray(source);
-    let targetIsArray = Array.isArray(target);
-    let sourceAndTargetTypesMatch = sourceIsArray === targetIsArray;
+        cloneUnlessOtherwiseSpecified: cloneUnlessOtherwiseSpecified
+    });
+    var sourceIsArray = Array.isArray(source);
+    var targetIsArray = Array.isArray(target);
+    var sourceAndTargetTypesMatch = sourceIsArray === targetIsArray;
     if (!sourceAndTargetTypesMatch) {
         return cloneUnlessOtherwiseSpecified(source, options);
-    } else if (sourceIsArray) {
+    }
+    else if (sourceIsArray) {
         return options.arrayMerge(target, source, options);
-    } else {
+    }
+    else {
         return mergeObject(target, source, options);
     }
 }
 merge.all = function deepmergeAll(array, options) {
     if (!Array.isArray(array)) {
-        throw new Error('first argument should be an array');
+        throw new Error("first argument should be an array");
     }
-    return array.reduce(function(prev, next) {
+    return array.reduce(function (prev, next) {
         return merge(prev, next, options);
     }, {});
 };
-
-//# sourceMappingURL=merge.js.map