@jsenv/core 23.2.2 → 23.4.2

package/src/abort/callback_list.js

@@ -1,64 +0,0 @@
-export const createCallbackList = () => {
-  let callbacks = []
-
-  const add = (callback) => {
-    if (typeof callback !== "function") {
-      throw new Error(`callback must be a function, got ${callback}`)
-    }
-
-    // don't register twice
-    const existingCallback = callbacks.find((callbackCandidate) => {
-      return callbackCandidate === callback
-    })
-    if (existingCallback) {
-      if (typeof process.emitWarning === "object") {
-        process.emitWarning(`Trying to register same callback twice`, {
-          CODE: "CALLBACK_DUPLICATION",
-          detail: `It's often the sign that code is executd more than once`,
-        })
-      } else {
-        console.warn(`Trying to add same callback twice`)
-      }
-    } else {
-      callbacks = [...callbacks, callback]
-    }
-
-    return () => {
-      remove(callback)
-    }
-  }
-
-  const remove = (callback) => {
-    callbacks = arrayWithout(callbacks, callback)
-  }
-
-  const clear = () => {
-    callbacks = []
-  }
-
-  const copy = () => {
-    return callbacks.slice()
-  }
-
-  return {
-    add,
-    remove,
-    clear,
-    copy,
-  }
-}
-
-const arrayWithout = (array, item) => {
-  if (array.length === 0) return array
-  const arrayWithoutItem = []
-  let i = 0
-  while (i < array.length) {
-    const value = array[i]
-    i++
-    if (value === item) {
-      continue
-    }
-    arrayWithoutItem.push(value)
-  }
-  return arrayWithoutItem
-}

package/src/abort/callback_race.js

@@ -1,34 +0,0 @@
-/*
- * See callback_race.md
- */
-
-export const raceCallbacks = (raceDescription, winnerCallback) => {
-  const cleanCallbacks = []
-  let done = false
-
-  const cleanup = () => {
-    const cleanCallbacksCopy = cleanCallbacks.slice()
-    cleanCallbacks.length = 0
-    cleanCallbacksCopy.forEach((clean) => {
-      clean()
-    })
-  }
-
-  Object.keys(raceDescription).forEach((candidateName) => {
-    const register = raceDescription[candidateName]
-    const returnValue = register((data) => {
-      if (done) return
-      done = true
-      cleanup()
-      winnerCallback({
-        name: candidateName,
-        data,
-      })
-    })
-    if (typeof returnValue === "function") {
-      cleanCallbacks.push(returnValue)
-    }
-  })
-
-  return cleanup
-}

package/src/abort/cleaner.js

@@ -1,22 +0,0 @@
-import { createCallbackList } from "./callback_list.js"
-
-export const createCleaner = () => {
-  const callbackList = createCallbackList()
-
-  const addCallback = (callback) => {
-    return callbackList.add(callback)
-  }
-
-  const clean = async (reason) => {
-    const callbacks = callbackList.copy()
-    callbackList.clear()
-
-    await Promise.all(
-      callbacks.map(async (callback) => {
-        await callback(reason)
-      }),
-    )
-  }
-
-  return { addCallback, clean }
-}

package/src/abort/main.js

@@ -1,32 +0,0 @@
-/*
- * When starting an http server there is two distinct things
- * that code may want to do:
- * 1. Abort the server while it's starting
- * 2. Stop server onces its started
- *
- * This can be achieved with the following code where
- * server is aborted if it takes more than 1s to start
- * and immediatly stopped once started
- *
- * const abortController = new AbortController()
- * setTimeout(() => { abortController.abort() }, 1000)
- * const server = await startServer({
- *   abortSignal: abortController.signal
- * })
- * await server.stop()
- *
- * In order to implement this kind of API two helpers are exported
- * here:
- * 1. "Abort" which can be used to throw an abort error
- *   while server is starting
- * 2. "Cleanup" which can be used to track how to cleanup all the things
- *   done to start the server
- *
- * Same concepts could be reused when spwaning a child process, a worker, etc..
- *
- */
-
-export { Abortable } from "./abortable.js"
-
-// when will be a package this should be a Node.js export only
-export { raceProcessTeardownEvents } from "./process_teardown_events.js"

package/src/abort/process_teardown_events.js

@@ -1,59 +0,0 @@
-import { raceCallbacks } from "./callback_race.js"
-
-export const raceProcessTeardownEvents = (processTeardownEvents, callback) => {
-  return raceCallbacks(
-    {
-      ...(processTeardownEvents.SIGHUP ? SIGHUP_CALLBACK : {}),
-      ...(processTeardownEvents.SIGTERM ? SIGTERM_CALLBACK : {}),
-      ...(processTeardownEvents.SIGINT ? SIGINT_CALLBACK : {}),
-      ...(processTeardownEvents.beforeExit ? BEFORE_EXIT_CALLBACK : {}),
-      ...(processTeardownEvents.exit ? EXIT_CALLBACK : {}),
-    },
-    callback,
-  )
-}
-
-const SIGHUP_CALLBACK = {
-  SIGHUP: (cb) => {
-    process.on("SIGHUP", cb)
-    return () => {
-      process.removeListener("SIGHUP", cb)
-    }
-  },
-}
-
-const SIGTERM_CALLBACK = {
-  SIGTERM: (cb) => {
-    process.on("SIGTERM", cb)
-    return () => {
-      process.removeListener("SIGTERM", cb)
-    }
-  },
-}
-
-const BEFORE_EXIT_CALLBACK = {
-  beforeExit: (cb) => {
-    process.on("beforeExit", cb)
-    return () => {
-      process.removeListener("beforeExit", cb)
-    }
-  },
-}
-
-const EXIT_CALLBACK = {
-  exit: (cb) => {
-    process.on("exit", cb)
-    return () => {
-      process.removeListener("exit", cb)
-    }
-  },
-}
-
-const SIGINT_CALLBACK = {
-  SIGINT: (cb) => {
-    process.on("SIGINT", cb)
-    return () => {
-      process.removeListener("SIGINT", cb)
-    }
-  },
-}

package/src/internal/createCallbackList.js

@@ -1,21 +0,0 @@
-export const createCallbackList = () => {
-  const callbackSet = new Set()
-
-  const register = (callback) => {
-    callbackSet.add(callback)
-    return () => {
-      callbackSet.delete(callback)
-    }
-  }
-
-  const notify = (...args) => {
-    callbackSet.forEach((callback) => {
-      callback(...args)
-    })
-  }
-
-  return {
-    register,
-    notify,
-  }
-}

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

@@ -1,108 +0,0 @@
-import { require } from "../../require.js"
-
-// https://github.com/istanbuljs/istanbuljs/blob/5405550c3868712b14fd8bfe0cbd6f2e7ac42279/packages/istanbul-lib-coverage/lib/coverage-map.js#L43
-export const composeIstanbulCoverages = (
-  istanbulCoverages,
-  { coverageV8MergeConflictIsExpected = false } = {},
-) => {
-  const coverageComposed = {}
-
-  // we can't merge coverage coming from code instrumented by istanbul
-  // with coverage coming from v8 and converted to istanbul, so we want to:
-  // 1. Have istanbul and v8 as long as they don't cover the same file
-  // 2. Choose istanbul or v8 depending which one cover the most
-  // To do that we first merge all v8 together and istanbul together
-  // To be able to know which one covers the most in case of merge conflict
-  const coverageFromV8Conversion = {}
-  const coverageFromIstanbul = {}
-  istanbulCoverages.forEach((istanbulCoverage) => {
-    Object.keys(istanbulCoverage).forEach((key) => {
-      const istanbulFileCoverage = istanbulCoverage[key]
-      if (istanbulFileCoverage.fromV8) {
-        const existingCoverageForFile = coverageFromV8Conversion[key]
-        if (existingCoverageForFile) {
-          coverageFromV8Conversion[key] = merge(existingCoverageForFile, istanbulFileCoverage)
-        } else {
-          coverageFromV8Conversion[key] = istanbulFileCoverage
-        }
-      } else {
-        const existingCoverageForFile = coverageFromIstanbul[key]
-        if (existingCoverageForFile) {
-          coverageFromIstanbul[key] = merge(existingCoverageForFile, istanbulFileCoverage)
-        } else {
-          coverageFromIstanbul[key] = istanbulFileCoverage
-        }
-      }
-    })
-  })
-
-  Object.keys(coverageFromV8Conversion).forEach((key) => {
-    const fileCoverageFromV8 = coverageFromV8Conversion[key]
-    const fileCoverageFromIstanbul = coverageFromIstanbul[key]
-    if (fileCoverageFromIstanbul) {
-      const v8HitCount = hitCountFromFileCoverage(fileCoverageFromV8)
-      const istanbulHitCount = hitCountFromFileCoverage(fileCoverageFromIstanbul)
-      const coverageWithMostHit =
-        v8HitCount >= istanbulHitCount ? fileCoverageFromV8 : fileCoverageFromIstanbul
-
-      if (!coverageV8MergeConflictIsExpected) {
-        // ideally when coverageV8MergeConflictIsExpected it would be a console.debug
-        console.warn(
-          formatMergeConflictBetweenV8AndIstanbulWarning({
-            fileRelativeUrl: key,
-            coverageKept: coverageWithMostHit,
-          }),
-        )
-      }
-      coverageComposed[key] = coverageWithMostHit
-    } else {
-      coverageComposed[key] = fileCoverageFromV8
-    }
-  })
-
-  Object.keys(coverageFromIstanbul).forEach((key) => {
-    const fileCoverageFromIstanbul = coverageFromIstanbul[key]
-    const fileCoverageFromV8 = coverageFromV8Conversion[key]
-    if (fileCoverageFromV8) {
-      // already handled
-    } else {
-      coverageComposed[key] = fileCoverageFromIstanbul
-    }
-  })
-
-  return coverageComposed
-}
-
-const hitCountFromFileCoverage = ({ b, s }) => {
-  const statementHitCount = Object.keys(s).reduce((previous, key) => {
-    return previous + s[key]
-  }, 0)
-
-  const branchHitCount = Object.keys(b).reduce((previous, key) => {
-    const branchCount = b[key].reduce((previous, count) => {
-      return previous + count
-    }, 0)
-    return previous + branchCount
-  }, 0)
-
-  return statementHitCount + branchHitCount
-}
-
-const merge = (istanbulFileCoverageA, istanbulFileCoverageB) => {
-  const { createFileCoverage } = require("istanbul-lib-coverage")
-  const istanbulFileCoverageObject = createFileCoverage(istanbulFileCoverageA)
-  istanbulFileCoverageObject.merge(istanbulFileCoverageB)
-  return istanbulFileCoverageObject.toJSON()
-}
-
-const formatMergeConflictBetweenV8AndIstanbulWarning = ({ fileRelativeUrl, coverageKept }) => {
-  return `Cannot merge file coverage coming from v8 and istanbul.
-The one with most branch coverage will be kept and the other ignored.
---- coverage kept ---
-${coverageKept.fromV8 ? "v8" : "istanbul"}
---- file ---
-${fileRelativeUrl}
---- suggestion ---
-If this is expected use coverageV8MergeConflictIsExpected to disable this warning
-`
-}

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

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

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

@@ -1,43 +0,0 @@
-/**
- *
- * The goal is to get an istanbul coverage from a list of coverage that are either
- * v8Coverage or istanbul coverage
- *
- */
-
-import { composeV8Coverages } from "./composeV8Coverages.js"
-import { composeIstanbulCoverages } from "./composeIstanbulCoverages.js"
-import { istanbulCoverageFromV8Coverage } from "./istanbulCoverageFromV8Coverage.js"
-import { normalizeIstanbulCoverage } from "./normalizeIstanbulCoverage.js"
-
-export const istanbulCoverageFromCoverages = async (
-  coverages,
-  { projectDirectoryUrl, coverageV8MergeConflictIsExpected },
-) => {
-  const v8Coverages = []
-  const istanbulCoverages = []
-
-  coverages.forEach((coverage) => {
-    if (coverage.result) {
-      v8Coverages.push(coverage)
-    } else {
-      istanbulCoverages.push(normalizeIstanbulCoverage(coverage, projectDirectoryUrl))
-    }
-  })
-
-  const v8CoverageComposed = composeV8Coverages(v8Coverages)
-  const istanbulCoverageComposed = composeIstanbulCoverages(istanbulCoverages)
-  const istanbulCoverageFromV8CoverageComposed = await istanbulCoverageFromV8Coverage(
-    v8CoverageComposed,
-  )
-  const istanbulCoverage = composeIstanbulCoverages(
-    [
-      istanbulCoverageComposed,
-      normalizeIstanbulCoverage(istanbulCoverageFromV8CoverageComposed, projectDirectoryUrl),
-    ],
-    {
-      coverageV8MergeConflictIsExpected,
-    },
-  )
-  return istanbulCoverage
-}

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

@@ -1,79 +0,0 @@
-import { urlToFileSystemPath } from "@jsenv/filesystem"
-
-import { require } from "@jsenv/core/src/internal/require.js"
-
-import { composeIstanbulCoverages } from "./composeIstanbulCoverages.js"
-
-export const istanbulCoverageFromV8Coverage = async (v8Coverage) => {
-  const v8ToIstanbul = require("v8-to-istanbul")
-  const sourcemapCache = v8Coverage["source-map-cache"]
-  const istanbulCoverages = await Promise.all(
-    v8Coverage.result.map(async (fileV8Coverage) => {
-      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()
-      return istanbulCoverage
-    }),
-  )
-
-  const istanbulCoverageComposed = composeIstanbulCoverages(istanbulCoverages)
-  return markCoverageAsConverted(istanbulCoverageComposed)
-}
-
-const markCoverageAsConverted = (istanbulCoverage) => {
-  const istanbulCoverageMarked = {}
-  Object.keys(istanbulCoverage).forEach((key) => {
-    istanbulCoverageMarked[key] = {
-      ...istanbulCoverage[key],
-      fromV8: true,
-    }
-  })
-  return istanbulCoverageMarked
-}
-
-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/coverage/v8CoverageFromAllV8Coverages.js

@@ -1,40 +0,0 @@
-import { resolveUrl, normalizeStructuredMetaMap, urlToMeta } from "@jsenv/filesystem"
-
-import { composeV8Coverages } from "./composeV8Coverages.js"
-
-export const v8CoverageFromAllV8Coverages = (
-  allV8Coverages,
-  { coverageRootUrl, coverageConfig },
-) => {
-  const v8Coverages = filterCoverageReports(allV8Coverages, {
-    coverageRootUrl,
-    coverageConfig,
-  })
-
-  const v8Coverage = composeV8Coverages(v8Coverages)
-  return v8Coverage
-}
-
-const filterCoverageReports = (coverageReports, { coverageRootUrl, coverageConfig }) => {
-  const structuredMetaMapForCover = normalizeStructuredMetaMap(
-    {
-      cover: coverageConfig,
-    },
-    coverageRootUrl,
-  )
-  const shouldIgnoreCoverage = (url) => {
-    return !urlToMeta({
-      url: resolveUrl(url, coverageRootUrl),
-      structuredMetaMap: structuredMetaMapForCover,
-    }).cover
-  }
-
-  return coverageReports.map((coverageReport) => {
-    return {
-      ...coverageReport,
-      result: coverageReport.result.filter((fileReport) => {
-        return !shouldIgnoreCoverage(fileReport.url)
-      }),
-    }
-  })
-}

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

@@ -1,67 +0,0 @@
-import {
-  assertAndNormalizeDirectoryUrl,
-  readDirectory,
-  readFile,
-  resolveUrl,
-} from "@jsenv/filesystem"
-import { createDetailedMessage } from "@jsenv/logger"
-
-import { v8CoverageFromAllV8Coverages } from "./v8CoverageFromAllV8Coverages.js"
-
-export const v8CoverageFromNodeV8Directory = async ({
-  projectDirectoryUrl,
-  NODE_V8_COVERAGE,
-  coverageConfig,
-}) => {
-  const allV8Coverages = await readV8CoverageReportsFromDirectory(
-    NODE_V8_COVERAGE,
-  )
-
-  const v8Coverage = v8CoverageFromAllV8Coverages(allV8Coverages, {
-    coverageRootUrl: projectDirectoryUrl,
-    coverageConfig,
-  })
-
-  return v8Coverage
-}
-
-const readV8CoverageReportsFromDirectory = async (coverageDirectory) => {
-  const tryReadDirectory = async () => {
-    const dirContent = await readDirectory(coverageDirectory)
-    if (dirContent.length > 0) {
-      return dirContent
-    }
-    console.warn(`v8 coverage directory is empty at ${coverageDirectory}`)
-    return dirContent
-  }
-  const dirContent = await tryReadDirectory()
-
-  const coverageReports = []
-  const coverageDirectoryUrl = assertAndNormalizeDirectoryUrl(coverageDirectory)
-  await Promise.all(
-    dirContent.map(async (dirEntry) => {
-      const dirEntryUrl = resolveUrl(dirEntry, coverageDirectoryUrl)
-      const tryReadJsonFile = async () => {
-        try {
-          const fileContent = await readFile(dirEntryUrl, { as: "json" })
-          return fileContent
-        } catch (e) {
-          console.warn(
-            createDetailedMessage(`Error while reading coverage file`, {
-              "error stack": e.stack,
-              "file": dirEntryUrl,
-            }),
-          )
-          return null
-        }
-      }
-
-      const fileContent = await tryReadJsonFile()
-      if (fileContent) {
-        coverageReports.push(fileContent)
-      }
-    }),
-  )
-
-  return coverageReports
-}

package/src/internal/executing/logUtils.js

@@ -1,30 +0,0 @@
-// https://github.com/yarnpkg/yarn/blob/master/src/reporters/console/util.js
-// https://github.com/yarnpkg/yarn/blob/master/src/reporters/console/progress-bar.js
-// https://github.com/sindresorhus/log-update/blob/master/index.js
-// see https://github.com/jsenv/jsenv-core/issues/59
-import readline from "node:readline"
-import tty from "node:tty"
-
-import { createSupportsColor } from "supports-color"
-
-const CLEAR_WHOLE_LINE = 0
-
-export const clearLine = (stdout = process.stdout) => {
-  if (createSupportsColor(stdout)) {
-    readline.clearLine(stdout, CLEAR_WHOLE_LINE)
-    readline.cursorTo(stdout, 0)
-  } else if (stdout instanceof tty.WriteStream) {
-    if (stdout.columns > 0) {
-      stdout.write(`\r${" ".repeat(stdout.columns - 1)}`)
-    }
-    stdout.write(`\r`)
-  }
-}
-
-export const toStartOfLine = (stdout = process.stdout) => {
-  if (createSupportsColor(stdout)) {
-    readline.cursorTo(stdout, 0)
-  } else {
-    stdout.write("\r")
-  }
-}