@jsenv/core 25.6.2 → 27.0.0-alpha.0

package/src/internal/error-stack-remapping/remapCallSite.js

@@ -1,314 +0,0 @@
-import { createDetailedMessage } from "@jsenv/logger"
-import {
-  startsWithWindowsDriveLetter,
-  windowsFilePathToUrl,
-} from "../filePathUtils.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-remapping/stackToString.js

@@ -1,9 +0,0 @@
-export const stackToString = (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}`
-}

package/src/internal/escapeRegexpSpecialCharacters.js

@@ -1,34 +0,0 @@
-// https://github.com/benjamingr/RegExp.escape/blob/master/polyfill.js
-
-export const escapeRegexpSpecialCharacters = (string) => {
-  string = String(string)
-  let i = 0
-  let escapedString = ""
-
-  while (i < string.length) {
-    const char = string[i]
-    i++
-    escapedString += isRegExpSpecialChar(char) ? `\\${char}` : char
-  }
-  return escapedString
-}
-
-const isRegExpSpecialChar = (char) => regexpSpecialChars.indexOf(char) > -1
-
-const regexpSpecialChars = [
-  "/",
-  "^",
-  "\\",
-  "[",
-  "]",
-  "(",
-  ")",
-  "{",
-  "}",
-  "?",
-  "+",
-  "*",
-  ".",
-  "|",
-  "$",
-]

package/src/internal/escapeTemplateStringSpecialCharacters.js

@@ -1,20 +0,0 @@
-// https://github.com/mgenware/string-to-template-literal/blob/main/src/main.ts#L1
-
-export const escapeTemplateStringSpecialCharacters = (string) => {
-  string = String(string)
-  let i = 0
-  let escapedString = ""
-
-  while (i < string.length) {
-    const char = string[i]
-    i++
-    escapedString += isTemplateStringSpecialChar(char) ? `\\${char}` : char
-  }
-
-  return escapedString
-}
-
-const isTemplateStringSpecialChar = (char) =>
-  templateStringSpecialChars.indexOf(char) > -1
-
-const templateStringSpecialChars = ["\\", "`", "$"]

package/src/internal/executing/coverage/babel_plugin_instrument.js

@@ -1,90 +0,0 @@
-import {
-  resolveUrl,
-  normalizeStructuredMetaMap,
-  urlToMeta,
-} from "@jsenv/filesystem"
-
-import { require } from "../../require.js"
-
-// https://github.com/istanbuljs/babel-plugin-istanbul/blob/321740f7b25d803f881466ea819d870f7ed6a254/src/index.js
-
-export const babelPluginInstrument = (api, options) => {
-  const { programVisitor } = require("istanbul-lib-instrument")
-
-  const { types } = api
-  const {
-    useInlineSourceMaps = false,
-    projectDirectoryUrl,
-    coverageConfig = { "./**/*": true },
-  } = options
-
-  const structuredMetaMapForCover = normalizeStructuredMetaMap(
-    {
-      cover: coverageConfig,
-    },
-    projectDirectoryUrl,
-  )
-  const shouldInstrument = (relativeUrl) => {
-    return urlToMeta({
-      url: resolveUrl(relativeUrl, projectDirectoryUrl),
-      structuredMetaMap: structuredMetaMapForCover,
-    }).cover
-  }
-
-  return {
-    name: "transform-instrument",
-    visitor: {
-      Program: {
-        enter(path) {
-          const { file } = this
-          const { opts } = file
-
-          const relativeUrl = optionsToRelativeUrl(opts)
-          if (!relativeUrl) {
-            console.warn("file without relativeUrl", relativeUrl)
-            return
-          }
-          if (!shouldInstrument(relativeUrl)) return
-
-          this.__dv__ = null
-
-          let inputSourceMap
-
-          if (useInlineSourceMaps) {
-            // https://github.com/istanbuljs/babel-plugin-istanbul/commit/a9e15643d249a2985e4387e4308022053b2cd0ad#diff-1fdf421c05c1140f6d71444ea2b27638R65
-            inputSourceMap =
-              opts.inputSourceMap || file.inputMap
-                ? file.inputMap.sourcemap
-                : null
-          } else {
-            inputSourceMap = opts.inputSourceMap
-          }
-
-          this.__dv__ = programVisitor(
-            types,
-            opts.filenameRelative || opts.filename,
-            {
-              coverageVariable: "__coverage__",
-              inputSourceMap,
-            },
-          )
-          this.__dv__.enter(path)
-        },
-
-        exit(path) {
-          if (!this.__dv__) {
-            return
-          }
-          const object = this.__dv__.exit(path)
-          // object got two properties: fileCoverage and sourceMappingURL
-          this.file.metadata.coverage = object.fileCoverage
-        },
-      },
-    },
-  }
-}
-
-const optionsToRelativeUrl = ({ filenameRelative }) => {
-  if (filenameRelative) return filenameRelative
-  return ""
-}

package/src/internal/executing/coverage/reportToCoverage.js

@@ -1,198 +0,0 @@
-import { readFile } from "@jsenv/filesystem"
-import { Abort } from "@jsenv/abort"
-
-import {
-  visitNodeV8Directory,
-  filterV8Coverage,
-} from "../coverage_utils/v8_coverage_from_directory.js"
-import { composeTwoV8Coverages } from "../coverage_utils/v8_coverage_composition.js"
-import { composeTwoFileByFileIstanbulCoverages } from "../coverage_utils/istanbul_coverage_composition.js"
-import { v8CoverageToIstanbul } from "../coverage_utils/v8_coverage_to_istanbul.js"
-import { composeV8AndIstanbul } from "../coverage_utils/v8_and_istanbul.js"
-import { normalizeFileByFileCoveragePaths } from "../coverage_utils/file_by_file_coverage.js"
-import { getMissingFileByFileCoverage } from "../coverage_missing/missing_coverage.js"
-
-export const reportToCoverage = async (
-  report,
-  {
-    signal,
-    logger,
-    projectDirectoryUrl,
-    babelPluginMap,
-    coverageConfig,
-    coverageIncludeMissing,
-    coverageIgnorePredicate,
-    coverageForceIstanbul,
-    coverageV8ConflictWarning,
-  },
-) => {
-  // collect v8 and istanbul coverage from executions
-  let { v8Coverage, fileByFileIstanbulCoverage } = await getCoverageFromReport({
-    signal,
-    report,
-    onMissing: ({ file, executionResult, executionName }) => {
-      // several reasons not to have coverage here:
-      // 1. the file we executed did not import an instrumented file.
-      // - a test file without import
-      // - a test file importing only file excluded from coverage
-      // - a coverDescription badly configured so that we don't realize
-      // a file should be covered
-
-      // 2. the file we wanted to executed timedout
-      // - infinite loop
-      // - too extensive operation
-      // - a badly configured or too low allocatedMs for that execution.
-
-      // 3. the file we wanted to execute contains syntax-error
-
-      // in any scenario we are fine because
-      // coverDescription will generate empty coverage for files
-      // that were suppose to be coverage but were not.
-      if (
-        executionResult.status === "completed" &&
-        executionResult.runtimeName !== "node" &&
-        !process.env.NODE_V8_COVERAGE
-      ) {
-        logger.warn(
-          `No execution.coverageFileUrl from execution named "${executionName}" of ${file}`,
-        )
-      }
-    },
-  })
-
-  if (!coverageForceIstanbul && process.env.NODE_V8_COVERAGE) {
-    await visitNodeV8Directory({
-      logger,
-      signal,
-      NODE_V8_COVERAGE: process.env.NODE_V8_COVERAGE,
-      onV8Coverage: (nodeV8Coverage) => {
-        const nodeV8CoverageLight = filterV8Coverage(nodeV8Coverage, {
-          coverageIgnorePredicate,
-        })
-        v8Coverage = v8Coverage
-          ? composeTwoV8Coverages(v8Coverage, nodeV8CoverageLight)
-          : nodeV8CoverageLight
-      },
-    })
-  }
-
-  // try to merge v8 with istanbul, if any
-  let fileByFileCoverage
-  if (v8Coverage) {
-    let v8FileByFileCoverage = await v8CoverageToIstanbul(v8Coverage, {
-      signal,
-    })
-
-    v8FileByFileCoverage = normalizeFileByFileCoveragePaths(
-      v8FileByFileCoverage,
-      projectDirectoryUrl,
-    )
-
-    if (fileByFileIstanbulCoverage) {
-      fileByFileIstanbulCoverage = normalizeFileByFileCoveragePaths(
-        fileByFileIstanbulCoverage,
-        projectDirectoryUrl,
-      )
-      fileByFileCoverage = composeV8AndIstanbul(
-        v8FileByFileCoverage,
-        fileByFileIstanbulCoverage,
-        { coverageV8ConflictWarning },
-      )
-    } else {
-      fileByFileCoverage = v8FileByFileCoverage
-    }
-  }
-  // get istanbul only
-  else if (fileByFileIstanbulCoverage) {
-    fileByFileCoverage = normalizeFileByFileCoveragePaths(
-      fileByFileIstanbulCoverage,
-      projectDirectoryUrl,
-    )
-  }
-  // no coverage found in execution (or zero file where executed)
-  else {
-    fileByFileCoverage = {}
-  }
-
-  // now add coverage for file not covered
-  if (coverageIncludeMissing) {
-    const missingFileByFileCoverage = await getMissingFileByFileCoverage({
-      signal,
-      projectDirectoryUrl,
-      coverageConfig,
-      fileByFileCoverage,
-      babelPluginMap,
-    })
-    Object.assign(
-      fileByFileCoverage,
-      normalizeFileByFileCoveragePaths(
-        missingFileByFileCoverage,
-        projectDirectoryUrl,
-      ),
-    )
-  }
-
-  return fileByFileCoverage
-}
-
-const getCoverageFromReport = async ({ signal, report, onMissing }) => {
-  const operation = Abort.startOperation()
-  operation.addAbortSignal(signal)
-
-  try {
-    let v8Coverage
-    let fileByFileIstanbulCoverage
-
-    // collect v8 and istanbul coverage from executions
-    await Object.keys(report).reduce(async (previous, file) => {
-      operation.throwIfAborted()
-      await previous
-
-      const executionResultForFile = report[file]
-      await Object.keys(executionResultForFile).reduce(
-        async (previous, executionName) => {
-          operation.throwIfAborted()
-          await previous
-
-          const executionResultForFileOnRuntime =
-            executionResultForFile[executionName]
-          const { coverageFileUrl } = executionResultForFileOnRuntime
-          if (!coverageFileUrl) {
-            onMissing({
-              executionName,
-              file,
-              executionResult: executionResultForFileOnRuntime,
-            })
-            return
-          }
-
-          const executionCoverage = await readFile(coverageFileUrl, {
-            as: "json",
-          })
-          if (isV8Coverage(executionCoverage)) {
-            v8Coverage = v8Coverage
-              ? composeTwoV8Coverages(v8Coverage, executionCoverage)
-              : executionCoverage
-          } else {
-            fileByFileIstanbulCoverage = fileByFileIstanbulCoverage
-              ? composeTwoFileByFileIstanbulCoverages(
-                  fileByFileIstanbulCoverage,
-                  executionCoverage,
-                )
-              : executionCoverage
-          }
-        },
-        Promise.resolve(),
-      )
-    }, Promise.resolve())
-
-    return {
-      v8Coverage,
-      fileByFileIstanbulCoverage,
-    }
-  } finally {
-    await operation.end()
-  }
-}
-
-const isV8Coverage = (coverage) => Boolean(coverage.result)

package/src/internal/executing/coverage_missing/createEmptyCoverage.js

@@ -1,6 +0,0 @@
-import { require } from "../../require.js"
-
-export const createEmptyCoverage = (relativeUrl) => {
-  const { createFileCoverage } = require("istanbul-lib-coverage")
-  return createFileCoverage(relativeUrl).toJSON()
-}

package/src/internal/executing/coverage_missing/list_files_not_covered.js

@@ -1,20 +0,0 @@
-import { collectFiles } from "@jsenv/filesystem"
-
-export const listRelativeFileUrlToCover = async ({
-  signal,
-  projectDirectoryUrl,
-  coverageConfig,
-}) => {
-  const structuredMetaMapForCoverage = {
-    cover: coverageConfig,
-  }
-
-  const matchingFileResultArray = await collectFiles({
-    signal,
-    directoryUrl: projectDirectoryUrl,
-    structuredMetaMap: structuredMetaMapForCoverage,
-    predicate: ({ cover }) => cover,
-  })
-
-  return matchingFileResultArray.map(({ relativeUrl }) => relativeUrl)
-}