@arrai-innovations/reactive-helpers 11.3.0 → 11.4.1

package/.circleci/config.yml

@@ -1,34 +1,34 @@
 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:
         jobs:
-            #            - npm/coverage:
-            #                  name: tests
-            #                  context: arrai-global
-            #                  filters:
-            #                      branches:
-            #                          only:
-            #                              - main
-            #            - npm/coverage:
-            #                  name: tests-no-badge
-            #                  context: arrai-global
-            #                  create_badges: false
-            #                  filters:
-            #                      tags:
-            #                          only: /.*/
-            #                      branches:
-            #                          ignore:
-            #                              - main
+            - npm/coverage:
+                  name: tests
+                  context: arrai-global
+                  filters:
+                      branches:
+                          only:
+                              - main
+            - npm/coverage:
+                  name: tests-no-badge
+                  context: arrai-global
+                  create_badges: false
+                  filters:
+                      tags:
+                          only: /.*/
+                      branches:
+                          ignore:
+                              - main
             - npm/publish:
                   name: publish
                   context: arrai-private-package-publishing
-                  #                  requires:
-                  #                      - tests-no-badge
+                  requires:
+                      - tests-no-badge
                   filters:
                       tags:
                           only: /.*/
@@ -37,8 +37,8 @@ workflows:
             - github/create_release:
                   name: release_on_github
                   context: arrai-global
-                  #                  requires:
-                  #                      - tests-no-badge
+                  requires:
+                      - tests-no-badge
                   filters:
                       tags:
                           only: /.*/
@@ -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.1",
     "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/use/listInstance.spec.js

@@ -593,12 +593,14 @@ describe("use/listInstance.spec.js", function () {
             expect(isReadonly(passedIsCancelled)).toBe(true);
             expect(passedIsCancelled.value).toBe(false);
             expect(cancelablePromise.cancel).toBeTruthy();
+            expect(listInstance.state.loading).toBe(true);
 
             const cancelPromise = cancelablePromise.cancel();
             myListFnCancelResolve();
             await cancelPromise;
 
             expect(passedIsCancelled.value).toBe(true);
+            expect(listInstance.state.loading).toBe(false);
         });
     });
 });

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/use/listCalculated.js

@@ -67,10 +67,6 @@ export function useListCalculated({ parentState, calculatedObjectsRules }) {
     function calculatedObjectsWatch() {
         const calculatedObjectsRulesIsEmpty = !state.calculatedObjectsRules || isEmpty(state.calculatedObjectsRules);
         for (const objectKey of Object.keys(state.calculatedObjects)) {
-            const originalObject = toRef(parentState.objects, objectKey);
-            const relatedObject = parentState.relatedObjects
-                ? toRef(parentState.relatedObjects, objectKey)
-                : ref(undefined);
             if (!state.calculatedObjects[objectKey]) {
                 state.calculatedObjects[objectKey] = {};
             }
@@ -96,12 +92,16 @@ export function useListCalculated({ parentState, calculatedObjectsRules }) {
             if (!calculatedObjectsEffectScopes[objectKey]) {
                 calculatedObjectsEffectScopes[objectKey] = effectScope();
             }
+            const originalObjectRef = toRef(parentState.objects, objectKey);
+            const relatedObjectRef = parentState.relatedObjects
+                ? toRef(parentState.relatedObjects, objectKey)
+                : ref(undefined);
             calculatedObjectsEffectScopes[objectKey].run(() => {
                 for (const addedRuleKey of addedRuleKeys) {
                     calculatedObjectsObject[addedRuleKey] = computed(() =>
                         state.calculatedObjectsRules?.[addedRuleKey]?.(
-                            unref(originalObject),
-                            unref(relatedObject),
+                            unref(originalObjectRef),
+                            unref(relatedObjectRef),
                             calculatedObjectsObject
                         )
                     );

package/use/listInstance.js

@@ -198,6 +198,7 @@ export function useListInstance({ props, functions = {}, keepOldPages = false })
                 if (promise) {
                     await promise;
                 }
+                state.loading = false;
             };
         }
         // the indirection of promises here is to allow us to do additional work on listPromise's cancel

package/use/listRelated.js

@@ -92,8 +92,6 @@ export function useListRelated({ parentState, relatedObjectsRules }) {
     function relatedObjectsWatch() {
         const relatedObjectsRulesIsEmpty = !state.relatedObjectsRules || isEmpty(state.relatedObjectsRules);
         for (const objectKey of Object.keys(state.relatedObjects)) {
-            const originalObjectRef = toRef(parentState.objects, objectKey);
-            const relatedObjectRef = toRef(state.relatedObjects, objectKey);
             let removedRuleKeys, addedRuleKeys;
             if (!relatedObjectsRulesIsEmpty) {
                 ({ removedKeys: removedRuleKeys, addedKeys: addedRuleKeys } = keyDiff(
@@ -119,6 +117,8 @@ export function useListRelated({ parentState, relatedObjectsRules }) {
                 if (!relatedObjectsEffectScopes[objectKey]) {
                     relatedObjectsEffectScopes[objectKey] = effectScope();
                 }
+                const originalObjectRef = toRef(parentState.objects, objectKey);
+                const relatedObjectRef = toRef(state.relatedObjects, objectKey);
                 relatedObjectsEffectScopes[objectKey].run(() => {
                     for (const addedRuleKey of addedRuleKeys) {
                         const rules = toRef(state.relatedObjectsRules, addedRuleKey);

package/use/objectRelated.js

@@ -79,7 +79,6 @@ export function useObjectRelated({ parentState, relatedObjectRules }) {
                         // deal with computed objects being passed.
                         const ruleObjects = unref(state.relatedObjectRules?.[addedRuleKey]?.objects);
                         const rulePkKey = state.relatedObjectRules?.[addedRuleKey]?.pkKey || addedRuleKey;
-                        const ruleOrder = unref(state.relatedObjectRules?.[addedRuleKey]?.order);
                         if (!ruleObjects || !rulePkKey) {
                             state.relatedObject[addedRuleKey] = undefined;
                             return;
@@ -90,6 +89,7 @@ export function useObjectRelated({ parentState, relatedObjectRules }) {
                             return;
                         }
                         if (isArray(value)) {
+                            const ruleOrder = unref(state.relatedObjectRules?.[addedRuleKey]?.order);
                             // the related list could be sorted differently than the original list.
                             if (ruleOrder?.length) {
                                 value = value.filter(identity);

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";