@assistant-ui/tap 0.4.5 → 0.5.0

package/src/__tests__/strictmode/strictmode.test.ts

@@ -1,11 +1,12 @@
 import { describe, it, expect } from "vitest";
 import { resource } from "../../core/resource";
-import { isDevelopment } from "../../core/env";
+import { isDevelopment } from "../../core/helpers/env";
 import { tapRef } from "../../hooks/tap-ref";
 import { tapState } from "../../hooks/tap-state";
 import { tapEffect } from "../../hooks/tap-effect";
+import { tapMemo } from "../../hooks/tap-memo";
 import { tapResource } from "../../hooks/tap-resource";
-import { createResource } from "../../core/createResource";
+import { createResourceRoot } from "../../core/createResourceRoot";
 import { withKey } from "../../core/withKey";
 
 describe("Strict Mode", () => {
@@ -13,6 +14,68 @@ describe("Strict Mode", () => {
     expect(isDevelopment).toBe(true);
   });
 
+  it("should persist tapMemo cache across strict mode double render", () => {
+    const events: string[] = [];
+    let outerCount = 0;
+    let memoCount = 0;
+
+    const TestResource = resource(() => {
+      const idx = outerCount++;
+      events.push(`outer-${idx}`);
+
+      tapMemo(() => {
+        events.push(`memo-${memoCount++}`);
+        return {};
+      }, []);
+
+      events.push(`outerend-${idx}`);
+    });
+
+    const root = createResourceRoot();
+    root.render(TestResource());
+
+    console.log("Events:", events);
+
+    // tapMemo factory runs twice during first render (strict mode double-call)
+    // but should NOT run during second render (cache should persist)
+    expect(events).toEqual([
+      "outer-0",
+      "memo-0",
+      "memo-1",
+      "outerend-0",
+      "outer-1",
+      // no memo call here — cache should be reused
+      "outerend-1",
+    ]);
+  });
+
+  it("should double-invoke tapMemo factory and use the first result", () => {
+    const events: string[] = [];
+    let memoCallCount = 0;
+
+    const TestResource = resource(() => {
+      const memoValue = tapMemo(() => {
+        memoCallCount++;
+        events.push(`memo-${memoCallCount}`);
+        return memoCallCount;
+      }, []);
+
+      events.push(`render memoValue=${memoValue}`);
+    });
+
+    const root = createResourceRoot();
+    root.render(TestResource());
+
+    // Matches React useMemo behavior: factory is double-invoked,
+    // first result is kept
+    expect(events).toEqual([
+      "memo-1",
+      "memo-2",
+      "render memoValue=1",
+      "render memoValue=1",
+    ]);
+  });
+
   it("should double-render on first render", () => {
     let renderCount = 0;
 
@@ -21,8 +84,9 @@ describe("Strict Mode", () => {
       return { renderCount };
     });
 
-    const handle = createResource(TestResource(), { devStrictMode: true });
-    const output = handle.getValue();
+    const root = createResourceRoot();
+    const sub = root.render(TestResource());
+    const output = sub.getValue();
 
     expect(renderCount).toBe(2);
     expect(output.renderCount).toBe(2);
@@ -47,7 +111,8 @@ describe("Strict Mode", () => {
       expect(ref.current).toBe(4);
     });
 
-    createResource(TestResource(), { devStrictMode: true });
+    const root = createResourceRoot();
+    root.render(TestResource());
 
     expect(renderCount).toBe(4);
   });
@@ -86,7 +151,8 @@ describe("Strict Mode", () => {
       }, [count]);
     });
 
-    createResource(TestResource(), { devStrictMode: true });
+    const root = createResourceRoot();
+    root.render(TestResource());
 
     expect(events).toEqual([
       "mount-1",
@@ -113,8 +179,9 @@ describe("Strict Mode", () => {
       return tapResource(TestChildResource());
     });
 
-    const handle = createResource(TestResource(), { devStrictMode: true });
-    const output = handle.getValue();
+    const root = createResourceRoot();
+    const sub = root.render(TestResource());
+    const output = sub.getValue();
 
     expect(renderCount).toBe(2);
     expect(output.renderCount).toBe(2);
@@ -134,10 +201,8 @@ describe("Strict Mode", () => {
       });
     });
 
-    createResource(TestResource(), {
-      mount: true,
-      devStrictMode: true,
-    });
+    const root = createResourceRoot();
+    root.render(TestResource());
 
     expect(events).toEqual([
       "render-0",
@@ -189,11 +254,9 @@ describe("Strict Mode", () => {
       return tapResource(withKey(id, TestChildResource()));
     });
 
-    const handle = createResource(TestResource(), {
-      mount: true,
-      devStrictMode: true,
-    });
-    const output = handle.getValue();
+    const root = createResourceRoot();
+    const sub = root.render(TestResource());
+    const output = sub.getValue();
 
     expect(renderCount).toBe(4);
     expect(fnCount).toBe(4);
@@ -238,10 +301,8 @@ describe("Strict Mode", () => {
       return tapResource(withKey(id, TestChildResource()));
     });
 
-    createResource(TestResource(), {
-      mount: true,
-      devStrictMode: true,
-    });
+    const root = createResourceRoot();
+    root.render(TestResource());
 
     expect(events).toEqual([
       "outer-render-0",

package/src/__tests__/strictmode/tap-strictmode-rerender-sources.test.ts

@@ -7,52 +7,12 @@ import { describe, it, expect } from "vitest";
 import { resource } from "../../core/resource";
 import { tapState } from "../../hooks/tap-state";
 import { tapEffect } from "../../hooks/tap-effect";
-import { createResource } from "../../core/createResource";
+import { createResourceRoot } from "../../core/createResourceRoot";
 import { flushResourcesSync } from "../../core/scheduler";
 
 describe("Tap Strict Mode - Rerender Sources", () => {
-  describe("DEBUG: Callback invocation count", () => {
-    it("should show how many times the dispatchUpdate callback is invoked", () => {
-      let updaterInvocations = 0;
-      const events: string[] = [];
-
-      const TestResource = resource(() => {
-        const [count, setCount] = tapState(0);
-        events.push(`render count=${count}`);
-
-        return {
-          count,
-          increment: () => {
-            events.push("setState called");
-            setCount((prevCount) => {
-              updaterInvocations++;
-              events.push(
-                `updater invocation #${updaterInvocations} with prevCount=${prevCount}`,
-              );
-              return prevCount + 1;
-            });
-          },
-        };
-      });
-
-      const handle = createResource(TestResource(), { devStrictMode: true });
-
-      events.length = 0;
-      updaterInvocations = 0;
-
-      flushResourcesSync(() => {
-        handle.getValue().increment();
-      });
-
-      console.log("Updater invocations:", updaterInvocations);
-      console.log("Events:", events);
-      console.log(
-        "Expected: updater called twice (React behavior), actual:",
-        updaterInvocations,
-      );
-    });
-
-    it.skip("should use the same return value logic as React when updater returns different values", () => {
+  describe("Callback invocation count", () => {
+    it("should use the first return value when updater returns different values", () => {
       const events: string[] = [];
       let updaterCallCount = 0;
 
@@ -80,28 +40,26 @@ describe("Tap Strict Mode - Rerender Sources", () => {
         return { count };
       });
 
-      createResource(TestResource(), {
-        devStrictMode: true,
-        mount: true,
-      });
-
-      console.log("Tap updater call count:", updaterCallCount);
-      console.log("Tap events:", events);
+      const root = createResourceRoot();
+      root.render(TestResource());
 
-      // React behavior: updater called 4 times, uses LAST return value (200)
-      // Expected tap behavior: Same as React
+      // Tap behavior: updater called 4 times, uses FIRST return value per dispatch
+      // Effect #1 dispatch: updater(0) → 100 (kept)
+      // Effect #1 cleanup, Effect #2 mount
+      // Effect #2 dispatch: updater(0) → 200 (kept... but wait, prev=100 from effect #1)
+      // Updater double-invoke happens per-dispatch (matching React ordering)
       expect(updaterCallCount).toBe(4);
       expect(events).toEqual([
         "render count=0",
         "render count=0",
         "effect mount",
-        "updater call #1 with prev=0", // Effect #1: returns 100
+        "updater call #1 with prev=0",
         "effect cleanup",
         "effect mount",
-        "updater call #2 with prev=0", // Effect #2: returns 200
-        "updater call #3 with prev=100", // Strict mode double: returns 200
-        "updater call #4 with prev=100", // Strict mode double again: returns 200
-        "render count=200", // Uses LAST return value
+        "updater call #2 with prev=0",
+        "updater call #3 with prev=100",
+        "updater call #4 with prev=100",
+        "render count=200",
         "render count=200",
       ]);
     });
@@ -117,7 +75,8 @@ describe("Tap Strict Mode - Rerender Sources", () => {
         return { count };
       });
 
-      createResource(TestResource(), { devStrictMode: true });
+      const root = createResourceRoot();
+      root.render(TestResource());
 
       expect(events).toEqual(["render count=0", "render count=0"]);
     });
@@ -144,7 +103,8 @@ describe("Tap Strict Mode - Rerender Sources", () => {
         return { count };
       });
 
-      createResource(TestResource(), { devStrictMode: true, mount: true });
+      const root = createResourceRoot();
+      root.render(TestResource());
 
       expect(events).toEqual([
         "render count=0",
@@ -177,7 +137,8 @@ describe("Tap Strict Mode - Rerender Sources", () => {
         };
       });
 
-      const handle = createResource(TestResource(), { devStrictMode: true });
+      const root = createResourceRoot();
+      const sub = root.render(TestResource());
 
       // Initial render is double
       expect(events).toEqual(["render count=0", "render count=0"]);
@@ -186,7 +147,7 @@ describe("Tap Strict Mode - Rerender Sources", () => {
 
       // Call the method inside flushResourcesSync (like clicking a button)
       flushResourcesSync(() => {
-        handle.getValue().increment();
+        sub.getValue().increment();
       });
 
       // flushResourcesSync setState should ALSO double-render (matching React 19)
@@ -209,19 +170,20 @@ describe("Tap Strict Mode - Rerender Sources", () => {
         };
       });
 
-      const handle = createResource(TestResource(), { devStrictMode: true });
+      const root = createResourceRoot();
+      const sub = root.render(TestResource());
 
       events.length = 0; // Clear initial renders
 
       // Multiple flushResourcesSync calls (like multiple button clicks)
       flushResourcesSync(() => {
-        handle.getValue().increment();
+        sub.getValue().increment();
       });
       flushResourcesSync(() => {
-        handle.getValue().increment();
+        sub.getValue().increment();
       });
       flushResourcesSync(() => {
-        handle.getValue().increment();
+        sub.getValue().increment();
       });
 
       // Each call should cause double render
@@ -240,7 +202,7 @@ describe("Tap Strict Mode - Rerender Sources", () => {
   });
 
   describe("Source 4: setState in setTimeout", () => {
-    it.skip("should double-render AND double-call setTimeout callback", async () => {
+    it("should double-render AND double-call setTimeout callback", async () => {
       const events: string[] = [];
 
       const TestResource = resource(() => {
@@ -259,7 +221,8 @@ describe("Tap Strict Mode - Rerender Sources", () => {
         return { count };
       });
 
-      createResource(TestResource(), { devStrictMode: true, mount: true });
+      const root = createResourceRoot();
+      root.render(TestResource());
 
       // Wait for setTimeout
       await new Promise((resolve) => setTimeout(resolve, 50));
@@ -296,7 +259,8 @@ describe("Tap Strict Mode - Rerender Sources", () => {
         return { count };
       });
 
-      createResource(TestResource(), { devStrictMode: true, mount: true });
+      const root = createResourceRoot();
+      root.render(TestResource());
 
       // Wait for promise
       await new Promise((resolve) => setTimeout(resolve, 10));
@@ -331,12 +295,13 @@ describe("Tap Strict Mode - Rerender Sources", () => {
         };
       });
 
-      const handle = createResource(TestResource(), { devStrictMode: true });
+      const root = createResourceRoot();
+      const sub = root.render(TestResource());
 
       events.length = 0; // Clear initial renders
 
       flushResourcesSync(() => {
-        handle.getValue().updateBoth();
+        sub.getValue().updateBoth();
       });
 
       // Both setState calls batched, but render is DOUBLED
@@ -365,7 +330,8 @@ describe("Tap Strict Mode - Rerender Sources", () => {
         return {};
       });
 
-      createResource(TestResource(), { devStrictMode: true, mount: true });
+      const root = createResourceRoot();
+      root.render(TestResource());
 
       // Initial double-render, then batched setState causes another double-render
       expect(events).toEqual([
@@ -391,7 +357,8 @@ describe("Tap Strict Mode - Rerender Sources", () => {
         };
       });
 
-      createResource(TestResource(), { devStrictMode: true });
+      const root = createResourceRoot();
+      root.render(TestResource());
 
       // Resource renders should be doubled
       expect(events).toEqual(["render count=0", "render count=0"]);
@@ -418,12 +385,13 @@ describe("Tap Strict Mode - Rerender Sources", () => {
         };
       });
 
-      const handle = createResource(TestResource(), { devStrictMode: true });
+      const root = createResourceRoot();
+      const sub = root.render(TestResource());
 
       events.length = 0; // Clear initial renders
 
       flushResourcesSync(() => {
-        handle.getValue().increment();
+        sub.getValue().increment();
       });
 
       // React behavior: Updater function is called TWICE in strict mode
@@ -438,7 +406,7 @@ describe("Tap Strict Mode - Rerender Sources", () => {
   });
 
   describe("Source 9: Complex effect patterns", () => {
-    it.skip("should handle effect with dependencies and setState", () => {
+    it("should handle effect with dependencies and setState", () => {
       const events: string[] = [];
 
       const TestResource = resource(() => {
@@ -460,33 +428,26 @@ describe("Tap Strict Mode - Rerender Sources", () => {
         };
       });
 
-      const handle = createResource(TestResource(), {
-        devStrictMode: true,
-        mount: true,
-      });
+      const root = createResourceRoot();
+      const sub = root.render(TestResource());
 
-      // React behavior: When effect calls setState during strict mode,
-      // it triggers additional render cycles
+      // setDoubled(0*2) = setDoubled(0) is a no-op, so no extra render
       expect(events).toEqual([
         "render count=0 doubled=0",
         "render count=0 doubled=0",
         "effect count=0",
         "cleanup count=0",
         "effect count=0",
-        "render count=0 doubled=0",
-        "render count=0 doubled=0",
-        "cleanup count=0",
-        "effect count=0",
       ]);
 
       events.length = 0;
 
       // Trigger increment via flushResourcesSync
       flushResourcesSync(() => {
-        handle.getValue().increment();
+        sub.getValue().increment();
       });
 
-      // Should double-render with new count, effect updates doubled
+      // Double-render with new count, effect sets doubled=2, triggers another double-render
       expect(events).toEqual([
         "render count=1 doubled=0",
         "render count=1 doubled=0",
@@ -494,8 +455,6 @@ describe("Tap Strict Mode - Rerender Sources", () => {
         "effect count=1",
         "render count=1 doubled=2",
         "render count=1 doubled=2",
-        "cleanup count=1",
-        "effect count=1",
       ]);
     });
   });
@@ -517,7 +476,8 @@ describe("Tap Strict Mode - Rerender Sources", () => {
         return { value };
       });
 
-      createResource(TestResource(), { devStrictMode: true });
+      const root = createResourceRoot();
+      root.render(TestResource());
 
       // tapState initializer should be called twice, first value kept
       expect(events).toEqual([
@@ -544,17 +504,19 @@ describe("Tap Strict Mode - Rerender Sources", () => {
       });
 
       // Create first instance
-      const handle1 = createResource(TestResource(), { devStrictMode: true });
+      const root1 = createResourceRoot();
+      root1.render(TestResource());
 
       expect(events).toEqual(["render count=0", "render count=0"]);
 
       events.length = 0;
 
       // Unmount
-      handle1.unmount();
+      root1.unmount();
 
       // Create second instance
-      const handle2 = createResource(TestResource(), { devStrictMode: true });
+      const root2 = createResourceRoot();
+      const sub2 = root2.render(TestResource());
 
       // Should still double-render
       expect(events).toEqual(["render count=0", "render count=0"]);
@@ -563,7 +525,7 @@ describe("Tap Strict Mode - Rerender Sources", () => {
 
       // Method calls via flushResourcesSync should still double-render
       flushResourcesSync(() => {
-        handle2.getValue().increment();
+        sub2.getValue().increment();
       });
 
       expect(events).toEqual(["render count=1", "render count=1"]);
@@ -600,10 +562,8 @@ describe("Tap Strict Mode - Rerender Sources", () => {
         return { count };
       });
 
-      createResource(TestResource(), {
-        devStrictMode: true,
-        mount: true,
-      });
+      const root = createResourceRoot();
+      root.render(TestResource());
 
       // Expected: setState(1) from effect #1 should be applied
       // even though effect #1 was cleaned up
@@ -649,10 +609,8 @@ describe("Tap Strict Mode - Rerender Sources", () => {
         return { count };
       });
 
-      createResource(TestResource(), {
-        devStrictMode: true,
-        mount: true,
-      });
+      const root = createResourceRoot();
+      root.render(TestResource());
 
       // Expected: Only setState(2) should be applied (last one wins)
       expect(events).toEqual([
@@ -668,7 +626,7 @@ describe("Tap Strict Mode - Rerender Sources", () => {
       ]);
     });
 
-    it.skip("should handle updater functions from both effect mounts", () => {
+    it("should handle updater functions from both effect mounts", () => {
       const events: string[] = [];
       let effectRunCount = 0;
 
@@ -696,14 +654,13 @@ describe("Tap Strict Mode - Rerender Sources", () => {
         return { count };
       });
 
-      createResource(TestResource(), {
-        devStrictMode: true,
-        mount: true,
-      });
+      const root = createResourceRoot();
+      root.render(TestResource());
 
-      // React behavior: Both updaters are queued and executed
-      // Effect #1: updater(0) => 0 + 1 = 1
-      // Effect #2: updater(0) => 0 + 2 = 2, but then runs TWICE more with prev=1
+      // Tap behavior: Both updaters are queued and executed, first value kept per dispatch
+      // Updater double-invoke happens per-dispatch (matching React ordering)
+      // Effect #1: updater(0) => 0 + 1 = 1 (kept)
+      // Effect #2: updater(0) => 0 + 2 = 2... but prev=1 from effect #1
       // Final: 3
       expect(events).toEqual([
         "render count=0",

package/src/__tests__/test-utils.ts

@@ -1,3 +1,4 @@
+import { createResourceFiberRoot } from "../core/helpers/root";
 import { resource } from "../core/resource";
 import {
   createResourceFiber,
@@ -30,7 +31,10 @@ export function createTestResource<R, P>(fn: (props: P) => R) {
     }
   };
 
-  const fiber = createResourceFiber(resource(fn), rerenderCallback);
+  const fiber = createResourceFiber(
+    resource(fn),
+    createResourceFiberRoot(rerenderCallback),
+  );
   return fiber;
 }
 

package/src/core/ResourceFiber.ts

@@ -1,17 +1,27 @@
-import { ResourceFiber, RenderResult, Resource } from "./types";
-import { commitRender, cleanupAllEffects } from "./commit";
-import { getDevStrictMode, withResourceFiber } from "./execution-context";
-import { callResourceFn } from "./callResourceFn";
-import { isDevelopment } from "./env";
+import {
+  ResourceFiber,
+  RenderResult,
+  Resource,
+  ResourceFiberRoot,
+} from "./types";
+import { commitAllEffects, cleanupAllEffects } from "./helpers/commit";
+import {
+  getDevStrictMode,
+  withResourceFiber,
+} from "./helpers/execution-context";
+import { callResourceFn } from "./helpers/callResourceFn";
+import { isDevelopment } from "./helpers/env";
 
 export function createResourceFiber<R, P>(
   type: Resource<R, P>,
-  dispatchUpdate: (callback: () => boolean) => void,
+  root: ResourceFiberRoot,
+  markDirty: (() => void) | undefined = undefined,
   strictMode: "root" | "child" | null = getDevStrictMode(false),
 ): ResourceFiber<R, P> {
   return {
     type,
-    dispatchUpdate,
+    root,
+    markDirty,
     devStrictMode: strictMode,
     cells: [],
     currentIndex: 0,
@@ -35,7 +45,7 @@ export function renderResourceFiber<R, P>(
   props: P,
 ): RenderResult {
   const result = {
-    commitTasks: [],
+    effectTasks: [],
     props,
     output: undefined as R | undefined,
   };
@@ -59,10 +69,12 @@ export function commitResourceFiber<R, P>(
   fiber.isMounted = true;
 
   if (isDevelopment && fiber.isNeverMounted && fiber.devStrictMode === "root") {
-    commitRender(result);
+    fiber.isNeverMounted = false;
+
+    commitAllEffects(result);
     cleanupAllEffects(fiber);
   }
 
   fiber.isNeverMounted = false;
-  commitRender(result);
+  commitAllEffects(result);
 }

package/src/core/createResourceRoot.ts

@@ -0,0 +1,53 @@
+import { ResourceElement } from "./types";
+import {
+  createResourceFiber,
+  unmountResourceFiber,
+  renderResourceFiber,
+  commitResourceFiber,
+} from "./ResourceFiber";
+import { tapResourceRoot } from "../tapResourceRoot";
+import { resource } from "./resource";
+import { isDevelopment } from "./helpers/env";
+import { flushResourcesSync, UpdateScheduler } from "./scheduler";
+import { createResourceFiberRoot } from "./helpers/root";
+
+const SubscribableResource = resource(tapResourceRoot);
+
+export const createResourceRoot = () => {
+  const fiber = createResourceFiber<
+    tapResourceRoot.SubscribableResource<any>,
+    ResourceElement<any>
+  >(
+    SubscribableResource,
+    createResourceFiberRoot((callback) => {
+      new UpdateScheduler(() => {
+        if (callback()) {
+          throw new Error(
+            "Unexpected rerender of createResourceRoot outer fiber",
+          );
+        }
+        return false;
+      }).markDirty();
+    }),
+    undefined,
+    isDevelopment ? "root" : null,
+  );
+
+  return {
+    render: <R, P>(element: ResourceElement<R, P>) => {
+      // In strict mode, render twice to detect side effects
+      if (isDevelopment && fiber.devStrictMode === "root") {
+        void renderResourceFiber(fiber, element);
+      }
+
+      const render = renderResourceFiber(fiber, element);
+
+      flushResourcesSync(() => commitResourceFiber(fiber, render));
+
+      return render.output;
+    },
+    unmount: () => {
+      unmountResourceFiber(fiber);
+    },
+  };
+};