rollup-plugin-iife-split 0.0.3 → 0.0.5

package/README.md

@@ -105,7 +105,8 @@ MyLib.Admin = (function (exports, shared) {
 | `secondaryProps` | `Record<string, string>` | Yes | Maps secondary entry names to their property name on the primary global. Example: `{ admin: 'Admin' }` → `window.MyLib.Admin` |
 | `sharedProp` | `string` | Yes | Property name on the global where shared exports are attached. Example: `'Shared'` → `window.MyLib.Shared` |
 | `unshared` | `(id: string) => boolean` | No | Function that returns `true` for modules that should be duplicated instead of shared. See [Excluding Modules from Sharing](#excluding-modules-from-sharing). |
-| `debug` | `boolean` | No | Enable debug logging to see intermediate transformation steps. |
+| `debugDir` | `string` | No | Directory to write intermediate files for debugging. If set, writes ESM files before IIFE conversion to help diagnose issues. Example: `'./debug-output'` |
+| `skipRequireGlobals` | `boolean` | No | If `true`, don't error when an external module is missing a `globals` mapping. Instead, let Rollup auto-generate a sanitized global name. Default: `false` |
 
 ## Excluding Modules from Sharing
 
@@ -135,6 +136,27 @@ With this configuration:
 - They are **not** merged into the primary/shared chunk
 - Each satellite entry is self-contained with its own copy of the locale data
 
+## External Dependencies
+
+When using external dependencies with IIFE output, you must specify `globals` in your Rollup output options to map module IDs to global variable names:
+
+```js
+export default {
+  input: { /* ... */ },
+  external: ['lodash', '@fullcalendar/core'],
+  plugins: [iifeSplit({ /* ... */ })],
+  output: {
+    dir: 'dist',
+    globals: {
+      'lodash': '_',
+      '@fullcalendar/core': 'FullCalendar'
+    }
+  }
+};
+```
+
+By default, the plugin will error if an external is missing from `globals`—this prevents invalid JavaScript output. If you want Rollup to auto-generate global names instead, set `skipRequireGlobals: true`.
+
 ## How It Works
 
 1. **Build phase**: Rollup builds with ESM format, using `manualChunks` to consolidate all shared modules into one chunk

package/dist/index.d.ts

@@ -44,6 +44,12 @@ interface IifeSplitOptions {
      * Example: './debug-output'
      */
     debugDir?: string;
+    /**
+     * If true, don't error when an external module is missing a global mapping.
+     * Instead, let Rollup generate a sanitized global name automatically.
+     * Default: false (errors on missing globals)
+     */
+    skipRequireGlobals?: boolean;
 }
 
 declare function iifeSplit(options: IifeSplitOptions): Plugin;

package/dist/index.js

@@ -158,9 +158,12 @@ function destructureSharedParameter(code, mappings, parse) {
   return ms.toString();
 }
 async function convertToIife(options) {
-  const { code, globalName, globals, sharedGlobalPath, sharedChunkFileName, parse } = options;
+  const { code, globalName, globals, sharedGlobalPath, sharedChunkFileName, parse, skipRequireGlobals } = options;
   const importMappings = sharedGlobalPath ? extractSharedImportMappings(code, parse) : [];
   const rollupGlobals = (id) => {
+    if (globalName && (id === globalName || globalName.startsWith(id + "."))) {
+      return id;
+    }
     if (sharedGlobalPath) {
       if (id.includes(SHARED_CHUNK_NAME)) {
         return sharedGlobalPath;
@@ -172,7 +175,16 @@ async function convertToIife(options) {
         }
       }
     }
-    return globals[id] ?? id;
+    const global = globals[id];
+    if (global === void 0) {
+      if (skipRequireGlobals) {
+        return void 0;
+      }
+      throw new Error(
+        `[iife-split] Missing global for external "${id}". IIFE builds require all externals to have a global mapping. Add it to output.globals in your Rollup config, e.g.: globals: { '${id}': 'SomeGlobalName' }`
+      );
+    }
+    return global;
   };
   const bundle = await rollup({
     input: VIRTUAL_ENTRY,
@@ -184,6 +196,7 @@ async function convertToIife(options) {
   const { output } = await bundle.generate({
     format: "iife",
     name: globalName,
+    // Cast needed: Rollup's types say string, but it handles undefined by using default name generation
     globals: rollupGlobals,
     exports: "named"
   });
@@ -242,6 +255,22 @@ function extractTopLevelDeclarations(code, parse) {
   }
   return declarations;
 }
+function extractExternalImportBindings(code, parse) {
+  const ast = parse(code);
+  const bindings = /* @__PURE__ */ new Set();
+  for (const node of ast.body) {
+    if (node.type === "ImportDeclaration") {
+      const importNode = node;
+      const source = importNode.source.value;
+      if (typeof source === "string" && !source.startsWith(".") && !source.startsWith("/")) {
+        for (const spec of importNode.specifiers) {
+          bindings.add(spec.local.name);
+        }
+      }
+    }
+  }
+  return bindings;
+}
 function renameIdentifiers(code, renameMap, parse) {
   if (renameMap.size === 0) return code;
   const ast = parse(code);
@@ -321,6 +350,117 @@ function stripExports(code, parse) {
   });
   return s.toString();
 }
+function extractExternalImports(code, parse) {
+  const ast = parse(code);
+  const imports = [];
+  walk2(ast, {
+    enter(node) {
+      if (node.type === "ImportDeclaration") {
+        const importNode = node;
+        const source = importNode.source.value;
+        if (typeof source === "string" && !source.startsWith(".") && !source.startsWith("/")) {
+          const specifiers = [];
+          for (const spec of importNode.specifiers) {
+            if (spec.type === "ImportDefaultSpecifier") {
+              specifiers.push({ type: "default", localName: spec.local.name });
+            } else if (spec.type === "ImportNamespaceSpecifier") {
+              specifiers.push({ type: "namespace", localName: spec.local.name });
+            } else if (spec.type === "ImportSpecifier" && spec.imported) {
+              specifiers.push({
+                type: "named",
+                localName: spec.local.name,
+                importedName: spec.imported.name
+              });
+            }
+          }
+          imports.push({
+            source,
+            specifiers,
+            fullStatement: code.slice(importNode.start, importNode.end),
+            start: importNode.start,
+            end: importNode.end
+          });
+        }
+      }
+    }
+  });
+  return imports;
+}
+function removeOrRewriteDuplicateExternalImports(sharedCode, primaryImports, parse) {
+  const sharedImports = extractExternalImports(sharedCode, parse);
+  const s = new MagicString2(sharedCode);
+  const renameMap = /* @__PURE__ */ new Map();
+  const primaryBySource = /* @__PURE__ */ new Map();
+  for (const imp of primaryImports) {
+    const existing = primaryBySource.get(imp.source) || [];
+    existing.push(imp);
+    primaryBySource.set(imp.source, existing);
+  }
+  for (const sharedImp of sharedImports) {
+    const primaryImpsForSource = primaryBySource.get(sharedImp.source);
+    if (!primaryImpsForSource) continue;
+    const specifiersToKeep = [];
+    for (const sharedSpec of sharedImp.specifiers) {
+      let foundInPrimary = false;
+      for (const primaryImp of primaryImpsForSource) {
+        for (const primarySpec of primaryImp.specifiers) {
+          if (sharedSpec.type === primarySpec.type) {
+            if (sharedSpec.type === "named" && primarySpec.type === "named") {
+              if (sharedSpec.importedName === primarySpec.importedName) {
+                foundInPrimary = true;
+                if (sharedSpec.localName !== primarySpec.localName) {
+                  renameMap.set(sharedSpec.localName, primarySpec.localName);
+                }
+                break;
+              }
+            } else if (sharedSpec.type === "default" && primarySpec.type === "default") {
+              foundInPrimary = true;
+              if (sharedSpec.localName !== primarySpec.localName) {
+                renameMap.set(sharedSpec.localName, primarySpec.localName);
+              }
+              break;
+            } else if (sharedSpec.type === "namespace" && primarySpec.type === "namespace") {
+              foundInPrimary = true;
+              if (sharedSpec.localName !== primarySpec.localName) {
+                renameMap.set(sharedSpec.localName, primarySpec.localName);
+              }
+              break;
+            }
+          }
+        }
+        if (foundInPrimary) break;
+      }
+      if (!foundInPrimary) {
+        specifiersToKeep.push(sharedSpec);
+      }
+    }
+    if (specifiersToKeep.length === 0) {
+      s.remove(sharedImp.start, sharedImp.end);
+    } else if (specifiersToKeep.length < sharedImp.specifiers.length) {
+      const parts = [];
+      const namedParts = [];
+      for (const spec of specifiersToKeep) {
+        if (spec.type === "default") {
+          parts.unshift(spec.localName);
+        } else if (spec.type === "namespace") {
+          parts.push(`* as ${spec.localName}`);
+        } else if (spec.type === "named") {
+          if (spec.importedName === spec.localName) {
+            namedParts.push(spec.localName);
+          } else {
+            namedParts.push(`${spec.importedName} as ${spec.localName}`);
+          }
+        }
+      }
+      if (namedParts.length > 0) {
+        parts.push(`{ ${namedParts.join(", ")} }`);
+      }
+      const newImport = `import ${parts.join(", ")} from '${sharedImp.source}';`;
+      s.overwrite(sharedImp.start, sharedImp.end, newImport);
+    }
+  }
+  return { code: s.toString(), renameMap };
+}
 function isSharedChunkSource(source, sharedChunkFileName) {
   return source.includes(SHARED_CHUNK_NAME) || source.includes(sharedChunkFileName.replace(/\.js$/, ""));
 }
@@ -546,56 +686,63 @@ ${entryWithoutImports.trim()}`;
 }
 function mergeSharedIntoPrimary(primaryChunk, sharedChunk, sharedProperty, neededExports, parse) {
   const { exports: sharedExports, hasDefault } = extractExports(sharedChunk.code, parse);
+  const sharedExternalImports = extractExternalImports(sharedChunk.code, parse);
+  const { code: primaryCodeDeduped, renameMap: externalRenameMap } = removeOrRewriteDuplicateExternalImports(primaryChunk.code, sharedExternalImports, parse);
   const sharedDeclarations = extractTopLevelDeclarations(sharedChunk.code, parse);
-  const primaryDeclarations = extractTopLevelDeclarations(primaryChunk.code, parse);
-  const renameMap = /* @__PURE__ */ new Map();
+  const primaryDeclarations = extractTopLevelDeclarations(primaryCodeDeduped, parse);
+  const primaryExternalBindings = extractExternalImportBindings(primaryCodeDeduped, parse);
+  const collisionRenameMap = /* @__PURE__ */ new Map();
   for (const name of sharedDeclarations) {
-    if (primaryDeclarations.has(name)) {
-      renameMap.set(name, `__shared$${name}`);
+    if (primaryDeclarations.has(name) || primaryExternalBindings.has(name)) {
+      collisionRenameMap.set(name, `__shared$${name}`);
     }
   }
   let processedSharedCode = sharedChunk.code;
-  if (renameMap.size > 0) {
-    processedSharedCode = renameIdentifiers(processedSharedCode, renameMap, parse);
+  if (collisionRenameMap.size > 0) {
+    processedSharedCode = renameIdentifiers(processedSharedCode, collisionRenameMap, parse);
   }
   const strippedSharedCode = stripExports(processedSharedCode, parse);
   const sharedExportToLocal = /* @__PURE__ */ new Map();
   for (const exp of sharedExports) {
-    const renamedLocal = renameMap.get(exp.localName) ?? exp.localName;
+    const renamedLocal = collisionRenameMap.get(exp.localName) ?? exp.localName;
     sharedExportToLocal.set(exp.exportedName, renamedLocal);
   }
   if (hasDefault) {
     sharedExportToLocal.set("default", "__shared_default__");
   }
-  const primaryWithoutSharedImports = removeSharedImportsAndRewriteRefs(
-    primaryChunk.code,
+  let primaryWithoutSharedImports = removeSharedImportsAndRewriteRefs(
+    primaryCodeDeduped,
     sharedChunk.fileName,
     sharedExportToLocal,
     parse
   );
+  if (externalRenameMap.size > 0) {
+    primaryWithoutSharedImports = renameIdentifiers(primaryWithoutSharedImports, externalRenameMap, parse);
+  }
   const sharedExportEntries = [
     ...sharedExports.filter((exp) => neededExports.has(exp.exportedName)).map((exp) => {
-      const renamedLocal = renameMap.get(exp.localName) ?? exp.localName;
+      const renamedLocal = collisionRenameMap.get(exp.localName) ?? exp.localName;
       return exp.exportedName === renamedLocal ? renamedLocal : `${exp.exportedName}: ${renamedLocal}`;
     }),
     ...hasDefault && neededExports.has("default") ? ["default: __shared_default__"] : []
   ];
-  const sharedExportObject = `const ${sharedProperty} = { ${sharedExportEntries.join(", ")} };`;
-  primaryChunk.code = [
+  const parts = [
     strippedSharedCode.trim(),
     "",
-    primaryWithoutSharedImports.trim(),
-    "",
-    sharedExportObject,
-    `export { ${sharedProperty} };`
-  ].join("\n");
+    primaryWithoutSharedImports.trim()
+  ];
+  if (sharedExportEntries.length > 0) {
+    const sharedExportObject = `const ${sharedProperty} = { ${sharedExportEntries.join(", ")} };`;
+    parts.push("", sharedExportObject, `export { ${sharedProperty} };`);
+  }
+  primaryChunk.code = parts.join("\n");
 }
 
 // src/index.ts
 import { writeFileSync, mkdirSync } from "fs";
 import { join } from "path";
 function iifeSplit(options) {
-  const { primary, primaryGlobal, secondaryProps, sharedProp, unshared, debugDir } = options;
+  const { primary, primaryGlobal, secondaryProps, sharedProp, unshared, debugDir, skipRequireGlobals } = options;
   const sanitizeName = (name) => name.replace(/[/\\]/g, "-");
   const writeDebugFile = (filename, content) => {
     if (!debugDir) return;
@@ -607,6 +754,8 @@ function iifeSplit(options) {
     }
   };
   let outputGlobals = {};
+  let outputBanner;
+  let outputFooter;
   const manualChunks = (id, { getModuleInfo }) => {
     const moduleInfo = getModuleInfo(id);
     if (!moduleInfo) return void 0;
@@ -622,13 +771,18 @@ function iifeSplit(options) {
   };
   return {
     name: "iife-split",
-    // Hook into outputOptions to capture globals and configure chunking
+    // Hook into outputOptions to capture globals/banner/footer and configure chunking
     outputOptions(outputOptions) {
       outputGlobals = outputOptions.globals ?? {};
+      outputBanner = outputOptions.banner;
+      outputFooter = outputOptions.footer;
       return {
         ...outputOptions,
         format: "es",
-        manualChunks
+        manualChunks,
+        // Remove banner/footer so Rollup doesn't embed them in ESM
+        banner: void 0,
+        footer: void 0
       };
     },
     // Main transformation hook - convert ESM chunks to IIFE
@@ -691,7 +845,8 @@ function iifeSplit(options) {
           sharedGlobalPath: null,
           // Primary doesn't need to import shared
           sharedChunkFileName: null,
-          parse
+          parse,
+          skipRequireGlobals
         }).then((code) => {
           analysis.primaryChunk.code = code;
         })
@@ -712,13 +867,35 @@ function iifeSplit(options) {
             globals: outputGlobals,
             sharedGlobalPath: `${primaryGlobal}.${sharedProp}`,
             sharedChunkFileName,
-            parse
+            parse,
+            skipRequireGlobals
           }).then((code) => {
             satellite.code = code;
           })
         );
       }
       await Promise.all(conversions);
+      if (outputBanner || outputFooter) {
+        for (const chunk of Object.values(bundle)) {
+          if (chunk.type === "chunk") {
+            const resolveBannerFooter = async (value) => {
+              if (value === void 0) return "";
+              if (typeof value === "function") {
+                return await value(chunk);
+              }
+              return value;
+            };
+            const banner = await resolveBannerFooter(outputBanner);
+            const footer = await resolveBannerFooter(outputFooter);
+            if (banner) {
+              chunk.code = banner + "\n" + chunk.code;
+            }
+            if (footer) {
+              chunk.code = chunk.code + "\n" + footer;
+            }
+          }
+        }
+      }
     }
   };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rollup-plugin-iife-split",
-  "version": "0.0.3",
+  "version": "0.0.5",
   "type": "module",
   "description": "Rollup plugin for intelligent IIFE code-splitting",
   "main": "dist/index.js",
@@ -12,15 +12,16 @@
     "rollup": "^3.0.0 || ^4.0.0"
   },
   "dependencies": {
-    "magic-string": "^0.30.0",
-    "estree-walker": "^3.0.0"
+    "estree-walker": "^3.0.0",
+    "magic-string": "^0.30.0"
   },
   "devDependencies": {
+    "@types/node": "^20.0.0",
+    "acorn": "^8.15.0",
     "rollup": "^4.0.0",
-    "typescript": "^5.0.0",
     "tsup": "^8.0.0",
-    "vitest": "^1.0.0",
-    "@types/node": "^20.0.0"
+    "typescript": "^5.0.0",
+    "vitest": "^1.0.0"
   },
   "keywords": [
     "rollup",