@ersbeth/picoflow 1.1.2 → 2.0.0

package/test/nodes/sync/flowConstant.test.ts

@@ -1,620 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import { constant, effect, state } from "#package";
-
-describe("flowConstant", () => {
-	describe("unit", () => {
-		describe("initialization", () => {
-			it("should initialize with computed value", async () => {
-				const $constant = constant(() => 1);
-				expect(await $constant.pick()).toBe(1);
-			});
-
-			it("should compute value lazily on first access", async () => {
-				const computeFn = vi.fn(() => 42);
-				const $constant = constant(computeFn);
-
-				// Function should not be called yet
-				expect(computeFn).not.toHaveBeenCalled();
-
-				// First access triggers computation
-				const value = await $constant.pick();
-				expect(value).toBe(42);
-				expect(computeFn).toHaveBeenCalledTimes(1);
-			});
-
-			it("should call compute function only once", async () => {
-				const computeFn = vi.fn(() => 100);
-				const $constant = constant(computeFn);
-
-				// Multiple accesses should only call compute once
-				await $constant.pick();
-				await $constant.pick();
-				await $constant.pick();
-
-				expect(computeFn).toHaveBeenCalledTimes(1);
-			});
-
-			it("should cache value after first computation", async () => {
-				const computeFn = vi.fn(() => "cached");
-				const $constant = constant(computeFn);
-
-				const value1 = await $constant.pick();
-				const value2 = await $constant.pick();
-				const value3 = await $constant.pick();
-
-				expect(value1).toBe("cached");
-				expect(value2).toBe("cached");
-				expect(value3).toBe("cached");
-				expect(computeFn).toHaveBeenCalledTimes(1);
-			});
-
-			it("should handle number values", async () => {
-				const $constant = constant(() => 42);
-				expect(await $constant.pick()).toBe(42);
-			});
-
-			it("should handle string values", async () => {
-				const $constant = constant(() => "hello");
-				expect(await $constant.pick()).toBe("hello");
-			});
-
-			it("should handle object values", async () => {
-				const obj = { a: 1, b: 2 };
-				const $constant = constant(() => obj);
-				const value = await $constant.pick();
-				expect(value).toBe(obj);
-				expect(value).toEqual({ a: 1, b: 2 });
-			});
-
-			it("should handle array values", async () => {
-				const arr = [1, 2, 3];
-				const $constant = constant(() => arr);
-				const value = await $constant.pick();
-				expect(value).toBe(arr);
-				expect(value).toEqual([1, 2, 3]);
-			});
-
-			it("should handle undefined values", async () => {
-				const $constant = constant(() => undefined);
-				const value = await $constant.pick();
-				expect(value).toBeUndefined();
-			});
-
-			it("should handle null values", async () => {
-				const $constant = constant(() => null);
-				const value = await $constant.pick();
-				expect(value).toBeNull();
-			});
-		});
-
-		describe("get", () => {
-			it("should return value with tracking context", () => {
-				const $constant = constant(() => 5);
-				const $tracker = state(0); // Use state as FlowTracker
-				const value = $constant.get($tracker);
-				expect(value).toBe(5);
-			});
-
-			it("should compute value on first get call", () => {
-				const computeFn = vi.fn(() => 10);
-				const $constant = constant(computeFn);
-				const $tracker = state(0);
-
-				expect(computeFn).not.toHaveBeenCalled();
-				const value = $constant.get($tracker);
-				expect(value).toBe(10);
-				expect(computeFn).toHaveBeenCalledTimes(1);
-			});
-
-			it("should return cached value on subsequent get calls", () => {
-				const computeFn = vi.fn(() => 20);
-				const $constant = constant(computeFn);
-				const $tracker = state(0);
-
-				const value1 = $constant.get($tracker);
-				const value2 = $constant.get($tracker);
-				const value3 = $constant.get($tracker);
-
-				expect(value1).toBe(20);
-				expect(value2).toBe(20);
-				expect(value3).toBe(20);
-				expect(computeFn).toHaveBeenCalledTimes(1);
-			});
-
-			it("should throw error when get is called after disposal", () => {
-				const $constant = constant(() => 1);
-				const $tracker = state(0);
-
-				$constant.get($tracker);
-				$constant.dispose();
-
-				expect(() => $constant.get($tracker)).toThrow(
-					"[PicoFlow] Primitive is disposed",
-				);
-			});
-		});
-
-		describe("pick", () => {
-			it("should return value without tracking", async () => {
-				const $constant = constant(() => 15);
-				const value = await $constant.pick();
-				expect(value).toBe(15);
-			});
-
-			it("should compute value on first pick call", async () => {
-				const computeFn = vi.fn(() => 25);
-				const $constant = constant(computeFn);
-
-				expect(computeFn).not.toHaveBeenCalled();
-				const value = await $constant.pick();
-				expect(value).toBe(25);
-				expect(computeFn).toHaveBeenCalledTimes(1);
-			});
-
-			it("should return cached value on subsequent pick calls", async () => {
-				const computeFn = vi.fn(() => 30);
-				const $constant = constant(computeFn);
-
-				const value1 = await $constant.pick();
-				const value2 = await $constant.pick();
-				const value3 = await $constant.pick();
-
-				expect(value1).toBe(30);
-				expect(value2).toBe(30);
-				expect(value3).toBe(30);
-				expect(computeFn).toHaveBeenCalledTimes(1);
-			});
-
-			it("should throw error when pick is called after disposal", async () => {
-				const $constant = constant(() => 1);
-
-				expect(await $constant.pick()).toBe(1);
-
-				$constant.dispose();
-
-				await expect($constant.pick()).rejects.toThrow(
-					"[PicoFlow] Primitive is disposed",
-				);
-			});
-		});
-
-		describe("watch", () => {
-			it("should register dependency when watch is called", () => {
-				const $constant = constant(() => 35);
-				const $tracker = state(0);
-
-				expect(() => $constant.watch($tracker)).not.toThrow();
-			});
-
-			it("should compute value when watch is called", () => {
-				const computeFn = vi.fn(() => 40);
-				const $constant = constant(computeFn);
-				const $tracker = state(0);
-
-				expect(computeFn).not.toHaveBeenCalled();
-				$constant.watch($tracker);
-				expect(computeFn).toHaveBeenCalledTimes(1);
-			});
-
-			it("should throw error when watch is called after disposal", () => {
-				const $constant = constant(() => 1);
-				const $tracker = state(0);
-
-				$constant.watch($tracker);
-				$constant.dispose();
-
-				expect(() => $constant.watch($tracker)).toThrow(
-					"[PicoFlow] Primitive is disposed",
-				);
-			});
-		});
-
-		describe("subscribe", () => {
-			it("should return a disposer function", () => {
-				const $constant = constant(() => 50);
-				const listener = vi.fn();
-				const disposer = $constant.subscribe(listener);
-
-				expect(typeof disposer).toBe("function");
-			});
-
-			it("should call listener immediately with current value", async () => {
-				const $constant = constant(() => 55);
-				const listener = vi.fn();
-
-				$constant.subscribe(listener);
-
-				await vi.waitFor(() => expect(listener).toHaveBeenCalledTimes(1));
-				expect(listener).toHaveBeenLastCalledWith(55);
-			});
-
-			it("should not call listener after disposal of constant", async () => {
-				const $constant = constant(() => 60);
-				const listener = vi.fn();
-
-				$constant.subscribe(listener);
-				await vi.waitFor(() => expect(listener).toHaveBeenCalledTimes(1));
-
-				$constant.dispose();
-
-				// Wait to ensure listener is not called again
-				await new Promise((resolve) => setTimeout(resolve, 50));
-				expect(listener).toHaveBeenCalledTimes(1);
-			});
-
-			it("should not call listener after disposer is called", async () => {
-				const $constant = constant(() => 65);
-				const listener = vi.fn();
-
-				const disposer = $constant.subscribe(listener);
-				await vi.waitFor(() => expect(listener).toHaveBeenCalledTimes(1));
-
-				disposer();
-
-				// Wait to ensure listener is not called again
-				await new Promise((resolve) => setTimeout(resolve, 50));
-				expect(listener).toHaveBeenCalledTimes(1);
-			});
-
-			it("should support multiple subscriptions", async () => {
-				const $constant = constant(() => 70);
-				const listener1 = vi.fn();
-				const listener2 = vi.fn();
-				const listener3 = vi.fn();
-
-				$constant.subscribe(listener1);
-				$constant.subscribe(listener2);
-				$constant.subscribe(listener3);
-
-				await vi.waitFor(() => {
-					expect(listener1).toHaveBeenCalledTimes(1);
-					expect(listener2).toHaveBeenCalledTimes(1);
-					expect(listener3).toHaveBeenCalledTimes(1);
-				});
-
-				expect(listener1).toHaveBeenLastCalledWith(70);
-				expect(listener2).toHaveBeenLastCalledWith(70);
-				expect(listener3).toHaveBeenLastCalledWith(70);
-			});
-
-			it("should throw error when subscribe is called after disposal", () => {
-				const $constant = constant(() => 1);
-				const listener = vi.fn();
-
-				$constant.dispose();
-
-				expect(() => $constant.subscribe(listener)).toThrow(
-					"[PicoFlow] Primitive is disposed",
-				);
-			});
-		});
-
-		describe("disposal", () => {
-			it("should have disposed property set to false initially", () => {
-				const $constant = constant(() => 1);
-				expect($constant.disposed).toBe(false);
-			});
-
-			it("should have disposed property set to true after disposal", () => {
-				const $constant = constant(() => 1);
-				$constant.dispose();
-				expect($constant.disposed).toBe(true);
-			});
-
-			it("should throw error when disposed twice", () => {
-				const $constant = constant(() => 1);
-				$constant.dispose();
-				expect(() => $constant.dispose()).toThrow(
-					"[PicoFlow] Primitive is disposed",
-				);
-			});
-		});
-
-		describe("special cases", () => {
-			it("should handle constant with compute function using closure to capture values", () => {
-				let externalValue = 10;
-				const $constant = constant(() => {
-					// Closure captures external value at computation time
-					return externalValue * 2;
-				});
-
-				// Constant computes once with captured value
-				expect($constant.get(state(0))).toBe(20);
-
-				// Changing external value should not affect constant (it's cached)
-				externalValue = 20;
-				expect($constant.get(state(0))).toBe(20); // Still cached value
-			});
-		});
-
-		describe("error handling", () => {
-			describe("compute function errors", () => {
-				it("should propagate error when pick is called", async () => {
-					const error = new Error("Compute error");
-					const $constant = constant(() => {
-						throw error;
-					});
-
-					await expect($constant.pick()).rejects.toThrow("Compute error");
-				});
-
-				it("should propagate error when get is called", () => {
-					const error = new Error("Get error");
-					const $constant = constant(() => {
-						throw error;
-					});
-
-					expect(() => $constant.get(state(0))).toThrow("Get error");
-				});
-			});
-
-			describe("disposed constant", () => {
-				it("should throw error when pick is called after disposal", async () => {
-					const $constant = constant(() => 1);
-
-					$constant.dispose();
-
-					await expect($constant.pick()).rejects.toThrow(
-						"[PicoFlow] Primitive is disposed",
-					);
-				});
-
-				it("should throw error when get is called after disposal", () => {
-					const $constant = constant(() => 1);
-					const $tracker = state(0);
-
-					$constant.dispose();
-
-					expect(() => $constant.get($tracker)).toThrow(
-						"[PicoFlow] Primitive is disposed",
-					);
-				});
-			});
-		});
-	});
-
-	describe("with effect", () => {
-		describe("get", () => {
-			it("should create reactive dependency when get is used in effect", async () => {
-				const $constant = constant(() => 100);
-				const effectFn = vi.fn();
-
-				effect((t) => {
-					$constant.get(t);
-					effectFn();
-				});
-
-				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
-			});
-
-			it("should not re-execute effect when constant value does not change", async () => {
-				const $constant = constant(() => 200);
-				const effectFn = vi.fn();
-
-				effect((t) => {
-					$constant.get(t);
-					effectFn();
-				});
-
-				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
-
-				// Wait to ensure effect doesn't re-run
-				await new Promise((resolve) => setTimeout(resolve, 50));
-				expect(effectFn).toHaveBeenCalledTimes(1);
-			});
-
-			it("should not re-execute effect when constant value is immutable", async () => {
-				let capturedValue = 5;
-				const $constant = constant(() => capturedValue * 3);
-
-				const effectFn = vi.fn();
-				effect((t) => {
-					const value = $constant.get(t);
-					effectFn(value);
-				});
-
-				// Initial execution with computed value (5 * 3 = 15)
-				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
-				expect(effectFn).toHaveBeenLastCalledWith(15);
-
-				// Change captured value - constant is cached, so effect should not re-run
-				capturedValue = 10;
-				await new Promise((resolve) => setTimeout(resolve, 50));
-
-				// Effect should not re-run because constant is immutable and cached
-				expect(effectFn).toHaveBeenCalledTimes(1);
-			});
-
-			it("should support multiple effects depending on same constant", async () => {
-				const $constant = constant(() => 300);
-				const effectFn1 = vi.fn();
-				const effectFn2 = vi.fn();
-				const effectFn3 = vi.fn();
-
-				effect((t) => {
-					$constant.get(t);
-					effectFn1();
-				});
-
-				effect((t) => {
-					$constant.get(t);
-					effectFn2();
-				});
-
-				effect((t) => {
-					$constant.get(t);
-					effectFn3();
-				});
-
-				await vi.waitFor(() => {
-					expect(effectFn1).toHaveBeenCalledTimes(1);
-					expect(effectFn2).toHaveBeenCalledTimes(1);
-					expect(effectFn3).toHaveBeenCalledTimes(1);
-				});
-			});
-		});
-
-		describe("watch", () => {
-			it("should register dependency when watch is used in effect", async () => {
-				const $constant = constant(() => 400);
-				const effectFn = vi.fn();
-
-				effect((t) => {
-					$constant.watch(t);
-					effectFn();
-				});
-
-				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
-			});
-
-			it("should not trigger re-runs when constant is watched (immutable)", async () => {
-				const $constant = constant(() => 500);
-				const effectFn = vi.fn();
-
-				effect((t) => {
-					$constant.watch(t);
-					effectFn();
-				});
-
-				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
-
-				// Wait to ensure effect doesn't re-run
-				await new Promise((resolve) => setTimeout(resolve, 50));
-				expect(effectFn).toHaveBeenCalledTimes(1);
-			});
-		});
-
-		describe("subscribe", () => {
-			it("should call listener immediately when subscribe is used", async () => {
-				const $constant = constant(() => 600);
-				const listener = vi.fn();
-
-				$constant.subscribe(listener);
-
-				await vi.waitFor(() => expect(listener).toHaveBeenCalledTimes(1));
-				expect(listener).toHaveBeenLastCalledWith(600);
-			});
-
-			it("should not call listener after constant disposal", async () => {
-				const $constant = constant(() => 700);
-				const listener = vi.fn();
-
-				$constant.subscribe(listener);
-				await vi.waitFor(() => expect(listener).toHaveBeenCalledTimes(1));
-
-				$constant.dispose();
-
-				// Wait to ensure listener is not called again
-				await new Promise((resolve) => setTimeout(resolve, 50));
-				expect(listener).toHaveBeenCalledTimes(1);
-			});
-
-			it("should support multiple subscriptions", async () => {
-				const $constant = constant(() => 800);
-				const listener1 = vi.fn();
-				const listener2 = vi.fn();
-
-				$constant.subscribe(listener1);
-				$constant.subscribe(listener2);
-
-				await vi.waitFor(() => {
-					expect(listener1).toHaveBeenCalledTimes(1);
-					expect(listener2).toHaveBeenCalledTimes(1);
-				});
-
-				expect(listener1).toHaveBeenLastCalledWith(800);
-				expect(listener2).toHaveBeenLastCalledWith(800);
-			});
-		});
-
-		describe("disposal", () => {
-			it("should dispose effects when constant is disposed", async () => {
-				const $constant = constant(() => 900);
-				const effectFn = vi.fn();
-				const $effect = effect((t) => {
-					$constant.get(t);
-					effectFn();
-				});
-
-				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
-				expect($effect.disposed).toBe(false);
-
-				$constant.dispose();
-
-				expect($effect.disposed).toBe(true);
-			});
-
-			it("should not dispose effects when constant is disposed with self option", async () => {
-				const $constant = constant(() => 1000);
-				const effectFn = vi.fn();
-				const $effect = effect((t) => {
-					$constant.get(t);
-					effectFn();
-				});
-
-				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
-				expect($effect.disposed).toBe(false);
-
-				$constant.dispose({ self: true });
-
-				expect($effect.disposed).toBe(false);
-				expect($constant.disposed).toBe(true);
-			});
-
-			it("should unregister effects when constant is disposed with self option", async () => {
-				const $constant = constant(() => 1100);
-				const effectFn = vi.fn();
-				const $effect = effect((t) => {
-					$constant.get(t);
-					effectFn();
-				});
-
-				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
-
-				$constant.dispose({ self: true });
-
-				// Effect should still be active but not notified
-				expect($effect.disposed).toBe(false);
-
-				// But constant is disposed so operations should fail
-				const $tracker = state(0);
-				expect(() => $constant.get($tracker)).toThrow(
-					"[PicoFlow] Primitive is disposed",
-				);
-			});
-		});
-
-		describe("error handling", () => {
-			describe("compute function errors", () => {
-				it("should propagate error when used inside an effect", async () => {
-					const error = new Error("Effect compute error");
-					const $constant = constant(() => {
-						throw error;
-					});
-
-					const $effect = effect((t) => {
-						$constant.get(t);
-					});
-
-					await expect($effect.settled).rejects.toThrow("Effect compute error");
-				});
-			});
-
-			describe("disposed constant", () => {
-				it("should throw error when creating an effect with a disposed constant", async () => {
-					const $constant = constant(() => 1);
-
-					$constant.dispose();
-
-					const $effect = effect((t) => {
-						$constant.get(t);
-					});
-
-					await expect($effect.settled).rejects.toThrow(
-						"[PicoFlow] Primitive is disposed",
-					);
-				});
-			});
-		});
-	});
-});