@jsenv/core 25.2.0 → 25.4.0

package/src/internal/browser_feature_detection/browser_feature_detection.js

@@ -1,274 +0,0 @@
-/* eslint-env browser */
-
-import { computeCompileIdFromGroupId } from "../runtime/computeCompileIdFromGroupId.js"
-import { resolveGroup } from "../runtime/resolveGroup.js"
-import { fetchJson } from "../browser_utils/fetchJson.js"
-import { detectBrowser } from "../browser_detection/browser_detection.js"
-
-export const scanBrowserRuntimeFeatures = async ({
-  coverageHandledFromOutside = false,
-  failFastOnFeatureDetection = false,
-} = {}) => {
-  const {
-    outDirectoryRelativeUrl,
-    inlineImportMapIntoHTML,
-    customCompilerPatterns,
-    compileServerGroupMap,
-  } = await fetchJson("/.jsenv/__compile_server_meta__.json")
-
-  const browser = detectBrowser()
-  const compileId = computeCompileIdFromGroupId({
-    groupId: resolveGroup(browser, compileServerGroupMap),
-    groupMap: compileServerGroupMap,
-  })
-  const groupInfo = compileServerGroupMap[compileId]
-
-  const featuresReport = {
-    importmap: undefined,
-    dynamicImport: undefined,
-    topLevelAwait: undefined,
-    jsonImportAssertions: undefined,
-    cssImportAssertions: undefined,
-    newStylesheet: undefined,
-  }
-  await detectSupportedFeatures({
-    featuresReport,
-    failFastOnFeatureDetection,
-    inlineImportMapIntoHTML,
-  })
-  const missingFeatureNames = await adjustMissingFeatureNames(groupInfo, {
-    featuresReport,
-    coverageHandledFromOutside,
-  })
-
-  const canAvoidCompilation =
-    customCompilerPatterns.length === 0 &&
-    missingFeatureNames.length === 0 &&
-    featuresReport.importmap &&
-    featuresReport.dynamicImport &&
-    featuresReport.topLevelAwait
-
-  return {
-    canAvoidCompilation,
-    featuresReport,
-    customCompilerPatterns,
-    missingFeatureNames,
-    inlineImportMapIntoHTML,
-    outDirectoryRelativeUrl,
-    compileId,
-    browser,
-  }
-}
-
-const adjustMissingFeatureNames = async (
-  groupInfo,
-  { featuresReport, coverageHandledFromOutside },
-) => {
-  const { missingFeatureNames } = groupInfo
-  const missingFeatureNamesCopy = missingFeatureNames.slice()
-  const markAsSupported = (name) => {
-    const index = missingFeatureNamesCopy.indexOf(name)
-    if (index > -1) {
-      missingFeatureNamesCopy.splice(index, 1)
-    }
-  }
-  // When instrumentation CAN be handed by playwright
-  // https://playwright.dev/docs/api/class-chromiumcoverage#chromiumcoveragestartjscoverageoptions
-  // coverageHandledFromOutside is true and "transform-instrument" becomes non mandatory
-  if (coverageHandledFromOutside) {
-    markAsSupported("transform-instrument")
-  }
-  if (missingFeatureNames.includes("transform-import-assertions")) {
-    const jsonImportAssertions = await supportsJsonImportAssertions()
-    featuresReport.jsonImportAssertions = jsonImportAssertions
-
-    const cssImportAssertions = await supportsCssImportAssertions()
-    featuresReport.cssImportAssertions = cssImportAssertions
-
-    if (jsonImportAssertions && cssImportAssertions) {
-      markAsSupported("transform-import-assertions")
-    }
-  }
-  if (missingFeatureNames.includes("new-stylesheet-as-jsenv-import")) {
-    const newStylesheet = supportsNewStylesheet()
-    featuresReport.newStylesheet = newStylesheet
-    markAsSupported("new-stylesheet-as-jsenv-import")
-  }
-  return missingFeatureNamesCopy
-}
-
-const detectSupportedFeatures = async ({
-  featuresReport,
-  failFastOnFeatureDetection,
-  inlineImportMapIntoHTML,
-}) => {
-  // 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
-  const 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,
-  })
-  featuresReport.importmap = importmap
-  if (!importmap && failFastOnFeatureDetection) {
-    return
-  }
-
-  const dynamicImport = await supportsDynamicImport()
-  featuresReport.dynamicImport = dynamicImport
-  if (!dynamicImport && failFastOnFeatureDetection) {
-    return
-  }
-
-  const topLevelAwait = await supportsTopLevelAwait()
-  featuresReport.topLevelAwait = topLevelAwait
-  if (!topLevelAwait && failFastOnFeatureDetection) {
-    return
-  }
-}
-
-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)
-    return window.__jsenv_runtime_test_importmap__
-  } catch (e) {
-    document.body.removeChild(importmapScript)
-    return false
-  }
-}
-
-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__
-    return namespace.default === 42
-  } catch (e) {
-    return false
-  }
-}
-
-const supportsNewStylesheet = () => {
-  try {
-    // eslint-disable-next-line no-new
-    new CSSStyleSheet()
-    return true
-  } catch (e) {
-    return false
-  }
-}
-
-const supportsTopLevelAwait = async () => {
-  try {
-    await executeWithScriptModuleInjection(
-      `window.__jsenv_runtime_test_top_level_await__ = await Promise.resolve(42)`,
-    )
-    return window.__jsenv_runtime_test_top_level_await__ === 42
-  } catch (e) {
-    return false
-  }
-}
-
-// to execute in a browser devtools
-// const featuresReport = {}
-// await detectSupportedFeatures({ featuresReport, inlineImportMapIntoHTML: true })
-// console.log(featuresReport)
-
-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__
-    return namespace.default === 42
-  } catch (e) {
-    return false
-  }
-}
-
-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
-  }
-}
-
-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
-}
-
-const asBase64Url = (text, mimeType = "application/javascript") => {
-  return `data:${mimeType};base64,${window.btoa(text)}`
-}
-
-// const cssImportAssertions = await supportsCssImportAssertions()
-// console.log({ cssImportAssertions })

package/src/internal/compiling/js-compilation-service/jsenvTransform.js

@@ -1,243 +0,0 @@
-import { urlToFileSystemPath } from "@jsenv/filesystem"
-
-import { require } from "@jsenv/core/src/internal/require.js"
-import { babelPluginTransformImportMeta } from "@jsenv/core/src/internal/babel_plugin_transform_import_meta.js"
-import {
-  getMinimalBabelPluginMap,
-  babelPluginsFromBabelPluginMap,
-} from "@jsenv/core/src/internal/compiling/babel_plugins.js"
-import { babelPluginProxyExternalImports } from "@jsenv/core/src/internal/compiling/babel_plugin_proxy_external_imports.js"
-import { babelPluginImportMetadata } from "@jsenv/core/src/internal/compiling/babel_plugin_import_metadata.js"
-
-import { ansiToHTML } from "./ansiToHTML.js"
-import { babelPluginRegeneratorRuntimeAsJsenvImport } from "./babel_plugin_regenerator_runtime_as_jsenv_import.js"
-import { babelPluginBabelHelpersAsJsenvImports } from "./babel_plugin_babel_helpers_as_jsenv_imports.js"
-import { babelPluginSystemJsPrepend } from "./babel_plugin_systemjs_prepend.js"
-import { filePathToBabelHelperName } from "./babelHelper.js"
-
-export const jsenvTransform = async ({
-  jsenvRemoteDirectory,
-  url,
-  relativeUrl, // optional
-
-  babelPluginMap,
-  moduleOutFormat,
-  importMetaFormat = moduleOutFormat,
-  topLevelAwait,
-  babelHelpersInjectionAsImport,
-  prependSystemJs,
-  transformGenerator,
-  regeneratorRuntimeImportPath,
-
-  sourcemapEnabled,
-  ast, // optional
-  map, // optional
-  code,
-}) => {
-  const transformModulesSystemJs = require("@babel/plugin-transform-modules-systemjs")
-  const proposalDynamicImport = require("@babel/plugin-proposal-dynamic-import")
-
-  const inputPath = computeInputPath(url)
-
-  // https://babeljs.io/docs/en/options
-  const options = {
-    filename: inputPath,
-    filenameRelative: relativeUrl,
-    inputSourceMap: map,
-    configFile: false,
-    babelrc: false, // trust only these options, do not read any babelrc config file
-    ast: true,
-    sourceMaps: sourcemapEnabled,
-    sourceFileName: inputPath,
-    // https://babeljs.io/docs/en/options#parseropts
-    parserOpts: {
-      allowAwaitOutsideFunction:
-        topLevelAwait === undefined ||
-        topLevelAwait === "return" ||
-        topLevelAwait === "simple" ||
-        topLevelAwait === "ignore",
-    },
-    generatorOpts: {
-      compact: false,
-    },
-  }
-
-  const babelHelperName = filePathToBabelHelperName(inputPath)
-  // to prevent typeof circular dependency
-  if (babelHelperName === "typeof") {
-    const babelPluginMapWithoutTransformTypeOf = { ...babelPluginMap }
-    delete babelPluginMapWithoutTransformTypeOf["transform-typeof-symbol"]
-    babelPluginMap = babelPluginMapWithoutTransformTypeOf
-  }
-
-  if (transformGenerator) {
-    babelPluginMap = {
-      ...babelPluginMap,
-      "regenerator-runtime-as-jsenv-import": [
-        babelPluginRegeneratorRuntimeAsJsenvImport,
-        {
-          regeneratorRuntimeImportPath,
-        },
-      ],
-    }
-  }
-  babelPluginMap = {
-    ...getMinimalBabelPluginMap(),
-    "transform-import-meta": [
-      babelPluginTransformImportMeta,
-      {
-        replaceImportMeta: (
-          metaPropertyName,
-          { replaceWithImport, replaceWithValue },
-        ) => {
-          if (metaPropertyName === "url") {
-            if (importMetaFormat === "esmodule") {
-              // keep native version
-              return
-            }
-            if (importMetaFormat === "systemjs") {
-              // systemjs will handle it
-              return
-            }
-            if (importMetaFormat === "commonjs") {
-              replaceWithImport({
-                from: `@jsenv/core/helpers/import-meta/import-meta-url-commonjs.js`,
-              })
-              return
-            }
-            if (importMetaFormat === "global") {
-              replaceWithImport({
-                from: `@jsenv/core/helpers/import-meta/import-meta-url-global.js`,
-              })
-              return
-            }
-            return
-          }
-
-          if (metaPropertyName === "resolve") {
-            if (importMetaFormat === "esmodule") {
-              // keep native version
-              return
-            }
-            if (importMetaFormat === "systemjs") {
-              // systemjs will handle it
-              return
-            }
-            if (importMetaFormat === "commonjs") {
-              throw createParseError({
-                message: `import.meta.resolve() not supported with commonjs format`,
-              })
-            }
-            if (importMetaFormat === "global") {
-              throw createParseError({
-                message: `import.meta.resolve() not supported with global format`,
-              })
-            }
-            return
-          }
-
-          replaceWithValue(undefined)
-        },
-      },
-    ],
-    ...babelPluginMap,
-    ...(babelHelpersInjectionAsImport
-      ? {
-          "babel-helpers-as-jsenv-imports": [
-            babelPluginBabelHelpersAsJsenvImports,
-          ],
-        }
-      : {}),
-    ...(jsenvRemoteDirectory
-      ? {
-          "proxy-external-imports": [
-            babelPluginProxyExternalImports,
-            { jsenvRemoteDirectory },
-          ],
-        }
-      : {}),
-    "import-metadata": [babelPluginImportMetadata],
-  }
-  if (moduleOutFormat === "systemjs") {
-    babelPluginMap = {
-      ...babelPluginMap,
-      "proposal-dynamic-import": [proposalDynamicImport],
-      "transform-modules-systemjs": [transformModulesSystemJs],
-    }
-  }
-  if (prependSystemJs) {
-    babelPluginMap = {
-      ...babelPluginMap,
-      "systemjs-prepend": [babelPluginSystemJsPrepend],
-    }
-  }
-
-  const asyncToPromise = babelPluginMap["transform-async-to-promises"]
-  if (topLevelAwait && asyncToPromise) {
-    asyncToPromise.options.topLevelAwait = topLevelAwait
-  }
-
-  const babelTransformReturnValue = await babelTransform({
-    ast,
-    code,
-    options: {
-      ...options,
-      plugins: babelPluginsFromBabelPluginMap(babelPluginMap),
-    },
-  })
-  code = babelTransformReturnValue.code
-  map = babelTransformReturnValue.map
-  ast = babelTransformReturnValue.ast
-  const { metadata } = babelTransformReturnValue
-  return { code, map, metadata, ast }
-}
-
-const computeInputPath = (url) => {
-  if (url.startsWith("file://")) {
-    return urlToFileSystemPath(url)
-  }
-  return url
-}
-
-const babelTransform = async ({ ast, code, options }) => {
-  const { transformAsync, transformFromAstAsync } = await import("@babel/core")
-
-  try {
-    if (ast) {
-      const result = await transformFromAstAsync(ast, code, options)
-      return result
-    }
-    return await transformAsync(code, options)
-  } catch (error) {
-    if (error && error.code === "BABEL_PARSE_ERROR") {
-      const message = error.message
-      const messageWithoutAnsi = message.replace(ansiRegex, "")
-      throw createParseError({
-        cause: error,
-        message: messageWithoutAnsi,
-        messageHTML: ansiToHTML(message),
-        filename: options.filename,
-        lineNumber: error.loc.line,
-        columnNumber: error.loc.column,
-      })
-    }
-    throw error
-  }
-}
-
-const pattern = [
-  "[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:[a-zA-Z\\d]*(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)",
-  "(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-ntqry=><~]))",
-].join("|")
-const ansiRegex = new RegExp(pattern, "g")
-
-const createParseError = ({ message, cause, ...data }) => {
-  const parseError = new Error(message, { cause })
-  parseError.code = "PARSE_ERROR"
-  parseError.data = {
-    message,
-    ...data,
-  }
-
-  return parseError
-}

package/src/internal/generateGroupMap/generateGroupMap.js

@@ -1,65 +0,0 @@
-/*
-
-# featureCompatMap legend
-
-        featureName
-             │
-{ ┌──────────┴────────────┐
-  "transform-block-scoping": {─┐
-    "chrome": "10",            │
-    "safari": "3.0",           minRuntimeVersions
-    "firefox": "5.1"           │
-}────┼─────────┼───────────────┘
-}    │         └─────┐
-  runtimeName  runtimeVersion
-
-# group legend
-
-{
-  "best": {
-    "missingFeatureNames" : [
-      "transform-block-scoping",
-    ],
-    "minRuntimeVersions": {
-      "chrome": "10",
-      "firefox": "6"
-    }
-  }
-}
-
-Take chars below to update legends
-─│┌┐└┘├┤┴┬
-
-*/
-
-import { COMPILE_ID_OTHERWISE, COMPILE_ID_BEST } from "../CONSTANTS.js"
-import { createRuntimeCompat } from "./runtime_compat.js"
-
-export const generateGroupMap = ({ featureNames, runtimeSupport }) => {
-  if (!Array.isArray(featureNames)) {
-    throw new TypeError(`featureNames must be an array, got ${featureNames}`)
-  }
-  if (typeof runtimeSupport !== "object") {
-    throw new TypeError(
-      `runtimeSupport must be an object, got ${runtimeSupport}`,
-    )
-  }
-  const runtimeNames = Object.keys(runtimeSupport)
-  const groupWithoutFeature = {
-    missingFeatureNames: featureNames,
-    minRuntimeVersions: {},
-  }
-  if (runtimeNames.length === 0) {
-    return {
-      [COMPILE_ID_OTHERWISE]: groupWithoutFeature,
-    }
-  }
-  const runtimeCompat = createRuntimeCompat({
-    runtimeSupport,
-    featureNames,
-  })
-  return {
-    [COMPILE_ID_BEST]: runtimeCompat,
-    [COMPILE_ID_OTHERWISE]: groupWithoutFeature,
-  }
-}

package/src/internal/generateGroupMap/one_runtime_compat.js

@@ -1,38 +0,0 @@
-import { findHighestVersion } from "../semantic_versioning/index.js"
-
-export const createOneRuntimeCompat = ({
-  runtimeName,
-  runtimeVersion,
-  featureNames,
-  featuresCompatMap,
-}) => {
-  const missingFeatureNames = []
-  // will be the first runtime version compatible with all features not listed in
-  // missingFeatureNames
-  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) {
-      missingFeatureNames.push(featureName)
-    }
-
-    if (compatible && runtimeVersionCompatible !== "Infinity") {
-      // there is a version from which runtime becomes compatible with this feature
-      minRuntimeVersion = findHighestVersion(
-        minRuntimeVersion || "0.0.0",
-        runtimeVersionCompatible,
-      )
-    }
-  })
-  return {
-    missingFeatureNames,
-    minRuntimeVersion: minRuntimeVersion || runtimeVersion,
-  }
-}

package/src/internal/generateGroupMap/runtime_compat.js

@@ -1,34 +0,0 @@
-import { featuresCompatMap } from "./features_compatibility.js"
-import { createOneRuntimeCompat } from "./one_runtime_compat.js"
-
-export const createRuntimeCompat = ({ runtimeSupport, featureNames }) => {
-  const minRuntimeVersions = {}
-  const missingFeatureNames = []
-  const runtimeNames = Object.keys(runtimeSupport)
-  if (runtimeNames.length === 0) {
-    // when runtimes are unknown, everything is required
-    missingFeatureNames.push(...featureNames)
-  } else {
-    runtimeNames.forEach((runtimeName) => {
-      const runtimeVersion = runtimeSupport[runtimeName]
-      const oneRuntimeCompat = createOneRuntimeCompat({
-        runtimeName,
-        runtimeVersion,
-        featureNames,
-        featuresCompatMap,
-      })
-
-      minRuntimeVersions[runtimeName] = oneRuntimeCompat.minRuntimeVersion
-      oneRuntimeCompat.missingFeatureNames.forEach((missingFeatureName) => {
-        if (!missingFeatureNames.includes(missingFeatureName)) {
-          missingFeatureNames.push(missingFeatureName)
-        }
-      })
-    })
-  }
-
-  return {
-    missingFeatureNames,
-    minRuntimeVersions,
-  }
-}