bippy 0.7.3-dev.e910a3b → 0.7.3-dev.fbafc40

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/renderer-dispatchers.ts

@@ -1,6 +1,6 @@
-import type { RendererDispatcherRef } from "../react-internals/index.js";
-import { _renderers, getRDTHook, isRendererMap } from "../rdt-hook.js";
-import type { ReactDevToolsTarget } from "../rdt-hook.js";
+import type { RendererDispatcherRef } from "../react-internals/index";
+import { _renderers, getRDTHook, isRendererMap } from "../rdt-hook";
+import type { ReactDevToolsTarget } from "../rdt-hook";
 
 export const getRendererDispatcherRefs = (
   target: ReactDevToolsTarget = globalThis,

package/src/source/symbolication.ts

@@ -1,8 +1,9 @@
 import { decode, type SourceMapMappings, type SourceMapSegment } from "@jridgewell/sourcemap-codec";
 
-import { BippySourceMapError } from "../errors.js";
-import { SCHEME_REGEX } from "./constants.js";
-import type { StackFrame } from "./parse-stack.js";
+import { BippySourceMapError } from "../errors";
+import { SCHEME_REGEX } from "./constants";
+import { normalizeFileName } from "./normalize-file-name";
+import type { StackFrame } from "./parse-stack";
 
 export interface DecodedSourceMapSection {
   map: {
@@ -207,6 +208,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 +223,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;
@@ -261,37 +273,40 @@ export const getSourceFromSourceMapByFunctionName = (
   );
 };
 
-const findSourceContentByFileName = (
-  sources: string[],
-  sourcesContent: Array<string | null> | undefined,
-  fileName: string,
-): string | null => {
-  if (!sourcesContent) return null;
-  const sourceIndex = sources.indexOf(fileName);
-  return sourceIndex === -1 ? null : (sourcesContent[sourceIndex] ?? null);
+const canonicalSourcePath = (fileName: string): string => {
+  const normalizedFileName = normalizeFileName(fileName);
+  return normalizedFileName.startsWith("./") ? normalizedFileName.slice(2) : normalizedFileName;
 };
 
 export const getSourceContentFromSourceMap = (
   sourceMap: SourceMap,
   originalFileName: string,
 ): string | null => {
-  const sourceContent = findSourceContentByFileName(
-    sourceMap.sources,
-    sourceMap.sourcesContent,
-    originalFileName,
-  );
-  if (sourceContent !== null) return sourceContent;
-
-  if (!sourceMap.sections) return null;
-  for (const section of sourceMap.sections) {
-    const sectionSourceContent = findSourceContentByFileName(
-      section.map.sources,
-      section.map.sourcesContent,
-      originalFileName,
-    );
-    if (sectionSourceContent !== null) return sectionSourceContent;
+  const maps = [sourceMap, ...(sourceMap.sections?.map((section) => section.map) ?? [])];
+  let hasExactSource = false;
+  for (const map of maps) {
+    const sourceIndex = getStringIndex(map.sources, originalFileName);
+    if (sourceIndex === -1) continue;
+    hasExactSource = true;
+    const sourceContent = map.sourcesContent?.[sourceIndex];
+    if (typeof sourceContent === "string") return sourceContent;
+  }
+  if (hasExactSource) return null;
+
+  const canonicalFileName = canonicalSourcePath(originalFileName);
+  if (!canonicalFileName) return null;
+  let matchedFileName: string | undefined;
+  let matchedContent: string | null = null;
+  for (const map of maps) {
+    for (let index = 0; index < map.sources.length; index++) {
+      const fileName = map.sources[index];
+      if (!fileName || canonicalSourcePath(fileName) !== canonicalFileName) continue;
+      if (matchedFileName !== undefined && matchedFileName !== fileName) return null;
+      matchedFileName = fileName;
+      matchedContent ??= map.sourcesContent?.[index] ?? null;
+    }
   }
-  return null;
+  return matchedContent;
 };
 
 const resolveUrl = (reference: string, baseUrl: string): string | null => {
@@ -434,12 +449,46 @@ const getIgnoredSourceIndices = (rawSourceMap: StandardSourceMap): Set<number> |
   return ignoreList?.length ? new Set(ignoreList) : undefined;
 };
 
+const isAbsoluteSourcePath = (source: string): boolean =>
+  source.startsWith("/") || /^[a-zA-Z]:[\\/]/.test(source) || SCHEME_REGEX.test(source);
+
+const resolveRelativeSource = (source: string, sourceMapUrl: string): string => {
+  if (!source.startsWith("./") && !source.startsWith("../")) return source;
+  if (INLINE_SOURCEMAP_REGEX.test(sourceMapUrl)) return source;
+  return resolveUrl(source, sourceMapUrl) ?? source;
+};
+
+const normalizeJoinedSourcePath = (joinedSource: string): string => {
+  const pathSegments = joinedSource.split("/");
+  const normalizedPathSegments: string[] = [];
+  for (const pathSegment of pathSegments) {
+    if (pathSegment === "" || pathSegment === ".") {
+      if (pathSegment === "" && normalizedPathSegments.length === 0) {
+        normalizedPathSegments.push("");
+      }
+      continue;
+    }
+    if (pathSegment === "..") {
+      const previousSegment = normalizedPathSegments[normalizedPathSegments.length - 1];
+      if (previousSegment && previousSegment !== ".." && previousSegment !== "") {
+        normalizedPathSegments.pop();
+      } else {
+        normalizedPathSegments.push("..");
+      }
+      continue;
+    }
+    normalizedPathSegments.push(pathSegment);
+  }
+  return normalizedPathSegments.join("/");
+};
+
 const resolveSourceRoot = (
   sourceRoot: string | undefined,
   source: string,
   sourceMapUrl: string,
 ): string => {
-  if (!sourceRoot || SCHEME_REGEX.test(source) || source.startsWith("/")) return source;
+  if (isAbsoluteSourcePath(source)) return source;
+  if (!sourceRoot) return resolveRelativeSource(source, sourceMapUrl);
   const normalizedSourceRoot = sourceRoot.endsWith("/") ? sourceRoot : `${sourceRoot}/`;
   const normalizedSource = source.replace(/^\.\//, "");
   try {
@@ -448,16 +497,7 @@ const resolveSourceRoot = (
       : new URL(normalizedSourceRoot, sourceMapUrl).toString();
     return new URL(normalizedSource, baseUrl).toString();
   } catch {
-    const pathSegments = `${normalizedSourceRoot}${normalizedSource}`.split("/");
-    const normalizedPathSegments: string[] = [];
-    for (const pathSegment of pathSegments) {
-      if (pathSegment === "..") {
-        normalizedPathSegments.pop();
-      } else if (pathSegment !== ".") {
-        normalizedPathSegments.push(pathSegment);
-      }
-    }
-    return normalizedPathSegments.join("/");
+    return normalizeJoinedSourcePath(`${normalizedSourceRoot}${normalizedSource}`);
   }
 };