@assistant-ui/tap 0.6.1 → 0.7.1

package/src/core/createResourceRoot.ts

@@ -1,53 +0,0 @@
-import type { ResourceElement } from "./types";
-import {
-  createResourceFiber,
-  unmountResourceFiber,
-  renderResourceFiber,
-  commitResourceFiber,
-} from "./ResourceFiber";
-import { useResourceRoot } from "../hooks/useResourceRoot";
-import { resource } from "./resource";
-import { isDevelopment } from "./helpers/env";
-import { flushResourcesSync, UpdateScheduler } from "./scheduler";
-import { createResourceFiberRoot } from "./helpers/root";
-
-const SubscribableResource = resource(useResourceRoot);
-
-export const createResourceRoot = () => {
-  const fiber = createResourceFiber<
-    useResourceRoot.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 as useResourceRoot.SubscribableResource<R>;
-    },
-    unmount: () => {
-      unmountResourceFiber(fiber);
-    },
-  };
-};

package/src/core/helpers/callResourceFn.ts

@@ -1,21 +0,0 @@
-import type { Resource } from "../types";
-
-/**
- * Renders a resource with the given props.
- * @internal This is for internal use only.
- */
-export function callResourceFn<R, P>(resource: Resource<R, P>, props: P): R {
-  const fn = (resource as unknown as { [fnSymbol]?: (props: P) => R })[
-    fnSymbol
-  ];
-  if (!fn) {
-    throw new Error("ResourceElement.type is not a valid Resource");
-  }
-  return fn(props);
-}
-
-/**
- * Symbol used to store the ResourceFn in the Resource constructor.
- * @internal This is for internal use only.
- */
-export const fnSymbol = Symbol("fnSymbol");

package/src/hooks/useEffect.ts

@@ -1,72 +0,0 @@
-import type { Cell } from "../core/types";
-import { depsShallowEqual } from "./utils/depsShallowEqual";
-import { useCell, registerRenderMountTask } from "./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(() => {
-    const errors: unknown[] = [];
-
-    try {
-      cell.cleanup?.();
-    } catch (error) {
-      errors.push(error);
-    } finally {
-      cell.cleanup = undefined;
-    }
-
-    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;
-    } catch (error) {
-      errors.push(error);
-    }
-
-    cell.deps = deps;
-
-    if (errors.length > 0) {
-      if (errors.length === 1) {
-        throw errors[0];
-      } else {
-        for (const error of errors) {
-          console.error(error);
-        }
-        throw new AggregateError(errors, "Errors during commit");
-      }
-    }
-  });
-}

package/src/hooks/useReducer.ts

@@ -1,160 +0,0 @@
-import { isDevelopment } from "../core/helpers/env";
-import { getCurrentResourceFiber } from "../core/helpers/execution-context";
-import type { ReducerQueueEntry, ResourceFiber } from "../core/types";
-import { markCellDirty } from "../core/helpers/root";
-import { useCell } from "./utils/useCell";
-
-type Dispatch<A> = (action: A) => void;
-
-const dispatchOnFiber = (
-  fiber: ResourceFiber<any, any>,
-  callback: () => (() => void) | null,
-): void => {
-  if (fiber.renderContext) {
-    throw new Error("Resource updated during render");
-  }
-  if (fiber.isNeverMounted) {
-    throw new Error("Resource updated before mount");
-  }
-
-  fiber.root.dispatchUpdate(() => {
-    const result = callback();
-    if (result) {
-      result();
-      fiber.root.changelog.push(result);
-      return true;
-    }
-    return false;
-  });
-};
-
-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,
-): [R, Dispatch<A>] {
-  const cell = useCell("reducer", () => {
-    const fiber = getCurrentResourceFiber();
-
-    // First render: compute initial state
-    const initialState = initFn ? initFn(initialArg as I) : initialArg;
-
-    if (isDevelopment && fiber.devStrictMode && initFn) {
-      void initFn(initialArg as I);
-    }
-
-    return {
-      type: "reducer",
-      queue: new Set(),
-      dirty: false,
-      workInProgress: initialState,
-      current: initialState,
-      reducer,
-      dispatch: (action: A) => {
-        const entry: ReducerQueueEntry = {
-          action,
-          hasEagerState: false,
-          eagerState: undefined,
-        };
-
-        dispatchOnFiber(fiber, () => {
-          if (fiber.root.dirtyCells.length === 0 && !entry.hasEagerState) {
-            entry.eagerState = reducer(cell.workInProgress, action);
-            entry.hasEagerState = true;
-
-            if (Object.is(cell.current, entry.eagerState)) return null;
-          }
-
-          return () => {
-            markCellDirty(fiber, cell);
-            cell.queue.add(entry);
-          };
-        });
-      },
-    };
-  });
-
-  const fiber = getCurrentResourceFiber();
-  const sameReducer = reducer === cell.reducer;
-  cell.reducer = reducer;
-
-  for (const item of cell.queue) {
-    if (!item.hasEagerState || !sameReducer) {
-      item.eagerState = reducer(cell.workInProgress, item.action);
-      item.hasEagerState = true;
-    }
-
-    if (isDevelopment && fiber.devStrictMode) {
-      void reducer(cell.workInProgress, item.action);
-    }
-
-    cell.workInProgress = item.eagerState;
-  }
-  cell.queue.clear();
-
-  if (getDerivedState) {
-    const derived = getDerivedState(cell.workInProgress);
-
-    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,
-  );
-}
-
-/**
- * @deprecated experimental — a `getDerivedStateFromProps` replacement for
- * resources: adjust state in response to props without setting during render.
- * Tap-only for now (call it inside a resource render, not a React component) and
- * may change before stabilizing.
- */
-export function useReducerWithDerivedState<S, A, R extends S>(
-  reducer: (state: S, action: A) => S,
-  getDerivedState: (state: S) => R,
-  initialState: S,
-): [R, Dispatch<A>];
-/**
- * @deprecated experimental — a `getDerivedStateFromProps` replacement for
- * resources: adjust state in response to props without setting during render.
- * Tap-only for now (call it inside a resource render, not a React component) and
- * may change before stabilizing.
- */
-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);
-}

package/src/hooks/useResourceRoot.ts

@@ -1,130 +0,0 @@
-import {
-  commitResourceFiber,
-  createResourceFiber,
-  renderResourceFiber,
-  unmountResourceFiber,
-} 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";
-
-export namespace useResourceRoot {
-  export type Unsubscribe = () => void;
-
-  export interface SubscribableResource<TState> {
-    /**
-     * Get the current state of the store.
-     */
-    getValue(): TState;
-
-    /**
-     * Subscribe to the store.
-     */
-    subscribe(listener: () => void): Unsubscribe;
-  }
-}
-
-// The root is never reset, because rollbacks are not supported in useResourceRoot.
-
-export const useResourceRoot = <TState>(
-  element: ResourceElement<TState>,
-): useResourceRoot.SubscribableResource<TState> => {
-  const scheduler = useMemo(
-    () => new UpdateScheduler(() => handleUpdate(null)),
-    [],
-  );
-  const queue = useMemo(() => [] as (() => void)[], []);
-
-  const fiber = useMemo(() => {
-    void element.key;
-
-    return createResourceFiber(
-      element.type,
-      createResourceFiberRoot((callback) => {
-        if (!scheduler.isDirty && !callback()) return;
-        queue.push(callback);
-        scheduler.markDirty();
-      }),
-    );
-  }, [element.type, element.key, queue, scheduler]);
-
-  setRootVersion(fiber.root, fiber.root.committedVersion);
-  const render = renderResourceFiber(fiber, element.props);
-
-  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);
-
-      queue.forEach((callback) => {
-        if (isDevelopment && fiber.devStrictMode) {
-          callback();
-        }
-
-        callback();
-      });
-
-      if (isDevelopment && fiber.devStrictMode) {
-        void renderResourceFiber(fiber, committedPropsRef.current);
-      }
-
-      render = renderResourceFiber(fiber, committedPropsRef.current);
-    }
-
-    if (scheduler.isDirty)
-      throw new Error("Scheduler is dirty, this should never happen");
-
-    commitRoot(fiber.root);
-    queue.length = 0;
-
-    if (isMountedRef.current) {
-      commitResourceFiber(fiber, render);
-    }
-
-    if (scheduler.isDirty || valueRef.current === render.output) return;
-    valueRef.current = render.output;
-    subscribers.forEach((callback) => callback());
-  });
-
-  useEffect(() => {
-    isMountedRef.current = true;
-    return () => {
-      isMountedRef.current = false;
-      unmountResourceFiber(fiber);
-    };
-  }, [fiber]);
-
-  useEffect(() => {
-    committedPropsRef.current = render.props;
-    commitRoot(fiber.root);
-    commitResourceFiber(fiber, render);
-
-    if (scheduler.isDirty || valueRef.current === render.output) return;
-    valueRef.current = render.output;
-    subscribers.forEach((callback) => callback());
-  });
-
-  return useMemo(
-    () => ({
-      getValue: () => valueRef.current,
-      subscribe: (listener: () => void) => {
-        subscribers.add(listener);
-        return () => subscribers.delete(listener);
-      },
-    }),
-    [subscribers],
-  );
-};

package/src/react/hooks.ts

@@ -1,112 +0,0 @@
-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,
-);