@wener/utils 1.1.51 → 1.1.53

package/lib/objects/parseObjectPath.js

@@ -12,28 +12,60 @@
             s
         ];
     }
-    const parts = s.split('.');
+    var parts = s.split('.');
     // fast path
     if (!s.includes('[')) {
         return parts;
     }
-    const result = [];
-    for (const part of parts){
-        if (!part.endsWith(']')) {
-            result.push(part);
-        } else {
-            // a[0][1]
-            // try parseInt can extend to support a[-1] to use .at access
-            const s = part.split('[');
-            for (let sub of s){
-                if (sub.endsWith(']')) {
-                    sub = sub.slice(0, -1);
+    var result = [];
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = parts[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var part = _step.value;
+            if (!part.endsWith(']')) {
+                result.push(part);
+            } else {
+                // a[0][1]
+                // try parseInt can extend to support a[-1] to use .at access
+                var _$s = part.split('[');
+                var _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = undefined;
+                try {
+                    for(var _iterator1 = _$s[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true){
+                        var sub = _step1.value;
+                        if (sub.endsWith(']')) {
+                            sub = sub.slice(0, -1);
+                        }
+                        result.push(sub);
+                    }
+                } catch (err) {
+                    _didIteratorError1 = true;
+                    _iteratorError1 = err;
+                } finally{
+                    try {
+                        if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+                            _iterator1.return();
+                        }
+                    } finally{
+                        if (_didIteratorError1) {
+                            throw _iteratorError1;
+                        }
+                    }
                 }
-                result.push(sub);
+            }
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
             }
         }
     }
     return result;
 }
-
-//# sourceMappingURL=parseObjectPath.js.map

package/lib/objects/parseObjectPath.test.js

@@ -0,0 +1,138 @@
+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 { parseObjectPath } from "./parseObjectPath.js";
+test("parseObjectPath", function () {
+    for (var _i = 0, _iter = [
+        [
+            "a.b.c",
+            [
+                "a",
+                "b",
+                "c"
+            ]
+        ],
+        [
+            "a[1].c",
+            [
+                "a",
+                "1",
+                "c"
+            ]
+        ],
+        [
+            "a.1.c",
+            [
+                "a",
+                "1",
+                "c"
+            ]
+        ],
+        [
+            "a[b].c",
+            [
+                "a",
+                "b",
+                "c"
+            ]
+        ],
+        [
+            "arr[1][0]",
+            [
+                "arr",
+                "1",
+                "0"
+            ]
+        ],
+        [
+            "arr.2",
+            [
+                "arr",
+                "2"
+            ]
+        ],
+        [
+            "arr[2]",
+            [
+                "arr",
+                "2"
+            ]
+        ],
+        [
+            Symbol.toStringTag,
+            [
+                Symbol.toStringTag
+            ]
+        ],
+        [
+            [
+                Symbol.toStringTag
+            ],
+            [
+                Symbol.toStringTag
+            ]
+        ]
+    ]; _i < _iter.length; _i++) {
+        var _iter__i = _sliced_to_array(_iter[_i], 2), k = _iter__i[0], v = _iter__i[1];
+        expect(parseObjectPath(k)).toEqual(v);
+    }
+});

package/lib/objects/set.js

@@ -1,32 +1,40 @@
-import { parseObjectPath } from './parseObjectPath.js';
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+import { parseObjectPath } from "./parseObjectPath.js";
 /**
  * Deep set
  *
  * {@link https://github.com/lukeed/dset dset}
- */ export function set(obj, key, val, merging = true) {
-    const path = parseObjectPath(key);
-    let i = 0;
-    const len = path.length;
-    let current = obj;
-    let x, k;
-    while(i < len){
+ */ export function set(obj, key, val) {
+    var merging = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : true;
+    var path = parseObjectPath(key);
+    var i = 0;
+    var len = path.length;
+    var current = obj;
+    var x, k;
+    while (i < len) {
         k = path[i++];
-        if (k === '__proto__' || k === 'constructor' || k === 'prototype') break;
+        if (k === "__proto__" || k === "constructor" || k === "prototype")
+            break;
         // noinspection PointlessArithmeticExpressionJS
-        current = current[k] = i === len ? merging ? merge(current[k], val) : val : typeof (x = current[k]) === typeof path ? x : path[i] * 0 !== 0 || !!~('' + path[i]).indexOf('.') // eslint-disable-line
-         ? {} : [];
+        current = current[k] = i === len ? merging ? merge(current[k], val) : val : _type_of(x = current[k]) === (typeof path === "undefined" ? "undefined" : _type_of(path)) ? x : path[i] * 0 !== 0 || !!~("" + path[i]).indexOf(".") // eslint-disable-line
+            ? {} : [];
     }
 }
 export function merge(a, b) {
-    let k;
-    if (typeof a === 'object' && typeof b === 'object') {
+    var k;
+    if ((typeof a === "undefined" ? "undefined" : _type_of(a)) === "object" && (typeof b === "undefined" ? "undefined" : _type_of(b)) === "object") {
         if (Array.isArray(a) && Array.isArray(b)) {
-            for(k = 0; k < b.length; k++){
+            for (k = 0; k < b.length; k++) {
                 a[k] = merge(a[k], b[k]);
             }
-        } else {
-            for(k in b){
-                if (k === '__proto__' || k === 'constructor' || k === 'prototype') break;
+        }
+        else {
+            for (k in b) {
+                if (k === "__proto__" || k === "constructor" || k === "prototype")
+                    break;
                 a[k] = merge(a[k], b[k]);
             }
         }
@@ -34,5 +42,3 @@ export function merge(a, b) {
     }
     return b;
 }
-
-//# sourceMappingURL=set.js.map