@assistant-ui/tap 0.3.4 → 0.3.5

package/src/__tests__/basic/tapState.basic.test.ts

@@ -0,0 +1,240 @@
+import { describe, it, expect, afterEach } from "vitest";
+import { tapState } from "../../hooks/tap-state";
+import { tapEffect } from "../../hooks/tap-effect";
+import {
+  createTestResource,
+  renderTest,
+  cleanupAllResources,
+  waitForNextTick,
+  getCommittedState,
+} from "../test-utils";
+
+describe("tapState - Basic Functionality", () => {
+  afterEach(() => {
+    cleanupAllResources();
+  });
+
+  describe("Initialization", () => {
+    it("should initialize with direct value", () => {
+      const testFiber = createTestResource(() => {
+        const [count] = tapState(42);
+        return count;
+      });
+
+      const result = renderTest(testFiber, undefined);
+      expect(result).toBe(42);
+    });
+
+    it("should initialize with lazy value function", () => {
+      let initCalled = 0;
+
+      const testFiber = createTestResource(() => {
+        const [count] = tapState(() => {
+          initCalled++;
+          return 100;
+        });
+        return count;
+      });
+
+      // First render
+      const result = renderTest(testFiber, undefined);
+      expect(result).toBe(100);
+      expect(initCalled).toBe(1);
+
+      // Re-render should not call initializer again
+      renderTest(testFiber, undefined);
+      expect(initCalled).toBe(1);
+    });
+
+    it("should handle undefined initial state", () => {
+      const testFiber = createTestResource(() => {
+        const [value] = tapState<string>();
+        return value;
+      });
+
+      const result = renderTest(testFiber, undefined);
+      expect(result).toBeUndefined();
+    });
+  });
+
+  describe("State Updates", () => {
+    it("should update state and trigger re-render", async () => {
+      let renderCount = 0;
+      let setCountFn: ((value: number) => void) | null = null;
+
+      const testFiber = createTestResource(() => {
+        renderCount++;
+        const [count, setCount] = tapState(0);
+
+        // Capture setter on first render
+        if (!setCountFn) {
+          setCountFn = setCount;
+        }
+
+        return { count, renderCount };
+      });
+
+      // Initial render
+      const result1 = renderTest(testFiber, undefined);
+      expect(result1).toEqual({ count: 0, renderCount: 1 });
+
+      // Update state
+      setCountFn!(10);
+
+      // Wait for re-render
+      await waitForNextTick();
+
+      // Check that state was updated
+      expect(getCommittedState(testFiber)).toEqual({
+        count: 10,
+        renderCount: 2,
+      });
+    });
+
+    it("should not re-render for same value (Object.is comparison)", async () => {
+      let renderCount = 0;
+      let setCountFn: ((value: number) => void) | null = null;
+
+      const testFiber = createTestResource(() => {
+        renderCount++;
+        const [count, setCount] = tapState(42);
+
+        tapEffect(() => {
+          setCountFn = setCount;
+        });
+
+        return { count, renderCount };
+      });
+
+      // Initial render
+      renderTest(testFiber, undefined);
+      expect(renderCount).toBe(1);
+
+      // Set same value
+      setCountFn!(42);
+
+      // Wait to ensure no re-render happens
+      await waitForNextTick();
+
+      // Should not trigger re-render
+      expect(renderCount).toBe(1);
+    });
+
+    it("should handle functional updates", async () => {
+      let setCountFn: ((updater: (prev: number) => number) => void) | null =
+        null;
+
+      const testFiber = createTestResource(() => {
+        const [count, setCount] = tapState(10);
+
+        tapEffect(() => {
+          setCountFn = setCount;
+        });
+
+        return count;
+      });
+
+      // Initial render
+      renderTest(testFiber, undefined);
+      expect(getCommittedState(testFiber)).toBe(10);
+
+      // Functional update
+      setCountFn!((prev) => prev * 2);
+
+      await waitForNextTick();
+      expect(getCommittedState(testFiber)).toBe(20);
+
+      // Another functional update
+      setCountFn!((prev) => prev + 5);
+
+      await waitForNextTick();
+      expect(getCommittedState(testFiber)).toBe(25);
+    });
+  });
+
+  describe("Multiple States", () => {
+    it("should handle multiple state hooks independently", () => {
+      const testFiber = createTestResource(() => {
+        const [count1, setCount1] = tapState(1);
+        const [count2, setCount2] = tapState(2);
+        const [text, setText] = tapState("hello");
+
+        return {
+          count1,
+          count2,
+          text,
+          setters: { setCount1, setCount2, setText },
+        };
+      });
+
+      const result = renderTest(testFiber, undefined);
+      expect(result).toMatchObject({
+        count1: 1,
+        count2: 2,
+        text: "hello",
+      });
+    });
+
+    it("should update multiple states independently", async () => {
+      let setters: any = null;
+
+      const testFiber = createTestResource(() => {
+        const [a, setA] = tapState("a");
+        const [b, setB] = tapState("b");
+        const [c, setC] = tapState("c");
+
+        tapEffect(() => {
+          setters = { setA, setB, setC };
+        });
+
+        return { a, b, c };
+      });
+
+      // Initial render
+      renderTest(testFiber, undefined);
+      expect(getCommittedState(testFiber)).toEqual({ a: "a", b: "b", c: "c" });
+
+      // Update only B
+      setters.setB("B");
+      await waitForNextTick();
+      expect(getCommittedState(testFiber)).toEqual({ a: "a", b: "B", c: "c" });
+
+      // Update A and C
+      setters.setA("A");
+      setters.setC("C");
+      await waitForNextTick();
+      expect(getCommittedState(testFiber)).toEqual({ a: "A", b: "B", c: "C" });
+    });
+  });
+
+  describe("State Persistence", () => {
+    it("should persist state across prop changes", async () => {
+      let setCountFn: ((value: number) => void) | null = null;
+
+      const testFiber = createTestResource((props: { multiplier: number }) => {
+        const [count, setCount] = tapState(10);
+
+        tapEffect(() => {
+          setCountFn = setCount;
+        });
+
+        return {
+          count,
+          multiplied: count * props.multiplier,
+        };
+      });
+
+      // Initial render
+      const result1 = renderTest(testFiber, { multiplier: 2 });
+      expect(result1).toEqual({ count: 10, multiplied: 20 });
+
+      // Update state
+      setCountFn!(15);
+      await waitForNextTick();
+
+      // Re-render with different props
+      const result2 = renderTest(testFiber, { multiplier: 3 });
+      expect(result2).toEqual({ count: 15, multiplied: 45 });
+    });
+  });
+});

package/src/__tests__/errors/errors.effect-errors.test.ts

@@ -0,0 +1,222 @@
+import { describe, it, expect, vi } from "vitest";
+import { tapEffect } from "../../hooks/tap-effect";
+import { tapState } from "../../hooks/tap-state";
+import { createTestResource, renderTest, unmountResource } from "../test-utils";
+import {
+  renderResourceFiber,
+  commitResourceFiber,
+} from "../../core/ResourceFiber";
+
+describe("Errors - Effect Errors", () => {
+  it("should propagate errors from effects", () => {
+    const error = new Error("Effect error");
+
+    const resource = createTestResource(() => {
+      tapEffect(() => {
+        throw error;
+      });
+      return null;
+    });
+
+    expect(() => renderTest(resource, undefined)).toThrow(error);
+  });
+
+  it("should propagate errors from cleanup functions", () => {
+    const error = new Error("Cleanup error");
+    let dep = 0;
+
+    const resource = createTestResource(() => {
+      tapEffect(() => {
+        return () => {
+          if (dep > 0) {
+            throw error;
+          }
+        };
+      }, [dep]); // Cleanup will run when dep changes
+
+      return dep;
+    });
+
+    // First render and commit - establishes the effect
+    const ctx1 = renderResourceFiber(resource, undefined);
+    commitResourceFiber(resource, ctx1);
+
+    // Change dep to trigger cleanup on next render
+    dep = 1;
+
+    // Second render with different dep should trigger cleanup that throws
+    const ctx2 = renderResourceFiber(resource, undefined);
+    expect(() => commitResourceFiber(resource, ctx2)).toThrow(error);
+  });
+
+  it("should throw on invalid effect return value", () => {
+    const resource = createTestResource(() => {
+      tapEffect(() => {
+        return "not a function" as any; // Invalid return
+      });
+      return null;
+    });
+
+    expect(() => renderTest(resource, undefined)).toThrow(
+      "An effect function must either return a cleanup function or nothing",
+    );
+  });
+
+  it("should handle multiple effect errors", () => {
+    const error1 = new Error("First error");
+    const error2 = new Error("Second error");
+    const goodEffect = vi.fn();
+
+    const resource = createTestResource(() => {
+      tapEffect(() => {
+        throw error1;
+      });
+
+      tapEffect(goodEffect); // This won't run
+
+      tapEffect(() => {
+        throw error2;
+      });
+
+      return null;
+    });
+
+    // Should throw first error
+    expect(() => renderTest(resource, undefined)).toThrow(error1);
+    expect(goodEffect).not.toHaveBeenCalled();
+  });
+
+  it("should continue cleanup on unmount despite errors", () => {
+    const cleanupError = new Error("Cleanup failed");
+    const cleanup1 = vi.fn(() => {
+      throw cleanupError;
+    });
+    const cleanup2 = vi.fn();
+    const cleanup3 = vi.fn();
+
+    const resource = createTestResource(() => {
+      tapEffect(() => cleanup1);
+      tapEffect(() => cleanup2);
+      tapEffect(() => cleanup3);
+      return null;
+    });
+
+    renderTest(resource, undefined);
+
+    // Unmount should throw the error but should still run all cleanups
+    expect(() => unmountResource(resource)).toThrow(cleanupError);
+    expect(cleanup1).toHaveBeenCalled();
+    expect(cleanup2).toHaveBeenCalled();
+    expect(cleanup3).toHaveBeenCalled();
+  });
+
+  it("should handle errors in effect with dependencies", () => {
+    const error = new Error("Dep effect error");
+    let shouldThrow = false;
+
+    const resource = createTestResource(() => {
+      const [dep, setDep] = tapState(0);
+
+      tapEffect(() => {
+        if (shouldThrow) {
+          throw error;
+        }
+      }, [dep]);
+
+      // Use effect to trigger state change
+      tapEffect(() => {
+        if (dep === 0) {
+          shouldThrow = true;
+          setDep(1); // Trigger effect re-run
+        }
+      }, [dep]);
+
+      return dep;
+    });
+
+    // The initial render will trigger setState which causes flushSync
+    // The flushed re-render will throw the error
+    expect(() => renderTest(resource, undefined)).toThrow(error);
+  });
+
+  it("should handle async errors in effects", async () => {
+    // Set up a promise to catch the async error
+    let asyncErrorPromise: Promise<void>;
+
+    const resource = createTestResource(() => {
+      tapEffect(() => {
+        // Async errors are not caught by the framework
+        asyncErrorPromise = new Promise((_, reject) => {
+          setTimeout(() => {
+            reject(new Error("Async error"));
+          }, 0);
+        });
+
+        // Catch the error to prevent unhandled rejection
+        asyncErrorPromise.catch(() => {
+          // Expected - async errors are not caught by the framework
+        });
+      });
+      return null;
+    });
+
+    // This won't throw synchronously
+    expect(() => renderTest(resource, undefined)).not.toThrow();
+
+    // Wait for the async error to be handled
+    await new Promise((resolve) => setTimeout(resolve, 10));
+  });
+
+  it("should properly clean up state after effect error", () => {
+    const error = new Error("Effect error");
+    let effectRan = false;
+
+    const resource = createTestResource(() => {
+      const [value] = tapState("initial");
+
+      tapEffect(() => {
+        effectRan = true;
+        throw error;
+      });
+
+      return value;
+    });
+
+    expect(() => renderTest(resource, undefined)).toThrow(error);
+    expect(effectRan).toBe(true);
+
+    // Resource should not have committed state since commit failed
+    // Since commit failed, we can't check the state through normal means
+  });
+
+  it("should handle errors in effect cleanup during re-render", () => {
+    const cleanupError = new Error("Cleanup during re-render");
+    let throwOnCleanup = false;
+
+    const resource = createTestResource(() => {
+      const [count, setCount] = tapState(0);
+
+      tapEffect(() => {
+        return () => {
+          if (throwOnCleanup) {
+            throw cleanupError;
+          }
+        };
+      }, [count]);
+
+      // Use effect to trigger state change
+      tapEffect(() => {
+        if (count === 0) {
+          throwOnCleanup = true;
+          setCount(1);
+        }
+      }, [count]);
+
+      return count;
+    });
+
+    // The initial render will trigger setState which causes flushSync
+    // During the flush, the cleanup will run and throw
+    expect(() => renderTest(resource, undefined)).toThrow(cleanupError);
+  });
+});

package/src/__tests__/errors/errors.render-errors.test.ts

@@ -0,0 +1,190 @@
+import { describe, it, expect } from "vitest";
+import { tapEffect } from "../../hooks/tap-effect";
+import { tapState } from "../../hooks/tap-state";
+import { createTestResource, renderTest } from "../test-utils";
+import {
+  renderResourceFiber,
+  commitResourceFiber,
+  unmountResourceFiber,
+} from "../../core/ResourceFiber";
+
+describe("Errors - Render Errors", () => {
+  it("should propagate errors during render", () => {
+    const error = new Error("Render error");
+
+    const resource = createTestResource(() => {
+      throw error;
+    });
+
+    expect(() => renderResourceFiber(resource, undefined)).toThrow(error);
+  });
+
+  it("should throw when hooks are called outside render context", () => {
+    // Try to call hook outside of resource render
+    expect(() => {
+      tapState(0);
+    }).toThrow("No resource fiber available");
+
+    expect(() => {
+      tapEffect(() => {});
+    }).toThrow("No resource fiber available");
+  });
+
+  it("should handle errors in state initializers", () => {
+    const error = new Error("Initializer error");
+
+    const resource = createTestResource(() => {
+      const [value] = tapState(() => {
+        throw error;
+      });
+      return value;
+    });
+
+    expect(() => renderResourceFiber(resource, undefined)).toThrow(error);
+  });
+
+  it("should detect render during render", () => {
+    const resource = createTestResource(() => {
+      const [count, setCount] = tapState(0);
+
+      // This violates the rules - no state updates during render
+      if (count < 5) {
+        expect(() => setCount(count + 1)).toThrow(
+          "Resource updated during render",
+        );
+      }
+
+      return count;
+    });
+
+    renderResourceFiber(resource, undefined);
+  });
+
+  it("should allow setState during commit (effects)", () => {
+    const resource = createTestResource(() => {
+      const [count, setCount] = tapState(0);
+
+      tapEffect(() => {
+        // setState during effects (commit phase) is allowed
+        if (count < 5) {
+          setCount(count + 1);
+        }
+      });
+
+      return count;
+    });
+
+    const ctx = renderResourceFiber(resource, undefined);
+    // This should not throw - setState in effects is allowed
+    expect(() => commitResourceFiber(resource, ctx)).not.toThrow();
+    unmountResourceFiber(resource);
+  });
+
+  it("should handle errors in hook order validation", () => {
+    let useStateFirst = true;
+
+    const resource = createTestResource(() => {
+      if (useStateFirst) {
+        tapState(1);
+        tapEffect(() => {});
+      } else {
+        tapEffect(() => {});
+        tapState(1);
+      }
+      return null;
+    });
+
+    renderResourceFiber(resource, undefined);
+
+    useStateFirst = false;
+
+    expect(() => renderResourceFiber(resource, undefined)).toThrow(
+      "Hook order changed between renders",
+    );
+  });
+
+  it("should maintain resource state after render error", () => {
+    let shouldThrow = false;
+
+    const resource = createTestResource(() => {
+      const [count, _setCount] = tapState(42);
+
+      if (shouldThrow) {
+        throw new Error("Render failed");
+      }
+
+      return count;
+    });
+
+    // First successful render
+    const result = renderTest(resource, undefined);
+    expect(result).toBe(42);
+
+    // Failed render
+    shouldThrow = true;
+    expect(() => renderTest(resource, undefined)).toThrow("Render failed");
+
+    // State should be unchanged after failed render
+    // The resource state is preserved
+  });
+
+  it("should handle complex error scenarios", () => {
+    let phase = "render";
+
+    const resource = createTestResource(() => {
+      if (phase === "hook-order") {
+        // Wrong hook order
+        tapEffect(() => {});
+        tapState(1);
+      } else {
+        tapState(1);
+        tapEffect(() => {
+          if (phase === "effect-error") {
+            throw new Error("Effect error");
+          }
+        });
+      }
+
+      if (phase === "render-error") {
+        throw new Error("Render error");
+      }
+
+      return phase;
+    });
+
+    // Successful render
+    renderTest(resource, undefined);
+
+    // Render error
+    phase = "render-error";
+    expect(() => renderTest(resource, undefined)).toThrow("Render error");
+
+    // Hook order error
+    phase = "hook-order";
+    expect(() => renderTest(resource, undefined)).toThrow("Hook order changed");
+
+    // Effect error
+    phase = "effect-error";
+    expect(() => renderTest(resource, undefined)).toThrow("Effect error");
+  });
+
+  it("should handle errors in nested hook calls", () => {
+    const useFeature = () => {
+      // This will fail if called outside render
+      const [value] = tapState("feature");
+      return value;
+    };
+
+    // Outside render context
+    expect(() => useFeature()).toThrow("No resource fiber available");
+
+    // Inside render context
+    const resource = createTestResource(() => {
+      const feature = useFeature(); // This works
+      return feature;
+    });
+
+    const result = renderTest(resource, undefined);
+    expect(result).toBe("feature");
+  });
+});