bippy 0.7.3-dev.049a43d → 0.7.3-dev.0c7e504

package/src/react.ts

@@ -1,77 +1,152 @@
 import "./install-hook-only.js";
-import * as React from "react";
-import { isFiber } from "./core.js";
+import React from "react";
+import { isFiber, traverseFiber } from "./core.js";
+import { _renderers } from "./rdt-hook.js";
 import type { Fiber } from "./react-internals/index.js";
 
 export type { Fiber } from "./react-internals/index.js";
 
-const preserveState = (state: undefined): undefined => state;
-const readEmptySnapshot = (): undefined => undefined;
-const unsubscribeFromEmptyStore = (): void => {};
-const subscribeToEmptyStore = (): (() => void) => unsubscribeFromEmptyStore;
-const useSyncExternalStore: unknown = Reflect.get(React, "useSyncExternalStore");
+interface RenderMarker {
+  (state: undefined): undefined;
+}
 
-const captureFiberFromHook = (useCaptureHook: () => void): Fiber | null => {
-  const originalBind = Function.prototype.bind;
-  let capturedFiber: Fiber | null = null;
-  // HACK: React binds hook callbacks to the rendering Fiber in production but exposes no public API for it.
+interface ReducerQueue {
+  lastRenderedReducer: unknown;
+}
+
+interface FiberCapture {
+  fiber: Fiber;
+  queue: ReducerQueue | null;
+}
+
+const isReducerQueue = (value: unknown): value is ReducerQueue =>
+  typeof value === "object" && value !== null && "lastRenderedReducer" in value;
+
+const hasRenderMarker = (fiber: Fiber, renderMarker: RenderMarker): boolean => {
+  for (let hook = fiber.memoizedState; hook; hook = hook.next) {
+    if (Array.isArray(hook.memoizedState) && hook.memoizedState[0] === renderMarker) return true;
+  }
+  return false;
+};
+
+const getReducerQueue = (fiber: Fiber, renderMarker: RenderMarker): ReducerQueue | null => {
+  for (let hook = fiber.memoizedState; hook; hook = hook.next) {
+    if (isReducerQueue(hook.queue) && hook.queue.lastRenderedReducer === renderMarker)
+      return hook.queue;
+  }
+  return null;
+};
+
+const getDevToolsFiber = (renderMarker: RenderMarker): Fiber | null => {
+  for (const renderer of _renderers) {
+    try {
+      const fiber = renderer.getCurrentFiber?.();
+      if (fiber && isFiber(fiber) && hasRenderMarker(fiber, renderMarker)) return fiber;
+    } catch {}
+  }
+  return null;
+};
+
+const captureReducerFiber = (
+  renderMarker: RenderMarker,
+  shouldCapture: boolean,
+): FiberCapture | null => {
+  let originalBind: typeof Function.prototype.bind | undefined;
+  if (shouldCapture) {
+    try {
+      originalBind = Function.prototype.bind;
+    } catch {}
+  }
+  if (!originalBind) {
+    React.useReducer(renderMarker, undefined);
+    return null;
+  }
+
+  let capture: FiberCapture | null = null;
+  let isCapturing = true;
+  // HACK: Production React binds a new reducer's Fiber and queue; validate the private reducer marker, not argument positions.
   const bindProxy = new Proxy(originalBind, {
-    apply: (bind, functionToBind, boundArguments) => {
-      const fiber = boundArguments[1];
-      if (!capturedFiber && isFiber(fiber)) {
-        capturedFiber = fiber;
+    apply: (bind, callback, boundArguments) => {
+      if (isCapturing && !capture) {
+        try {
+          const queue = boundArguments.find(
+            (argument): argument is ReducerQueue =>
+              isReducerQueue(argument) && argument.lastRenderedReducer === renderMarker,
+          );
+          if (queue) {
+            const fiber = boundArguments.find(
+              (argument): argument is Fiber => isFiber(argument) && isFiber(argument.return),
+            );
+            if (fiber) capture = { fiber, queue };
+          }
+        } catch {}
       }
-      return Reflect.apply(bind, functionToBind, boundArguments);
+      return Reflect.apply(bind, callback, boundArguments);
     },
   });
-  Reflect.set(Function.prototype, "bind", bindProxy);
 
   try {
-    useCaptureHook();
+    try {
+      Reflect.set(Function.prototype, "bind", bindProxy);
+    } catch {}
+    React.useReducer(renderMarker, undefined);
+    return capture;
   } finally {
-    if (Function.prototype.bind === bindProxy) {
-      Reflect.set(Function.prototype, "bind", originalBind);
-    }
+    isCapturing = false;
+    capture = null;
+    try {
+      if (Function.prototype.bind === bindProxy) {
+        Reflect.set(Function.prototype, "bind", originalBind);
+      }
+    } catch {}
   }
-
-  return capturedFiber;
 };
 
-const useExternalStoreCapture = (): void => {
-  if (typeof useSyncExternalStore !== "function") return;
-  Reflect.apply(useSyncExternalStore, React, [
-    subscribeToEmptyStore,
-    readEmptySnapshot,
-    readEmptySnapshot,
-  ]);
-};
-
-const useReducerCapture = (): void => {
-  React.useReducer(preserveState, undefined);
+// HACK: React <16.13 attaches hooks after render; the shared reducer queue validates the root-walk fallback.
+const getRenderingFiberFromRoot = (
+  { fiber, queue }: FiberCapture,
+  renderMarker: RenderMarker,
+): Fiber | null => {
+  if (queue?.lastRenderedReducer !== renderMarker) return null;
+  let rootFiber = fiber;
+  while (rootFiber.return) rootFiber = rootFiber.return;
+  const root = rootFiber.stateNode;
+  if (typeof root !== "object" || root === null || !("current" in root) || !isFiber(root.current)) {
+    return null;
+  }
+  const renderingRoot = root.current.alternate;
+  return traverseFiber(renderingRoot, (candidate) => {
+    if (candidate !== fiber && candidate !== fiber.alternate) return false;
+    let parent = candidate;
+    while (parent.return) parent = parent.return;
+    return parent === renderingRoot;
+  });
 };
 
-const useFiberWithExternalStore = (): Fiber | undefined =>
-  captureFiberFromHook(useExternalStoreCapture) ?? undefined;
-
-const useFiberWithReducer = (): Fiber | undefined => {
-  const committedFiberRef = React.useRef<Fiber | null>(null);
-  const renderedFiberRef = React.useRef<Fiber | null>(null);
-  const hookFiber = captureFiberFromHook(useReducerCapture);
+export const useFiber = (): Fiber | undefined => {
+  "use no memo";
+  const fiberRef = React.useRef<FiberCapture | null>(null);
+  const renderMarker: RenderMarker = (state) => state;
+  React.useMemo(() => renderMarker, [renderMarker]);
+  const devToolsFiber = fiberRef.current ? null : getDevToolsFiber(renderMarker);
+  const capture = captureReducerFiber(renderMarker, !fiberRef.current && !devToolsFiber);
+  if (devToolsFiber) {
+    fiberRef.current = {
+      fiber: devToolsFiber,
+      queue: getReducerQueue(devToolsFiber, renderMarker),
+    };
+    return devToolsFiber;
+  }
+  const knownCapture = capture ?? fiberRef.current;
+  if (!knownCapture) return undefined;
+  const knownFiber = knownCapture.fiber;
   const fiber =
-    hookFiber ??
-    (renderedFiberRef.current !== committedFiberRef.current
-      ? renderedFiberRef.current
-      : committedFiberRef.current?.alternate) ??
-    committedFiberRef.current;
-
-  renderedFiberRef.current = fiber;
-
-  React.useEffect(() => {
-    committedFiberRef.current = fiber;
-  }, [fiber]);
-
+    capture?.fiber ??
+    (hasRenderMarker(knownFiber, renderMarker)
+      ? knownFiber
+      : knownFiber.alternate && hasRenderMarker(knownFiber.alternate, renderMarker)
+        ? knownFiber.alternate
+        : getRenderingFiberFromRoot(knownCapture, renderMarker));
+  if (fiber) fiberRef.current = { fiber, queue: knownCapture.queue };
   return fiber ?? undefined;
 };
-
-export const useFiber =
-  typeof useSyncExternalStore === "function" ? useFiberWithExternalStore : useFiberWithReducer;

package/src/source/inspect-hooks.ts

@@ -87,6 +87,16 @@ let currentHook: MemoizedState | null = null;
 let currentContextDependency: ContextDependency<unknown> | null = null;
 let currentThenableIndex = 0;
 let currentThenableState: unknown[] | null = null;
+let currentMemoCacheIndex = 0;
+let isInspectingHooks = false;
+
+const assertNotInspectingHooks = (): void => {
+  if (isInspectingHooks) {
+    throw new BippyHookInspectionError(
+      "Hook inspection cannot be called during another inspection.",
+    );
+  }
+};
 
 const SuspenseException: unknown = new Error(
   "Suspense interrupted this render. This error is an internal implementation detail of `use`.",
@@ -323,16 +333,8 @@ const dispatcherUseMemoCache = (size: number): unknown[] => {
   const memoCache = fiber.updateQueue?.memoCache;
   if (memoCache === null || memoCache === undefined) return [];
 
-  let memoCacheSlots = memoCache.data[memoCache.index];
-  if (memoCacheSlots === undefined) {
-    memoCacheSlots = memoCache.data[memoCache.index] = Array.from(
-      { length: size },
-      () => REACT_MEMO_CACHE_SENTINEL,
-    );
-  }
-
-  memoCache.index++;
-  return memoCacheSlots;
+  const memoCacheSlots = memoCache.data[currentMemoCacheIndex++];
+  return memoCacheSlots?.slice() ?? Array.from({ length: size }, () => REACT_MEMO_CACHE_SENTINEL);
 };
 
 const dispatcherUseOptimistic = (passthrough: unknown): [unknown, () => void] => {
@@ -834,6 +836,7 @@ const performDispatcherInspection = <TArgs extends unknown[]>(
 ): HooksTree => {
   const previousDispatcher = readDispatcher(dispatcherRef);
   writeDispatcher(dispatcherRef, dispatcherProxy);
+  isInspectingHooks = true;
 
   let capturedHookLog: HookLogEntry[] = [];
   let ancestorStackError: Error | undefined;
@@ -846,6 +849,7 @@ const performDispatcherInspection = <TArgs extends unknown[]>(
   } finally {
     capturedHookLog = hookLog;
     hookLog = [];
+    isInspectingHooks = false;
     writeDispatcher(dispatcherRef, previousDispatcher);
   }
 
@@ -938,6 +942,7 @@ export const inspectHooks = (
   props: Record<string, unknown>,
   target: ReactDevToolsTarget = globalThis,
 ): HooksTree => {
+  assertNotInspectingHooks();
   const dispatcherRef = requireDispatcherRef(undefined, target);
   getPrimitiveStackCache();
   currentHook = null;
@@ -961,6 +966,7 @@ export const inspectHooks = (
 };
 
 export const getFiberHooks = (fiber: Fiber): HooksTree => {
+  assertNotInspectingHooks();
   const dispatcherRef = requireDispatcherRef(fiber);
   const workTags = getReactWorkTagsForFiber(fiber);
 
@@ -976,6 +982,7 @@ export const getFiberHooks = (fiber: Fiber): HooksTree => {
 
   currentHook = fiber.memoizedState;
   currentFiber = fiber;
+  currentMemoCacheIndex = 0;
 
   const debugThenableState = fiber.dependencies?._debugThenableState;
   const usedThenables = Array.isArray(debugThenableState)
@@ -984,18 +991,16 @@ export const getFiberHooks = (fiber: Fiber): HooksTree => {
   currentThenableState = Array.isArray(usedThenables) ? usedThenables : null;
   currentThenableIndex = 0;
 
-  resolveContextDependency(fiber);
-
-  const type = fiber.type;
-  let props = fiber.memoizedProps;
-  if (type !== fiber.elementType) {
-    props = resolveDefaultProps(type, props);
-  }
-
   const originalConsoleMethods = suppressConsole();
   const contextMap = new Map<ReactContext<unknown>, unknown>();
 
   try {
+    resolveContextDependency(fiber);
+    const type = fiber.type;
+    const props =
+      type !== fiber.elementType
+        ? resolveDefaultProps(type, fiber.memoizedProps)
+        : fiber.memoizedProps;
     if (
       currentContextDependency !== null &&
       !Object.hasOwn(currentContextDependency, "memoizedValue")
@@ -1030,6 +1035,7 @@ export const getFiberHooks = (fiber: Fiber): HooksTree => {
     currentContextDependency = null;
     currentThenableState = null;
     currentThenableIndex = 0;
+    currentMemoCacheIndex = 0;
     restoreContexts(contextMap);
     restoreConsole(originalConsoleMethods);
   }