bippy 0.6.1-dev.3a24abf → 0.6.1-dev.b88fcb4

package/src/react-internals/generated/react-work-tags.ts

@@ -0,0 +1,314 @@
+import { compareSemver } from "../semver.js";
+
+export const ReactBuildType = {
+  Development: 1,
+  Production: 0,
+} as const;
+
+export const ReactFiberFlags = {
+  ChildDeletion: 16,
+  Cloned: 8,
+  ContentReset: 32,
+  Hydrating: 4096,
+  PerformedWork: 1,
+  Placement: 2,
+  Snapshot: 1024,
+  Update: 4,
+  Visibility: 8192,
+} as const;
+
+export const ReactSymbols = {
+  CONCURRENT_MODE_NUMBER: 60111,
+  CONCURRENT_MODE_SYMBOL_DESCRIPTION: "react.concurrent_mode",
+  CONCURRENT_MODE_SYMBOL_STRING: "Symbol(react.concurrent_mode)",
+  DEPRECATED_ASYNC_MODE_SYMBOL_DESCRIPTION: "react.async_mode",
+  DEPRECATED_ASYNC_MODE_SYMBOL_STRING: "Symbol(react.async_mode)",
+  ELEMENT_SYMBOL_STRING: "Symbol(react.transitional.element)",
+  LEGACY_ELEMENT_SYMBOL_STRING: "Symbol(react.element)",
+} as const;
+
+export interface ReactWorkTagMap {
+  ActivityComponent: number;
+  CacheComponent: number;
+  ClassComponent: number;
+  ContextConsumer: number;
+  ContextProvider: number;
+  CoroutineComponent: number;
+  CoroutineHandlerPhase: number;
+  DehydratedSuspenseComponent: number;
+  ForwardRef: number;
+  Fragment: number;
+  FunctionComponent: number;
+  HostComponent: number;
+  HostHoistable: number;
+  HostPortal: number;
+  HostRoot: number;
+  HostSingleton: number;
+  HostText: number;
+  IncompleteClassComponent: number;
+  IncompleteFunctionComponent: number;
+  IndeterminateComponent: number;
+  LazyComponent: number;
+  LegacyHiddenComponent: number;
+  MemoComponent: number;
+  Mode: number;
+  OffscreenComponent: number;
+  Profiler: number;
+  ScopeComponent: number;
+  SimpleMemoComponent: number;
+  SuspenseComponent: number;
+  SuspenseListComponent: number;
+  Throw: number;
+  TracingMarkerComponent: number;
+  ViewTransitionComponent: number;
+  YieldComponent: number;
+}
+
+const defineReactWorkTags = <const VersionedWorkTags extends Record<string, ReactWorkTagMap>>(
+  workTags: VersionedWorkTags,
+): VersionedWorkTags => workTags;
+
+const reactWorkTagsByVersion = defineReactWorkTags({
+  "16.0.0": {
+    ActivityComponent: -1,
+    CacheComponent: -1,
+    ClassComponent: 2,
+    ContextConsumer: 12,
+    ContextProvider: 13,
+    CoroutineComponent: 7,
+    CoroutineHandlerPhase: 8,
+    DehydratedSuspenseComponent: -1,
+    ForwardRef: 14,
+    Fragment: 10,
+    FunctionComponent: 1,
+    HostComponent: 5,
+    HostHoistable: -1,
+    HostPortal: 4,
+    HostRoot: 3,
+    HostSingleton: -1,
+    HostText: 6,
+    IncompleteClassComponent: -1,
+    IncompleteFunctionComponent: -1,
+    IndeterminateComponent: 0,
+    LazyComponent: -1,
+    LegacyHiddenComponent: -1,
+    MemoComponent: -1,
+    Mode: 11,
+    OffscreenComponent: -1,
+    Profiler: 15,
+    ScopeComponent: -1,
+    SimpleMemoComponent: -1,
+    SuspenseComponent: 16,
+    SuspenseListComponent: -1,
+    Throw: -1,
+    TracingMarkerComponent: -1,
+    ViewTransitionComponent: -1,
+    YieldComponent: 9,
+  },
+  "16.4.3-alpha": {
+    ActivityComponent: -1,
+    CacheComponent: -1,
+    ClassComponent: 2,
+    ContextConsumer: 11,
+    ContextProvider: 12,
+    CoroutineComponent: -1,
+    CoroutineHandlerPhase: -1,
+    DehydratedSuspenseComponent: -1,
+    ForwardRef: 13,
+    Fragment: 9,
+    FunctionComponent: 0,
+    HostComponent: 7,
+    HostHoistable: -1,
+    HostPortal: 6,
+    HostRoot: 5,
+    HostSingleton: -1,
+    HostText: 8,
+    IncompleteClassComponent: -1,
+    IncompleteFunctionComponent: -1,
+    IndeterminateComponent: 4,
+    LazyComponent: -1,
+    LegacyHiddenComponent: -1,
+    MemoComponent: -1,
+    Mode: 10,
+    OffscreenComponent: -1,
+    Profiler: 15,
+    ScopeComponent: -1,
+    SimpleMemoComponent: -1,
+    SuspenseComponent: 16,
+    SuspenseListComponent: -1,
+    Throw: -1,
+    TracingMarkerComponent: -1,
+    ViewTransitionComponent: -1,
+    YieldComponent: -1,
+  },
+  "16.6.0-beta.0": {
+    ActivityComponent: -1,
+    CacheComponent: -1,
+    ClassComponent: 1,
+    ContextConsumer: 9,
+    ContextProvider: 10,
+    CoroutineComponent: -1,
+    CoroutineHandlerPhase: -1,
+    DehydratedSuspenseComponent: 18,
+    ForwardRef: 11,
+    Fragment: 7,
+    FunctionComponent: 0,
+    HostComponent: 5,
+    HostHoistable: -1,
+    HostPortal: 4,
+    HostRoot: 3,
+    HostSingleton: -1,
+    HostText: 6,
+    IncompleteClassComponent: 17,
+    IncompleteFunctionComponent: -1,
+    IndeterminateComponent: 2,
+    LazyComponent: 16,
+    LegacyHiddenComponent: -1,
+    MemoComponent: 14,
+    Mode: 8,
+    OffscreenComponent: -1,
+    Profiler: 12,
+    ScopeComponent: -1,
+    SimpleMemoComponent: 15,
+    SuspenseComponent: 13,
+    SuspenseListComponent: 19,
+    Throw: -1,
+    TracingMarkerComponent: -1,
+    ViewTransitionComponent: -1,
+    YieldComponent: -1,
+  },
+  "17.0.0-alpha": {
+    ActivityComponent: -1,
+    CacheComponent: -1,
+    ClassComponent: 1,
+    ContextConsumer: 9,
+    ContextProvider: 10,
+    CoroutineComponent: -1,
+    CoroutineHandlerPhase: -1,
+    DehydratedSuspenseComponent: 18,
+    ForwardRef: 11,
+    Fragment: 7,
+    FunctionComponent: 0,
+    HostComponent: 5,
+    HostHoistable: -1,
+    HostPortal: 4,
+    HostRoot: 3,
+    HostSingleton: -1,
+    HostText: 6,
+    IncompleteClassComponent: 17,
+    IncompleteFunctionComponent: -1,
+    IndeterminateComponent: 2,
+    LazyComponent: 16,
+    LegacyHiddenComponent: 24,
+    MemoComponent: 14,
+    Mode: 8,
+    OffscreenComponent: 23,
+    Profiler: 12,
+    ScopeComponent: 21,
+    SimpleMemoComponent: 15,
+    SuspenseComponent: 13,
+    SuspenseListComponent: 19,
+    Throw: -1,
+    TracingMarkerComponent: -1,
+    ViewTransitionComponent: -1,
+    YieldComponent: -1,
+  },
+  "17.0.2": {
+    ActivityComponent: 31,
+    CacheComponent: 24,
+    ClassComponent: 1,
+    ContextConsumer: 9,
+    ContextProvider: 10,
+    CoroutineComponent: -1,
+    CoroutineHandlerPhase: -1,
+    DehydratedSuspenseComponent: 18,
+    ForwardRef: 11,
+    Fragment: 7,
+    FunctionComponent: 0,
+    HostComponent: 5,
+    HostHoistable: 26,
+    HostPortal: 4,
+    HostRoot: 3,
+    HostSingleton: 27,
+    HostText: 6,
+    IncompleteClassComponent: 17,
+    IncompleteFunctionComponent: 28,
+    IndeterminateComponent: 2,
+    LazyComponent: 16,
+    LegacyHiddenComponent: 23,
+    MemoComponent: 14,
+    Mode: 8,
+    OffscreenComponent: 22,
+    Profiler: 12,
+    ScopeComponent: 21,
+    SimpleMemoComponent: 15,
+    SuspenseComponent: 13,
+    SuspenseListComponent: 19,
+    Throw: 29,
+    TracingMarkerComponent: 25,
+    ViewTransitionComponent: 30,
+    YieldComponent: -1,
+  },
+});
+
+export type ReactWorkTagVersion = keyof typeof reactWorkTagsByVersion;
+
+export interface GetReactWorkTags {
+  <Version extends ReactWorkTagVersion>(
+    reactVersion: Version,
+  ): Readonly<(typeof reactWorkTagsByVersion)[Version]>;
+  (reactVersion: string): Readonly<ReactWorkTagMap>;
+}
+
+export type ReactWorkTag = Exclude<
+  (typeof reactWorkTagsByVersion)[ReactWorkTagVersion][keyof ReactWorkTagMap],
+  -1
+>;
+
+export type HostWorkTag = Exclude<
+  | (typeof reactWorkTagsByVersion)[ReactWorkTagVersion]["HostComponent"]
+  | (typeof reactWorkTagsByVersion)[ReactWorkTagVersion]["HostHoistable"]
+  | (typeof reactWorkTagsByVersion)[ReactWorkTagVersion]["HostSingleton"]
+  | (typeof reactWorkTagsByVersion)[ReactWorkTagVersion]["HostText"],
+  -1
+>;
+
+interface ReactWorkTagRange {
+  isMinimumExcluded: boolean;
+  minimumVersion: string;
+  workTags: Readonly<ReactWorkTagMap>;
+}
+
+const reactWorkTagRanges: ReactWorkTagRange[] = [
+  {
+    isMinimumExcluded: true,
+    minimumVersion: "17.0.1",
+    workTags: reactWorkTagsByVersion["17.0.2"],
+  },
+  {
+    isMinimumExcluded: false,
+    minimumVersion: "17.0.0-alpha",
+    workTags: reactWorkTagsByVersion["17.0.0-alpha"],
+  },
+  {
+    isMinimumExcluded: false,
+    minimumVersion: "16.6.0-beta.0",
+    workTags: reactWorkTagsByVersion["16.6.0-beta.0"],
+  },
+  {
+    isMinimumExcluded: false,
+    minimumVersion: "16.4.3-alpha",
+    workTags: reactWorkTagsByVersion["16.4.3-alpha"],
+  },
+];
+
+export const getReactWorkTags: GetReactWorkTags = (reactVersion: string) => {
+  for (const range of reactWorkTagRanges) {
+    const comparison = compareSemver(reactVersion, range.minimumVersion);
+    if (comparison === null) return reactWorkTagsByVersion["17.0.2"];
+    if (comparison === 1 || (comparison === 0 && !range.isMinimumExcluded)) {
+      return range.workTags;
+    }
+  }
+  return reactWorkTagsByVersion["16.0.0"];
+};

package/src/react-internals/index.ts

@@ -0,0 +1,67 @@
+import { getReactWorkTags, ReactFiberFlags } from "./generated/react-work-tags.js";
+import type { ReactWorkTagMap } from "./generated/react-work-tags.js";
+import { compareSemver } from "./semver.js";
+import type { Fiber, ReactRenderer } from "./types.js";
+
+export { compareSemver } from "./semver.js";
+export {
+  getReactWorkTags,
+  ReactBuildType,
+  ReactFiberFlags,
+  ReactSymbols,
+} from "./generated/react-work-tags.js";
+export type {
+  HostWorkTag,
+  ReactWorkTag,
+  ReactWorkTagMap,
+  ReactWorkTagVersion,
+} from "./generated/react-work-tags.js";
+export * from "./types.js";
+
+const defaultReactWorkTags = getReactWorkTags("");
+const fiberReactWorkTags = new WeakMap<Fiber, Readonly<ReactWorkTagMap>>();
+
+export const getReactWorkTagsForRenderer = (
+  renderer?: ReactRenderer | null,
+): Readonly<ReactWorkTagMap> => {
+  const reconcilerVersion = renderer?.reconcilerVersion;
+  if (reconcilerVersion && compareSemver(reconcilerVersion, reconcilerVersion) === 0) {
+    return getReactWorkTags(reconcilerVersion);
+  }
+  return getReactWorkTags(renderer?.version ?? "");
+};
+
+export const setReactWorkTagsForFiber = (fiber: Fiber, renderer?: ReactRenderer): void => {
+  const workTags = getReactWorkTagsForRenderer(renderer);
+  fiberReactWorkTags.set(fiber, workTags);
+  if (fiber.alternate) fiberReactWorkTags.set(fiber.alternate, workTags);
+};
+
+export const getReactWorkTagsForFiber = (fiber: Fiber): Readonly<ReactWorkTagMap> => {
+  const cachedWorkTags = fiberReactWorkTags.get(fiber);
+  if (cachedWorkTags) return cachedWorkTags;
+
+  const traversedFibers: Fiber[] = [fiber];
+  let rootFiber = fiber;
+  while (rootFiber.return) {
+    rootFiber = rootFiber.return;
+    traversedFibers.push(rootFiber);
+  }
+  const workTags = fiberReactWorkTags.get(rootFiber) ?? defaultReactWorkTags;
+  for (const traversedFiber of traversedFibers) {
+    fiberReactWorkTags.set(traversedFiber, workTags);
+    if (traversedFiber.alternate) {
+      fiberReactWorkTags.set(traversedFiber.alternate, workTags);
+    }
+  }
+  return workTags;
+};
+
+export const MutationMask =
+  ReactFiberFlags.Placement |
+  ReactFiberFlags.Update |
+  ReactFiberFlags.ChildDeletion |
+  ReactFiberFlags.ContentReset |
+  ReactFiberFlags.Hydrating |
+  ReactFiberFlags.Visibility |
+  ReactFiberFlags.Snapshot;

package/src/react-internals/semver.ts

@@ -0,0 +1,78 @@
+interface SemanticVersion {
+  major: string;
+  minor: string;
+  patch: string;
+  prerelease: string[];
+}
+
+const SEMVER_PATTERN =
+  /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/;
+const NUMERIC_IDENTIFIER_PATTERN = /^\d+$/;
+
+const parseSemver = (version: string): SemanticVersion | null => {
+  const match = SEMVER_PATTERN.exec(version);
+  if (!match) return null;
+  const prerelease = match[4]?.split(".") ?? [];
+  if (
+    prerelease.some(
+      (identifier) =>
+        NUMERIC_IDENTIFIER_PATTERN.test(identifier) &&
+        identifier.length > 1 &&
+        identifier.startsWith("0"),
+    )
+  ) {
+    return null;
+  }
+  return {
+    major: match[1],
+    minor: match[2],
+    patch: match[3],
+    prerelease,
+  };
+};
+
+const compareNumericIdentifiers = (left: string, right: string): -1 | 0 | 1 => {
+  if (left.length !== right.length) return left.length < right.length ? -1 : 1;
+  if (left === right) return 0;
+  return left < right ? -1 : 1;
+};
+
+const comparePrereleaseIdentifiers = (left: string, right: string): -1 | 0 | 1 => {
+  const isLeftNumeric = NUMERIC_IDENTIFIER_PATTERN.test(left);
+  const isRightNumeric = NUMERIC_IDENTIFIER_PATTERN.test(right);
+  if (isLeftNumeric && isRightNumeric) return compareNumericIdentifiers(left, right);
+  if (isLeftNumeric !== isRightNumeric) return isLeftNumeric ? -1 : 1;
+  if (left === right) return 0;
+  return left < right ? -1 : 1;
+};
+
+const comparePrerelease = (left: string[], right: string[]): -1 | 0 | 1 => {
+  if (left.length === 0 || right.length === 0) {
+    if (left.length === right.length) return 0;
+    return left.length === 0 ? 1 : -1;
+  }
+  const identifierCount = Math.max(left.length, right.length);
+  for (let identifierIndex = 0; identifierIndex < identifierCount; identifierIndex++) {
+    const leftIdentifier = left[identifierIndex];
+    const rightIdentifier = right[identifierIndex];
+    if (leftIdentifier === undefined || rightIdentifier === undefined) {
+      return leftIdentifier === undefined ? -1 : 1;
+    }
+    const comparison = comparePrereleaseIdentifiers(leftIdentifier, rightIdentifier);
+    if (comparison !== 0) return comparison;
+  }
+  return 0;
+};
+
+export const compareSemver = (leftVersion: string, rightVersion: string): -1 | 0 | 1 | null => {
+  const left = parseSemver(leftVersion);
+  const right = parseSemver(rightVersion);
+  if (!left || !right) return null;
+  const majorComparison = compareNumericIdentifiers(left.major, right.major);
+  if (majorComparison !== 0) return majorComparison;
+  const minorComparison = compareNumericIdentifiers(left.minor, right.minor);
+  if (minorComparison !== 0) return minorComparison;
+  const patchComparison = compareNumericIdentifiers(left.patch, right.patch);
+  if (patchComparison !== 0) return patchComparison;
+  return comparePrerelease(left.prerelease, right.prerelease);
+};

package/src/{types.ts → react-internals/types.ts}

@@ -1,6 +1,6 @@
 import type { ReactNode } from "react";
 import type ReactReconciler from "react-reconciler";
-import type { HostWorkTag, ReactWorkTag } from "./react-internals.js";
+import type { HostWorkTag, ReactWorkTag } from "./generated/react-work-tags.js";
 
 export type BundleType = ReactReconciler.BundleType;
 export type Flags = ReactReconciler.Flags;
@@ -89,7 +89,12 @@ export interface ContextDependency<T> extends Omit<
   observedBits?: number;
 }
 
+export interface DebugThenableState {
+  thenables?: unknown[];
+}
+
 export interface Dependencies extends Omit<ReactReconciler.Dependencies, "firstContext"> {
+  _debugThenableState?: DebugThenableState | unknown[];
   firstContext: ContextDependency<unknown> | null;
 }
 
@@ -115,6 +120,11 @@ export interface ReactDebugInfo {
   name?: string;
 }
 
+export interface ReactMemoCache {
+  data: unknown[][];
+  index: number;
+}
+
 export interface FiberDebugSource extends Source {
   columnNumber?: number;
 }
@@ -123,7 +133,7 @@ export interface FiberUpdateQueue {
   [key: string]: unknown;
   dispatch?: unknown;
   lastEffect: Effect | null;
-  memoCache?: unknown;
+  memoCache?: ReactMemoCache;
 }
 
 // HACK: @types/react-reconciler does not yet include React 19 debug fields or recursive server owners.
@@ -160,7 +170,7 @@ export interface Fiber<T = unknown> extends Omit<
   sibling: Fiber | null;
   stateNode: T;
   tag: WorkTag;
-  updateQueue: FiberUpdateQueue;
+  updateQueue: FiberUpdateQueue | null;
 }
 
 export interface HostFiber<T = unknown> extends Fiber<T> {

package/src/source/error-stack.ts

@@ -0,0 +1,11 @@
+interface ErrorConstructorWithPrepareStackTrace {
+  prepareStackTrace?: unknown;
+}
+
+const errorConstructor: ErrorConstructorWithPrepareStackTrace = Error;
+
+export const getPrepareStackTrace = (): unknown => errorConstructor.prepareStackTrace;
+
+export const setPrepareStackTrace = (prepareStackTrace: unknown): void => {
+  errorConstructor.prepareStackTrace = prepareStackTrace;
+};

package/src/source/get-display-name-from-source.ts

@@ -1,4 +1,4 @@
-import { Fiber } from "../types.js";
+import { Fiber } from "../react-internals/index.js";
 import { getDisplayName } from "../core.js";
 import { getParentStack } from "./owner-stack.js";
 import { getSourceFromSourceMap, getSourceMap } from "./symbolication.js";

package/src/source/get-source.ts

@@ -1,6 +1,6 @@
-import { Fiber } from "../types.js";
+import type { Fiber } from "../react-internals/index.js";
 
-import { FiberSource } from "./types.js";
+import type { FiberSource } from "./types.js";
 import {
   SCHEME_REGEX,
   INTERNAL_SCHEME_PREFIXES,

package/src/source/index.ts

@@ -6,12 +6,20 @@ export {
   symbolicateStack,
   type DecodedSourceMapSection,
   type IndexSourceMap,
-  type RawSourceMap,
+  type SourceFetch,
   type SourceMap,
+  type SourceMapRequestOptions,
   type StandardSourceMap,
 } from "./symbolication.js";
 export type { FiberSource } from "./types.js";
 export { parseStack, type ParseOptions, type StackFrame } from "./parse-stack.js";
 export { getDisplayNameFromSource } from "./get-display-name-from-source.js";
+export {
+  BippyError,
+  BippyHookInspectionError,
+  BippyHookRenderError,
+  BippySourceMapError,
+  BippyUnsupportedHookError,
+} from "../errors.js";
 export { getFiberHooks, type HookSource, type HooksNode, type HooksTree } from "./inspect-hooks.js";
 export { parseHookNames, type HookNames } from "./parse-hook-names.js";