@jsenv/core 27.0.0-alpha.31 → 27.0.0-alpha.34

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsenv/core",
-  "version": "27.0.0-alpha.31",
+  "version": "27.0.0-alpha.34",
   "description": "Tool to develop, test and build js projects",
   "license": "MIT",
   "repository": {

package/src/build/build.js

@@ -46,19 +46,44 @@ import { injectGlobalVersionMapping } from "./inject_global_version_mappings.js"
 import { injectServiceWorkerUrls } from "./inject_service_worker_urls.js"
 import { resyncRessourceHints } from "./resync_ressource_hints.js"
 
+/**
+ * Generate an optimized version of source files into a directory
+ * @param {Object} buildParameters
+ * @param {string|url} buildParameters.rootDirectoryUrl
+ *        Directory containing source files
+ * @param {string|url} buildParameters.buildDirectoryUrl
+ *        Directory where optimized files will be written
+ * @param {object} buildParameters.entryPoints
+ *        Describe entry point paths and control their names in the build directory
+ * @param {object} buildParameters.runtimeCompat
+ *        Code generated will be compatible with these runtimes
+ * @param {string="/"} buildParameters.baseUrl
+ *        All urls in build file contents are prefixed with this url
+ * @param {boolean|object} [buildParameters.minification=true]
+ *        Minify build file contents
+ * @param {boolean} [buildParameters.versioning=true]
+ *        Controls if url in build file contents are versioned
+ * @param {('search_param'|'filename')} [buildParameters.versioningMethod="search_param"]
+ *        Controls how url are versioned
+ * @param {boolean|string} [buildParameters.sourcemaps=false]
+ *        Generate sourcemaps in the build directory
+ * @return {Object} buildReturnValue
+ * @return {Object} buildReturnValue.buildFileContents
+ *        Contains all build file paths relative to the build directory and their content
+ * @return {Object} buildReturnValue.buildInlineContents
+ *        Contains content that is inline into build files
+ * @return {Object} buildReturnValue.buildManifest
+ *        Map build file paths without versioning to versioned file paths
+ */
 export const build = async ({
   signal = new AbortController().signal,
   logLevel = "info",
   rootDirectoryUrl,
   buildDirectoryUrl,
   entryPoints = {},
-  // for now it's here but I think preview will become an other script
-  // that will just pass different options to build project
-  // and this function will be agnostic about "preview" concept
-  isPreview = false,
 
   plugins = [],
-  sourcemaps = isPreview ? "file" : false,
+  sourcemaps = false,
   nodeEsmResolution,
   fileSystemMagicResolution,
   injectedGlobals,
@@ -142,6 +167,7 @@ build ${entryPointKeys.length} entry points`)
             specifier: key,
           })
           entryUrls.push(entryUrlInfo.url)
+          entryUrlInfo.filename = entryPoints[key]
         })
       },
     })
@@ -234,6 +260,7 @@ ${Object.keys(rawGraph.urlInfos).join("\n")}`,
       })
     }
   })
+  const bundleUrlRedirections = {}
   await Object.keys(bundlers).reduce(async (previous, type) => {
     await previous
     const bundler = bundlers[type]
@@ -276,6 +303,13 @@ ${Object.keys(rawGraph.urlInfos).join("\n")}`,
         rawUrlRedirections[url] = buildUrl
         rawUrls[buildUrl] = url
         bundleUrlInfos[buildUrl] = bundleUrlInfo
+        if (bundlerGeneratedUrlInfo.data.bundleRelativeUrl) {
+          const urlForBundler = new URL(
+            bundlerGeneratedUrlInfo.data.bundleRelativeUrl,
+            buildDirectoryUrl,
+          ).href
+          bundleUrlRedirections[urlForBundler] = buildUrl
+        }
       })
     } catch (e) {
       bundleTask.fail()
@@ -313,6 +347,10 @@ ${Object.keys(rawGraph.urlInfos).join("\n")}`,
             reference.specifier[0] === "/"
               ? new URL(reference.specifier.slice(1), buildDirectoryUrl).href
               : new URL(reference.specifier, reference.parentUrl).href
+          const urlRedirectedByBundle = bundleUrlRedirections[url]
+          if (urlRedirectedByBundle) {
+            return urlRedirectedByBundle
+          }
           const parentIsFromBundle = Boolean(
             bundleUrlInfos[reference.parentUrl],
           )
@@ -579,220 +617,22 @@ ${Object.keys(rawGraph.urlInfos).join("\n")}`,
 ${Object.keys(finalGraph.urlInfos).join("\n")}`,
   )
   if (versioning) {
-    const versioningTask = createTaskLog(logger, "inject version in urls")
-    try {
-      const urlsSorted = sortUrlGraphByDependencies(finalGraph)
-      urlsSorted.forEach((url) => {
-        if (url.startsWith("data:")) {
-          return
-        }
-        const urlInfo = finalGraph.getUrlInfo(url)
-        if (urlInfo.type === "sourcemap") {
-          return
-        }
-        // ignore:
-        // - inline files:
-        //   they are already taken into account in the file where they appear
-        // - external files
-        //   we don't know their content
-        // - unused files without reference
-        //   File updated such as style.css -> style.css.js or file.js->file.es5.js
-        //   Are used at some point just to be discarded later because they need to be converted
-        //   There is no need to version them and we could not because the file have been ignored
-        //   so their content is unknown
-        if (urlInfo.isInline) {
-          return
-        }
-        if (urlInfo.external) {
-          return
-        }
-        if (!urlInfo.data.isEntryPoint && urlInfo.dependents.size === 0) {
-          return
-        }
-
-        const urlContent =
-          urlInfo.type === "html"
-            ? stringifyHtmlAst(
-                parseHtmlString(urlInfo.content, {
-                  storeOriginalPositions: false,
-                }),
-                { removeOriginalPositionAttributes: true },
-              )
-            : urlInfo.content
-        const versionGenerator = createVersionGenerator()
-        versionGenerator.augmentWithContent({
-          content: urlContent,
-          contentType: urlInfo.contentType,
-          lineBreakNormalization,
-        })
-        urlInfo.dependencies.forEach((dependencyUrl) => {
-          // this dependency is inline (data:) or remote (http://, https://)
-          if (!dependencyUrl.startsWith("file:")) {
-            return
-          }
-          const dependencyUrlInfo = finalGraph.getUrlInfo(dependencyUrl)
-          if (
-            // this content is part of the file, no need to take into account twice
-            dependencyUrlInfo.isInline ||
-            // this dependency content is not known
-            dependencyUrlInfo.external
-          ) {
-            return
-          }
-          if (dependencyUrlInfo.data.version) {
-            versionGenerator.augmentWithDependencyVersion(
-              dependencyUrlInfo.data.version,
-            )
-          } else {
-            // because all dependencies are know, if the dependency has no version
-            // it means there is a circular dependency between this file
-            // and it's dependency
-            // in that case we'll use the dependency content
-            versionGenerator.augmentWithContent({
-              content: dependencyUrlInfo.content,
-              contentType: dependencyUrlInfo.contentType,
-              lineBreakNormalization,
-            })
-          }
-        })
-        urlInfo.data.version = versionGenerator.generate()
-
-        urlInfo.data.versionedUrl = injectVersionIntoBuildUrl({
-          buildUrl: urlInfo.url,
-          version: urlInfo.data.version,
-          versioningMethod,
-        })
-      })
-      const versionMappings = {}
-      const usedVersionMappings = []
-      const versioningKitchen = createKitchen({
-        logger,
-        rootDirectoryUrl: buildDirectoryUrl,
-        urlGraph: finalGraph,
-        scenario: "build",
-        sourcemaps,
-        runtimeCompat,
-        plugins: [
-          jsenvPluginInline({
-            fetchInlineUrls: false,
-            analyzeConvertedScripts: true, // to be able to version their urls
-            allowEscapeForVersioning: true,
-          }),
-          {
-            name: "jsenv:versioning",
-            appliesDuring: { build: true },
-            resolveUrl: (reference) => {
-              if (reference.specifier[0] === "#") {
-                reference.external = true
-              }
-              const buildUrl = buildUrls[reference.specifier]
-              if (buildUrl) {
-                return buildUrl
-              }
-              const url = new URL(reference.specifier, reference.parentUrl).href
-              return url
-            },
-            formatUrl: (reference) => {
-              if (reference.isInline) {
-                return null
-              }
-              // 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 (!canUseVersionedUrl(referencedUrlInfo)) {
-                return reference.specifier
-              }
-              // data:* urls and so on
-              if (!referencedUrlInfo.url.startsWith("file:")) {
-                return null
-              }
-              const versionedUrl = referencedUrlInfo.data.versionedUrl
-              if (!versionedUrl) {
-                // happens for sourcemap
-                return `${baseUrl}${urlToRelativeUrl(
-                  referencedUrlInfo.url,
-                  buildDirectoryUrl,
-                )}`
-              }
-              const versionedSpecifier = `${baseUrl}${urlToRelativeUrl(
-                versionedUrl,
-                buildDirectoryUrl,
-              )}`
-              versionMappings[reference.specifier] = versionedSpecifier
-              buildUrls[versionedSpecifier] = versionedUrl
-
-              const parentUrlInfo = finalGraph.getUrlInfo(reference.parentUrl)
-              if (parentUrlInfo.jsQuote) {
-                // the url is inline inside js quotes
-                usedVersionMappings.push(reference.specifier)
-                return () =>
-                  `${parentUrlInfo.jsQuote}+__v__(${JSON.stringify(
-                    reference.specifier,
-                  )})+${parentUrlInfo.jsQuote}`
-              }
-              if (
-                reference.type === "js_url_specifier" ||
-                reference.subtype === "import_dynamic"
-              ) {
-                usedVersionMappings.push(reference.specifier)
-                return () => `__v__(${JSON.stringify(reference.specifier)})`
-              }
-              return versionedSpecifier
-            },
-            fetchUrlContent: (versionedUrlInfo) => {
-              if (!versionedUrlInfo.url.startsWith("file:")) {
-                return { external: true }
-              }
-              if (versionedUrlInfo.isInline) {
-                const rawUrlInfo = rawGraph.getUrlInfo(
-                  rawUrls[versionedUrlInfo.url],
-                )
-                const finalUrlInfo = finalGraph.getUrlInfo(versionedUrlInfo.url)
-                return {
-                  originalContent: rawUrlInfo
-                    ? rawUrlInfo.originalContent
-                    : undefined,
-                  sourcemap: finalUrlInfo ? finalUrlInfo.sourcemap : undefined,
-                  contentType: versionedUrlInfo.contentType,
-                  content: versionedUrlInfo.content,
-                }
-              }
-              return versionedUrlInfo
-            },
-          },
-        ],
-      })
-      await loadUrlGraph({
-        urlGraph: finalGraph,
-        kitchen: versioningKitchen,
-        startLoading: (cookEntryFile) => {
-          postBuildEntryUrls.forEach((postBuildEntryUrl) => {
-            cookEntryFile({
-              trace: `entryPoint`,
-              type: "entry_point",
-              specifier: postBuildEntryUrl,
-            })
-          })
-        },
-      })
-      if (usedVersionMappings.length) {
-        const versionMappingsNeeded = {}
-        usedVersionMappings.forEach((specifier) => {
-          versionMappingsNeeded[specifier] = versionMappings[specifier]
-        })
-        await injectGlobalVersionMapping({
-          finalGraphKitchen,
-          finalGraph,
-          versionMappings: versionMappingsNeeded,
-        })
-      }
-    } catch (e) {
-      versioningTask.fail()
-      throw e
-    }
-    versioningTask.done()
+    await applyUrlVersioning({
+      logger,
+      buildDirectoryUrl,
+      rawUrls,
+      buildUrls,
+      baseUrl,
+      postBuildEntryUrls,
+      sourcemaps,
+      runtimeCompat,
+      rawGraph,
+      finalGraph,
+      finalGraphKitchen,
+      lineBreakNormalization,
+      versioningMethod,
+    })
   }
-
   GRAPH.forEach(finalGraph, (urlInfo) => {
     if (!urlInfo.url.startsWith("file:")) {
       return
@@ -818,7 +658,6 @@ ${Object.keys(finalGraph.urlInfos).join("\n")}`,
     urlInfo.data.buildUrlIsVersioned = useVersionedUrl
     urlInfo.data.buildUrlSpecifier = buildUrlSpecifier
   })
-
   await resyncRessourceHints({
     finalGraphKitchen,
     finalGraph,
@@ -846,7 +685,6 @@ ${Object.keys(finalGraph.urlInfos).join("\n")}`,
     finalGraph,
     lineBreakNormalization,
   })
-
   logger.debug(
     `graph urls post-versioning:
 ${Object.keys(finalGraph.urlInfos).join("\n")}`,
@@ -905,6 +743,235 @@ ${Object.keys(finalGraph.urlInfos).join("\n")}`,
   }
 }
 
+const applyUrlVersioning = async ({
+  logger,
+  buildDirectoryUrl,
+  rawUrls,
+  buildUrls,
+  baseUrl,
+  postBuildEntryUrls,
+  sourcemaps,
+  runtimeCompat,
+  rawGraph,
+  finalGraph,
+  finalGraphKitchen,
+  lineBreakNormalization,
+  versioningMethod,
+}) => {
+  const versioningTask = createTaskLog(logger, "inject version in urls")
+  try {
+    const urlsSorted = sortUrlGraphByDependencies(finalGraph)
+    urlsSorted.forEach((url) => {
+      if (url.startsWith("data:")) {
+        return
+      }
+      const urlInfo = finalGraph.getUrlInfo(url)
+      if (urlInfo.type === "sourcemap") {
+        return
+      }
+      // ignore:
+      // - inline files:
+      //   they are already taken into account in the file where they appear
+      // - external files
+      //   we don't know their content
+      // - unused files without reference
+      //   File updated such as style.css -> style.css.js or file.js->file.es5.js
+      //   Are used at some point just to be discarded later because they need to be converted
+      //   There is no need to version them and we could not because the file have been ignored
+      //   so their content is unknown
+      if (urlInfo.isInline) {
+        return
+      }
+      if (urlInfo.external) {
+        return
+      }
+      if (!urlInfo.data.isEntryPoint && urlInfo.dependents.size === 0) {
+        return
+      }
+
+      const urlContent =
+        urlInfo.type === "html"
+          ? stringifyHtmlAst(
+              parseHtmlString(urlInfo.content, {
+                storeOriginalPositions: false,
+              }),
+              { removeOriginalPositionAttributes: true },
+            )
+          : urlInfo.content
+      const versionGenerator = createVersionGenerator()
+      versionGenerator.augmentWithContent({
+        content: urlContent,
+        contentType: urlInfo.contentType,
+        lineBreakNormalization,
+      })
+      urlInfo.dependencies.forEach((dependencyUrl) => {
+        // this dependency is inline (data:) or remote (http://, https://)
+        if (!dependencyUrl.startsWith("file:")) {
+          return
+        }
+        const dependencyUrlInfo = finalGraph.getUrlInfo(dependencyUrl)
+        if (
+          // this content is part of the file, no need to take into account twice
+          dependencyUrlInfo.isInline ||
+          // this dependency content is not known
+          dependencyUrlInfo.external
+        ) {
+          return
+        }
+        if (dependencyUrlInfo.data.version) {
+          versionGenerator.augmentWithDependencyVersion(
+            dependencyUrlInfo.data.version,
+          )
+        } else {
+          // because all dependencies are know, if the dependency has no version
+          // it means there is a circular dependency between this file
+          // and it's dependency
+          // in that case we'll use the dependency content
+          versionGenerator.augmentWithContent({
+            content: dependencyUrlInfo.content,
+            contentType: dependencyUrlInfo.contentType,
+            lineBreakNormalization,
+          })
+        }
+      })
+      urlInfo.data.version = versionGenerator.generate()
+
+      urlInfo.data.versionedUrl = injectVersionIntoBuildUrl({
+        buildUrl: urlInfo.url,
+        version: urlInfo.data.version,
+        versioningMethod,
+      })
+    })
+    const versionMappings = {}
+    const usedVersionMappings = []
+    const versioningKitchen = createKitchen({
+      logger,
+      rootDirectoryUrl: buildDirectoryUrl,
+      urlGraph: finalGraph,
+      scenario: "build",
+      sourcemaps,
+      runtimeCompat,
+      plugins: [
+        jsenvPluginInline({
+          fetchInlineUrls: false,
+          analyzeConvertedScripts: true, // to be able to version their urls
+          allowEscapeForVersioning: true,
+        }),
+        {
+          name: "jsenv:versioning",
+          appliesDuring: { build: true },
+          resolveUrl: (reference) => {
+            if (reference.specifier[0] === "#") {
+              reference.external = true
+            }
+            const buildUrl = buildUrls[reference.specifier]
+            if (buildUrl) {
+              return buildUrl
+            }
+            const url = new URL(reference.specifier, reference.parentUrl).href
+            return url
+          },
+          formatUrl: (reference) => {
+            if (reference.isInline) {
+              return null
+            }
+            // 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 (!canUseVersionedUrl(referencedUrlInfo)) {
+              return reference.specifier
+            }
+            // data:* urls and so on
+            if (!referencedUrlInfo.url.startsWith("file:")) {
+              return null
+            }
+            const versionedUrl = referencedUrlInfo.data.versionedUrl
+            if (!versionedUrl) {
+              // happens for sourcemap
+              return `${baseUrl}${urlToRelativeUrl(
+                referencedUrlInfo.url,
+                buildDirectoryUrl,
+              )}`
+            }
+            const versionedSpecifier = `${baseUrl}${urlToRelativeUrl(
+              versionedUrl,
+              buildDirectoryUrl,
+            )}`
+            versionMappings[reference.specifier] = versionedSpecifier
+            buildUrls[versionedSpecifier] = versionedUrl
+
+            const parentUrlInfo = finalGraph.getUrlInfo(reference.parentUrl)
+            if (parentUrlInfo.jsQuote) {
+              // the url is inline inside js quotes
+              usedVersionMappings.push(reference.specifier)
+              return () =>
+                `${parentUrlInfo.jsQuote}+__v__(${JSON.stringify(
+                  reference.specifier,
+                )})+${parentUrlInfo.jsQuote}`
+            }
+            if (
+              reference.type === "js_url_specifier" ||
+              reference.subtype === "import_dynamic"
+            ) {
+              usedVersionMappings.push(reference.specifier)
+              return () => `__v__(${JSON.stringify(reference.specifier)})`
+            }
+            return versionedSpecifier
+          },
+          fetchUrlContent: (versionedUrlInfo) => {
+            if (!versionedUrlInfo.url.startsWith("file:")) {
+              return { external: true }
+            }
+            if (versionedUrlInfo.isInline) {
+              const rawUrlInfo = rawGraph.getUrlInfo(
+                rawUrls[versionedUrlInfo.url],
+              )
+              const finalUrlInfo = finalGraph.getUrlInfo(versionedUrlInfo.url)
+              return {
+                originalContent: rawUrlInfo
+                  ? rawUrlInfo.originalContent
+                  : undefined,
+                sourcemap: finalUrlInfo ? finalUrlInfo.sourcemap : undefined,
+                contentType: versionedUrlInfo.contentType,
+                content: versionedUrlInfo.content,
+              }
+            }
+            return versionedUrlInfo
+          },
+        },
+      ],
+    })
+    await loadUrlGraph({
+      urlGraph: finalGraph,
+      kitchen: versioningKitchen,
+      startLoading: (cookEntryFile) => {
+        postBuildEntryUrls.forEach((postBuildEntryUrl) => {
+          cookEntryFile({
+            trace: `entryPoint`,
+            type: "entry_point",
+            specifier: postBuildEntryUrl,
+          })
+        })
+      },
+    })
+    if (usedVersionMappings.length) {
+      const versionMappingsNeeded = {}
+      usedVersionMappings.forEach((specifier) => {
+        versionMappingsNeeded[specifier] = versionMappings[specifier]
+      })
+      await injectGlobalVersionMapping({
+        finalGraphKitchen,
+        finalGraph,
+        versionMappings: versionMappingsNeeded,
+      })
+    }
+  } catch (e) {
+    versioningTask.fail()
+    throw e
+  }
+  versioningTask.done()
+}
+
 const injectVersionIntoBuildUrl = ({ buildUrl, version, versioningMethod }) => {
   if (versioningMethod === "search_param") {
     return injectQueryParams(buildUrl, {

package/src/build/build_urls_generator.js

@@ -4,6 +4,17 @@ import { memoizeByUrl } from "@jsenv/utils/memoize/memoize_by_url.js"
 
 export const createBuilUrlsGenerator = ({ buildDirectoryUrl }) => {
   const cache = {}
+
+  const getUrlName = (url, urlInfo) => {
+    if (!urlInfo) {
+      return urlToFilename(url)
+    }
+    if (urlInfo.filename) {
+      return urlInfo.filename
+    }
+    return urlToFilename(url)
+  }
+
   const generate = memoizeByUrl((url, { urlInfo, parentUrlInfo }) => {
     const directoryPath = determineDirectoryPath({
       urlInfo,
@@ -16,9 +27,7 @@ export const createBuilUrlsGenerator = ({ buildDirectoryUrl }) => {
     }
     const urlObject = new URL(url)
     let { search, hash } = urlObject
-    let name = urlInfo
-      ? urlInfo.filename || urlToFilename(url)
-      : urlToFilename(url)
+    let name = getUrlName(url, urlInfo)
     const [basename, extension] = splitFileExtension(name)
     let nameCandidate = name
     let integer = 1

package/src/build/start_build_server.js

@@ -45,7 +45,7 @@ export const startBuildServer = async ({
   rootDirectoryUrl,
   buildDirectoryUrl,
   buildCommand,
-  mainBuildFile,
+  mainBuildFileUrl = "/index.html",
   watchedFilePatterns,
   cooldownBetweenFileEvents,
   autorestart,
@@ -145,10 +145,10 @@ export const startBuildServer = async ({
         request.ressource,
         request.origin,
       ).searchParams.has("v")
-      if (mainBuildFile && request.ressource === "/") {
+      if (mainBuildFileUrl && request.ressource === "/") {
         request = {
           ...request,
-          ressource: `/${mainBuildFile}`,
+          ressource: mainBuildFileUrl,
         }
       }
       return fetchFileSystem(

package/src/plugins/bundling/js_module/bundle_js_module.js

@@ -132,9 +132,9 @@ const rollupPluginJsenv = ({
         // there is 3 types of file: "placeholder", "asset", "chunk"
         if (rollupFileInfo.type === "chunk") {
           const jsModuleBundleUrlInfo = {
-            // buildRelativeUrl: rollupFileInfo.fileName,
             data: {
               generatedBy: "rollup",
+              bundleRelativeUrl: rollupFileInfo.fileName,
               usesImport:
                 rollupFileInfo.imports.length > 0 ||
                 rollupFileInfo.dynamicImports.length > 0,
@@ -176,7 +176,18 @@ const rollupPluginJsenv = ({
             fileUrlConverter,
             jsModuleUrlInfos,
           })
-          return insideJs ? `js/${chunkInfo.name}.js` : `${chunkInfo.name}.js`
+          let nameFromUrlInfo
+          if (chunkInfo.facadeModuleId) {
+            const url = fileUrlConverter.asFileUrl(chunkInfo.facadeModuleId)
+            const urlInfo = jsModuleUrlInfos.find(
+              (jsModuleUrlInfo) => jsModuleUrlInfo.url === url,
+            )
+            if (urlInfo) {
+              nameFromUrlInfo = urlInfo.filename
+            }
+          }
+          const name = nameFromUrlInfo || `${chunkInfo.name}.js`
+          return insideJs ? `js/${name}` : `${name}`
         },
         // https://rollupjs.org/guide/en/#outputpaths
         // paths: (id) => {