@arrai-innovations/reactive-helpers 11.3.0 → 11.4.0

package/.circleci/config.yml

@@ -1,8 +1,8 @@
 version: 2.1
 orbs:
-    eslint: arrai/eslint@7.6.0
-    prettier: arrai/prettier@5.5.0
-    npm: arrai/npm@2.9.0
+    eslint: arrai/eslint@7.8.0
+    prettier: arrai/prettier@5.7.0
+    npm: arrai/npm@2.11.0
     github: arrai/github@1.1.0
 workflows:
     test:
@@ -46,7 +46,7 @@ workflows:
                           ignore: /.*/
     lint:
         jobs:
-            - eslint/eslint:
+            - eslint/eslint_fixed_ip:
                   name: eslint
                   context: arrai-global
                   files: "."
@@ -72,7 +72,7 @@ workflows:
                       branches:
                           ignore:
                               - main
-            - prettier/code_style:
+            - prettier/code_style_fixed_ip:
                   name: prettier
                   context: arrai-global
                   filters:

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@arrai-innovations/reactive-helpers",
-    "version": "11.3.0",
+    "version": "11.4.0",
     "description": "VueJS 3 utility composition functions to help manipulate objects and lists.",
     "main": "index.js",
     "type": "module",
@@ -28,7 +28,7 @@
     "homepage": "https://github.com/arrai-innovations/reactive-helpers#readme",
     "devDependencies": {
         "@arrai-innovations/commitlint-config": "^1.1.0",
-        "@commitlint/cli": "^16.2.4",
+        "@commitlint/cli": "^18.4.3",
         "@godaddy/dmd": "^1.0.4",
         "@trivago/prettier-plugin-sort-imports": "^4.1.1",
         "@vitest/coverage-v8": "^0.32.2",

package/tests/unit/.eslintrc.cjs

@@ -6,5 +6,6 @@ module.exports = {
     },
     rules: {
         "vitest/no-conditional-expect": "off",
+        "vitest/valid-expect": "off", // we want to use expect(value, message).toBe(expected), which is not supported by this rule
     },
 };

package/tests/unit/utils/deleteKey.spec.js

@@ -0,0 +1,265 @@
+import { del, lodashLikePathSplit } from "../../../utils/deleteKey.js";
+
+describe("utils/deleteKey.js", () => {
+    describe("pathSplitRegex", () => {
+        const tests = [
+            {
+                path: "",
+                expected: [""],
+                obj: {},
+            },
+            {
+                path: "a",
+                expected: ["a"],
+                obj: { a: 1 },
+            },
+            {
+                path: "a.",
+                expected: ["a", ""],
+                obj: { a: 1 },
+            },
+            {
+                path: "a.b.c",
+                expected: ["a", "b", "c"],
+                obj: { a: { b: { c: 1 } } },
+            },
+            {
+                path: "a[b[c]]",
+                expected: ["a", "b", "c"],
+                obj: { a: { b: { c: 1 } } },
+            },
+            {
+                path: "a.b.",
+                expected: ["a", "b", ""],
+                obj: { a: { b: { c: 1 } } },
+            },
+            {
+                path: "a[b[1]]",
+                expected: ["a", "b", "1"],
+                obj: { a: { b: [1, 2, 3] } },
+            },
+            {
+                path: "a[b[1].c]",
+                expected: ["a", "b", "1", "c"],
+                obj: { a: { b: [{ c: 1 }, { c: 2 }, { c: 3 }] } },
+            },
+            {
+                path: "a[1]",
+                expected: ["a", "1"],
+                obj: { a: [1, 2, 3] },
+            },
+            {
+                path: "a[1].b",
+                expected: ["a", "1", "b"],
+                obj: { a: [{ b: 1 }, { b: 2 }, { b: 3 }] },
+            },
+            {
+                path: "a[1].b[1]",
+                expected: ["a", "1", "b", "1"],
+                obj: { a: [{ b: [1, 2, 3] }, { b: [4, 5, 6] }, { b: [7, 8, 9] }] },
+            },
+            {
+                path: "a[1].",
+                expected: ["a", "1", ""],
+                obj: { a: [{}, {}, {}] },
+            },
+            {
+                path: "a[1].b[1].",
+                expected: ["a", "1", "b", "1", ""],
+                obj: { a: [{ b: [1, {}, 3] }, { b: [4, {}, 6] }, { b: [7, {}, 9] }] },
+            },
+            {
+                path: "a[1].c",
+                expected: ["a", "1", "c"],
+                obj: { a: [{ b: [1, 2, 3] }, { b: [4, 5, 6] }, { c: [7, 8, 9] }] },
+            },
+            {
+                path: "c[",
+                expected: ["c["],
+                obj: { "c[": 1 },
+            },
+            {
+                path: "c[1",
+                expected: ["c[1"],
+                obj: { "c[1": 1 },
+            },
+            {
+                path: "c]",
+                expected: ["c]"],
+                obj: { "c]": 1 },
+            },
+            {
+                path: "c1]",
+                expected: ["c1]"],
+                obj: { "c1]": 1 },
+            },
+            {
+                path: "$property",
+                expected: ["$property"],
+                obj: { $property: 1 },
+            },
+            {
+                path: "~path",
+                expected: ["~path"],
+                obj: { "~path": 1 },
+            },
+            {
+                path: "name_with_special$characters",
+                expected: ["name_with_special$characters"],
+                obj: { name_with_special$characters: 1 },
+            },
+            {
+                path: "a[1][1]",
+                expected: ["a", "1", "1"],
+                obj: [{ a: [1, 2, 3] }, { a: [4, 5, 6] }, { a: [7, 8, 9] }],
+            },
+            {
+                path: "b[[1]]",
+                expected: ["b", "1"],
+                obj: [{ b: [1, 2, 3] }, { b: [4, 5, 6] }, { b: [7, 8, 9] }],
+            },
+            {
+                path: "c[1][",
+                expected: ["c", "1"],
+                obj: {
+                    c: [{}, { "[": 1 }, {}],
+                },
+            },
+            {
+                path: "c[1][",
+                expected: ["c[1]["],
+                obj: {
+                    "c[1][": 1,
+                },
+            },
+            {
+                path: "c[[2]",
+                expected: ["c", "2"],
+                obj: {
+                    c: [1, 2, 3],
+                },
+            },
+            {
+                path: "c[1][.f[3]",
+                expected: ["c", "1", "f", "3"],
+                obj: {
+                    c: [{}, { f: [1, 2, 3, 4] }],
+                },
+            },
+            {
+                path: "c[1][.f[3]",
+                expected: ["c[1][.f[3]"],
+                obj: {
+                    "c[1][.f[3]": 1,
+                },
+            },
+            {
+                path: "[1][1]",
+                expected: ["1", "1"],
+                obj: [
+                    [1, 2, 3],
+                    [4, 5, 6],
+                    [7, 8, 9],
+                ],
+            },
+        ];
+        for (let i = 0; i < tests.length; i++) {
+            it(`should split ${tests[i].path}`, () => {
+                const path = tests[i].path;
+                const expected = tests[i].expected;
+                const obj = tests[i].obj;
+                const actual = lodashLikePathSplit(path, obj);
+                expect(actual, `Failed on path ${path} for obj ${JSON.stringify(obj)}`).toEqual(expected);
+            });
+        }
+    });
+    describe("del", () => {
+        describe("Basic Cases", () => {
+            it("should delete a key from an object", () => {
+                const obj = { a: 1, b: 2 };
+                del(obj, "a");
+                expect(obj).toEqual({ b: 2 });
+            });
+            it("should delete a deep key from an object", () => {
+                const obj = { a: { b: { c: 1 } } };
+                del(obj, "a.b.c");
+                expect(obj).toEqual({ a: { b: {} } });
+            });
+            it("should delete an index from an array", () => {
+                const obj = { a: [1, 2, 3] };
+                del(obj, "a[1]");
+                expect(obj).toEqual({ a: [1, undefined, 3] });
+            });
+            it("should delete a deep index from an array", () => {
+                const obj = { a: [{ b: 1 }, { b: 2 }, { b: 3 }] };
+                del(obj, "a[1].b");
+                expect(obj).toEqual({ a: [{ b: 1 }, {}, { b: 3 }] });
+            });
+            it("should delete a deep index from a key with multiple indexes", () => {
+                const obj = { a: [{ b: [1, 2, 3] }, { b: [4, 5, 6] }, { b: [7, 8, 9] }] };
+                del(obj, "a[1].b[1]");
+                expect(obj).toEqual({ a: [{ b: [1, 2, 3] }, { b: [4, undefined, 6] }, { b: [7, 8, 9] }] });
+            });
+        });
+        describe("Edge Cases", () => {
+            it("should handle deleting a non-existent key", () => {
+                const obj = { a: 1, b: 2 };
+                del(obj, "c");
+                expect(obj).toEqual({ a: 1, b: 2 });
+            });
+            it("should handled deleting a key in a non-existent object", () => {
+                const obj = { a: 1, b: 2 };
+                del(obj, "c.d");
+                expect(obj).toEqual({ a: 1, b: 2 });
+            });
+            it("should handle deleting an index in a non-existent array", () => {
+                const obj = { a: 1, b: 2 };
+                del(obj, "c[0]");
+                expect(obj).toEqual({ a: 1, b: 2 });
+            });
+            it("should handle deleting a non-existent index in an array", () => {
+                const obj = { a: [1, 2, 3] };
+                del(obj, "a[3]");
+                expect(obj).toEqual({ a: [1, 2, 3] });
+            });
+            it("should handle deleting a non-existent index in a deep array", () => {
+                const obj = { a: [{ b: [1, 2, 3] }, { b: [4, 5, 6] }, { b: [7, 8, 9] }] };
+                del(obj, "a[1].b[3]");
+                expect(obj).toEqual({ a: [{ b: [1, 2, 3] }, { b: [4, 5, 6] }, { b: [7, 8, 9] }] });
+            });
+            it("should handled unpaired brackets as a key", () => {
+                const obj = { a: 1, b: 2, "c[": 3 };
+                del(obj, "c[");
+                expect(obj).toEqual({ a: 1, b: 2 });
+            });
+            it("should handle deleting a key with a trailing dot", () => {
+                const obj = { a: 1, b: 2 };
+                del(obj, "a.");
+                expect(obj).toEqual({ a: 1, b: 2 });
+            });
+            it("should handle deleting a key with a trailing dot in a deep object", () => {
+                const obj = { a: { b: { c: 1 } } };
+                del(obj, "a.b.");
+                expect(obj).toEqual({ a: { b: { c: 1 } } });
+            });
+            it("should handle an array as the root object", () => {
+                const obj = [1, 2, 3];
+                del(obj, "[1]");
+                expect(obj).toEqual([1, undefined, 3]);
+            });
+            it("should handle nested arrays as the root object", () => {
+                const obj = [
+                    [1, 2, 3],
+                    [4, 5, 6],
+                    [7, 8, 9],
+                ];
+                del(obj, "[1][1]");
+                expect(obj).toEqual([
+                    [1, 2, 3],
+                    [4, undefined, 6],
+                    [7, 8, 9],
+                ]);
+            });
+        });
+    });
+});

package/utils/deleteKey.js

@@ -0,0 +1,50 @@
+import isKey from "lodash-es/_isKey.js";
+import isArray from "lodash-es/isArray.js";
+import isSymbol from "lodash-es/isSymbol.js";
+
+const reEscapeChar = /\\(\\)?/g;
+const rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g;
+
+function toKey(value) {
+    if (typeof value == "string" || isSymbol(value)) {
+        return value;
+    }
+    var result = value + "";
+    // noinspection EqualityComparisonWithCoercionJS
+    return result == "0" && 1 / value == -(1 / 0) ? "-0" : result;
+}
+
+export function lodashLikePathSplit(string, object) {
+    if (isArray(string)) {
+        return string;
+    }
+    if (isKey(string, object)) {
+        return [string];
+    }
+    const result = [];
+    if (string.charCodeAt(0) === 46 /* . */) {
+        result.push("");
+    }
+    string.replace(rePropName, function (match, number, quote, subString) {
+        result.push(quote ? subString.replace(reEscapeChar, "$1") : number || match);
+    });
+    return result;
+}
+
+export function del(obj, path) {
+    // lodash-like delete function, as companion for get/set
+    if (!obj) {
+        return;
+    }
+    const pathArray = lodashLikePathSplit(path, obj);
+    let index = 0;
+    const length = pathArray.length;
+
+    while (obj != null && index < length - 1) {
+        obj = obj[toKey(pathArray[index++])];
+    }
+    if (!obj) {
+        return;
+    }
+    delete obj[toKey(pathArray[index])];
+}

package/utils/index.js

@@ -3,6 +3,7 @@ export * from "./classes.js";
 export * from "./compact.js";
 export * from "./debugMessage.js";
 export * from "./debugWatch.js";
+export * from "./deleteKey.js";
 export * from "./flattenPaths.js";
 export * from "./getFakeId.js";
 export * from "./keyDiff.js";