@jsenv/plugin-bundling 2.4.2 → 2.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsenv/plugin-bundling",
-  "version": "2.4.2",
+  "version": "2.5.0",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -26,11 +26,11 @@
   "dependencies": {
     "@jsenv/log": "3.4.0",
     "@jsenv/url-meta": "8.1.0",
-    "@jsenv/urls": "2.1.0",
-    "@jsenv/sourcemap": "1.1.0",
+    "@jsenv/urls": "2.2.0",
+    "@jsenv/sourcemap": "1.2.0",
     "acorn-import-assertions": "1.9.0",
     "lightningcss": "1.21.5",
-    "rollup": "3.26.3"
+    "rollup": "3.27.0"
   },
   "peerDependencies": {
     "@jsenv/core": "*"

package/src/js_module/bundle_js_modules.js

@@ -24,7 +24,6 @@ export const bundleJsModules = async (
     signal,
     logger,
     rootDirectoryUrl,
-    assetsDirectory,
     runtimeCompat,
     sourcemaps,
     isSupportedOnCurrentClients,
@@ -70,7 +69,6 @@ export const bundleJsModules = async (
           logger,
           rootDirectoryUrl,
           buildDirectoryUrl,
-          assetsDirectory,
           graph,
           jsModuleUrlInfos,
 
@@ -128,8 +126,6 @@ export const bundleJsModules = async (
 const rollupPluginJsenv = ({
   // logger,
   rootDirectoryUrl,
-  buildDirectoryUrl,
-  assetsDirectory,
   graph,
   jsModuleUrlInfos,
   sourcemaps,
@@ -145,7 +141,7 @@ const rollupPluginJsenv = ({
     throw new Error("not implemented");
   };
   const format = jsModuleUrlInfos.some((jsModuleUrlInfo) =>
-    jsModuleUrlInfo.filename.endsWith(".cjs"),
+    jsModuleUrlInfo.filenameHint.endsWith(".cjs"),
   )
     ? "cjs"
     : "esm";
@@ -165,7 +161,19 @@ const rollupPluginJsenv = ({
       return URL_META.applyAssociations({ url, associations }).bundle;
     };
   }
-  const urlImporters = {};
+
+  const getOriginalUrl = (rollupFileInfo) => {
+    const { facadeModuleId } = rollupFileInfo;
+    if (facadeModuleId) {
+      return fileUrlConverter.asFileUrl(facadeModuleId);
+    }
+    if (rollupFileInfo.isDynamicEntry) {
+      const { moduleIds } = rollupFileInfo;
+      const lastModuleId = moduleIds[moduleIds.length - 1];
+      return fileUrlConverter.asFileUrl(lastModuleId);
+    }
+    return new URL(rollupFileInfo.fileName, rootDirectoryUrl).href;
+  };
 
   return {
     name: "jsenv",
@@ -216,49 +224,90 @@ const rollupPluginJsenv = ({
     async generateBundle(outputOptions, rollupResult) {
       _rollupEmitFile = (...args) => this.emitFile(...args);
 
-      const jsModuleBundleUrlInfos = {};
-      Object.keys(rollupResult).forEach((fileName) => {
-        const rollupFileInfo = rollupResult[fileName];
-        // there is 3 types of file: "placeholder", "asset", "chunk"
-        if (rollupFileInfo.type === "chunk") {
-          const sourceUrls = Object.keys(rollupFileInfo.modules).map((id) =>
-            fileUrlConverter.asFileUrl(id),
-          );
+      const createBundledFileInfo = (rollupFileInfo) => {
+        const originalUrl = getOriginalUrl(rollupFileInfo);
+        const sourceUrls = Object.keys(rollupFileInfo.modules).map((id) =>
+          fileUrlConverter.asFileUrl(id),
+        );
 
-          let url;
-          let originalUrl;
-          if (rollupFileInfo.facadeModuleId) {
-            url = fileUrlConverter.asFileUrl(rollupFileInfo.facadeModuleId);
-            originalUrl = url;
-          } else {
-            url = new URL(rollupFileInfo.fileName, buildDirectoryUrl).href;
-            if (rollupFileInfo.isDynamicEntry) {
-              originalUrl = sourceUrls[sourceUrls.length - 1];
-            } else {
-              originalUrl = url;
+        const specifierToUrlMap = new Map();
+        const { imports, dynamicImports } = rollupFileInfo;
+        for (const importFileName of imports) {
+          if (!importFileName.startsWith("file:")) {
+            const importRollupFileInfo = rollupResult[importFileName];
+            if (!importRollupFileInfo) {
+              // happens for external import, like "ignore:" or anything marked as external
+              specifierToUrlMap.set(importFileName, importFileName);
+              continue;
             }
+            const importUrl = getOriginalUrl(importRollupFileInfo);
+            const rollupSpecifier = `./${importRollupFileInfo.fileName}`;
+            specifierToUrlMap.set(rollupSpecifier, importUrl);
           }
+        }
+        for (const dynamicImportFileName of dynamicImports) {
+          if (!dynamicImportFileName.startsWith("file:")) {
+            const dynamicImportRollupFileInfo =
+              rollupResult[dynamicImportFileName];
+            if (!dynamicImportRollupFileInfo) {
+              // happens for external import, like "ignore:" or anything marked as external
+              specifierToUrlMap.set(
+                dynamicImportFileName,
+                dynamicImportFileName,
+              );
+              continue;
+            }
+            const dynamicImportUrl = getOriginalUrl(
+              dynamicImportRollupFileInfo,
+            );
+            const rollupSpecifier = `./${dynamicImportRollupFileInfo.fileName}`;
+            specifierToUrlMap.set(rollupSpecifier, dynamicImportUrl);
+          }
+        }
+
+        return {
+          originalUrl,
+          type: format === "esm" ? "js_module" : "common_js",
+          data: {
+            bundlerName: "rollup",
+            bundleRelativeUrl: rollupFileInfo.fileName,
+            usesImport:
+              rollupFileInfo.imports.length > 0 ||
+              rollupFileInfo.dynamicImports.length > 0,
+            isDynamicEntry: rollupFileInfo.isDynamicEntry,
+          },
+          sourceUrls,
+          contentType: "text/javascript",
+          content: rollupFileInfo.code,
+          sourcemap: rollupFileInfo.map,
+          // rollup is generating things like "./file.js"
+          // that must be converted back to urls for jsenv
+          remapReference:
+            specifierToUrlMap.size > 0
+              ? (reference) => {
+                  // rollup generate specifiers only for static and dynamic imports
+                  // other references (like new URL()) are ignored
+                  // there is no need to remap them back
+                  if (reference.type === "js_import") {
+                    return specifierToUrlMap.get(reference.specifier);
+                  }
+                  return reference.specifier;
+                }
+              : undefined,
+        };
+      };
 
-          const jsModuleBundleUrlInfo = {
-            url,
-            originalUrl,
-            type: format === "esm" ? "js_module" : "common_js",
-            data: {
-              bundlerName: "rollup",
-              bundleRelativeUrl: rollupFileInfo.fileName,
-              usesImport:
-                rollupFileInfo.imports.length > 0 ||
-                rollupFileInfo.dynamicImports.length > 0,
-              isDynamicEntry: rollupFileInfo.isDynamicEntry,
-            },
-            sourceUrls,
-            contentType: "text/javascript",
-            content: rollupFileInfo.code,
-            sourcemap: rollupFileInfo.map,
-          };
-          jsModuleBundleUrlInfos[url] = jsModuleBundleUrlInfo;
+      const jsModuleBundleUrlInfos = {};
+      const fileNames = Object.keys(rollupResult);
+      for (const fileName of fileNames) {
+        const rollupFileInfo = rollupResult[fileName];
+        // there is 3 types of file: "placeholder", "asset", "chunk"
+        if (rollupFileInfo.type === "chunk") {
+          const jsModuleInfo = createBundledFileInfo(rollupFileInfo);
+          jsModuleBundleUrlInfos[jsModuleInfo.originalUrl] = jsModuleInfo;
         }
-      });
+      }
+
       resultRef.current = {
         jsModuleBundleUrlInfos,
       };
@@ -267,38 +316,18 @@ const rollupPluginJsenv = ({
       // const sourcemapFile = buildDirectoryUrl
       Object.assign(outputOptions, {
         format,
-        dir: fileUrlConverter.asFilePath(buildDirectoryUrl),
+        dir: fileUrlConverter.asFilePath(rootDirectoryUrl),
         sourcemap: sourcemaps === "file" || sourcemaps === "inline",
         // sourcemapFile,
         sourcemapPathTransform: (relativePath) => {
-          return new URL(relativePath, buildDirectoryUrl).href;
+          return new URL(relativePath, rootDirectoryUrl).href;
         },
         entryFileNames: () => {
           return `[name].js`;
         },
         chunkFileNames: (chunkInfo) => {
-          const insideJs = willBeInsideJsDirectory({
-            chunkInfo,
-            fileUrlConverter,
-            jsModuleUrlInfos,
-          });
-          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 ? `${assetsDirectory}js/${name}` : `${name}`;
+          return `${chunkInfo.name}.js`;
         },
-        // https://rollupjs.org/guide/en/#outputpaths
-        // paths: (id) => {
-        //   return id
-        // },
       });
     },
     // https://rollupjs.org/guide/en/#resolvedynamicimport
@@ -339,10 +368,6 @@ const rollupPluginJsenv = ({
       } else {
         url = new URL(specifier, importer).href;
       }
-      const existingImporter = urlImporters[url];
-      if (!existingImporter) {
-        urlImporters[url] = importer;
-      }
       if (!url.startsWith("file:")) {
         return { id: url, external: true };
       }
@@ -397,31 +422,3 @@ const applyRollupPlugins = async ({
   const rollupOutputArray = await rollupReturnValue.generate(rollupOutput);
   return rollupOutputArray;
 };
-
-const willBeInsideJsDirectory = ({
-  chunkInfo,
-  fileUrlConverter,
-  jsModuleUrlInfos,
-}) => {
-  // if the chunk is generated dynamically by rollup
-  // for an entry point jsenv will put that file inside js/ directory
-  // if it's generated dynamically for a file already in js/ directory
-  // both will be inside the js/ directory
-  if (!chunkInfo.facadeModuleId) {
-    // generated by rollup
-    return true;
-  }
-  const url = fileUrlConverter.asFileUrl(chunkInfo.facadeModuleId);
-  const jsModuleUrlInfo = jsModuleUrlInfos.find(
-    (jsModuleUrlInfo) => jsModuleUrlInfo.url === url,
-  );
-  if (!jsModuleUrlInfo) {
-    // generated by rollup
-    return true;
-  }
-  if (!jsModuleUrlInfo.isEntryPoint) {
-    // not an entry point, jsenv will put it inside js/ directory
-    return true;
-  }
-  return false;
-};