@jsenv/core 25.2.0 → 25.4.0

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,85 @@
+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 } =
+    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,
+    compileProfile,
+    compileId,
+    runtimeReport,
+  }
+}
+
+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/jsenv_remote_directory.js

@@ -6,9 +6,9 @@ import {
   urlToMeta,
   writeFile,
 } from "@jsenv/filesystem"
+import { validateResponseIntegrity } from "@jsenv/integrity"
 
 import { fetchUrl } from "@jsenv/core/src/internal/fetchUrl.js"
-import { validateResponseIntegrity } from "@jsenv/core/src/internal/integrity/integrity_validation.js"
 
 import { originDirectoryConverter } from "./origin_directory_converter.js"
 

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,

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/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

package/src/internal/{dev_server/redirector → redirector}/redirector.html

@@ -8,38 +8,28 @@
   </head>
 
   <body>
-    <script
-      type="importmap"
-      src="../../../../node_resolution.importmap"
-    ></script>
+    <script type="importmap" src="../../../node_resolution.importmap"></script>
     <script type="module">
-      import { scanBrowserRuntimeFeatures } from "../../browser_feature_detection/browser_feature_detection.js"
+      import { scanBrowserRuntimeFeatures } from "../features/browser_feature_detection/browser_feature_detection.js"
 
       const redirect = async () => {
         const redirectTarget = new URLSearchParams(window.location.search).get(
           "redirect",
         )
-        const browserRuntimeFeaturesReport = await scanBrowserRuntimeFeatures({
-          failFastOnFeatureDetection: true,
-        })
-
+        const browserRuntimeProfile = await scanBrowserRuntimeFeatures()
         const href = `${getDirectoryUrl(
-          browserRuntimeFeaturesReport,
+          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 = ({
-        canAvoidCompilation,
-        outDirectoryRelativeUrl,
-        compileId,
-      }) => {
-        if (canAvoidCompilation) {
-          return `/`
+      const getDirectoryUrl = ({ jsenvDirectoryRelativeUrl, compileId }) => {
+        if (compileId) {
+          return `/${jsenvDirectoryRelativeUrl}${compileId}/`
         }
-        return `/${outDirectoryRelativeUrl}${compileId}/`
+        return `/`
       }
 
       redirect()

package/src/internal/url_conversion.js

@@ -150,33 +150,28 @@ const normalizeUrlMappings = (urlMappings, baseUrl) => {
 
 export const serverUrlToCompileInfo = (
   url,
-  { compileServerOrigin, outDirectoryRelativeUrl },
+  { compileServerOrigin, jsenvDirectoryRelativeUrl },
 ) => {
-  const outDirectoryServerUrl = resolveDirectoryUrl(
-    outDirectoryRelativeUrl,
+  const jsenvDirectoryServerUrl = resolveDirectoryUrl(
+    jsenvDirectoryRelativeUrl,
     compileServerOrigin,
   )
   // not inside compile directory -> nothing to compile
-  if (!url.startsWith(outDirectoryServerUrl)) {
+  if (!url.startsWith(jsenvDirectoryServerUrl)) {
     return { insideCompileDirectory: false }
   }
-
-  const afterOutDirectory = url.slice(outDirectoryServerUrl.length)
-
+  const afterJsenvDirectory = url.slice(jsenvDirectoryServerUrl.length)
   // serve files inside /.jsenv/* directly without compilation
   // this is just to allow some files to be written inside outDirectory and read directly
-  // if asked by the client (such as __compile_server_meta__.json)
-  if (!afterOutDirectory.includes("/") || afterOutDirectory[0] === "/") {
+  if (!afterJsenvDirectory.includes("/") || afterJsenvDirectory[0] === "/") {
     return { insideCompileDirectory: true }
   }
-
-  const parts = afterOutDirectory.split("/")
+  const parts = afterJsenvDirectory.split("/")
   const compileId = parts[0]
   // no compileId, we don't know what to compile (not supposed so happen)
   if (compileId === "") {
     return { insideCompileDirectory: true, compileId: null }
   }
-
   const afterCompileId = parts.slice(1).join("/")
   // note: afterCompileId can be '' (but not supposed to happen)
   return { insideCompileDirectory: true, compileId, afterCompileId }
@@ -260,7 +255,7 @@ const originalProjectUrlFromUrl = (
   {
     projectDirectoryUrl,
     compileServerOrigin,
-    outDirectoryRelativeUrl,
+    jsenvDirectoryRelativeUrl,
     compileDirectoryRelativeUrl,
   },
 ) => {
@@ -280,7 +275,7 @@ const originalProjectUrlFromUrl = (
     compileDirectoryRelativeUrl = extractCompileDirectoryRelativeUrl({
       serverUrl,
       compileServerOrigin,
-      outDirectoryRelativeUrl,
+      jsenvDirectoryRelativeUrl,
     })
     if (!compileDirectoryRelativeUrl) {
       return projectUrl
@@ -305,14 +300,14 @@ const originalProjectUrlFromUrl = (
 const extractCompileDirectoryRelativeUrl = ({
   serverUrl,
   compileServerOrigin,
-  outDirectoryRelativeUrl,
+  jsenvDirectoryRelativeUrl,
 }) => {
   const compileInfo = serverUrlToCompileInfo(serverUrl, {
     compileServerOrigin,
-    outDirectoryRelativeUrl,
+    jsenvDirectoryRelativeUrl,
   })
   if (compileInfo.compiledId) {
-    return `${outDirectoryRelativeUrl}${compileInfo.compileId}/`
+    return `${jsenvDirectoryRelativeUrl}${compileInfo.compileId}/`
   }
   return null
 }