@jsenv/core 25.6.2 → 27.0.0-alpha.0

package/src/internal/node_runtime/evalSource.js

@@ -1,6 +0,0 @@
-import { Script } from "node:vm"
-
-export const evalSource = (code, filePath) => {
-  const script = new Script(code, { filename: filePath })
-  return script.runInThisContext()
-}

package/src/internal/node_runtime/fetchSource.js

@@ -1,8 +0,0 @@
-import { fetchUrl } from "../fetchUrl.js"
-
-export const fetchSource = (url, options) => {
-  return fetchUrl(url, {
-    ignoreHttpsError: true,
-    ...options,
-  })
-}

package/src/internal/node_runtime/node_execution_dynamic_import.js

@@ -1,74 +0,0 @@
-import { resolveUrl } from "@jsenv/filesystem"
-
-import { unevalException } from "@jsenv/core/src/internal/unevalException.js"
-import { measureAsyncFnPerf } from "@jsenv/core/src/internal/perf_node.js"
-import { startObservingPerformances } from "./node_execution_performance.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_runtime/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_runtime/node_execution_systemjs.js

@@ -1,125 +0,0 @@
-import { resolveUrl } from "@jsenv/filesystem"
-
-import { measureAsyncFnPerf } from "@jsenv/core/src/internal/perf_node.js"
-import { startObservingPerformances } from "./node_execution_performance.js"
-import { unevalException } from "@jsenv/core/src/internal/unevalException.js"
-
-import { installNodeErrorStackRemapping } from "@jsenv/core/src/internal/error-stack-remapping/installNodeErrorStackRemapping.js"
-import { fetchSource } from "@jsenv/core/src/internal/node_runtime/fetchSource.js"
-import { createNodeSystem } from "@jsenv/core/src/internal/node_runtime/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_runtime/node_system.js

@@ -1,191 +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 "../require.js"
-import "../runtime/s.js"
-import {
-  fromFunctionReturningNamespace,
-  getJavaScriptModuleResponseError,
-  fromFunctionReturningRegisteredModule,
-} from "../runtime/module-registration.js"
-import { valueInstall } from "../runtime/valueInstall.js"
-import { evalSource } from "./evalSource.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/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/perf_node.js

@@ -1,13 +0,0 @@
-import { performance } from "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/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++)
-    }
-  })
-}

package/src/internal/redirector/redirector.html

@@ -1,40 +0,0 @@
-<!DOCTYPE html>
-<html>
-  <head>
-    <title>Jsenv redirector</title>
-    <meta name="viewport" content="width=device-width, initial-scale=1" />
-    <meta charset="utf-8" />
-    <link rel="icon" href="data:," />
-  </head>
-
-  <body>
-    <script type="importmap" src="../../../node_resolution.importmap"></script>
-    <script type="module">
-      import { scanBrowserRuntimeFeatures } from "../features/browser_feature_detection/browser_feature_detection.js"
-
-      const redirect = async () => {
-        const searchParams = new URLSearchParams(window.location.search)
-        const redirectTarget = searchParams.get("redirect")
-        const forceCompilation = searchParams.get("force_compilation")
-        const browserRuntimeProfile = await scanBrowserRuntimeFeatures({
-          forceCompilation: forceCompilation === "1",
-        })
-        const href = `${getDirectoryUrl(
-          browserRuntimeProfile,
-        )}${redirectTarget}`
-        // It's IMPORTANT to use location.replace and NOT location.href = url
-        // otherwise it would break the back button
-        window.location.replace(href)
-      }
-
-      const getDirectoryUrl = ({ jsenvDirectoryRelativeUrl, compileId }) => {
-        if (compileId) {
-          return `/${jsenvDirectoryRelativeUrl}${compileId}/`
-        }
-        return `/`
-      }
-
-      redirect()
-    </script>
-  </body>
-</html>

package/src/internal/require.js

@@ -1,3 +0,0 @@
-import { createRequire } from "module"
-
-export const require = createRequire(import.meta.url)