@jsenv/core 22.5.1 → 23.0.0

package/src/executeTestPlan.js

@@ -24,7 +24,6 @@ import { generateCoverageJsonFile } from "./internal/executing/coverage/generate
 import { generateCoverageHtmlDirectory } from "./internal/executing/coverage/generateCoverageHtmlDirectory.js"
 import { generateCoverageTextLog } from "./internal/executing/coverage/generateCoverageTextLog.js"
 import { jsenvCoverageConfig } from "./jsenvCoverageConfig.js"
-import { jsenvRuntimeSupportDuringDev } from "./jsenvRuntimeSupportDuringDev.js"
 
 export const executeTestPlan = async ({
   logLevel = "info",
@@ -79,8 +78,6 @@ export const executeTestPlan = async ({
   babelPluginMap,
   babelConfigFileUrl,
   customCompilers,
-  // we could even affine depending on testPlan
-  runtimeSupportDuringDev = jsenvRuntimeSupportDuringDev,
   jsenvDirectoryClean,
 }) => {
   const jsenvExecuteTestPlanFunction = async ({ jsenvCancellationToken }) => {
@@ -188,7 +185,6 @@ export const executeTestPlan = async ({
       babelPluginMap,
       babelConfigFileUrl,
       customCompilers,
-      runtimeSupport: runtimeSupportDuringDev,
     })
 
     if (updateProcessExitCode && !executionIsPassed(result)) {

package/src/importUsingChildProcess.js

@@ -18,41 +18,45 @@ export const importUsingChildProcess = async (
   const result = await launchAndExecute({
     stopAfterExecute: true,
     fileRelativeUrl: String(fileUrl),
-    launch: async () => {
-      const controllableNodeProcess = await createControllableNodeProcess({
-        logLevel,
-        debugPort,
-        debugMode,
-        debugModeInheritBreak,
-        env,
-        commandLineOptions,
-        stdin,
-        stdout,
-        stderr,
-      })
+    runtime: {
+      name: "node",
+      version: process.version.slice(1),
+      launch: async () => {
+        const controllableNodeProcess = await createControllableNodeProcess({
+          logLevel,
+          debugPort,
+          debugMode,
+          debugModeInheritBreak,
+          env,
+          commandLineOptions,
+          stdin,
+          stdout,
+          stderr,
+        })
 
-      return {
-        ...controllableNodeProcess,
-        execute: async () => {
-          try {
-            const namespace =
-              await controllableNodeProcess.requestActionOnChildProcess({
-                actionType: "execute-using-import",
-                actionParams: { fileUrl },
-              })
+        return {
+          ...controllableNodeProcess,
+          execute: async () => {
+            try {
+              const namespace =
+                await controllableNodeProcess.requestActionOnChildProcess({
+                  actionType: "execute-using-import",
+                  actionParams: { fileUrl },
+                })
 
-            return {
-              status: "ok",
-              namespace,
+              return {
+                status: "ok",
+                namespace,
+              }
+            } catch (e) {
+              return {
+                status: "errored",
+                error: e,
+              }
             }
-          } catch (e) {
-            return {
-              status: "errored",
-              error: e,
-            }
-          }
-        },
-      }
+          },
+        }
+      },
     },
   })
   if (result.status === "errored") {

package/src/internal/browser-launcher/executeHtmlFile.js

@@ -47,22 +47,20 @@ export const executeHtmlFile = async (
   )
   await page.goto(compileProxyClientUrl)
 
-  const coverageInstrumentationRequired =
-    coverageForceIstanbul || !coveragePlaywrightAPIAvailable
+  const coverageHandledFromOutside =
+    coveragePlaywrightAPIAvailable && !coverageForceIstanbul
 
   const browserRuntimeFeaturesReport = await page.evaluate(
     /* istanbul ignore next */
-    ({ coverageInstrumentationRequired }) => {
+    ({ coverageHandledFromOutside }) => {
       // eslint-disable-next-line no-undef
       return window.scanBrowserRuntimeFeatures({
-        coverageInstrumentationRequired,
+        coverageHandledFromOutside,
+        failFastOnFeatureDetection: true,
       })
     },
-    { coverageInstrumentationRequired },
+    { coverageHandledFromOutside },
   )
-  // ici si on peut avoid compilation alors on pourrait visiter la page de base
-  // mais il faudrait alors un moyen d'obtenir:
-  // coverage et namespace des scripts qui s'éxécute
 
   try {
     let executionResult

package/src/internal/browser-launcher/jsenv-browser-system.js

@@ -189,7 +189,10 @@ const getBrowserRuntime = memoize(async () => {
   return browserRuntime
 })
 
+const livereloadingCallbacks = {}
+
 window.__jsenv__ = {
+  livereloadingCallbacks,
   executionResultPromise,
   executeFileUsingDynamicImport,
   executeFileUsingSystemJs,

package/src/internal/building/asset_url_versioning.js

@@ -4,15 +4,11 @@ export const computeBuildRelativeUrlForRessource = (
   ressource,
   { lineBreakNormalization },
 ) => {
-  return computeBuildRelativeUrl(
-    ressource.url,
-    ressource.bufferAfterBuild,
-    {
-      pattern: fileNamePatternFromRessource(ressource),
-      contentType: ressource.contentType,
-      lineBreakNormalization,
-    },
-  )
+  return computeBuildRelativeUrl(ressource.url, ressource.bufferAfterBuild, {
+    pattern: fileNamePatternFromRessource(ressource),
+    contentType: ressource.contentType,
+    lineBreakNormalization,
+  })
 }
 
 const assetFileNamePattern = "assets/[name]-[hash][extname]"

package/src/internal/building/buildServiceWorker.js

@@ -31,19 +31,12 @@ export const buildServiceWorker = async ({
   const serviceWorkerCode = serviceWorkerTransformer(workerBundle.code)
 
   if (minify) {
-    const minifyResult = await minifyJs(
-      serviceWorkerCode,
-      serviceWorkerProjectRelativeUrl,
-      {
-        sourceMap: {
-          ...(workerBundle.map
-            ? { content: JSON.stringify(workerBundle.map) }
-            : {}),
-          asObject: true,
-          includeSources: true,
-        },
-      },
-    )
+    const minifyResult = await minifyJs({
+      url: serviceWorkerProjectUrl,
+      code: serviceWorkerCode,
+      map: workerBundle.map,
+      sourcemapIncludeSources: true,
+    })
     await writeJsAndSourcemap(
       serviceWorkerBuildUrl,
       minifyResult.code,

package/src/internal/building/buildUsingRollup.js

@@ -9,6 +9,7 @@ import { createDetailedMessage } from "@jsenv/logger"
 
 import { buildServiceWorker } from "@jsenv/core/src/internal/building/buildServiceWorker.js"
 import { humanizeUrl } from "@jsenv/core/src/internal/building/url_trace.js"
+import { createRuntimeCompat } from "@jsenv/core/src/internal/generateGroupMap/runtime_compat.js"
 import { createJsenvRollupPlugin } from "./createJsenvRollupPlugin.js"
 
 export const buildUsingRollup = async ({
@@ -68,6 +69,36 @@ export const buildUsingRollup = async ({
       runtimeSupport.safari,
   )
 
+  const runtimeCompatMap = createRuntimeCompat({
+    runtimeSupport,
+    pluginMap: {
+      import_assertion_type_json: true,
+      import_assertion_type_css: true,
+    },
+    pluginCompatMap: {
+      import_assertion_type_json: {
+        chrome: "91",
+        edge: "91",
+      },
+      import_assertion_type_css: {
+        chrome: "93",
+        edge: "93",
+      },
+    },
+  })
+  const importAssertionsSupport = {
+    json:
+      format === "esmodule" &&
+      !runtimeCompatMap.pluginRequiredNameArray.includes(
+        "import_assertion_type_json",
+      ),
+    css:
+      format === "esmodule" &&
+      !runtimeCompatMap.pluginRequiredNameArray.includes(
+        "import_assertion_type_json",
+      ),
+  }
+
   const {
     jsenvRollupPlugin,
     getLastErrorMessage,
@@ -93,6 +124,7 @@ export const buildUsingRollup = async ({
     transformTopLevelAwait,
     node,
     browser,
+    importAssertionsSupport,
 
     urlMappings,
     importResolutionMethod,
@@ -205,6 +237,7 @@ const useRollup = async ({
   asOriginalUrl,
 }) => {
   const { rollup } = await import("rollup")
+  const { importAssertions } = await import("acorn-import-assertions")
 
   const rollupInputOptions = {
     // about cache here, we should/could reuse previous rollup call
@@ -256,6 +289,7 @@ const useRollup = async ({
     input: [],
     preserveEntrySignatures,
     plugins: [jsenvRollupPlugin],
+    acornInjectPlugins: [importAssertions],
   }
   const rollupOutputOptions = {
     // https://rollupjs.org/guide/en#experimentaltoplevelawait

package/src/internal/building/build_logs.js

@@ -4,6 +4,17 @@ import { byteAsFileSize } from "../logs/byteAsFileSize.js"
 import { msAsDuration } from "../logs/msAsDuration.js"
 import { stringifyUrlSite } from "./url_trace.js"
 
+export const formatBuildStartLog = ({ entryPointMap }) => {
+  const entryFileRelativeUrls = Object.keys(entryPointMap)
+  if (entryFileRelativeUrls.length === 1) {
+    return `
+building ${entryFileRelativeUrls[0]}...`
+  }
+
+  return `
+building ${entryFileRelativeUrls.length} entry files...`
+}
+
 export const formatUseImportMapFromHtml = (importMapInfoFromHtml) => {
   return `
 use importmap from html ${showHtmlSourceLocation(importMapInfoFromHtml)}`

package/src/internal/building/build_stats.js

@@ -59,7 +59,7 @@ const getProjectFileContents = (ressourceBuilder) => {
 
   Object.keys(ressourceMap).forEach((url) => {
     const ressource = ressourceMap[url]
-    const { isInline, isExternal, bufferBeforeBuild } = ressource
+    const { isInline, isExternal, isPlaceholder, bufferBeforeBuild } = ressource
     if (isInline) {
       // inline ressources are not files
       return
@@ -74,6 +74,12 @@ const getProjectFileContents = (ressourceBuilder) => {
       // -> we don't gave the bufferBeforeBuild (the ressource file content)
       return
     }
+    if (isPlaceholder) {
+      // placeholders (used for sourcemap files)
+      // means the file did not exists in the project is there is a placeholder
+      // to generate it in the build
+      return
+    }
     projectFileContents[url] = bufferBeforeBuild
   })
   return projectFileContents