bippy 0.7.3-dev.e2b879b → 0.7.3-dev.e6929e3

package/src/react.ts

@@ -1,98 +1,162 @@
 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 { getCurrentFiberFromRoot } from "./react-internals/current-fiber.js";
 import type { Fiber } from "./react-internals/index.js";
 
 export type { Fiber } from "./react-internals/index.js";
 
-interface FiberHookEffect {
-  create: unknown;
-  next: unknown;
+interface RenderMarker {
+  (state: undefined): undefined;
 }
 
-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 ReducerQueue {
+  lastRenderedReducer: unknown;
+}
 
-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.
-  const bindProxy = new Proxy(originalBind, {
-    apply: (bind, functionToBind, boundArguments) => {
-      const fiber = boundArguments[1];
-      if (!capturedFiber && isFiber(fiber)) {
-        capturedFiber = fiber;
-      }
-      return Reflect.apply(bind, functionToBind, boundArguments);
-    },
-  });
-  Reflect.set(Function.prototype, "bind", bindProxy);
+interface FiberCapture {
+  fiber: Fiber;
+  queue: ReducerQueue | null;
+}
 
-  try {
-    useCaptureHook();
-  } finally {
-    if (Function.prototype.bind === bindProxy) {
-      Reflect.set(Function.prototype, "bind", originalBind);
-    }
-  }
+const isReducerQueue = (value: unknown): value is ReducerQueue =>
+  typeof value === "object" && value !== null && "lastRenderedReducer" in value;
 
-  return capturedFiber;
+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 useExternalStoreCapture = (): void => {
-  if (typeof useSyncExternalStore !== "function") return;
-  Reflect.apply(useSyncExternalStore, React, [
-    subscribeToEmptyStore,
-    readEmptySnapshot,
-    readEmptySnapshot,
-  ]);
+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 useReducerCapture = (): void => {
-  React.useReducer(preserveState, undefined);
+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 useFiberWithExternalStore = (): Fiber | undefined =>
-  captureFiberFromHook(useExternalStoreCapture) ?? undefined;
+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;
+  }
 
-const isHookEffect = (value: unknown): value is FiberHookEffect =>
-  typeof value === "object" && value !== null && "create" in value && "next" in value;
+  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, 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, callback, boundArguments);
+    },
+  });
 
-const hasRenderMarker = (fiber: Fiber, renderMarker: () => void): boolean => {
-  const lastEffect = fiber.updateQueue?.lastEffect;
-  if (!isHookEffect(lastEffect)) return false;
-  let effect = lastEffect;
-  do {
-    if (effect.create === renderMarker) return true;
-    if (!isHookEffect(effect.next)) return false;
-    effect = effect.next;
-  } while (effect !== lastEffect);
-  return false;
+  try {
+    try {
+      Reflect.set(Function.prototype, "bind", bindProxy);
+    } catch {}
+    React.useReducer(renderMarker, undefined);
+    return capture;
+  } finally {
+    isCapturing = false;
+    capture = null;
+    try {
+      if (Function.prototype.bind === bindProxy) {
+        Reflect.set(Function.prototype, "bind", originalBind);
+      }
+    } catch {}
+  }
 };
 
-// HACK: React 17 only binds the rendering Fiber on mount. Later renders are identified through
-// the effect list instead: renderWithHooks clears `updateQueue` on the work-in-progress Fiber,
-// so only the Fiber that is rendering right now holds this render's marker effect.
-const useFiberWithReducer = (): Fiber | undefined => {
-  const fiberRef = React.useRef<Fiber | null>(null);
-  const renderMarker = (): void => {};
-  React.useEffect(renderMarker, []);
-  const mountedFiber = captureFiberFromHook(useReducerCapture);
-  if (mountedFiber) {
-    fiberRef.current = mountedFiber;
-    return mountedFiber;
+// 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 knownFiber = fiberRef.current;
-  if (!knownFiber) return undefined;
-  return (
-    [knownFiber, knownFiber.alternate].find(
-      (candidate) => candidate !== null && hasRenderMarker(candidate, renderMarker),
-    ) ?? undefined
-  );
+  const renderingRoot = root.current.alternate;
+  const renderingFiber = getCurrentFiberFromRoot(fiber)?.alternate;
+  if (renderingFiber) {
+    let ancestor = renderingFiber;
+    while (ancestor.return) ancestor = ancestor.return;
+    if (ancestor === renderingRoot) return renderingFiber;
+  }
+  return traverseFiber(renderingRoot, (candidate) => {
+    if (candidate !== fiber && candidate !== fiber.alternate) return false;
+    let parent = candidate;
+    while (parent.return) parent = parent.return;
+    return parent === renderingRoot;
+  });
 };
 
-export const useFiber =
-  typeof useSyncExternalStore === "function" ? useFiberWithExternalStore : useFiberWithReducer;
+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 =
+    capture?.fiber ??
+    (hasRenderMarker(knownFiber, renderMarker)
+      ? knownFiber
+      : knownFiber.alternate && hasRenderMarker(knownFiber.alternate, renderMarker)
+        ? knownFiber.alternate
+        : getRenderingFiberFromRoot(knownCapture, renderMarker));
+  if (fiber) {
+    knownCapture.fiber = fiber;
+    fiberRef.current = knownCapture;
+  }
+  return fiber ?? undefined;
+};

package/src/source/inspect-hooks.ts

@@ -14,7 +14,7 @@ import {
   BippyUnsupportedHookError,
 } from "../errors.js";
 import { getReactWorkTagsForFiber } from "../react-internals/index.js";
-import { parseStack, type StackFrame } from "./parse-stack.js";
+import { createStackParser, parseStack, type StackFrame } from "./parse-stack.js";
 import {
   getRendererDispatcherRefs,
   readDispatcher,
@@ -604,8 +604,9 @@ const findPrimitiveIndex = (hookStack: StackFrame[], hook: HookLogEntry): number
 const parseTrimmedStack = (
   rootStack: StackFrame[],
   hook: HookLogEntry,
+  parseHookStack: (stack: string) => StackFrame[],
 ): [StackFrame | null, StackFrame[] | null] => {
-  const hookStack = parseErrorStack(hook.stackError);
+  const hookStack = parseHookStack(hook.stackError.stack || "");
   const rootIndex = findCommonAncestorIndex(rootStack, hookStack);
   const primitiveIndex = findPrimitiveIndex(hookStack, hook);
   if (rootIndex === -1 || primitiveIndex === -1 || rootIndex - primitiveIndex < 2) {
@@ -626,13 +627,14 @@ const NON_ID_HOOK_PRIMITIVES = new Set([
 
 const buildTree = (rootStack: StackFrame[], capturedHookLog: HookLogEntry[]): HooksTree => {
   const rootChildren: HooksNode[] = [];
+  const parseHookStack = createStackParser();
   let previousStack: StackFrame[] | null = null;
   let levelChildren = rootChildren;
   let nativeHookID = 0;
   const childrenStack: HooksNode[][] = [];
 
   for (const hook of capturedHookLog) {
-    const [primitiveFrame, stack] = parseTrimmedStack(rootStack, hook);
+    const [primitiveFrame, stack] = parseTrimmedStack(rootStack, hook, parseHookStack);
     let displayName = hook.displayName;
     if (displayName === null && primitiveFrame !== null) {
       const primitiveName = parseHookName(primitiveFrame.functionName);

package/src/source/parse-stack.ts

@@ -28,16 +28,14 @@ export const parseStack = (stackString: string, options?: ParseOptions): StackFr
     const frames: StackFrame[] = [];
     for (const rawLine of lines) {
       if (/^\s*at\s+/.test(rawLine)) {
-        const parsed = parseV8OrIeString(rawLine)[0];
-        if (parsed) frames.push(parsed);
+        if (CHROME_IE_STACK_REGEXP.test(rawLine)) frames.push(parseV8Line(rawLine));
       } else if (/^\s*in\s+/.test(rawLine)) {
         const elementName = rawLine
           .replace(/^\s*in\s+/, "")
           .replace(/\s*(?:\(at .*\)|\[[^\]]+\])$/, "");
         frames.push({ functionName: elementName, source: rawLine });
       } else if (rawLine.match(FIREFOX_SAFARI_STACK_REGEXP)) {
-        const parsed = parseFFOrSafariString(rawLine)[0];
-        if (parsed) frames.push(parsed);
+        if (!SAFARI_NATIVE_CODE_REGEXP.test(rawLine)) frames.push(parseSafariLine(rawLine));
       }
     }
     return frames;
@@ -48,6 +46,18 @@ export const parseStack = (stackString: string, options?: ParseOptions): StackFr
   return parseFFOrSafariString(stackString);
 };
 
+const getPositionIndex = (location: string, endIndex: number): number => {
+  let positionIndex = endIndex - 1;
+  while (positionIndex >= 0) {
+    const character = location.charCodeAt(positionIndex);
+    if (character < 48 || character > 57) break;
+    positionIndex--;
+  }
+  return positionIndex < endIndex - 1 && location.charCodeAt(positionIndex) === 58
+    ? positionIndex
+    : -1;
+};
+
 export const extractLocation = (
   urlLike: string,
 ): [string, string | undefined, string | undefined] => {
@@ -59,77 +69,115 @@ export const extractLocation = (
   const isWrappedLocation = urlLike.startsWith("(") && /:\d+\)$/.test(urlLike);
   const sanitizedResult = isWrappedLocation ? urlLike.slice(1, -1) : urlLike;
 
-  const regExp = /(.+?)(?::(\d+))?(?::(\d+))?$/;
-  const parts = regExp.exec(sanitizedResult);
-  if (!parts) return [sanitizedResult, undefined, undefined];
-  return [parts[1], parts[2] || undefined, parts[3] || undefined] as const;
-};
+  if (/[\n\r\u2028\u2029]/.test(sanitizedResult)) {
+    const parts = /(.+?)(?::(\d+))?(?::(\d+))?$/.exec(sanitizedResult);
+    return parts
+      ? [parts[1], parts[2] || undefined, parts[3] || undefined]
+      : [sanitizedResult, undefined, undefined];
+  }
 
-export const parseV8OrIeString = (stack: string): StackFrame[] => {
-  const filteredLines = stack.split("\n").filter((line) => {
-    return !!line.match(CHROME_IE_STACK_REGEXP);
-  });
-
-  return filteredLines.map((line): StackFrame => {
-    let currentLine = line;
-    if (currentLine.includes("(eval ")) {
-      currentLine = currentLine
-        .replace(/eval code/g, "eval")
-        .replace(/(\(eval at [^()]*)|(,.*$)/g, "");
-    }
-    let sanitizedLine = currentLine
-      .replace(/^\s+/, "")
-      .replace(/\(eval code/g, "(")
-      .replace(/^.*?\s+/, "");
+  const lastPositionIndex = getPositionIndex(sanitizedResult, sanitizedResult.length);
+  if (lastPositionIndex <= 0) return [sanitizedResult, undefined, undefined];
+  const previousPositionIndex = getPositionIndex(sanitizedResult, lastPositionIndex);
+  if (previousPositionIndex <= 0) {
+    return [
+      sanitizedResult.slice(0, lastPositionIndex),
+      sanitizedResult.slice(lastPositionIndex + 1),
+      undefined,
+    ];
+  }
+  return [
+    sanitizedResult.slice(0, previousPositionIndex),
+    sanitizedResult.slice(previousPositionIndex + 1, lastPositionIndex),
+    sanitizedResult.slice(lastPositionIndex + 1),
+  ];
+};
 
-    const locationMatch = sanitizedLine.match(/ (\(.+\)$)/);
+const parseV8Line = (line: string): StackFrame => {
+  let currentLine = line;
+  if (currentLine.includes("(eval ")) {
+    currentLine = currentLine
+      .replace(/eval code/g, "eval")
+      .replace(/(\(eval at [^()]*)|(,.*$)/g, "");
+  }
+  let sanitizedLine = currentLine
+    .replace(/^\s+/, "")
+    .replace(/\(eval code/g, "(")
+    .replace(/^.*?\s+/, "");
+
+  const locationMatch = sanitizedLine.match(/ (\(.+\)$)/);
+
+  sanitizedLine = locationMatch ? sanitizedLine.replace(locationMatch[0], "") : sanitizedLine;
+
+  const locationParts = extractLocation(locationMatch ? locationMatch[1] : sanitizedLine);
+  const functionName = (locationMatch && sanitizedLine) || undefined;
+  const fileName = ["eval", "<anonymous>", "(native)"].includes(locationParts[0])
+    ? undefined
+    : locationParts[0];
+
+  return {
+    functionName,
+    fileName,
+    lineNumber: locationParts[1] ? +locationParts[1] : undefined,
+    columnNumber: locationParts[2] ? +locationParts[2] : undefined,
+    source: currentLine,
+  };
+};
 
-    sanitizedLine = locationMatch ? sanitizedLine.replace(locationMatch[0], "") : sanitizedLine;
+const parseSafariLine = (line: string): StackFrame => {
+  let currentLine = line;
+  if (currentLine.includes(" > eval"))
+    currentLine = currentLine.replace(/ line (\d+)(?: > eval line \d+)* > eval:\d+:\d+/g, ":$1");
 
-    const locationParts = extractLocation(locationMatch ? locationMatch[1] : sanitizedLine);
-    const functionName = (locationMatch && sanitizedLine) || undefined;
-    const fileName = ["eval", "<anonymous>", "(native)"].includes(locationParts[0])
-      ? undefined
-      : locationParts[0];
+  if (!currentLine.includes("@") && !currentLine.includes(":")) {
+    return {
+      functionName: currentLine,
+    };
+  } else {
+    const functionNameRegex =
+      /(([^\n\r"\u2028\u2029]*".[^\n\r"\u2028\u2029]*"[^\n\r@\u2028\u2029]*(?:@[^\n\r"\u2028\u2029]*"[^\n\r@\u2028\u2029]*)*(?:[\n\r\u2028\u2029][^@]*)?)?[^@]*)@/;
+    const matches = currentLine.match(functionNameRegex);
+    const functionName = matches && matches[1] ? matches[1] : undefined;
+    const locationParts = extractLocation(currentLine.replace(functionNameRegex, ""));
 
     return {
       functionName,
-      fileName,
+      fileName: locationParts[0],
       lineNumber: locationParts[1] ? +locationParts[1] : undefined,
       columnNumber: locationParts[2] ? +locationParts[2] : undefined,
       source: currentLine,
     };
-  });
+  }
 };
 
-export const parseFFOrSafariString = (stack: string): StackFrame[] => {
-  const filteredLines = stack.split("\n").filter((line) => {
-    return !line.match(SAFARI_NATIVE_CODE_REGEXP);
-  });
-
-  return filteredLines.map((line): StackFrame => {
-    let currentLine = line;
-    if (currentLine.includes(" > eval"))
-      currentLine = currentLine.replace(/ line (\d+)(?: > eval line \d+)* > eval:\d+:\d+/g, ":$1");
-
-    if (!currentLine.includes("@") && !currentLine.includes(":")) {
-      return {
-        functionName: currentLine,
-      };
-    } else {
-      const functionNameRegex =
-        /(([^\n\r"\u2028\u2029]*".[^\n\r"\u2028\u2029]*"[^\n\r@\u2028\u2029]*(?:@[^\n\r"\u2028\u2029]*"[^\n\r@\u2028\u2029]*)*(?:[\n\r\u2028\u2029][^@]*)?)?[^@]*)@/;
-      const matches = currentLine.match(functionNameRegex);
-      const functionName = matches && matches[1] ? matches[1] : undefined;
-      const locationParts = extractLocation(currentLine.replace(functionNameRegex, ""));
-
-      return {
-        functionName,
-        fileName: locationParts[0],
-        lineNumber: locationParts[1] ? +locationParts[1] : undefined,
-        columnNumber: locationParts[2] ? +locationParts[2] : undefined,
-        source: currentLine,
-      };
+const parseLines = (
+  stack: string,
+  isV8: boolean,
+  cache?: Map<string, StackFrame>,
+): StackFrame[] => {
+  const frames: StackFrame[] = [];
+  for (const line of stack.split("\n")) {
+    let frame = cache?.get(line);
+    if (!frame) {
+      if (isV8 ? !CHROME_IE_STACK_REGEXP.test(line) : SAFARI_NATIVE_CODE_REGEXP.test(line))
+        continue;
+      frame = isV8 ? parseV8Line(line) : parseSafariLine(line);
+      cache?.set(line, frame);
     }
-  });
+    frames.push(frame);
+  }
+  return frames;
+};
+
+export const parseV8OrIeString = (stack: string): StackFrame[] => parseLines(stack, true);
+
+export const parseFFOrSafariString = (stack: string): StackFrame[] => parseLines(stack, false);
+
+export const createStackParser = () => {
+  const v8Frames = new Map<string, StackFrame>();
+  const safariFrames = new Map<string, StackFrame>();
+  return (stack: string): StackFrame[] => {
+    const isV8 = CHROME_IE_STACK_REGEXP.test(stack);
+    return parseLines(stack, isV8, isV8 ? v8Frames : safariFrames);
+  };
 };

package/src/source/symbolication.ts

@@ -207,6 +207,13 @@ export const getSourceFromSourceMap = (
   );
 };
 
+const getStringIndex = (values: string[], target: string): number => {
+  for (let valueIndex = 0; valueIndex < values.length; valueIndex++) {
+    if (values[valueIndex] === target) return valueIndex;
+  }
+  return -1;
+};
+
 const getSourceFromMappingsByFunctionName = (
   mappings: SourceMapMappings,
   sources: string[],
@@ -215,13 +222,17 @@ const getSourceFromMappingsByFunctionName = (
   ignoredSourceIndices?: Set<number>,
 ): StackFrame | null => {
   if (!names) return null;
-  const functionNameIndex = names.indexOf(functionName);
+  const functionNameIndex = getStringIndex(names, functionName);
   if (functionNameIndex === -1) return null;
 
   let ignoredSource: StackFrame | null = null;
-  for (const lineMapping of mappings) {
-    for (const segment of lineMapping) {
+  for (let lineIndex = 0; lineIndex < mappings.length; lineIndex++) {
+    const lineMapping = mappings[lineIndex];
+    for (let segmentIndex = 0; segmentIndex < lineMapping.length; segmentIndex++) {
+      const segment = lineMapping[segmentIndex];
       if (segment[4] !== functionNameIndex) continue;
+      if (ignoredSource && segment[1] !== undefined && ignoredSourceIndices?.has(segment[1]))
+        continue;
       const source = getSourceFromSegment(segment, sources, ignoredSourceIndices, names);
       if (!source) continue;
       if (!source.isIgnoreListed) return source;
@@ -267,7 +278,7 @@ const findSourceContentByFileName = (
   fileName: string,
 ): string | null => {
   if (!sourcesContent) return null;
-  const sourceIndex = sources.indexOf(fileName);
+  const sourceIndex = getStringIndex(sources, fileName);
   return sourceIndex === -1 ? null : (sourcesContent[sourceIndex] ?? null);
 };