@jsenv/core 24.2.1 → 24.3.3

package/src/internal/dev_server/toolbar/toolbar.injector.js

@@ -1,6 +1,10 @@
 import { fetchExploringJson } from "@jsenv/core/src/internal/dev_server/exploring/fetchExploringJson.js"
 import { setAttributes, setStyles } from "./util/dom.js"
 
+// eslint-disable-next-line no-undef
+const TOOLBAR_BUILD_RELATIVE_URL = __TOOLBAR_BUILD_RELATIVE_URL_
+const jsenvLogoSvgUrl = new URL("./jsenv-logo.svg", import.meta.url)
+
 const injectToolbar = async () => {
   await new Promise((resolve) => {
     if (window.requestIdleCallback) {
@@ -40,7 +44,7 @@ const injectToolbar = async () => {
   })
   const iframeLoadedPromise = iframeToLoadedPromise(iframe)
   const jsenvToolbarHtmlServerUrl = resolveUrl(
-    "./src/internal/dev_server/toolbar/toolbar.html",
+    TOOLBAR_BUILD_RELATIVE_URL,
     jsenvDirectoryServerUrl,
   )
   // set iframe src BEFORE putting it into the DOM (prevent firefox adding an history entry)
@@ -50,40 +54,11 @@ const injectToolbar = async () => {
   await iframeLoadedPromise
   iframe.removeAttribute("tabindex")
 
-  const listenToolbarIframeEvent = (event, fn) => {
-    window.addEventListener(
-      "message",
-      (messageEvent) => {
-        const { data } = messageEvent
-        if (typeof data !== "object") return
-        const { jsenv } = data
-        if (!jsenv) return
-        const { type } = data
-        if (type !== event) return
-        fn(data.value)
-      },
-      false,
-    )
-  }
-
-  listenToolbarIframeEvent("toolbar-visibility-change", (visible) => {
-    if (visible) {
-      hideToolbarTrigger()
-    } else {
-      showToolbarTrigger()
-    }
-  })
-
   const div = document.createElement("div")
-  const jsenvLogoUrl = resolveUrl(
-    "./src/internal/dev_server/toolbar/jsenv-logo.svg",
-    jsenvDirectoryServerUrl,
-  )
-  const jsenvLogoSvgSrc = jsenvLogoUrl
   div.innerHTML = `
 <div id="jsenv-toolbar-trigger">
   <svg id="jsenv-toolbar-trigger-icon">
-    <use xlink:href="${jsenvLogoSvgSrc}#jsenv-logo"></use>
+    <use xlink:href="${jsenvLogoSvgUrl}#jsenv-logo"></use>
   </svg>
   <style>
     #jsenv-toolbar-trigger {
@@ -148,7 +123,7 @@ const injectToolbar = async () => {
     collapseToolbarTrigger()
   }
   toolbarTrigger.onclick = () => {
-    window.__jsenv__.toolbar.show()
+    sendCommandToToolbar(iframe, "showToolbar")
   }
 
   const showToolbarTrigger = () => {
@@ -166,13 +141,56 @@ const injectToolbar = async () => {
   const collapseToolbarTrigger = () => {
     toolbarTrigger.removeAttribute("data-expanded", "")
   }
-  hideToolbarTrigger()
 
-  iframe.contentWindow.renderToolbar()
+  hideToolbarTrigger()
+  addToolbarEventCallback(iframe, "toolbar-visibility-change", (visible) => {
+    if (visible) {
+      hideToolbarTrigger()
+    } else {
+      showToolbarTrigger()
+    }
+  })
+  addToolbarEventCallback(iframe, "toolbar_ready", () => {
+    sendCommandToToolbar(iframe, "renderToolbar")
+  })
 
   return iframe
 }
 
+const addToolbarEventCallback = (iframe, eventName, callback) => {
+  const messageEventCallback = (messageEvent) => {
+    const { data } = messageEvent
+    if (typeof data !== "object") {
+      return
+    }
+    const { __jsenv__ } = data
+    if (!__jsenv__) {
+      return
+    }
+    if (__jsenv__.event !== eventName) {
+      return
+    }
+    callback(__jsenv__.data)
+  }
+
+  window.addEventListener("message", messageEventCallback, false)
+  return () => {
+    window.removeEventListener("message", messageEventCallback, false)
+  }
+}
+
+const sendCommandToToolbar = (iframe, command, ...args) => {
+  iframe.contentWindow.postMessage(
+    {
+      __jsenv__: {
+        command,
+        args,
+      },
+    },
+    window.origin,
+  )
+}
+
 const getToolbarPlaceholder = () => {
   const placeholder = queryPlaceholder()
   if (placeholder) {
@@ -188,8 +206,9 @@ const getToolbarPlaceholder = () => {
   return createTooolbarPlaceholder()
 }
 
-const queryPlaceholder = () =>
-  document.querySelector("[data-jsenv-toolbar-placeholder]")
+const queryPlaceholder = () => {
+  return document.querySelector("[data-jsenv-toolbar-placeholder]")
+}
 
 const createTooolbarPlaceholder = () => {
   const placeholder = document.createElement("span")

package/src/internal/dev_server/toolbar/toolbar.main.js

@@ -4,7 +4,6 @@ import { urlToRelativeUrl } from "@jsenv/filesystem/src/urlToRelativeUrl.js"
 import { fetchExploringJson } from "../exploring/fetchExploringJson.js"
 import { startJavaScriptAnimation } from "../toolbar/util/animation.js"
 import "./focus/toolbar.focus.js"
-import { renderBackToListInToolbar } from "./backtolist/toolbar.backtolist.js"
 import {
   getToolbarIframe,
   deactivateToolbarSection,
@@ -45,16 +44,6 @@ const renderToolbar = async () => {
     hideSettings()
   }
 
-  const toolbarElement = document.querySelector("#toolbar")
-  exposeOnParentWindow({
-    toolbar: {
-      element: toolbarElement,
-      show: showToolbar,
-      hide: () => hideToolbar(),
-      toggle: toogleToolbar,
-    },
-  })
-
   const toolbarVisible = toolbarVisibilityPreference.has()
     ? toolbarVisibilityPreference.get()
     : true
@@ -65,11 +54,6 @@ const renderToolbar = async () => {
     hideToolbar({ animate: false })
   }
 
-  renderBackToListInToolbar({
-    outDirectoryRelativeUrl,
-    exploringHtmlFileRelativeUrl: exploringConfig.exploringHtmlFileRelativeUrl,
-  })
-
   renderToolbarNotification()
   makeToolbarResponsive()
   renderToolbarSettings()
@@ -91,16 +75,6 @@ const renderToolbar = async () => {
     toogleToolbar()
 }
 
-const exposeOnParentWindow = (object) => {
-  let { __jsenv__ } = window.parent
-  if (!__jsenv__) {
-    __jsenv__ = {}
-    window.parent.__jsenv__ = {}
-  }
-
-  Object.assign(__jsenv__, object)
-}
-
 const toogleToolbar = () => {
   if (toolbarIsVisible()) {
     hideToolbar()
@@ -213,15 +187,55 @@ const getCompileGroup = ({
   }
 }
 
-const sendEventToParent = (type, value) => {
+const addExternalCommandCallback = (command, callback) => {
+  const messageEventCallback = (messageEvent) => {
+    const { data } = messageEvent
+    if (typeof data !== "object") {
+      return
+    }
+    const { __jsenv__ } = data
+    if (!__jsenv__) {
+      return
+    }
+
+    if (__jsenv__.command !== command) {
+      return
+    }
+
+    callback(...__jsenv__.args)
+  }
+
+  window.addEventListener("message", messageEventCallback)
+  return () => {
+    window.removeEventListener("message", messageEventCallback)
+  }
+}
+
+const sendEventToParent = (name, data) => {
   window.parent.postMessage(
     {
-      jsenv: true,
-      type,
-      value,
+      __jsenv__: {
+        event: name,
+        data,
+      },
     },
     "*",
   )
 }
 
-window.renderToolbar = renderToolbar
+window.toolbar = {
+  render: renderToolbar,
+  show: showToolbar,
+  hide: () => hideToolbar(),
+}
+
+addExternalCommandCallback("renderToolbar", () => {
+  renderToolbar()
+})
+addExternalCommandCallback("showToolbar", () => {
+  showToolbar()
+})
+addExternalCommandCallback("hideToolbar", () => {
+  hideToolbar()
+})
+sendEventToParent("toolbar_ready")

package/src/internal/dev_server/toolbar/util/fetching.js

@@ -6,7 +6,7 @@ const fetchPolyfill = async (...args) => {
 }
 
 const loadPolyfill = memoize(() =>
-  import("../../../browser-utils/fetchUsingXHR.js"),
+  import("../../../browser_utils/fetchUsingXHR.js"),
 )
 
 export const fetchUrl =

package/src/internal/executing/executeConcurrently.js

@@ -27,8 +27,7 @@ export const executeConcurrently = async (
     launchAndExecuteLogLevel,
 
     projectDirectoryUrl,
-    compileServerOrigin,
-    outDirectoryRelativeUrl,
+    compileServer,
 
     babelPluginMap,
 
@@ -206,8 +205,10 @@ export const executeConcurrently = async (
           coverageTempDirectoryUrl,
           runtimeParams: {
             projectDirectoryUrl,
-            compileServerOrigin,
-            outDirectoryRelativeUrl,
+            compileServerOrigin: compileServer.origin,
+            compileServerId: compileServer.id,
+            outDirectoryRelativeUrl: compileServer.outDirectoryRelativeUrl,
+
             collectCoverage: coverage,
             coverageIgnorePredicate,
             coverageForceIstanbul,

package/src/internal/executing/executePlan.js

@@ -146,8 +146,7 @@ export const executePlan = async (
       launchAndExecuteLogLevel,
 
       projectDirectoryUrl,
-      compileServerOrigin: compileServer.origin,
-      outDirectoryRelativeUrl: compileServer.outDirectoryRelativeUrl,
+      compileServer,
 
       // not sure we actually have to pass import params to executeConcurrently
       importResolutionMethod,

package/src/internal/generateGroupMap/one_runtime_compat.js

@@ -1,4 +1,4 @@
-import { findHighestVersion } from "../semantic-versioning/index.js"
+import { findHighestVersion } from "../semantic_versioning/index.js"
 
 export const createOneRuntimeCompat = ({
   runtimeName,

package/src/internal/generateGroupMap/runtime_compat_composition.js

@@ -1,4 +1,4 @@
-import { findHighestVersion } from "../semantic-versioning/index.js"
+import { findHighestVersion } from "../semantic_versioning/index.js"
 
 export const composeMinRuntimeVersions = (
   firstMinRuntimeVersions,

package/src/internal/generateGroupMap/runtime_support.js

@@ -1,4 +1,4 @@
-import { findLowestVersion } from "../semantic-versioning/findLowestVersion.js"
+import { findLowestVersion } from "../semantic_versioning/findLowestVersion.js"
 
 export const isNodePartOfSupportedRuntimes = (runtimeSupport) => {
   return Boolean(runtimeSupport.node)

package/src/internal/jsenvInternalFiles.js

@@ -14,32 +14,6 @@ export const jsenvNodeSystemFileInfo = {
   ),
 }
 
-export const jsenvBrowserSystemFileInfo = {
-  jsenvRelativeUrl: "./src/internal/browser-launcher/jsenv-browser-system.js",
-  jsenvBuildRelativeUrl: "./jsenv_browser_system.js",
-  jsenvBuildUrl: resolveUrl(
-    "./dist/jsenv_browser_system.js",
-    jsenvCoreDirectoryUrl,
-  ),
-}
-
-export const jsenvCompileProxyHtmlFileInfo = {
-  jsenvRelativeUrl: "./src/internal/browser-launcher/jsenv_compile_proxy.html",
-  url: resolveUrl(
-    "./src/internal/browser-launcher/jsenv_compile_proxy.html",
-    jsenvCoreDirectoryUrl,
-  ),
-}
-
-export const jsenvCompileProxyFileInfo = {
-  jsenvRelativeUrl: "./src/internal/browser-launcher/jsenv_compile_proxy.js",
-  jsenvBuildRelativeUrl: "./jsenv_compile_proxy.js",
-  jsenvBuildUrl: resolveUrl(
-    "./dist/jsenv_compile_proxy.js",
-    jsenvCoreDirectoryUrl,
-  ),
-}
-
 export const sourcemapMainFileInfo = {
   url: fileSystemPathToUrl(require.resolve("source-map/dist/source-map.js")),
 }

package/src/internal/jsenv_builds.js

@@ -0,0 +1,19 @@
+import { readFile } from "@jsenv/filesystem"
+
+import { jsenvCoreDirectoryUrl } from "./jsenvCoreDirectoryUrl.js"
+
+export const getJsenvBuildUrl = async (buildRelativeUrlWithoutHash) => {
+  try {
+    const manifest = await readFile(
+      new URL("./dist/manifest.json", jsenvCoreDirectoryUrl),
+      { as: "json" },
+    )
+    const buildRelativeUrl = manifest[buildRelativeUrlWithoutHash]
+    return new URL(buildRelativeUrl, jsenvCoreDirectoryUrl).href
+  } catch (e) {
+    if (e.code === "ENOENT") {
+      return null
+    }
+    throw e
+  }
+}

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) => {