@ersbeth/picoflow 2.0.1 → 2.0.3

package/test/reactivity/flowSignal.test.ts

@@ -1,226 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import { signal, subscribe } from "~";
-
-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()).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 void when triggered", () => {
-                const $signal = signal();
-                const result = $signal.trigger();
-                expect(result).toBeUndefined();
-            });
-
-            it("should throw error when trigger is called after disposal", () => {
-                const $signal = signal();
-                $signal.dispose();
-                expect(() => $signal.trigger()).toThrow("[PicoFlow] Primitive is disposed");
-            });
-
-            it("should allow multiple triggers", () => {
-                const $signal = signal();
-                $signal.trigger();
-                $signal.trigger();
-                $signal.trigger();
-                // Should not throw
-                expect(true).toBe(true);
-            });
-        });
-    });
-
-    describe("integration", () => {
-        describe("with effects", () => {
-            describe("watch", () => {
-                it("should register effect when watch is called", async () => {
-                    const $signal = signal();
-                    const onData = vi.fn();
-                    subscribe((t) => $signal.watch(t), onData);
-
-                    await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
-                    expect(onData).toHaveBeenCalledTimes(1);
-                });
-
-                it("should throw error when watch is called after signal disposal", async () => {
-                    const $signal = signal();
-                    const onData1 = vi.fn();
-                    subscribe((t) => $signal.watch(t), onData1);
-
-                    await vi.waitFor(() => expect(onData1).toHaveBeenCalledTimes(1));
-
-                    $signal.dispose();
-
-                    const onData2 = vi.fn();
-                    const onError = vi.fn();
-
-                    subscribe((t) => $signal.watch(t), onData2, onError);
-
-                    await vi.waitFor(() => expect(onError).toHaveBeenCalledTimes(1));
-                    expect(onData2).toHaveBeenCalledTimes(0);
-                    expect(onError).toHaveBeenLastCalledWith(expect.any(Error));
-
-                    expect(() => $signal.trigger()).toThrow("[PicoFlow] Primitive is disposed");
-                });
-            });
-
-            describe("trigger", () => {
-                it("should notify effects when triggered", async () => {
-                    const $signal = signal();
-                    const onData = vi.fn();
-                    subscribe((t) => $signal.watch(t), onData);
-
-                    await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
-
-                    $signal.trigger();
-                    await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
-
-                    $signal.trigger();
-                    await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(3));
-                });
-
-                it("should notify multiple effects when triggered", async () => {
-                    const $signal = signal();
-                    const onData1 = vi.fn();
-                    const onData2 = vi.fn();
-                    const onData3 = vi.fn();
-
-                    subscribe((t) => $signal.watch(t), onData1);
-
-                    subscribe((t) => $signal.watch(t), onData2);
-
-                    subscribe((t) => $signal.watch(t), onData3);
-
-                    await vi.waitFor(() => {
-                        expect(onData1).toHaveBeenCalledTimes(1);
-                        expect(onData2).toHaveBeenCalledTimes(1);
-                        expect(onData3).toHaveBeenCalledTimes(1);
-                    });
-
-                    $signal.trigger();
-                    await vi.waitFor(() => {
-                        expect(onData1).toHaveBeenCalledTimes(2);
-                        expect(onData2).toHaveBeenCalledTimes(2);
-                        expect(onData3).toHaveBeenCalledTimes(2);
-                    });
-                });
-
-                it("should not notify effects after they are disposed", async () => {
-                    const $signal = signal();
-                    const onData = vi.fn();
-                    const $effect = subscribe((t) => $signal.watch(t), onData);
-
-                    await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
-
-                    $signal.trigger();
-                    await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
-
-                    $effect.dispose();
-
-                    $signal.trigger();
-                    await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
-                });
-
-                it("should notify effects multiple times on multiple triggers", async () => {
-                    const $signal = signal();
-                    const onData = vi.fn();
-                    subscribe((t) => $signal.watch(t), onData);
-
-                    await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
-
-                    $signal.trigger();
-                    await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
-
-                    $signal.trigger();
-                    await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(3));
-
-                    $signal.trigger();
-                    await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(4));
-                });
-
-                it("should execute effects asynchronously when triggered", async () => {
-                    const $signal = signal();
-                    const onData = vi.fn();
-
-                    subscribe(
-                        (t) => $signal.watch(t),
-                        () => onData("effect-executed"),
-                    );
-
-                    onData("after-initial-effect");
-                    $signal.trigger();
-                    onData("trigger-called");
-
-                    await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(4));
-
-                    expect(onData).toHaveBeenNthCalledWith(1, "effect-executed");
-                    expect(onData).toHaveBeenNthCalledWith(2, "after-initial-effect");
-                    expect(onData).toHaveBeenNthCalledWith(3, "trigger-called");
-                    expect(onData).toHaveBeenNthCalledWith(4, "effect-executed");
-                });
-            });
-
-            describe("dispose", () => {
-                it("should not dispose effects when signal is disposed", async () => {
-                    const $signal = signal();
-                    const onData = vi.fn();
-                    const $effect = subscribe((t) => $signal.watch(t), onData);
-
-                    await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
-                    expect($effect.disposed).toBe(false);
-
-                    $signal.dispose();
-
-                    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 onData = vi.fn();
-                    const $effect = subscribe((t) => $signal.watch(t), onData);
-
-                    await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
-
-                    $signal.dispose();
-
-                    // Effect should still be active but not notified
-                    expect($effect.disposed).toBe(false);
-
-                    // But signal is disposed so trigger will fail
-                    expect(() => $signal.trigger()).toThrow("[PicoFlow] Primitive is disposed");
-                });
-            });
-        });
-    });
-});