@jsenv/core 27.0.0-alpha.1 → 27.0.0-alpha.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsenv/core",
-  "version": "27.0.0-alpha.1",
+  "version": "27.0.0-alpha.10",
   "description": "Tool to develop, test and build js projects",
   "license": "MIT",
   "repository": {
@@ -11,8 +11,7 @@
     "node": ">=16.13.0"
   },
   "publishConfig": {
-    "access": "public",
-    "registry": "https://registry.npmjs.org"
+    "access": "public"
   },
   "type": "module",
   "imports": {},
@@ -54,7 +53,7 @@
     "@c88/v8-coverage": "0.1.1",
     "@financial-times/polyfill-useragent-normaliser": "2.0.1",
     "@jsenv/abort": "4.1.2",
-    "@jsenv/babel-plugins": "1.0.0",
+    "@jsenv/babel-plugins": "1.0.2",
     "@jsenv/filesystem": "3.1.0",
     "@jsenv/importmap": "1.2.0",
     "@jsenv/integrity": "0.0.1",
@@ -107,4 +106,4 @@
     "redux": "4.1.2",
     "rollup": "2.70.1"
   }
-}
+}

package/src/build/build.js

@@ -22,7 +22,7 @@ import {
   injectQueryParams,
   setUrlFilename,
 } from "@jsenv/utils/urls/url_utils.js"
-import { createUrlVersionGenerator } from "@jsenv/utils/urls/url_version_generator.js"
+import { createVersionGenerator } from "@jsenv/utils/versioning/version_generator.js"
 import { generateSourcemapUrl } from "@jsenv/utils/sourcemap/sourcemap_utils.js"
 import {
   parseHtmlString,
@@ -38,11 +38,12 @@ import { loadUrlGraph } from "../omega/url_graph/url_graph_load.js"
 import { createUrlGraphSummary } from "../omega/url_graph/url_graph_report.js"
 import { sortUrlGraphByDependencies } from "../omega/url_graph/url_graph_sort.js"
 
-import { createBuilUrlsGenerator } from "./build_urls_generator.js"
-import { injectVersionMappings } from "./inject_version_mappings.js"
 import { jsenvPluginBundleJsModule } from "./plugins/bundle_js_module/jsenv_plugin_bundle_js_module.js"
 import { jsenvPluginMinifyJs } from "./plugins/minify_js/jsenv_plugin_minify_js.js"
 import { jsenvPluginMinifyHtml } from "./plugins/minify_html/jsenv_plugin_minify_html.js"
+import { createBuilUrlsGenerator } from "./build_urls_generator.js"
+import { injectVersionMappings } from "./inject_version_mappings.js"
+import { injectServiceWorkerUrls } from "./inject_service_worker_urls.js"
 
 export const build = async ({
   signal = new AbortController().signal,
@@ -59,6 +60,7 @@ export const build = async ({
   nodeEsmResolution,
   fileSystemMagicResolution,
   babel,
+  injectedGlobals,
   runtimeSupport = defaultRuntimeSupport,
   sourcemaps = isPreview ? "file" : false,
 
@@ -70,6 +72,8 @@ export const build = async ({
   writeOnFileSystem = true,
   buildDirectoryClean = true,
   baseUrl = "/",
+  assetManifest = true,
+  assetManifestFileRelativeUrl = "asset-manifest.json",
 }) => {
   const logger = createLogger({ logLevel })
   rootDirectoryUrl = assertAndNormalizeDirectoryUrl(rootDirectoryUrl)
@@ -84,7 +88,7 @@ export const build = async ({
   const entryPointKeys = Object.keys(entryPoints)
   if (entryPointKeys.length === 1) {
     logger.info(`
-build ${entryPointKeys[0]}`)
+build "${entryPointKeys[0]}"`)
   } else {
     logger.info(`
 build ${entryPointKeys.length} entry points`)
@@ -112,6 +116,7 @@ build ${entryPointKeys.length} entry points`)
         nodeEsmResolution,
         fileSystemMagicResolution,
         babel,
+        injectedGlobals,
       }),
       jsenvPluginBundleJsModule(),
       ...(minify ? [jsenvPluginMinifyJs(), jsenvPluginMinifyHtml()] : []),
@@ -119,22 +124,23 @@ build ${entryPointKeys.length} entry points`)
     scenario: "build",
     sourcemaps,
   })
-  const loadEntryFiles = (cookEntryFile) => {
-    Object.keys(entryPoints).forEach((key) => {
-      cookEntryFile({
-        trace: `"${key}" in entryPoints parameter`,
-        type: "entry_point",
-        specifier: key,
-      })
-    })
-  }
+  const entryUrls = []
   try {
     await loadUrlGraph({
       urlGraph: rawGraph,
       kitchen: rawGraphKitchen,
       outDirectoryUrl: new URL(`.jsenv/build/`, rootDirectoryUrl),
       runtimeSupport,
-      startLoading: loadEntryFiles,
+      startLoading: (cookEntryFile) => {
+        Object.keys(entryPoints).forEach((key) => {
+          const [, entryUrlInfo] = cookEntryFile({
+            trace: `"${key}" in entryPoints parameter`,
+            type: "entry_point",
+            specifier: key,
+          })
+          entryUrls.push(entryUrlInfo.url)
+        })
+      },
     })
   } catch (e) {
     prebuildTask.fail()
@@ -180,30 +186,39 @@ ${Object.keys(rawGraph.urlInfos).join("\n")}`,
         return
       }
     }
-    Object.keys(rawGraph.urlInfos).forEach((rawUrl) => {
-      const rawUrlInfo = rawGraph.getUrlInfo(rawUrl)
-      if (!rawUrlInfo.data.isEntryPoint) {
-        return
-      }
-      addToBundlerIfAny(rawUrlInfo)
-      if (rawUrlInfo.type === "html") {
-        rawUrlInfo.dependencies.forEach((dependencyUrl) => {
-          const dependencyUrlInfo = rawGraph.getUrlInfo(dependencyUrl)
-          if (dependencyUrlInfo.isInline) {
-            if (dependencyUrlInfo.type === "js_module") {
-              // bundle inline script type module deps
-              dependencyUrlInfo.references.forEach((inlineScriptRef) => {
-                if (inlineScriptRef.type === "js_import_export") {
-                  addToBundlerIfAny(rawGraph.getUrlInfo(inlineScriptRef.url))
-                }
-              })
+    GRAPH.forEach(rawGraph, (rawUrlInfo) => {
+      if (rawUrlInfo.data.isEntryPoint) {
+        addToBundlerIfAny(rawUrlInfo)
+        if (rawUrlInfo.type === "html") {
+          rawUrlInfo.dependencies.forEach((dependencyUrl) => {
+            const dependencyUrlInfo = rawGraph.getUrlInfo(dependencyUrl)
+            if (dependencyUrlInfo.isInline) {
+              if (dependencyUrlInfo.type === "js_module") {
+                // bundle inline script type module deps
+                dependencyUrlInfo.references.forEach((inlineScriptRef) => {
+                  if (inlineScriptRef.type === "js_import_export") {
+                    addToBundlerIfAny(rawGraph.getUrlInfo(inlineScriptRef.url))
+                  }
+                })
+              }
+              // inline content cannot be bundled
+              return
             }
-            // inline content cannot be bundled
-            return
+            addToBundlerIfAny(dependencyUrlInfo)
+          })
+          return
+        }
+      }
+      // File referenced with new URL('./file.js', import.meta.url)
+      // are entry points that can be bundled
+      // For instance we will bundle service worker/workers detected like this
+      if (rawUrlInfo.type === "js_module") {
+        rawUrlInfo.references.forEach((reference) => {
+          if (reference.type === "js_import_meta_url_pattern") {
+            const urlInfo = rawGraph.getUrlInfo(reference.url)
+            addToBundlerIfAny(urlInfo)
           }
-          addToBundlerIfAny(dependencyUrlInfo)
         })
-        return
       }
     })
     await Object.keys(bundlers).reduce(async (previous, type) => {
@@ -238,6 +253,7 @@ ${Object.keys(rawGraph.urlInfos).join("\n")}`,
           const rawUrlInfo = rawGraph.getUrlInfo(url)
           bundleUrlInfos[url] = {
             type,
+            subtype: rawUrlInfo ? rawUrlInfo.subtype : undefined,
             ...bundleUrlInfo,
             data: {
               ...(rawUrlInfo ? rawUrlInfo.data : {}),
@@ -344,8 +360,7 @@ ${Object.keys(rawGraph.urlInfos).join("\n")}`,
             return buildUrl
           }
           if (reference.isInline) {
-            const rawUrl = Object.keys(rawGraph.urlInfos).find((url) => {
-              const rawUrlInfo = rawGraph.urlInfos[url]
+            const rawUrlInfo = GRAPH.find(rawGraph, (rawUrlInfo) => {
               if (!rawUrlInfo.isInline) {
                 return false
               }
@@ -354,10 +369,9 @@ ${Object.keys(rawGraph.urlInfos).join("\n")}`,
               }
               return false
             })
-            if (!rawUrl) {
+            if (!rawUrlInfo) {
               throw new Error(`cannot find raw url`)
             }
-            const rawUrlInfo = rawGraph.getUrlInfo(rawUrl)
             const parentUrlInfo = finalGraph.getUrlInfo(reference.parentUrl)
             const buildUrl = buildUrlsGenerator.generate(
               reference.url,
@@ -365,7 +379,7 @@ ${Object.keys(rawGraph.urlInfos).join("\n")}`,
               parentUrlInfo,
             )
             rawUrls[buildUrl] = reference.url
-            reference.data.rawUrl = rawUrl
+            reference.data.rawUrl = rawUrlInfo.url
             return buildUrl
           }
           if (reference.type === "sourcemap_comment") {
@@ -402,6 +416,7 @@ ${Object.keys(rawGraph.urlInfos).join("\n")}`,
           const rawUrl = finalUrlInfo.data.rawUrl
           const bundleUrlInfo = bundleUrlInfos[rawUrl]
           const urlInfo = bundleUrlInfo || rawGraph.getUrlInfo(rawUrl)
+          finalUrlInfo.subtype = urlInfo.subtype
           return {
             data: bundleUrlInfo ? bundleUrlInfo.data : undefined,
             originalContent: urlInfo.originalContent,
@@ -447,13 +462,23 @@ ${Object.keys(rawGraph.urlInfos).join("\n")}`,
     sourcemaps,
   })
   const buildTask = createTaskLog(logger, "build")
+  const postBuildEntryUrls = []
   try {
     await loadUrlGraph({
       urlGraph: finalGraph,
       kitchen: finalGraphKitchen,
       outDirectoryUrl: new URL(".jsenv/postbuild/", rootDirectoryUrl),
       runtimeSupport,
-      startLoading: loadEntryFiles,
+      startLoading: (cookEntryFile) => {
+        entryUrls.forEach((entryUrl) => {
+          const [, postBuildEntryUrlInfo] = cookEntryFile({
+            trace: `entryPoint`,
+            type: "entry_point",
+            specifier: entryUrl,
+          })
+          postBuildEntryUrls.push(postBuildEntryUrlInfo.url)
+        })
+      },
     })
   } catch (e) {
     buildTask.fail()
@@ -480,8 +505,8 @@ ${Object.keys(finalGraph.urlInfos).join("\n")}`,
         if (urlInfo.isInline) {
           return
         }
-        const urlVersionGenerator = createUrlVersionGenerator()
-        urlVersionGenerator.augmentWithContent({
+        const versionGenerator = createVersionGenerator()
+        versionGenerator.augmentWithContent({
           content: urlInfo.content,
           contentType: urlInfo.contentType,
           lineBreakNormalization,
@@ -493,7 +518,7 @@ ${Object.keys(finalGraph.urlInfos).join("\n")}`,
             return
           }
           if (dependencyUrlInfo.data.version) {
-            urlVersionGenerator.augmentWithDependencyVersion(
+            versionGenerator.augmentWithDependencyVersion(
               dependencyUrlInfo.data.version,
             )
           } else {
@@ -501,14 +526,14 @@ ${Object.keys(finalGraph.urlInfos).join("\n")}`,
             // it means there is a circular dependency between this file
             // and it's dependency
             // in that case we'll use the dependency content
-            urlVersionGenerator.augmentWithContent({
+            versionGenerator.augmentWithContent({
               content: dependencyUrlInfo.content,
               contentType: dependencyUrlInfo.contentType,
               lineBreakNormalization,
             })
           }
         })
-        urlInfo.data.version = urlVersionGenerator.generate()
+        urlInfo.data.version = versionGenerator.generate()
         urlInfo.data.versionedUrl = injectVersionIntoBuildUrl({
           buildUrl: urlInfo.url,
           version: urlInfo.data.version,
@@ -540,12 +565,12 @@ ${Object.keys(finalGraph.urlInfos).join("\n")}`,
           {
             name: "jsenv:versioning",
             appliesDuring: { build: true },
-            resolve: ({ parentUrl, specifier }) => {
-              const buildUrl = buildUrls[specifier]
+            resolve: (reference) => {
+              const buildUrl = buildUrls[reference.specifier]
               if (buildUrl) {
                 return buildUrl
               }
-              const url = new URL(specifier, parentUrl).href
+              const url = new URL(reference.specifier, reference.parentUrl).href
               return url
             },
             formatReferencedUrl: (reference) => {
@@ -555,7 +580,11 @@ ${Object.keys(finalGraph.urlInfos).join("\n")}`,
               // specifier comes from "normalize" hook done a bit earlier in this file
               // we want to get back their build url to access their infos
               const referencedUrlInfo = finalGraph.getUrlInfo(reference.url)
-              if (referencedUrlInfo.data.isEntryPoint) {
+              if (
+                referencedUrlInfo.data.isEntryPoint ||
+                referencedUrlInfo.subtype === "service_worker" ||
+                referencedUrlInfo.type === "webmanifest"
+              ) {
                 return reference.specifier
               }
               // data:* urls and so on
@@ -593,13 +622,12 @@ ${Object.keys(finalGraph.urlInfos).join("\n")}`,
               }
               return versionedSpecifier
             },
-            load: ({ url }) => {
-              const urlInfo = finalGraph.getUrlInfo(url)
+            load: (finalUrlInfo) => {
               return {
-                originalContent: urlInfo.originalContent,
-                contentType: urlInfo.contentType,
-                content: urlInfo.content,
-                sourcemap: urlInfo.sourcemap,
+                originalContent: finalUrlInfo.originalContent,
+                contentType: finalUrlInfo.contentType,
+                content: finalUrlInfo.content,
+                sourcemap: finalUrlInfo.sourcemap,
               }
             },
           },
@@ -608,15 +636,22 @@ ${Object.keys(finalGraph.urlInfos).join("\n")}`,
         sourcemaps,
       })
       // arrange state before reloading all files
-      Object.keys(finalGraph.urlInfos).forEach((url) => {
-        const urlInfo = finalGraph.urlInfos[url]
-        urlInfo.data.promise = null
+      GRAPH.forEach(finalGraph, (finalUrlInfo) => {
+        finalUrlInfo.data.promise = null
       })
       await loadUrlGraph({
         urlGraph: finalGraph,
         kitchen: versioningKitchen,
         runtimeSupport,
-        startLoading: loadEntryFiles,
+        startLoading: (cookEntryFile) => {
+          postBuildEntryUrls.forEach((postBuildEntryUrl) => {
+            cookEntryFile({
+              trace: `entryPoint`,
+              type: "entry_point",
+              specifier: postBuildEntryUrl,
+            })
+          })
+        },
       })
       if (usedVersionMappings.length) {
         const versionMappingsNeeded = {}
@@ -624,12 +659,12 @@ ${Object.keys(finalGraph.urlInfos).join("\n")}`,
           versionMappingsNeeded[specifier] = versionMappings[specifier]
         })
         await Promise.all(
-          Object.keys(finalGraph.urlInfos).map(async (buildUrl) => {
-            const buildUrlInfo = finalGraph.getUrlInfo(buildUrl)
-            if (!buildUrlInfo.data.isEntryPoint) {
+          GRAPH.map(finalGraph, async (urlInfo) => {
+            if (!urlInfo.data.isEntryPoint) {
               return
             }
-            await injectVersionMappings(buildUrlInfo, {
+            await injectVersionMappings({
+              urlInfo,
               kitchen: finalGraphKitchen,
               versionMappings: versionMappingsNeeded,
             })
@@ -643,34 +678,98 @@ ${Object.keys(finalGraph.urlInfos).join("\n")}`,
     versioningTask.done()
   }
 
-  const buildFileContents = {}
-  const buildInlineFileContents = {}
-  const buildManifest = {}
-  Object.keys(finalGraph.urlInfos).forEach((url) => {
-    if (!url.startsWith("file:")) {
+  GRAPH.forEach(finalGraph, (urlInfo) => {
+    if (!urlInfo.url.startsWith("file:")) {
       return
     }
-    const buildUrlInfo = finalGraph.getUrlInfo(url)
-    const versionedUrl = buildUrlInfo.data.versionedUrl
-    const useVersionedUrl = versionedUrl && !buildUrlInfo.data.isEntryPoint
-    const buildUrl = useVersionedUrl ? versionedUrl : buildUrlInfo.url
+    const version = urlInfo.data.version
+    const useVersionedUrl =
+      !urlInfo.data.isEntryPoint &&
+      urlInfo.subtype !== "service_worker" &&
+      urlInfo.type !== "webmanifest" &&
+      version
+    const buildUrl = useVersionedUrl ? urlInfo.data.versionedUrl : urlInfo.url
     if (!urlIsInsideOf(buildUrl, buildDirectoryUrl)) {
       throw new Error(`build url outside build directory`)
     }
     const buildRelativeUrl = urlToRelativeUrl(buildUrl, buildDirectoryUrl)
-    if (buildUrlInfo.isInline) {
-      buildInlineFileContents[buildRelativeUrl] = buildUrlInfo.content
+    urlInfo.data.buildUrl = buildUrl
+    urlInfo.data.buildUrlIsVersioned = useVersionedUrl
+    urlInfo.data.buildRelativeUrl = buildRelativeUrl
+  })
+
+  const hasServiceWorker = Boolean(
+    GRAPH.find(
+      finalGraph,
+      (finalUrlInfo) => finalUrlInfo.subtype === "service_worker",
+    ),
+  )
+  if (hasServiceWorker) {
+    const serviceWorkerUrls = {}
+    GRAPH.forEach(finalGraph, (urlInfo) => {
+      if (!urlInfo.url.startsWith("file:")) {
+        return
+      }
+      if (urlInfo.isInline) {
+        return
+      }
+      if (urlInfo.data.buildUrlIsVersioned) {
+        serviceWorkerUrls[urlInfo.data.buildRelativeUrl] = {
+          versioned: true,
+        }
+        return
+      }
+      if (!urlInfo.data.version) {
+        // when url is not versioned we compute a "version" for that url anyway
+        // so that service worker source still changes and navigator
+        // detect there is a change
+        const versionGenerator = createVersionGenerator()
+        versionGenerator.augmentWithContent({
+          content: urlInfo.content,
+          contentType: urlInfo.contentType,
+          lineBreakNormalization,
+        })
+        const version = versionGenerator.generate()
+        urlInfo.data.version = version
+      }
+      serviceWorkerUrls[urlInfo.data.buildRelativeUrl] = {
+        versioned: false,
+        version: urlInfo.data.version,
+      }
+    })
+    await Promise.all(
+      GRAPH.map(finalGraph, async (urlInfo) => {
+        if (urlInfo.subtype !== "service_worker") {
+          return
+        }
+        await injectServiceWorkerUrls({
+          urlInfo,
+          kitchen: finalGraphKitchen,
+          serviceWorkerUrls,
+        })
+      }),
+    )
+  }
+
+  const buildManifest = {}
+  const buildFileContents = {}
+  const buildInlineFileContents = {}
+  GRAPH.forEach(finalGraph, (urlInfo) => {
+    const { buildUrlIsVersioned, buildRelativeUrl } = urlInfo.data
+    if (urlInfo.isInline) {
+      buildInlineFileContents[buildRelativeUrl] = urlInfo.content
     } else {
-      buildFileContents[buildRelativeUrl] = buildUrlInfo.content
+      buildFileContents[buildRelativeUrl] = urlInfo.content
     }
-    if (useVersionedUrl) {
+    if (buildUrlIsVersioned) {
       const buildRelativeUrlWithoutVersioning = urlToRelativeUrl(
-        buildUrlInfo.url,
+        urlInfo.url,
         buildDirectoryUrl,
       )
       buildManifest[buildRelativeUrlWithoutVersioning] = buildRelativeUrl
     }
   })
+
   logger.debug(
     `graph urls post-versioning:
 ${Object.keys(finalGraph.urlInfos).join("\n")}`,
@@ -689,6 +788,16 @@ ${Object.keys(finalGraph.urlInfos).join("\n")}`,
         )
       }),
     )
+    if (
+      versioning !== "none" &&
+      assetManifest &&
+      Object.keys(buildManifest).length
+    ) {
+      await writeFile(
+        new URL(assetManifestFileRelativeUrl, buildDirectoryUrl),
+        JSON.stringify(buildManifest, null, "  "),
+      )
+    }
   }
   logger.info(createUrlGraphSummary(finalGraph, { title: "build files" }))
   return {
@@ -698,6 +807,27 @@ ${Object.keys(finalGraph.urlInfos).join("\n")}`,
   }
 }
 
+const GRAPH = {
+  map: (graph, callback) => {
+    return Object.keys(graph.urlInfos).map((url) => {
+      return callback(graph.urlInfos[url])
+    })
+  },
+
+  forEach: (graph, callback) => {
+    Object.keys(graph.urlInfos).forEach((url) => {
+      callback(graph.urlInfos[url], url)
+    })
+  },
+
+  find: (graph, callback) => {
+    const urlFound = Object.keys(graph.urlInfos).find((url) => {
+      return callback(graph.urlInfos[url])
+    })
+    return graph.urlInfos[urlFound]
+  },
+}
+
 const injectVersionIntoBuildUrl = ({ buildUrl, version, versioning }) => {
   if (versioning === "search_param") {
     return injectQueryParams(buildUrl, {

package/src/build/build_urls_generator.js

@@ -6,6 +6,12 @@ export const createBuilUrlsGenerator = ({ buildDirectoryUrl }) => {
   const cache = {}
   const generate = memoizeByUrl((url, urlInfo, parentUrlInfo) => {
     const directoryPath = determineDirectoryPath(urlInfo, parentUrlInfo)
+    let names = cache[directoryPath]
+    if (!names) {
+      names = []
+      cache[directoryPath] = names
+    }
+
     let name = urlToFilename(url)
     const { searchParams } = new URL(url)
     if (
@@ -15,12 +21,7 @@ export const createBuilUrlsGenerator = ({ buildDirectoryUrl }) => {
     ) {
       name = `${name}.js`
     }
-    let names = cache[directoryPath]
-    if (!names) {
-      names = []
-      cache[directoryPath] = names
-    }
-
+    const [basename, extension] = splitFileExtension(name)
     let nameCandidate = name
     let integer = 1
     // eslint-disable-next-line no-constant-condition
@@ -30,7 +31,7 @@ export const createBuilUrlsGenerator = ({ buildDirectoryUrl }) => {
         break
       }
       integer++
-      nameCandidate = `${name}${integer}`
+      nameCandidate = `${basename}${integer}${extension}`
     }
     return `${buildDirectoryUrl}${directoryPath}${nameCandidate}`
   })
@@ -40,6 +41,14 @@ export const createBuilUrlsGenerator = ({ buildDirectoryUrl }) => {
   }
 }
 
+const splitFileExtension = (filename) => {
+  const dotLastIndex = filename.lastIndexOf(".")
+  if (dotLastIndex === -1) {
+    return [filename, ""]
+  }
+  return [filename.slice(0, dotLastIndex), filename.slice(dotLastIndex)]
+}
+
 const determineDirectoryPath = (urlInfo, parentUrlInfo) => {
   if (urlInfo.isInline) {
     const parentDirectoryPath = determineDirectoryPath(parentUrlInfo)

package/src/build/inject_service_worker_urls.js

@@ -0,0 +1,25 @@
+import { createMagicSource } from "@jsenv/utils/sourcemap/magic_source.js"
+
+export const injectServiceWorkerUrls = async ({
+  urlInfo,
+  kitchen,
+  serviceWorkerUrls,
+}) => {
+  const magicSource = createMagicSource(urlInfo.content)
+  const urlsWithoutSelf = {
+    ...serviceWorkerUrls,
+  }
+  delete urlsWithoutSelf[urlInfo.data.buildRelativeUrl]
+  magicSource.prepend(generateClientCode(urlsWithoutSelf))
+  const { content, sourcemap } = magicSource.toContentAndSourcemap()
+  await kitchen.urlInfoTransformer.applyFinalTransformations(urlInfo, {
+    content,
+    sourcemap,
+  })
+}
+
+const generateClientCode = (serviceWorkerUrls) => {
+  return `
+self.serviceWorkerUrls = ${JSON.stringify(serviceWorkerUrls, null, "  ")};
+`
+}

package/src/build/inject_version_mappings.js

@@ -8,10 +8,11 @@ import {
 } from "@jsenv/utils/html_ast/html_ast.js"
 import { createMagicSource } from "@jsenv/utils/sourcemap/magic_source.js"
 
-export const injectVersionMappings = async (
+export const injectVersionMappings = async ({
   urlInfo,
-  { kitchen, versionMappings },
-) => {
+  kitchen,
+  versionMappings,
+}) => {
   const injector = injectors[urlInfo.type]
   if (injector) {
     const { content, sourcemap } = injector(urlInfo, { versionMappings })

package/src/build/plugins/bundle_js_module/jsenv_plugin_bundle_js_module.js

@@ -131,15 +131,6 @@ const rollupPluginJsenv = ({
         const rollupFileInfo = rollupResult[fileName]
         // there is 3 types of file: "placeholder", "asset", "chunk"
         if (rollupFileInfo.type === "chunk") {
-          const { facadeModuleId } = rollupFileInfo
-          let url
-          if (facadeModuleId) {
-            url = fileUrlConverter.asFileUrl(facadeModuleId)
-          } else {
-            const { sources } = rollupFileInfo.map
-            const sourcePath = sources[sources.length - 1]
-            url = fileUrlConverter.asFileUrl(sourcePath)
-          }
           const jsModuleBundleUrlInfo = {
             // buildRelativeUrl: rollupFileInfo.fileName,
             data: {
@@ -149,6 +140,12 @@ const rollupPluginJsenv = ({
             content: rollupFileInfo.code,
             sourcemap: rollupFileInfo.map,
           }
+          let url
+          if (rollupFileInfo.facadeModuleId) {
+            url = fileUrlConverter.asFileUrl(rollupFileInfo.facadeModuleId)
+          } else {
+            url = new URL(rollupFileInfo.fileName, rootDirectoryUrl).href
+          }
           jsModuleBundleUrlInfos[url] = jsModuleBundleUrlInfo
         }
       })
@@ -171,13 +168,18 @@ const rollupPluginJsenv = ({
         },
         chunkFileNames: (chunkInfo) => {
           // preserves relative path parts:
-          // the goal is to mantain the original relative path (relative to the root directory)
+          // the goal is to maintain the original relative path (relative to the root directory)
           // so that later in the build process, when resolving these urls, we are able to
           // re-resolve the specifier againt the original parent url and find the original url
-          const { facadeModuleId } = chunkInfo
-          const fileUrl = fileUrlConverter.asFileUrl(facadeModuleId)
-          const relativePath = urlToRelativeUrl(fileUrl, rootDirectoryUrl)
-          return relativePath
+          if (chunkInfo.facadeModuleId) {
+            const fileUrl = fileUrlConverter.asFileUrl(chunkInfo.facadeModuleId)
+            const relativePath = urlToRelativeUrl(fileUrl, rootDirectoryUrl)
+            return relativePath
+          }
+          // chunk generated dynamically by rollup to share code.
+          // we prefix with "__rollup__/" to avoid potential conflict of filename
+          // between this one and a file with the same name existing in the root directory
+          return `__rollup__/${chunkInfo.name}.js`
         },
         // https://rollupjs.org/guide/en/#outputpaths
         // paths: (id) => {