@arrai-innovations/reactive-helpers 11.2.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/docs.md

@@ -686,12 +686,13 @@ The configuration options used to create a list subscription.
 **Kind**: global typedef  
 **Properties**
 
-| Name         | Type             | Description                                                                              |
-| ------------ | ---------------- | ---------------------------------------------------------------------------------------- |
-| props        | `object`         | passed on to a created list instance if one is not provided                              |
-| functions    | `object`         | passed on to a created list instance if one is not provided                              |
-| listInstance | [`ListInstance`] | a list instance to use instead of creating one                                           |
-| keepOldPages | `boolean`        | if true, pages will not be cleared when defaultPageCallback is called. default is false. |
+| Name                           | Type             | Description                                                                              |
+| ------------------------------ | ---------------- | ---------------------------------------------------------------------------------------- |
+| props                          | `object`         | passed on to a created list instance if one is not provided                              |
+| functions                      | `object`         | passed on to a created list instance if one is not provided                              |
+| listInstance                   | [`ListInstance`] | a list instance to use instead of creating one                                           |
+| keepOldPages                   | `boolean`        | if true, pages will not be cleared when defaultPageCallback is called. default is false. |
+| clearListOnListIntentTriggered | `boolean`        | if true, the list will be cleared when the list intent is triggered. default is false.   |
 
 ## ListSubscriptionState
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@arrai-innovations/reactive-helpers",
-    "version": "11.2.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/use/listSubscription.spec.js

@@ -615,4 +615,52 @@ describe("use/listSubscription.spec.js", function () {
         expect(inspect(listSubscription.A)).toEqual(inspect(listSubscriptionA));
         expect(inspect(listSubscription.B)).toEqual(inspect(listSubscriptionB));
     });
+    describe("clearListOnListIntentTriggered true", function () {
+        it("on true", async function () {
+            crudSubscribeResolvable[0].promise.cancel.mockImplementation(() => Promise.resolve(true));
+            const listArgs = reactive({
+                user: 1,
+            });
+            const retrieveArgs = reactive({
+                fields: fields,
+            });
+            const listInstance = useListInstance({
+                props: { listArgs, retrieveArgs },
+            });
+            listInstance.clearList = vi.fn().mockImplementationOnce(() => undefined);
+            const listSubscription = useListSubscription({
+                listInstance,
+                clearListOnListIntentTriggered: true,
+            });
+            listSubscription.subscribe();
+            await nextTick();
+            await flushPromises();
+            listArgs.user = 2;
+            expect(listInstance.clearList).toHaveBeenCalledTimes(1);
+        });
+    });
+    describe("clearListOnListIntentTriggered false", function () {
+        it("on true", async function () {
+            crudSubscribeResolvable[0].promise.cancel.mockImplementation(() => Promise.resolve(true));
+            const listArgs = reactive({
+                user: 1,
+            });
+            const retrieveArgs = reactive({
+                fields: fields,
+            });
+            const listInstance = useListInstance({
+                props: { listArgs, retrieveArgs },
+            });
+            listInstance.clearList = vi.fn().mockImplementationOnce(() => undefined);
+            const listSubscription = useListSubscription({
+                listInstance,
+                clearListOnListIntentTriggered: false,
+            });
+            listSubscription.subscribe();
+            await nextTick();
+            await flushPromises();
+            listArgs.user = 2;
+            expect(listInstance.clearList).toHaveBeenCalledTimes(0);
+        });
+    });
 });

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

@@ -31,6 +31,7 @@ export const useList = ({
     functions = {},
     paged = false,
     keepOldPages = false,
+    clearListOnListIntentTriggered = false,
     searchThrottle = 500,
     sortThrottleWait,
     searchShowAllWhenEmpty,
@@ -63,6 +64,7 @@ export const useList = ({
 
         managed.listSubscription = useListSubscription({
             listInstance: managed.listInstance,
+            clearListOnListIntentTriggered,
         });
         managed.listSubscription.state.intendToList = toRef(props, "intendToList");
         managed.listSubscription.state.intendToSubscribe = toRef(props, "intendToSubscribe");

package/use/listSubscription.js

@@ -22,6 +22,7 @@ export class ListSubscriptionError extends Error {
  * @property {object} functions - passed on to a created list instance if one is not provided
  * @property {ListInstance} listInstance - a list instance to use instead of creating one
  * @property {boolean} keepOldPages - if true, pages will not be cleared when defaultPageCallback is called. default is false.
+ * @property {boolean} clearListOnListIntentTriggered - if true, the list will be cleared when the list intent is triggered. default is false.
  */
 
 /* eslint-disable jsdoc/check-types */
@@ -70,7 +71,13 @@ export function useListSubscriptions(args, listInstances = {}) {
  * @param {ListSubscriptionOptions} options - the configuration options for the list subscription
  * @returns {ListSubscription} - the list subscription
  */
-export function useListSubscription({ listInstance, props, functions, keepOldPages = false }) {
+export function useListSubscription({
+    listInstance,
+    props,
+    functions,
+    keepOldPages = false,
+    clearListOnListIntentTriggered = false,
+}) {
     if (!listInstance && !props) {
         throw new ListSubscriptionError("useListSubscription should be passed listInstance or props and functions.");
     }
@@ -233,7 +240,12 @@ export function useListSubscription({ listInstance, props, functions, keepOldPag
         state.subscribed = toRef(subscribeIntent.state, "active");
 
         listIntent = useCancellableIntent({
-            awaitableWithCancel: listInstance.list,
+            awaitableWithCancel: () => {
+                if (clearListOnListIntentTriggered) {
+                    listInstance.clearList();
+                }
+                return listInstance.list();
+            },
             watchArguments: reactive({
                 intendToList: toRef(state, "intendToList"),
                 listArgs: toRef(parentState, "listArgs"),

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