@jsenv/core 25.6.2 → 27.0.0-alpha.0

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

@@ -1,25 +0,0 @@
-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

@@ -1,37 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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

@@ -1,89 +0,0 @@
-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/features/browser_feature_detection/compile_proxy.html

@@ -1,27 +0,0 @@
-<!DOCTYPE html>
-<html>
-  <head>
-    <title>Compile proxy</title>
-    <meta name="viewport" content="width=device-width, initial-scale=1" />
-    <meta charset="utf-8" />
-    <link rel="icon" href="data:," />
-  </head>
-
-  <body>
-    <script>
-      window.readyPromise = new Promise((resolve) => {
-        window.resolveReadyPromise = resolve
-      })
-    </script>
-    <script
-      type="importmap"
-      src="../../../../node_resolution.importmap"
-    ></script>
-    <script type="module">
-      import { scanBrowserRuntimeFeatures } from "./browser_feature_detection.js"
-
-      window.scanBrowserRuntimeFeatures = scanBrowserRuntimeFeatures
-      window.resolveReadyPromise()
-    </script>
-  </body>
-</html>

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

@@ -1,24 +0,0 @@
-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

@@ -1,38 +0,0 @@
-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

@@ -1,31 +0,0 @@
-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/features/features_compatibility.js

@@ -1,37 +0,0 @@
-import { babelPluginCompatMap } from "./babel_plugins_compatibility.js"
-
-export const featuresCompatMap = {
-  script_type_module: {
-    edge: "16",
-    firefox: "60",
-    chrome: "61",
-    safari: "10.1",
-    opera: "48",
-    ios: "10.3",
-    android: "61",
-    samsung: "8.2",
-  },
-  // https://caniuse.com/import-maps
-  importmap: {
-    edge: "89",
-    chrome: "89",
-    opera: "76",
-    samsung: "15",
-  },
-  import_assertion_type_json: {
-    chrome: "91",
-    edge: "91",
-  },
-  import_assertion_type_css: {
-    chrome: "93",
-    edge: "93",
-  },
-  worker_type_module: {
-    chrome: "80",
-    edge: "80",
-    opera: "67",
-    android: "80",
-  },
-  worker_importmap: {},
-  ...babelPluginCompatMap,
-}

package/src/internal/features/node_feature_detection/feature_detect_dynamic_import.mjs

@@ -1,5 +0,0 @@
-const jsAsBase64 = Buffer.from("export default 42").toString("base64")
-const moduleSource = `data:text/javascript;base64,${jsAsBase64}`
-const namespacePromise = import(moduleSource)
-
-export default namespacePromise

package/src/internal/features/node_feature_detection/feature_detect_top_level_await.mjs

@@ -1 +0,0 @@
-export default await Promise.resolve(42)

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

@@ -1,5 +0,0 @@
-import { memoize } from "@jsenv/filesystem"
-
-export const nodeSupportsDynamicImport = memoize(async () => {
-  return true
-})

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

@@ -1,16 +0,0 @@
-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/features/node_feature_detection/node_feature_detection.js

@@ -1,66 +0,0 @@
-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/fetchUrl.js

@@ -1,28 +0,0 @@
-import { globalAgent } from "node:https"
-import { fetchUrl as serverFetchUrl } from "@jsenv/server"
-import { headersToObject } from "@jsenv/server/src/internal/headersToObject.js"
-
-// ideally we should only pass this to the fetch below
-globalAgent.options.rejectUnauthorized = false
-
-export const fetchUrl = async (
-  url,
-  { ignoreHttpsError = true, ...rest } = {},
-) => {
-  const response = await serverFetchUrl(url, {
-    ignoreHttpsError,
-    ...rest,
-  })
-  const responseObject = {
-    url: response.url,
-    type: "default",
-    status: response.status,
-    statusText: response.statusText,
-    headers: headersToObject(response.headers),
-    text: response.text.bind(response),
-    json: response.json.bind(response),
-    blob: response.blob.bind(response),
-    arrayBuffer: response.arrayBuffer.bind(response),
-  }
-  return responseObject
-}

package/src/internal/filePathUtils.js

@@ -1,19 +0,0 @@
-export const isWindowsFilePath = (path) =>
-  startsWithWindowsDriveLetter(path) && path[2] === "\\"
-
-export const startsWithWindowsDriveLetter = (string) => {
-  const firstChar = string[0]
-  if (!/[a-zA-Z]/.test(firstChar)) return false
-
-  const secondChar = string[1]
-  if (secondChar !== ":") return false
-
-  return true
-}
-
-export const windowsFilePathToUrl = (windowsFilePath) => {
-  return `file:///${replaceBackSlashesWithSlashes(windowsFilePath)}`
-}
-
-export const replaceBackSlashesWithSlashes = (string) =>
-  string.replace(/\\/g, "/")

package/src/internal/import-resolution/default-extension.js

@@ -1,40 +0,0 @@
-export const applyDefaultExtension = (specifier, importer) => {
-  if (!importer) {
-    return specifier
-  }
-
-  const importerExtension = urlToExtension(importer)
-  const fakeUrl = new URL(specifier, importer).href
-  const specifierExtension = urlToExtension(fakeUrl)
-  if (specifierExtension !== "") {
-    return specifier
-  }
-
-  // I guess typescript still expect default extension to be .ts
-  // in a tsx file.
-  if (importerExtension === "tsx") {
-    return `${specifier}.ts`
-  }
-
-  // extension magic
-  return `${specifier}${importerExtension}`
-}
-
-const urlToExtension = (url) => {
-  return pathnameToExtension(urlToPathname(url))
-}
-
-const urlToPathname = (url) => new URL(url).pathname
-
-const pathnameToExtension = (pathname) => {
-  const slashLastIndex = pathname.lastIndexOf("/")
-  if (slashLastIndex !== -1) {
-    pathname = pathname.slice(slashLastIndex + 1)
-  }
-
-  const dotLastIndex = pathname.lastIndexOf(".")
-  if (dotLastIndex === -1) return ""
-  // if (dotLastIndex === pathname.length - 1) return ""
-  const extension = pathname.slice(dotLastIndex)
-  return extension
-}

package/src/internal/import-resolution/import-resolver-importmap.js

@@ -1,64 +0,0 @@
-import { createDetailedMessage } from "@jsenv/logger"
-import { resolveImport } from "@jsenv/importmap/src/resolveImport.js"
-
-import { tryToFindProjectRelativeUrl } from "@jsenv/core/src/internal/runtime/module-registration.js"
-
-import { applyDefaultExtension } from "./default-extension.js"
-
-export const createImportResolverForImportmap = async ({
-  // projectDirectoryUrl,
-  compileServerOrigin,
-  compileDirectoryRelativeUrl,
-  importMap,
-  importMapUrl,
-  importDefaultExtension,
-  onBareSpecifierError = () => {},
-}) => {
-  const _resolveImport = (specifier, importer) => {
-    if (importDefaultExtension) {
-      specifier = applyDefaultExtension(specifier, importer)
-    }
-    return resolveImport({
-      specifier,
-      importer,
-      importMap,
-      createBareSpecifierError: ({ specifier, importer }) => {
-        const bareSpecifierError = createBareSpecifierError({
-          specifier,
-          importer:
-            tryToFindProjectRelativeUrl(importer, {
-              compileServerOrigin,
-              compileDirectoryRelativeUrl,
-            }) || importer,
-          importMapUrl:
-            tryToFindProjectRelativeUrl(importMapUrl, {
-              compileServerOrigin,
-              compileDirectoryRelativeUrl,
-            }) || importMapUrl,
-          importMap,
-        })
-        onBareSpecifierError(bareSpecifierError)
-        return bareSpecifierError
-      },
-    })
-  }
-
-  return { resolveImport: _resolveImport }
-}
-
-const createBareSpecifierError = ({ specifier, importer, importMapUrl }) => {
-  const detailedMessage = createDetailedMessage("Unmapped bare specifier.", {
-    specifier,
-    importer,
-    ...(importMapUrl
-      ? {
-          "how to fix": `Add a mapping for "${specifier}" into the importmap file at "${importMapUrl}"`,
-        }
-      : {
-          "how to fix": `Add an importmap with a mapping for "${specifier}"`,
-          "suggestion": `Generate importmap using https://github.com/jsenv/importmap-node-module`,
-        }),
-  })
-
-  return new Error(detailedMessage)
-}