@ersbeth/picoflow 2.0.1 → 2.0.3

package/test/reactivity/nodes/sync/flowState.test.ts

@@ -1,341 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import { state, subscribe } from "~";
-
-describe("flowState", () => {
-    describe("unit", () => {
-        describe("initialization", () => {
-            it("should initialize with direct value", async () => {
-                const $state = state(1);
-                expect(await $state.pick()).toBe(1);
-            });
-        });
-
-        describe("set", () => {
-            it("should update value with direct value", async () => {
-                const $state = state(1);
-                expect(await $state.pick()).toBe(1);
-
-                $state.set(2);
-                expect(await $state.pick()).toBe(2);
-            });
-
-            it("should update value with updater function", async () => {
-                const $state = state(1);
-                expect(await $state.pick()).toBe(1);
-
-                $state.set((current) => (current !== undefined ? current + 1 : 0));
-                expect(await $state.pick()).toBe(2);
-            });
-
-            it("should not notify when set with same value", async () => {
-                const $state = state(1);
-                const onData = vi.fn();
-                $state.subscribe(onData);
-
-                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
-
-                $state.set(1);
-
-                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
-            });
-
-            it("should notify when set with different value", async () => {
-                const $state = state(1);
-                const onData = vi.fn();
-                $state.subscribe(onData);
-
-                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
-                expect(onData).toHaveBeenLastCalledWith(1);
-                $state.set(2);
-                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
-                expect(onData).toHaveBeenLastCalledWith(2);
-            });
-
-            it("should not notify when updater returns same value", async () => {
-                const $state = state(5);
-                const onData = vi.fn();
-                $state.subscribe(onData);
-
-                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
-
-                $state.set((current) => current ?? 0);
-
-                // Wait to ensure no additional calls
-                await new Promise((resolve) => setTimeout(resolve, 50));
-                expect(onData).toHaveBeenCalledTimes(1);
-            });
-
-            it("should notify when updater returns different value", async () => {
-                const $state = state(5);
-                const onData = vi.fn();
-                $state.subscribe(onData);
-
-                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
-
-                await $state.set((current) => (current ? current + 1 : 0));
-                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
-                expect(onData).toHaveBeenLastCalledWith(6);
-            });
-        });
-
-        describe("subscribe", () => {
-            it("should call onData immediately with current value", async () => {
-                const $state = state(55);
-                const onData = vi.fn();
-
-                $state.subscribe(onData);
-
-                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
-                expect(onData).toHaveBeenLastCalledWith(55);
-            });
-
-            it("should call onData when value is updated", async () => {
-                const $state = state(65);
-                const onData = vi.fn();
-
-                $state.subscribe(onData);
-                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
-
-                $state.set(70);
-                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
-                expect(onData).toHaveBeenLastCalledWith(70);
-            });
-
-            it("should not call onData when updated with same value", async () => {
-                const $state = state(75);
-                const onData = vi.fn();
-
-                $state.subscribe(onData);
-                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
-
-                $state.set(80);
-                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
-
-                $state.set(80);
-                await new Promise((resolve) => setTimeout(resolve, 50));
-                expect(onData).toHaveBeenCalledTimes(2);
-            });
-        });
-
-        describe("nesting", () => {
-            it("should handle nested states", async () => {
-                const $stateA = state(1);
-                const $stateB = state(2);
-                const $stateC = state({
-                    a: $stateA,
-                    b: $stateB,
-                });
-
-                const value = await $stateC.pick();
-                expect(value.a).toBe($stateA);
-                expect(value.b).toBe($stateB);
-            });
-
-            it("should handle state with complex object values", async () => {
-                const complexObj = {
-                    nested: { deep: { value: 42 } },
-                    array: [1, 2, 3],
-                };
-                const $state = state(complexObj);
-                const value = await $state.pick();
-                expect(value).toBe(complexObj);
-                expect(value.nested.deep.value).toBe(42);
-                expect(value.array).toEqual([1, 2, 3]);
-            });
-        });
-
-        describe("error handling", () => {
-            describe("disposed state", () => {
-                it("should throw error when set is called after disposal", async () => {
-                    const $state = state(1);
-
-                    await $state.pick();
-                    await $state.set(2);
-                    $state.dispose();
-
-                    expect(() => $state.set(3)).toThrow("[PicoFlow] Primitive is disposed");
-                });
-
-                it("should throw error when trigger is called after disposal", () => {
-                    const $state = state(1);
-                    $state.dispose();
-                    expect(() => $state.trigger()).toThrow("[PicoFlow] Primitive is disposed");
-                });
-            });
-        });
-    });
-
-    describe("with effect", () => {
-        describe("get", () => {
-            it("should call effect with initial value", async () => {
-                const $state = state(1);
-                const onData = vi.fn();
-                subscribe((t) => $state.get(t), onData);
-
-                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
-                expect(onData).toHaveBeenLastCalledWith(1);
-            });
-
-            it("should call effect when value is updated", async () => {
-                const $state = state(1);
-                const onData = vi.fn();
-                subscribe((t) => $state.get(t), onData);
-
-                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
-                expect(onData).toHaveBeenLastCalledWith(1);
-
-                $state.set(2);
-                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
-                expect(onData).toHaveBeenLastCalledWith(2);
-            });
-
-            it("should not call effect when updated with same value", async () => {
-                const $state = state(1);
-                const onData = vi.fn();
-                subscribe((t) => $state.get(t), onData);
-
-                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
-
-                $state.set(2);
-                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
-                expect(onData).toHaveBeenLastCalledWith(2);
-
-                $state.set(2);
-                await new Promise((resolve) => setTimeout(resolve, 50));
-                expect(onData).toHaveBeenCalledTimes(2);
-            });
-
-            it("should not call effect after effect is disposed", async () => {
-                const $state = state(1);
-                const onData = vi.fn();
-                const $effect = subscribe((t) => $state.get(t), onData);
-
-                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
-                expect(onData).toHaveBeenLastCalledWith(1);
-
-                $state.set(2);
-                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
-                expect(onData).toHaveBeenLastCalledWith(2);
-
-                $effect.dispose();
-
-                $state.set(3);
-                await new Promise((resolve) => setTimeout(resolve, 50));
-                expect(onData).toHaveBeenCalledTimes(2);
-            });
-
-            it("should support effect depending on multiple states", async () => {
-                const $stateA = state(5);
-                const $stateB = state(10);
-                const onData = vi.fn();
-
-                subscribe(
-                    (t) => ({ a: $stateA.get(t), b: $stateB.get(t) }),
-                    (data) => onData(data.a, data.b),
-                );
-
-                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
-                expect(onData).toHaveBeenLastCalledWith(5, 10);
-
-                $stateA.set(6);
-                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
-                expect(onData).toHaveBeenLastCalledWith(6, 10);
-
-                $stateB.set(11);
-                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(3));
-                expect(onData).toHaveBeenLastCalledWith(6, 11);
-            });
-        });
-
-        describe("watch", () => {
-            it("should register dependency when watch is used in effect", async () => {
-                const $state = state(400);
-                const onData = vi.fn();
-
-                subscribe((t) => $state.watch(t), onData);
-
-                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
-            });
-
-            it("should trigger re-runs when state changes after watch", async () => {
-                const $state = state(500);
-                const onData = vi.fn();
-
-                subscribe((t) => $state.watch(t), onData);
-
-                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
-
-                await $state.set(600);
-                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
-            });
-        });
-
-        describe("error handling", () => {
-            describe("disposed state", () => {
-                it("should throw error when triggering a disposed state", () => {
-                    const $state = state(1);
-
-                    $state.dispose();
-
-                    expect(() => $state.trigger()).toThrow("[PicoFlow] Primitive is disposed");
-                });
-
-                it("should throw error when setting a disposed state", () => {
-                    const $state = state(1);
-
-                    $state.dispose();
-
-                    expect(() => $state.set(2)).toThrow("[PicoFlow] Primitive is disposed");
-                });
-            });
-        });
-
-        describe("complex cases", () => {
-            it("should handle nested states in effects", async () => {
-                const $stateA = state(1);
-                const $stateB = state(2);
-                const $stateC = state({
-                    a: $stateA,
-                    b: $stateB,
-                });
-
-                const onData = vi.fn();
-                subscribe((t) => $stateC.get(t).a.get(t), onData);
-
-                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
-                expect(onData).toHaveBeenLastCalledWith(1);
-
-                await $stateA.set(3);
-                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
-                expect(onData).toHaveBeenLastCalledWith(3);
-            });
-
-            it("should handle effect depending on multiple states", async () => {
-                const $stateA = state(10);
-                const $stateB = state(20);
-                const $stateC = state(30);
-                const onData = vi.fn();
-
-                subscribe(
-                    (t) => ({
-                        a: $stateA.get(t),
-                        b: $stateB.get(t),
-                        c: $stateC.get(t),
-                    }),
-                    (data) => onData(data.a, data.b, data.c),
-                );
-
-                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
-                expect(onData).toHaveBeenLastCalledWith(10, 20, 30);
-
-                $stateA.set(11);
-                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
-                expect(onData).toHaveBeenLastCalledWith(11, 20, 30);
-
-                $stateB.set(21);
-                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(3));
-                expect(onData).toHaveBeenLastCalledWith(11, 21, 30);
-            });
-        });
-    });
-});