@assistant-ui/tap 0.5.14 → 0.6.1

package/src/{tapResourceRoot.ts → hooks/useResourceRoot.ts}

@@ -3,22 +3,21 @@ import {
   createResourceFiber,
   renderResourceFiber,
   unmountResourceFiber,
-} from "./core/ResourceFiber";
-import { UpdateScheduler } from "./core/scheduler";
-import { tapConst } from "./hooks/tap-const";
-import { tapMemo } from "./hooks/tap-memo";
-import { tapEffect } from "./hooks/tap-effect";
-import { tapEffectEvent } from "./hooks/tap-effect-event";
-import { tapRef } from "./hooks/tap-ref";
-import type { RenderResult, ResourceElement } from "./core/types";
-import { isDevelopment } from "./core/helpers/env";
+} from "../core/ResourceFiber";
+import { UpdateScheduler } from "../core/scheduler";
+import { useMemo } from "./useMemo";
+import { useEffect } from "./useEffect";
+import { useEffectEvent } from "./useEffectEvent";
+import { useRef } from "./useRef";
+import type { RenderResult, ResourceElement } from "../core/types";
+import { isDevelopment } from "../core/helpers/env";
 import {
   commitRoot,
   createResourceFiberRoot,
   setRootVersion,
-} from "./core/helpers/root";
+} from "../core/helpers/root";
 
-export namespace tapResourceRoot {
+export namespace useResourceRoot {
   export type Unsubscribe = () => void;
 
   export interface SubscribableResource<TState> {
@@ -34,18 +33,18 @@ export namespace tapResourceRoot {
   }
 }
 
-// currently we never reset the root, because rollbakcs are not supported in tapResourceRoot
+// The root is never reset, because rollbacks are not supported in useResourceRoot.
 
-export const tapResourceRoot = <TState>(
+export const useResourceRoot = <TState>(
   element: ResourceElement<TState>,
-): tapResourceRoot.SubscribableResource<TState> => {
-  const scheduler = tapConst(
+): useResourceRoot.SubscribableResource<TState> => {
+  const scheduler = useMemo(
     () => new UpdateScheduler(() => handleUpdate(null)),
     [],
   );
-  const queue = tapConst(() => [] as (() => void)[], []);
+  const queue = useMemo(() => [] as (() => void)[], []);
 
-  const fiber = tapMemo(() => {
+  const fiber = useMemo(() => {
     void element.key;
 
     return createResourceFiber(
@@ -56,16 +55,16 @@ export const tapResourceRoot = <TState>(
         scheduler.markDirty();
       }),
     );
-  }, [element.type, element.key]);
+  }, [element.type, element.key, queue, scheduler]);
 
   setRootVersion(fiber.root, fiber.root.committedVersion);
   const render = renderResourceFiber(fiber, element.props);
 
-  const isMountedRef = tapRef(false);
-  const committedPropsRef = tapRef(element.props);
-  const valueRef = tapRef<TState>(render.output);
-  const subscribers = tapConst(() => new Set<() => void>(), []);
-  const handleUpdate = tapEffectEvent((render: RenderResult | null) => {
+  const isMountedRef = useRef(false);
+  const committedPropsRef = useRef(element.props);
+  const valueRef = useRef<TState>(render.output);
+  const subscribers = useMemo(() => new Set<() => void>(), []);
+  const handleUpdate = useEffectEvent((render: RenderResult | null) => {
     if (render === null) {
       setRootVersion(fiber.root, 2);
       setRootVersion(fiber.root, 1);
@@ -100,7 +99,7 @@ export const tapResourceRoot = <TState>(
     subscribers.forEach((callback) => callback());
   });
 
-  tapEffect(() => {
+  useEffect(() => {
     isMountedRef.current = true;
     return () => {
       isMountedRef.current = false;
@@ -108,7 +107,7 @@ export const tapResourceRoot = <TState>(
     };
   }, [fiber]);
 
-  tapEffect(() => {
+  useEffect(() => {
     committedPropsRef.current = render.props;
     commitRoot(fiber.root);
     commitResourceFiber(fiber, render);
@@ -118,7 +117,7 @@ export const tapResourceRoot = <TState>(
     subscribers.forEach((callback) => callback());
   });
 
-  return tapMemo(
+  return useMemo(
     () => ({
       getValue: () => valueRef.current,
       subscribe: (listener: () => void) => {
@@ -126,6 +125,6 @@ export const tapResourceRoot = <TState>(
         return () => subscribers.delete(listener);
       },
     }),
-    [],
+    [subscribers],
   );
 };

package/src/hooks/{tap-resources.ts → useResources.ts}

@@ -4,17 +4,16 @@ import type {
   ResourceElement,
   ResourceFiber,
 } from "../core/types";
-import { tapEffect } from "./tap-effect";
-import { tapMemo } from "./tap-memo";
-import { tapCallback } from "./tap-callback";
+import { useEffect } from "./useEffect";
+import { useMemo } from "./useMemo";
+import { useCallback } from "./useCallback";
 import {
   createResourceFiber,
   unmountResourceFiber,
   renderResourceFiber,
   commitResourceFiber,
 } from "../core/ResourceFiber";
-import { tapConst } from "./tap-const";
-import { tapRef } from "./tap-ref";
+import { useRef } from "./useRef";
 import { getCurrentResourceFiber } from "../core/helpers/execution-context";
 
 type FiberState = {
@@ -25,31 +24,31 @@ type FiberState = {
     | "delete";
 };
 
-export function tapResources<E extends ResourceElement<any, any>>(
+export function useResources<E extends ResourceElement<any, any>>(
   getElements: () => readonly E[],
   getElementsDeps?: readonly unknown[],
 ): ExtractResourceReturnType<E>[] {
-  const versionRef = tapRef(0);
+  const versionRef = useRef(0);
   const version = versionRef.current;
 
-  const parentFiber = tapConst(getCurrentResourceFiber, []);
-  const markDirty = tapConst(
+  const parentFiber = useMemo(() => getCurrentResourceFiber(), []);
+  const markDirty = useMemo(
     () => () => {
       versionRef.current++;
       parentFiber.markDirty?.();
     },
-    [],
+    [parentFiber],
   );
-  const fibers = tapConst(() => new Map<string | number, FiberState>(), []);
+  const fibers = useMemo(() => new Map<string | number, FiberState>(), []);
 
   const getElementsMemo = getElementsDeps
-    ? // oxlint-disable-next-line tap-hooks/exhaustive-deps -- deps forwarded by caller
-      tapCallback(getElements, getElementsDeps)
+    ? // oxlint-disable-next-line react/exhaustive-deps,react/rules-of-hooks -- deps forwarded by caller; getElementsDeps presence is fixed per call site
+      useCallback(getElements, getElementsDeps)
     : getElements;
 
   // Process each element
 
-  const res = tapMemo(() => {
+  const res = useMemo(() => {
     void version;
 
     const elementsArray = getElementsMemo();
@@ -64,12 +63,12 @@ export function tapResources<E extends ResourceElement<any, any>>(
       const elementKey = element.key;
       if (elementKey === undefined) {
         throw new Error(
-          `tapResources did not provide a key for array at index ${i}`,
+          `useResources did not provide a key for array at index ${i}`,
         );
       }
 
       if (seenKeys.has(elementKey))
-        throw new Error(`Duplicate key ${elementKey} in tapResources`);
+        throw new Error(`Duplicate key ${elementKey} in useResources`);
       seenKeys.add(elementKey);
 
       let state = fibers.get(elementKey);
@@ -112,20 +111,20 @@ export function tapResources<E extends ResourceElement<any, any>>(
     }
 
     return results;
-  }, [getElementsMemo, version]);
+  }, [getElementsMemo, version, parentFiber, markDirty, fibers]);
 
   // Cleanup on unmount
-  tapEffect(() => {
+  useEffect(() => {
     return () => {
       for (const key of fibers.keys()) {
         const fiber = fibers.get(key)!.fiber;
         unmountResourceFiber(fiber);
       }
     };
-  }, []);
+  }, [fibers]);
 
-  tapEffect(() => {
-    res; // as a performance optimization, we only run if the results have changed
+  useEffect(() => {
+    void res; // as a performance optimization, we only run if the results have changed
 
     for (const [key, state] of fibers.entries()) {
       if (state.next === "delete") {
@@ -142,7 +141,7 @@ export function tapResources<E extends ResourceElement<any, any>>(
         commitResourceFiber(state.fiber, state.next);
       }
     }
-  }, [res]);
+  }, [res, fibers]);
 
   return res;
 }

package/src/hooks/useState.ts

@@ -0,0 +1,29 @@
+import { useReducer } from "./useReducer";
+
+export namespace useState {
+  export type StateUpdater<S> = S | ((prev: S) => S);
+}
+
+const stateReducer = <S>(
+  state: S | undefined,
+  action: useState.StateUpdater<S>,
+): S =>
+  typeof action === "function"
+    ? (action as (prev: S | undefined) => S)(state)
+    : action;
+
+const stateInit = <S>(initial: S | (() => S)): S =>
+  typeof initial === "function" ? (initial as () => S)() : initial;
+
+export function useState<S = undefined>(): [
+  S | undefined,
+  (updater: useState.StateUpdater<S>) => void,
+];
+export function useState<S>(
+  initial: S | (() => S),
+): [S, (updater: useState.StateUpdater<S>) => void];
+export function useState<S>(
+  initial?: S | (() => S),
+): [S | undefined, (updater: useState.StateUpdater<S>) => void] {
+  return useReducer(stateReducer, initial, stateInit);
+}

package/src/hooks/utils/{tapHook.ts → useCell.ts}

@@ -1,7 +1,7 @@
 import { getCurrentResourceFiber } from "../../core/helpers/execution-context";
 import type { Cell } from "../../core/types";
 
-export const tapHook = <T extends Cell["type"]>(
+export const useCell = <T extends Cell["type"]>(
   type: T,
   init: () => Cell,
 ): Cell & { type: T } => {

package/src/index.ts

@@ -1,35 +1,15 @@
 export { resource } from "./core/resource";
 export { withKey } from "./core/withKey";
 
-// primitive hooks
-export { tapState } from "./hooks/tap-state";
-export { tapReducer, tapReducerWithDerivedState } from "./hooks/tap-reducer";
-export { tapEffect } from "./hooks/tap-effect";
-
-// utility hooks
-export { tapRef } from "./hooks/tap-ref";
-export { tapConst } from "./hooks/tap-const";
-export { tapMemo } from "./hooks/tap-memo";
-export { tapCallback } from "./hooks/tap-callback";
-export { tapEffectEvent } from "./hooks/tap-effect-event";
-
-// resources
-export { tapResource } from "./hooks/tap-resource";
-export { tapResources } from "./hooks/tap-resources";
-
-// subscribable
-export { tapResourceRoot } from "./tapResourceRoot";
-
 // imperative
 export { createResourceRoot } from "./core/createResourceRoot";
 export { flushResourcesSync } from "./core/scheduler";
 
 // context
-export {
-  createResourceContext,
-  tap,
-  withContextProvider,
-} from "./core/context";
+export { createResourceContext, withContextProvider } from "./core/context";
+
+// hooks
+export { useResource, useResources, useResourceRoot } from "./react/hooks";
 
 // types
 export type {

package/src/react/hooks.ts

@@ -0,0 +1,112 @@
+import { useLayoutEffect, useMemo, useReducer, useRef, useState } from "react";
+import type { ResourceFiberRoot, Resource } from "../core/types";
+import {
+  createResourceFiber,
+  unmountResourceFiber,
+  renderResourceFiber,
+  commitResourceFiber,
+} from "../core/ResourceFiber";
+import { isDevelopment } from "../core/helpers/env";
+import {
+  commitRoot,
+  createResourceFiberRoot,
+  setRootVersion,
+} from "../core/helpers/root";
+import { peekResourceFiber } from "../core/helpers/execution-context";
+import * as hooks from "../hooks";
+import { resource } from "../core/resource";
+
+const useDevStrictMode = () => {
+  if (!isDevelopment) return null;
+
+  // oxlint-disable-next-line react/rules-of-hooks -- isDevelopment is a build-time constant, so this branch is stable per build
+  const count = useRef(0);
+  const isFirstRender = count.current === 0;
+  // oxlint-disable-next-line react/rules-of-hooks -- isDevelopment is a build-time constant, so this branch is stable per build
+  useState(() => count.current++);
+  if (count.current !== 2) return null;
+  return isFirstRender ? ("child" as const) : ("root" as const);
+};
+
+const HostResource = resource(function HostResource<T>(callback: () => T) {
+  return callback();
+});
+
+// Runs `callback` inside a resource render hosted by a React component, so the
+// resource composition hooks (useResource/useResources/useResourceRoot) work from
+// React. `callback` executes inside the resource fiber below, so it may only call
+// resource hooks, not React's own hooks (which would have no fiber to attach to).
+// This is the single React->resource bridge; the React branch of every public
+// hook goes through it.
+const useResourceHost = <T>(callback: () => T): T => {
+  const root = useMemo<ResourceFiberRoot>(() => {
+    return createResourceFiberRoot((cb) => dispatch(cb));
+  }, []);
+
+  const [version, dispatch] = useReducer((v: number, cb: () => boolean) => {
+    setRootVersion(root, v);
+    return v + (cb() ? 1 : 0);
+  }, 0);
+  setRootVersion(root, version);
+
+  const devStrictMode = useDevStrictMode();
+  const fiber = useMemo(() => {
+    return createResourceFiber(
+      HostResource as unknown as Resource<T, () => T>,
+      root,
+      undefined,
+      devStrictMode,
+    );
+  }, [root, devStrictMode]);
+
+  const result = renderResourceFiber(fiber, callback);
+  useLayoutEffect(() => {
+    return () => unmountResourceFiber(fiber);
+  }, [fiber]);
+  useLayoutEffect(() => {
+    commitRoot(root);
+    commitResourceFiber(fiber, result);
+  });
+
+  return result.output;
+};
+
+// Turns a resource hook into an isomorphic hook with the SAME type (overloads
+// included): inside a resource render it calls the hook directly; inside a React
+// component it hosts it via the `useResourceHost` bridge. peekResourceFiber() is
+// stable per call site (a given call always renders in the same environment), so
+// the branch order across renders is fixed even though rules-of-hooks can't prove
+// it.
+const makeHook = <F extends (...args: any[]) => any>(hook: F): F =>
+  ((...args: any[]) => {
+    /* oxlint-disable react/rules-of-hooks */
+    if (peekResourceFiber()) return hook(...args);
+    return useResourceHost(() => hook(...args));
+    /* oxlint-enable react/rules-of-hooks */
+  }) as F;
+
+/**
+ * Hosts a resource element. Inside a resource render it hosts the element as a
+ * child resource; inside a React component it hosts it via the React bridge.
+ * `propsDeps` is a resource-render optimization and is ignored on the React side.
+ */
+export const useResource: typeof hooks.useResource = makeHook(
+  hooks.useResource,
+);
+
+/**
+ * Hosts a keyed list of resource elements. Inside a resource render it composes
+ * them directly; inside a React component it hosts them via the React bridge.
+ */
+export const useResources: typeof hooks.useResources = makeHook(
+  hooks.useResources,
+);
+
+/**
+ * Hosts a resource element as a subscribable root. Inside a resource render it
+ * uses the root hook directly; inside a React component it hosts that root via
+ * the React bridge (host it in one place; observe it via getValue/subscribe).
+ */
+export const useResourceRoot: typeof hooks.useResourceRoot = makeHook(
+  hooks.useResourceRoot,
+);

package/src/react-shim/index.ts

@@ -0,0 +1,75 @@
+/* oxlint-disable react/rules-of-hooks -- this module deliberately routes hook calls between tap and React at runtime */
+/* oxlint-disable react/exhaustive-deps -- dependency arrays are forwarded verbatim from the caller */
+// Runtime drop-in for "react": forward everything from react, then override the
+// hooks that have a tap equivalent so they route to tap inside a resource render
+// and to React otherwise. Alias `react` to this module (build `output.paths` /
+// vitest resolver) in code that can run inside a tap resource.
+//
+// This subpath ships no type declarations: the build reverts the aliased
+// specifier back to `"react"` in emitted `.d.ts`, so consumer types resolve to
+// React's own. The source-level TS2498 from the `export *` below is suppressed.
+import React from "react";
+import { peekResourceFiber } from "../core/helpers/execution-context";
+import * as hooks from "../hooks";
+import { useResourceContext, isResourceContext } from "../core/context";
+
+// @ts-expect-error -- @types/react uses `export =`; this is valid at runtime.
+export * from "react";
+export { default } from "react";
+
+const inTap = () => peekResourceFiber() !== null;
+const ReactRuntime = React as any;
+
+// --- hooks with a tap equivalent: override the star-exported react hooks ---
+
+export const useState = (initialState?: any) =>
+  inTap() ? hooks.useState(initialState) : ReactRuntime.useState(initialState);
+
+export const useReducer = (reducer: any, initialArg: any, init?: any) =>
+  inTap()
+    ? hooks.useReducer(reducer, initialArg, init)
+    : ReactRuntime.useReducer(reducer, initialArg, init);
+
+export const useRef = (initialValue?: any) =>
+  inTap() ? hooks.useRef(initialValue) : ReactRuntime.useRef(initialValue);
+
+export const useMemo = (factory: any, deps: any) =>
+  inTap() ? hooks.useMemo(factory, deps) : ReactRuntime.useMemo(factory, deps);
+
+export const useCallback = (callback: any, deps: any) =>
+  inTap()
+    ? hooks.useCallback(callback, deps)
+    : ReactRuntime.useCallback(callback, deps);
+
+export const useEffect = (effect: any, deps?: any) =>
+  inTap()
+    ? hooks.useEffect(effect, deps)
+    : ReactRuntime.useEffect(effect, deps);
+
+// tap has a single effect primitive; layout effects collapse onto it
+export const useLayoutEffect = (effect: any, deps?: any) =>
+  inTap()
+    ? hooks.useEffect(effect, deps)
+    : ReactRuntime.useLayoutEffect(effect, deps);
+
+// The non-tap fallback requires a React version that provides useEffectEvent.
+export const useEffectEvent = (callback: any) =>
+  inTap()
+    ? hooks.useEffectEvent(callback)
+    : ReactRuntime.useEffectEvent(callback);
+
+// `use(usable)` reads tap resource context when handed a tap context (routed by
+// its brand, not by ambient render state), and falls back to React's `use`
+// (promises / React context) for everything else. The non-tap fallback requires
+// React 19.
+export const use = (usable: any) =>
+  isResourceContext(usable)
+    ? useResourceContext(usable)
+    : ReactRuntime.use(usable);
+
+// `useContext(context)` reads tap resource context when handed a tap context
+// (routed by its brand), and falls back to React's `useContext` otherwise.
+export const useContext = (context: any) =>
+  isResourceContext(context)
+    ? useResourceContext(context)
+    : ReactRuntime.useContext(context);

package/dist/hooks/tap-callback.d.ts

@@ -1,5 +0,0 @@
-//#region src/hooks/tap-callback.d.ts
-declare const tapCallback: <T extends (...args: any[]) => any>(fn: T, deps: readonly unknown[]) => T;
-//#endregion
-export { tapCallback };
-//# sourceMappingURL=tap-callback.d.ts.map

package/dist/hooks/tap-callback.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"tap-callback.d.ts","names":[],"sources":["../../src/hooks/tap-callback.ts"],"mappings":";cAEa,WAAA,iBAA6B,IAAA,iBACxC,EAAA,EAAI,CAAA,EACJ,IAAA,yBACC,CAGF"}

package/dist/hooks/tap-callback.js

@@ -1,9 +0,0 @@
-import { tapMemo } from "./tap-memo.js";
-//#region src/hooks/tap-callback.ts
-const tapCallback = (fn, deps) => {
-	return tapMemo(() => fn, deps);
-};
-//#endregion
-export { tapCallback };
-
-//# sourceMappingURL=tap-callback.js.map

package/dist/hooks/tap-callback.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"tap-callback.js","names":[],"sources":["../../src/hooks/tap-callback.ts"],"sourcesContent":["import { tapMemo } from \"./tap-memo\";\n\nexport const tapCallback = <T extends (...args: any[]) => any>(\n  fn: T,\n  deps: readonly unknown[],\n): T => {\n  // oxlint-disable-next-line tap-hooks/exhaustive-deps -- user-provided dep array forwarded verbatim\n  return tapMemo(() => fn, deps);\n};\n"],"mappings":";;AAEA,MAAa,eACX,IACA,SACM;CAEN,OAAO,cAAc,IAAI,IAAI;AAC/B"}

package/dist/hooks/tap-const.d.ts

@@ -1,5 +0,0 @@
-//#region src/hooks/tap-const.d.ts
-declare function tapConst<T>(getValue: () => T, _deps: readonly never[]): T;
-//#endregion
-export { tapConst };
-//# sourceMappingURL=tap-const.d.ts.map

package/dist/hooks/tap-const.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"tap-const.d.ts","names":[],"sources":["../../src/hooks/tap-const.ts"],"mappings":";iBAEgB,QAAA,IAAY,QAAA,QAAgB,CAAA,EAAG,KAAA,qBAA0B,CAAC"}

package/dist/hooks/tap-const.js

@@ -1,10 +0,0 @@
-import { tapState } from "./tap-state.js";
-//#region src/hooks/tap-const.ts
-function tapConst(getValue, _deps) {
-	const [state] = tapState(getValue);
-	return state;
-}
-//#endregion
-export { tapConst };
-
-//# sourceMappingURL=tap-const.js.map

package/dist/hooks/tap-const.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"tap-const.js","names":[],"sources":["../../src/hooks/tap-const.ts"],"sourcesContent":["import { tapState } from \"./tap-state\";\n\nexport function tapConst<T>(getValue: () => T, _deps: readonly never[]): T {\n  const [state] = tapState(getValue);\n  return state;\n}\n"],"mappings":";;AAEA,SAAgB,SAAY,UAAmB,OAA4B;CACzE,MAAM,CAAC,SAAS,SAAS,QAAQ;CACjC,OAAO;AACT"}

package/dist/hooks/tap-effect-event.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"tap-effect-event.d.ts","names":[],"sources":["../../src/hooks/tap-effect-event.ts"],"mappings":";;AAqBA;;;;;;;;;;AAEI;;;;iBAFY,cAAA,eAA6B,IAAA,iBAC3C,QAAA,EAAU,CAAA,GACT,CAAC"}

package/dist/hooks/tap-effect-event.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"tap-effect-event.js","names":[],"sources":["../../src/hooks/tap-effect-event.ts"],"sourcesContent":["import { tapRef } from \"./tap-ref\";\nimport { tapEffect } from \"./tap-effect\";\nimport { isDevelopment } from \"../core/helpers/env\";\nimport { tapCallback } from \"./tap-callback\";\nimport { getCurrentResourceFiber } from \"../core/helpers/execution-context\";\n\n/**\n * Creates a stable function reference that always calls the most recent version of the callback.\n * Similar to React's useEffectEvent hook.\n *\n * @param callback - The callback function to wrap\n * @returns A stable function reference that always calls the latest callback\n *\n * @example\n * ```typescript\n * const handleClick = tapEffectEvent((value: string) => {\n *   console.log(value);\n * });\n * // handleClick reference is stable, but always calls the latest version\n * ```\n */\nexport function tapEffectEvent<T extends (...args: any[]) => any>(\n  callback: T,\n): T {\n  const callbackRef = tapRef(callback);\n\n  // TODO this effect needs to run before all userland effects\n  tapEffect(() => {\n    callbackRef.current = callback;\n  });\n\n  const fiber = getCurrentResourceFiber();\n  return tapCallback(\n    ((...args: Parameters<T>) => {\n      if (isDevelopment && fiber.renderContext)\n        throw new Error(\"tapEffectEvent cannot be called during render\");\n      return callbackRef.current(...args);\n    }) as T,\n    [fiber],\n  );\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAqBA,SAAgB,eACd,UACG;CACH,MAAM,cAAc,OAAO,QAAQ;CAGnC,gBAAgB;EACd,YAAY,UAAU;CACxB,CAAC;CAED,MAAM,QAAQ,wBAAwB;CACtC,OAAO,cACH,GAAG,SAAwB;EAC3B,IAAI,iBAAiB,MAAM,eACzB,MAAM,IAAI,MAAM,+CAA+C;EACjE,OAAO,YAAY,QAAQ,GAAG,IAAI;CACpC,IACA,CAAC,KAAK,CACR;AACF"}

package/dist/hooks/tap-effect.d.ts

@@ -1,10 +0,0 @@
-//#region src/hooks/tap-effect.d.ts
-declare namespace tapEffect {
-  type Destructor = () => void;
-  type EffectCallback = () => Destructor | undefined;
-}
-declare function tapEffect(effect: tapEffect.EffectCallback): void;
-declare function tapEffect(effect: tapEffect.EffectCallback, deps: readonly unknown[]): void;
-//#endregion
-export { tapEffect };
-//# sourceMappingURL=tap-effect.d.ts.map

package/dist/hooks/tap-effect.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"tap-effect.d.ts","names":[],"sources":["../../src/hooks/tap-effect.ts"],"mappings":";kBAUiB,SAAA;EAAA,KACH,UAAA;EAAA,KACA,cAAA,SAAuB,UAAU;AAAA;AAAA,iBAG/B,SAAA,CAAU,MAAA,EAAQ,SAAA,CAAU,cAAc;AAAA,iBAC1C,SAAA,CACd,MAAA,EAAQ,SAAA,CAAU,cAAc,EAChC,IAAA"}

package/dist/hooks/tap-effect.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"tap-effect.js","names":[],"sources":["../../src/hooks/tap-effect.ts"],"sourcesContent":["import type { Cell } from \"../core/types\";\nimport { depsShallowEqual } from \"./utils/depsShallowEqual\";\nimport { tapHook, registerRenderMountTask } from \"./utils/tapHook\";\n\nconst newEffect = (): Cell & { type: \"effect\" } => ({\n  type: \"effect\",\n  cleanup: undefined,\n  deps: null, // null means the effect has never been run\n});\n\nexport namespace tapEffect {\n  export type Destructor = () => void;\n  export type EffectCallback = () => Destructor | undefined;\n}\n\nexport function tapEffect(effect: tapEffect.EffectCallback): void;\nexport function tapEffect(\n  effect: tapEffect.EffectCallback,\n  deps: readonly unknown[],\n): void;\nexport function tapEffect(\n  effect: tapEffect.EffectCallback,\n  deps?: readonly unknown[],\n): void {\n  const cell = tapHook(\"effect\", newEffect);\n\n  if (deps && cell.deps && depsShallowEqual(cell.deps, deps)) return;\n  if (cell.deps !== null && !!deps !== !!cell.deps)\n    throw new Error(\n      \"tapEffect called with and without dependencies across re-renders\",\n    );\n\n  registerRenderMountTask(() => {\n    const errors: unknown[] = [];\n\n    try {\n      cell.cleanup?.();\n    } catch (error) {\n      errors.push(error);\n    } finally {\n      cell.cleanup = undefined;\n    }\n\n    try {\n      const cleanup = effect();\n\n      if (cleanup !== undefined && typeof cleanup !== \"function\") {\n        throw new Error(\n          \"An effect function must either return a cleanup function or nothing. \" +\n            `Received: ${typeof cleanup}`,\n        );\n      }\n\n      cell.cleanup = cleanup;\n    } catch (error) {\n      errors.push(error);\n    }\n\n    cell.deps = deps;\n\n    if (errors.length > 0) {\n      if (errors.length === 1) {\n        throw errors[0];\n      } else {\n        for (const error of errors) {\n          console.error(error);\n        }\n        throw new AggregateError(errors, \"Errors during commit\");\n      }\n    }\n  });\n}\n"],"mappings":";;;AAIA,MAAM,mBAA8C;CAClD,MAAM;CACN,SAAS,KAAA;CACT,MAAM;AACR;AAYA,SAAgB,UACd,QACA,MACM;CACN,MAAM,OAAO,QAAQ,UAAU,SAAS;CAExC,IAAI,QAAQ,KAAK,QAAQ,iBAAiB,KAAK,MAAM,IAAI,GAAG;CAC5D,IAAI,KAAK,SAAS,QAAQ,CAAC,CAAC,SAAS,CAAC,CAAC,KAAK,MAC1C,MAAM,IAAI,MACR,kEACF;CAEF,8BAA8B;EAC5B,MAAM,SAAoB,CAAC;EAE3B,IAAI;GACF,KAAK,UAAU;EACjB,SAAS,OAAO;GACd,OAAO,KAAK,KAAK;EACnB,UAAU;GACR,KAAK,UAAU,KAAA;EACjB;EAEA,IAAI;GACF,MAAM,UAAU,OAAO;GAEvB,IAAI,YAAY,KAAA,KAAa,OAAO,YAAY,YAC9C,MAAM,IAAI,MACR,kFACe,OAAO,SACxB;GAGF,KAAK,UAAU;EACjB,SAAS,OAAO;GACd,OAAO,KAAK,KAAK;EACnB;EAEA,KAAK,OAAO;EAEZ,IAAI,OAAO,SAAS,GAClB,IAAI,OAAO,WAAW,GACpB,MAAM,OAAO;OACR;GACL,KAAK,MAAM,SAAS,QAClB,QAAQ,MAAM,KAAK;GAErB,MAAM,IAAI,eAAe,QAAQ,sBAAsB;EACzD;CAEJ,CAAC;AACH"}

package/dist/hooks/tap-memo.d.ts

@@ -1,5 +0,0 @@
-//#region src/hooks/tap-memo.d.ts
-declare const tapMemo: <T>(fn: () => T, deps: readonly unknown[]) => T;
-//#endregion
-export { tapMemo };
-//# sourceMappingURL=tap-memo.d.ts.map

package/dist/hooks/tap-memo.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"tap-memo.d.ts","names":[],"sources":["../../src/hooks/tap-memo.ts"],"mappings":";cAWa,OAAA,MAAc,EAAA,QAAU,CAAA,EAAG,IAAA,yBAA2B,CAkBlE"}

package/dist/hooks/tap-memo.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"tap-memo.js","names":[],"sources":["../../src/hooks/tap-memo.ts"],"sourcesContent":["import { isDevelopment } from \"../core/helpers/env\";\nimport { getCurrentResourceFiber } from \"../core/helpers/execution-context\";\nimport { tapReducerWithDerivedState } from \"./tap-reducer\";\nimport { depsShallowEqual } from \"./utils/depsShallowEqual\";\n\nconst memoReducer = () => {\n  throw new Error(\"Memo reducer should not be called\");\n};\n\ntype MemoState<T> = { value: T; deps: readonly unknown[] };\n\nexport const tapMemo = <T>(fn: () => T, deps: readonly unknown[]): T => {\n  const fiber = getCurrentResourceFiber();\n  const [state] = tapReducerWithDerivedState(\n    memoReducer,\n    (state: MemoState<T> | null): MemoState<T> => {\n      if (state && depsShallowEqual(state.deps, deps)) return state;\n\n      const value = fn();\n\n      if (isDevelopment && fiber.devStrictMode) {\n        void fn();\n      }\n\n      return { value, deps };\n    },\n    null,\n  );\n  return state.value;\n};\n"],"mappings":";;;;;AAKA,MAAM,oBAAoB;CACxB,MAAM,IAAI,MAAM,mCAAmC;AACrD;AAIA,MAAa,WAAc,IAAa,SAAgC;CACtE,MAAM,QAAQ,wBAAwB;CACtC,MAAM,CAAC,SAAS,2BACd,cACC,UAA6C;EAC5C,IAAI,SAAS,iBAAiB,MAAM,MAAM,IAAI,GAAG,OAAO;EAExD,MAAM,QAAQ,GAAG;EAEjB,IAAI,iBAAiB,MAAM,eACzB,GAAQ;EAGV,OAAO;GAAE;GAAO;EAAK;CACvB,GACA,IACF;CACA,OAAO,MAAM;AACf"}

package/dist/hooks/tap-reducer.d.ts

@@ -1,9 +0,0 @@
-//#region src/hooks/tap-reducer.d.ts
-type Dispatch<A> = (action: A) => void;
-declare function tapReducer<S, A>(reducer: (state: S, action: A) => S, initialState: S): [S, Dispatch<A>];
-declare function tapReducer<S, A, I>(reducer: (state: S, action: A) => S, initialArg: I, init: (arg: I) => S): [S, Dispatch<A>];
-declare function tapReducerWithDerivedState<S, A, R extends S>(reducer: (state: S, action: A) => S, getDerivedState: (state: S) => R, initialState: S): [R, Dispatch<A>];
-declare function tapReducerWithDerivedState<S, A, I, R extends S>(reducer: (state: S, action: A) => S, getDerivedState: (state: S) => R, initialArg: I, init: (arg: I) => S): [R, Dispatch<A>];
-//#endregion
-export { tapReducer, tapReducerWithDerivedState };
-//# sourceMappingURL=tap-reducer.d.ts.map

package/dist/hooks/tap-reducer.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"tap-reducer.d.ts","names":[],"sources":["../../src/hooks/tap-reducer.ts"],"mappings":";KAMK,QAAA,OAAe,MAAA,EAAQ,CAAC;AAAA,iBAqGb,UAAA,OACd,OAAA,GAAU,KAAA,EAAO,CAAA,EAAG,MAAA,EAAQ,CAAA,KAAM,CAAA,EAClC,YAAA,EAAc,CAAA,IACZ,CAAA,EAAG,QAAA,CAAS,CAAA;AAAA,iBACA,UAAA,UACd,OAAA,GAAU,KAAA,EAAO,CAAA,EAAG,MAAA,EAAQ,CAAA,KAAM,CAAA,EAClC,UAAA,EAAY,CAAA,EACZ,IAAA,GAAO,GAAA,EAAK,CAAA,KAAM,CAAA,IAChB,CAAA,EAAG,QAAA,CAAS,CAAA;AAAA,iBAcA,0BAAA,iBAA2C,CAAA,EACzD,OAAA,GAAU,KAAA,EAAO,CAAA,EAAG,MAAA,EAAQ,CAAA,KAAM,CAAA,EAClC,eAAA,GAAkB,KAAA,EAAO,CAAA,KAAM,CAAA,EAC/B,YAAA,EAAc,CAAA,IACZ,CAAA,EAAG,QAAA,CAAS,CAAA;AAAA,iBACA,0BAAA,oBAA8C,CAAA,EAC5D,OAAA,GAAU,KAAA,EAAO,CAAA,EAAG,MAAA,EAAQ,CAAA,KAAM,CAAA,EAClC,eAAA,GAAkB,KAAA,EAAO,CAAA,KAAM,CAAA,EAC/B,UAAA,EAAY,CAAA,EACZ,IAAA,GAAO,GAAA,EAAK,CAAA,KAAM,CAAA,IAChB,CAAA,EAAG,QAAA,CAAS,CAAA"}

package/dist/hooks/tap-reducer.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"tap-reducer.js","names":[],"sources":["../../src/hooks/tap-reducer.ts"],"sourcesContent":["import { isDevelopment } from \"../core/helpers/env\";\nimport { getCurrentResourceFiber } from \"../core/helpers/execution-context\";\nimport type { ReducerQueueEntry, ResourceFiber } from \"../core/types\";\nimport { markCellDirty } from \"../core/helpers/root\";\nimport { tapHook } from \"./utils/tapHook\";\n\ntype Dispatch<A> = (action: A) => void;\n\nconst dispatchOnFiber = (\n  fiber: ResourceFiber<any, any>,\n  callback: () => (() => void) | null,\n): void => {\n  if (fiber.renderContext) {\n    throw new Error(\"Resource updated during render\");\n  }\n  if (fiber.isNeverMounted) {\n    throw new Error(\"Resource updated before mount\");\n  }\n\n  fiber.root.dispatchUpdate(() => {\n    const result = callback();\n    if (result) {\n      result();\n      fiber.root.changelog.push(result);\n      return true;\n    }\n    return false;\n  });\n};\n\nfunction tapReducerImpl<S, A, I, R extends S>(\n  reducer: (state: S, action: A) => S,\n  getDerivedState: ((state: S) => R) | undefined,\n  initialArg: S | I,\n  initFn: ((arg: I) => S) | undefined,\n): [R, Dispatch<A>] {\n  const cell = tapHook(\"reducer\", () => {\n    const fiber = getCurrentResourceFiber();\n\n    // First render: compute initial state\n    const initialState = initFn ? initFn(initialArg as I) : initialArg;\n\n    if (isDevelopment && fiber.devStrictMode && initFn) {\n      void initFn(initialArg as I);\n    }\n\n    return {\n      type: \"reducer\",\n      queue: new Set(),\n      dirty: false,\n      workInProgress: initialState,\n      current: initialState,\n      reducer,\n      dispatch: (action: A) => {\n        const entry: ReducerQueueEntry = {\n          action,\n          hasEagerState: false,\n          eagerState: undefined,\n        };\n\n        dispatchOnFiber(fiber, () => {\n          if (fiber.root.dirtyCells.length === 0 && !entry.hasEagerState) {\n            entry.eagerState = reducer(cell.workInProgress, action);\n            entry.hasEagerState = true;\n\n            if (Object.is(cell.current, entry.eagerState)) return null;\n          }\n\n          return () => {\n            markCellDirty(fiber, cell);\n            cell.queue.add(entry);\n          };\n        });\n      },\n    };\n  });\n\n  const fiber = getCurrentResourceFiber();\n  const sameReducer = reducer === cell.reducer;\n  cell.reducer = reducer;\n\n  for (const item of cell.queue) {\n    if (!item.hasEagerState || !sameReducer) {\n      item.eagerState = reducer(cell.workInProgress, item.action);\n      item.hasEagerState = true;\n    }\n\n    if (isDevelopment && fiber.devStrictMode) {\n      void reducer(cell.workInProgress, item.action);\n    }\n\n    cell.workInProgress = item.eagerState;\n  }\n  cell.queue.clear();\n\n  if (getDerivedState) {\n    const derived = getDerivedState(cell.workInProgress);\n\n    if (!Object.is(derived, cell.workInProgress)) {\n      markCellDirty(fiber, cell);\n      cell.workInProgress = derived;\n    }\n  }\n\n  return [cell.workInProgress, cell.dispatch];\n}\n\nexport function tapReducer<S, A>(\n  reducer: (state: S, action: A) => S,\n  initialState: S,\n): [S, Dispatch<A>];\nexport function tapReducer<S, A, I>(\n  reducer: (state: S, action: A) => S,\n  initialArg: I,\n  init: (arg: I) => S,\n): [S, Dispatch<A>];\nexport function tapReducer<S, A, I>(\n  reducer: (state: S, action: A) => S,\n  initialArg: S | I,\n  init?: (arg: I) => S,\n): [S, Dispatch<A>] {\n  return tapReducerImpl(\n    reducer,\n    undefined,\n    initialArg as S,\n    init as ((arg: S) => S) | undefined,\n  );\n}\n\nexport function tapReducerWithDerivedState<S, A, R extends S>(\n  reducer: (state: S, action: A) => S,\n  getDerivedState: (state: S) => R,\n  initialState: S,\n): [R, Dispatch<A>];\nexport function tapReducerWithDerivedState<S, A, I, R extends S>(\n  reducer: (state: S, action: A) => S,\n  getDerivedState: (state: S) => R,\n  initialArg: I,\n  init: (arg: I) => S,\n): [R, Dispatch<A>];\nexport function tapReducerWithDerivedState<S, A, I, R extends S>(\n  reducer: (state: S, action: A) => S,\n  getDerivedState: (state: S) => R,\n  initialArg: I,\n  init?: (arg: I) => S,\n): [R, Dispatch<A>] {\n  return tapReducerImpl(reducer, getDerivedState, initialArg, init);\n}\n"],"mappings":";;;;;AAQA,MAAM,mBACJ,OACA,aACS;CACT,IAAI,MAAM,eACR,MAAM,IAAI,MAAM,gCAAgC;CAElD,IAAI,MAAM,gBACR,MAAM,IAAI,MAAM,+BAA+B;CAGjD,MAAM,KAAK,qBAAqB;EAC9B,MAAM,SAAS,SAAS;EACxB,IAAI,QAAQ;GACV,OAAO;GACP,MAAM,KAAK,UAAU,KAAK,MAAM;GAChC,OAAO;EACT;EACA,OAAO;CACT,CAAC;AACH;AAEA,SAAS,eACP,SACA,iBACA,YACA,QACkB;CAClB,MAAM,OAAO,QAAQ,iBAAiB;EACpC,MAAM,QAAQ,wBAAwB;EAGtC,MAAM,eAAe,SAAS,OAAO,UAAe,IAAI;EAExD,IAAI,iBAAiB,MAAM,iBAAiB,QAC1C,OAAY,UAAe;EAG7B,OAAO;GACL,MAAM;GACN,uBAAO,IAAI,IAAI;GACf,OAAO;GACP,gBAAgB;GAChB,SAAS;GACT;GACA,WAAW,WAAc;IACvB,MAAM,QAA2B;KAC/B;KACA,eAAe;KACf,YAAY,KAAA;IACd;IAEA,gBAAgB,aAAa;KAC3B,IAAI,MAAM,KAAK,WAAW,WAAW,KAAK,CAAC,MAAM,eAAe;MAC9D,MAAM,aAAa,QAAQ,KAAK,gBAAgB,MAAM;MACtD,MAAM,gBAAgB;MAEtB,IAAI,OAAO,GAAG,KAAK,SAAS,MAAM,UAAU,GAAG,OAAO;KACxD;KAEA,aAAa;MACX,cAAc,OAAO,IAAI;MACzB,KAAK,MAAM,IAAI,KAAK;KACtB;IACF,CAAC;GACH;EACF;CACF,CAAC;CAED,MAAM,QAAQ,wBAAwB;CACtC,MAAM,cAAc,YAAY,KAAK;CACrC,KAAK,UAAU;CAEf,KAAK,MAAM,QAAQ,KAAK,OAAO;EAC7B,IAAI,CAAC,KAAK,iBAAiB,CAAC,aAAa;GACvC,KAAK,aAAa,QAAQ,KAAK,gBAAgB,KAAK,MAAM;GAC1D,KAAK,gBAAgB;EACvB;EAEA,IAAI,iBAAiB,MAAM,eACzB,QAAa,KAAK,gBAAgB,KAAK,MAAM;EAG/C,KAAK,iBAAiB,KAAK;CAC7B;CACA,KAAK,MAAM,MAAM;CAEjB,IAAI,iBAAiB;EACnB,MAAM,UAAU,gBAAgB,KAAK,cAAc;EAEnD,IAAI,CAAC,OAAO,GAAG,SAAS,KAAK,cAAc,GAAG;GAC5C,cAAc,OAAO,IAAI;GACzB,KAAK,iBAAiB;EACxB;CACF;CAEA,OAAO,CAAC,KAAK,gBAAgB,KAAK,QAAQ;AAC5C;AAWA,SAAgB,WACd,SACA,YACA,MACkB;CAClB,OAAO,eACL,SACA,KAAA,GACA,YACA,IACF;AACF;AAaA,SAAgB,2BACd,SACA,iBACA,YACA,MACkB;CAClB,OAAO,eAAe,SAAS,iBAAiB,YAAY,IAAI;AAClE"}

package/dist/hooks/tap-ref.d.ts

@@ -1,11 +0,0 @@
-//#region src/hooks/tap-ref.d.ts
-declare namespace tapRef {
-  interface RefObject<T> {
-    current: T;
-  }
-}
-declare function tapRef<T>(initialValue: T): tapRef.RefObject<T>;
-declare function tapRef<T = undefined>(): tapRef.RefObject<T | undefined>;
-//#endregion
-export { tapRef };
-//# sourceMappingURL=tap-ref.d.ts.map

package/dist/hooks/tap-ref.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"tap-ref.d.ts","names":[],"sources":["../../src/hooks/tap-ref.ts"],"mappings":";kBAEiB,MAAA;EAAA,UACE,SAAA;IACf,OAAA,EAAS,CAAC;EAAA;AAAA;AAAA,iBAIE,MAAA,IAAU,YAAA,EAAc,CAAA,GAAI,MAAA,CAAO,SAAA,CAAU,CAAA;AAAA,iBAC7C,MAAA,mBAAyB,MAAA,CAAO,SAAS,CAAC,CAAA"}