@jsenv/core 34.3.0 → 35.0.0

package/src/execute/runtimes/node/node_worker_thread.js

@@ -1,295 +0,0 @@
-// https://github.com/avajs/ava/blob/576f534b345259055c95fa0c2b33bef10847a2af/lib/fork.js#L23
-// https://nodejs.org/api/worker_threads.html
-// https://github.com/avajs/ava/blob/576f534b345259055c95fa0c2b33bef10847a2af/lib/worker/base.js
-import { Worker } from "node:worker_threads"
-import { fileURLToPath } from "node:url"
-import {
-  Abort,
-  createCallbackListNotifiedOnce,
-  raceCallbacks,
-} from "@jsenv/abort"
-import { memoize } from "@jsenv/utils/src/memoize/memoize.js"
-
-import { createChildExecOptions } from "./child_exec_options.js"
-import { ExecOptions } from "./exec_options.js"
-import { EXIT_CODES } from "./exit_codes.js"
-import { IMPORTMAP_NODE_LOADER_FILE_URL } from "./importmap_node_loader_file_url.js"
-import { NO_EXPERIMENTAL_WARNING_FILE_URL } from "./no_experimental_warnings_file_url.js"
-
-const CONTROLLABLE_WORKER_THREAD_URL = new URL(
-  "./controllable_worker_thread.mjs?entry_point",
-  import.meta.url,
-).href
-
-export const nodeWorkerThread = {
-  type: "node",
-  name: "node_worker_thread",
-  version: process.version.slice(1),
-}
-
-nodeWorkerThread.run = async ({
-  signal = new AbortController().signal,
-  // logger,
-  rootDirectoryUrl,
-  fileRelativeUrl,
-  importMap,
-
-  keepRunning,
-  stopSignal,
-  onConsole,
-
-  collectConsole = false,
-  collectPerformance,
-  coverageEnabled = false,
-  coverageConfig,
-  coverageMethodForNodeJs,
-  coverageFileUrl,
-
-  env,
-  debugPort,
-  debugMode,
-  debugModeInheritBreak,
-  inheritProcessEnv = true,
-  commandLineOptions = [],
-}) => {
-  if (env !== undefined && typeof env !== "object") {
-    throw new TypeError(`env must be an object, got ${env}`)
-  }
-  env = {
-    ...env,
-    JSENV: true,
-  }
-  if (coverageMethodForNodeJs !== "NODE_V8_COVERAGE") {
-    env.NODE_V8_COVERAGE = ""
-  }
-  if (importMap) {
-    env.IMPORT_MAP = JSON.stringify(importMap)
-    env.IMPORT_MAP_BASE_URL = rootDirectoryUrl
-    commandLineOptions.push(
-      `--experimental-loader=${fileURLToPath(IMPORTMAP_NODE_LOADER_FILE_URL)}`,
-    )
-    commandLineOptions.push(
-      `--require=${fileURLToPath(NO_EXPERIMENTAL_WARNING_FILE_URL)}`,
-    )
-  }
-
-  const workerThreadExecOptions = await createChildExecOptions({
-    signal,
-    debugPort,
-    debugMode,
-    debugModeInheritBreak,
-  })
-  const execArgvForWorkerThread = ExecOptions.toExecArgv({
-    ...workerThreadExecOptions,
-    ...ExecOptions.fromExecArgv(commandLineOptions),
-  })
-  const envForWorkerThread = {
-    ...(inheritProcessEnv ? process.env : {}),
-    ...env,
-  }
-
-  const cleanupCallbackList = createCallbackListNotifiedOnce()
-  const cleanup = async (reason) => {
-    await cleanupCallbackList.notify({ reason })
-  }
-  const actionOperation = Abort.startOperation()
-  actionOperation.addAbortSignal(signal)
-  // https://nodejs.org/api/worker_threads.html#new-workerfilename-options
-  const workerThread = new Worker(
-    fileURLToPath(CONTROLLABLE_WORKER_THREAD_URL),
-    {
-      env: envForWorkerThread,
-      execArgv: execArgvForWorkerThread,
-      // workerData: { options },
-      stdin: true,
-      stdout: true,
-      stderr: true,
-    },
-  )
-  const removeOutputListener = installWorkerThreadOutputListener(
-    workerThread,
-    ({ type, text }) => {
-      onConsole({ type, text })
-    },
-  )
-  const workerThreadReadyPromise = new Promise((resolve) => {
-    onceWorkerThreadMessage(workerThread, "ready", resolve)
-  })
-
-  const stop = memoize(async () => {
-    // read all stdout before terminating
-    // (no need for stderr because it's sync)
-    if (collectConsole) {
-      while (workerThread.stdout.read() !== null) {}
-      await new Promise((resolve) => {
-        setTimeout(resolve, 50)
-      })
-    }
-    await workerThread.terminate()
-  })
-
-  const winnerPromise = new Promise((resolve) => {
-    raceCallbacks(
-      {
-        aborted: (cb) => {
-          return actionOperation.addAbortCallback(cb)
-        },
-        error: (cb) => {
-          return onceWorkerThreadEvent(workerThread, "error", cb)
-        },
-        exit: (cb) => {
-          return onceWorkerThreadEvent(workerThread, "exit", (code, signal) => {
-            cb({ code, signal })
-          })
-        },
-        response: (cb) => {
-          return onceWorkerThreadMessage(workerThread, "action-result", cb)
-        },
-      },
-      resolve,
-    )
-  })
-
-  const result = {
-    status: "executing",
-    errors: [],
-    namespace: null,
-  }
-
-  const writeResult = async () => {
-    actionOperation.throwIfAborted()
-    await workerThreadReadyPromise
-    actionOperation.throwIfAborted()
-    await sendToWorkerThread(workerThread, {
-      type: "action",
-      data: {
-        actionType: "execute-using-dynamic-import",
-        actionParams: {
-          rootDirectoryUrl,
-          fileUrl: new URL(fileRelativeUrl, rootDirectoryUrl).href,
-          collectPerformance,
-          coverageEnabled,
-          coverageConfig,
-          coverageMethodForNodeJs,
-          coverageFileUrl,
-          exitAfterAction: true,
-        },
-      },
-    })
-    const winner = await winnerPromise
-    if (winner.name === "aborted") {
-      result.status = "aborted"
-      return
-    }
-    if (winner.name === "error") {
-      const error = winner.data
-      removeOutputListener()
-      result.status = "failed"
-      result.errors.push(error)
-      return
-    }
-    if (winner.name === "exit") {
-      const { code } = winner.data
-      await cleanup("process exit")
-      if (code === 12) {
-        result.status = "failed"
-        result.errors.push(
-          new Error(
-            `node process exited with 12 (the forked child process wanted to use a non-available port for debug)`,
-          ),
-        )
-        return
-      }
-      if (
-        code === null ||
-        code === 0 ||
-        code === EXIT_CODES.SIGINT ||
-        code === EXIT_CODES.SIGTERM ||
-        code === EXIT_CODES.SIGABORT
-      ) {
-        result.status = "failed"
-        result.errors.push(
-          new Error(`node worker thread exited during execution`),
-        )
-        return
-      }
-      // process.exit(1) in child process or process.exitCode = 1 + process.exit()
-      // means there was an error even if we don't know exactly what.
-      result.status = "failed"
-      result.errors.push(
-        new Error(
-          `node worker thread exited with code ${code} during execution`,
-        ),
-      )
-    }
-    const { status, value } = winner.data
-    if (status === "action-failed") {
-      result.status = "failed"
-      result.errors.push(value)
-      return
-    }
-    const { namespace, performance, coverage } = value
-    result.status = "completed"
-    result.namespace = namespace
-    result.performance = performance
-    result.coverage = coverage
-  }
-
-  try {
-    await writeResult()
-  } catch (e) {
-    result.status = "failed"
-    result.errors.push(e)
-  }
-
-  if (keepRunning) {
-    stopSignal.notify = stop
-  } else {
-    await stop()
-  }
-  await actionOperation.end()
-  return result
-}
-
-const installWorkerThreadOutputListener = (workerThread, callback) => {
-  // beware that we may receive ansi output here, should not be a problem but keep that in mind
-  const stdoutDataCallback = (chunk) => {
-    const text = String(chunk)
-    callback({ type: "log", text })
-  }
-  workerThread.stdout.on("data", stdoutDataCallback)
-  const stdErrorDataCallback = (chunk) => {
-    const text = String(chunk)
-    callback({ type: "error", text })
-  }
-  workerThread.stderr.on("data", stdErrorDataCallback)
-  return () => {
-    workerThread.stdout.removeListener("data", stdoutDataCallback)
-    workerThread.stderr.removeListener("data", stdErrorDataCallback)
-  }
-}
-
-const sendToWorkerThread = (worker, { type, data }) => {
-  worker.postMessage({ jsenv: true, type, data })
-}
-
-const onceWorkerThreadMessage = (workerThread, type, callback) => {
-  const onmessage = (message) => {
-    if (message && message.jsenv && message.type === type) {
-      workerThread.removeListener("message", onmessage)
-      // eslint-disable-next-line no-eval
-      callback(message.data ? eval(`(${message.data})`) : undefined)
-    }
-  }
-  workerThread.on("message", onmessage)
-  return () => {
-    workerThread.removeListener("message", onmessage)
-  }
-}
-
-const onceWorkerThreadEvent = (worker, type, callback) => {
-  worker.once(type, callback)
-  return () => {
-    worker.removeListener(type, callback)
-  }
-}

package/src/execute/runtimes/node/profiler_v8_coverage.js

@@ -1,56 +0,0 @@
-/*
- * Calling Profiler.startPreciseCoverage DO NOT propagate to
- * subprocesses (new Worker or child_process.fork())
- * So the best solution remains NODE_V8_COVERAGE
- * This profiler strategy remains useful when:
- * - As fallback when NODE_V8_COVERAGE is not configured
- * - If explicitely enabled with coverageMethodForNodeJs: 'Profiler'
- *   - Used by jsenv during automated tests about coverage
- *   - Anyone prefering this approach over NODE_V8_COVERAGE and assuming
- *     it will not fork subprocess or don't care if coverage is missed for this code
- * - https://v8.dev/blog/javascript-code-coverage#for-embedders
- * - https://github.com/nodejs/node/issues/28283
- * - https://vanilla.aslushnikov.com/?Profiler.startPreciseCoverage
- */
-
-import { Session } from "node:inspector"
-
-export const startJsCoverage = async ({
-  callCount = true,
-  detailed = true,
-} = {}) => {
-  const session = new Session()
-  session.connect()
-  const postSession = (action, options) => {
-    const promise = new Promise((resolve, reject) => {
-      session.post(action, options, (error, data) => {
-        if (error) {
-          reject(error)
-        } else {
-          resolve(data)
-        }
-      })
-    })
-    return promise
-  }
-
-  await postSession("Profiler.enable")
-  await postSession("Profiler.startPreciseCoverage", { callCount, detailed })
-
-  const takeJsCoverage = async () => {
-    const coverage = await postSession("Profiler.takePreciseCoverage")
-    return coverage
-  }
-
-  const stopJsCoverage = async () => {
-    const coverage = await takeJsCoverage()
-    await postSession("Profiler.stopPreciseCoverage")
-    await postSession("Profiler.disable")
-    return coverage
-  }
-
-  return {
-    takeJsCoverage,
-    stopJsCoverage,
-  }
-}

package/src/execute/runtimes/readme.md

@@ -1,13 +0,0 @@
-# runtimes/
-
-Code implementing runtimes can be found here.
-
-# Description
-
-A runtime is an object with a "run" method.
-The run method is roughly doing the following:
-
-1. spawn a runtime (browser,Node.js)
-2. set various listeners to monitor file execution
-3. execute the file
-4. return info about file execution (logs and errors for instance)

package/src/execute/web_server_param.js

@@ -1,74 +0,0 @@
-import { assertAndNormalizeDirectoryUrl } from "@jsenv/filesystem"
-
-import { pingServer } from "../ping_server.js"
-import { basicFetch } from "../basic_fetch.js"
-
-export const assertAndNormalizeWebServer = async (webServer) => {
-  if (!webServer) {
-    throw new TypeError(
-      `webServer is required when running tests on browser(s)`,
-    )
-  }
-  const unexpectedParamNames = Object.keys(webServer).filter((key) => {
-    return !["origin", "moduleUrl", "rootDirectoryUrl"].includes(key)
-  })
-  if (unexpectedParamNames.length > 0) {
-    throw new TypeError(
-      `${unexpectedParamNames.join(",")}: there is no such param to webServer`,
-    )
-  }
-
-  let aServerIsListening = await pingServer(webServer.origin)
-  if (!aServerIsListening) {
-    if (!webServer.moduleUrl) {
-      throw new TypeError(
-        `webServer.moduleUrl is required as there is no server listening "${webServer.origin}"`,
-      )
-    }
-    try {
-      process.env.IMPORTED_BY_TEST_PLAN = "1"
-      await import(webServer.moduleUrl)
-      delete process.env.IMPORTED_BY_TEST_PLAN
-    } catch (e) {
-      if (e.code === "ERR_MODULE_NOT_FOUND") {
-        throw new Error(
-          `webServer.moduleUrl does not lead to a file at "${webServer.moduleUrl}"`,
-        )
-      }
-      throw e
-    }
-    aServerIsListening = await pingServer(webServer.origin)
-    if (!aServerIsListening) {
-      throw new Error(
-        `webServer.moduleUrl did not start a server listening at "${webServer.origin}", check file at "${webServer.moduleUrl}"`,
-      )
-    }
-  }
-  const { headers } = await basicFetch(webServer.origin, {
-    method: "GET",
-    rejectUnauthorized: false,
-    headers: {
-      "x-server-inspect": "1",
-    },
-  })
-  if (String(headers["server"]).includes("jsenv_dev_server")) {
-    webServer.isJsenvDevServer = true
-    const { json } = await basicFetch(`${webServer.origin}/__params__.json`, {
-      rejectUnauthorized: false,
-    })
-    if (webServer.rootDirectoryUrl === undefined) {
-      const jsenvDevServerParams = await json()
-      webServer.rootDirectoryUrl = jsenvDevServerParams.sourceDirectoryUrl
-    } else {
-      webServer.rootDirectoryUrl = assertAndNormalizeDirectoryUrl(
-        webServer.rootDirectoryUrl,
-        "webServer.rootDirectoryUrl",
-      )
-    }
-  } else {
-    webServer.rootDirectoryUrl = assertAndNormalizeDirectoryUrl(
-      webServer.rootDirectoryUrl,
-      "webServer.rootDirectoryUrl",
-    )
-  }
-}

package/src/test/coverage/babel_plugin_instrument.js

@@ -1,48 +0,0 @@
-import { requireFromJsenv } from "@jsenv/core/src/require_from_jsenv.js"
-
-// https://github.com/istanbuljs/babel-plugin-istanbul/blob/321740f7b25d803f881466ea819d870f7ed6a254/src/index.js
-
-export const babelPluginInstrument = (api, { useInlineSourceMaps = false }) => {
-  const { programVisitor } = requireFromJsenv("istanbul-lib-instrument")
-  const { types } = api
-
-  return {
-    name: "transform-instrument",
-    visitor: {
-      Program: {
-        enter(path) {
-          const { file } = this
-          const { opts } = file
-          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
-        },
-      },
-    },
-  }
-}

package/src/test/coverage/coverage_reporter_html_directory.js

@@ -1,32 +0,0 @@
-import { fileURLToPath } from "node:url"
-import { readFileSync } from "node:fs"
-
-import { requireFromJsenv } from "@jsenv/core/src/require_from_jsenv.js"
-import { istanbulCoverageMapFromCoverage } from "./istanbul_coverage_map_from_coverage.js"
-
-export const generateCoverageHtmlDirectory = async (
-  coverage,
-  {
-    rootDirectoryUrl,
-    coverageHtmlDirectoryRelativeUrl,
-    coverageReportSkipEmpty,
-    coverageReportSkipFull,
-  },
-) => {
-  const libReport = requireFromJsenv("istanbul-lib-report")
-  const reports = requireFromJsenv("istanbul-reports")
-
-  const context = libReport.createContext({
-    dir: fileURLToPath(rootDirectoryUrl),
-    coverageMap: istanbulCoverageMapFromCoverage(coverage),
-    sourceFinder: (path) =>
-      readFileSync(new URL(path, rootDirectoryUrl), "utf8"),
-  })
-
-  const report = reports.create("html", {
-    skipEmpty: coverageReportSkipEmpty,
-    skipFull: coverageReportSkipFull,
-    subdir: coverageHtmlDirectoryRelativeUrl,
-  })
-  report.execute(context)
-}

package/src/test/coverage/coverage_reporter_json_file.js

@@ -1,17 +0,0 @@
-import { writeFile } from "@jsenv/filesystem"
-import { urlToFileSystemPath } from "@jsenv/urls"
-import { byteAsFileSize } from "@jsenv/log"
-
-export const generateCoverageJsonFile = async ({
-  coverage,
-  coverageJsonFileUrl,
-  logger,
-}) => {
-  const coverageAsText = JSON.stringify(coverage, null, "  ")
-  logger.info(
-    `-> ${urlToFileSystemPath(coverageJsonFileUrl)} (${byteAsFileSize(
-      Buffer.byteLength(coverageAsText),
-    )})`,
-  )
-  await writeFile(coverageJsonFileUrl, coverageAsText)
-}

package/src/test/coverage/coverage_reporter_text_log.js

@@ -1,19 +0,0 @@
-import { requireFromJsenv } from "@jsenv/core/src/require_from_jsenv.js"
-import { istanbulCoverageMapFromCoverage } from "./istanbul_coverage_map_from_coverage.js"
-
-export const generateCoverageTextLog = (
-  coverage,
-  { coverageReportSkipEmpty, coverageReportSkipFull },
-) => {
-  const libReport = requireFromJsenv("istanbul-lib-report")
-  const reports = requireFromJsenv("istanbul-reports")
-
-  const context = libReport.createContext({
-    coverageMap: istanbulCoverageMapFromCoverage(coverage),
-  })
-  const report = reports.create("text", {
-    skipEmpty: coverageReportSkipEmpty,
-    skipFull: coverageReportSkipFull,
-  })
-  report.execute(context)
-}

package/src/test/coverage/empty_coverage_factory.js

@@ -1,52 +0,0 @@
-import { readFile } from "@jsenv/filesystem"
-import { resolveUrl } from "@jsenv/urls"
-import { Abort } from "@jsenv/abort"
-import { applyBabelPlugins } from "@jsenv/ast"
-
-import { requireFromJsenv } from "@jsenv/core/src/require_from_jsenv.js"
-import { babelPluginInstrument } from "./babel_plugin_instrument.js"
-
-export const relativeUrlToEmptyCoverage = async (
-  relativeUrl,
-  { signal, rootDirectoryUrl },
-) => {
-  const operation = Abort.startOperation()
-  operation.addAbortSignal(signal)
-
-  try {
-    const fileUrl = resolveUrl(relativeUrl, rootDirectoryUrl)
-    const content = await readFile(fileUrl, { as: "string" })
-
-    operation.throwIfAborted()
-    const { metadata } = await applyBabelPlugins({
-      babelPlugins: [babelPluginInstrument],
-      urlInfo: {
-        originalUrl: fileUrl,
-        content,
-      },
-    })
-    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 === "PARSE_ERROR") {
-      // return an empty coverage for that file when
-      // it contains a syntax error
-      return createEmptyCoverage(relativeUrl)
-    }
-    throw e
-  } finally {
-    await operation.end()
-  }
-}
-
-const createEmptyCoverage = (relativeUrl) => {
-  const { createFileCoverage } = requireFromJsenv("istanbul-lib-coverage")
-  return createFileCoverage(relativeUrl).toJSON()
-}

package/src/test/coverage/file_by_file_coverage.js

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

package/src/test/coverage/istanbul_coverage_composition.js

@@ -1,28 +0,0 @@
-import { requireFromJsenv } from "@jsenv/core/src/require_from_jsenv.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 } = requireFromJsenv("istanbul-lib-coverage")
-  const istanbulFileCoverageObject = createFileCoverage(firstIstanbulCoverage)
-  istanbulFileCoverageObject.merge(secondIstanbulCoverage)
-  const istanbulCoverage = istanbulFileCoverageObject.toJSON()
-  return istanbulCoverage
-}

package/src/test/coverage/istanbul_coverage_map_from_coverage.js

@@ -1,16 +0,0 @@
-import { requireFromJsenv } from "@jsenv/core/src/require_from_jsenv.js"
-
-export const istanbulCoverageMapFromCoverage = (coverage) => {
-  const { createCoverageMap } = requireFromJsenv("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
-}