@ersbeth/picoflow 1.1.1 → 2.0.0

package/test/solid/converters.test.ts

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