@jsenv/core 22.5.1 → 23.0.0

package/src/internal/runtime/createNodeRuntime/createNodeRuntime.js

@@ -1,8 +1,4 @@
-import { nodeSupportsDynamicImport } from "../node-feature-detect/nodeSupportsDynamicImport.js"
-import { nodeSupportsTopLevelAwait } from "../node-feature-detect/nodeSupportsTopLevelAwait.js"
-import { computeCompileIdFromGroupId } from "../computeCompileIdFromGroupId.js"
-import { resolveNodeGroup } from "../resolveNodeGroup.js"
-import { fetchSource } from "./fetchSource.js"
+import { scanNodeRuntimeFeatures } from "./scanNodeRuntimeFeatures.js"
 import { createNodeExecutionWithSystemJs } from "./createNodeExecutionWithSystemJs.js"
 import { createNodeExecutionWithDynamicImport } from "./createNodeExecutionWithDynamicImport.js"
 
@@ -10,33 +6,16 @@ export const createNodeRuntime = async ({
   projectDirectoryUrl,
   compileServerOrigin,
   outDirectoryRelativeUrl,
-  canUseNativeModuleSystem,
+  canUseNativeModuleSystem = true,
 }) => {
-  const outDirectoryServerUrl = `${compileServerOrigin}/${outDirectoryRelativeUrl}`
-  const groupMapServerUrl = String(
-    new URL("groupMap.json", outDirectoryServerUrl),
-  )
-  const envFileServerUrl = String(new URL("env.json", outDirectoryServerUrl))
-  const [groupMap, envJson] = await Promise.all([
-    importJson(groupMapServerUrl),
-    importJson(envFileServerUrl),
-  ])
-
-  const { importDefaultExtension } = envJson
-
-  const compileId = computeCompileIdFromGroupId({
-    groupId: resolveNodeGroup(groupMap),
-    groupMap,
+  const nodeFeatures = await scanNodeRuntimeFeatures({
+    compileServerOrigin,
+    outDirectoryRelativeUrl,
   })
-  const groupInfo = groupMap[compileId]
-  if (canUseNativeModuleSystem === undefined) {
-    canUseNativeModuleSystem = await nodeRuntimeSupportsAllFeatures({
-      groupInfo,
-      importDefaultExtension,
-    })
-  }
+  const { canAvoidCompilation, compileId, importDefaultExtension } =
+    nodeFeatures
 
-  if (canUseNativeModuleSystem) {
+  if (canAvoidCompilation && canUseNativeModuleSystem) {
     return createNodeExecutionWithDynamicImport({
       projectDirectoryUrl,
       compileServerOrigin,
@@ -51,60 +30,3 @@ export const createNodeRuntime = async ({
     importDefaultExtension,
   })
 }
-
-const importJson = async (url) => {
-  const response = await fetchSource(url)
-  const status = response.status
-  if (status !== 200) {
-    throw new Error(`unexpected response status for ${url}, got ${status}`)
-  }
-  const object = await response.json()
-  return object
-}
-
-const nodeRuntimeSupportsAllFeatures = async ({
-  groupInfo,
-  importDefaultExtension,
-}) => {
-  // node native resolution will not auto add extension
-  if (importDefaultExtension) {
-    return false
-  }
-
-  const requiredBabelPluginCount = countRequiredBabelPlugins(groupInfo)
-  if (requiredBabelPluginCount > 0) {
-    return false
-  }
-
-  if (groupInfo.jsenvPluginRequiredNameArray.length > 0) {
-    return false
-  }
-
-  const hasDynamicImport = await nodeSupportsDynamicImport()
-  if (!hasDynamicImport) {
-    return false
-  }
-
-  const hasTopLevelAwait = await nodeSupportsTopLevelAwait()
-  if (!hasTopLevelAwait) {
-    return false
-  }
-
-  return true
-}
-
-const countRequiredBabelPlugins = (groupInfo) => {
-  const { babelPluginRequiredNameArray } = groupInfo
-  let count = babelPluginRequiredNameArray.length
-
-  // https://nodejs.org/docs/latest-v15.x/api/cli.html#cli_node_v8_coverage_dir
-  // instrumentation CAN be handed by process.env.NODE_V8_COVERAGE
-  // "transform-instrument" becomes non mandatory
-  const transformInstrumentIndex = babelPluginRequiredNameArray.indexOf(
-    "transform-instrument",
-  )
-  if (transformInstrumentIndex > -1 && process.env.NODE_V8_COVERAGE) {
-    count--
-  }
-  return count
-}

package/src/internal/runtime/createNodeRuntime/scanNodeRuntimeFeatures.js

@@ -0,0 +1,115 @@
+import { detectNode } from "../detectNode/detectNode.js"
+import { resolveGroup } from "../resolveGroup.js"
+import { computeCompileIdFromGroupId } from "../computeCompileIdFromGroupId.js"
+import { nodeSupportsDynamicImport } from "../node-feature-detect/nodeSupportsDynamicImport.js"
+import { nodeSupportsTopLevelAwait } from "../node-feature-detect/nodeSupportsTopLevelAwait.js"
+import { fetchSource } from "./fetchSource.js"
+
+export const scanNodeRuntimeFeatures = async ({
+  compileServerOrigin,
+  outDirectoryRelativeUrl,
+}) => {
+  const outDirectoryServerUrl = `${compileServerOrigin}/${outDirectoryRelativeUrl}`
+  const groupMapServerUrl = String(
+    new URL("groupMap.json", outDirectoryServerUrl),
+  )
+  const envFileServerUrl = String(new URL("env.json", outDirectoryServerUrl))
+  const [groupMap, envJson] = await Promise.all([
+    importJson(groupMapServerUrl),
+    importJson(envFileServerUrl),
+  ])
+
+  const { importDefaultExtension, customCompilerPatterns } = envJson
+
+  const node = detectNode()
+  const compileId = computeCompileIdFromGroupId({
+    groupId: resolveGroup(node, groupMap),
+    groupMap,
+  })
+  const groupInfo = groupMap[compileId]
+
+  const featuresReport = {
+    dynamicImport: undefined,
+    topLevelAwait: undefined,
+  }
+  await detectSupportedFeatures({
+    featuresReport,
+    failFastOnFeatureDetection: true,
+  })
+  const pluginRequiredNameArray = pluginRequiredNamesFromGroupInfo(groupInfo, {
+    featuresReport,
+    // https://nodejs.org/docs/latest-v15.x/api/cli.html#cli_node_v8_coverage_dir
+    // instrumentation CAN be handed by process.env.NODE_V8_COVERAGE
+    // "transform-instrument" becomes non mandatory
+    coverageHandledFromOutside: process.env.NODE_V8_COVERAGE,
+  })
+
+  const canAvoidCompilation =
+    // node native resolution will not auto add extension
+    !importDefaultExtension &&
+    customCompilerPatterns.length === 0 &&
+    pluginRequiredNameArray.length === 0 &&
+    featuresReport.dynamicImport &&
+    featuresReport.topLevelAwait
+
+  return {
+    canAvoidCompilation,
+    featuresReport,
+    pluginRequiredNameArray,
+    compileId,
+    importDefaultExtension,
+    node,
+  }
+}
+
+const detectSupportedFeatures = async ({
+  featuresReport,
+  failFastOnFeatureDetection,
+}) => {
+  const dynamicImport = await nodeSupportsDynamicImport()
+  featuresReport.dynamicImport = dynamicImport
+  if (failFastOnFeatureDetection && !dynamicImport) {
+    return
+  }
+
+  const topLevelAwait = await nodeSupportsTopLevelAwait()
+  featuresReport.topLevelAwait = topLevelAwait
+  if (failFastOnFeatureDetection && !topLevelAwait) {
+    return
+  }
+}
+
+const importJson = async (url) => {
+  const response = await fetchSource(url)
+  const status = response.status
+  if (status !== 200) {
+    throw new Error(`unexpected response status for ${url}, got ${status}`)
+  }
+  const object = await response.json()
+  return object
+}
+
+const pluginRequiredNamesFromGroupInfo = (
+  groupInfo,
+  { coverageHandledFromOutside },
+) => {
+  const { pluginRequiredNameArray } = groupInfo
+  const requiredPluginNames = pluginRequiredNameArray.slice()
+  const markPluginAsSupported = (name) => {
+    const index = requiredPluginNames.indexOf(name)
+    if (index > -1) {
+      requiredPluginNames.splice(index, 1)
+    }
+  }
+
+  if (coverageHandledFromOutside) {
+    markPluginAsSupported("transform-instrument")
+  }
+  // We assume import assertions and constructable stylesheet won't be used
+  // in code executed in Node.js
+  // so event they are conceptually required, they are ignored
+  markPluginAsSupported("transform-import-assertions")
+  markPluginAsSupported("new-stylesheet-as-jsenv-import")
+
+  return requiredPluginNames
+}

package/src/internal/runtime/module-registration.js

@@ -108,8 +108,7 @@ export const getJavaScriptModuleResponseError = async (
             compileServerOrigin,
             compileDirectoryRelativeUrl,
           }),
-          "suggestion": `Prefer import.meta.url as documented in https://github.com/jsenv/jsenv-core/blob/master/docs/building/readme.md#How-to-reference-js-assets`,
-          "suggestion 2": `Use customCompilers to convert non-js to js`,
+          suggestion: `Use import.meta.url or import assertions as documented in https://github.com/jsenv/jsenv-core/blob/master/docs/building/readme.md#How-to-reference-assets`,
         },
       ),
     )

package/src/internal/runtime/resolveGroup.js

@@ -3,11 +3,10 @@ import { findHighestVersion } from "../semantic-versioning/index.js"
 export const resolveGroup = ({ name, version }, groupMap) => {
   return Object.keys(groupMap).find((compileIdCandidate) => {
     const { minRuntimeVersions } = groupMap[compileIdCandidate]
-    if (name in minRuntimeVersions === false) {
+    const versionForGroup = minRuntimeVersions[name]
+    if (!versionForGroup) {
       return false
     }
-    const versionForGroup = minRuntimeVersions[name]
-
     const highestVersion = findHighestVersion(version, versionForGroup)
     return highestVersion === version
   })

package/src/internal/toolbar/compilation/toolbar.compilation.js

@@ -11,8 +11,10 @@ export const renderCompilationInToolbar = ({ compileGroup }) => {
 
   scanBrowserRuntimeFeatures().then(
     ({
-      featuresReport,
       canAvoidCompilation,
+      featuresReport,
+      customCompilerPatterns,
+      pluginRequiredNameArray,
       inlineImportMapIntoHTML,
       outDirectoryRelativeUrl,
       compileId,
@@ -35,6 +37,8 @@ export const renderCompilationInToolbar = ({ compileGroup }) => {
               {
                 missingOnly: true,
                 featuresReport,
+                customCompilerPatterns,
+                pluginRequiredNameArray,
                 inlineImportMapIntoHTML,
               },
             )}`,
@@ -49,6 +53,8 @@ export const renderCompilationInToolbar = ({ compileGroup }) => {
             `Source files (except html) can be executed directly in this browser because: ${getBrowserSupportMessage(
               {
                 featuresReport,
+                customCompilerPatterns,
+                pluginRequiredNameArray,
                 inlineImportMapIntoHTML,
               },
             )}`,
@@ -63,6 +69,8 @@ export const renderCompilationInToolbar = ({ compileGroup }) => {
             `Source files can be executed directly in this browser because: ${getBrowserSupportMessage(
               {
                 featuresReport,
+                customCompilerPatterns,
+                pluginRequiredNameArray,
                 inlineImportMapIntoHTML,
               },
             )}`,
@@ -119,6 +127,8 @@ export const renderCompilationInToolbar = ({ compileGroup }) => {
 const getBrowserSupportMessage = ({
   missingOnly,
   featuresReport,
+  customCompilerPatterns,
+  pluginRequiredNameArray,
   inlineImportMapIntoHTML,
 }) => {
   const parts = []
@@ -154,19 +164,17 @@ const getBrowserSupportMessage = ({
     parts.push(`top level await is not supported`)
   }
 
-  const { babelPluginRequiredNames } = featuresReport
-  const babelPluginRequiredCount = babelPluginRequiredNames.length
-  if (babelPluginRequiredCount === 0) {
+  const pluginRequiredCount = pluginRequiredNameArray.length
+  if (pluginRequiredCount === 0) {
     if (!missingOnly) {
-      parts.push(`all babel plugins are natively supported`)
+      parts.push(`all plugins are natively supported`)
     }
   } else {
     parts.push(
-      `${babelPluginRequiredCount} babel plugins are mandatory: ${babelPluginRequiredNames}`,
+      `${pluginRequiredCount} plugins are mandatory: ${pluginRequiredNameArray}`,
     )
   }
 
-  const { customCompilerPatterns } = featuresReport
   const customCompilerCount = customCompilerPatterns.length
   if (customCompilerCount === 0) {
     // no need to talk about something unused
@@ -176,16 +184,6 @@ const getBrowserSupportMessage = ({
     )
   }
 
-  const { jsenvPluginRequiredNames } = featuresReport
-  const jsenvPluginRequiredCount = jsenvPluginRequiredNames.length
-  if (jsenvPluginRequiredCount === 0) {
-    // no need to talk about something unused
-  } else {
-    parts.push(
-      `${jsenvPluginRequiredCount} jsenv plugins are mandatory: ${jsenvPluginRequiredNames}`,
-    )
-  }
-
   return `
 - ${parts.join(`
 - `)}`

package/src/internal/toolbar/eventsource/toolbar.eventsource.js

@@ -18,8 +18,13 @@ export const initToolbarEventSource = ({
   executedFileRelativeUrl,
   livereloading,
 }) => {
+  const getLivereloadCallback = (originalFileProjectRelativeUrl) => {
+    const callbacks = window.parent.__jsenv__.livereloadingCallbacks
+    return callbacks[originalFileProjectRelativeUrl]
+  }
+
   removeForceHideElement(document.querySelector("#eventsource-indicator"))
-  connectEventSource(executedFileRelativeUrl)
+  connectEventSource({ executedFileRelativeUrl, getLivereloadCallback })
   livereloadingAvailableOnServer = livereloading
   if (!livereloadingAvailableOnServer) {
     disableLivereloadSetting()
@@ -54,11 +59,18 @@ let eventSourceHooks = {}
 let eventSourceConnection
 let connectionReadyPromise
 
-const handleFileChange = (file, type) => {
-  latestChangeMap[file] = type
+const handleFileChange = ({ file, eventType, livereloadCallback }) => {
+  latestChangeMap[file] = eventType
   updateEventSourceIndicator()
+
   if (shouldLivereload()) {
-    if (
+    if (livereloadCallback) {
+      livereloadCallback({
+        file,
+        latestChangeMap,
+        reloadPage,
+      })
+    } else if (
       file.endsWith(".css") ||
       file.endsWith(".scss") ||
       file.endsWith(".sass")
@@ -109,7 +121,10 @@ const reloadChanges = () => {
   }
 }
 
-const connectEventSource = (executedFileRelativeUrl) => {
+const connectEventSource = ({
+  executedFileRelativeUrl,
+  getLivereloadCallback,
+}) => {
   updateEventSourceIndicator()
   connectionReadyPromise = createPromiseAndHooks()
 
@@ -117,13 +132,25 @@ const connectEventSource = (executedFileRelativeUrl) => {
     executedFileRelativeUrl,
     {
       onFileModified: (file) => {
-        handleFileChange(file, "modified")
+        handleFileChange({
+          file,
+          eventType: "modified",
+          livereloadCallback: getLivereloadCallback(file),
+        })
       },
       onFileRemoved: (file) => {
-        handleFileChange(file, "removed")
+        handleFileChange({
+          file,
+          eventType: "removed",
+          livereloadCallback: getLivereloadCallback(file),
+        })
       },
       onFileAdded: (file) => {
-        handleFileChange(file, "added")
+        handleFileChange({
+          file,
+          eventType: "added",
+          livereloadCallback: getLivereloadCallback(file),
+        })
       },
       onConnecting: ({ cancel }) => {
         eventSourceState = "connecting"

package/src/internal/toolbar/toolbar.main.js

@@ -80,7 +80,10 @@ const renderToolbar = async () => {
   renderCompilationInToolbar({ compileGroup })
   // this might become active but we need to detect this somehow
   deactivateToolbarSection(document.querySelector("#file-list-link"))
-  initToolbarEventSource({ executedFileRelativeUrl, livereloading })
+  initToolbarEventSource({
+    executedFileRelativeUrl,
+    livereloading,
+  })
 
   // if user click enter or space quickly while closing toolbar
   // it will cancel the closing
@@ -188,13 +191,13 @@ const getCompileGroup = ({
   outDirectoryRelativeUrl,
   compileServerOrigin,
 }) => {
-  const outDirectoryRemoteUrl = String(
+  const outDirectoryServerUrl = String(
     new URL(outDirectoryRelativeUrl, compileServerOrigin),
   )
-  if (urlIsInsideOf(executedFileCompiledUrl, outDirectoryRemoteUrl)) {
+  if (urlIsInsideOf(executedFileCompiledUrl, outDirectoryServerUrl)) {
     const afterCompileDirectory = urlToRelativeUrl(
       executedFileCompiledUrl,
-      outDirectoryRemoteUrl,
+      outDirectoryServerUrl,
     )
     const slashIndex = afterCompileDirectory.indexOf("/")
     const fileRelativeUrl = afterCompileDirectory.slice(slashIndex + 1)

package/src/internal/url_utils.js

@@ -11,3 +11,23 @@ export const setUrlExtension = (url, extension) => {
   const newPathname = `${pathnameWithoutExtension}${extension}`
   return `${origin}${newPathname}${search ? `?${search}` : ""}`
 }
+
+export const getUrlSearchParamsDescriptor = (url) => {
+  const urlObject = new URL(url)
+  const { searchParams } = urlObject
+  const searchParamsDescriptor = {}
+  Array.from(searchParams.keys()).forEach((key) => {
+    const value = searchParams.getAll(key)
+    searchParamsDescriptor[key] = value.length === 1 ? value[0] : value
+  })
+  return searchParamsDescriptor
+}
+
+export const setUrlSearchParamsDescriptor = (url, searchParamsDescriptor) => {
+  const urlObject = new URL(url)
+  const { searchParams } = urlObject
+  Object.keys(searchParamsDescriptor).forEach((key) => {
+    searchParams.set(key, searchParamsDescriptor[key])
+  })
+  return String(urlObject)
+}

package/src/launchBrowser.js

@@ -5,11 +5,12 @@ import {
   createCancellationToken,
   createStoppableOperation,
 } from "@jsenv/cancellation"
+import { createDetailedMessage } from "@jsenv/logger"
 import { teardownSignal } from "@jsenv/node-signals"
 
 import { trackRessources } from "./internal/trackRessources.js"
 import { fetchUrl } from "./internal/fetchUrl.js"
-import { validateResponseStatusIsOk } from "./internal/validateResponseStatusIsOk.js"
+import { validateResponse } from "./internal/response_validation.js"
 import { trackPageToNotify } from "./internal/browser-launcher/trackPageToNotify.js"
 import { createSharing } from "./internal/browser-launcher/createSharing.js"
 import { executeHtmlFile } from "./internal/browser-launcher/executeHtmlFile.js"
@@ -20,8 +21,11 @@ import {
 } from "./playwright_browser_versions.js"
 
 const chromiumSharing = createSharing()
-
-export const launchChromium = async ({
+export const chromiumRuntime = {
+  name: "chromium",
+  version: PLAYWRIGHT_CHROMIUM_VERSION,
+}
+chromiumRuntime.launch = async ({
   browserServerLogLevel,
   cancellationToken = createCancellationToken(),
   chromiumExecutablePath,
@@ -91,9 +95,11 @@ export const launchChromium = async ({
       cancellationToken,
       ignoreHttpsError: true,
     })
-    const { valid, message } = await validateResponseStatusIsOk(browserResponse)
-    if (!valid) {
-      throw new Error(message)
+    const { isValid, message, details } = await validateResponse(
+      browserResponse,
+    )
+    if (!isValid) {
+      throw new Error(createDetailedMessage(message, details))
     }
 
     const browserResponseObject = JSON.parse(browserResponse.body)
@@ -103,8 +109,6 @@ export const launchChromium = async ({
 
   return {
     browser,
-    runtimeName: "chromium",
-    runtimeVersion: PLAYWRIGHT_CHROMIUM_VERSION,
     stop: ressourceTracker.cleanup,
     ...browserToRuntimeHooks(browser, {
       browserServerLogLevel,
@@ -124,16 +128,21 @@ export const launchChromium = async ({
     }),
   }
 }
-
-export const launchChromiumTab = (namedArgs) =>
-  launchChromium({
-    share: true,
-    ...namedArgs,
-  })
+export const chromiumTabRuntime = {
+  ...chromiumRuntime,
+  launch: (params) =>
+    chromiumRuntime.launch({
+      shared: true,
+      ...params,
+    }),
+}
 
 const firefoxSharing = createSharing()
-
-export const launchFirefox = async ({
+export const firefoxRuntime = {
+  name: "firefox",
+  version: PLAYWRIGHT_FIREFOX_VERSION,
+}
+firefoxRuntime.launch = async ({
   cancellationToken = createCancellationToken(),
   firefoxExecutablePath,
   browserServerLogLevel,
@@ -179,8 +188,6 @@ export const launchFirefox = async ({
 
   return {
     browser,
-    runtimeName: "firefox",
-    runtimeVersion: PLAYWRIGHT_FIREFOX_VERSION,
     stop: ressourceTracker.cleanup,
     ...browserToRuntimeHooks(browser, {
       browserServerLogLevel,
@@ -199,16 +206,21 @@ export const launchFirefox = async ({
     }),
   }
 }
-
-export const launchFirefoxTab = (namedArgs) =>
-  launchFirefox({
-    share: true,
-    ...namedArgs,
-  })
+export const firefoxTabRuntime = {
+  ...firefoxRuntime,
+  launch: (params) =>
+    firefoxRuntime.launch({
+      shared: true,
+      ...params,
+    }),
+}
 
 const webkitSharing = createSharing()
-
-export const launchWebkit = async ({
+export const webkitRuntime = {
+  name: "webkit",
+  version: PLAYWRIGHT_WEBKIT_VERSION,
+}
+webkitRuntime.launch = async ({
   browserServerLogLevel,
   cancellationToken = createCancellationToken(),
   webkitExecutablePath,
@@ -254,8 +266,7 @@ export const launchWebkit = async ({
 
   return {
     browser,
-    runtimeName: "webkit",
-    runtimeVersion: PLAYWRIGHT_WEBKIT_VERSION,
+
     stop: ressourceTracker.cleanup,
     ...browserToRuntimeHooks(browser, {
       browserServerLogLevel,
@@ -274,12 +285,14 @@ export const launchWebkit = async ({
     }),
   }
 }
-
-export const launchWebkitTab = (namedArgs) =>
-  launchWebkit({
-    share: true,
-    ...namedArgs,
-  })
+export const webkitTabRuntime = {
+  ...webkitRuntime,
+  launch: (params) =>
+    webkitRuntime.launch({
+      shared: true,
+      ...params,
+    }),
+}
 
 const launchBrowser = async (
   browserName,

package/src/launchNode.js

@@ -1,6 +1,5 @@
 /* eslint-disable import/max-dependencies */
-import { Script } from "vm"
-
+import { Script } from "node:vm"
 import cuid from "cuid"
 import { loggerToLogLevel } from "@jsenv/logger"
 import { createCancellationToken } from "@jsenv/cancellation"
@@ -17,7 +16,11 @@ import { escapeRegexpSpecialCharacters } from "./internal/escapeRegexpSpecialCha
 import { createControllableNodeProcess } from "./internal/node-launcher/createControllableNodeProcess.js"
 import { v8CoverageFromNodeV8Directory } from "./internal/executing/coverage/v8CoverageFromNodeV8Directory.js"
 
-export const launchNode = async ({
+export const nodeRuntime = {
+  name: "node",
+  version: process.version.slice(1),
+}
+nodeRuntime.launch = async ({
   logger,
   logProcessCommand,
   cancellationToken = createCancellationToken(),