@jsenv/core 26.0.1 → 27.0.0-alpha.2

package/src/internal/coverage/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)
-}

package/src/internal/coverage/missing_coverage.js

@@ -1,46 +0,0 @@
-import { Abort } from "@jsenv/abort"
-
-import { listRelativeFileUrlToCover } from "./list_files_not_covered.js"
-import { relativeUrlToEmptyCoverage } from "./empty_coverage_factory.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/coverage/report_to_coverage.js

@@ -1,198 +0,0 @@
-import { readFile } from "@jsenv/filesystem"
-import { Abort } from "@jsenv/abort"
-
-import {
-  visitNodeV8Directory,
-  filterV8Coverage,
-} from "./v8_coverage_from_directory.js"
-import { composeTwoV8Coverages } from "./v8_coverage_composition.js"
-import { composeTwoFileByFileIstanbulCoverages } from "./istanbul_coverage_composition.js"
-import { v8CoverageToIstanbul } from "./v8_coverage_to_istanbul.js"
-import { composeV8AndIstanbul } from "./v8_and_istanbul.js"
-import { normalizeFileByFileCoveragePaths } from "./file_by_file_coverage.js"
-import { getMissingFileByFileCoverage } from "./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/coverage/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/coverage/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/coverage/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/coverage/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/data_url.js

@@ -1,54 +0,0 @@
-/* eslint-env browser, node */
-
-export const DataUrl = {
-  parse: (string, { as = "raw" } = {}) => {
-    const afterDataProtocol = string.slice("data:".length)
-    const commaIndex = afterDataProtocol.indexOf(",")
-    const beforeComma = afterDataProtocol.slice(0, commaIndex)
-
-    let mediaType
-    let base64Flag
-    if (beforeComma.endsWith(`;base64`)) {
-      mediaType = beforeComma.slice(0, -`;base64`.length)
-      base64Flag = true
-    } else {
-      mediaType = beforeComma
-      base64Flag = false
-    }
-
-    const afterComma = afterDataProtocol.slice(commaIndex + 1)
-    return {
-      mediaType: mediaType === "" ? "text/plain;charset=US-ASCII" : mediaType,
-      base64Flag,
-      data:
-        as === "string" && base64Flag ? base64ToString(afterComma) : afterComma,
-    }
-  },
-
-  stringify: ({ mediaType, base64Flag = true, data }) => {
-    if (!mediaType || mediaType === "text/plain;charset=US-ASCII") {
-      // can be a buffer or a string, hence check on data.length instead of !data or data === ''
-      if (data.length === 0) {
-        return `data:,`
-      }
-      if (base64Flag) {
-        return `data:,${data}`
-      }
-      return `data:,${dataToBase64(data)}`
-    }
-    if (base64Flag) {
-      return `data:${mediaType};base64,${dataToBase64(data)}`
-    }
-    return `data:${mediaType},${data}`
-  },
-}
-
-const dataToBase64 =
-  typeof window === "object"
-    ? window.atob
-    : (data) => Buffer.from(data).toString("base64")
-
-const base64ToString =
-  typeof window === "object"
-    ? window.btoa
-    : (base64String) => Buffer.from(base64String, "base64").toString("utf8")

package/src/internal/dev_server/event_source_client/event_source_client.js

@@ -1,63 +0,0 @@
-/* eslint-env browser */
-
-import { createEventSourceConnection } from "./event_source_connection.js"
-import {
-  getFileChanges,
-  addFileChange,
-  setFileChangeCallback,
-  reloadIfNeeded,
-} from "./file_changes.js"
-import {
-  isLivereloadEnabled,
-  setLivereloadPreference,
-} from "./livereload_preference.js"
-
-const eventsourceConnection = createEventSourceConnection(
-  document.location.href,
-  {
-    "file-added": ({ data }) => {
-      addFileChange({
-        file: data,
-        eventType: "added",
-      })
-    },
-    "file-modified": ({ data }) => {
-      addFileChange({
-        file: data,
-        eventType: "modified",
-      })
-    },
-    "file-removed": ({ data }) => {
-      addFileChange({
-        file: data,
-        eventType: "removed",
-      })
-    },
-  },
-  {
-    retryMaxAttempt: Infinity,
-    retryAllocatedMs: 20 * 1000,
-  },
-)
-
-const {
-  connect,
-  disconnect,
-  setConnectionStatusChangeCallback,
-  getConnectionStatus,
-} = eventsourceConnection
-
-connect()
-
-window.__jsenv_event_source_client__ = {
-  connect,
-  disconnect,
-  getConnectionStatus,
-  setConnectionStatusChangeCallback,
-  getFileChanges,
-  addFileChange,
-  setFileChangeCallback,
-  reloadIfNeeded,
-  isLivereloadEnabled,
-  setLivereloadPreference,
-}