@jsenv/core 24.2.2 → 24.4.0

package/src/internal/node_feature_detection/nodeSupportsTopLevelAwait.js

@@ -0,0 +1,16 @@
+import { memoize } from "@jsenv/filesystem"
+
+const FEATURE_DETECT_DYNAMIC_IMPORT_FILE_URL = new URL(
+  "./feature_detect_top_level_await.mjs",
+  import.meta.url,
+).href
+
+export const nodeSupportsTopLevelAwait = memoize(async () => {
+  try {
+    const namespace = await import(FEATURE_DETECT_DYNAMIC_IMPORT_FILE_URL)
+    const supported = namespace.default === 42
+    return supported
+  } catch (e) {
+    return false
+  }
+})

package/src/internal/{runtime/createNodeRuntime/scanNodeRuntimeFeatures.js → node_feature_detection/node_feature_detection.js}

@@ -1,13 +1,14 @@
-import { detectNode } from "../detectNode/detectNode.js"
-import { resolveGroup } from "../resolveGroup.js"
-import { computeCompileIdFromGroupId } from "../computeCompileIdFromGroupId.js"
-import { nodeSupportsDynamicImport } from "../node-feature-detect/nodeSupportsDynamicImport.js"
-import { nodeSupportsTopLevelAwait } from "../node-feature-detect/nodeSupportsTopLevelAwait.js"
-import { fetchSource } from "./fetchSource.js"
+import { resolveGroup } from "@jsenv/core/src/internal/runtime/resolveGroup.js"
+import { detectNode } from "@jsenv/core/src/internal/node_runtime/detectNode.js"
+import { computeCompileIdFromGroupId } from "@jsenv/core/src/internal/runtime/computeCompileIdFromGroupId.js"
+import { nodeSupportsDynamicImport } from "@jsenv/core/src/internal/node_feature_detection/nodeSupportsDynamicImport.js"
+import { nodeSupportsTopLevelAwait } from "@jsenv/core/src/internal/node_feature_detection/nodeSupportsTopLevelAwait.js"
+import { fetchSource } from "@jsenv/core/src/internal/node_runtime/fetchSource.js"
 
 export const scanNodeRuntimeFeatures = async ({
   compileServerOrigin,
   outDirectoryRelativeUrl,
+  coverageHandledFromOutside = false,
 }) => {
   const outDirectoryServerUrl = `${compileServerOrigin}/${outDirectoryRelativeUrl}`
   const {
@@ -35,10 +36,7 @@ export const scanNodeRuntimeFeatures = async ({
   })
   const pluginRequiredNameArray = pluginRequiredNamesFromGroupInfo(groupInfo, {
     featuresReport,
-    // https://nodejs.org/docs/latest-v15.x/api/cli.html#cli_node_v8_coverage_dir
-    // instrumentation CAN be handed by process.env.NODE_V8_COVERAGE
-    // "transform-instrument" becomes non mandatory
-    coverageHandledFromOutside: process.env.NODE_V8_COVERAGE,
+    coverageHandledFromOutside,
   })
 
   const canAvoidCompilation =
@@ -102,9 +100,10 @@ const pluginRequiredNamesFromGroupInfo = (
   if (coverageHandledFromOutside) {
     markPluginAsSupported("transform-instrument")
   }
-  // We assume import assertions and constructable stylesheet won't be used
-  // in code executed in Node.js
-  // so event they are conceptually required, they are ignored
+  // CSS import assertions and constructable stylesheet are not supported by Node.js
+  // but we assume they are not used for code executed in Node.js
+  // Without this check code executed on Node.js would always be compiled
+  // because import assertions and constructable stylesheet are enabled by default
   markPluginAsSupported("transform-import-assertions")
   markPluginAsSupported("new-stylesheet-as-jsenv-import")
 

package/src/internal/{node-launcher → node_launcher}/createControllableNodeProcess.js

@@ -1,11 +1,7 @@
 import { fork } from "node:child_process"
 import { uneval } from "@jsenv/uneval"
 import { createLogger, createDetailedMessage } from "@jsenv/logger"
-import {
-  urlToFileSystemPath,
-  resolveUrl,
-  assertFilePresence,
-} from "@jsenv/filesystem"
+import { urlToFileSystemPath, assertFilePresence } from "@jsenv/filesystem"
 import {
   Abort,
   raceCallbacks,
@@ -13,8 +9,7 @@ import {
   createCallbackListNotifiedOnce,
 } from "@jsenv/abort"
 
-import { nodeSupportsDynamicImport } from "../runtime/node-feature-detect/nodeSupportsDynamicImport.js"
-import { jsenvCoreDirectoryUrl } from "../jsenvCoreDirectoryUrl.js"
+import { nodeSupportsDynamicImport } from "../node_feature_detection/nodeSupportsDynamicImport.js"
 import { createChildProcessOptions } from "./createChildProcessOptions.js"
 import {
   processOptionsFromExecArgv,
@@ -22,10 +17,10 @@ import {
 } from "./processOptions.js"
 import { killProcessTree } from "./kill_process_tree.js"
 
-const nodeControllableFileUrl = resolveUrl(
-  "./src/internal/node-launcher/nodeControllableFile.mjs",
-  jsenvCoreDirectoryUrl,
-)
+const NODE_CONTROLLABLE_FILE_URL = new URL(
+  "../node_runtime/nodeControllableFile.mjs",
+  import.meta.url,
+).href
 
 // https://nodejs.org/api/process.html#process_signal_events
 const SIGINT_SIGNAL_NUMBER = 2
@@ -79,12 +74,12 @@ export const createControllableNodeProcess = async ({
     throw new TypeError(`env must be an object, got ${env}`)
   }
 
-  await assertFilePresence(nodeControllableFileUrl)
+  await assertFilePresence(NODE_CONTROLLABLE_FILE_URL)
   const envForChildProcess = {
     ...(inheritProcessEnv ? process.env : {}),
     ...env,
   }
-  const childProcess = fork(urlToFileSystemPath(nodeControllableFileUrl), {
+  const childProcess = fork(urlToFileSystemPath(NODE_CONTROLLABLE_FILE_URL), {
     execArgv,
     // silent: true
     stdio: ["pipe", "pipe", "pipe", "ipc"],
@@ -111,7 +106,7 @@ export const createControllableNodeProcess = async ({
   if (logProcessCommand) {
     console.log(
       `${process.argv[0]} ${execArgv.join(" ")} ${urlToFileSystemPath(
-        nodeControllableFileUrl,
+        NODE_CONTROLLABLE_FILE_URL,
       )}`,
     )
   }

package/src/internal/node_launcher/node_runtime_report.js

@@ -0,0 +1,71 @@
+import { scanNodeRuntimeFeatures } from "@jsenv/core/src/internal/node_feature_detection/node_feature_detection.js"
+
+export const getNodeRuntimeReport = async ({
+  runtime,
+  compileServerId,
+  compileServerOrigin,
+  outDirectoryRelativeUrl,
+  coverageHandledFromOutside,
+}) => {
+  const cache = cacheFromParams({
+    runtime,
+    compileServerId,
+    compileServerOrigin,
+    outDirectoryRelativeUrl,
+    coverageHandledFromOutside,
+  })
+  const entry = cache.read()
+  if (entry) {
+    return entry
+  }
+  const nodeRuntimeFeaturesReport = await scanNodeRuntimeFeatures({
+    compileServerOrigin,
+    outDirectoryRelativeUrl,
+    coverageHandledFromOutside,
+  })
+  cache.write(nodeRuntimeFeaturesReport)
+  return nodeRuntimeFeaturesReport
+}
+
+let currentCacheParams
+let currentCacheValue
+const cacheFromParams = ({
+  compileServerId,
+  compileServerOrigin,
+  outDirectoryRelativeUrl,
+  coverageHandledFromOutside,
+}) => {
+  const params = {
+    compileServerId,
+    compileServerOrigin,
+    outDirectoryRelativeUrl,
+    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/{runtime/createNodeRuntime → node_runtime}/evalSource.js

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

package/src/internal/{runtime/createNodeRuntime → node_runtime}/fetchSource.js

@@ -1,4 +1,4 @@
-import { fetchUrl } from "../../fetchUrl.js"
+import { fetchUrl } from "../fetchUrl.js"
 
 export const fetchSource = (url, { executionId } = {}) => {
   return fetchUrl(url, {

package/src/internal/{node-launcher → node_runtime}/nodeControllableFile.mjs

@@ -1,19 +1,26 @@
 import v8 from "node:v8"
 import { uneval } from "@jsenv/uneval"
 
-import { jsenvNodeSystemFileInfo } from "@jsenv/core/src/internal/jsenvInternalFiles.js"
+const NODE_EXECUTION_DYNAMIC_IMPORT_URL = new URL(
+  "./node_execution_dynamic_import.js",
+  import.meta.url,
+).href
+const NODE_EXECUTION_SYSTEMJS_URL = new URL(
+  "./node_execution_systemjs.js",
+  import.meta.url,
+).href
 
 const ACTIONS_AVAILABLE = {
-  "execute-using-dynamic-import-fallback-on-systemjs": async (
-    executeParams,
-  ) => {
-    const { execute } = await import(jsenvNodeSystemFileInfo.url)
-
+  "execute-using-dynamic-import": async (executeParams) => {
+    const { execute } = await import(NODE_EXECUTION_DYNAMIC_IMPORT_URL)
+    return execute(executeParams)
+  },
+  "execute-using-systemjs": async (executeParams) => {
+    const { execute } = await import(NODE_EXECUTION_SYSTEMJS_URL)
     return execute(executeParams)
   },
   "execute-using-import": async ({ fileUrl }) => {
     const namespace = await import(fileUrl)
-
     const namespaceResolved = {}
     await Promise.all([
       ...Object.keys(namespace).map(async (key) => {
@@ -21,19 +28,15 @@ const ACTIONS_AVAILABLE = {
         namespaceResolved[key] = value
       }),
     ])
-
     return namespaceResolved
   },
   "execute-using-require": async ({ fileUrl }) => {
     const { createRequire } = await import("module")
     const { fileURLToPath } = await import("url")
-
     const filePath = fileURLToPath(fileUrl)
     const require = createRequire(fileUrl)
-
     // eslint-disable-next-line import/no-dynamic-require
     const namespace = require(filePath)
-
     const namespaceResolved = {}
     await Promise.all([
       ...Object.keys(namespace).map(async (key) => {

package/src/internal/{runtime/createNodeRuntime/createNodeExecutionWithDynamicImport.js → node_runtime/node_execution_dynamic_import.js}

@@ -2,10 +2,33 @@ 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 createNodeExecutionWithDynamicImport = ({
+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 } = {},
@@ -13,7 +36,6 @@ export const createNodeExecutionWithDynamicImport = ({
     // 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"
@@ -33,14 +55,20 @@ export const createNodeExecutionWithDynamicImport = ({
         }
       }
     }
-
     if (measurePerformance) {
       return measureAsyncFnPerf(importWithDynamicImport, "jsenv_file_import")
     }
     return importWithDynamicImport()
   }
 
-  return {
-    executeFile,
-  }
+  const executionResult = await executeFile(fileRelativeUrl, {
+    errorExposureInConsole,
+    measurePerformance,
+    collectCoverage,
+  })
+
+  return finalizeExecutionResult({
+    ...executionResult,
+    indirectCoverage: global.__indirectCoverage__,
+  })
 }

package/src/internal/node_runtime/node_execution_performance.js

@@ -0,0 +1,67 @@
+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/{runtime/createNodeRuntime/createNodeExecutionWithSystemJs.js → node_runtime/node_execution_systemjs.js}

@@ -1,38 +1,48 @@
 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 { memoize } from "../../memoize.js"
-import { installNodeErrorStackRemapping } from "../../error-stack-remapping/installNodeErrorStackRemapping.js"
-import { fetchSource } from "./fetchSource.js"
-import { createNodeSystem } from "./createNodeSystem.js"
 
-const memoizedCreateNodeSystem = memoize(createNodeSystem)
+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 createNodeExecutionWithSystemJs = ({
+export const execute = async ({
   projectDirectoryUrl,
   compileServerOrigin,
+  fileRelativeUrl,
   outDirectoryRelativeUrl,
   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 = `${outDirectoryRelativeUrl}${compileId}/`
 
-  const importFile = async (specifier) => {
-    const nodeSystem = await memoizedCreateNodeSystem({
-      projectDirectoryUrl,
-      compileServerOrigin,
-      compileDirectoryRelativeUrl,
-      fetchSource,
-      importDefaultExtension,
-    })
-    return makePromiseKeepNodeProcessAlive(nodeSystem.import(specifier))
-  }
-
   const errorTransformer = async (error) => {
     // code can throw something else than an error
     // in that case return it unchanged
@@ -52,7 +62,7 @@ export const createNodeExecutionWithSystemJs = ({
       `${compileServerOrigin}/${compileDirectoryRelativeUrl}`,
     )
 
-    const nodeSystem = await memoizedCreateNodeSystem({
+    const nodeSystem = await createNodeSystem({
       projectDirectoryUrl,
       compileServerOrigin,
       compileDirectoryRelativeUrl,
@@ -88,18 +98,22 @@ export const createNodeExecutionWithSystemJs = ({
         }
       }
     }
-
     if (measurePerformance) {
       return measureAsyncFnPerf(importWithSystemJs, "jsenv_file_import")
     }
     return importWithSystemJs()
   }
 
-  return {
-    compileDirectoryRelativeUrl,
-    importFile,
-    executeFile,
-  }
+  const executionResult = await executeFile(fileRelativeUrl, {
+    errorExposureInConsole,
+    measurePerformance,
+    collectCoverage,
+  })
+
+  return finalizeExecutionResult({
+    ...executionResult,
+    indirectCoverage: global.__indirectCoverage__,
+  })
 }
 
 const makePromiseKeepNodeProcessAlive = async (promise) => {

package/src/internal/{runtime/createNodeRuntime/createNodeSystem.js → node_runtime/node_system.js}

@@ -8,14 +8,14 @@ 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 "../s.js"
+import { require } from "../require.js"
+import "../runtime/s.js"
 import {
   fromFunctionReturningNamespace,
   getJavaScriptModuleResponseError,
   fromFunctionReturningRegisteredModule,
-} from "../module-registration.js"
-import { valueInstall } from "../valueInstall.js"
+} from "../runtime/module-registration.js"
+import { valueInstall } from "../runtime/valueInstall.js"
 import { evalSource } from "./evalSource.js"
 
 export const createNodeSystem = async ({

package/src/internal/runtime/computeCompileIdFromGroupId.js

@@ -1,4 +1,5 @@
 import { createDetailedMessage } from "@jsenv/logger"
+
 import { COMPILE_ID_OTHERWISE } from "../CONSTANTS.js"
 
 export const computeCompileIdFromGroupId = ({ groupId, groupMap }) => {

package/src/internal/runtime/resolveGroup.js

@@ -1,4 +1,4 @@
-import { findHighestVersion } from "../semantic-versioning/index.js"
+import { findHighestVersion } from "../semantic_versioning/index.js"
 
 export const resolveGroup = ({ name, version }, groupMap) => {
   return Object.keys(groupMap).find((compileIdCandidate) => {

package/src/internal/runtime/resolveRuntimeGroup.js

@@ -1,6 +1,6 @@
 /* eslint-env browser, node */
-import { detectBrowser } from "./detectBrowser/detectBrowser.js"
-import { detectNode } from "./detectNode/detectNode.js"
+import { detectBrowser } from "../browser_detection/browser_detection.js"
+import { detectNode } from "../node_runtime/detectNode.js"
 import { resolveGroup } from "./resolveGroup.js"
 
 export const resolveRuntimeGroup = (groupMap) => {