@jsenv/core 25.0.0-alpha.0 → 25.0.0-alpha.1

package/src/buildProject.js

@@ -2,6 +2,7 @@ import { createLogger, createDetailedMessage } from "@jsenv/logger"
 import { resolveDirectoryUrl } from "@jsenv/filesystem"
 import { Abort, raceProcessTeardownEvents } from "@jsenv/abort"
 
+import { shakeBabelPluginMap } from "@jsenv/core/src/internal/generateGroupMap/shake_babel_plugin_map.js"
 import { COMPILE_ID_BEST } from "./internal/CONSTANTS.js"
 import {
   assertProjectDirectoryUrl,
@@ -23,6 +24,12 @@ export const buildProject = async ({
 
   projectDirectoryUrl,
   entryPoints,
+  workers = [],
+  serviceWorkers = [],
+  serviceWorkerFinalizer,
+  classicWorkers = [],
+  classicServiceWorkers = [],
+  importMapInWebWorkers = false,
   buildDirectoryRelativeUrl,
   buildDirectoryClean = true,
   assetManifestFile = false,
@@ -77,12 +84,6 @@ export const buildProject = async ({
   // https://github.com/cssnano/cssnano/tree/master/packages/cssnano-preset-default
   minifyCssOptions,
 
-  workers = {},
-  serviceWorkers = {},
-  serviceWorkerFinalizer,
-  classicWorkers = {},
-  classicServiceWorkers = {},
-
   env = {},
   protocol,
   privateKey,
@@ -114,6 +115,11 @@ export const buildProject = async ({
       `runtimeSupport must be an object, got ${runtimeSupport}`,
     )
   }
+  if (format !== "systemjs" && importMapInWebWorkers) {
+    throw new Error(
+      `format must be "systemjs" when importMapInWebWorkers is enabled`,
+    )
+  }
 
   projectDirectoryUrl = assertProjectDirectoryUrl({ projectDirectoryUrl })
   await assertProjectDirectoryExists({ projectDirectoryUrl })
@@ -166,6 +172,7 @@ export const buildProject = async ({
     moduleOutFormat: "esmodule", // rollup will transform into the right format
     importMetaFormat: "esmodule", // rollup will transform into the right format
     topLevelAwait: "ignore", // rollup will transform if needed
+    prependSystemJs: false,
 
     protocol,
     privateKey,
@@ -174,9 +181,10 @@ export const buildProject = async ({
     port,
     env,
     babelPluginMap,
-    customCompilers,
+    workers,
+    serviceWorkers,
     runtimeSupport,
-
+    customCompilers,
     compileServerCanReadFromFilesystem: filesystemCache,
     compileServerCanWriteOnFilesystem: filesystemCache,
     // keep source html untouched
@@ -219,8 +227,19 @@ export const buildProject = async ({
       systemJsUrl,
       globalName,
       globals,
-      babelPluginMap: compileServer.babelPluginMap,
+      babelPluginMap: shakeBabelPluginMap({
+        babelPluginMap: compileServer.babelPluginMap,
+        missingFeatureNames:
+          compileServer.compileServerGroupMap[COMPILE_ID_BEST]
+            .missingFeatureNames,
+      }),
       runtimeSupport,
+      workers,
+      serviceWorkers,
+      serviceWorkerFinalizer,
+      classicWorkers,
+      classicServiceWorkers,
+      importMapInWebWorkers,
 
       urlVersioning,
       lineBreakNormalization,
@@ -235,12 +254,6 @@ export const buildProject = async ({
       minifyJsOptions,
       minifyCssOptions,
 
-      workers,
-      serviceWorkers,
-      serviceWorkerFinalizer,
-      classicWorkers,
-      classicServiceWorkers,
-
       writeOnFileSystem,
       sourcemapExcludeSources,
     })

package/src/dev_server.js

@@ -45,17 +45,20 @@ export const startDevServer = async ({
   keepProcessAlive = true,
 
   babelPluginMap,
+  workers,
+  serviceWorkers,
+  importMapInWebWorkers,
+  customCompilers,
   runtimeSupportDuringDev = {
     // this allows to compile nothing or almost nothing when opening files
     // with a recent chrome. Without this we would compile all the things not yet unsupported
     // by Firefox and Safari such as top level await, importmap, etc
-    chrome: "93",
+    chrome: "96",
   },
   logLevel,
   compileServerCanReadFromFilesystem,
   compileServerCanWriteOnFilesystem,
   sourcemapMethod,
-  customCompilers,
   livereloadWatchConfig,
   livereloadLogLevel,
   jsenvDirectoryClean,
@@ -124,6 +127,9 @@ export const startDevServer = async ({
     customCompilers,
     sourcemapMethod,
     babelPluginMap,
+    workers,
+    serviceWorkers,
+    importMapInWebWorkers,
     runtimeSupport: runtimeSupportDuringDev,
     livereloadWatchConfig,
     livereloadLogLevel,

package/src/execute.js

@@ -46,6 +46,9 @@ export const execute = async ({
   port,
   babelPluginMap,
   customCompilers,
+  workers,
+  serviceWorkers,
+  importMapInWebWorkers,
   compileServerCanReadFromFilesystem,
   compileServerCanWriteOnFilesystem,
 
@@ -105,10 +108,13 @@ export const execute = async ({
       ip,
       port,
       babelPluginMap,
-      customCompilers,
       runtimeSupport: normalizeRuntimeSupport({
         [runtime.name]: runtime.version,
       }),
+      customCompilers,
+      workers,
+      serviceWorkers,
+      importMapInWebWorkers,
       compileServerCanReadFromFilesystem,
       compileServerCanWriteOnFilesystem,
     })

package/src/executeTestPlan.js

@@ -79,6 +79,9 @@ export const executeTestPlan = async ({
   compileServerCanWriteOnFilesystem,
   babelPluginMap,
   babelConfigFileUrl,
+  workers,
+  serviceWorkers,
+  importMapInWebWorkers,
   customCompilers,
   jsenvDirectoryClean,
 }) => {
@@ -179,6 +182,9 @@ export const executeTestPlan = async ({
     compileServerCanWriteOnFilesystem,
     babelPluginMap,
     babelConfigFileUrl,
+    workers,
+    serviceWorkers,
+    importMapInWebWorkers,
     customCompilers,
   })
 

package/src/internal/browser_feature_detection/browser_feature_detection.js

@@ -36,17 +36,14 @@ export const scanBrowserRuntimeFeatures = async ({
     failFastOnFeatureDetection,
     inlineImportMapIntoHTML,
   })
-  const pluginRequiredNameArray = await pluginRequiredNamesFromGroupInfo(
-    groupInfo,
-    {
-      featuresReport,
-      coverageHandledFromOutside,
-    },
-  )
+  const missingFeatureNames = await adjustMissingFeatureNames(groupInfo, {
+    featuresReport,
+    coverageHandledFromOutside,
+  })
 
   const canAvoidCompilation =
     customCompilerPatterns.length === 0 &&
-    pluginRequiredNameArray.length === 0 &&
+    missingFeatureNames.length === 0 &&
     featuresReport.importmap &&
     featuresReport.dynamicImport &&
     featuresReport.topLevelAwait
@@ -55,7 +52,7 @@ export const scanBrowserRuntimeFeatures = async ({
     canAvoidCompilation,
     featuresReport,
     customCompilerPatterns,
-    pluginRequiredNameArray,
+    missingFeatureNames,
     inlineImportMapIntoHTML,
     outDirectoryRelativeUrl,
     compileId,
@@ -63,27 +60,25 @@ export const scanBrowserRuntimeFeatures = async ({
   }
 }
 
-const pluginRequiredNamesFromGroupInfo = async (
+const adjustMissingFeatureNames = async (
   groupInfo,
   { featuresReport, coverageHandledFromOutside },
 ) => {
-  const { pluginRequiredNameArray } = groupInfo
-  const requiredPluginNames = pluginRequiredNameArray.slice()
-  const markPluginAsSupported = (name) => {
-    const index = requiredPluginNames.indexOf(name)
+  const { missingFeatureNames } = groupInfo
+  const missingFeatureNamesCopy = missingFeatureNames.slice()
+  const markAsSupported = (name) => {
+    const index = missingFeatureNamesCopy.indexOf(name)
     if (index > -1) {
-      requiredPluginNames.splice(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) {
-    markPluginAsSupported("transform-instrument")
+    markAsSupported("transform-instrument")
   }
-
-  if (pluginRequiredNameArray.includes("transform-import-assertions")) {
+  if (missingFeatureNames.includes("transform-import-assertions")) {
     const jsonImportAssertions = await supportsJsonImportAssertions()
     featuresReport.jsonImportAssertions = jsonImportAssertions
 
@@ -91,17 +86,15 @@ const pluginRequiredNamesFromGroupInfo = async (
     featuresReport.cssImportAssertions = cssImportAssertions
 
     if (jsonImportAssertions && cssImportAssertions) {
-      markPluginAsSupported("transform-import-assertions")
+      markAsSupported("transform-import-assertions")
     }
   }
-
-  if (pluginRequiredNameArray.includes("new-stylesheet-as-jsenv-import")) {
+  if (missingFeatureNames.includes("new-stylesheet-as-jsenv-import")) {
     const newStylesheet = supportsNewStylesheet()
     featuresReport.newStylesheet = newStylesheet
-    markPluginAsSupported("new-stylesheet-as-jsenv-import")
+    markAsSupported("new-stylesheet-as-jsenv-import")
   }
-
-  return requiredPluginNames
+  return missingFeatureNamesCopy
 }
 
 const detectSupportedFeatures = async ({

package/src/internal/browser_runtime/browser_runtime.js

@@ -127,12 +127,12 @@ const onExecutionError = (
   },
 ) => {
   const error = executionResult.error
-  if (error.code === "NETWORK_FAILURE") {
+  if (error && error.code === "NETWORK_FAILURE") {
     if (currentScript) {
       const errorEvent = new Event("error")
       currentScript.dispatchEvent(errorEvent)
     }
-  } else {
+  } else if (typeof error === "object") {
     const { parsingError } = error
     const globalErrorEvent = new Event("error")
     if (parsingError) {

package/src/internal/browser_runtime/createBrowserRuntime.js

@@ -40,7 +40,7 @@ export const createBrowserRuntime = async ({
   // if there is an importmap in the document we use it instead of fetching.
   // systemjs style with systemjs-importmap
   const importmapScript = document.querySelector(
-    `script[type="jsenv-importmap"]`,
+    `script[type="systemjs-importmap"]`,
   )
   let importMap
   let importMapUrl

package/src/internal/browser_runtime/displayErrorInDocument.js

@@ -102,6 +102,8 @@ const errorToHTML = (error) => {
     }
   } else if (typeof error === "string") {
     html = error
+  } else if (error === undefined) {
+    html = "undefined"
   } else {
     html = JSON.stringify(error)
   }

package/src/internal/browser_runtime/displayErrorNotification.js

@@ -7,7 +7,7 @@ const displayErrorNotificationImplementation = (error, { icon } = {}) => {
   if (Notification.permission === "granted") {
     const notification = new Notification("An error occured", {
       lang: "en",
-      body: error.stack,
+      body: error ? error.stack : "undefined",
       icon,
     })
     notification.onclick = () => {

package/src/internal/building/buildUsingRollup.js

@@ -13,7 +13,6 @@ import {
   isNodePartOfSupportedRuntimes,
   isBrowserPartOfSupportedRuntimes,
 } from "@jsenv/core/src/internal/generateGroupMap/runtime_support.js"
-import { featuresCompatMap } from "@jsenv/core/src/internal/generateGroupMap/featuresCompatMap.js"
 import { createRuntimeCompat } from "@jsenv/core/src/internal/generateGroupMap/runtime_compat.js"
 import { createRollupPlugins } from "./rollup_plugin_jsenv.js"
 
@@ -70,21 +69,17 @@ export const buildUsingRollup = async ({
 
   const runtimeCompatMap = createRuntimeCompat({
     runtimeSupport,
-    pluginMap: {
-      import_assertion_type_json: true,
-      import_assertion_type_css: true,
-    },
-    pluginCompatMap: featuresCompatMap,
+    featureNames: ["import_assertion_type_json", "import_assertion_type_css"],
   })
   const importAssertionsSupport = {
     json:
       format === "esmodule" &&
-      !runtimeCompatMap.pluginRequiredNameArray.includes(
+      !runtimeCompatMap.missingFeatureNames.includes(
         "import_assertion_type_json",
       ),
     css:
       format === "esmodule" &&
-      !runtimeCompatMap.pluginRequiredNameArray.includes(
+      !runtimeCompatMap.missingFeatureNames.includes(
         "import_assertion_type_json",
       ),
   }

package/src/internal/building/ressource_builder.js

@@ -114,6 +114,7 @@ export const createRessourceBuilder = (
     jsLine,
     jsColumn,
     isImportAssertion,
+    isJsModule,
 
     contentTypeExpected,
     ressourceSpecifier,
@@ -131,6 +132,7 @@ export const createRessourceBuilder = (
 
       contentType,
       bufferBeforeBuild,
+      isJsModule,
     })
     return reference
   }
@@ -772,64 +774,55 @@ export const createRessourceBuilder = (
   }
 
   const rollupBuildEnd = ({
-    rollupJsFileInfos,
-    rollupAssetFileInfos,
+    rollupResult,
     useImportMapToMaximizeCacheReuse,
   }) => {
     const jsRessources = {}
+
     Object.keys(ressourceMap).forEach((ressourceUrl) => {
       const ressource = ressourceMap[ressourceUrl]
-      const jsModuleFileName = Object.keys(rollupJsFileInfos).find((key) => {
-        const rollupFileInfo = rollupJsFileInfos[key]
-        return rollupFileInfo.url === ressourceUrl
+      const rollupFileName = Object.keys(rollupResult).find((key) => {
+        const rollupFileInfo = rollupResult[key]
+        return (
+          rollupFileInfo.url === ressourceUrl ||
+          // asset
+          ressource.fileName === key ||
+          ressource.relativeUrl === key
+        )
       })
-      if (jsModuleFileName) {
-        const rollupFileInfo = rollupJsFileInfos[jsModuleFileName]
-        // We expect to find the ressource in the rollup build except when:
-        // - js was only preloaded/prefetched and never referenced afterwards
-        // - js was only referenced by other js
-        if (!rollupFileInfo) {
-          const referencedOnlyByRessourceHint = !ressource.firstStrongReference
-          if (referencedOnlyByRessourceHint) {
-            return
-          }
-          const referencedOnlyByRollup = ressource.references.every(
-            (ref) => ref.fromRollup,
-          )
-          if (referencedOnlyByRollup) {
-            // concatened by rollup
-            return
+      if (rollupFileName) {
+        const rollupFileInfo = rollupResult[rollupFileName]
+        if (rollupFileInfo.type === "asset") {
+          ressource.fileName = rollupFileName
+          return
+        }
+        if (rollupFileInfo.type === "chunk") {
+          applyBuildEndEffects(ressource, {
+            rollupFileInfo,
+            rollupResult,
+            useImportMapToMaximizeCacheReuse,
+          })
+          const { rollupBuildDoneCallbacks } = ressource
+          rollupBuildDoneCallbacks.forEach((rollupBuildDoneCallback) => {
+            rollupBuildDoneCallback()
+          })
+          if (rollupFileInfo.type === "chunk") {
+            jsRessources[ressourceUrl] = ressource
           }
-          throw new Error(
-            `${shortenUrl(ressource.url)} cannot be found in the build info`,
-          )
+          return
         }
-        applyBuildEndEffects(ressource, {
-          rollupFileInfo,
-          rollupAssetFileInfos,
-          useImportMapToMaximizeCacheReuse,
-        })
-        const { rollupBuildDoneCallbacks } = ressource
-        rollupBuildDoneCallbacks.forEach((rollupBuildDoneCallback) => {
-          rollupBuildDoneCallback()
-        })
-        jsRessources[ressourceUrl] = ressource
-        return
       }
     })
-
     return { jsRessources }
   }
 
   const applyBuildEndEffects = (
     ressource,
-    { rollupFileInfo, rollupAssetFileInfos, useImportMapToMaximizeCacheReuse },
+    { rollupFileInfo, rollupResult, useImportMapToMaximizeCacheReuse },
   ) => {
     const fileName = rollupFileInfo.fileName
     let code = rollupFileInfo.code
-    if (rollupFileInfo.type === "chunk") {
-      ressource.contentType = "application/javascript"
-    }
+    ressource.contentType = "application/javascript"
 
     if (useImportMapToMaximizeCacheReuse) {
       ressource.fileName = fileName
@@ -842,8 +835,7 @@ export const createRessourceBuilder = (
     const map = rollupFileInfo.map
     if (map) {
       const sourcemapBuildRelativeUrl = `${ressource.buildRelativeUrl}.map`
-      const sourcemapRollupFileInfo =
-        rollupAssetFileInfos[sourcemapBuildRelativeUrl]
+      const sourcemapRollupFileInfo = rollupResult[sourcemapBuildRelativeUrl]
       if (!sourcemapRollupFileInfo) {
         const ressourceBuildUrl = resolveUrl(
           ressource.buildRelativeUrl,
@@ -873,6 +865,7 @@ export const createRessourceBuilder = (
           // ${"//#"} is to avoid a parser thinking there is a sourceMappingUrl for this file
           referenceColumn: `${"//#"} sourceMappingURL=`.length + 1,
           isSourcemap: true,
+          isPlaceholder: true,
         })
         sourcemapReference.ressource.buildEnd(
           sourcemapAsString,