@jsenv/core 23.2.0 → 23.4.0

package/src/abort/abortable.js

@@ -1,172 +0,0 @@
-/*
- * https://github.com/whatwg/dom/issues/920
- */
-
-import { createCleaner } from "./cleaner.js"
-import { raceCallbacks } from "./callback_race.js"
-import { createCallbackList } from "./callback_list.js"
-
-export const Abortable = {
-  throwIfAborted: (operation) => {
-    if (operation.signal.aborted) {
-      const error = new Error(`The operation was aborted`)
-      error.name = "AbortError"
-      error.type = "aborted"
-      throw error
-    }
-  },
-
-  isAbortError: (error) => {
-    return error.name === "AbortError"
-  },
-
-  start: () => {
-    const abortController = new AbortController()
-    const abort = (value) => abortController.abort(value)
-    const signal = abortController.signal
-    const cleaner = createCleaner()
-
-    // abortCallbackList is used to ignore the max listeners warning from Node.js
-    // this warning is useful but becomes problematic when it's expected
-    // (a function doing 20 http call in parallel)
-    // To be 100% sure we don't have memory leak, only Abortable.asyncCallback
-    // uses abortCallbackList to know when something is aborted
-    const abortCallbackList = createCallbackList()
-    signal.onabort = () => {
-      const callbacks = abortCallbackList.copy()
-      abortCallbackList.clear()
-      callbacks.forEach((callback) => {
-        callback()
-      })
-    }
-    cleaner.addCallback(() => {
-      abortCallbackList.clear()
-    })
-
-    const operation = {
-      abort,
-      signal,
-      abortCallbackList,
-      cleaner,
-    }
-
-    return operation
-  },
-
-  fromSignal: (signal) => {
-    const operation = Abortable.start()
-    Abortable.followSignal(operation, signal)
-    return operation
-  },
-
-  followSignal: (operation, signal, cleanup = cleanupNoop) => {
-    if (operation.signal.aborted) {
-      return () => {}
-    }
-
-    if (signal.aborted) {
-      operation.abort()
-      return () => {}
-    }
-
-    return raceCallbacks(
-      {
-        parent_abort: (cb) => {
-          return operation.abortCallbackList.add(cb)
-        },
-        child_abort: (cb) => {
-          return addEventListener(signal, "abort", cb)
-        },
-        cleaned: (cb) => {
-          return operation.cleaner.addCallback(cb)
-        },
-      },
-      (winner) => {
-        const raceEffects = {
-          parent_abort: () => {
-            // Nothing to do, exists to remove
-            // - "abort" event listener on parent
-            // - "abort" event listener on child
-            cleanup()
-          },
-          child_abort: () => {
-            operation.abort()
-          },
-          cleaned: () => {
-            // Nothing to do, exists to remove
-            // - "abort" event listener on parent
-            // - "abort" event listener on child
-            cleanup()
-          },
-        }
-        raceEffects[winner.name](winner.value)
-      },
-    )
-  },
-
-  effect: (operation, effect) => {
-    const abortController = new AbortController()
-    const returnValue = effect((value) => abortController.abort(value))
-    const cleanup =
-      typeof returnValue === "function" ? returnValue : cleanupNoop
-    const signal = abortController.signal
-
-    Abortable.followSignal(operation, signal, cleanup)
-    return {
-      signal,
-      cleanup,
-    }
-  },
-
-  timeout: (operation, ms) => {
-    return Abortable.effect(operation, (abort) => {
-      const timeoutId = setTimeout(abort, ms)
-      return () => {
-        clearTimeout(timeoutId)
-      }
-    })
-  },
-
-  cleanOnAbort: (operation) => {
-    const removeAbortEventListener = addEventListener(
-      operation.signal,
-      "abort",
-      () => {
-        removeAbortEventListener()
-        operation.cleaner.clean("operation aborted")
-      },
-    )
-    return removeAbortEventListener
-  },
-
-  // Provide a signal to the callback
-  // this signal won't inherit the current signal max listeners
-  asyncCallback: async (operation, asyncFunction) => {
-    Abortable.throwIfAborted(operation)
-
-    const abortController = new AbortController()
-    const signal = abortController.signal
-
-    const removeOperationAbortCallback = operation.abortCallbackList.add(() => {
-      abortController.abort()
-    })
-
-    try {
-      const value = await asyncFunction(signal)
-      removeOperationAbortCallback()
-      return value
-    } catch (e) {
-      removeOperationAbortCallback()
-      throw e
-    }
-  },
-}
-
-const cleanupNoop = () => {}
-
-const addEventListener = (target, eventName, cb) => {
-  target.addEventListener(eventName, cb)
-  return () => {
-    target.removeEventListener(eventName, cb)
-  }
-}

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/generateCoverageJsonFile.js

@@ -1,5 +0,0 @@
-import { writeFile } from "@jsenv/filesystem"
-
-export const generateCoverageJsonFile = async (coverage, coverageJsonFileUrl) => {
-  await writeFile(coverageJsonFileUrl, JSON.stringify(coverage, null, "  "))
-}

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
-}