@ersbeth/picoflow 1.0.0 → 1.1.0

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

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