@jsenv/core 25.3.0 → 25.4.3

package/src/internal/features/browser_feature_detection/browser_feature_detect_dynamic_import.js

@@ -0,0 +1,20 @@
+import {
+  asBase64Url,
+  executeWithScriptModuleInjection,
+} from "./execute_with_script_module.js"
+
+export const supportsDynamicImport = async () => {
+  const moduleSource = asBase64Url(`export default 42`)
+  try {
+    await executeWithScriptModuleInjection(
+      `window.__jsenv_runtime_test_dynamic_import__ = import(${JSON.stringify(
+        moduleSource,
+      )})`,
+    )
+    const namespace = await window.__jsenv_runtime_test_dynamic_import__
+    delete window.__jsenv_runtime_test_dynamic_import__
+    return namespace.default === 42
+  } catch (e) {
+    return false
+  }
+}

package/src/internal/features/browser_feature_detection/browser_feature_detect_import_assertions_css.js

@@ -0,0 +1,23 @@
+import {
+  asBase64Url,
+  executeWithScriptModuleInjection,
+} from "./execute_with_script_module.js"
+
+export const supportsCssImportAssertions = async () => {
+  const cssBase64Url = asBase64Url("p { color: red; }", "text/css")
+  const moduleSource = asBase64Url(
+    `import css from "${cssBase64Url}" assert { type: "css" }
+  export default css`,
+  )
+  try {
+    await executeWithScriptModuleInjection(
+      `window.__jsenv_runtime_test_css_import_assertion__ = import(${JSON.stringify(
+        moduleSource,
+      )})`,
+    )
+    const namespace = await window.__jsenv_runtime_test_css_import_assertion__
+    return namespace.default instanceof CSSStyleSheet
+  } catch (e) {
+    return false
+  }
+}

package/src/internal/features/browser_feature_detection/browser_feature_detect_import_assertions_json.js

@@ -0,0 +1,25 @@
+import {
+  asBase64Url,
+  executeWithScriptModuleInjection,
+} from "./execute_with_script_module.js"
+
+export const supportsJsonImportAssertions = async () => {
+  const jsonBase64Url = asBase64Url("42", "application/json")
+  const moduleSource = asBase64Url(
+    `import data from "${jsonBase64Url}" assert { type: "json" }
+  export default data`,
+  )
+  try {
+    await executeWithScriptModuleInjection(
+      `window.__jsenv_runtime_test_json_import_assertion__ = import(${JSON.stringify(
+        moduleSource,
+      )})`,
+    )
+    const namespace = await window.__jsenv_runtime_test_json_import_assertion__
+    const supported = namespace.default === 42
+    delete window.__jsenv_runtime_test_json_import_assertion__
+    return supported
+  } catch (e) {
+    return false
+  }
+}

package/src/internal/features/browser_feature_detection/browser_feature_detect_importmap.js

@@ -0,0 +1,37 @@
+import {
+  asBase64Url,
+  executeWithScriptModuleInjection,
+} from "./execute_with_script_module.js"
+
+export const supportsImportmap = async ({ remote = true } = {}) => {
+  const specifier = asBase64Url(`export default false`)
+  const importMap = {
+    imports: {
+      [specifier]: asBase64Url(`export default true`),
+    },
+  }
+  const importmapScript = document.createElement("script")
+  const importmapString = JSON.stringify(importMap, null, "  ")
+  importmapScript.type = "importmap"
+  if (remote) {
+    importmapScript.src = `data:application/json;base64,${window.btoa(
+      importmapString,
+    )}`
+  } else {
+    importmapScript.textContent = importmapString
+  }
+  document.body.appendChild(importmapScript)
+
+  try {
+    await executeWithScriptModuleInjection(
+      `import supported from "${specifier}"; window.__jsenv_runtime_test_importmap__ = supported`,
+    )
+    document.body.removeChild(importmapScript)
+    const supported = window.__jsenv_runtime_test_importmap__
+    delete window.__jsenv_runtime_test_importmap__
+    return supported
+  } catch (e) {
+    document.body.removeChild(importmapScript)
+    return false
+  }
+}

package/src/internal/features/browser_feature_detection/browser_feature_detect_new_stylesheet.js

@@ -0,0 +1,9 @@
+export const supportsNewStylesheet = () => {
+  try {
+    // eslint-disable-next-line no-new
+    new CSSStyleSheet()
+    return true
+  } catch (e) {
+    return false
+  }
+}

package/src/internal/features/browser_feature_detection/browser_feature_detect_top_level_await.js

@@ -0,0 +1,14 @@
+import { executeWithScriptModuleInjection } from "./execute_with_script_module.js"
+
+export const supportsTopLevelAwait = async () => {
+  try {
+    await executeWithScriptModuleInjection(
+      `window.__jsenv_runtime_test_top_level_await__ = await Promise.resolve(42)`,
+    )
+    const supported = window.__jsenv_runtime_test_top_level_await__ === 42
+    delete window.__jsenv_runtime_test_top_level_await__
+    return supported
+  } catch (e) {
+    return false
+  }
+}

package/src/internal/features/browser_feature_detection/browser_feature_detection.js

@@ -0,0 +1,89 @@
+import { fetchJson } from "../../browser_utils/fetchJson.js"
+import { detectBrowser } from "../../browser_detection/browser_detection.js"
+
+import { supportsImportmap } from "./browser_feature_detect_importmap.js"
+import { supportsDynamicImport } from "./browser_feature_detect_dynamic_import.js"
+import { supportsTopLevelAwait } from "./browser_feature_detect_top_level_await.js"
+import { supportsJsonImportAssertions } from "./browser_feature_detect_import_assertions_json.js"
+import { supportsCssImportAssertions } from "./browser_feature_detect_import_assertions_css.js"
+import { supportsNewStylesheet } from "./browser_feature_detect_new_stylesheet.js"
+
+export const scanBrowserRuntimeFeatures = async ({
+  coverageHandledFromOutside = false,
+  forceCompilation = false,
+  forceSource = false,
+} = {}) => {
+  const jsenvCompileProfileUrl = "/__jsenv_compile_profile__"
+  const {
+    jsenvDirectoryRelativeUrl,
+    inlineImportMapIntoHTML,
+    availableCompileIds,
+  } = await fetchJson(jsenvCompileProfileUrl)
+  const { name, version } = detectBrowser()
+  const featuresReport = await detectSupportedFeatures({
+    coverageHandledFromOutside,
+    inlineImportMapIntoHTML,
+  })
+  const runtimeReport = {
+    env: { browser: true },
+    name,
+    version,
+    featuresReport,
+    forceSource,
+    forceCompilation,
+  }
+  const { compileProfile, compileId } = await fetchJson(
+    jsenvCompileProfileUrl,
+    {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+      },
+      body: JSON.stringify(runtimeReport),
+    },
+  )
+  return {
+    jsenvDirectoryRelativeUrl,
+    inlineImportMapIntoHTML,
+    availableCompileIds,
+    runtimeReport,
+    compileProfile,
+    compileId,
+  }
+}
+
+const detectSupportedFeatures = async ({
+  coverageHandledFromOutside,
+  inlineImportMapIntoHTML,
+}) => {
+  const featuresReport = {}
+  featuresReport["import_http"] = true
+  featuresReport["coverage_js"] = coverageHandledFromOutside
+  // new CSSStyleSheet
+  featuresReport["new_stylesheet"] = supportsNewStylesheet()
+  // importmap
+  // start testing importmap support first and not in paralell
+  // so that there is not module script loaded beore importmap is injected
+  // it would log an error in chrome console and return undefined
+  featuresReport.importmap = await supportsImportmap({
+    // chrome supports inline but not remote importmap
+    // https://github.com/WICG/import-maps/issues/235
+    // at this stage we won't know if the html file will use
+    // an importmap or not and if that importmap is inline or specified with an src
+    // so we should test if browser support local and remote importmap.
+    // But there exploring server can inline importmap by transforming html
+    // and in that case we can test only the local importmap support
+    // so we test importmap support and the remote one
+    remote: !inlineImportMapIntoHTML,
+  })
+  // dynamic import
+  featuresReport["import_dynamic"] = await supportsDynamicImport()
+  // top level await
+  featuresReport["top_level_await"] = await supportsTopLevelAwait()
+  // import assertions
+  featuresReport["import_assertion_type_json"] =
+    await supportsJsonImportAssertions()
+  featuresReport["import_assertion_type_css"] =
+    await supportsCssImportAssertions()
+  return featuresReport
+}

package/src/internal/{browser_feature_detection → features/browser_feature_detection}/compile_proxy.html

@@ -15,7 +15,7 @@
     </script>
     <script
       type="importmap"
-      src="../../../node_resolution.importmap"
+      src="../../../../node_resolution.importmap"
     ></script>
     <script type="module">
       import { scanBrowserRuntimeFeatures } from "./browser_feature_detection.js"

package/src/internal/features/browser_feature_detection/execute_with_script_module.js

@@ -0,0 +1,24 @@
+export const executeWithScriptModuleInjection = (code) => {
+  const scriptModule = document.createElement("script")
+  scriptModule.type = "module"
+
+  const loadPromise = new Promise((resolve, reject) => {
+    scriptModule.onload = () => {
+      document.body.removeChild(scriptModule)
+      resolve()
+    }
+    scriptModule.onerror = () => {
+      document.body.removeChild(scriptModule)
+      reject()
+    }
+    document.body.appendChild(scriptModule)
+  })
+
+  scriptModule.src = asBase64Url(code)
+
+  return loadPromise
+}
+
+export const asBase64Url = (text, mimeType = "application/javascript") => {
+  return `data:${mimeType};base64,${window.btoa(text)}`
+}

package/src/internal/features/features_compat_from_runtime.js

@@ -0,0 +1,38 @@
+import { findHighestVersion } from "@jsenv/core/src/internal/semantic_versioning/index.js"
+
+import { featuresCompatMap } from "./features_compatibility.js"
+
+export const featuresCompatFromRuntime = ({
+  runtimeName,
+  runtimeVersion,
+  featureNames,
+}) => {
+  const availableFeatureNames = []
+  // "minRuntimeVersion" is the first version where all
+  // features in "availableFeatureNames" where available
+  // can be lower or equal to "runtimeVersion"
+  let minRuntimeVersion
+  featureNames.forEach((featureName) => {
+    const featureCompat = featuresCompatMap[featureName] || {}
+    const runtimeVersionCompatible = featureCompat[runtimeName] || "Infinity"
+    const highestVersion = findHighestVersion(
+      runtimeVersion,
+      runtimeVersionCompatible,
+    )
+    const compatible = highestVersion === runtimeVersion
+    if (compatible) {
+      availableFeatureNames.push(featureName)
+      if (runtimeVersionCompatible !== "Infinity") {
+        // there is a version from which runtime becomes compatible with this feature
+        minRuntimeVersion = findHighestVersion(
+          minRuntimeVersion || "0.0.0",
+          runtimeVersionCompatible,
+        )
+      }
+    }
+  })
+  return {
+    availableFeatureNames,
+    minRuntimeVersion: minRuntimeVersion || runtimeVersion,
+  }
+}

package/src/internal/features/features_compat_from_runtime_support.js

@@ -0,0 +1,31 @@
+import { featuresCompatFromRuntime } from "./features_compat_from_runtime.js"
+
+export const featuresCompatFromRuntimeSupport = ({
+  runtimeSupport,
+  featureNames,
+}) => {
+  const availableFeatureNames = []
+  const minRuntimeVersions = {}
+  const runtimeNames = Object.keys(runtimeSupport)
+  runtimeNames.forEach((runtimeName) => {
+    const runtimeVersion = runtimeSupport[runtimeName]
+    const runtimeFeaturesCompat = featuresCompatFromRuntime({
+      runtimeName,
+      runtimeVersion,
+      featureNames,
+    })
+
+    minRuntimeVersions[runtimeName] = runtimeFeaturesCompat.minRuntimeVersion
+    runtimeFeaturesCompat.availableFeatureNames.forEach(
+      (availableFeatureName) => {
+        if (!availableFeatureNames.includes(availableFeatureName)) {
+          availableFeatureNames.push(availableFeatureName)
+        }
+      },
+    )
+  })
+  return {
+    availableFeatureNames,
+    minRuntimeVersions,
+  }
+}

package/src/internal/{generateGroupMap → features}/features_compatibility.js

@@ -1,7 +1,7 @@
-import { jsenvBabelPluginCompatMap } from "./babel_plugins_compatibility.js"
+import { babelPluginCompatMap } from "./babel_plugins_compatibility.js"
 
 export const featuresCompatMap = {
-  module: {
+  script_type_module: {
     edge: "16",
     firefox: "60",
     chrome: "61",
@@ -33,5 +33,5 @@ export const featuresCompatMap = {
     android: "80",
   },
   worker_importmap: {},
-  ...jsenvBabelPluginCompatMap,
+  ...babelPluginCompatMap,
 }

package/src/internal/features/node_feature_detection/node_feature_detection.js

@@ -0,0 +1,66 @@
+import { fetchSource } from "@jsenv/core/src/internal/node_runtime/fetchSource.js"
+
+import { nodeSupportsDynamicImport } from "./node_feature_detect_dynamic_import.js"
+import { nodeSupportsTopLevelAwait } from "./node_feature_detect_top_level_await.js"
+
+export const scanNodeRuntimeFeatures = async ({
+  compileServerOrigin,
+  moduleOutFormat,
+  forceSource,
+  forceCompilation,
+  coverageHandledFromOutside,
+}) => {
+  const jsenvCompileProfileServerUrl = new URL(
+    "__jsenv_compile_profile__",
+    compileServerOrigin,
+  ).href
+  const { compileContext } = await fetchJson(jsenvCompileProfileServerUrl)
+  const featuresReport = await detectSupportedFeatures({
+    compileContext,
+    coverageHandledFromOutside,
+  })
+  const runtimeReport = {
+    env: { node: true },
+    name: "node",
+    version: process.version.slice(1),
+    featuresReport,
+    moduleOutFormat,
+    forceSource,
+    forceCompilation,
+  }
+  const { compileProfile, compileId } = await fetchJson(
+    jsenvCompileProfileServerUrl,
+    {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+      },
+      body: JSON.stringify(runtimeReport),
+    },
+  )
+  return {
+    compileProfile,
+    compileId,
+  }
+}
+
+const detectSupportedFeatures = async ({ coverageHandledFromOutside }) => {
+  const featuresReport = {}
+  // Node.js do not support http(s) imports, this information is important
+  // so that we know we cannot use dynamic import
+  featuresReport["import_http"] = false
+  featuresReport["coverage_js"] = coverageHandledFromOutside
+  featuresReport["import_dynamic"] = await nodeSupportsDynamicImport()
+  featuresReport["top_level_await"] = await nodeSupportsTopLevelAwait()
+  return featuresReport
+}
+
+const fetchJson = async (url, options) => {
+  const response = await fetchSource(url, options)
+  const status = response.status
+  if (status !== 200) {
+    throw new Error(`unexpected response status for ${url}, got ${status}`)
+  }
+  const object = await response.json()
+  return object
+}

package/src/internal/import-resolution/importmap_default.js

@@ -18,7 +18,6 @@ export const getDefaultImportmap = (
     jsenvCoreDirectoryUrl,
     projectDirectoryUrl,
   )
-
   let jsenvCoreUrl
   if (compileDirectoryUrl && urlIsInsideOf(url, compileDirectoryUrl)) {
     jsenvCoreUrl = resolveUrl(
@@ -28,25 +27,11 @@ export const getDefaultImportmap = (
   } else {
     jsenvCoreUrl = jsenvCoreDirectoryUrl
   }
-
+  const jsenvCoreRelativeUrl = urlToRelativeUrl(jsenvCoreUrl, url)
   const importmap = {
     imports: {
-      "@jsenv/core/": makeRelativeMapping(jsenvCoreUrl, url),
+      "@jsenv/core/": `./${jsenvCoreRelativeUrl}`,
     },
   }
   return importmap
 }
-
-// this function just here to ensure relative urls starts with './'
-// so that importmap do not consider them as bare specifiers
-const makeRelativeMapping = (url, baseUrl) => {
-  const relativeUrl = urlToRelativeUrl(url, baseUrl)
-
-  if (urlIsInsideOf(url, baseUrl)) {
-    if (relativeUrl.startsWith("../")) return relativeUrl
-    if (relativeUrl.startsWith("./")) return relativeUrl
-    return `./${relativeUrl}`
-  }
-
-  return relativeUrl
-}

package/src/internal/node_launcher/createControllableNodeProcess.js

@@ -1,15 +1,16 @@
 import { fork } from "node:child_process"
-import { uneval } from "@jsenv/uneval"
-import { createLogger, createDetailedMessage } from "@jsenv/logger"
 import { urlToFileSystemPath, assertFilePresence } from "@jsenv/filesystem"
+import { createLogger, createDetailedMessage } from "@jsenv/logger"
 import {
   Abort,
   raceCallbacks,
   createCallbackList,
   createCallbackListNotifiedOnce,
 } from "@jsenv/abort"
+import { uneval } from "@jsenv/uneval"
+
+import { nodeSupportsDynamicImport } from "@jsenv/core/src/internal/features/node_feature_detection/node_feature_detect_dynamic_import.js"
 
-import { nodeSupportsDynamicImport } from "../node_feature_detection/nodeSupportsDynamicImport.js"
 import { createChildProcessOptions } from "./createChildProcessOptions.js"
 import {
   processOptionsFromExecArgv,
@@ -276,7 +277,6 @@ export const createControllableNodeProcess = async ({
 
 const sendToProcess = async (childProcess, type, data) => {
   const source = uneval(data, { functionAllowed: true })
-
   return new Promise((resolve, reject) => {
     childProcess.send({ type, data: source }, (error) => {
       if (error) {
@@ -294,12 +294,10 @@ const installProcessOutputListener = (childProcess, callback) => {
     callback({ type: "log", text: String(chunk) })
   }
   childProcess.stdout.on("data", stdoutDataCallback)
-
   const stdErrorDataCallback = (chunk) => {
     callback({ type: "error", text: String(chunk) })
   }
   childProcess.stderr.on("data", stdErrorDataCallback)
-
   return () => {
     childProcess.stdout.removeListener("data", stdoutDataCallback)
     childProcess.stderr.removeListener("data", stdoutDataCallback)

package/src/internal/node_launcher/node_runtime_report.js

@@ -1,17 +1,21 @@
-import { scanNodeRuntimeFeatures } from "@jsenv/core/src/internal/node_feature_detection/node_feature_detection.js"
+import { scanNodeRuntimeFeatures } from "@jsenv/core/src/internal/features/node_feature_detection/node_feature_detection.js"
 
 export const getNodeRuntimeReport = async ({
   runtime,
   compileServerId,
   compileServerOrigin,
-  outDirectoryRelativeUrl,
+
+  moduleOutFormat,
+  forceCompilation,
   coverageHandledFromOutside,
 }) => {
   const cache = cacheFromParams({
     runtime,
     compileServerId,
     compileServerOrigin,
-    outDirectoryRelativeUrl,
+
+    moduleOutFormat,
+    forceCompilation,
     coverageHandledFromOutside,
   })
   const entry = cache.read()
@@ -20,7 +24,8 @@ export const getNodeRuntimeReport = async ({
   }
   const nodeRuntimeFeaturesReport = await scanNodeRuntimeFeatures({
     compileServerOrigin,
-    outDirectoryRelativeUrl,
+    moduleOutFormat,
+    forceCompilation,
     coverageHandledFromOutside,
   })
   cache.write(nodeRuntimeFeaturesReport)
@@ -32,16 +37,19 @@ let currentCacheValue
 const cacheFromParams = ({
   compileServerId,
   compileServerOrigin,
-  outDirectoryRelativeUrl,
+
+  moduleOutFormat,
+  forceCompilation,
   coverageHandledFromOutside,
 }) => {
   const params = {
     compileServerId,
     compileServerOrigin,
-    outDirectoryRelativeUrl,
+
+    moduleOutFormat,
+    forceCompilation,
     coverageHandledFromOutside,
   }
-
   if (!currentCacheParams) {
     currentCacheParams = params
     return {
@@ -51,7 +59,6 @@ const cacheFromParams = ({
       },
     }
   }
-
   if (JSON.stringify(currentCacheParams) !== JSON.stringify(params)) {
     return {
       read: () => null,
@@ -61,7 +68,6 @@ const cacheFromParams = ({
       },
     }
   }
-
   return {
     read: () => currentCacheValue,
     write: (value) => {

package/src/internal/node_runtime/fetchSource.js

@@ -1,10 +1,8 @@
 import { fetchUrl } from "../fetchUrl.js"
 
-export const fetchSource = (url, { executionId } = {}) => {
+export const fetchSource = (url, options) => {
   return fetchUrl(url, {
     ignoreHttpsError: true,
-    headers: {
-      ...(executionId ? { "x-jsenv-execution-id": executionId } : {}),
-    },
+    ...options,
   })
 }

package/src/internal/node_runtime/nodeControllableFile.mjs

@@ -59,8 +59,7 @@ const sendActionFailed = (error) => {
   sendToParent(
     ACTION_RESPONSE_EVENT_NAME,
     // process.send algorithm does not send non enumerable values
-    // because it works with JSON.stringify I guess so use uneval
-
+    // so use @jsenv/uneval
     uneval(
       {
         status: ACTION_RESPONSE_STATUS_FAILED,
@@ -91,7 +90,6 @@ const sendToParent = (type, data) => {
   if (!process.connected) {
     return
   }
-
   // this can keep process alive longer than expected
   // when source is a long string.
   // It means node process may stay alive longer than expected
@@ -111,11 +109,9 @@ const onceProcessMessage = (type, callback) => {
       callback(eval(`(${event.data})`))
     }
   }
-
   const removeListener = () => {
     process.removeListener("message", listener)
   }
-
   process.on("message", listener)
   return removeListener
 }

package/src/internal/node_runtime/node_execution_systemjs.js

@@ -12,7 +12,7 @@ export const execute = async ({
   projectDirectoryUrl,
   compileServerOrigin,
   fileRelativeUrl,
-  outDirectoryRelativeUrl,
+  jsenvDirectoryRelativeUrl,
   compileId,
   importDefaultExtension,
   // do not log in the console
@@ -25,7 +25,6 @@ export const execute = async ({
   collectPerformance,
 }) => {
   let finalizeExecutionResult = (result) => result
-
   if (collectPerformance) {
     const getPerformance = startObservingPerformances()
     finalizeExecutionResult = async (executionResult) => {
@@ -36,12 +35,10 @@ export const execute = async ({
       }
     }
   }
-
   const { getErrorOriginalStackString } = installNodeErrorStackRemapping({
     projectDirectoryUrl,
   })
-
-  const compileDirectoryRelativeUrl = `${outDirectoryRelativeUrl}${compileId}/`
+  const compileDirectoryRelativeUrl = `${jsenvDirectoryRelativeUrl}${compileId}/`
 
   const errorTransformer = async (error) => {
     // code can throw something else than an error