@ersbeth/picoflow 1.1.1 → 2.0.0

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

@@ -0,0 +1,654 @@
+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();
+                    });
+                });
+            });
+        });
+    });
+});