@jsenv/core 26.0.1 → 27.0.0-alpha.2

package/src/internal/executing/logs_plan_summary.js

@@ -1,144 +0,0 @@
-import { ANSI } from "@jsenv/log"
-
-import { msAsDuration } from "@jsenv/core/src/internal/logs/ms_as_duration.js"
-import { formatByte } from "@jsenv/core/src/internal/logs/byte.js"
-
-import { EXECUTION_COLORS } from "./execution_colors.js"
-
-export const createSummaryLog = (
-  summary,
-) => `-------------- summary -----------------
-${createAllExecutionsSummary(summary)}
-total duration: ${msAsDuration(summary.duration)}
-----------------------------------------`
-
-const createAllExecutionsSummary = ({
-  executionCount,
-  abortedCount,
-  timedoutCount,
-  erroredCount,
-  completedCount,
-  cancelledCount,
-}) => {
-  if (executionCount === 0) {
-    return `no execution`
-  }
-
-  const executionLabel =
-    executionCount === 1 ? `1 execution` : `${executionCount} executions`
-  return `${executionLabel}: ${createStatusSummary({
-    executionCount,
-    abortedCount,
-    timedoutCount,
-    erroredCount,
-    completedCount,
-    cancelledCount,
-  })}`
-}
-
-export const createIntermediateSummary = ({
-  executionCount,
-  abortedCount,
-  timedoutCount,
-  erroredCount,
-  completedCount,
-  cancelledCount,
-  memoryHeap,
-}) => {
-  let intermediateSummary = createStatusSummary({
-    executionCount,
-    abortedCount,
-    timedoutCount,
-    erroredCount,
-    completedCount,
-    cancelledCount,
-  })
-
-  if (memoryHeap) {
-    intermediateSummary += ` / memory heap: ${formatByte(memoryHeap)}`
-  }
-
-  return intermediateSummary
-}
-
-const createStatusSummary = ({
-  executionCount,
-  abortedCount,
-  timedoutCount,
-  erroredCount,
-  completedCount,
-  cancelledCount,
-}) => {
-  if (abortedCount === executionCount) {
-    return `all ${ANSI.color(`aborted`, EXECUTION_COLORS.aborted)}`
-  }
-  if (timedoutCount === executionCount) {
-    return `all ${ANSI.color(`timed out`, EXECUTION_COLORS.timedout)}`
-  }
-  if (erroredCount === executionCount) {
-    return `all ${ANSI.color(`errored`, EXECUTION_COLORS.errored)}`
-  }
-  if (completedCount === executionCount) {
-    return `all ${ANSI.color(`completed`, EXECUTION_COLORS.completed)}`
-  }
-  if (cancelledCount === executionCount) {
-    return `all ${ANSI.color(`cancelled`, EXECUTION_COLORS.cancelled)}`
-  }
-
-  return createMixedDetails({
-    executionCount,
-    abortedCount,
-    timedoutCount,
-    erroredCount,
-    completedCount,
-    cancelledCount,
-  })
-}
-
-const createMixedDetails = ({
-  abortedCount,
-  timedoutCount,
-  erroredCount,
-  completedCount,
-  cancelledCount,
-}) => {
-  const parts = []
-
-  if (timedoutCount) {
-    parts.push(
-      `${timedoutCount} ${ANSI.color(`timed out`, EXECUTION_COLORS.timedout)}`,
-    )
-  }
-
-  if (erroredCount) {
-    parts.push(
-      `${erroredCount} ${ANSI.color(`errored`, EXECUTION_COLORS.errored)}`,
-    )
-  }
-
-  if (completedCount) {
-    parts.push(
-      `${completedCount} ${ANSI.color(
-        `completed`,
-        EXECUTION_COLORS.completed,
-      )}`,
-    )
-  }
-
-  if (abortedCount) {
-    parts.push(
-      `${abortedCount} ${ANSI.color(`aborted`, EXECUTION_COLORS.aborted)}`,
-    )
-  }
-
-  if (cancelledCount) {
-    parts.push(
-      `${cancelledCount} ${ANSI.color(
-        `cancelled`,
-        EXECUTION_COLORS.cancelled,
-      )}`,
-    )
-  }
-
-  return `${parts.join(", ")}`
-}

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

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

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

@@ -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/fetch_json.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/highest_version.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_launcher/fetch_source.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/fetching.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
-}