@ersbeth/picoflow 2.0.1 → 2.0.3

package/test/converters/solid.node.test.ts

@@ -1,654 +0,0 @@
-import { createEffect, createRoot } from "solid-js";
-import { describe, expect, it, vi } from "vitest";
-import type { FlowTracker } from "~";
-import { derivation, derivationAsync, from, state, stateAsync } from "~";
-
-describe("converters", () => {
-    describe("from", () => {
-        describe("unit", () => {
-            describe("initialization", () => {
-                it("should convert synchronous FlowNode to SolidResource", async () => {
-                    await createRoot(async (dispose) => {
-                        const $state = state(42);
-                        const solidResource = from($state);
-
-                        await vi.waitFor(() => expect(solidResource()).toBe(42));
-                        dispose();
-                    });
-                });
-
-                it("should convert FlowNodeAsync to SolidResource", async () => {
-                    await createRoot(async (dispose) => {
-                        const $stateAsync = stateAsync(Promise.resolve(42));
-                        const solidResource = from($stateAsync);
-
-                        await vi.waitFor(() => expect(solidResource()).toBe(42));
-                        dispose();
-                    });
-                });
-
-                it("should convert synchronous getter function to SolidResource", async () => {
-                    await createRoot(async (dispose) => {
-                        const $state = state(42);
-                        const getter = (t: FlowTracker) => $state.get(t);
-                        const solidResource = from(getter);
-
-                        await vi.waitFor(() => expect(solidResource()).toBe(42));
-                        dispose();
-                    });
-                });
-
-                it("should return a SolidResource instance", async () => {
-                    await createRoot(async (dispose) => {
-                        const $state = state(42);
-                        const solidResource = from($state);
-
-                        await vi.waitFor(() => expect(solidResource()).toBe(42));
-                        dispose();
-                    });
-                });
-            });
-
-            describe("conversion from FlowNode (synchronous)", () => {
-                it("should convert a FlowState to SolidResource", async () => {
-                    await createRoot(async (dispose) => {
-                        const $state = state(42);
-                        const solidResource = from($state);
-
-                        await vi.waitFor(() => expect(solidResource()).toBe(42));
-                        dispose();
-                    });
-                });
-
-                it("should convert a FlowDerivation to SolidResource", async () => {
-                    await createRoot(async (dispose) => {
-                        const $state = state(5);
-                        const $derivation = derivation((t) => $state.get(t) * 2);
-                        const solidResource = from($derivation);
-
-                        await vi.waitFor(() => expect(solidResource()).toBe(10));
-                        dispose();
-                    });
-                });
-
-                it("should initialize with FlowNode value", async () => {
-                    await createRoot(async (dispose) => {
-                        const $state = state(42);
-                        const solidResource = from($state);
-
-                        // Wait for resource to load
-                        await vi.waitFor(() => expect(solidResource()).toBe(42));
-                        dispose();
-                    });
-                });
-
-                it("should handle number values", async () => {
-                    await createRoot(async (dispose) => {
-                        const $state = state(42);
-                        const solidResource = from($state);
-
-                        await vi.waitFor(() => expect(solidResource()).toBe(42));
-                        dispose();
-                    });
-                });
-
-                it("should handle string values", async () => {
-                    await createRoot(async (dispose) => {
-                        const $state = state("hello");
-                        const solidResource = from($state);
-
-                        await vi.waitFor(() => expect(solidResource()).toBe("hello"));
-                        dispose();
-                    });
-                });
-
-                it("should handle object values", async () => {
-                    await createRoot(async (dispose) => {
-                        const obj = { a: 1, b: 2 };
-                        const $state = state(obj);
-                        const solidResource = from($state);
-
-                        await vi.waitFor(() => expect(solidResource()).toEqual({ a: 1, b: 2 }));
-                        dispose();
-                    });
-                });
-
-                it("should handle array values", async () => {
-                    await createRoot(async (dispose) => {
-                        const arr = [1, 2, 3];
-                        const $state = state(arr);
-                        const solidResource = from($state);
-
-                        await vi.waitFor(() => expect(solidResource()).toEqual([1, 2, 3]));
-                        dispose();
-                    });
-                });
-
-                it("should handle null values", async () => {
-                    await createRoot(async (dispose) => {
-                        const $stateNull = state(null);
-                        const solidResourceNull = from($stateNull);
-
-                        await vi.waitFor(() => expect(solidResourceNull()).toBeNull());
-                        dispose();
-                    });
-                });
-
-                it("should handle undefined values", async () => {
-                    await createRoot(async (dispose) => {
-                        const $stateUndefined = state(undefined);
-                        const solidResourceUndefined = from($stateUndefined);
-
-                        await vi.waitFor(() => expect(solidResourceUndefined()).toBeUndefined());
-                        dispose();
-                    });
-                });
-            });
-
-            describe("conversion from FlowNodeAsync (asynchronous)", () => {
-                it("should convert a FlowStateAsync to SolidResource", async () => {
-                    await createRoot(async (dispose) => {
-                        const $stateAsync = stateAsync(Promise.resolve(42));
-                        const solidResource = from($stateAsync);
-
-                        await vi.waitFor(() => expect(solidResource()).toBe(42));
-                        dispose();
-                    });
-                });
-
-                it("should convert a FlowDerivationAsync to SolidResource", async () => {
-                    await createRoot(async (dispose) => {
-                        const $stateAsync = stateAsync(Promise.resolve(5));
-                        const $derivationAsync = derivationAsync(async (t) => $stateAsync.get(t) * 2);
-                        const solidResource = from($derivationAsync);
-
-                        await vi.waitFor(() => expect(solidResource()).toBe(10));
-                        dispose();
-                    });
-                });
-
-                it("should initialize with FlowNodeAsync value", async () => {
-                    await createRoot(async (dispose) => {
-                        const $stateAsync = stateAsync(Promise.resolve(42));
-                        const solidResource = from($stateAsync);
-
-                        await vi.waitFor(() => expect(solidResource()).toBe(42));
-                        dispose();
-                    });
-                });
-
-                it("should handle resolved Promises", async () => {
-                    await createRoot(async (dispose) => {
-                        const $stateAsync = stateAsync(Promise.resolve(42));
-                        const solidResource = from($stateAsync);
-
-                        await vi.waitFor(() => expect(solidResource()).toBe(42));
-                        dispose();
-                    });
-                });
-
-                it("should handle rejected Promises", async () => {
-                    await createRoot(async (dispose) => {
-                        const error = new Error("Test error");
-                        const $stateAsync = stateAsync(Promise.reject(error));
-
-                        const solidResource = from($stateAsync);
-                        await vi.waitFor(() => expect(solidResource.error).toBe(error));
-                        dispose();
-                    });
-                });
-            });
-
-            describe("conversion from getter function", () => {
-                it("should convert a synchronous getter to SolidResource", async () => {
-                    await createRoot(async (dispose) => {
-                        const $state = state(42);
-                        const getter = (t: FlowTracker) => $state.get(t);
-                        const solidResource = from(getter);
-
-                        await vi.waitFor(() => expect(solidResource()).toBe(42));
-                        dispose();
-                    });
-                });
-
-                it("should track dependencies in the getter", async () => {
-                    await createRoot(async (dispose) => {
-                        const $state = state(5);
-                        const getter = (t: FlowTracker) => $state.get(t) * 2;
-                        const solidResource = from(getter);
-
-                        await vi.waitFor(() => expect(solidResource()).toBe(10));
-
-                        $state.set(6);
-                        await vi.waitFor(() => expect(solidResource()).toBe(12));
-                        dispose();
-                    });
-                });
-
-                it("should create a FlowNodeSync from the getter", async () => {
-                    await createRoot(async (dispose) => {
-                        const $state = state(42);
-                        const getter = (t: FlowTracker) => $state.get(t);
-                        const solidResource = from(getter);
-
-                        await vi.waitFor(() => expect(solidResource()).toBe(42));
-                        dispose();
-                    });
-                });
-            });
-
-            describe("reactivity", () => {
-                it("should update SolidResource when FlowState changes", async () => {
-                    await createRoot(async (dispose) => {
-                        const $state = state(0);
-                        const solidResource = from($state);
-
-                        // Wait for initial load
-                        await vi.waitFor(() => expect(solidResource()).toBe(0));
-                        const fn = vi.fn();
-
-                        createEffect(() => {
-                            fn(solidResource());
-                        });
-
-                        // Wait for effect to run
-                        await vi.waitFor(() => {
-                            expect(fn).toHaveBeenCalledTimes(1);
-                        });
-                        expect(fn).toHaveBeenLastCalledWith(0);
-
-                        // Update FlowState
-                        $state.set(1);
-
-                        // Wait for update
-                        await vi.waitFor(() => {
-                            expect(fn).toHaveBeenCalledTimes(2);
-                        });
-                        expect(fn).toHaveBeenLastCalledWith(1);
-                        dispose();
-                    });
-                });
-
-                it("should update SolidResource when FlowDerivation changes", async () => {
-                    await createRoot(async (dispose) => {
-                        const $state = state(5);
-                        const $derivation = derivation((t) => $state.get(t) * 2);
-                        const solidResource = from($derivation);
-
-                        // Wait for initial load
-                        await vi.waitFor(() => expect(solidResource()).toBe(10));
-
-                        const fn = vi.fn();
-                        createEffect(() => {
-                            fn(solidResource());
-                        });
-
-                        // Wait for effect to run
-                        await vi.waitFor(() => expect(fn).toHaveBeenCalledTimes(1));
-                        expect(fn).toHaveBeenLastCalledWith(10);
-
-                        // Update dependency
-                        $state.set(6);
-
-                        // Wait for update
-                        await vi.waitFor(() => {
-                            expect(fn).toHaveBeenCalledTimes(2);
-                        });
-                        expect(fn).toHaveBeenLastCalledWith(12);
-                        dispose();
-                    });
-                });
-
-                it("should update SolidResource when FlowStateAsync changes", async () => {
-                    await createRoot(async (dispose) => {
-                        const $stateAsync = stateAsync(Promise.resolve(0));
-                        const solidResource = from($stateAsync);
-
-                        // Wait for initial load
-                        await vi.waitFor(() => expect(solidResource()).toBe(0));
-
-                        const fn = vi.fn();
-                        createEffect(() => {
-                            fn(solidResource());
-                        });
-
-                        // Wait for effect to run
-                        await vi.waitFor(() => expect(fn).toHaveBeenCalledTimes(1));
-                        expect(fn).toHaveBeenLastCalledWith(0);
-
-                        // Update FlowStateAsync
-                        $stateAsync.set(Promise.resolve(1));
-
-                        // Wait for update
-                        await vi.waitFor(() => {
-                            expect(fn).toHaveBeenCalledTimes(2);
-                        });
-                        expect(fn).toHaveBeenLastCalledWith(1);
-
-                        dispose();
-                    });
-                });
-
-                it("should update SolidResource when FlowDerivationAsync changes", async () => {
-                    await createRoot(async (dispose) => {
-                        const $stateAsync = stateAsync(Promise.resolve(5));
-                        const $derivationAsync = derivationAsync(async (t) => (await $stateAsync.get(t)) * 2);
-                        const solidResource = from($derivationAsync);
-
-                        // Wait for initial load
-                        await vi.waitFor(() => expect(solidResource()).toBe(10));
-
-                        const fn = vi.fn();
-                        createEffect(() => {
-                            fn(solidResource());
-                        });
-
-                        // Wait for effect to run
-                        await vi.waitFor(() => expect(fn).toHaveBeenCalledTimes(1));
-                        expect(fn).toHaveBeenLastCalledWith(10);
-
-                        // Update async dependency
-                        $stateAsync.set(Promise.resolve(6));
-
-                        // Wait for update
-                        await vi.waitFor(() => {
-                            expect(fn).toHaveBeenCalledTimes(2);
-                        });
-                        expect(fn).toHaveBeenLastCalledWith(12);
-                        dispose();
-                    });
-                });
-
-                it("should update SolidResource when getter dependency changes", async () => {
-                    await createRoot(async (dispose) => {
-                        const $state = state(5);
-                        const getter = (t: FlowTracker) => $state.get(t) * 2;
-                        const solidResource = from(getter);
-
-                        // Wait for initial load
-                        await vi.waitFor(() => expect(solidResource()).toBe(10));
-
-                        const fn = vi.fn();
-                        createEffect(() => {
-                            fn(solidResource());
-                        });
-
-                        // Wait for effect to run
-                        await vi.waitFor(() => expect(fn).toHaveBeenCalledTimes(1));
-                        expect(fn).toHaveBeenLastCalledWith(10);
-
-                        // Update the tracked FlowNode
-                        $state.set(6);
-
-                        // Wait for update
-                        await vi.waitFor(() => {
-                            expect(fn).toHaveBeenCalledTimes(2);
-                        });
-                        expect(fn).toHaveBeenLastCalledWith(12);
-
-                        dispose();
-                    });
-                });
-
-                it("should propagate multiple sequential changes", async () => {
-                    await createRoot(async (dispose) => {
-                        const $state = state(0);
-                        const solidResource = from($state);
-
-                        // Wait for initial load
-                        await vi.waitFor(() => expect(solidResource()).toBe(0));
-
-                        const fn = vi.fn();
-                        createEffect(() => {
-                            fn(solidResource());
-                        });
-
-                        // Wait for initial effect
-                        await vi.waitFor(() => expect(fn).toHaveBeenCalledTimes(1));
-                        expect(fn).toHaveBeenLastCalledWith(0);
-
-                        // Make multiple changes
-                        $state.set(1);
-                        await vi.waitFor(() => expect(solidResource()).toBe(1));
-
-                        $state.set(2);
-                        await vi.waitFor(() => expect(solidResource()).toBe(2));
-
-                        $state.set(3);
-                        await vi.waitFor(() => {
-                            expect(solidResource()).toBe(3);
-                        });
-                        dispose();
-                    });
-                });
-
-                it("should be reactive within createRoot", async () => {
-                    await createRoot(async (dispose) => {
-                        const $state = state(0);
-                        const solidResource = from($state);
-
-                        // Wait for initial load
-                        await vi.waitFor(() => expect(solidResource()).toBe(0));
-
-                        $state.set(1);
-                        await vi.waitFor(() => expect(solidResource()).toBe(1));
-
-                        $state.set(2);
-                        await vi.waitFor(() => expect(solidResource()).toBe(2));
-                        dispose();
-                    });
-                });
-
-                it("should update SolidResource.get() value when FlowNode changes", async () => {
-                    await createRoot(async (dispose) => {
-                        const $state = state(0);
-                        const solidResource = from($state);
-
-                        // Wait for initial load
-                        await vi.waitFor(() => expect(solidResource()).toBe(0));
-
-                        $state.set(1);
-                        await vi.waitFor(() => expect(solidResource()).toBe(1));
-
-                        // Test async updates for FlowNodeAsync
-                        const $stateAsync = stateAsync(Promise.resolve(10));
-                        const solidResourceAsync = from($stateAsync);
-
-                        await vi.waitFor(() => expect(solidResourceAsync()).toBe(10));
-
-                        $stateAsync.set(Promise.resolve(20));
-                        await vi.waitFor(() => expect(solidResourceAsync()).toBe(20));
-                        dispose();
-                    });
-                });
-
-                it("should trigger createEffect when FlowNode value changes", async () => {
-                    await createRoot(async (dispose) => {
-                        const $state = state(0);
-                        const solidResource = from($state);
-
-                        // Wait for initial load
-                        await vi.waitFor(() => expect(solidResource()).toBe(0));
-
-                        const fn = vi.fn();
-                        createEffect(() => {
-                            fn(solidResource());
-                        });
-
-                        // Wait for initial effect
-                        await vi.waitFor(() => expect(fn).toHaveBeenCalledTimes(1));
-                        expect(fn).toHaveBeenLastCalledWith(0);
-
-                        // Change FlowNode
-                        $state.set(1);
-                        await vi.waitFor(() => expect(fn).toHaveBeenCalledTimes(2));
-                        expect(fn).toHaveBeenLastCalledWith(1);
-
-                        // Test with async FlowNode
-                        const $stateAsync = stateAsync(Promise.resolve(10));
-                        const solidResourceAsync = from($stateAsync);
-
-                        await vi.waitFor(() => expect(solidResourceAsync()).toBe(10));
-
-                        const fn2 = vi.fn();
-                        createEffect(() => {
-                            fn2(solidResourceAsync());
-                        });
-
-                        await vi.waitFor(() => expect(fn2).toHaveBeenCalledTimes(1));
-                        expect(fn2).toHaveBeenLastCalledWith(10);
-
-                        $stateAsync.set(Promise.resolve(20));
-                        await vi.waitFor(() => expect(fn2).toHaveBeenCalledTimes(2));
-                        expect(fn2).toHaveBeenLastCalledWith(20);
-                        dispose();
-                    });
-                });
-            });
-
-            describe("cleanup", () => {
-                it("should dispose FlowEffect on cleanup", async () => {
-                    await createRoot(async (dispose) => {
-                        const $state = state(0);
-                        const solidResource = from($state);
-
-                        // Wait for initial load
-                        await vi.waitFor(() => expect(solidResource()).toBe(0));
-
-                        const fn = vi.fn();
-                        createEffect(() => {
-                            fn(solidResource());
-                        });
-
-                        await vi.waitFor(() => expect(fn).toHaveBeenCalledTimes(1));
-                        expect(fn).toHaveBeenLastCalledWith(0);
-
-                        // Dispose
-                        dispose();
-
-                        // Try to update - should not trigger effects after dispose
-                        $state.set(1);
-                        await new Promise((resolve) => setTimeout(resolve, 20));
-
-                        // Effect count should not have increased after dispose
-                        expect(fn).toHaveBeenCalledTimes(1);
-                    });
-                });
-
-                it("should clean up subscriptions on unmount", async () => {
-                    await createRoot(async (dispose) => {
-                        const $state = state(0);
-                        const solidResource = from($state);
-
-                        // Wait for initial load
-                        await vi.waitFor(() => expect(solidResource()).toBe(0));
-
-                        const fn = vi.fn();
-                        createEffect(() => {
-                            fn(solidResource());
-                        });
-
-                        await vi.waitFor(() => expect(fn).toHaveBeenCalledTimes(1));
-                        expect(fn).toHaveBeenLastCalledWith(0);
-
-                        // Dispose (unmount)
-                        dispose();
-
-                        // Update should not trigger after unmount
-                        $state.set(1);
-                        await new Promise((resolve) => setTimeout(resolve, 20));
-
-                        expect(fn).toHaveBeenCalledTimes(1);
-                    });
-                });
-
-                it("should not update after dispose", async () => {
-                    await createRoot(async (dispose) => {
-                        const $state = state(0);
-                        const solidResource = from($state);
-
-                        // Wait for initial load
-                        await vi.waitFor(() => expect(solidResource()).toBe(0));
-
-                        const initialValue = solidResource();
-                        expect(initialValue).toBe(0);
-
-                        // Dispose
-                        dispose();
-
-                        // Update FlowNode
-                        $state.set(1);
-
-                        // Wait a bit
-                        await new Promise((resolve) => setTimeout(resolve, 20));
-
-                        // Value should not have changed after dispose
-                        // Note: The resource might still have the old value cached, but it shouldn't update
-                        // This test verifies that updates stop after dispose
-                        expect(solidResource()).toBe(initialValue);
-                    });
-                });
-            });
-
-            describe("integration with SolidJS", () => {
-                it("should work with createEffect", async () => {
-                    await createRoot(async (dispose) => {
-                        const $state = state(0);
-                        const solidResource = from($state);
-
-                        // Wait for initial load
-                        await vi.waitFor(() => expect(solidResource()).toBe(0));
-
-                        const values: number[] = [];
-                        createEffect(() => {
-                            values.push(solidResource() ?? 0);
-                        });
-
-                        await vi.waitFor(() => {
-                            expect(values.length).toBeGreaterThan(0);
-                            expect(values[0]).toBe(0);
-                        });
-
-                        $state.set(1);
-                        await vi.waitFor(() => {
-                            expect(solidResource()).toBe(1);
-                            expect(values.length).toBeGreaterThan(1);
-                        });
-                        dispose();
-                    });
-                });
-
-                it("should handle multiple simultaneous conversions", async () => {
-                    await createRoot(async (dispose) => {
-                        const $state1 = state(1);
-                        const $state2 = state(2);
-                        const $state3 = state(3);
-
-                        const solidResource1 = from($state1);
-                        const solidResource2 = from($state2);
-                        const solidResource3 = from($state3);
-
-                        // Wait for all to load
-                        await Promise.all([
-                            vi.waitFor(() => expect(solidResource1()).toBe(1)),
-                            vi.waitFor(() => expect(solidResource2()).toBe(2)),
-                            vi.waitFor(() => expect(solidResource3()).toBe(3)),
-                        ]);
-
-                        // Update all
-                        $state1.set(10);
-                        $state2.set(20);
-                        $state3.set(30);
-
-                        await Promise.all([
-                            vi.waitFor(() => expect(solidResource1()).toBe(10)),
-                            vi.waitFor(() => expect(solidResource2()).toBe(20)),
-                            vi.waitFor(() => expect(solidResource3()).toBe(30)),
-                        ]);
-                        dispose();
-                    });
-                });
-            });
-        });
-    });
-});