@jsenv/plugin-bundling 2.7.24 → 2.8.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsenv/plugin-bundling",
-  "version": "2.7.24",
+  "version": "2.8.0",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -21,10 +21,10 @@
     "/src/"
   ],
   "dependencies": {
-    "@jsenv/humanize": "1.2.8",
-    "@jsenv/url-meta": "8.5.2",
-    "@jsenv/urls": "2.6.0",
-    "@jsenv/sourcemap": "1.2.30",
+    "@jsenv/humanize": "1.3.0",
+    "@jsenv/url-meta": "8.5.4",
+    "@jsenv/urls": "2.6.1",
+    "@jsenv/sourcemap": "1.3.0",
     "lightningcss": "1.29.1",
     "rollup": "4.31.0"
   },

package/src/js_module/bundle_js_modules.js

@@ -1,8 +1,9 @@
+import { lookupPackageDirectory } from "@jsenv/filesystem";
 import { createDetailedMessage } from "@jsenv/humanize";
 import { sourcemapConverter } from "@jsenv/sourcemap";
 import { URL_META } from "@jsenv/url-meta";
 import { isFileSystemPath } from "@jsenv/urls";
-
+import { readFileSync } from "node:fs";
 import { fileUrlConverter } from "../file_url_converter.js";
 
 export const bundleJsModules = async (
@@ -35,15 +36,59 @@ export const bundleJsModules = async (
   }
 
   let manualChunks;
-  if (Object.keys(chunks).length) {
+  if (chunks) {
+    if (chunks.vendors) {
+      chunks.vendors = {
+        "file:///**/node_modules/": true,
+        ...chunks.vendors,
+      };
+    } else {
+      chunks.vendors = {
+        "file:///**/node_modules/": true,
+      };
+    }
+    const packageDirectoryUrl = lookupPackageDirectory(rootDirectoryUrl);
+    if (packageDirectoryUrl) {
+      try {
+        const packageFileContent = readFileSync(
+          new URL("package.json", packageDirectoryUrl),
+          "utf8",
+        );
+        const packageJSON = JSON.parse(packageFileContent);
+        const workspaces = packageJSON.workspaces;
+        if (workspaces) {
+          const workspacePatterns = {};
+          for (const workspace of workspaces) {
+            const workspacePattern = new URL(
+              workspace.endsWith("/*") ? workspace.slice(0, -1) : workspace,
+              packageDirectoryUrl,
+            ).href;
+            workspacePatterns[workspacePattern] = true;
+          }
+          if (chunks.workspaces) {
+            chunks.workspaces = {
+              ...workspacePatterns,
+              ...chunks.workspaces,
+            };
+          } else {
+            chunks.workspaces = workspacePatterns;
+          }
+        }
+      } catch {}
+    }
+
     const associations = URL_META.resolveAssociations(chunks, rootDirectoryUrl);
-    manualChunks = (id) => {
+    manualChunks = (id, manualChunksApi) => {
       if (rollupOutput.manualChunks) {
-        const manualChunkName = rollupOutput.manualChunks(id);
+        const manualChunkName = rollupOutput.manualChunks(id, manualChunksApi);
         if (manualChunkName) {
           return manualChunkName;
         }
       }
+      const moduleInfo = manualChunksApi.getModuleInfo(id);
+      if (moduleInfo.isEntry || moduleInfo.dynamicImporters.length) {
+        return null;
+      }
       const url = fileUrlConverter.asFileUrl(id);
       const urlObject = new URL(url);
       urlObject.search = "";
@@ -52,8 +97,12 @@ export const bundleJsModules = async (
         url: urlWithoutSearch,
         associations,
       });
-      const chunkName = Object.keys(meta).find((key) => meta[key]);
-      return chunkName || null;
+      for (const chunkNameCandidate of Object.keys(meta)) {
+        if (meta[chunkNameCandidate]) {
+          return chunkNameCandidate;
+        }
+      }
+      return undefined;
     };
   }
 
@@ -91,6 +140,12 @@ export const bundleJsModules = async (
             // ideally we should disable only for jsenv files
             return;
           }
+          if (
+            warning.code === "INVALID_ANNOTATION" &&
+            warning.loc.file.includes("/node_modules/")
+          ) {
+            return;
+          }
           logger.warn(String(warning));
         },
         ...rollupInput,
@@ -180,13 +235,13 @@ const rollupPluginJsenv = ({
     async buildStart() {
       _rollupEmitFile = (...args) => this.emitFile(...args);
       let previousNonEntryPointModuleId;
-      jsModuleUrlInfos.forEach((jsModuleUrlInfo) => {
+      for (const jsModuleUrlInfo of jsModuleUrlInfos) {
         const id = jsModuleUrlInfo.url;
         if (jsModuleUrlInfo.isEntryPoint) {
           emitChunk({
             id,
           });
-          return;
+          continue;
         }
         let preserveSignature;
         if (strictExports) {
@@ -218,8 +273,10 @@ const rollupPluginJsenv = ({
             : null,
           preserveSignature,
         });
-        previousNonEntryPointModuleId = id;
-      });
+        if (jsModuleUrlInfo.originalUrl.startsWith("file:")) {
+          previousNonEntryPointModuleId = id;
+        }
+      }
     },
     async generateBundle(outputOptions, rollupResult) {
       _rollupEmitFile = (...args) => this.emitFile(...args);
@@ -291,16 +348,32 @@ const rollupPluginJsenv = ({
           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" &&
-                    reference.subtype !== "import_meta_resolve"
+                    preserveDynamicImport &&
+                    reference.subtype === "dynamic_import"
+                  ) {
+                    // when dynamic import are preserved, no need to remap them
+                    return reference.specifier;
+                  }
+                  if (
+                    reference.type !== "js_import" ||
+                    reference.subtype === "import_meta_resolve"
                   ) {
-                    return specifierToUrlMap.get(reference.specifier);
+                    // rollup generate specifiers only for static and dynamic imports
+                    // other references (like new URL()) are ignored
+                    // there is no need to remap them back
+                    return reference.specifier;
                   }
-                  return reference.specifier;
+                  const specifierBeforeRollup = specifierToUrlMap.get(
+                    reference.specifier,
+                  );
+                  if (!specifierBeforeRollup) {
+                    console.warn(
+                      `cannot remap "${reference.specifier}" back to specifier before rollup, this is unexpected.`,
+                    );
+                    return reference.specifier;
+                  }
+                  return specifierBeforeRollup;
                 }
               : undefined,
         };
@@ -341,31 +414,30 @@ const rollupPluginJsenv = ({
     },
     // https://rollupjs.org/guide/en/#resolvedynamicimport
     resolveDynamicImport: (specifier, importer) => {
-      if (preserveDynamicImport) {
-        let urlObject;
-        if (specifier[0] === "/") {
-          urlObject = new URL(specifier.slice(1), rootDirectoryUrl);
-        } else {
-          if (isFileSystemPath(importer)) {
-            importer = fileUrlConverter.asFileUrl(importer);
-          }
-          urlObject = new URL(specifier, importer);
-        }
-        const searchParamsToAdd =
-          augmentDynamicImportUrlSearchParams(urlObject);
-        if (searchParamsToAdd) {
-          Object.keys(searchParamsToAdd).forEach((key) => {
-            const value = searchParamsToAdd[key];
-            if (value === undefined) {
-              urlObject.searchParams.delete(key);
-            } else {
-              urlObject.searchParams.set(key, value);
-            }
-          });
+      if (!preserveDynamicImport) {
+        return null;
+      }
+      let urlObject;
+      if (specifier[0] === "/") {
+        urlObject = new URL(specifier.slice(1), rootDirectoryUrl);
+      } else {
+        if (isFileSystemPath(importer)) {
+          importer = fileUrlConverter.asFileUrl(importer);
         }
-        return { external: true, id: urlObject.href };
+        urlObject = new URL(specifier, importer);
+      }
+      const searchParamsToAdd = augmentDynamicImportUrlSearchParams(urlObject);
+      if (searchParamsToAdd) {
+        Object.keys(searchParamsToAdd).forEach((key) => {
+          const value = searchParamsToAdd[key];
+          if (value === undefined) {
+            urlObject.searchParams.delete(key);
+          } else {
+            urlObject.searchParams.set(key, value);
+          }
+        });
       }
-      return null;
+      return { external: true, id: urlObject.href };
     },
     resolveId: (specifier, importer = rootDirectoryUrl) => {
       if (isFileSystemPath(importer)) {