@jsenv/plugin-bundling 2.8.0 → 2.8.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsenv/plugin-bundling",
-  "version": "2.8.0",
+  "version": "2.8.2",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -20,13 +20,14 @@
   "files": [
     "/src/"
   ],
+  "sideEffects": false,
   "dependencies": {
-    "@jsenv/humanize": "1.3.0",
+    "@jsenv/humanize": "1.3.1",
     "@jsenv/url-meta": "8.5.4",
-    "@jsenv/urls": "2.6.1",
-    "@jsenv/sourcemap": "1.3.0",
-    "lightningcss": "1.29.1",
-    "rollup": "4.31.0"
+    "@jsenv/urls": "2.6.3",
+    "@jsenv/sourcemap": "1.3.2",
+    "lightningcss": "1.29.2",
+    "rollup": "4.35.0"
   },
   "peerDependencies": {
     "@jsenv/core": "*"

package/src/js_module/bundle_js_modules.js

@@ -1,8 +1,9 @@
-import { lookupPackageDirectory } from "@jsenv/filesystem";
+import { lookupPackageDirectory, readPackageAtOrNull } from "@jsenv/filesystem";
 import { createDetailedMessage } from "@jsenv/humanize";
+import { isSpecifierForNodeBuiltin } from "@jsenv/node-esm-resolution/src/node_builtin_specifiers.js";
 import { sourcemapConverter } from "@jsenv/sourcemap";
 import { URL_META } from "@jsenv/url-meta";
-import { isFileSystemPath } from "@jsenv/urls";
+import { fileSystemPathToUrl, isFileSystemPath } from "@jsenv/urls";
 import { readFileSync } from "node:fs";
 import { fileUrlConverter } from "../file_url_converter.js";
 
@@ -37,44 +38,44 @@ export const bundleJsModules = async (
 
   let manualChunks;
   if (chunks) {
-    if (chunks.vendors) {
-      chunks.vendors = {
-        "file:///**/node_modules/": true,
-        ...chunks.vendors,
-      };
-    } else {
-      chunks.vendors = {
-        "file:///**/node_modules/": true,
-      };
-    }
+    let workspaces;
+    let packageName;
     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 packageJSON = readPackageAtOrNull(packageDirectoryUrl);
+      if (packageJSON) {
+        packageName = packageJSON.name;
+        workspaces = packageJSON.workspaces;
+      }
+    }
+    let nodeModuleChunkName = "node_modules";
+    let packagesChunkName = "packages";
+
+    if (packageName) {
+      let packageNameAsFilename = packageName
+        .replaceAll("@", "")
+        .replaceAll("-", "_")
+        .replaceAll("/", "_");
+      nodeModuleChunkName = `${packageNameAsFilename}_node_modules`;
+      packagesChunkName = `${packageNameAsFilename}_packages`;
+    }
+    chunks[nodeModuleChunkName] = {
+      "file:///**/node_modules/": true,
+      ...chunks.vendors,
+    };
+    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;
+      }
+      chunks[packagesChunkName] = {
+        ...workspacePatterns,
+        ...chunks.workspaces,
+      };
     }
 
     const associations = URL_META.resolveAssociations(chunks, rootDirectoryUrl);
@@ -146,6 +147,13 @@ export const bundleJsModules = async (
           ) {
             return;
           }
+          if (
+            warning.code === "EMPTY_BUNDLE" &&
+            (warning.names.join("").endsWith("node_modules") ||
+              warning.names.join("").endsWith("packages"))
+          ) {
+            return;
+          }
           logger.warn(String(warning));
         },
         ...rollupInput,
@@ -181,6 +189,7 @@ export const bundleJsModules = async (
 const rollupPluginJsenv = ({
   // logger,
   rootDirectoryUrl,
+  buildDirectoryUrl,
   graph,
   jsModuleUrlInfos,
   sourcemaps,
@@ -218,16 +227,24 @@ const rollupPluginJsenv = ({
   }
 
   const getOriginalUrl = (rollupFileInfo) => {
-    const { facadeModuleId } = rollupFileInfo;
-    if (facadeModuleId) {
-      return fileUrlConverter.asFileUrl(facadeModuleId);
+    if (
+      // - explicitely emitted by emitChunk
+      // - import.meta.resolve("")
+      rollupFileInfo.isEntry ||
+      // - new URL("", import.meta.url)
+      rollupFileInfo.isImplicitEntry
+    ) {
+      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 new URL(rollupFileInfo.fileName, buildDirectoryUrl).href;
   };
 
   return {
@@ -381,11 +398,19 @@ const rollupPluginJsenv = ({
 
       const jsModuleBundleUrlInfos = {};
       const fileNames = Object.keys(rollupResult);
+      const originalUrlSet = new Set();
       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);
+          const originalUrl = jsModuleInfo.originalUrl;
+          if (originalUrlSet.has(originalUrl)) {
+            throw new Error(
+              `duplicate bundle info, cannot override ${originalUrl}`,
+            );
+          }
+          originalUrlSet.add(originalUrl);
           jsModuleBundleUrlInfos[jsModuleInfo.originalUrl] = jsModuleInfo;
         }
       }
@@ -408,6 +433,15 @@ const rollupPluginJsenv = ({
           return `[name].js`;
         },
         chunkFileNames: (chunkInfo) => {
+          if (chunkInfo.isEntry) {
+            const originalFileUrl = getOriginalUrl(chunkInfo);
+            const jsModuleUrlInfo = jsModuleUrlInfos.find(
+              (candidate) => candidate.url === originalFileUrl,
+            );
+            if (jsModuleUrlInfo && jsModuleUrlInfo.filenameHint) {
+              return jsModuleUrlInfo.filenameHint;
+            }
+          }
           return `${chunkInfo.name}.js`;
         },
       });
@@ -460,7 +494,7 @@ const rollupPluginJsenv = ({
         // happen when excluded by referenceAnalysis.include
         return { id: url, external: true };
       }
-      if (urlInfo.url.startsWith("ignore:")) {
+      if (url.startsWith("ignore:")) {
         return { id: url, external: true };
       }
       const filePath = fileUrlConverter.asFilePath(url);
@@ -491,8 +525,83 @@ const applyRollupPlugins = async ({
     const rollupModule = await import("rollup");
     rollup = rollupModule.rollup;
   }
+
+  const packageSideEffectsCacheMap = new Map();
+  const readClosestPackageJsonSideEffects = (url) => {
+    const packageDirectoryUrl = lookupPackageDirectory(url);
+    if (!packageDirectoryUrl) {
+      return undefined;
+    }
+    const fromCache = packageSideEffectsCacheMap.get(packageDirectoryUrl);
+    if (fromCache) {
+      return fromCache.value;
+    }
+    try {
+      const packageFileContent = readFileSync(
+        new URL("./package.json", packageDirectoryUrl),
+        "utf8",
+      );
+      const packageJSON = JSON.parse(packageFileContent);
+      const value = packageJSON.sideEffects;
+      if (Array.isArray(value)) {
+        const sideEffectPatterns = {};
+        for (const v of value) {
+          sideEffectPatterns[v] = true;
+        }
+        const associations = URL_META.resolveAssociations(
+          { sideEffects: sideEffectPatterns },
+          packageDirectoryUrl,
+        );
+        const isMatching = (url) => {
+          const meta = URL_META.applyAssociations({ url, associations });
+          return meta.sideEffects || false;
+        };
+        packageSideEffectsCacheMap.set(packageDirectoryUrl, {
+          value: isMatching,
+        });
+      } else {
+        packageSideEffectsCacheMap.set(packageDirectoryUrl, { value });
+      }
+      return value;
+    } catch {
+      packageSideEffectsCacheMap.set(packageDirectoryUrl, { value: undefined });
+      return undefined;
+    }
+  };
+
   const rollupReturnValue = await rollup({
     ...rollupInput,
+    treeshake: {
+      ...rollupInput.treeshake,
+      moduleSideEffects: (id, external) => {
+        if (id.startsWith("ignore:node:")) {
+          return false;
+        }
+        if (isSpecifierForNodeBuiltin(id)) {
+          return false;
+        }
+        if (id.startsWith("ignore:")) {
+          return null;
+        }
+        const url = id.startsWith("file:") ? id : fileSystemPathToUrl(id);
+        const closestPackageJsonSideEffects =
+          readClosestPackageJsonSideEffects(url);
+        if (closestPackageJsonSideEffects !== undefined) {
+          if (typeof closestPackageJsonSideEffects === "function") {
+            return closestPackageJsonSideEffects(url);
+          }
+          return closestPackageJsonSideEffects;
+        }
+        const moduleSideEffects = rollupInput.treeshake?.moduleSideEffects;
+        if (moduleSideEffects) {
+          if (typeof moduleSideEffects === "function") {
+            return moduleSideEffects(id, external);
+          }
+          return moduleSideEffects;
+        }
+        return null;
+      },
+    },
     plugins: rollupPlugins,
   });
   const rollupOutputArray = await rollupReturnValue.generate(rollupOutput);