@ersbeth/picoflow 1.0.0 → 1.1.0

package/test/solid/converters.test.ts

@@ -0,0 +1,721 @@
+import { createEffect, createRoot } from "solid-js";
+import { describe, expect, it, vi } from "vitest";
+import {
+	derivation,
+	derivationAsync,
+	type FlowTracker,
+	state,
+	stateAsync,
+} from "#package";
+import { from } from "../../src/solid/converters";
+import { SolidResource } from "../../src/solid/primitives";
+
+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);
+
+						expect(solidResource).toBeInstanceOf(SolidResource);
+
+						await vi.waitFor(() => expect(solidResource.get()).toBe(42));
+						dispose();
+					});
+				});
+
+				it("should convert FlowNodeAsync to SolidResource", async () => {
+					await createRoot(async (dispose) => {
+						const $stateAsync = stateAsync(Promise.resolve(42));
+						const solidResource = from($stateAsync);
+
+						expect(solidResource).toBeInstanceOf(SolidResource);
+
+						await vi.waitFor(() => expect(solidResource.get()).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);
+
+						expect(solidResource).toBeInstanceOf(SolidResource);
+
+						await vi.waitFor(() => expect(solidResource.get()).toBe(42));
+						dispose();
+					});
+				});
+
+				it("should convert asynchronous getter function to SolidResource", async () => {
+					await createRoot(async (dispose) => {
+						const $stateAsync = stateAsync(Promise.resolve(42));
+						const getter = async (t: FlowTracker) => await $stateAsync.get(t);
+						const solidResource = from(getter);
+
+						expect(solidResource).toBeInstanceOf(SolidResource);
+
+						await vi.waitFor(() => expect(solidResource.get()).toBe(42));
+						dispose();
+					});
+				});
+
+				it("should return a SolidResource instance", async () => {
+					await createRoot(async (dispose) => {
+						const $state = state(42);
+						const solidResource = from($state);
+
+						expect(solidResource).toBeInstanceOf(SolidResource);
+
+						await vi.waitFor(() => expect(solidResource.get()).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);
+
+						expect(solidResource).toBeInstanceOf(SolidResource);
+
+						await vi.waitFor(() => expect(solidResource.get()).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);
+
+						expect(solidResource).toBeInstanceOf(SolidResource);
+
+						await vi.waitFor(() => expect(solidResource.get()).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.get()).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.get()).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.get()).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.get()).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.get()).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.get()).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.get()).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);
+
+						expect(solidResource).toBeInstanceOf(SolidResource);
+
+						await vi.waitFor(() => expect(solidResource.get()).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) => (await $stateAsync.get(t)) * 2,
+						);
+						const solidResource = from($derivationAsync);
+
+						expect(solidResource).toBeInstanceOf(SolidResource);
+
+						await vi.waitFor(() => expect(solidResource.get()).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.get()).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.get()).toBe(42));
+						dispose();
+					});
+				});
+
+				it("should handle rejected Promises", async () => {
+					await createRoot(async (dispose) => {
+						const $stateAsync = stateAsync(
+							Promise.reject(new Error("Test error")),
+						);
+
+						const solidResource = from($stateAsync);
+
+						solidResource.get();
+
+						await vi.waitFor(() =>
+							expect(solidResource.state()).toBe("errored"),
+						);
+						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);
+
+						expect(solidResource).toBeInstanceOf(SolidResource);
+
+						await vi.waitFor(() => expect(solidResource.get()).toBe(42));
+						dispose();
+					});
+				});
+
+				it("should convert an asynchronous getter to SolidResource", async () => {
+					await createRoot(async (dispose) => {
+						const $stateAsync = stateAsync(Promise.resolve(42));
+						const getter = async (t: FlowTracker) => await $stateAsync.get(t);
+						const solidResource = from(getter);
+
+						expect(solidResource).toBeInstanceOf(SolidResource);
+
+						await vi.waitFor(() => expect(solidResource.get()).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.get()).toBe(10));
+
+						$state.set(6);
+						await vi.waitFor(() => expect(solidResource.get()).toBe(12));
+						dispose();
+					});
+				});
+
+				it("should create a FlowNodeAsync from the getter", async () => {
+					await createRoot(async (dispose) => {
+						const $stateAsync = stateAsync(Promise.resolve(42));
+						const getter = async (t: FlowTracker) => await $stateAsync.get(t);
+						const solidResource = from(getter);
+
+						await vi.waitFor(() => expect(solidResource.get()).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.get()).toBe(0));
+						const fn = vi.fn();
+
+						createEffect(() => {
+							fn(solidResource.get());
+						});
+
+						// 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.get()).toBe(10));
+
+						const fn = vi.fn();
+						createEffect(() => {
+							fn(solidResource.get());
+						});
+
+						// 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.get()).toBe(0));
+
+						const fn = vi.fn();
+						createEffect(() => {
+							fn(solidResource.get());
+						});
+
+						// Wait for effect to run
+						await vi.waitFor(() => expect(fn).toHaveBeenCalledTimes(1));
+						expect(fn).toHaveBeenLastCalledWith(0);
+
+						// Update FlowStateAsync
+						await $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.get()).toBe(10));
+
+						const fn = vi.fn();
+						createEffect(() => {
+							fn(solidResource.get());
+						});
+
+						// Wait for effect to run
+						await vi.waitFor(() => expect(fn).toHaveBeenCalledTimes(1));
+						expect(fn).toHaveBeenLastCalledWith(10);
+
+						// Update async dependency
+						await $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.get()).toBe(10));
+
+						const fn = vi.fn();
+						createEffect(() => {
+							fn(solidResource.get());
+						});
+
+						// 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.get()).toBe(0));
+
+						const fn = vi.fn();
+						createEffect(() => {
+							fn(solidResource.get());
+						});
+
+						// 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.get()).toBe(1));
+
+						$state.set(2);
+						await vi.waitFor(() => expect(solidResource.get()).toBe(2));
+
+						$state.set(3);
+						await vi.waitFor(() => {
+							expect(solidResource.get()).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.get()).toBe(0));
+
+						$state.set(1);
+						await vi.waitFor(() => expect(solidResource.get()).toBe(1));
+
+						$state.set(2);
+						await vi.waitFor(() => expect(solidResource.get()).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.get()).toBe(0));
+
+						$state.set(1);
+						await vi.waitFor(() => expect(solidResource.get()).toBe(1));
+
+						// Test async updates for FlowNodeAsync
+						const $stateAsync = stateAsync(Promise.resolve(10));
+						const solidResourceAsync = from($stateAsync);
+
+						await vi.waitFor(() => expect(solidResourceAsync.get()).toBe(10));
+
+						await $stateAsync.set(Promise.resolve(20));
+						await vi.waitFor(() => expect(solidResourceAsync.get()).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.get()).toBe(0));
+
+						const fn = vi.fn();
+						createEffect(() => {
+							fn(solidResource.get());
+						});
+
+						// 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.get()).toBe(10));
+
+						const fn2 = vi.fn();
+						createEffect(() => {
+							fn2(solidResourceAsync.get());
+						});
+
+						await vi.waitFor(() => expect(fn2).toHaveBeenCalledTimes(1));
+						expect(fn2).toHaveBeenLastCalledWith(10);
+
+						await $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.get()).toBe(0));
+
+						const fn = vi.fn();
+						createEffect(() => {
+							fn(solidResource.get());
+						});
+
+						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.get()).toBe(0));
+
+						const fn = vi.fn();
+						createEffect(() => {
+							fn(solidResource.get());
+						});
+
+						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.get()).toBe(0));
+
+						const initialValue = solidResource.get();
+						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.get()).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.get()).toBe(0));
+
+						const values: number[] = [];
+						createEffect(() => {
+							values.push(solidResource.get() ?? 0);
+						});
+
+						await vi.waitFor(() => {
+							expect(values.length).toBeGreaterThan(0);
+							expect(values[0]).toBe(0);
+						});
+
+						$state.set(1);
+						await vi.waitFor(() => {
+							expect(solidResource.get()).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.get()).toBe(1)),
+							vi.waitFor(() => expect(solidResource2.get()).toBe(2)),
+							vi.waitFor(() => expect(solidResource3.get()).toBe(3)),
+						]);
+
+						// Update all
+						$state1.set(10);
+						$state2.set(20);
+						$state3.set(30);
+
+						await Promise.all([
+							vi.waitFor(() => expect(solidResource1.get()).toBe(10)),
+							vi.waitFor(() => expect(solidResource2.get()).toBe(20)),
+							vi.waitFor(() => expect(solidResource3.get()).toBe(30)),
+						]);
+						dispose();
+					});
+				});
+			});
+		});
+	});
+});