@ersbeth/picoflow 0.0.1

package/test/derivation.test.ts

@@ -0,0 +1,422 @@
+import { describe, expect, test, vi } from "vitest";
+import { derivation, effect, resource, signal, state } from "#package";
+
+describe("derivation", () => {
+    describe("from state", () => {
+        test("is updated", () => {
+            const $state = state(1);
+            const $derivation = derivation((get) => get($state) * 2);
+            expect($derivation.get()).toBe(2);
+
+            $state.set(2);
+            expect($derivation.get()).toBe(4);
+        });
+
+        test("get throws when disposed", () => {
+            const $state = state(1);
+            const $derivation = derivation((get) => get($state) * 2);
+            expect($derivation.get()).toBe(2);
+
+            $state.set(2);
+            expect($derivation.get()).toBe(4);
+
+            $derivation.dispose();
+            expect(() => $derivation.get()).toThrow("Effect is disposed");
+        });
+
+        test("get throws when state is disposed", () => {
+            const $state = state(1);
+            const $derivation = derivation((get) => get($state) * 2);
+            expect($derivation.get()).toBe(2);
+
+            $state.set(2);
+            expect($derivation.get()).toBe(4);
+
+            $state.dispose();
+            expect(() => $derivation.get()).toThrow("Effect is disposed");
+        });
+
+        test("is updated (chained dependencies)", () => {
+            const $state = state(1);
+            const $derivation1 = derivation((get) => get($state) * 2);
+            const $derivation2 = derivation((get) => get($derivation1) * 2);
+
+            expect($derivation2.get()).toBe(4);
+
+            $state.set(2);
+            expect($derivation2.get()).toBe(8);
+        });
+
+        test("is updated (multiple dependencies)", () => {
+            const $state1 = state(1);
+            const $state2 = state(2);
+            const $derivation = derivation(
+                (get) => get($state1) + get($state2),
+            );
+
+            expect($derivation.get()).toBe(3);
+
+            $state1.set(2);
+            expect($derivation.get()).toBe(4);
+
+            $state2.set(3);
+            expect($derivation.get()).toBe(5);
+        });
+
+        test("is updated (multiple dependants)", () => {
+            const $state = state(1);
+            const $derivation1 = derivation((get) => get($state) * 2);
+            const $derivation2 = derivation((get) => get($state) * 3);
+
+            expect($derivation1.get()).toBe(2);
+            expect($derivation2.get()).toBe(3);
+
+            $state.set(2);
+            expect($derivation1.get()).toBe(4);
+            expect($derivation2.get()).toBe(6);
+
+            $state.set(3);
+            expect($derivation1.get()).toBe(6);
+            expect($derivation2.get()).toBe(9);
+        });
+
+        test("is updated (async)", async () => {
+            const $state = state(1);
+            const $derivation = derivation(async (get) => get($state) * 2);
+
+            expect(await $derivation.get()).toBe(2);
+
+            $state.set(2);
+            expect(await $derivation.get()).toBe(4);
+        });
+
+        test("is updated (async chain)", async () => {
+            const $state = state(1);
+            const $derivation1 = derivation(async (get) => get($state) * 2);
+            const $derivation2 = derivation(
+                async (get) => (await get($derivation1)) * 2,
+            );
+
+            expect(await $derivation2.get()).toBe(4);
+
+            $state.set(2);
+            expect(await $derivation2.get()).toBe(8);
+        });
+    });
+
+    describe("from resource", () => {
+        test("from resource is updated", async () => {
+            let resourceCounter = 0;
+            const fetchResource = async () => {
+                resourceCounter++;
+                return resourceCounter;
+            };
+            const $resource = resource(fetchResource, 0);
+            const $derivation = derivation((get) => get($resource) * 2);
+
+            expect($derivation.get()).toBe(0);
+
+            await $resource.fetch();
+            expect($derivation.get()).toBe(2);
+
+            await $resource.fetch();
+            expect($derivation.get()).toBe(4);
+
+            await $resource.fetch();
+            expect($derivation.get()).toBe(6);
+        });
+    });
+});
+
+describe("effect", () => {
+    describe("from signal", () => {
+        test("called when triggered", () => {
+            const $signal = signal();
+            const $derivation = derivation((_, watch) => {
+                watch($signal);
+            });
+            const effectFn = vi.fn();
+            effect((_, watch) => {
+                watch($derivation);
+                effectFn();
+            });
+
+            expect(effectFn).toHaveBeenCalledTimes(1);
+
+            $signal.trigger();
+            expect(effectFn).toHaveBeenCalledTimes(2);
+
+            $signal.trigger();
+            expect(effectFn).toHaveBeenCalledTimes(3);
+
+            $signal.trigger();
+            expect(effectFn).toHaveBeenCalledTimes(4);
+        });
+
+        test("called when triggered (chained dependencies)", () => {
+            const $signal = signal();
+            const $derivation1 = derivation((_, watch) => watch($signal));
+            const $derivation2 = derivation((_, watch) => watch($derivation1));
+            const effectFn = vi.fn();
+            effect((_, watch) => {
+                watch($derivation2);
+                effectFn();
+            });
+
+            expect(effectFn).toHaveBeenCalledTimes(1);
+
+            $signal.trigger();
+            expect(effectFn).toHaveBeenCalledTimes(2);
+        });
+
+        test("called when triggered (multiple dependencies)", () => {
+            const $signal1 = signal();
+            const $signal2 = signal();
+            const $derivation = derivation((_, watch) => {
+                watch($signal1);
+                watch($signal2);
+            });
+            const effectFn = vi.fn();
+            effect((_, watch) => {
+                watch($derivation);
+                effectFn();
+            });
+
+            expect(effectFn).toHaveBeenCalledTimes(1);
+
+            $signal1.trigger();
+            expect(effectFn).toHaveBeenCalledTimes(2);
+
+            $signal2.trigger();
+            expect(effectFn).toHaveBeenCalledTimes(3);
+        });
+
+        test("called when is updated (multiple dependants)", () => {
+            const $signal = signal();
+            const $derivation1 = derivation((_, watch) => watch($signal));
+            const $derivation2 = derivation((_, watch) => watch($signal));
+            const effect1Fn = vi.fn();
+            const effect2Fn = vi.fn();
+
+            effect((get) => effect1Fn(get($derivation1)));
+            effect((get) => effect2Fn(get($derivation2)));
+
+            expect(effect1Fn).toHaveBeenCalledTimes(1);
+            expect(effect2Fn).toHaveBeenCalledTimes(1);
+
+            $signal.trigger();
+            expect(effect1Fn).toHaveBeenCalledTimes(2);
+            expect(effect2Fn).toHaveBeenCalledTimes(2);
+
+            $signal.trigger();
+            expect(effect1Fn).toHaveBeenCalledTimes(3);
+            expect(effect2Fn).toHaveBeenCalledTimes(3);
+        });
+
+        test("called when triggered (with state)", () => {
+            const $signal = signal();
+            const $state = state(1);
+            const $derivation = derivation((get, watch) => {
+                watch($signal);
+                return get($state) * 2;
+            });
+            const effectFn = vi.fn();
+            effect((get) => effectFn(get($derivation)));
+
+            expect(effectFn).toHaveBeenCalledTimes(1);
+            expect(effectFn).toHaveBeenLastCalledWith(2);
+
+            $signal.trigger();
+            expect(effectFn).toHaveBeenCalledTimes(2);
+            expect(effectFn).toHaveBeenLastCalledWith(2);
+
+            $signal.trigger();
+            expect(effectFn).toHaveBeenCalledTimes(3);
+            expect(effectFn).toHaveBeenLastCalledWith(2);
+
+            $state.set(2);
+            expect(effectFn).toHaveBeenCalledTimes(4);
+            expect(effectFn).toHaveBeenLastCalledWith(4);
+
+            $signal.trigger();
+            expect(effectFn).toHaveBeenCalledTimes(5);
+            expect(effectFn).toHaveBeenLastCalledWith(4);
+        });
+    });
+
+    describe("from state", () => {
+        test("called when is updated", () => {
+            const $state = state(1);
+            const $derivation = derivation((get) => get($state) * 2);
+            const effectFn = vi.fn();
+            effect((get) => effectFn(get($derivation)));
+
+            expect(effectFn).toHaveBeenCalledTimes(1);
+            expect(effectFn).toHaveBeenLastCalledWith(2);
+
+            $state.set(2);
+            expect(effectFn).toHaveBeenCalledTimes(2);
+            expect(effectFn).toHaveBeenLastCalledWith(4);
+        });
+
+        test("called when is updated (chained dependencies)", () => {
+            const $state = state(1);
+            const $derivation1 = derivation((get) => get($state) * 2);
+            const $derivation2 = derivation((get) => get($derivation1) * 2);
+            const effectFn = vi.fn();
+            effect((get) => effectFn(get($derivation2)));
+
+            expect(effectFn).toHaveBeenCalledTimes(1);
+            expect(effectFn).toHaveBeenLastCalledWith(4);
+
+            $state.set(2);
+            expect(effectFn).toHaveBeenCalledTimes(2);
+            expect(effectFn).toHaveBeenLastCalledWith(8);
+        });
+
+        test("called when is updated (multiple dependencies)", () => {
+            const $state1 = state(1);
+            const $state2 = state(2);
+            const $derivation = derivation(
+                (get) => get($state1) + get($state2),
+            );
+            const effectFn = vi.fn();
+            effect((get) => effectFn(get($derivation)));
+
+            expect(effectFn).toHaveBeenCalledTimes(1);
+            expect(effectFn).toHaveBeenLastCalledWith(3);
+
+            $state1.set(2);
+            expect(effectFn).toHaveBeenCalledTimes(2);
+            expect(effectFn).toHaveBeenLastCalledWith(4);
+
+            $state2.set(3);
+            expect(effectFn).toHaveBeenCalledTimes(3);
+            expect(effectFn).toHaveBeenLastCalledWith(5);
+        });
+
+        test("called when is updated (multiple dependants)", () => {
+            const $state = state(1);
+            const $derivation1 = derivation((get) => get($state) * 2);
+            const $derivation2 = derivation((get) => get($state) * 3);
+            const effect1Fn = vi.fn();
+            const effect2Fn = vi.fn();
+
+            effect((get) => effect1Fn(get($derivation1)));
+            effect((get) => effect2Fn(get($derivation2)));
+
+            expect(effect1Fn).toHaveBeenCalledTimes(1);
+            expect(effect1Fn).toHaveBeenLastCalledWith(2);
+            expect(effect2Fn).toHaveBeenCalledTimes(1);
+            expect(effect2Fn).toHaveBeenLastCalledWith(3);
+
+            $state.set(2);
+            expect(effect1Fn).toHaveBeenCalledTimes(2);
+            expect(effect1Fn).toHaveBeenLastCalledWith(4);
+            expect(effect2Fn).toHaveBeenCalledTimes(2);
+            expect(effect2Fn).toHaveBeenLastCalledWith(6);
+
+            $state.set(3);
+            expect(effect1Fn).toHaveBeenCalledTimes(3);
+            expect(effect1Fn).toHaveBeenLastCalledWith(6);
+            expect(effect2Fn).toHaveBeenCalledTimes(3);
+            expect(effect2Fn).toHaveBeenLastCalledWith(9);
+        });
+
+        test("called when is updated (async)", async () => {
+            const $state = state(1);
+            const $derivation = derivation(async (get) => get($state) * 2);
+            const effectFn = vi.fn();
+            effect((get) => effectFn(get($derivation)));
+
+            expect(effectFn).toHaveBeenCalledTimes(1);
+            expect(await effectFn.mock.calls[0][0]).toEqual(2);
+
+            $state.set(2);
+            expect(effectFn).toHaveBeenCalledTimes(2);
+            expect(await effectFn.mock.calls[1][0]).toEqual(4);
+        });
+
+        test("called when is updated (async chain)", async () => {
+            const $state = state(1);
+            const $derivation1 = derivation(async (get) => get($state) * 2);
+            const $derivation2 = derivation(
+                async (get) => (await get($derivation1)) * 2,
+            );
+            const effectFn = vi.fn();
+            effect((get) => effectFn(get($derivation2)));
+
+            expect(effectFn).toHaveBeenCalledTimes(1);
+            expect(await effectFn.mock.calls[0][0]).toEqual(4);
+
+            $state.set(2);
+            expect(effectFn).toHaveBeenCalledTimes(2);
+            expect(await effectFn.mock.calls[1][0]).toEqual(8);
+        });
+
+        test("NOT called when derivation is disposed", () => {
+            const $state = state(1);
+            const $derivation = derivation((get) => get($state) * 2);
+            const effectFn = vi.fn();
+            effect((get) => effectFn(get($derivation)));
+
+            expect(effectFn).toHaveBeenCalledTimes(1);
+            expect(effectFn).toHaveBeenLastCalledWith(2);
+
+            $state.set(2);
+            expect(effectFn).toHaveBeenCalledTimes(2);
+            expect(effectFn).toHaveBeenLastCalledWith(4);
+
+            $derivation.dispose();
+
+            $state.set(3);
+            expect(effectFn).toHaveBeenCalledTimes(2);
+            expect(effectFn).toHaveBeenLastCalledWith(4);
+        });
+
+        test("NOT called when disposed", () => {
+            const $state = state(1);
+            const $derivation = derivation((get) => get($state) * 2);
+            const effectFn = vi.fn();
+            const $effect = effect((get) => effectFn(get($derivation)));
+
+            expect(effectFn).toHaveBeenCalledTimes(1);
+            expect(effectFn).toHaveBeenLastCalledWith(2);
+
+            $state.set(2);
+            expect(effectFn).toHaveBeenCalledTimes(2);
+            expect(effectFn).toHaveBeenLastCalledWith(4);
+
+            $effect.dispose();
+
+            $state.set(3);
+            expect(effectFn).toHaveBeenCalledTimes(2);
+            expect(effectFn).toHaveBeenLastCalledWith(4);
+        });
+    });
+
+    describe("from resource", () => {
+        test("called when is updated", async () => {
+            let resourceCounter = 0;
+            const fetchResource = async () => {
+                resourceCounter++;
+                return resourceCounter;
+            };
+            const $resource = resource(fetchResource, 0);
+            const $derivation = derivation((get) => get($resource) * 2);
+            const effectFn = vi.fn();
+            effect((get) => effectFn(get($derivation)));
+
+            expect(effectFn).toHaveBeenCalledTimes(1);
+            expect(effectFn).toHaveBeenLastCalledWith(0);
+
+            await $resource.fetch();
+            expect(effectFn).toHaveBeenCalledTimes(2);
+            expect(effectFn).toHaveBeenLastCalledWith(2);
+
+            await $resource.fetch();
+            expect(effectFn).toHaveBeenCalledTimes(3);
+            expect(effectFn).toHaveBeenLastCalledWith(4);
+        });
+    });
+});

package/test/map.test.ts

@@ -0,0 +1,106 @@
+import { describe, expect, test, vi } from "vitest";
+import { effect, map } from "#package";
+
+describe("map", () => {
+    test("is updated", () => {
+        const $map = map();
+
+        expect(Array.from($map.get().entries())).toEqual([]);
+
+        $map.setAt("key1", 1);
+        expect($map.get().get("key1")).toBe(1);
+        expect($map.$lastSet.get()).toEqual({ key: "key1", value: 1 });
+
+        $map.setAt("key2", 2);
+        expect($map.get().get("key1")).toBe(1);
+        expect($map.get().get("key2")).toBe(2);
+        expect($map.$lastSet.get()).toEqual({ key: "key2", value: 2 });
+
+        $map.setAt("key1", 3);
+        expect($map.get().get("key1")).toBe(3);
+        expect($map.get().get("key2")).toBe(2);
+        expect($map.$lastSet.get()).toEqual({ key: "key1", value: 3 });
+
+        $map.delete("key1");
+        expect($map.get().get("key1")).toBe(undefined);
+        expect($map.get().get("key2")).toBe(2);
+        expect($map.$lastDeleted.get()).toEqual({ key: "key1", value: 3 });
+    });
+});
+
+describe("effect", () => {
+    test("called when map is updated", () => {
+        const $map = map();
+        const onSetFn = vi.fn();
+        const onSetAtFn = vi.fn();
+        const onDeleteFn = vi.fn();
+
+        effect((get) => onSetFn(get($map)));
+        effect((get) => onSetAtFn(get($map.$lastSet)));
+        effect((get) => onDeleteFn(get($map.$lastDeleted)));
+
+        expect(onSetFn).toHaveBeenCalledTimes(1);
+        expect(onSetFn).toHaveBeenLastCalledWith(new Map());
+        expect(onSetAtFn).toHaveBeenCalledTimes(1);
+        expect(onSetAtFn).toHaveBeenLastCalledWith({
+            key: undefined,
+            value: undefined,
+        });
+        expect(onDeleteFn).toHaveBeenCalledTimes(1);
+        expect(onDeleteFn).toHaveBeenLastCalledWith({
+            key: undefined,
+            value: undefined,
+        });
+
+        $map.setAt("key1", 1);
+        expect(onSetFn).toHaveBeenCalledTimes(2);
+        expect(onSetFn).toHaveBeenLastCalledWith(new Map([["key1", 1]]));
+        expect(onSetAtFn).toHaveBeenCalledTimes(2);
+        expect(onSetAtFn).toHaveBeenLastCalledWith({ key: "key1", value: 1 });
+        expect(onDeleteFn).toHaveBeenCalledTimes(1);
+        expect(onDeleteFn).toHaveBeenLastCalledWith({
+            key: undefined,
+            value: undefined,
+        });
+
+        $map.setAt("key2", 2);
+        expect(onSetFn).toHaveBeenCalledTimes(3);
+        expect(onSetFn).toHaveBeenLastCalledWith(
+            new Map([
+                ["key1", 1],
+                ["key2", 2],
+            ]),
+        );
+        expect(onSetAtFn).toHaveBeenCalledTimes(3);
+        expect(onSetAtFn).toHaveBeenLastCalledWith({ key: "key2", value: 2 });
+        expect(onDeleteFn).toHaveBeenCalledTimes(1);
+        expect(onDeleteFn).toHaveBeenLastCalledWith({
+            key: undefined,
+            value: undefined,
+        });
+
+        $map.setAt("key1", 3);
+        expect(onSetFn).toHaveBeenCalledTimes(4);
+        expect(onSetFn).toHaveBeenLastCalledWith(
+            new Map([
+                ["key1", 3],
+                ["key2", 2],
+            ]),
+        );
+        expect(onSetAtFn).toHaveBeenCalledTimes(4);
+        expect(onSetAtFn).toHaveBeenLastCalledWith({ key: "key1", value: 3 });
+        expect(onDeleteFn).toHaveBeenCalledTimes(1);
+        expect(onDeleteFn).toHaveBeenLastCalledWith({
+            key: undefined,
+            value: undefined,
+        });
+
+        $map.delete("key1");
+        expect(onSetFn).toHaveBeenCalledTimes(5);
+        expect(onSetFn).toHaveBeenLastCalledWith(new Map([["key2", 2]]));
+        expect(onSetAtFn).toHaveBeenCalledTimes(4);
+        expect(onSetAtFn).toHaveBeenLastCalledWith({ key: "key1", value: 3 });
+        expect(onDeleteFn).toHaveBeenCalledTimes(2);
+        expect(onDeleteFn).toHaveBeenLastCalledWith({ key: "key1", value: 3 });
+    });
+});

package/test/resource.test.ts

@@ -0,0 +1,127 @@
+import { describe, expect, test, vi } from "vitest";
+import { effect, resource } from "#package";
+
+describe("resource", () => {
+    test("is updated", async () => {
+        let resourceCounter = 0;
+        const fetchResource = async () => {
+            resourceCounter++;
+            return resourceCounter;
+        };
+
+        const $resource = resource(fetchResource, 0);
+        expect($resource.get()).toBe(0);
+
+        await $resource.fetch();
+        expect($resource.get()).toBe(1);
+
+        await $resource.fetch();
+        expect($resource.get()).toBe(2);
+    });
+
+    test("fetch throws when disposed", async () => {
+        let resourceCounter = 0;
+        const fetchResource = async () => {
+            resourceCounter++;
+            return resourceCounter;
+        };
+
+        const $resource = resource(fetchResource, 0);
+        expect($resource.get()).toBe(0);
+
+        await $resource.fetch();
+        expect($resource.get()).toBe(1);
+
+        $resource.dispose();
+        await expect(() => $resource.fetch()).rejects.toThrow(
+            "Resource is disposed",
+        );
+    });
+
+    test("get throws when disposed", async () => {
+        let resourceCounter = 0;
+        const fetchResource = async () => {
+            resourceCounter++;
+            return resourceCounter;
+        };
+
+        const $resource = resource(fetchResource, 0);
+        expect($resource.get()).toBe(0);
+
+        await $resource.fetch();
+        expect($resource.get()).toBe(1);
+
+        $resource.dispose();
+        expect(() => $resource.get()).toThrow("Resource is disposed");
+    });
+});
+
+describe("effect", () => {
+    test("called when resource updated", async () => {
+        let resourceCounter = 0;
+        const fetchResource = async () => {
+            resourceCounter++;
+            return resourceCounter;
+        };
+
+        const $resource = resource(fetchResource, 0);
+        const effectFn = vi.fn();
+        effect((get) => effectFn(get($resource)));
+
+        expect(effectFn).toHaveBeenCalledTimes(1);
+        expect(effectFn).toHaveBeenLastCalledWith(0);
+
+        await $resource.fetch();
+        expect(effectFn).toHaveBeenCalledTimes(2);
+        expect(effectFn).toHaveBeenLastCalledWith(1);
+
+        await $resource.fetch();
+        expect(effectFn).toHaveBeenCalledTimes(3);
+        expect(effectFn).toHaveBeenLastCalledWith(2);
+    });
+
+    test("NOT updated when value don't change", async () => {
+        const fetchResource = async () => {
+            return 0;
+        };
+
+        const $resource = resource(fetchResource, 0);
+        const effectFn = vi.fn();
+        effect((get) => effectFn(get($resource)));
+
+        expect(effectFn).toHaveBeenCalledTimes(1);
+        expect(effectFn).toHaveBeenLastCalledWith(0);
+
+        await $resource.fetch();
+        expect(effectFn).toHaveBeenCalledTimes(1);
+        expect(effectFn).toHaveBeenLastCalledWith(0);
+
+        await $resource.fetch();
+        expect(effectFn).toHaveBeenCalledTimes(1);
+        expect(effectFn).toHaveBeenLastCalledWith(0);
+    });
+
+    test("NOT called when disposed", async () => {
+        let resourceCounter = 0;
+        const fetchResource = async () => {
+            resourceCounter++;
+            return resourceCounter;
+        };
+
+        const $resource = resource(fetchResource, 0);
+        const effectFn = vi.fn();
+        const $effect = effect((get) => effectFn(get($resource)));
+
+        expect(effectFn).toHaveBeenCalledTimes(1);
+        expect(effectFn).toHaveBeenLastCalledWith(0);
+
+        await $resource.fetch();
+        expect(effectFn).toHaveBeenCalledTimes(2);
+        expect(effectFn).toHaveBeenLastCalledWith(1);
+
+        $effect.dispose();
+        await $resource.fetch();
+        expect(effectFn).toHaveBeenCalledTimes(2);
+        expect(effectFn).toHaveBeenLastCalledWith(1);
+    });
+});