@jsenv/core 24.6.4 → 25.0.0-alpha.2

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,
@@ -22,7 +23,13 @@ export const buildProject = async ({
   logger,
 
   projectDirectoryUrl,
-  entryPointMap,
+  entryPoints,
+  workers = [],
+  serviceWorkers = [],
+  serviceWorkerFinalizer,
+  classicWorkers = [],
+  classicServiceWorkers = [],
+  importMapInWebWorkers = false,
   buildDirectoryRelativeUrl,
   buildDirectoryClean = true,
   assetManifestFile = false,
@@ -57,7 +64,6 @@ export const buildProject = async ({
   urlVersioning = format === "systemjs" ||
     format === "esmodule" ||
     format === "global",
-  urlVersionningForEntryPoints = false,
   lineBreakNormalization = process.platform === "win32",
   // when jsConcatenation is disabled rollup becomes almost useless
   // except it can still do tree shaking
@@ -78,10 +84,6 @@ export const buildProject = async ({
   // https://github.com/cssnano/cssnano/tree/master/packages/cssnano-preset-default
   minifyCssOptions,
 
-  workers = {},
-  serviceWorkers = {},
-  serviceWorkerFinalizer,
-
   env = {},
   protocol,
   privateKey,
@@ -113,14 +115,19 @@ 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 })
 
-  assertEntryPointMap({ entryPointMap })
+  assertentryPoints({ entryPoints })
 
-  if (Object.keys(entryPointMap).length === 0) {
-    logger.error(`entryPointMap is an empty object`)
+  if (Object.keys(entryPoints).length === 0) {
+    logger.error(`entryPoints is an empty object`)
     return {
       rollupBuilds: {},
     }
@@ -165,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,
@@ -173,9 +181,10 @@ export const buildProject = async ({
     port,
     env,
     babelPluginMap,
-    customCompilers,
+    workers,
+    serviceWorkers,
     runtimeSupport,
-
+    customCompilers,
     compileServerCanReadFromFilesystem: filesystemCache,
     compileServerCanWriteOnFilesystem: filesystemCache,
     // keep source html untouched
@@ -197,7 +206,7 @@ export const buildProject = async ({
       buildOperation,
       logger,
 
-      entryPointMap,
+      entryPoints,
       projectDirectoryUrl,
       compileServerOrigin,
       compileDirectoryRelativeUrl: `${outDirectoryRelativeUrl}${COMPILE_ID_BEST}/`,
@@ -218,11 +227,21 @@ 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,
-      urlVersionningForEntryPoints,
       lineBreakNormalization,
       useImportMapToMaximizeCacheReuse,
       preserveEntrySignatures,
@@ -235,10 +254,6 @@ export const buildProject = async ({
       minifyJsOptions,
       minifyCssOptions,
 
-      workers,
-      serviceWorkers,
-      serviceWorkerFinalizer,
-
       writeOnFileSystem,
       sourcemapExcludeSources,
     })
@@ -255,27 +270,27 @@ export const buildProject = async ({
   }
 }
 
-const assertEntryPointMap = ({ entryPointMap }) => {
-  if (typeof entryPointMap !== "object") {
-    throw new TypeError(`entryPointMap must be an object, got ${entryPointMap}`)
+const assertentryPoints = ({ entryPoints }) => {
+  if (typeof entryPoints !== "object") {
+    throw new TypeError(`entryPoints must be an object, got ${entryPoints}`)
   }
-  const keys = Object.keys(entryPointMap)
+  const keys = Object.keys(entryPoints)
   keys.forEach((key) => {
     if (!key.startsWith("./")) {
       throw new TypeError(
-        `unexpected key in entryPointMap, all keys must start with ./ but found ${key}`,
+        `unexpected key in entryPoints, all keys must start with ./ but found ${key}`,
       )
     }
 
-    const value = entryPointMap[key]
+    const value = entryPoints[key]
     if (typeof value !== "string") {
       throw new TypeError(
-        `unexpected value in entryPointMap, all values must be strings found ${value} for key ${key}`,
+        `unexpected value in entryPoints, all values must be strings found ${value} for key ${key}`,
       )
     }
-    if (!value.startsWith("./")) {
+    if (value.includes("/")) {
       throw new TypeError(
-        `unexpected value in entryPointMap, all values must starts with ./ but found ${value} for key ${key}`,
+        `unexpected value in entryPoints, all values must be plain strings (no "/") but found ${value} for key ${key}`,
       )
     }
   })

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

@@ -19,6 +19,17 @@ import { generateCoverageHtmlDirectory } from "./internal/executing/coverage_rep
 import { generateCoverageTextLog } from "./internal/executing/coverage_reporter/coverage_reporter_text_log.js"
 import { jsenvCoverageConfig } from "./jsenvCoverageConfig.js"
 
+/**
+ * Execute a list of files and log how it goes
+ * @param {object} testPlan Configure files to execute and their runtimes (browsers/node)
+ * @param {string|url} projectDirectoryUrl Root directory of your files
+ * @param {number} [maxExecutionsInParallel=1] Maximum amount of execution in parallel
+ * @param {number} [defaultMsAllocatedPerExecution=30000] Milliseconds after which execution is aborted and considered as failed by timeout
+ * @param {number} [cooldownBetweenExecutions=0] Millisecond to wait between each execution
+ * @param {boolean} [logMemoryHeapUsage=false] Add memory heap usage during logs
+ * @param {boolean} [coverage=false] Controls if coverage is collected during files executions
+ * @param {boolean} [coverageV8ConflictWarning=true] Warn when coverage from 2 executions cannot be merged
+ */
 export const executeTestPlan = async ({
   signal = new AbortController().signal,
   handleSIGINT = true,
@@ -79,6 +90,9 @@ export const executeTestPlan = async ({
   compileServerCanWriteOnFilesystem,
   babelPluginMap,
   babelConfigFileUrl,
+  workers,
+  serviceWorkers,
+  importMapInWebWorkers,
   customCompilers,
   jsenvDirectoryClean,
 }) => {
@@ -179,6 +193,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"
 
@@ -22,7 +21,7 @@ export const buildUsingRollup = async ({
   logger,
 
   projectDirectoryUrl,
-  entryPointMap,
+  entryPoints,
   compileServerOrigin,
   compileDirectoryRelativeUrl,
   buildDirectoryUrl,
@@ -49,9 +48,10 @@ export const buildUsingRollup = async ({
   workers,
   serviceWorkers,
   serviceWorkerFinalizer,
+  classicWorkers,
+  classicServiceWorkers,
 
   urlVersioning,
-  urlVersionningForEntryPoints,
   lineBreakNormalization,
   jsConcatenation,
   cssConcatenation,
@@ -69,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",
       ),
   }
@@ -99,7 +95,7 @@ export const buildUsingRollup = async ({
     logger,
 
     projectDirectoryUrl,
-    entryPointMap,
+    entryPoints,
     compileServerOrigin,
     compileDirectoryRelativeUrl,
     buildDirectoryUrl,
@@ -121,9 +117,10 @@ export const buildUsingRollup = async ({
     workers,
     serviceWorkers,
     serviceWorkerFinalizer,
+    classicWorkers,
+    classicServiceWorkers,
 
     urlVersioning,
-    urlVersionningForEntryPoints,
     lineBreakNormalization,
     jsConcatenation,
     cssConcatenation,
@@ -204,7 +201,7 @@ export const buildUsingRollup = async ({
     buildFileContents,
     buildInlineFileContents,
     buildStats,
-  } = getResult()
+  } = await getResult()
 
   if (writeOnFileSystem) {
     if (buildDirectoryClean) {
@@ -264,7 +261,7 @@ const useRollup = async ({
 
   const rollupInputOptions = {
     // about cache here, we should/could reuse previous rollup call
-    // to get the cache from the entryPointMap
+    // to get the cache from the entryPoints
     // as shown here: https://rollupjs.org/guide/en#cache
     // it could be passed in arguments to this function
     // however parallelism and having different rollup options per
@@ -307,7 +304,7 @@ const useRollup = async ({
       logger.warn(String(warning))
     },
     // on passe input: [] car c'est le plugin jsenv qui se chargera d'emit des chunks
-    // en fonction de entryPointMap
+    // en fonction de entryPoints
     // on fait cela car sinon rollup est pénible si on passe un input de type html
     input: [],
     preserveEntrySignatures,

package/src/internal/building/build_logs.js

@@ -5,8 +5,8 @@ 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)
+export const formatBuildStartLog = ({ entryPoints }) => {
+  const entryFileRelativeUrls = Object.keys(entryPoints)
   if (entryFileRelativeUrls.length === 1) {
     return `
 building ${entryFileRelativeUrls[0]}...`

package/src/internal/building/build_stats.js

@@ -59,7 +59,13 @@ const getProjectFileContents = (ressourceBuilder) => {
 
   Object.keys(ressourceMap).forEach((url) => {
     const ressource = ressourceMap[url]
-    const { isInline, isExternal, isPlaceholder, bufferBeforeBuild } = ressource
+    const {
+      isInline,
+      isExternal,
+      isPlaceholder,
+      isSourcemap,
+      bufferBeforeBuild,
+    } = ressource
     if (isInline) {
       // inline ressources are not files
       return
@@ -80,6 +86,10 @@ const getProjectFileContents = (ressourceBuilder) => {
       // to generate it in the build
       return
     }
+    if (isSourcemap && !bufferBeforeBuild) {
+      // sourcemap generated by rollup do not have bufferBeforeBuild
+      return
+    }
     projectFileContents[url] = bufferBeforeBuild
   })
   return projectFileContents

package/src/internal/building/html/parseHtmlRessource.js

@@ -16,12 +16,7 @@ Or be sure to also reference this url somewhere in the html file like
 
 */
 
-import {
-  urlToFilename,
-  urlToRelativeUrl,
-  resolveUrl,
-  urlToParentUrl,
-} from "@jsenv/filesystem"
+import { urlToFilename, urlToRelativeUrl, resolveUrl } from "@jsenv/filesystem"
 
 import {
   parseHtmlString,
@@ -255,7 +250,7 @@ const regularScriptTextNodeVisitor = (
   })
   return () => {
     const { bufferAfterBuild } = jsReference.ressource
-    textNode.value = bufferAfterBuild
+    textNode.value = String(bufferAfterBuild)
   }
 }
 
@@ -359,8 +354,6 @@ const moduleScriptTextNodeVisitor = (
     }
     const { bufferAfterBuild } = jsReference.ressource
     const jsText = String(bufferAfterBuild)
-    // ici on voudrait pouvoir ajouter le commentaire de la sourcemap
-    // sauf que cela se produit un poil plus tard je crois?
     textNode.value = jsText
   }
 }
@@ -386,23 +379,6 @@ const importmapScriptSrcVisitor = (
     contentTypeExpected: "application/importmap+json",
     ressourceSpecifier: srcAttribute.value,
     ...referenceLocationFromHtmlNode(script, "src"),
-    // here we want to force the fileName for the importmap
-    // so that we don't have to rewrite its content
-    // the goal is to put the importmap at the same relative path
-    // than in the project
-    fileNamePattern: () => {
-      const importmapReferenceUrl = importmapReference.referenceUrl
-      const importmapRessourceUrl = importmapReference.ressource.url
-      const importmapUrlRelativeToImporter = urlToRelativeUrl(
-        importmapRessourceUrl,
-        importmapReferenceUrl,
-      )
-      const importmapParentRelativeUrl = urlToRelativeUrl(
-        urlToParentUrl(resolveUrl(importmapUrlRelativeToImporter, "file://")),
-        "file://",
-      )
-      return `${importmapParentRelativeUrl}[name]-[hash][extname]`
-    },
   })
   return ({ getUrlRelativeToImporter }) => {
     const { ressource } = importmapReference

package/src/internal/building/js/parseJsRessource.js

@@ -103,9 +103,10 @@ export const parseJsRessource = async (
     map.file = urlToFilename(jsBuildUrl)
     if (map.sources) {
       map.sources = map.sources.map((source) => {
-        const sourceUrl = resolveUrl(source, jsOriginalUrl)
+        const sourceUrl = resolveUrl(source, jsUrl)
+        const sourceOriginalUrl = asOriginalUrl(sourceUrl)
         const sourceUrlRelativeToSourceMap = urlToRelativeUrl(
-          sourceUrl,
+          sourceOriginalUrl,
           sourcemapPrecomputedBuildUrl,
         )
         return sourceUrlRelativeToSourceMap

package/src/internal/building/json_module.js

@@ -0,0 +1,11 @@
+export const convertJsonTextToJavascriptModule = ({ code }) => {
+  // here we could do the following
+  // return export default jsonText
+  // This would return valid js, that would be minified later
+  // however we will prefer using JSON.parse because it's faster
+  // for js engine to parse JSON than JS
+
+  return {
+    code: `export default JSON.parse(${JSON.stringify(code.trim())})`,
+  }
+}

package/src/internal/building/parseRessource.js

@@ -22,7 +22,7 @@ import { parseJsRessource } from "./js/parseJsRessource.js"
 import { parseJsonRessource } from "./json/parseJsonRessource.js"
 import { parseWebmanifestRessource } from "./webmanifest/parseWebmanifestRessource.js"
 
-export const parseRessource = (
+export const parseRessource = async (
   ressource,
   notifiers,
   {