@assistant-ui/tap 0.6.0 → 0.7.1

package/src/hooks/utils/depsShallowEqual.ts

@@ -1,9 +1,19 @@
+import { isDevelopment } from "../../core/helpers/env";
+
 export const depsShallowEqual = (
   a: readonly unknown[],
   b: readonly unknown[],
 ) => {
-  if (a.length !== b.length) return false;
-  for (let i = 0; i < a.length; i++) {
+  if (isDevelopment && a.length !== b.length) {
+    console.error(
+      "The final argument passed to a hook changed size between renders. " +
+        "The order and size of this array must remain constant.\n\n" +
+        `Previous: [${a.join(", ")}]\n` +
+        `Incoming: [${b.join(", ")}]`,
+    );
+  }
+
+  for (let i = 0; i < a.length && i < b.length; i++) {
     if (!Object.is(a[i], b[i])) return false;
   }
   return true;

package/src/hooks/utils/useCell.ts

@@ -1,5 +1,5 @@
 import { getCurrentResourceFiber } from "../../core/helpers/execution-context";
-import type { Cell } from "../../core/types";
+import type { Cell, EffectTask } from "../../core/types";
 
 export const useCell = <T extends Cell["type"]>(
   type: T,
@@ -29,7 +29,7 @@ export const useCell = <T extends Cell["type"]>(
   return cell as Cell & { type: T };
 };
 
-export const registerRenderMountTask = (task: () => void) => {
+export const registerRenderMountTask = (task: EffectTask) => {
   const fiber = getCurrentResourceFiber();
   fiber.renderContext!.effectTasks.push(task);
 };

package/src/hooks/utils/useDevStrictMode.ts

@@ -0,0 +1,34 @@
+import { useRef, useState } from "react";
+import { isDevelopment } from "../../core/helpers/env";
+import {
+  getCurrentResourceFiber,
+  peekResourceFiber,
+} from "../../core/helpers/execution-context";
+
+const getTapDevMode = () => {
+  const currentResourceFiber = getCurrentResourceFiber();
+  if (currentResourceFiber.devStrictMode)
+    return currentResourceFiber.isFirstRender
+      ? ("child" as const)
+      : ("root" as const);
+  return null;
+};
+
+const child = () => "child" as const;
+const notDevMode = () => null;
+
+const useDevStrictModeReact = () => {
+  if (!isDevelopment) return notDevMode;
+
+  // 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);
+  // 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 notDevMode;
+  return child;
+};
+
+export const useDevStrictMode = () => {
+  // oxlint-disable-next-line react-hooks/rules-of-hooks
+  return peekResourceFiber() ? getTapDevMode : useDevStrictModeReact();
+};

package/src/hooks/utils/useRenderMemo.ts

@@ -0,0 +1,27 @@
+import { useState, useEffect } from "react";
+import { depsShallowEqual } from "./depsShallowEqual";
+
+export const useRenderMemo = <T>(callback: () => T, deps: unknown[]) => {
+  const [state] = useState(() => ({
+    wipDeps: null as unknown[] | null,
+    wip: null as T,
+    currentDeps: null as unknown[] | null,
+    current: null as T,
+  }));
+
+  state.wipDeps = state.currentDeps;
+  state.wip = state.current;
+
+  useEffect(() => {
+    state.currentDeps = state.wipDeps;
+    state.current = state.wip;
+  });
+
+  if (state.currentDeps && depsShallowEqual(state.currentDeps, deps))
+    return state.current;
+
+  state.wipDeps = deps;
+  state.wip = callback();
+
+  return state.wip;
+};

package/src/hooks/utils/useResourceFiberHostUtils.ts

@@ -0,0 +1,61 @@
+import { useRef, useMemo, useReducer, useCallback } from "react";
+import {
+  getCurrentResourceFiber,
+  peekResourceFiber,
+} from "../../core/helpers/execution-context";
+import {
+  createResourceFiberRoot,
+  setRootVersion,
+} from "../../core/helpers/root";
+import { createResourceFiber } from "../../core/ResourceFiber";
+import type { ResourceFiberRoot } from "../../core/types";
+import { useDevStrictMode } from "./useDevStrictMode";
+
+const useResourceFiberHostUtilsTap = () => {
+  const versionRef = useRef(0);
+  const version = versionRef.current;
+  const parent = getCurrentResourceFiber();
+  const markDirty = useMemo(
+    () => () => {
+      versionRef.current++;
+      parent?.markDirty?.();
+    },
+    [parent],
+  );
+
+  return { version, markDirty, root: parent.root };
+};
+
+const useResourceFiberHostUtilsReact = () => {
+  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);
+
+  return { root, version, markDirty: undefined };
+};
+
+export const useResourceFiberHost = () => {
+  const getDevMode = useDevStrictMode();
+  const { root, version, markDirty } = peekResourceFiber()
+    ? // oxlint-disable-next-line react-hooks/rules-of-hooks
+      useResourceFiberHostUtilsTap()
+    : // oxlint-disable-next-line react-hooks/rules-of-hooks
+      useResourceFiberHostUtilsReact();
+
+  const createFiber = useCallback(
+    <R, A extends readonly any[]>(
+      hook: (...props: A) => R,
+      _key: string | number | undefined,
+    ) => createResourceFiber(hook, root, markDirty, getDevMode()),
+    // oxlint-disable-next-line react-hooks/exhaustive-deps
+    [],
+  );
+
+  return { version, createFiber };
+};

package/src/index.ts

@@ -2,14 +2,17 @@ export { resource } from "./core/resource";
 export { withKey } from "./core/withKey";
 
 // imperative
-export { createResourceRoot } from "./core/createResourceRoot";
-export { flushResourcesSync } from "./core/scheduler";
+export { createTapRoot } from "./core/createTapRoot";
+export { flushTapSync } from "./core/scheduler";
 
 // context
 export { createResourceContext, withContextProvider } from "./core/context";
 
 // hooks
-export { useResource, useResources, useResourceRoot } from "./react/hooks";
+export { useResource } from "./hooks/useResource";
+export { useResources } from "./hooks/useResources";
+export { useTapRoot } from "./hooks/useTapRoot";
+export { useTapHost } from "./hooks/useTapHost";
 
 // types
 export type {

package/src/{hooks → react-hooks}/index.ts

@@ -1,5 +1,5 @@
 export { useState } from "./useState";
-export { useReducer, useReducerWithDerivedState } from "./useReducer";
+export { useReducer } from "./useReducer";
 export { useRef } from "./useRef";
 export { useMemo } from "./useMemo";
 export { useCallback } from "./useCallback";
@@ -7,6 +7,6 @@ export { useEffect } from "./useEffect";
 export { useEffectEvent } from "./useEffectEvent";
 export { use } from "./use";
 export { useMemoCache } from "./useMemoCache";
-export { useResource } from "./useResource";
-export { useResources } from "./useResources";
-export { useResourceRoot } from "./useResourceRoot";
+export { useResource } from "../hooks/useResource";
+export { useResources } from "../hooks/useResources";
+export { useTapRoot } from "../hooks/useTapRoot";

package/src/react-hooks/useEffect.ts

@@ -0,0 +1,58 @@
+import type { Cell } from "../core/types";
+import { depsShallowEqual } from "../hooks/utils/depsShallowEqual";
+import { useCell, registerRenderMountTask } from "../hooks/utils/useCell";
+
+const newEffect = (): Cell & { type: "effect" } => ({
+  type: "effect",
+  cleanup: undefined,
+  deps: null, // null means the effect has never been run
+});
+
+export namespace useEffect {
+  export type Destructor = () => void;
+  export type EffectCallback = () => Destructor | undefined;
+}
+
+export function useEffect(effect: useEffect.EffectCallback): void;
+export function useEffect(
+  effect: useEffect.EffectCallback,
+  deps: readonly unknown[],
+): void;
+export function useEffect(
+  effect: useEffect.EffectCallback,
+  deps?: readonly unknown[],
+): void {
+  const cell = useCell("effect", newEffect);
+
+  if (deps && cell.deps && depsShallowEqual(cell.deps, deps)) return;
+  if (cell.deps !== null && !!deps !== !!cell.deps)
+    throw new Error(
+      "useEffect called with and without dependencies across re-renders",
+    );
+
+  registerRenderMountTask({
+    cleanup: () => {
+      try {
+        cell.cleanup?.();
+      } finally {
+        cell.cleanup = undefined;
+      }
+    },
+    setup: () => {
+      try {
+        const cleanup = effect();
+
+        if (cleanup !== undefined && typeof cleanup !== "function") {
+          throw new Error(
+            "An effect function must either return a cleanup function or nothing. " +
+              `Received: ${typeof cleanup}`,
+          );
+        }
+
+        cell.cleanup = cleanup;
+      } finally {
+        cell.deps = deps;
+      }
+    },
+  });
+}

package/src/{hooks → react-hooks}/useMemo.ts

@@ -1,7 +1,7 @@
 import { isDevelopment } from "../core/helpers/env";
 import { getCurrentResourceFiber } from "../core/helpers/execution-context";
 import { useReducerWithDerivedState } from "./useReducer";
-import { depsShallowEqual } from "./utils/depsShallowEqual";
+import { depsShallowEqual } from "../hooks/utils/depsShallowEqual";
 
 const memoReducer = () => {
   throw new Error("Memo reducer should not be called");

package/src/react-hooks/useReducer.ts

@@ -0,0 +1,254 @@
+import { isDevelopment } from "../core/helpers/env";
+import {
+  getCurrentResourceFiber,
+  peekResourceFiber,
+} from "../core/helpers/execution-context";
+import type { Cell, ChangelogRecord, ResourceFiber } from "../core/types";
+import { applyChangelogRecord, markCellDirty } from "../core/helpers/root";
+
+type Dispatch<A> = (action: A) => void;
+
+const dispatchOnFiber = (
+  fiber: ResourceFiber<any, any>,
+  callback: () => ChangelogRecord | null,
+): void => {
+  if (fiber.isNeverMounted) {
+    throw new Error("Resource updated before mount");
+  }
+
+  fiber.root.dispatchUpdate(() => {
+    const record = callback();
+    if (record) {
+      applyChangelogRecord(record);
+      fiber.root.changelog.push(record);
+      return true;
+    }
+    return false;
+  });
+};
+
+const createReducerCell = (
+  fiber: ResourceFiber<any, any>,
+  reducer: (state: any, action: any) => any,
+  initialArg: any,
+  initFn: ((arg: any) => any) | undefined,
+  eagerDispatch: boolean,
+): Cell & { type: "reducer" } => {
+  const initialState = initFn ? initFn(initialArg) : initialArg;
+
+  if (isDevelopment && fiber.devStrictMode && initFn) {
+    void initFn(initialArg);
+  }
+
+  const cell: Cell & { type: "reducer" } = {
+    type: "reducer",
+    queue: null,
+    renderQueue: null,
+    workInProgress: initialState,
+    current: initialState,
+    reducer,
+    dispatch: (action) => {
+      const currentFiber = peekResourceFiber();
+      if (currentFiber !== null) {
+        if (currentFiber !== fiber)
+          throw new Error(
+            "Cannot update a resource while rendering a different resource.",
+          );
+
+        (fiber.renderPendingCells ??= new Set()).add(cell);
+        (cell.renderQueue ??= []).push(action);
+      } else {
+        const record: ChangelogRecord = {
+          fiber,
+          cell,
+          action,
+          hasEagerState: false,
+          eagerState: undefined,
+          queued: false,
+        };
+
+        dispatchOnFiber(fiber, () => {
+          if (
+            eagerDispatch &&
+            fiber.root.dirtyCells.size === 0 &&
+            !record.hasEagerState
+          ) {
+            record.eagerState = reducer(cell.workInProgress, action);
+            record.hasEagerState = true;
+
+            if (Object.is(cell.current, record.eagerState)) return null;
+          }
+
+          return record;
+        });
+      }
+    },
+  };
+  return cell;
+};
+
+function useReducerImpl<S, A, I, R extends S>(
+  reducer: (state: S, action: A) => S,
+  getDerivedState: ((state: S) => R) | undefined,
+  initialArg: S | I,
+  initFn: ((arg: I) => S) | undefined,
+  eagerDispatch: boolean,
+): [R, Dispatch<A>] {
+  const fiber = getCurrentResourceFiber();
+  const index = fiber.currentIndex++;
+
+  const existing = fiber.cells[index];
+  let cell: Cell & { type: "reducer" };
+  if (existing === undefined) {
+    if (!fiber.isFirstRender && index >= fiber.cells.length) {
+      throw new Error(
+        "Rendered more hooks than during the previous render. " +
+          "Hooks must be called in the exact same order in every render.",
+      );
+    }
+    cell = createReducerCell(fiber, reducer, initialArg, initFn, eagerDispatch);
+    fiber.cells[index] = cell;
+  } else {
+    if (existing.type !== "reducer") {
+      throw new Error("Hook order changed between renders");
+    }
+    cell = existing;
+  }
+
+  const queue = cell.queue;
+  if (queue !== null) {
+    const sameReducer = reducer === cell.reducer;
+
+    // The drain consumes entries: a re-render of the same uncommitted lineage
+    // sees an empty queue and must not re-apply them. Rollback replays them
+    // into the queue via the changelog.
+    for (let i = 0; i < queue.length; i++) {
+      const item = queue[i]!;
+      if (!item.hasEagerState || !sameReducer) {
+        item.eagerState = reducer(cell.workInProgress, item.action);
+        item.hasEagerState = true;
+
+        if (isDevelopment && fiber.devStrictMode) {
+          // React keeps the strict re-invocation's result for render-computed
+          // actions (unlike eager-computed ones, whose ghost is discarded).
+          item.eagerState = reducer(cell.workInProgress, item.action);
+        }
+      } else if (isDevelopment && fiber.devStrictMode) {
+        void reducer(cell.workInProgress, item.action);
+      }
+
+      item.queued = false;
+      cell.workInProgress = item.eagerState;
+    }
+    cell.queue = null;
+  }
+  cell.reducer = reducer;
+
+  if (cell.renderQueue !== null || getDerivedState !== undefined) {
+    let derived = cell.workInProgress;
+    if (cell.renderQueue !== null) {
+      for (const action of cell.renderQueue) {
+        derived = reducer(derived, action);
+      }
+
+      cell.renderQueue = null;
+      fiber.renderPendingCells?.delete(cell);
+    }
+
+    if (getDerivedState) {
+      let changed;
+      let passes = 0;
+      do {
+        if (++passes > 25) {
+          throw new Error(
+            "Too many derivations. getDerivedState must reach a fixpoint; " +
+              "tap limits the number of iterations to prevent an infinite loop.",
+          );
+        }
+        const result = getDerivedState(derived);
+        changed = !Object.is(result, derived);
+        derived = result;
+      } while (changed);
+    }
+
+    if (!Object.is(derived, cell.workInProgress)) {
+      markCellDirty(fiber, cell);
+      cell.workInProgress = derived;
+    }
+  }
+
+  return [cell.workInProgress, cell.dispatch];
+}
+
+export function useReducer<S, A>(
+  reducer: (state: S, action: A) => S,
+  initialState: S,
+): [S, Dispatch<A>];
+export function useReducer<S, A, I>(
+  reducer: (state: S, action: A) => S,
+  initialArg: I,
+  init: (arg: I) => S,
+): [S, Dispatch<A>];
+export function useReducer<S, A, I>(
+  reducer: (state: S, action: A) => S,
+  initialArg: S | I,
+  init?: (arg: I) => S,
+): [S, Dispatch<A>] {
+  return useReducerImpl(
+    reducer,
+    undefined,
+    initialArg as S,
+    init as ((arg: S) => S) | undefined,
+    false,
+  );
+}
+
+/** @internal useState's entry point: eager dispatch, like React's basic state reducer. */
+export function useEagerReducer<S, A>(
+  reducer: (state: S, action: A) => S,
+  initialState: S,
+): [S, Dispatch<A>];
+export function useEagerReducer<S, A, I>(
+  reducer: (state: S, action: A) => S,
+  initialArg: I,
+  init: (arg: I) => S,
+): [S, Dispatch<A>];
+export function useEagerReducer<S, A, I>(
+  reducer: (state: S, action: A) => S,
+  initialArg: S | I,
+  init?: (arg: I) => S,
+): [S, Dispatch<A>] {
+  return useReducerImpl(
+    reducer,
+    undefined,
+    initialArg as S,
+    init as ((arg: S) => S) | undefined,
+    true,
+  );
+}
+
+/**
+ * @internal Backs useMemo and useMemoCache: a reducer cell whose state is
+ * recomputed during render via getDerivedState. Not part of the public API;
+ * user-facing state adjustment during render uses render-phase updates
+ * (setState during render), like React.
+ */
+export function useReducerWithDerivedState<S, A, R extends S>(
+  reducer: (state: S, action: A) => S,
+  getDerivedState: (state: S) => R,
+  initialState: S,
+): [R, Dispatch<A>];
+export function useReducerWithDerivedState<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>];
+export function useReducerWithDerivedState<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>] {
+  return useReducerImpl(reducer, getDerivedState, initialArg, init, true);
+}

package/src/{hooks → react-hooks}/useState.ts

@@ -1,4 +1,4 @@
-import { useReducer } from "./useReducer";
+import { useEagerReducer } from "./useReducer";
 
 export namespace useState {
   export type StateUpdater<S> = S | ((prev: S) => S);
@@ -25,5 +25,5 @@ export function useState<S>(
 export function useState<S>(
   initial?: S | (() => S),
 ): [S | undefined, (updater: useState.StateUpdater<S>) => void] {
-  return useReducer(stateReducer, initial, stateInit);
+  return useEagerReducer(stateReducer, initial, stateInit);
 }

package/src/react-shim/index.ts

@@ -8,9 +8,9 @@
 // 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 * as React from "react";
+import React from "react";
 import { peekResourceFiber } from "../core/helpers/execution-context";
-import * as hooks from "../hooks";
+import * as hooks from "../react-hooks";
 import { useResourceContext, isResourceContext } from "../core/context";
 
 // @ts-expect-error -- @types/react uses `export =`; this is valid at runtime.
@@ -18,47 +18,58 @@ 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) : React.useState(initialState);
+  inTap() ? hooks.useState(initialState) : ReactRuntime.useState(initialState);
 
 export const useReducer = (reducer: any, initialArg: any, init?: any) =>
   inTap()
     ? hooks.useReducer(reducer, initialArg, init)
-    : React.useReducer(reducer, initialArg, init);
+    : ReactRuntime.useReducer(reducer, initialArg, init);
 
 export const useRef = (initialValue?: any) =>
-  inTap() ? hooks.useRef(initialValue) : React.useRef(initialValue);
+  inTap() ? hooks.useRef(initialValue) : ReactRuntime.useRef(initialValue);
 
 export const useMemo = (factory: any, deps: any) =>
-  inTap() ? hooks.useMemo(factory, deps) : React.useMemo(factory, deps);
+  inTap() ? hooks.useMemo(factory, deps) : ReactRuntime.useMemo(factory, deps);
 
 export const useCallback = (callback: any, deps: any) =>
   inTap()
     ? hooks.useCallback(callback, deps)
-    : React.useCallback(callback, deps);
+    : ReactRuntime.useCallback(callback, deps);
 
 export const useEffect = (effect: any, deps?: any) =>
-  inTap() ? hooks.useEffect(effect, deps) : React.useEffect(effect, deps);
+  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) : React.useLayoutEffect(effect, deps);
+  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) : React.useEffectEvent(callback);
+  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.
+// (promises / React context) for everything else. The non-tap fallback requires
+// React 19.
 export const use = (usable: any) =>
-  isResourceContext(usable) ? useResourceContext(usable) : React.use(usable);
+  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)
-    : React.useContext(context);
+    : ReactRuntime.useContext(context);

package/dist/core/createResourceRoot.d.ts

@@ -1,11 +0,0 @@
-import { ResourceElement } from "./types.js";
-import { useResourceRoot } from "../hooks/useResourceRoot.js";
-
-//#region src/core/createResourceRoot.d.ts
-declare const createResourceRoot: () => {
-  render: <R, P>(element: ResourceElement<R, P>) => useResourceRoot.SubscribableResource<R>;
-  unmount: () => void;
-};
-//#endregion
-export { createResourceRoot };
-//# sourceMappingURL=createResourceRoot.d.ts.map

package/dist/core/createResourceRoot.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"createResourceRoot.d.ts","names":[],"sources":["../../src/core/createResourceRoot.ts"],"mappings":";;;;cAea,kBAAA;iBAqBI,OAAA,EAAW,eAAA,CAAgB,CAAA,EAAG,CAAA,MAUjB,eAAA,CAAgB,oBAAA,CAAqB,CAAA"}

package/dist/core/createResourceRoot.js

@@ -1,31 +0,0 @@
-import { resource } from "./resource.js";
-import { isDevelopment } from "./helpers/env.js";
-import { createResourceFiberRoot } from "./helpers/root.js";
-import { commitResourceFiber, createResourceFiber, renderResourceFiber, unmountResourceFiber } from "./ResourceFiber.js";
-import { UpdateScheduler, flushResourcesSync } from "./scheduler.js";
-import { useResourceRoot } from "../hooks/useResourceRoot.js";
-//#region src/core/createResourceRoot.ts
-const SubscribableResource = resource(useResourceRoot);
-const createResourceRoot = () => {
-	const fiber = createResourceFiber(SubscribableResource, createResourceFiberRoot((callback) => {
-		new UpdateScheduler(() => {
-			if (callback()) throw new Error("Unexpected rerender of createResourceRoot outer fiber");
-			return false;
-		}).markDirty();
-	}), void 0, isDevelopment ? "root" : null);
-	return {
-		render: (element) => {
-			if (isDevelopment && fiber.devStrictMode === "root") renderResourceFiber(fiber, element);
-			const render = renderResourceFiber(fiber, element);
-			flushResourcesSync(() => commitResourceFiber(fiber, render));
-			return render.output;
-		},
-		unmount: () => {
-			unmountResourceFiber(fiber);
-		}
-	};
-};
-//#endregion
-export { createResourceRoot };
-
-//# sourceMappingURL=createResourceRoot.js.map

package/dist/core/createResourceRoot.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"createResourceRoot.js","names":[],"sources":["../../src/core/createResourceRoot.ts"],"sourcesContent":["import type { ResourceElement } from \"./types\";\nimport {\n  createResourceFiber,\n  unmountResourceFiber,\n  renderResourceFiber,\n  commitResourceFiber,\n} from \"./ResourceFiber\";\nimport { useResourceRoot } from \"../hooks/useResourceRoot\";\nimport { resource } from \"./resource\";\nimport { isDevelopment } from \"./helpers/env\";\nimport { flushResourcesSync, UpdateScheduler } from \"./scheduler\";\nimport { createResourceFiberRoot } from \"./helpers/root\";\n\nconst SubscribableResource = resource(useResourceRoot);\n\nexport const createResourceRoot = () => {\n  const fiber = createResourceFiber<\n    useResourceRoot.SubscribableResource<any>,\n    ResourceElement<any>\n  >(\n    SubscribableResource,\n    createResourceFiberRoot((callback) => {\n      new UpdateScheduler(() => {\n        if (callback()) {\n          throw new Error(\n            \"Unexpected rerender of createResourceRoot outer fiber\",\n          );\n        }\n        return false;\n      }).markDirty();\n    }),\n    undefined,\n    isDevelopment ? \"root\" : null,\n  );\n\n  return {\n    render: <R, P>(element: ResourceElement<R, P>) => {\n      // In strict mode, render twice to detect side effects\n      if (isDevelopment && fiber.devStrictMode === \"root\") {\n        void renderResourceFiber(fiber, element);\n      }\n\n      const render = renderResourceFiber(fiber, element);\n\n      flushResourcesSync(() => commitResourceFiber(fiber, render));\n\n      return render.output as useResourceRoot.SubscribableResource<R>;\n    },\n    unmount: () => {\n      unmountResourceFiber(fiber);\n    },\n  };\n};\n"],"mappings":";;;;;;;AAaA,MAAM,uBAAuB,SAAS,eAAe;AAErD,MAAa,2BAA2B;CACtC,MAAM,QAAQ,oBAIZ,sBACA,yBAAyB,aAAa;EACpC,IAAI,sBAAsB;GACxB,IAAI,SAAS,GACX,MAAM,IAAI,MACR,uDACF;GAEF,OAAO;EACT,CAAC,CAAC,CAAC,UAAU;CACf,CAAC,GACD,KAAA,GACA,gBAAgB,SAAS,IAC3B;CAEA,OAAO;EACL,SAAe,YAAmC;GAEhD,IAAI,iBAAiB,MAAM,kBAAkB,QAC3C,oBAAyB,OAAO,OAAO;GAGzC,MAAM,SAAS,oBAAoB,OAAO,OAAO;GAEjD,yBAAyB,oBAAoB,OAAO,MAAM,CAAC;GAE3D,OAAO,OAAO;EAChB;EACA,eAAe;GACb,qBAAqB,KAAK;EAC5B;CACF;AACF"}

package/dist/core/helpers/callResourceFn.d.ts

@@ -1 +0,0 @@
-export { };