@ersbeth/picoflow 1.1.1 → 2.0.0

package/test/base/flowSignal.test.ts

@@ -1,372 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import { effect, signal } from "#package";
-
-describe("FlowSignal", () => {
-	describe("unit", () => {
-		describe("disposal", () => {
-			it("should have disposed property set to false initially and true after disposal", () => {
-				const $signal = signal();
-				expect($signal.disposed).toBe(false);
-				$signal.dispose();
-				expect($signal.disposed).toBe(true);
-			});
-
-			it("should throw error when disposed twice", () => {
-				const $signal = signal();
-				$signal.dispose();
-				expect(() => $signal.dispose()).toThrow(
-					"[PicoFlow] Primitive is disposed",
-				);
-			});
-
-			it("should dispose signal successfully", () => {
-				const $signal = signal();
-				expect(() => $signal.dispose()).not.toThrow();
-				expect($signal.disposed).toBe(true);
-			});
-
-			it("should accept self option without throwing", () => {
-				const $signal = signal();
-				expect(() => $signal.dispose({ self: true })).not.toThrow();
-				expect($signal.disposed).toBe(true);
-			});
-
-			it("should accept default options without throwing", () => {
-				const $signal = signal();
-				expect(() => $signal.dispose()).not.toThrow();
-				expect($signal.disposed).toBe(true);
-			});
-		});
-
-		describe("trigger", () => {
-			it("should return a promise when triggered", () => {
-				const $signal = signal();
-				const result = $signal.trigger();
-				expect(result).toBeInstanceOf(Promise);
-			});
-
-			it("should throw error when trigger is called after disposal", async () => {
-				const $signal = signal();
-				$signal.dispose();
-				await expect($signal.trigger()).rejects.toThrow(
-					"[PicoFlow] Primitive is disposed",
-				);
-			});
-
-			it("should allow multiple triggers", async () => {
-				const $signal = signal();
-				const promise1 = $signal.trigger();
-				const promise2 = $signal.trigger();
-				const promise3 = $signal.trigger();
-
-				expect(promise1).toBeInstanceOf(Promise);
-				expect(promise2).toBeInstanceOf(Promise);
-				expect(promise3).toBeInstanceOf(Promise);
-
-				await Promise.all([promise1, promise2, promise3]);
-			});
-		});
-
-		describe("watch", () => {
-			it("should throw error when watch is called after disposal", () => {
-				const $signal = signal();
-				const $tracker = signal(); // Use another signal as FlowTracker
-				$signal.dispose();
-				expect(() => $signal.watch($tracker)).toThrow(
-					"[PicoFlow] Primitive is disposed",
-				);
-			});
-		});
-	});
-
-	describe("integration", () => {
-		describe("with effects", () => {
-			describe("watch", () => {
-				it("should register effect when watch is called", async () => {
-					const $signal = signal();
-					const effectFn = vi.fn();
-					effect((t) => {
-						$signal.watch(t);
-						effectFn();
-					});
-
-					await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
-					expect(effectFn).toHaveBeenCalledTimes(1);
-				});
-
-				it("should throw error when watch is called after signal disposal", async () => {
-					const $signal = signal();
-					const effectFn = vi.fn();
-					effect((t) => {
-						$signal.watch(t);
-						effectFn();
-					});
-
-					await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
-
-					$signal.dispose();
-
-					effect((t) => {
-						expect(() => $signal.watch(t)).toThrow(
-							"[PicoFlow] Primitive is disposed",
-						);
-					});
-
-					await expect($signal.trigger()).rejects.toThrow(
-						"[PicoFlow] Primitive is disposed",
-					);
-				});
-			});
-
-			describe("trigger", () => {
-				it("should notify effects when triggered", async () => {
-					const $signal = signal();
-					const effectFn = vi.fn();
-					effect((t) => {
-						$signal.watch(t);
-						effectFn();
-					});
-
-					await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
-
-					$signal.trigger();
-					await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(2));
-
-					$signal.trigger();
-					await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(3));
-				});
-
-				it("should notify multiple effects when triggered", async () => {
-					const $signal = signal();
-					const effectFn1 = vi.fn();
-					const effectFn2 = vi.fn();
-					const effectFn3 = vi.fn();
-
-					effect((t) => {
-						$signal.watch(t);
-						effectFn1();
-					});
-
-					effect((t) => {
-						$signal.watch(t);
-						effectFn2();
-					});
-
-					effect((t) => {
-						$signal.watch(t);
-						effectFn3();
-					});
-
-					await vi.waitFor(() => {
-						expect(effectFn1).toHaveBeenCalledTimes(1);
-						expect(effectFn2).toHaveBeenCalledTimes(1);
-						expect(effectFn3).toHaveBeenCalledTimes(1);
-					});
-
-					$signal.trigger();
-					await vi.waitFor(() => {
-						expect(effectFn1).toHaveBeenCalledTimes(2);
-						expect(effectFn2).toHaveBeenCalledTimes(2);
-						expect(effectFn3).toHaveBeenCalledTimes(2);
-					});
-				});
-
-				it("should not notify effects after they are disposed", async () => {
-					const $signal = signal();
-					const effectFn = vi.fn();
-					const $effect = effect((t) => {
-						$signal.watch(t);
-						effectFn();
-					});
-
-					await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
-
-					$signal.trigger();
-					await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(2));
-
-					$effect.dispose();
-
-					$signal.trigger();
-					await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(2));
-				});
-
-				it("should notify effects multiple times on multiple triggers", async () => {
-					const $signal = signal();
-					const effectFn = vi.fn();
-					effect((t) => {
-						$signal.watch(t);
-						effectFn();
-					});
-
-					await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
-
-					$signal.trigger();
-					await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(2));
-
-					$signal.trigger();
-					await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(3));
-
-					$signal.trigger();
-					await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(4));
-				});
-
-				it("should await trigger promise before effects complete", async () => {
-					const $signal = signal();
-					const executionOrder: string[] = [];
-					const effectFn = vi.fn();
-
-					effect((t) => {
-						$signal.watch(t);
-						executionOrder.push("effect-executed");
-						effectFn();
-					});
-
-					await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
-					executionOrder.push("after-initial-effect");
-
-					const triggerPromise = $signal.trigger();
-					executionOrder.push("trigger-called");
-
-					await triggerPromise;
-					executionOrder.push("trigger-resolved");
-
-					await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(2));
-
-					expect(executionOrder).toEqual([
-						"effect-executed",
-						"after-initial-effect",
-						"effect-executed",
-						"trigger-called",
-						"trigger-resolved",
-					]);
-				});
-			});
-
-			describe("dispose", () => {
-				it("should dispose effects when signal is disposed", async () => {
-					const $signal = signal();
-					const effectFn = vi.fn();
-					const $effect = effect((t) => {
-						$signal.watch(t);
-						effectFn();
-					});
-
-					await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
-					expect($effect.disposed).toBe(false);
-
-					$signal.dispose();
-
-					expect($effect.disposed).toBe(true);
-
-					await expect($signal.trigger()).rejects.toThrow(
-						"[PicoFlow] Primitive is disposed",
-					);
-				});
-
-				it("should not dispose effects when signal is disposed with self option", async () => {
-					const $signal = signal();
-					const effectFn = vi.fn();
-					const $effect = effect((t) => {
-						$signal.watch(t);
-						effectFn();
-					});
-
-					await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
-					expect($effect.disposed).toBe(false);
-
-					$signal.dispose({ self: true });
-
-					expect($effect.disposed).toBe(false);
-					expect($signal.disposed).toBe(true);
-				});
-
-				it("should unregister effects when signal is disposed with self option", async () => {
-					const $signal = signal();
-					const effectFn = vi.fn();
-					const $effect = effect((t) => {
-						$signal.watch(t);
-						effectFn();
-					});
-
-					await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
-
-					$signal.dispose({ self: true });
-
-					// Effect should still be active but not notified
-					expect($effect.disposed).toBe(false);
-
-					// But signal is disposed so trigger will fail
-					await expect($signal.trigger()).rejects.toThrow(
-						"[PicoFlow] Primitive is disposed",
-					);
-				});
-			});
-		});
-
-		describe("signal chaining", () => {
-			it("should notify listener signals when triggered", async () => {
-				const $signal1 = signal();
-				const $signal2 = signal();
-				const effectFn = vi.fn();
-
-				// signal2 watches signal1
-				effect((t) => {
-					$signal1.watch(t);
-					$signal2.trigger();
-				});
-
-				// effect watches signal2
-				effect((t) => {
-					$signal2.watch(t);
-					effectFn();
-				});
-
-				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
-
-				$signal1.trigger();
-				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(2));
-			});
-
-			// TODO: Fix this test
-			it.skip("should notify chained signals in correct order", async () => {
-				const $signal1 = signal();
-				const $signal2 = signal();
-				const $signal3 = signal();
-				const executionOrder: string[] = [];
-
-				effect((t) => {
-					$signal1.watch(t);
-					executionOrder.push("signal1-triggered");
-					$signal2.trigger();
-				});
-
-				effect((t) => {
-					$signal2.watch(t);
-					executionOrder.push("signal2-triggered");
-					$signal3.trigger();
-				});
-
-				effect((t) => {
-					$signal3.watch(t);
-					executionOrder.push("signal3-triggered");
-				});
-
-				await vi.waitFor(() =>
-					expect(executionOrder.length).toBeGreaterThan(0),
-				);
-
-				executionOrder.length = 0; // Clear initial execution
-
-				$signal1.trigger();
-				await vi.waitFor(() => expect(executionOrder.length).toBe(5));
-				console.log(executionOrder);
-
-				expect(executionOrder).toEqual([
-					"signal1-triggered",
-					"signal2-triggered",
-					"signal3-triggered",
-				]);
-			});
-		});
-	});
-});