@jsenv/core 26.0.1 → 27.0.0-alpha.2

package/src/internal/error_stack_remap/remap_call_site.js

@@ -1,315 +0,0 @@
-import { createDetailedMessage } from "@jsenv/logger"
-
-import {
-  startsWithWindowsDriveLetter,
-  windowsFilePathToUrl,
-} from "@jsenv/core/src/internal/windows_file_path_utils.js"
-
-export const remapCallSite = async (
-  callSite,
-  { urlToSourcemapConsumer, resolveFile, readErrorStack, onFailure },
-) => {
-  if (callSite.isNative()) {
-    return callSite
-  }
-
-  // Most call sites will return the source file from getFileName(), but code
-  // passed to eval() ending in "//# sourceURL=..." will return the source file
-  // from getScriptNameOrSourceURL() instead
-  const source = callSite.getFileName() || callSite.getScriptNameOrSourceURL()
-  if (source) {
-    const line = callSite.getLineNumber()
-    const column = callSite.getColumnNumber() - 1
-    const originalPosition = await remapSourcePosition({
-      source,
-      line,
-      column,
-      resolveFile,
-      urlToSourcemapConsumer,
-      readErrorStack,
-      onFailure,
-    })
-
-    const callSiteClone = cloneCallSite(callSite)
-
-    callSiteClone.getFunctionName = () =>
-      originalPosition.name || callSite.getFunctionName()
-    callSiteClone.getFileName = () => originalPosition.source
-    callSiteClone.getLineNumber = () => originalPosition.line
-    callSiteClone.getColumnNumber = () => originalPosition.column + 1
-    callSiteClone.getScriptNameOrSourceURL = () => originalPosition.source
-
-    return callSiteClone
-  }
-
-  // Code called using eval() needs special handling
-  if (callSite.isEval()) {
-    const origin = callSite.getEvalOrigin()
-    if (origin) {
-      const callSiteClone = cloneCallSite(callSite)
-      const originalEvalOrigin = await remapEvalOrigin(origin, {
-        resolveFile,
-        urlToSourcemapConsumer,
-        readErrorStack,
-        onFailure,
-      })
-      callSiteClone.getEvalOrigin = () => originalEvalOrigin
-      return callSiteClone
-    }
-    return callSite
-  }
-
-  // If we get here then we were unable to change the source position
-  return callSite
-}
-
-const cloneCallSite = (callSite) => {
-  const callSiteClone = {}
-  methods.forEach((name) => {
-    callSiteClone[name] = () => callSite[name]()
-  })
-  callSiteClone.toString = () => callSiteToFunctionCall(callSiteClone)
-
-  return callSiteClone
-}
-
-const methods = [
-  "getColumnNumber",
-  "getEvalOrigin",
-  "getFileName",
-  "getFunction",
-  "getFunctionName",
-  "getLineNumber",
-  "getMethodName",
-  "getPosition",
-  "getScriptNameOrSourceURL",
-  "getThis",
-  "getTypeName",
-  "isConstructor",
-  "isEval",
-  "isNative",
-  "isToplevel",
-  "toString",
-]
-
-const callSiteToFunctionCall = (callSite) => {
-  const fileLocation = callSiteToFileLocation(callSite)
-  const isConstructor = callSite.isConstructor()
-  const isMethodCall = !callSite.isToplevel() && !isConstructor
-
-  if (isMethodCall) {
-    return `${callSiteToMethodCall(callSite)} (${fileLocation})`
-  }
-
-  const functionName = callSite.getFunctionName()
-  if (isConstructor) {
-    return `new ${functionName || "<anonymous>"} (${fileLocation})`
-  }
-
-  if (functionName) {
-    return `${functionName} (${fileLocation})`
-  }
-
-  return `${fileLocation}`
-}
-
-const callSiteToMethodCall = (callSite) => {
-  const functionName = callSite.getFunctionName()
-  const typeName = callSiteToType(callSite)
-
-  if (!functionName) {
-    return `${typeName}.<anonymous>`
-  }
-
-  const methodName = callSite.getMethodName()
-  const as = generateAs({ methodName, functionName })
-
-  if (typeName && !functionName.startsWith(typeName)) {
-    return `${typeName}.${functionName}${as}`
-  }
-
-  return `${functionName}${as}`
-}
-
-const generateAs = ({ methodName, functionName }) => {
-  if (!methodName) return ""
-  if (
-    functionName.indexOf(`.${methodName}`) ===
-    functionName.length - methodName.length - 1
-  )
-    return ""
-  return ` [as ${methodName}]`
-}
-
-const callSiteToType = (callSite) => {
-  const typeName = callSite.getTypeName()
-  // Fixes shim to be backward compatible with Node v0 to v4
-  if (typeName === "[object Object]") {
-    return "null"
-  }
-  return typeName
-}
-
-const callSiteToFileLocation = (callSite) => {
-  if (callSite.isNative()) return "native"
-
-  const sourceFile = callSiteToSourceFile(callSite)
-  const lineNumber = callSite.getLineNumber()
-  if (lineNumber === null) {
-    return sourceFile
-  }
-
-  const columnNumber = callSite.getColumnNumber()
-  if (!columnNumber) {
-    return `${sourceFile}:${lineNumber}`
-  }
-
-  return `${sourceFile}:${lineNumber}:${columnNumber}`
-}
-
-const callSiteToSourceFile = (callSite) => {
-  const fileName = callSite.getScriptNameOrSourceURL()
-
-  if (fileName) {
-    return fileName
-  }
-
-  // Source code does not originate from a file and is not native, but we
-  // can still get the source position inside the source string, e.g. in
-  // an eval string.
-  if (callSite.isEval()) {
-    return `${callSite.getEvalOrigin()}, <anonymous>`
-  }
-
-  return "<anonymous>"
-}
-
-// Parses code generated by FormatEvalOrigin(), a function inside V8:
-// https://code.google.com/p/v8/source/browse/trunk/src/messages.js
-const remapEvalOrigin = async (
-  origin,
-  { resolveFile, urlToSourcemapConsumer, onFailure },
-) => {
-  // Most eval() calls are in this format
-  const topLevelEvalMatch = /^eval at ([^(]+) \((.+):(\d+):(\d+)\)$/.exec(
-    origin,
-  )
-  if (topLevelEvalMatch) {
-    const source = topLevelEvalMatch[2]
-    const line = Number(topLevelEvalMatch[3])
-    const column = topLevelEvalMatch[4] - 1
-    const originalPosition = await remapSourcePosition({
-      source,
-      line,
-      column,
-      resolveFile,
-      urlToSourcemapConsumer,
-      onFailure,
-    })
-    return `eval at ${topLevelEvalMatch[1]} (${originalPosition.source}:${
-      originalPosition.line
-    }:${originalPosition.column + 1})`
-  }
-
-  // Parse nested eval() calls using recursion
-  const nestedEvalMatch = /^eval at ([^(]+) \((.+)\)$/.exec(origin)
-  if (nestedEvalMatch) {
-    const originalEvalOrigin = await remapEvalOrigin(nestedEvalMatch[2], {
-      resolveFile,
-      urlToSourcemapConsumer,
-      onFailure,
-    })
-    return `eval at ${nestedEvalMatch[1]} (${originalEvalOrigin})`
-  }
-
-  // Make sure we still return useful information if we didn't find anything
-  return origin
-}
-
-const remapSourcePosition = async ({
-  source,
-  line,
-  column,
-  resolveFile,
-  urlToSourcemapConsumer,
-  readErrorStack,
-  onFailure,
-}) => {
-  const position = { source, line, column }
-
-  const url = sourceToUrl(source, { resolveFile })
-  if (!url) return position
-
-  const sourceMapConsumer = await urlToSourcemapConsumer(url)
-
-  if (!sourceMapConsumer) return position
-
-  try {
-    const originalPosition = sourceMapConsumer.originalPositionFor(position)
-
-    // Only return the original position if a matching line was found. If no
-    // matching line is found then we return position instead, which will cause
-    // the stack trace to print the path and line for the compiled file. It is
-    // better to give a precise location in the compiled file than a vague
-    // location in the original file.
-    const originalSource = originalPosition.source
-
-    if (originalSource === null) return position
-    originalPosition.source = resolveFile(originalSource, url, {
-      type: "file-original",
-    })
-
-    return originalPosition
-  } catch (e) {
-    onFailure(
-      createDetailedMessage(`error while remapping position.`, {
-        ["error stack"]: readErrorStack(e),
-        ["source"]: source,
-        ["line"]: line,
-        ["column"]: column,
-      }),
-    )
-    return position
-  }
-}
-
-const sourceToUrl = (source, { resolveFile }) => {
-  if (startsWithScheme(source)) {
-    return source
-  }
-
-  // linux filesystem path
-  if (source[0] === "/") {
-    return resolveFile(source)
-  }
-
-  // be careful, due to babel or something like that we might receive paths like
-  // C:/directory/file.js (without backslashes we would expect on windows)
-  // In that case we consider C: is the signe we are on windows
-  // And I avoid to rely on process.platform === "win32" because this file might be executed in chrome
-  if (startsWithWindowsDriveLetter(source)) {
-    return windowsFilePathToUrl(source)
-  }
-
-  // I don't think we will ever encounter relative file in the stack trace
-  // but if it ever happens we are safe :)
-  if (source.slice(0, 2) === "./" || source.slice(0, 3) === "../") {
-    return resolveFile(source)
-  }
-
-  // we have received a "bare specifier" for the source
-  // it happens for internal/process/task_queues.js for instance
-  // if we do return resolveFile(source) it will be converted to
-  // file:///C:/project-directory/internal/process/task_queues.js in node
-  // and
-  // http://domain.com/internal/process/task_queues.js
-  // but the file will certainly be a 404
-  // and if not it won't be the right file anyway
-  // for now we assume "bare specifier" in the stack trace
-  // are internal files that are pointless to try to remap
-  return null
-}
-
-const startsWithScheme = (string) => {
-  return /^[a-zA-Z]{2,}:/.test(string)
-}

package/src/internal/error_stack_remap/remap_stack.js

@@ -1,218 +0,0 @@
-import { createDetailedMessage } from "@jsenv/logger"
-
-import { DataUrl } from "@jsenv/core/src/internal/data_url.js"
-import { getJavaScriptSourceMappingUrl } from "@jsenv/core/src/internal/sourcemap_utils.js"
-
-import { remapCallSite } from "./remap_call_site.js"
-
-export const remapStack = async ({
-  stack,
-  resolveFile,
-  fetchFile,
-  SourceMapConsumer,
-  readErrorStack,
-  onFailure,
-}) => {
-  const urlToSourcemapConsumer = memoizeByFirstArgStringValue(
-    async (stackTraceFileUrl) => {
-      if (stackTraceFileUrl.startsWith("node:")) {
-        return null
-      }
-
-      try {
-        let text
-        try {
-          const fileResponse = await fetchFile(stackTraceFileUrl)
-          const { status } = fileResponse
-          if (status !== 200) {
-            if (status === 404) {
-              onFailure(`stack trace file not found at ${stackTraceFileUrl}`)
-            } else {
-              onFailure(
-                createDetailedMessage(
-                  `unexpected response fetching stack trace file.`,
-                  {
-                    ["response status"]: status,
-                    ["response text"]: fileResponse.body,
-                    ["stack trace file"]: stackTraceFileUrl,
-                  },
-                ),
-              )
-            }
-            return null
-          }
-          text = await fileResponse.text()
-        } catch (e) {
-          onFailure(
-            createDetailedMessage(`error while fetching stack trace file.`, {
-              ["fetch error stack"]: readErrorStack(e),
-              ["stack trace file"]: stackTraceFileUrl,
-            }),
-          )
-
-          return null
-        }
-
-        const jsSourcemapUrl = getJavaScriptSourceMappingUrl(text)
-        if (!jsSourcemapUrl) {
-          return null
-        }
-
-        let sourcemapUrl
-        let sourcemapString
-        if (jsSourcemapUrl.startsWith("data:")) {
-          sourcemapUrl = stackTraceFileUrl
-          sourcemapString = DataUrl.parse(jsSourcemapUrl, { as: "string" })
-        } else {
-          sourcemapUrl = resolveFile(jsSourcemapUrl, stackTraceFileUrl, {
-            type: "source-map",
-          })
-
-          try {
-            const sourcemapResponse = await fetchFile(sourcemapUrl)
-            const { status } = sourcemapResponse
-            if (status !== 200) {
-              if (status === 404) {
-                onFailure(`sourcemap file not found at ${sourcemapUrl}`)
-              } else {
-                onFailure(
-                  createDetailedMessage(
-                    `unexpected response for sourcemap file.`,
-                    {
-                      ["response status"]: status,
-                      ["response text"]: await sourcemapResponse.text(),
-                      ["sourcemap url"]: sourcemapUrl,
-                    },
-                  ),
-                )
-              }
-              return null
-            }
-            sourcemapString = await sourcemapResponse.text()
-          } catch (e) {
-            onFailure(
-              createDetailedMessage(`error while fetching sourcemap.`, {
-                ["fetch error stack"]: readErrorStack(e),
-                ["sourcemap url"]: sourcemapUrl,
-              }),
-            )
-            return null
-          }
-        }
-
-        let sourceMap
-        try {
-          sourceMap = JSON.parse(sourcemapString)
-        } catch (e) {
-          onFailure(
-            createDetailedMessage(`error while parsing sourcemap.`, {
-              ["parse error stack"]: readErrorStack(e),
-              ["sourcemap url"]: sourcemapUrl,
-            }),
-          )
-          return null
-        }
-
-        let { sourcesContent } = sourceMap
-
-        if (!sourcesContent) {
-          sourcesContent = []
-          sourceMap.sourcesContent = sourcesContent
-        }
-
-        let firstSourceMapSourceFailure = null
-
-        await Promise.all(
-          sourceMap.sources.map(async (source, index) => {
-            if (index in sourcesContent) return
-
-            const sourcemapSourceUrl = resolveFile(source, sourcemapUrl, {
-              type: "source",
-            })
-            try {
-              const sourceResponse = await fetchFile(sourcemapSourceUrl)
-              const { status } = sourceResponse
-              if (status !== 200) {
-                if (firstSourceMapSourceFailure) return
-
-                if (status === 404) {
-                  firstSourceMapSourceFailure = createDetailedMessage(
-                    `sourcemap source not found.`,
-                    {
-                      ["sourcemap source url"]: sourcemapSourceUrl,
-                      ["sourcemap url"]: sourcemapUrl,
-                    },
-                  )
-                  return
-                }
-                firstSourceMapSourceFailure = createDetailedMessage(
-                  `unexpected response for sourcemap source.`,
-                  {
-                    ["response status"]: status,
-                    ["response text"]: await sourceResponse.text(),
-                    ["sourcemap source url"]: sourcemapSourceUrl,
-                    ["sourcemap url"]: sourcemapUrl,
-                  },
-                )
-                return
-              }
-
-              const sourceString = await sourceResponse.text()
-              sourcesContent[index] = sourceString
-            } catch (e) {
-              if (firstSourceMapSourceFailure) return
-              firstSourceMapSourceFailure = createDetailedMessage(
-                `error while fetching sourcemap source.`,
-                {
-                  ["fetch error stack"]: readErrorStack(e),
-                  ["sourcemap source url"]: sourcemapSourceUrl,
-                  ["sourcemap url"]: sourcemapUrl,
-                },
-              )
-            }
-          }),
-        )
-
-        if (firstSourceMapSourceFailure) {
-          onFailure(firstSourceMapSourceFailure)
-          return null
-        }
-
-        return new SourceMapConsumer(sourceMap)
-      } catch (e) {
-        onFailure(
-          createDetailedMessage(
-            `error while preparing a sourceMap consumer for a stack trace file.`,
-            {
-              ["error stack"]: readErrorStack(e),
-              ["stack trace file"]: stackTraceFileUrl,
-            },
-          ),
-        )
-        return null
-      }
-    },
-  )
-  const originalCallsites = await Promise.all(
-    stack.map((callSite) =>
-      remapCallSite(callSite, {
-        resolveFile,
-        urlToSourcemapConsumer,
-        readErrorStack,
-        onFailure,
-      }),
-    ),
-  )
-  return originalCallsites
-}
-
-const memoizeByFirstArgStringValue = (fn) => {
-  const stringValueCache = {}
-  return (firstArgValue) => {
-    if (firstArgValue in stringValueCache)
-      return stringValueCache[firstArgValue]
-    const value = fn(firstArgValue)
-    stringValueCache[firstArgValue] = value
-    return value
-  }
-}

package/src/internal/error_stack_remap/stringify_stack.js

@@ -1,9 +0,0 @@
-export const stringifyStack = (stack, { error, indent }) => {
-  const name = error.name || "Error"
-  const message = error.message || ""
-  const stackString = stack
-    .map((callSite) => `\n${indent}at ${callSite}`)
-    .join("")
-
-  return `${name}: ${message}${stackString}`
-}