@jsenv/core 26.0.1 → 27.0.0-alpha.2

package/src/internal/node_launcher/node_execution_dynamic_import.js

@@ -1,75 +0,0 @@
-import { resolveUrl } from "@jsenv/filesystem"
-
-import { unevalException } from "@jsenv/core/src/internal/runtime_client/uneval_exception.js"
-
-import { startObservingPerformances } from "./node_execution_performance.js"
-import { measureAsyncFnPerf } from "./perf_node.js"
-
-export const execute = async ({
-  projectDirectoryUrl,
-  fileRelativeUrl,
-  // do not log in the console
-  // because error handling becomes responsability
-  // of node code launching node process
-  // it avoids seeing error in runtime logs during testing
-  errorExposureInConsole = false,
-  collectCoverage,
-  measurePerformance,
-  collectPerformance,
-}) => {
-  let finalizeExecutionResult = (result) => result
-
-  if (collectPerformance) {
-    const getPerformance = startObservingPerformances()
-    finalizeExecutionResult = async (executionResult) => {
-      const performance = await getPerformance()
-      return {
-        ...executionResult,
-        performance,
-      }
-    }
-  }
-
-  const executeFile = async (
-    specifier,
-    { measurePerformance, errorExposureInConsole = false } = {},
-  ) => {
-    // we can't dynamically import from compileServerOrigin I guess
-    // we have to use the filesystem
-    const fileUrl = resolveUrl(specifier, projectDirectoryUrl)
-    const importWithDynamicImport = async () => {
-      try {
-        const status = "completed"
-        const namespace = await import(fileUrl)
-
-        return {
-          status,
-          namespace,
-        }
-      } catch (error) {
-        if (errorExposureInConsole) console.error(error)
-        const status = "errored"
-        const exceptionSource = unevalException(error)
-        return {
-          status,
-          exceptionSource,
-        }
-      }
-    }
-    if (measurePerformance) {
-      return measureAsyncFnPerf(importWithDynamicImport, "jsenv_file_import")
-    }
-    return importWithDynamicImport()
-  }
-
-  const executionResult = await executeFile(fileRelativeUrl, {
-    errorExposureInConsole,
-    measurePerformance,
-    collectCoverage,
-  })
-
-  return finalizeExecutionResult({
-    ...executionResult,
-    indirectCoverage: global.__indirectCoverage__,
-  })
-}

package/src/internal/node_launcher/node_execution_performance.js

@@ -1,67 +0,0 @@
-import { PerformanceObserver, performance } from "node:perf_hooks"
-
-export const startObservingPerformances = () => {
-  const measureEntries = []
-  // https://nodejs.org/dist/latest-v16.x/docs/api/perf_hooks.html
-  const perfObserver = new PerformanceObserver(
-    (
-      // https://nodejs.org/dist/latest-v16.x/docs/api/perf_hooks.html#perf_hooks_class_performanceobserverentrylist
-      list,
-    ) => {
-      const perfMeasureEntries = list.getEntriesByType("measure")
-      measureEntries.push(...perfMeasureEntries)
-    },
-  )
-  perfObserver.observe({
-    entryTypes: ["measure"],
-  })
-  return async () => {
-    // wait for node to call the performance observer
-    await new Promise((resolve) => {
-      setTimeout(resolve)
-    })
-    performance.clearMarks()
-    perfObserver.disconnect()
-    return {
-      ...readNodePerformance(),
-      measures: measuresFromMeasureEntries(measureEntries),
-    }
-  }
-}
-
-const readNodePerformance = () => {
-  const nodePerformance = {
-    nodeTiming: asPlainObject(performance.nodeTiming),
-    timeOrigin: performance.timeOrigin,
-    eventLoopUtilization: performance.eventLoopUtilization(),
-  }
-  return nodePerformance
-}
-
-// remove getters that cannot be stringified
-const asPlainObject = (objectWithGetters) => {
-  const objectWithoutGetters = {}
-  Object.keys(objectWithGetters).forEach((key) => {
-    objectWithoutGetters[key] = objectWithGetters[key]
-  })
-  return objectWithoutGetters
-}
-
-const measuresFromMeasureEntries = (measureEntries) => {
-  const measures = {}
-  // Sort to ensure measures order is predictable
-  // It seems to be already predictable on Node 16+ but
-  // it's not the case on Node 14.
-  measureEntries.sort((a, b) => {
-    return a.startTime - b.startTime
-  })
-  measureEntries.forEach(
-    (
-      // https://nodejs.org/dist/latest-v16.x/docs/api/perf_hooks.html#perf_hooks_class_performanceentry
-      perfMeasureEntry,
-    ) => {
-      measures[perfMeasureEntry.name] = perfMeasureEntry.duration
-    },
-  )
-  return measures
-}

package/src/internal/node_launcher/node_execution_systemjs.js

@@ -1,125 +0,0 @@
-import { resolveUrl } from "@jsenv/filesystem"
-
-import { unevalException } from "@jsenv/core/src/internal/runtime_client/uneval_exception.js"
-
-import { installNodeErrorStackRemapping } from "./node_error_stack_remap.js"
-import { startObservingPerformances } from "./node_execution_performance.js"
-import { measureAsyncFnPerf } from "./perf_node.js"
-import { fetchSource } from "./fetch_source.js"
-import { createNodeSystem } from "./node_system.js"
-
-export const execute = async ({
-  projectDirectoryUrl,
-  compileServerOrigin,
-  fileRelativeUrl,
-  jsenvDirectoryRelativeUrl,
-  compileId,
-  importDefaultExtension,
-  // do not log in the console
-  // because error handling becomes responsability
-  // of node code launching node process
-  // it avoids seeing error in runtime logs during testing
-  errorExposureInConsole = false,
-  collectCoverage,
-  measurePerformance,
-  collectPerformance,
-}) => {
-  let finalizeExecutionResult = (result) => result
-  if (collectPerformance) {
-    const getPerformance = startObservingPerformances()
-    finalizeExecutionResult = async (executionResult) => {
-      const performance = await getPerformance()
-      return {
-        ...executionResult,
-        performance,
-      }
-    }
-  }
-  const { getErrorOriginalStackString } = installNodeErrorStackRemapping({
-    projectDirectoryUrl,
-  })
-  const compileDirectoryRelativeUrl = `${jsenvDirectoryRelativeUrl}${compileId}/`
-
-  const errorTransformer = async (error) => {
-    // code can throw something else than an error
-    // in that case return it unchanged
-    if (!error || !(error instanceof Error)) return error
-
-    const originalStack = await getErrorOriginalStackString(error)
-    error.stack = originalStack
-    return error
-  }
-
-  const executeFile = async (
-    specifier,
-    { measurePerformance, errorExposureInConsole = true } = {},
-  ) => {
-    const compiledFileRemoteUrl = resolveUrl(
-      specifier,
-      `${compileServerOrigin}/${compileDirectoryRelativeUrl}`,
-    )
-
-    const nodeSystem = await createNodeSystem({
-      projectDirectoryUrl,
-      compileServerOrigin,
-      compileDirectoryRelativeUrl,
-      fetchSource,
-      importDefaultExtension,
-    })
-
-    const importWithSystemJs = async () => {
-      try {
-        const importPromise = nodeSystem.import(compiledFileRemoteUrl)
-        const namespace = await makePromiseKeepNodeProcessAlive(importPromise)
-        return {
-          status: "completed",
-          namespace,
-          coverage: global.__coverage__,
-        }
-      } catch (error) {
-        let transformedError
-        try {
-          transformedError = await errorTransformer(error)
-        } catch (e) {
-          transformedError = error
-        }
-
-        if (errorExposureInConsole) {
-          console.error(transformedError)
-        }
-
-        return {
-          status: "errored",
-          exceptionSource: unevalException(transformedError),
-          coverage: global.__coverage__,
-        }
-      }
-    }
-    if (measurePerformance) {
-      return measureAsyncFnPerf(importWithSystemJs, "jsenv_file_import")
-    }
-    return importWithSystemJs()
-  }
-
-  const executionResult = await executeFile(fileRelativeUrl, {
-    errorExposureInConsole,
-    measurePerformance,
-    collectCoverage,
-  })
-
-  return finalizeExecutionResult({
-    ...executionResult,
-    indirectCoverage: global.__indirectCoverage__,
-  })
-}
-
-const makePromiseKeepNodeProcessAlive = async (promise) => {
-  const timerId = setInterval(() => {}, 10000)
-
-  try {
-    const value = await promise
-    return value
-  } finally {
-    clearInterval(timerId)
-  }
-}

package/src/internal/node_launcher/node_runtime_report.js

@@ -1,77 +0,0 @@
-import { scanNodeRuntimeFeatures } from "@jsenv/core/src/internal/features/node_feature_detection/node_feature_detection.js"
-
-export const getNodeRuntimeReport = async ({
-  runtime,
-  compileServerId,
-  compileServerOrigin,
-
-  moduleOutFormat,
-  forceCompilation,
-  coverageHandledFromOutside,
-}) => {
-  const cache = cacheFromParams({
-    runtime,
-    compileServerId,
-    compileServerOrigin,
-
-    moduleOutFormat,
-    forceCompilation,
-    coverageHandledFromOutside,
-  })
-  const entry = cache.read()
-  if (entry) {
-    return entry
-  }
-  const nodeRuntimeFeaturesReport = await scanNodeRuntimeFeatures({
-    compileServerOrigin,
-    moduleOutFormat,
-    forceCompilation,
-    coverageHandledFromOutside,
-  })
-  cache.write(nodeRuntimeFeaturesReport)
-  return nodeRuntimeFeaturesReport
-}
-
-let currentCacheParams
-let currentCacheValue
-const cacheFromParams = ({
-  compileServerId,
-  compileServerOrigin,
-
-  moduleOutFormat,
-  forceCompilation,
-  coverageHandledFromOutside,
-}) => {
-  const params = {
-    compileServerId,
-    compileServerOrigin,
-
-    moduleOutFormat,
-    forceCompilation,
-    coverageHandledFromOutside,
-  }
-  if (!currentCacheParams) {
-    currentCacheParams = params
-    return {
-      read: () => null,
-      write: (value) => {
-        currentCacheValue = value
-      },
-    }
-  }
-  if (JSON.stringify(currentCacheParams) !== JSON.stringify(params)) {
-    return {
-      read: () => null,
-      write: (value) => {
-        currentCacheParams = params
-        currentCacheValue = value
-      },
-    }
-  }
-  return {
-    read: () => currentCacheValue,
-    write: (value) => {
-      currentCacheValue = value
-    },
-  }
-}

package/src/internal/node_launcher/node_system.js

@@ -1,192 +0,0 @@
-/**
-
-We could use https://nodejs.org/api/esm.html#esm_loaders once it gets stable
-
-*/
-
-import { urlToFileSystemPath, resolveUrl } from "@jsenv/filesystem"
-import { isSpecifierForNodeCoreModule } from "@jsenv/importmap/src/isSpecifierForNodeCoreModule.js"
-
-import { createImportResolverForNode } from "@jsenv/core/src/internal/import_resolution/import_resolver_node.js"
-import { require } from "@jsenv/core/src/internal/require.js"
-import "@jsenv/core/src/internal/runtime_client/s.js"
-import {
-  fromFunctionReturningNamespace,
-  getJavaScriptModuleResponseError,
-  fromFunctionReturningRegisteredModule,
-} from "@jsenv/core/src/internal/runtime_client/module_registration.js"
-
-import { valueInstall } from "./value_install.js"
-import { evalSource } from "./eval_source.js"
-
-export const createNodeSystem = async ({
-  projectDirectoryUrl,
-  compileServerOrigin,
-  compileDirectoryRelativeUrl,
-  fetchSource,
-  importDefaultExtension,
-} = {}) => {
-  if (typeof global.System === "undefined") {
-    throw new Error(`global.System is undefined`)
-  }
-
-  const nodeSystem = new global.System.constructor()
-  const nodeImporterResolver = await createImportResolverForNode({
-    projectDirectoryUrl,
-    compileServerOrigin,
-    compileDirectoryRelativeUrl,
-    importDefaultExtension,
-  })
-
-  const resolve = async (specifier, importer) => {
-    return nodeImporterResolver.resolveImport(specifier, importer)
-  }
-
-  nodeSystem.resolve = resolve
-
-  nodeSystem.instantiate = async (url, importerUrl) => {
-    if (isSpecifierForNodeCoreModule(url)) {
-      return fromFunctionReturningNamespace(
-        () => {
-          const coreNodeModuleSpecifier = url.startsWith("node:")
-            ? url.slice("node:".length)
-            : url
-          // eslint-disable-next-line import/no-dynamic-require
-          const moduleExportsForNativeNodeModule = require(coreNodeModuleSpecifier)
-          return moduleExportsToModuleNamespace(
-            moduleExportsForNativeNodeModule,
-          )
-        },
-        {
-          url,
-          importerUrl,
-          compileServerOrigin,
-          compileDirectoryRelativeUrl,
-        },
-      )
-    }
-
-    let response
-    try {
-      response = await fetchSource(url, {
-        importerUrl,
-      })
-    } catch (e) {
-      e.code = "NETWORK_FAILURE"
-      throw e
-    }
-
-    const responseError = await getJavaScriptModuleResponseError(response, {
-      url,
-      importerUrl,
-      compileServerOrigin,
-      compileDirectoryRelativeUrl,
-      jsonContentTypeAccepted: process.execArgv.includes(
-        "--experimental-json-modules",
-      ),
-    })
-    if (responseError) {
-      throw responseError
-    }
-
-    const contentType = response.headers["content-type"]
-    if (contentType === "application/json" || contentType.endsWith("+json")) {
-      const responseBodyAsJson = await response.json()
-      return fromFunctionReturningNamespace(
-        () => {
-          return {
-            default: responseBodyAsJson,
-          }
-        },
-        {
-          url: response.url,
-          importerUrl,
-          compileServerOrigin,
-          compileDirectoryRelativeUrl,
-        },
-      )
-    }
-
-    const responseBodyAsText = await response.text()
-    return fromFunctionReturningRegisteredModule(
-      () => {
-        const uninstallSystemGlobal = valueInstall(global, "System", nodeSystem)
-        try {
-          evalSource(
-            responseBodyAsText,
-            responseUrlToSourceUrl(response.url, {
-              projectDirectoryUrl,
-              compileServerOrigin,
-            }),
-          )
-        } finally {
-          uninstallSystemGlobal()
-        }
-
-        return nodeSystem.getRegister()
-      },
-      {
-        url: response.url,
-        importerUrl,
-        compileServerOrigin,
-        compileDirectoryRelativeUrl,
-      },
-    )
-  }
-
-  // https://github.com/systemjs/systemjs/blob/master/docs/hooks.md#createcontexturl---object
-  nodeSystem.createContext = (url) => {
-    const projectUrl = nodeImporterResolver.asProjectUrl(url, {
-      projectDirectoryUrl,
-      compileDirectoryRelativeUrl,
-      compileServerOrigin,
-    })
-
-    return {
-      url: projectUrl || url,
-      resolve: async (specifier) => {
-        const urlResolved = await resolve(specifier, url)
-        return nodeImporterResolver.fileUrlFromUrl(urlResolved, {
-          projectDirectoryUrl,
-          compileDirectoryRelativeUrl,
-          compileServerOrigin,
-        })
-      },
-    }
-  }
-
-  return nodeSystem
-}
-
-const responseUrlToSourceUrl = (
-  responseUrl,
-  { compileServerOrigin, projectDirectoryUrl },
-) => {
-  if (responseUrl.startsWith("file://")) {
-    return urlToFileSystemPath(responseUrl)
-  }
-  // compileServerOrigin is optionnal
-  // because we can also create a node system and use it to import a build
-  // from filesystem. In that case there is no compileServerOrigin
-  if (
-    compileServerOrigin &&
-    responseUrl.startsWith(`${compileServerOrigin}/`)
-  ) {
-    const afterOrigin = responseUrl.slice(`${compileServerOrigin}/`.length)
-    const fileUrl = resolveUrl(afterOrigin, projectDirectoryUrl)
-    return urlToFileSystemPath(fileUrl)
-  }
-  return responseUrl
-}
-
-const moduleExportsToModuleNamespace = (moduleExports) => {
-  // keep in mind moduleExports can be a function (like require('stream'))
-  if (typeof moduleExports === "object" && "default" in moduleExports) {
-    return moduleExports
-  }
-
-  return {
-    ...moduleExports,
-    default: moduleExports,
-  }
-}

package/src/internal/node_launcher/perf_node.js

@@ -1,13 +0,0 @@
-import { performance } from "node:perf_hooks"
-
-export const measureAsyncFnPerf = async (fn, name) => {
-  const perfMarkStartName = `${name}_start`
-
-  performance.mark(perfMarkStartName)
-  try {
-    const value = await fn()
-    return value
-  } finally {
-    performance.measure(name, perfMarkStartName)
-  }
-}

package/src/internal/node_launcher/process_options.js

@@ -1,46 +0,0 @@
-export const processOptionsFromExecArgv = (execArgv) => {
-  const processOptions = {}
-
-  let i = 0
-  while (i < execArgv.length) {
-    const execArg = execArgv[i]
-    const option = processOptionFromExecArg(execArg)
-    processOptions[option.name] = option.value
-    i++
-  }
-
-  return processOptions
-}
-
-const processOptionFromExecArg = (execArg) => {
-  const equalCharIndex = execArg.indexOf("=")
-  if (equalCharIndex === -1) {
-    return {
-      name: execArg,
-      value: "",
-    }
-  }
-
-  const name = execArg.slice(0, equalCharIndex)
-  const value = execArg.slice(equalCharIndex + 1)
-  return {
-    name,
-    value,
-  }
-}
-
-export const execArgvFromProcessOptions = (processOptions) => {
-  const execArgv = []
-  Object.keys(processOptions).forEach((processOptionName) => {
-    const processOptionValue = processOptions[processOptionName]
-    if (processOptionValue === "unset") {
-      return
-    }
-    if (processOptionValue === "") {
-      execArgv.push(processOptionName)
-      return
-    }
-    execArgv.push(`${processOptionName}=${processOptionValue}`)
-  })
-  return execArgv
-}

package/src/internal/node_launcher/value_install.js

@@ -1,14 +0,0 @@
-export const valueInstall = (object, name, value) => {
-  const has = name in object
-  const previous = object[name]
-
-  object[name] = value
-
-  return () => {
-    if (has) {
-      object[name] = previous
-    } else {
-      delete object[name]
-    }
-  }
-}

package/src/internal/origin_directory_converter.js

@@ -1,62 +0,0 @@
-// https://stackoverflow.com/a/1184263
-// using the list of bad characters from:
-// https://github.com/parshap/node-sanitize-filename/blob/master/index.js
-// so that the directory name can be decoded
-// so that we can find back the http origin
-// we should also ignore the query string params part
-// it does not matter, it can be removed from the url and added back
-// when performing the http request
-
-const escapeChar = "$"
-const reservedChars = ["/", "?", "<", ">", "\\", ":", "*", "|", '"']
-
-export const originDirectoryConverter = {
-  toDirectoryName: (origin) => {
-    let directoryName = ""
-    let i = 0
-    while (i < origin.length) {
-      const char = origin[i]
-      i++
-      if (reservedChars.includes(char)) {
-        const charAsHex = charToHexString(char)
-        directoryName += `${escapeChar}${charAsHex}`
-      } else {
-        directoryName += char
-      }
-    }
-    return directoryName
-  },
-
-  fromDirectoryName: (filename) => {
-    let origin = ""
-    let i = 0
-    while (i < filename.length) {
-      const char = filename[i]
-      i++
-      if (char === escapeChar) {
-        const encodedChar = `${filename[i]}${filename[i + 1]}`
-        i += 2
-        const decodedChar = charFromHexString(encodedChar)
-        origin += decodedChar
-      } else {
-        origin += char
-      }
-    }
-    return origin
-  },
-}
-
-const charToHexString = (char) => {
-  const charCode = char.charCodeAt(0)
-  const hexString = charCode.toString(16)
-  if (charCode < 16) {
-    return `0${hexString}`
-  }
-  return hexString
-}
-
-const charFromHexString = (hexString) => {
-  const charCode = parseInt(hexString, 16)
-  const char = String.fromCharCode(charCode)
-  return char
-}

package/src/internal/promise_race.js

@@ -1,19 +0,0 @@
-export const racePromises = (promiseArray) => {
-  return new Promise((resolve, reject) => {
-    let resolved = false
-
-    const visit = (index) => {
-      const promise = promiseArray[index]
-      promise.then((value) => {
-        if (resolved) return
-        resolved = true
-        resolve({ promise, value, index })
-      }, reject)
-    }
-
-    let i = 0
-    while (i < promiseArray.length) {
-      visit(i++)
-    }
-  })
-}