@arrai-innovations/reactive-helpers 1.0.0

package/tests/unit/use/search.spec.js

@@ -0,0 +1,67 @@
+import { doAwaitTimeout } from "../../../utils";
+
+describe("use/search", () => {
+    let useSearch, setDefaultSearchOptions;
+    beforeEach(async () => {
+        const searchModule = await import("../../../use/search");
+        useSearch = searchModule.useSearch;
+        setDefaultSearchOptions = searchModule.setDefaultSearchOptions;
+        setDefaultSearchOptions({
+            throttle: 150,
+        });
+    });
+    it("should allow adding items to the index", async () => {
+        const search = useSearch();
+        search.addIndex(1, "test index value one");
+        search.addIndex(2, "test index value two");
+        search.addIndex(3, "test index value three");
+        await doAwaitTimeout(200);
+        expect(Object.keys(search.state.results)).toEqual([]);
+        search.state.search = "test";
+        await doAwaitTimeout(200);
+        // keys are strings
+        expect(Object.keys(search.state.results)).toEqual(["1", "2", "3"]);
+    });
+    it("should allow removing items from the index", async () => {
+        const search = useSearch();
+        search.addIndex(1, "test index value one");
+        search.addIndex(2, "test index value two");
+        search.addIndex(3, "test index value three");
+        search.state.search = "test";
+        await doAwaitTimeout(200);
+        // keys are strings
+        expect(Object.keys(search.state.results)).toEqual(["1", "2", "3"]);
+        search.removeIndex(2);
+        await doAwaitTimeout(200);
+        expect(Object.keys(search.state.results)).toEqual(["1", "3"]);
+    });
+    it("should allow updating items in the index", async () => {
+        const search = useSearch();
+        search.addIndex(1, "test index value one");
+        search.addIndex(2, "test index value two");
+        search.addIndex(3, "test index value three");
+        search.state.search = "test";
+        await doAwaitTimeout(200);
+        // keys are strings
+        expect(Object.keys(search.state.results)).toEqual(["1", "2", "3"]);
+        search.updateIndex(2, "twest index value two updated");
+        await doAwaitTimeout(200);
+        expect(Object.keys(search.state.results)).toEqual(["1", "3"]);
+        search.state.search = "two";
+        await doAwaitTimeout(200);
+        expect(Object.keys(search.state.results)).toEqual(["2"]);
+    });
+    it("should allow clearing all items from the index", async () => {
+        const search = useSearch();
+        search.addIndex(1, "test index value one");
+        search.addIndex(2, "test index value two");
+        search.addIndex(3, "test index value three");
+        search.state.search = "test";
+        await doAwaitTimeout(200);
+        // keys are strings
+        expect(Object.keys(search.state.results)).toEqual(["1", "2", "3"]);
+        search.clearIndex();
+        await doAwaitTimeout(200);
+        expect(Object.keys(search.state.results)).toEqual([]);
+    });
+});

package/tests/unit/use/watches.spec.js

@@ -0,0 +1,252 @@
+import {
+    AwaitNot,
+    AwaitNotError,
+    AwaitTimeout,
+    AwaitTimeoutError,
+    doAwaitTimeout,
+    ImmediateStopWatch,
+} from "../../../utils";
+import { performance } from "perf_hooks";
+import { nextTick, reactive } from "vue";
+
+describe("use/watches", () => {
+    let timeout, reactiveObject, awaitNot;
+    beforeEach(async () => {
+        reactiveObject = reactive({});
+        awaitNot = new AwaitNot({
+            obj: reactiveObject,
+            prop: "prop",
+            couldAlreadyBeFalse: false,
+            timeout: 500,
+        });
+    });
+    afterEach(() => {
+        jest.resetAllMocks();
+    });
+    describe("doAwaitTimeout", () => {
+        it("should resolve after the passed timeout", async () => {
+            timeout = 200;
+            const start = performance.now();
+            await doAwaitTimeout(timeout);
+            const end = performance.now();
+            expect(end - start).toBeLessThan(timeout * 1.1);
+        });
+        it("rejects the promise when stopped manually", async () => {
+            timeout = 200;
+            const awaitTimeout = new AwaitTimeout(timeout);
+            awaitTimeout.start();
+            setTimeout(() => awaitTimeout.stop(), timeout / 2);
+            await expect(awaitTimeout.promise).rejects.toThrow(AwaitTimeoutError);
+        });
+    });
+    describe("doAwaitNot instance's obj.prop loading pattern begins as undefined...", () => {
+        it("resolves on cycling through true and false && couldAlreadyBeFalse = false", async () => {
+            awaitNot.start();
+            reactiveObject.prop = true;
+            await nextTick();
+            reactiveObject.prop = false;
+            await expect(awaitNot.promise).resolves.toBe(undefined);
+        });
+        it("resolves on cycling through true, true and false && couldAlreadyBeFalse = false", async () => {
+            awaitNot.start();
+            reactiveObject.prop = true;
+            await nextTick();
+            reactiveObject.prop = true;
+            await nextTick();
+            reactiveObject.prop = false;
+            await expect(awaitNot.promise).resolves.toBe(undefined);
+        });
+        it("rejects on cycling through true to undefined && couldAlreadyBeFalse = false", async () => {
+            awaitNot.start();
+            reactiveObject.prop = true;
+            await nextTick();
+            reactiveObject.prop = undefined;
+            await expect(awaitNot.promise).rejects.toThrow(AwaitNotError);
+        });
+        it("rejects as static undefined && couldAlreadyBeFalse: false", async () => {
+            awaitNot.start();
+            await nextTick();
+            await expect(awaitNot.promise).rejects.toThrow(AwaitNotError);
+        });
+        it("resolves on cycling through false && couldAlreadyBeFalse: true", async () => {
+            awaitNot.couldAlreadyBeFalse = true;
+            awaitNot.start();
+            reactiveObject.prop = false;
+            await nextTick();
+            await expect(awaitNot.promise).resolves.toBe(undefined);
+        });
+        it("resolves on cycling through true and false && couldAlreadyBeFalse: true", async () => {
+            awaitNot.couldAlreadyBeFalse = true;
+            awaitNot.start();
+            reactiveObject.prop = true;
+            await nextTick();
+            reactiveObject.prop = false;
+            await nextTick();
+            await expect(awaitNot.promise).resolves.toBe(undefined);
+        });
+        it("rejects on cycling through false and undefined && couldAlreadyBeFalse: true", async () => {
+            awaitNot.couldAlreadyBeFalse = true;
+            awaitNot.start();
+            reactiveObject.prop = false;
+            await nextTick();
+            reactiveObject.prop = undefined;
+            await nextTick();
+            await expect(awaitNot.promise).resolves.toBe(undefined);
+        });
+        it("rejects as static undefined && couldAlreadyBeFalse: true", async () => {
+            awaitNot.couldAlreadyBeFalse = true;
+            awaitNot.start();
+            await nextTick();
+            await expect(awaitNot.promise).rejects.toThrow(AwaitNotError);
+        });
+    });
+    describe("doAwaitNot instance's obj.prop loading pattern begins as false...", () => {
+        it("resolves on cycling through true and false && couldAlreadyBeFalse: false", async () => {
+            reactiveObject.prop = false;
+            awaitNot.start();
+            reactiveObject.prop = true;
+            await nextTick();
+            reactiveObject.prop = false;
+            await expect(awaitNot.promise).resolves.toBe(undefined);
+        });
+        it("resolves on cycling through true, true and false && couldAlreadyBeFalse: false", async () => {
+            reactiveObject.prop = false;
+            awaitNot.start();
+            reactiveObject.prop = true;
+            await nextTick();
+            reactiveObject.prop = true;
+            await nextTick();
+            reactiveObject.prop = false;
+            await expect(awaitNot.promise).resolves.toBe(undefined);
+        });
+        it("resolves as static false && couldAlreadyBeFalse: false", async () => {
+            reactiveObject.prop = false;
+            awaitNot.start();
+            await expect(awaitNot.promise).resolves.toBe(undefined);
+        });
+        it("resolves on cycling through true and false && couldAlreadyBeFalse: true", async () => {
+            awaitNot.couldAlreadyBeFalse = true;
+            reactiveObject.prop = false;
+            awaitNot.start();
+            reactiveObject.prop = true;
+            await nextTick();
+            reactiveObject.prop = false;
+            await expect(awaitNot.promise).resolves.toBe(undefined);
+        });
+        it("resolves on cycling through true, true and false && couldAlreadyBeFalse: true", async () => {
+            awaitNot.couldAlreadyBeFalse = true;
+            reactiveObject.prop = false;
+            awaitNot.start();
+            reactiveObject.prop = true;
+            await nextTick();
+            reactiveObject.prop = true;
+            await nextTick();
+            reactiveObject.prop = false;
+            await expect(awaitNot.promise).resolves.toBe(undefined);
+        });
+        it("rejects as static false && couldAlreadyBeFalse: true", async () => {
+            awaitNot.couldAlreadyBeFalse = true;
+            reactiveObject.prop = false;
+            awaitNot.start();
+            await expect(awaitNot.promise).rejects.toThrow(AwaitNotError);
+        });
+    });
+    describe("doAwaitNot instance's obj.prop loading pattern begins as true...", () => {
+        it("resolves on cycling through true and false && couldAlreadyBeFalse: false", async () => {
+            reactiveObject.prop = true;
+            awaitNot.start();
+            reactiveObject.prop = true;
+            await nextTick();
+            reactiveObject.prop = false;
+            await nextTick();
+            await expect(awaitNot.promise).resolves.toBe(undefined);
+        });
+        it("resolves on cycling through false && couldAlreadyBeFalse: false", async () => {
+            reactiveObject.prop = true;
+            awaitNot.start();
+            reactiveObject.prop = false;
+            await nextTick();
+            await expect(awaitNot.promise).resolves.toBe(undefined);
+        });
+        it("rejects as static true && couldAlreadyBeFalse: false", async () => {
+            reactiveObject.prop = true;
+            awaitNot.start();
+            await expect(awaitNot.promise).rejects.toThrow(AwaitNotError);
+        });
+        it("resolves on cycling through false && couldAlreadyBeFalse: true", async () => {
+            awaitNot.couldAlreadyBeFalse = true;
+            reactiveObject.prop = true;
+            awaitNot.start();
+            reactiveObject.prop = false;
+            await nextTick();
+            await expect(awaitNot.promise).resolves.toBe(undefined);
+        });
+        it("resolves on cycling through true and false && couldAlreadyBeFalse: true", async () => {
+            awaitNot.couldAlreadyBeFalse = true;
+            reactiveObject.prop = true;
+            awaitNot.start();
+            reactiveObject.prop = true;
+            await nextTick();
+            reactiveObject.prop = false;
+            await nextTick();
+            await expect(awaitNot.promise).resolves.toBe(undefined);
+        });
+        it("rejects as static true && couldAlreadyBeFalse: true", async () => {
+            awaitNot.couldAlreadyBeFalse = true;
+            reactiveObject.prop = true;
+            awaitNot.start();
+            await nextTick();
+            await expect(awaitNot.promise).rejects.toThrow(AwaitNotError);
+        });
+    });
+    describe("ImmediateStopWatch", () => {
+        it("responds to multiple calls", async () => {
+            const immediateStopWatch = new ImmediateStopWatch({});
+            reactiveObject.prop = true;
+            const watchSources = () => reactiveObject.prop;
+            const watchFunc = jest.fn();
+            const watchFuncArgs = [reactiveObject.prop];
+
+            const propsList = [true, false, true, false];
+            const cycleProp = async (propsList) => {
+                for (let prop of propsList) {
+                    reactiveObject.prop = prop;
+                    await nextTick();
+                }
+            };
+
+            immediateStopWatch.start(watchSources, watchFunc, watchFuncArgs);
+            reactiveObject.prop = false;
+            await nextTick();
+            expect(watchFunc).toBeCalled();
+            await cycleProp(propsList);
+            expect(watchFunc).toHaveBeenCalledTimes(6);
+        });
+        it("stops when expected", async () => {
+            const immediateStopWatch = new ImmediateStopWatch({});
+            reactiveObject.prop = true;
+            const watchSources = () => reactiveObject.prop;
+            const watchFunc = jest.fn((newValue) => {
+                if (newValue === undefined) {
+                    immediateStopWatch.stop();
+                }
+            });
+            const watchFuncArgs = [reactiveObject.prop];
+
+            const propsList = [true, false, undefined, true, false];
+            const cycleProp = async (propsList) => {
+                for (let prop of propsList) {
+                    reactiveObject.prop = prop;
+                    await nextTick();
+                }
+            };
+
+            immediateStopWatch.start(watchSources, watchFunc, watchFuncArgs);
+            reactiveObject.prop = false;
+            await nextTick();
+            expect(watchFunc).toBeCalled();
+            await cycleProp(propsList);
+            expect(watchFunc).toHaveBeenCalledTimes(5);
+        });
+    });
+});

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

@@ -0,0 +1,127 @@
+import {
+    addOrUpdateReactiveObject,
+    assignReactiveObject,
+    AssignReactiveObjectError,
+} from "../../../utils/assignReactiveObject";
+import { computed, EffectScope, effectScope, reactive, toRef } from "vue";
+
+describe("utils/assignReactiveObject", function () {
+    describe("addOrUpdateReactiveObject", function () {});
+    describe("assignReactiveObject", function () {
+        describe("should update the target", function () {
+            it("when both target and source are not reactive", function () {
+                const target = {
+                    a: 1,
+                    b: 2,
+                    c: 3,
+                };
+                const source = {
+                    a: 4,
+                    b: 5,
+                    c: 6,
+                };
+                assignReactiveObject(target, source);
+                expect(target).toEqual({
+                    a: 4,
+                    b: 5,
+                    c: 6,
+                });
+            });
+            it("when both target and source are reactive, to not break reactivity", function () {
+                const target = reactive({
+                    a: 1,
+                    b: 2,
+                    c: 3,
+                });
+                const source = reactive({
+                    a: 4,
+                    b: 5,
+                    c: 6,
+                });
+                const tes = effectScope();
+                let computedSum;
+                tes.run(() => {
+                    computedSum = computed(() => {
+                        return target.a + target.b + target.c;
+                    });
+                });
+                try {
+                    expect(computedSum.value).toBe(6);
+                    assignReactiveObject(target, source);
+                    expect(target).toEqual({
+                        a: 4,
+                        b: 5,
+                        c: 6,
+                    });
+                    expect(computedSum.value).toBe(15);
+                } finally {
+                    computedSum = null;
+                    tes.stop();
+                }
+            });
+        });
+        describe("should throw an error", function () {
+            it("when target is not an array or object", function () {
+                expect(() => assignReactiveObject(null, {})).toThrowError(
+                    new AssignReactiveObjectError("target must be an object or an array, not null")
+                );
+                expect(() => assignReactiveObject(undefined, {})).toThrowError(
+                    new AssignReactiveObjectError("target must be an object or an array, not undefined")
+                );
+                expect(() => assignReactiveObject(1, {})).toThrowError(
+                    new AssignReactiveObjectError("target must be an object or an array, not 1")
+                );
+                expect(() => assignReactiveObject(NaN, {})).toThrowError(
+                    new AssignReactiveObjectError("target must be an object or an array, not NaN")
+                );
+                expect(() => assignReactiveObject(Infinity, {})).toThrowError(
+                    new AssignReactiveObjectError("target must be an object or an array, not Infinity")
+                );
+            });
+            it("when source is not an array or object", function () {
+                expect(() => assignReactiveObject({}, null)).toThrowError(
+                    new AssignReactiveObjectError("source must be an object or an array, not null")
+                );
+                expect(() => assignReactiveObject({}, undefined)).toThrowError(
+                    new AssignReactiveObjectError("source must be an object or an array, not undefined")
+                );
+                expect(() => assignReactiveObject({}, 1)).toThrowError(
+                    new AssignReactiveObjectError("source must be an object or an array, not 1")
+                );
+                expect(() => assignReactiveObject({}, NaN)).toThrowError(
+                    new AssignReactiveObjectError("source must be an object or an array, not NaN")
+                );
+                expect(() => assignReactiveObject({}, Infinity)).toThrowError(
+                    new AssignReactiveObjectError("source must be an object or an array, not Infinity")
+                );
+            });
+        });
+    });
+    it("should work as in the example for the readme", function () {
+        const es = new EffectScope();
+        es.run(() => {
+            const target = reactive({ a: 1 });
+            const source = { a: 3, b: 4 };
+            const source2 = reactive({ b: 5 });
+
+            const a = toRef(target, "a");
+            const b = toRef(target, "b");
+            const mySum = computed(() => (a.value || 0) + (b.value || 0));
+
+            expect(mySum.value).toBe(1);
+            assignReactiveObject(target, source);
+            expect(mySum.value).toBe(7);
+            addOrUpdateReactiveObject(target, source2);
+            expect({ ...target }).toEqual({ a: 3, b: 5 });
+            expect(mySum.value).toBe(8);
+            source2.b = 6;
+            expect(mySum.value).toBe(9);
+            assignReactiveObject(target, source2);
+            expect({ ...target }).toEqual({ b: 6 });
+            expect(mySum.value).toBe(6);
+            source2.b = 10;
+            expect(mySum.value).toBe(10);
+        });
+        es.stop();
+    });
+});

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

@@ -0,0 +1,18 @@
+import fs from "fs/promises";
+import * as utils from "../../../utils";
+
+describe("utils/index.js", function () {
+    it("should export everything exported by individual files", async function () {
+        const files = await fs.readdir("./utils");
+        const modules = files.filter((file) => file.endsWith(".js") && file !== "index.js");
+        const exportedKeys = [];
+        for (const module of modules) {
+            const moduleExports = await import(`../../../utils/${module}`);
+            exportedKeys.push(...Object.keys(moduleExports).filter((key) => key !== "default"));
+        }
+        const utilsKeys = Object.keys(utils);
+        utilsKeys.sort();
+        exportedKeys.sort();
+        expect(utilsKeys).toEqual(exportedKeys);
+    });
+});

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

@@ -0,0 +1,67 @@
+import { keyDiff } from "../../../utils/keyDiff";
+
+describe("keyDiff", function () {
+    describe("should return the difference between two arrays of object keys", function () {
+        it("when the objects are the same", function () {
+            const newObj = {
+                a: 1,
+                b: 2,
+                c: 3,
+            };
+            const oldObj = {
+                a: 1,
+                b: 2,
+                c: 3,
+            };
+            expect(keyDiff(Object.keys(newObj), Object.keys(oldObj))).toEqual({
+                addedKeys: new Set(),
+                removedKeys: new Set(),
+                sameKeys: new Set(["a", "b", "c"]),
+            });
+        });
+        it("when keys are added", function () {
+            const newObj = {
+                a: 1,
+                b: 2,
+                c: 3,
+                d: 4,
+            };
+            const oldObj = {
+                a: 1,
+                b: 2,
+                c: 3,
+            };
+            expect(keyDiff(Object.keys(newObj), Object.keys(oldObj))).toEqual({
+                addedKeys: new Set(["d"]),
+                removedKeys: new Set(),
+                sameKeys: new Set(["a", "b", "c"]),
+            });
+        });
+        it("when keys are removed", function () {
+            const newObj = {
+                a: 1,
+                b: 2,
+                c: 3,
+            };
+            const oldObj = {
+                a: 1,
+                b: 2,
+                c: 3,
+                d: 4,
+            };
+            expect(keyDiff(Object.keys(newObj), Object.keys(oldObj))).toEqual({
+                addedKeys: new Set(),
+                removedKeys: new Set(["d"]),
+                sameKeys: new Set(["a", "b", "c"]),
+            });
+        });
+    });
+    it("should work as in the example for the readme", function () {
+        const newKeys = Object.keys({ a: 1, b: 2 });
+        const oldKeys = Object.keys({ a: 1, c: 3 });
+        const { addedKeys, removedKeys, sameKeys } = keyDiff(newKeys, oldKeys);
+        expect(addedKeys).toEqual(new Set(["b"]));
+        expect(removedKeys).toEqual(new Set(["c"]));
+        expect(sameKeys).toEqual(new Set(["a"]));
+    });
+});

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

@@ -0,0 +1,68 @@
+import { difference, intersection, isSuperset, symmetricDifference, union } from "../../../utils/set";
+
+describe("utils/set", function () {
+    describe("isSuperset", function () {
+        it("should return true if the first set is a super set of the subset", function () {
+            const set = new Set([1, 2, 3, 4]);
+            const subset = new Set([1, 2, 3]);
+            expect(isSuperset(set, subset)).toBe(true);
+        });
+        it("should return false if the first set is not a super set of the subset", function () {
+            const set = new Set([1, 2, 3, 4]);
+            const subset = new Set([1, 2, 5]);
+            expect(isSuperset(set, subset)).toBe(false);
+        });
+        it("should return true if the subset is equal to the first set", function () {
+            const set = new Set([1, 2, 3]);
+            const subset = new Set([1, 2, 3]);
+            expect(isSuperset(set, subset)).toBe(true);
+        });
+        it("should return true if the subset is empty", function () {
+            const set = new Set([1, 2, 3]);
+            const subset = new Set([]);
+            expect(isSuperset(set, subset)).toBe(true);
+        });
+        it("should return false if the set is empty", function () {
+            const set = new Set([]);
+            const subset = new Set([1, 2, 3]);
+            expect(isSuperset(set, subset)).toBe(false);
+        });
+    });
+    describe("union", function () {
+        it("should return a set with the union of the two sets", function () {
+            const set1 = new Set([1, 2, 3, 5]);
+            const set2 = new Set([1, 2, 3, 4]);
+            expect(union(set1, set2)).toEqual(new Set([1, 2, 3, 4, 5]));
+        });
+    });
+    describe("intersection", function () {
+        it("should return a set with the intersection of the two sets", function () {
+            const set1 = new Set([1, 2, 3, 5]);
+            const set2 = new Set([1, 2, 3, 4]);
+            expect(intersection(set1, set2)).toEqual(new Set([1, 2, 3]));
+        });
+    });
+    describe("symmetricDifference", function () {
+        it("should return a set with the symmetric difference of the two sets", function () {
+            const set1 = new Set([1, 2, 3, 5]);
+            const set2 = new Set([1, 2, 3, 4]);
+            expect(symmetricDifference(set1, set2)).toEqual(new Set([4, 5]));
+        });
+    });
+    describe("difference", function () {
+        it("should return a set with the difference of the two sets", function () {
+            const set1 = new Set([1, 2, 3, 4]);
+            const set2 = new Set([3, 4, 5, 6]);
+            expect(difference(set1, set2)).toEqual(new Set([1, 2]));
+            expect(difference(set2, set1)).toEqual(new Set([5, 6]));
+        });
+    });
+    it("should work as in the example for the readme", function () {
+        expect(isSuperset(new Set([1, 2, 3, 4]), new Set([1, 2, 3]))).toBe(true);
+        expect(union(new Set([1, 2, 3, 4]), new Set([1, 2, 3]))).toEqual(new Set([1, 2, 3, 4]));
+        expect(intersection(new Set([1, 2, 3, 4]), new Set([1, 2, 3]))).toEqual(new Set([1, 2, 3]));
+        expect(symmetricDifference(new Set([1, 2, 3, 4]), new Set([1, 2, 3, 5]))).toEqual(new Set([4, 5]));
+        expect(difference(new Set([1, 2, 3, 4]), new Set([1, 2, 3, 5]))).toEqual(new Set([4]));
+        expect(difference(new Set([1, 2, 3, 5]), new Set([1, 2, 3, 4]))).toEqual(new Set([5]));
+    });
+});