@jsenv/core 23.6.2 → 23.7.0

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

@@ -1,90 +1,90 @@
-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 ""
-}
+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,187 +1,187 @@
-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") {
-        logger.debug(
-          `No execution.coverageFileUrl from execution named "${executionName}" of ${file}`,
-        )
-      }
-    },
-  })
-
-  if (!coverageForceIstanbul && process.env.NODE_V8_COVERAGE) {
-    await visitNodeV8Directory({
-      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, missingFileByFileCoverage)
-  }
-
-  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)
+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") {
+        logger.debug(
+          `No execution.coverageFileUrl from execution named "${executionName}" of ${file}`,
+        )
+      }
+    },
+  })
+
+  if (!coverageForceIstanbul && process.env.NODE_V8_COVERAGE) {
+    await visitNodeV8Directory({
+      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, missingFileByFileCoverage)
+  }
+
+  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)