@jsenv/core 25.6.2 → 27.0.0-alpha.0

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

@@ -1,46 +0,0 @@
-import { Abort } from "@jsenv/abort"
-
-import { listRelativeFileUrlToCover } from "./list_files_not_covered.js"
-import { relativeUrlToEmptyCoverage } from "./relativeUrlToEmptyCoverage.js"
-
-export const getMissingFileByFileCoverage = async ({
-  signal,
-  projectDirectoryUrl,
-  coverageConfig,
-  fileByFileCoverage,
-  babelPluginMap,
-}) => {
-  const relativeUrlsToCover = await listRelativeFileUrlToCover({
-    signal,
-    projectDirectoryUrl,
-    coverageConfig,
-  })
-
-  const relativeUrlsMissing = relativeUrlsToCover.filter((relativeUrlToCover) =>
-    Object.keys(fileByFileCoverage).every((key) => {
-      return key !== `./${relativeUrlToCover}`
-    }),
-  )
-
-  const operation = Abort.startOperation()
-  operation.addAbortSignal(signal)
-
-  const missingFileByFileCoverage = {}
-  await relativeUrlsMissing.reduce(async (previous, relativeUrlMissing) => {
-    operation.throwIfAborted()
-    await previous
-    await operation.withSignal(async (signal) => {
-      const emptyCoverage = await relativeUrlToEmptyCoverage(
-        relativeUrlMissing,
-        {
-          signal,
-          projectDirectoryUrl,
-          babelPluginMap,
-        },
-      )
-      missingFileByFileCoverage[`./${relativeUrlMissing}`] = emptyCoverage
-    })
-  }, Promise.resolve())
-
-  return missingFileByFileCoverage
-}

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

@@ -1,63 +0,0 @@
-import { resolveUrl, urlToFileSystemPath, readFile } from "@jsenv/filesystem"
-import { Abort } from "@jsenv/abort"
-
-import {
-  babelPluginsFromBabelPluginMap,
-  getMinimalBabelPluginMap,
-} from "@jsenv/core/src/internal/compiling/babel_plugins.js"
-import { babelPluginInstrument } from "../coverage/babel_plugin_instrument.js"
-import { createEmptyCoverage } from "./createEmptyCoverage.js"
-
-export const relativeUrlToEmptyCoverage = async (
-  relativeUrl,
-  { signal, projectDirectoryUrl, babelPluginMap },
-) => {
-  const operation = Abort.startOperation()
-  operation.addAbortSignal(signal)
-
-  try {
-    const { transformAsync } = await import("@babel/core")
-    const fileUrl = resolveUrl(relativeUrl, projectDirectoryUrl)
-    const source = await readFile(fileUrl)
-
-    babelPluginMap = {
-      ...getMinimalBabelPluginMap(),
-      ...babelPluginMap,
-      "transform-instrument": [babelPluginInstrument, { projectDirectoryUrl }],
-    }
-
-    operation.throwIfAborted()
-    const { metadata } = await transformAsync(source, {
-      filename: urlToFileSystemPath(fileUrl),
-      filenameRelative: relativeUrl,
-      configFile: false,
-      babelrc: false,
-      ast: true,
-      parserOpts: {
-        allowAwaitOutsideFunction: true,
-      },
-      plugins: babelPluginsFromBabelPluginMap(babelPluginMap),
-    })
-
-    const { coverage } = metadata
-    if (!coverage) {
-      throw new Error(`missing coverage for file`)
-    }
-
-    // https://github.com/gotwarlost/istanbul/blob/bc84c315271a5dd4d39bcefc5925cfb61a3d174a/lib/command/common/run-with-cover.js#L229
-    Object.keys(coverage.s).forEach(function (key) {
-      coverage.s[key] = 0
-    })
-
-    return coverage
-  } catch (e) {
-    if (e && e.code === "BABEL_PARSE_ERROR") {
-      // return an empty coverage for that file when
-      // it contains a syntax error
-      return createEmptyCoverage(relativeUrl)
-    }
-    throw e
-  } finally {
-    await operation.end()
-  }
-}

package/src/internal/executing/coverage_reporter/coverage_reporter_html_directory.js

@@ -1,36 +0,0 @@
-import { readFileSync } from "node:fs"
-import { resolveUrl, urlToFileSystemPath } from "@jsenv/filesystem"
-
-import { require } from "../../require.js"
-import { istanbulCoverageMapFromCoverage } from "./istanbulCoverageMapFromCoverage.js"
-
-export const generateCoverageHtmlDirectory = async (
-  coverage,
-  {
-    projectDirectoryUrl,
-    coverageHtmlDirectoryRelativeUrl,
-    coverageSkipEmpty,
-    coverageSkipFull,
-  },
-) => {
-  const libReport = require("istanbul-lib-report")
-  const reports = require("istanbul-reports")
-
-  const context = libReport.createContext({
-    dir: urlToFileSystemPath(projectDirectoryUrl),
-    coverageMap: istanbulCoverageMapFromCoverage(coverage),
-    sourceFinder: (path) => {
-      return readFileSync(
-        urlToFileSystemPath(resolveUrl(path, projectDirectoryUrl)),
-        "utf8",
-      )
-    },
-  })
-
-  const report = reports.create("html", {
-    skipEmpty: coverageSkipEmpty,
-    skipFull: coverageSkipFull,
-    subdir: coverageHtmlDirectoryRelativeUrl,
-  })
-  report.execute(context)
-}

package/src/internal/executing/coverage_reporter/coverage_reporter_json_file.js

@@ -1,22 +0,0 @@
-import { writeFile, urlToFileSystemPath } from "@jsenv/filesystem"
-
-import { byteAsFileSize } from "@jsenv/core/src/internal/logs/byteAsFileSize.js"
-
-export const generateCoverageJsonFile = async ({
-  coverage,
-  coverageJsonFileUrl,
-  coverageJsonFileLog,
-  logger,
-}) => {
-  const coverageAsText = JSON.stringify(coverage, null, "  ")
-
-  if (coverageJsonFileLog) {
-    logger.info(
-      `-> ${urlToFileSystemPath(coverageJsonFileUrl)} (${byteAsFileSize(
-        Buffer.byteLength(coverageAsText),
-      )})`,
-    )
-  }
-
-  await writeFile(coverageJsonFileUrl, coverageAsText)
-}

package/src/internal/executing/coverage_reporter/coverage_reporter_text_log.js

@@ -1,19 +0,0 @@
-import { require } from "../../require.js"
-import { istanbulCoverageMapFromCoverage } from "./istanbulCoverageMapFromCoverage.js"
-
-export const generateCoverageTextLog = (
-  coverage,
-  { coverageSkipEmpty, coverageSkipFull },
-) => {
-  const libReport = require("istanbul-lib-report")
-  const reports = require("istanbul-reports")
-
-  const context = libReport.createContext({
-    coverageMap: istanbulCoverageMapFromCoverage(coverage),
-  })
-  const report = reports.create("text", {
-    skipEmpty: coverageSkipEmpty,
-    skipFull: coverageSkipFull,
-  })
-  report.execute(context)
-}

package/src/internal/executing/coverage_reporter/istanbulCoverageMapFromCoverage.js

@@ -1,16 +0,0 @@
-import { require } from "../../require.js"
-
-export const istanbulCoverageMapFromCoverage = (coverage) => {
-  const { createCoverageMap } = require("istanbul-lib-coverage")
-
-  const coverageAdjusted = {}
-  Object.keys(coverage).forEach((key) => {
-    coverageAdjusted[key.slice(2)] = {
-      ...coverage[key],
-      path: key.slice(2),
-    }
-  })
-
-  const coverageMap = createCoverageMap(coverageAdjusted)
-  return coverageMap
-}

package/src/internal/executing/coverage_utils/file_by_file_coverage.js

@@ -1,28 +0,0 @@
-import {
-  urlToRelativeUrl,
-  fileSystemPathToUrl,
-  isFileSystemPath,
-  resolveUrl,
-} from "@jsenv/filesystem"
-
-export const normalizeFileByFileCoveragePaths = (
-  fileByFileCoverage,
-  projectDirectoryUrl,
-) => {
-  const fileByFileNormalized = {}
-
-  Object.keys(fileByFileCoverage).forEach((key) => {
-    const fileCoverage = fileByFileCoverage[key]
-    const { path } = fileCoverage
-    const url = isFileSystemPath(path)
-      ? fileSystemPathToUrl(path)
-      : resolveUrl(path, projectDirectoryUrl)
-    const relativeUrl = urlToRelativeUrl(url, projectDirectoryUrl)
-    fileByFileNormalized[`./${relativeUrl}`] = {
-      ...fileCoverage,
-      path: `./${relativeUrl}`,
-    }
-  })
-
-  return fileByFileNormalized
-}

package/src/internal/executing/coverage_utils/istanbul_coverage_composition.js

@@ -1,28 +0,0 @@
-import { require } from "../../require.js"
-
-export const composeTwoFileByFileIstanbulCoverages = (
-  firstFileByFileIstanbulCoverage,
-  secondFileByFileIstanbulCoverage,
-) => {
-  const fileByFileIstanbulCoverage = {}
-  Object.keys(firstFileByFileIstanbulCoverage).forEach((key) => {
-    fileByFileIstanbulCoverage[key] = firstFileByFileIstanbulCoverage[key]
-  })
-  Object.keys(secondFileByFileIstanbulCoverage).forEach((key) => {
-    const firstCoverage = firstFileByFileIstanbulCoverage[key]
-    const secondCoverage = secondFileByFileIstanbulCoverage[key]
-    fileByFileIstanbulCoverage[key] = firstCoverage
-      ? merge(firstCoverage, secondCoverage)
-      : secondCoverage
-  })
-
-  return fileByFileIstanbulCoverage
-}
-
-const merge = (firstIstanbulCoverage, secondIstanbulCoverage) => {
-  const { createFileCoverage } = require("istanbul-lib-coverage")
-  const istanbulFileCoverageObject = createFileCoverage(firstIstanbulCoverage)
-  istanbulFileCoverageObject.merge(secondIstanbulCoverage)
-  const istanbulCoverage = istanbulFileCoverageObject.toJSON()
-  return istanbulCoverage
-}

package/src/internal/executing/coverage_utils/v8_and_istanbul.js

@@ -1,38 +0,0 @@
-import { createDetailedMessage } from "@jsenv/logger"
-
-export const composeV8AndIstanbul = (
-  v8FileByFileCoverage,
-  istanbulFileByFileCoverage,
-  { coverageV8ConflictWarning },
-) => {
-  const fileByFileCoverage = {}
-  const v8Files = Object.keys(v8FileByFileCoverage)
-  const istanbulFiles = Object.keys(istanbulFileByFileCoverage)
-
-  v8Files.forEach((key) => {
-    fileByFileCoverage[key] = v8FileByFileCoverage[key]
-  })
-  istanbulFiles.forEach((key) => {
-    const v8Coverage = v8FileByFileCoverage[key]
-    if (v8Coverage) {
-      if (coverageV8ConflictWarning) {
-        console.warn(
-          createDetailedMessage(
-            `Coverage conflict on "${key}", found two coverage that cannot be merged together: v8 and istanbul. The istanbul coverage will be ignored.`,
-            {
-              "details": `This happens when a file is executed on a runtime using v8 coverage (node or chromium) and on runtime using istanbul coverage (firefox or webkit)`,
-              "suggestion":
-                "You can disable this warning with coverageV8ConflictWarning: false",
-              "suggestion 2": `You can force usage of istanbul to prevent this conflict with coverageForceIstanbul: true`,
-            },
-          ),
-        )
-      }
-      fileByFileCoverage[key] = v8Coverage
-    } else {
-      fileByFileCoverage[key] = istanbulFileByFileCoverage[key]
-    }
-  })
-
-  return fileByFileCoverage
-}

package/src/internal/executing/coverage_utils/v8_coverage_composition.js

@@ -1,23 +0,0 @@
-import { require } from "@jsenv/core/src/internal/require.js"
-
-export const composeTwoV8Coverages = (firstV8Coverage, secondV8Coverage) => {
-  if (secondV8Coverage.result.length === 0) {
-    return firstV8Coverage
-  }
-
-  const { mergeProcessCovs } = require("@c88/v8-coverage")
-  // "mergeProcessCovs" do not preserves source-map-cache during the merge
-  // so we store sourcemap cache now
-  const sourceMapCache = {}
-  const visit = (coverageReport) => {
-    if (coverageReport["source-map-cache"]) {
-      Object.assign(sourceMapCache, coverageReport["source-map-cache"])
-    }
-  }
-  visit(firstV8Coverage)
-  visit(secondV8Coverage)
-  const v8Coverage = mergeProcessCovs([firstV8Coverage, secondV8Coverage])
-  v8Coverage["source-map-cache"] = sourceMapCache
-
-  return v8Coverage
-}

package/src/internal/executing/coverage_utils/v8_coverage_from_directory.js

@@ -1,86 +0,0 @@
-import {
-  assertAndNormalizeDirectoryUrl,
-  readDirectory,
-  readFile,
-  resolveUrl,
-} from "@jsenv/filesystem"
-import { createDetailedMessage } from "@jsenv/logger"
-import { Abort } from "@jsenv/abort"
-
-export const visitNodeV8Directory = async ({
-  logger,
-  signal,
-  NODE_V8_COVERAGE,
-  onV8Coverage,
-}) => {
-  const operation = Abort.startOperation()
-  operation.addAbortSignal(signal)
-
-  const tryReadDirectory = async () => {
-    const dirContent = await readDirectory(NODE_V8_COVERAGE)
-    if (dirContent.length > 0) {
-      return dirContent
-    }
-    logger.warn(`v8 coverage directory is empty at ${NODE_V8_COVERAGE}`)
-    return dirContent
-  }
-
-  try {
-    operation.throwIfAborted()
-    const dirContent = await tryReadDirectory()
-
-    const coverageDirectoryUrl =
-      assertAndNormalizeDirectoryUrl(NODE_V8_COVERAGE)
-    await dirContent.reduce(async (previous, dirEntry) => {
-      operation.throwIfAborted()
-      await previous
-
-      const dirEntryUrl = resolveUrl(dirEntry, coverageDirectoryUrl)
-      const tryReadJsonFile = async (timeSpentTrying = 0) => {
-        const fileContent = await readFile(dirEntryUrl, { as: "string" })
-        if (fileContent === "") {
-          if (timeSpentTrying < 400) {
-            await new Promise((resolve) => setTimeout(resolve, 200))
-            return tryReadJsonFile(timeSpentTrying + 200)
-          }
-          console.warn(`Coverage JSON file is empty at ${dirEntryUrl}`)
-          return null
-        }
-
-        try {
-          const fileAsJson = JSON.parse(fileContent)
-          return fileAsJson
-        } catch (e) {
-          if (timeSpentTrying < 400) {
-            await new Promise((resolve) => setTimeout(resolve, 200))
-            return tryReadJsonFile(timeSpentTrying + 200)
-          }
-          console.warn(
-            createDetailedMessage(`Error while reading coverage file`, {
-              "error stack": e.stack,
-              "file": dirEntryUrl,
-            }),
-          )
-          return null
-        }
-      }
-
-      const fileContent = await tryReadJsonFile()
-      if (fileContent) {
-        onV8Coverage(fileContent)
-      }
-    }, Promise.resolve())
-  } finally {
-    await operation.end()
-  }
-}
-
-export const filterV8Coverage = (v8Coverage, { coverageIgnorePredicate }) => {
-  const v8CoverageFiltered = {
-    ...v8Coverage,
-    result: v8Coverage.result.filter((fileReport) => {
-      return !coverageIgnorePredicate(fileReport.url)
-    }),
-  }
-  return v8CoverageFiltered
-}

package/src/internal/executing/coverage_utils/v8_coverage_to_istanbul.js

@@ -1,100 +0,0 @@
-import { urlToFileSystemPath } from "@jsenv/filesystem"
-import { Abort } from "@jsenv/abort"
-
-import { require } from "@jsenv/core/src/internal/require.js"
-
-import { composeTwoFileByFileIstanbulCoverages } from "./istanbul_coverage_composition.js"
-
-export const v8CoverageToIstanbul = async (v8Coverage, { signal }) => {
-  const operation = Abort.startOperation()
-  operation.addAbortSignal(signal)
-
-  try {
-    const v8ToIstanbul = require("v8-to-istanbul")
-    const sourcemapCache = v8Coverage["source-map-cache"]
-    let istanbulCoverageComposed = null
-
-    await v8Coverage.result.reduce(async (previous, fileV8Coverage) => {
-      operation.throwIfAborted()
-      await previous
-
-      const { source } = fileV8Coverage
-      let sources
-      // when v8 coverage comes from playwright (chromium) v8Coverage.source is set
-      if (typeof source === "string") {
-        sources = { source }
-      }
-      // when v8 coverage comes from Node.js, the source can be read from sourcemapCache
-      else if (sourcemapCache) {
-        sources = sourcesFromSourceMapCache(fileV8Coverage.url, sourcemapCache)
-      }
-      const path = urlToFileSystemPath(fileV8Coverage.url)
-
-      const converter = v8ToIstanbul(
-        path,
-        // wrapperLength is undefined we don't need it
-        // https://github.com/istanbuljs/v8-to-istanbul/blob/2b54bc97c5edf8a37b39a171ec29134ba9bfd532/lib/v8-to-istanbul.js#L27
-        undefined,
-        sources,
-      )
-      await converter.load()
-
-      converter.applyCoverage(fileV8Coverage.functions)
-      const istanbulCoverage = converter.toIstanbul()
-
-      istanbulCoverageComposed = istanbulCoverageComposed
-        ? composeTwoFileByFileIstanbulCoverages(
-            istanbulCoverageComposed,
-            istanbulCoverage,
-          )
-        : istanbulCoverage
-    }, Promise.resolve())
-
-    if (!istanbulCoverageComposed) {
-      return {}
-    }
-    istanbulCoverageComposed = markAsConvertedFromV8(istanbulCoverageComposed)
-    return istanbulCoverageComposed
-  } finally {
-    await operation.end()
-  }
-}
-
-const markAsConvertedFromV8 = (fileByFileCoverage) => {
-  const fileByFileMarked = {}
-  Object.keys(fileByFileCoverage).forEach((key) => {
-    const fileCoverage = fileByFileCoverage[key]
-    fileByFileMarked[key] = {
-      ...fileCoverage,
-      fromV8: true,
-    }
-  })
-  return fileByFileMarked
-}
-
-const sourcesFromSourceMapCache = (url, sourceMapCache) => {
-  const sourceMapAndLineLengths = sourceMapCache[url]
-  if (!sourceMapAndLineLengths) {
-    return {}
-  }
-
-  const { data, lineLengths } = sourceMapAndLineLengths
-  // See: https://github.com/nodejs/node/pull/34305
-  if (!data) {
-    return undefined
-  }
-
-  const sources = {
-    sourcemap: data,
-    ...(lineLengths ? { source: sourcesFromLineLengths(lineLengths) } : {}),
-  }
-  return sources
-}
-
-const sourcesFromLineLengths = (lineLengths) => {
-  let source = ""
-  lineLengths.forEach((length) => {
-    source += `${"".padEnd(length, ".")}\n`
-  })
-  return source
-}

package/src/internal/executing/createSummaryLog.js

@@ -1,143 +0,0 @@
-import { ANSI } from "@jsenv/log"
-
-import { msAsDuration } from "../logs/msAsDuration.js"
-import { formatByte } from "../logs/byte.js"
-import { EXECUTION_COLORS } from "./execution_colors.js"
-
-export const createSummaryLog = (
-  summary,
-) => `-------------- summary -----------------
-${createAllExecutionsSummary(summary)}
-total duration: ${msAsDuration(summary.duration)}
-----------------------------------------`
-
-const createAllExecutionsSummary = ({
-  executionCount,
-  abortedCount,
-  timedoutCount,
-  erroredCount,
-  completedCount,
-  cancelledCount,
-}) => {
-  if (executionCount === 0) {
-    return `no execution`
-  }
-
-  const executionLabel =
-    executionCount === 1 ? `1 execution` : `${executionCount} executions`
-  return `${executionLabel}: ${createStatusSummary({
-    executionCount,
-    abortedCount,
-    timedoutCount,
-    erroredCount,
-    completedCount,
-    cancelledCount,
-  })}`
-}
-
-export const createIntermediateSummary = ({
-  executionCount,
-  abortedCount,
-  timedoutCount,
-  erroredCount,
-  completedCount,
-  cancelledCount,
-  memoryHeap,
-}) => {
-  let intermediateSummary = createStatusSummary({
-    executionCount,
-    abortedCount,
-    timedoutCount,
-    erroredCount,
-    completedCount,
-    cancelledCount,
-  })
-
-  if (memoryHeap) {
-    intermediateSummary += ` / memory heap: ${formatByte(memoryHeap)}`
-  }
-
-  return intermediateSummary
-}
-
-const createStatusSummary = ({
-  executionCount,
-  abortedCount,
-  timedoutCount,
-  erroredCount,
-  completedCount,
-  cancelledCount,
-}) => {
-  if (abortedCount === executionCount) {
-    return `all ${ANSI.color(`aborted`, EXECUTION_COLORS.aborted)}`
-  }
-  if (timedoutCount === executionCount) {
-    return `all ${ANSI.color(`timed out`, EXECUTION_COLORS.timedout)}`
-  }
-  if (erroredCount === executionCount) {
-    return `all ${ANSI.color(`errored`, EXECUTION_COLORS.errored)}`
-  }
-  if (completedCount === executionCount) {
-    return `all ${ANSI.color(`completed`, EXECUTION_COLORS.completed)}`
-  }
-  if (cancelledCount === executionCount) {
-    return `all ${ANSI.color(`cancelled`, EXECUTION_COLORS.cancelled)}`
-  }
-
-  return createMixedDetails({
-    executionCount,
-    abortedCount,
-    timedoutCount,
-    erroredCount,
-    completedCount,
-    cancelledCount,
-  })
-}
-
-const createMixedDetails = ({
-  abortedCount,
-  timedoutCount,
-  erroredCount,
-  completedCount,
-  cancelledCount,
-}) => {
-  const parts = []
-
-  if (timedoutCount) {
-    parts.push(
-      `${timedoutCount} ${ANSI.color(`timed out`, EXECUTION_COLORS.timedout)}`,
-    )
-  }
-
-  if (erroredCount) {
-    parts.push(
-      `${erroredCount} ${ANSI.color(`errored`, EXECUTION_COLORS.errored)}`,
-    )
-  }
-
-  if (completedCount) {
-    parts.push(
-      `${completedCount} ${ANSI.color(
-        `completed`,
-        EXECUTION_COLORS.completed,
-      )}`,
-    )
-  }
-
-  if (abortedCount) {
-    parts.push(
-      `${abortedCount} ${ANSI.color(`aborted`, EXECUTION_COLORS.aborted)}`,
-    )
-  }
-
-  if (cancelledCount) {
-    parts.push(
-      `${cancelledCount} ${ANSI.color(
-        `cancelled`,
-        EXECUTION_COLORS.cancelled,
-      )}`,
-    )
-  }
-
-  return `${parts.join(", ")}`
-}

package/src/internal/executing/executionIsPassed.js

@@ -1,2 +0,0 @@
-export const executionIsPassed = ({ planSummary }) =>
-  planSummary.executionCount === planSummary.completedCount