rollup-plugin-iife-split 0.0.2 → 0.0.4

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

@@ -39,9 +39,17 @@ interface IifeSplitOptions {
      */
     unshared?: (id: string) => boolean;
     /**
-     * Enable debug logging to see intermediate transformation steps.
+     * Directory to write intermediate files for debugging.
+     * If set, writes ESM files before IIFE conversion to help diagnose issues.
+     * Example: './debug-output'
      */
-    debug?: boolean;
+    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,19 +158,12 @@ function destructureSharedParameter(code, mappings, parse) {
   return ms.toString();
 }
 async function convertToIife(options) {
-  const { code, globalName, globals, sharedGlobalPath, sharedChunkFileName, parse, debug } = options;
+  const { code, globalName, globals, sharedGlobalPath, sharedChunkFileName, parse, skipRequireGlobals } = options;
   const importMappings = sharedGlobalPath ? extractSharedImportMappings(code, parse) : [];
-  if (debug && sharedGlobalPath) {
-    console.log("\n=== DEBUG convertToIife ===");
-    console.log("globalName:", globalName);
-    console.log("sharedGlobalPath:", sharedGlobalPath);
-    console.log("sharedChunkFileName:", sharedChunkFileName);
-    console.log("--- ESM code (first 500 chars) ---");
-    console.log(code.slice(0, 500));
-    console.log("--- Import mappings ---");
-    console.log(importMappings);
-  }
   const rollupGlobals = (id) => {
+    if (globalName && (id === globalName || globalName.startsWith(id + "."))) {
+      return id;
+    }
     if (sharedGlobalPath) {
       if (id.includes(SHARED_CHUNK_NAME)) {
         return sharedGlobalPath;
@@ -182,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,
@@ -194,23 +196,15 @@ 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"
   });
   await bundle.close();
   let result = output[0].code;
-  if (debug && sharedGlobalPath) {
-    console.log("--- IIFE before destructuring (first 800 chars) ---");
-    console.log(result.slice(0, 800));
-  }
   if (sharedGlobalPath && importMappings.length > 0) {
     result = stripNamespaceGuards(result);
     result = destructureSharedParameter(result, importMappings, parse);
-    if (debug) {
-      console.log("--- IIFE after destructuring (first 800 chars) ---");
-      console.log(result.slice(0, 800));
-      console.log("=== END DEBUG ===\n");
-    }
   } else if (globalName && !globalName.includes(".")) {
   } else if (globalName) {
     result = stripNamespaceGuards(result);
@@ -340,6 +334,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$/, ""));
 }
@@ -347,6 +452,7 @@ function removeSharedImportsAndRewriteRefs(code, sharedChunkFileName, sharedExpo
   const ast = parse(code);
   const s = new MagicString2(code);
   const namespaceNames = /* @__PURE__ */ new Set();
+  const namedImportRenames = /* @__PURE__ */ new Map();
   walk2(ast, {
     enter(node) {
       if (node.type === "ImportDeclaration") {
@@ -356,6 +462,19 @@ function removeSharedImportsAndRewriteRefs(code, sharedChunkFileName, sharedExpo
           for (const spec of importNode.specifiers) {
             if (spec.type === "ImportNamespaceSpecifier") {
               namespaceNames.add(spec.local.name);
+            } else if (spec.type === "ImportSpecifier" && spec.imported) {
+              const exportedName = spec.imported.name;
+              const localAlias = spec.local.name;
+              const actualLocal = sharedExportToLocal.get(exportedName) ?? exportedName;
+              if (localAlias !== actualLocal) {
+                namedImportRenames.set(localAlias, actualLocal);
+              }
+            } else if (spec.type === "ImportDefaultSpecifier") {
+              const localAlias = spec.local.name;
+              const actualLocal = sharedExportToLocal.get("default") ?? "__shared_default__";
+              if (localAlias !== actualLocal) {
+                namedImportRenames.set(localAlias, actualLocal);
+              }
             }
           }
         }
@@ -369,6 +488,7 @@ function removeSharedImportsAndRewriteRefs(code, sharedChunkFileName, sharedExpo
         const source = importNode.source.value;
         if (typeof source === "string" && isSharedChunkSource(source, sharedChunkFileName)) {
           s.remove(importNode.start, importNode.end);
+          this.skip();
         }
       }
       if (node.type === "ExportNamedDeclaration") {
@@ -388,6 +508,7 @@ function removeSharedImportsAndRewriteRefs(code, sharedChunkFileName, sharedExpo
               }
             }
             s.overwrite(exportNode.start, exportNode.end, `export { ${exportParts.join(", ")} };`);
+            this.skip();
           }
         }
       }
@@ -397,6 +518,14 @@ function removeSharedImportsAndRewriteRefs(code, sharedChunkFileName, sharedExpo
           const propertyName = memberNode.property.name;
           const localName = sharedExportToLocal.get(propertyName) ?? propertyName;
           s.overwrite(memberNode.start, memberNode.end, localName);
+          this.skip();
+        }
+      }
+      if (node.type === "Identifier" && namedImportRenames.size > 0) {
+        const id = node;
+        const newName = namedImportRenames.get(id.name);
+        if (newName) {
+          s.overwrite(id.start, id.end, newName);
         }
       }
     }
@@ -494,7 +623,7 @@ function removeChunkImportsAndRewriteRefs(code, chunkFileName, exportToLocal, pa
 function chunkImportsFrom(chunk, sourceChunkFileName) {
   return chunk.imports.some((imp) => isChunkSource(imp, sourceChunkFileName));
 }
-function mergeUnsharedIntoImporters(unsharedChunk, entryChunks, parse, debug) {
+function mergeUnsharedIntoImporters(unsharedChunk, entryChunks, parse) {
   const { exports: unsharedExports, hasDefault } = extractExports(unsharedChunk.code, parse);
   const exportToLocal = /* @__PURE__ */ new Map();
   for (const exp of unsharedExports) {
@@ -534,68 +663,79 @@ function mergeUnsharedIntoImporters(unsharedChunk, entryChunks, parse, debug) {
       localExportToLocal,
       parse
     );
-    entry.code = [
-      debug && `// === Inlined from ${unsharedChunk.name} (duplicated by rollup-plugin-iife-split) ===`,
-      codeToInline.trim(),
-      "",
-      debug && "// === Entry code ===",
-      entryWithoutImports.trim()
-    ].filter((line) => line !== false).join("\n");
+    entry.code = `${codeToInline.trim()}
+
+${entryWithoutImports.trim()}`;
   }
 }
-function mergeSharedIntoPrimary(primaryChunk, sharedChunk, sharedProperty, neededExports, parse, debug) {
+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 collisionRenameMap = /* @__PURE__ */ new Map();
   for (const name of sharedDeclarations) {
     if (primaryDeclarations.has(name)) {
-      renameMap.set(name, `__shared$${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 = [
-    debug && "// === Shared code (merged by rollup-plugin-iife-split) ===",
+  const parts = [
     strippedSharedCode.trim(),
     "",
-    debug && "// === Primary entry code ===",
-    primaryWithoutSharedImports.trim(),
-    "",
-    debug && "// === Shared exports object ===",
-    sharedExportObject,
-    `export { ${sharedProperty} };`
-  ].filter((line) => line !== false).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, debug } = options;
+  const { primary, primaryGlobal, secondaryProps, sharedProp, unshared, debugDir, skipRequireGlobals } = options;
+  const sanitizeName = (name) => name.replace(/[/\\]/g, "-");
+  const writeDebugFile = (filename, content) => {
+    if (!debugDir) return;
+    try {
+      mkdirSync(debugDir, { recursive: true });
+      writeFileSync(join(debugDir, filename), content);
+    } catch (e) {
+      console.warn(`[iife-split] Failed to write debug file ${filename}:`, e);
+    }
+  };
   let outputGlobals = {};
   const manualChunks = (id, { getModuleInfo }) => {
     const moduleInfo = getModuleInfo(id);
@@ -625,6 +765,18 @@ function iifeSplit(options) {
     async generateBundle(outputOptions, bundle) {
       const parse = this.parse.bind(this);
       const analysis = analyzeChunks(bundle, primary);
+      if (debugDir) {
+        writeDebugFile("1-primary-original.js", analysis.primaryChunk.code);
+        if (analysis.sharedChunk) {
+          writeDebugFile("1-shared-original.js", analysis.sharedChunk.code);
+        }
+        for (const satellite of analysis.satelliteChunks) {
+          writeDebugFile(`1-satellite-${sanitizeName(satellite.name)}-original.js`, satellite.code);
+        }
+        for (const unshared2 of analysis.unsharedChunks) {
+          writeDebugFile(`1-unshared-${sanitizeName(unshared2.name)}-original.js`, unshared2.code);
+        }
+      }
       const sharedChunkFileName = analysis.sharedChunk?.fileName ?? null;
       if (analysis.sharedChunk) {
         const neededExports = /* @__PURE__ */ new Set();
@@ -634,21 +786,32 @@ function iifeSplit(options) {
             neededExports.add(imp);
           }
         }
+        if (debugDir) {
+          writeDebugFile("2-needed-exports.json", JSON.stringify(Array.from(neededExports), null, 2));
+        }
         mergeSharedIntoPrimary(
           analysis.primaryChunk,
           analysis.sharedChunk,
           sharedProp,
           neededExports,
-          parse,
-          debug
+          parse
         );
         delete bundle[analysis.sharedChunk.fileName];
       }
+      if (debugDir) {
+        writeDebugFile("2-primary-after-shared-merge.js", analysis.primaryChunk.code);
+      }
       const allEntries = [analysis.primaryChunk, ...analysis.satelliteChunks];
       for (const unsharedChunk of analysis.unsharedChunks) {
-        mergeUnsharedIntoImporters(unsharedChunk, allEntries, parse, debug);
+        mergeUnsharedIntoImporters(unsharedChunk, allEntries, parse);
         delete bundle[unsharedChunk.fileName];
       }
+      if (debugDir) {
+        writeDebugFile("3-primary-before-iife.js", analysis.primaryChunk.code);
+        for (const satellite of analysis.satelliteChunks) {
+          writeDebugFile(`3-satellite-${sanitizeName(satellite.name)}-before-iife.js`, satellite.code);
+        }
+      }
       const conversions = [];
       conversions.push(
         convertToIife({
@@ -659,7 +822,7 @@ function iifeSplit(options) {
           // Primary doesn't need to import shared
           sharedChunkFileName: null,
           parse,
-          debug
+          skipRequireGlobals
         }).then((code) => {
           analysis.primaryChunk.code = code;
         })
@@ -681,7 +844,7 @@ function iifeSplit(options) {
             sharedGlobalPath: `${primaryGlobal}.${sharedProp}`,
             sharedChunkFileName,
             parse,
-            debug
+            skipRequireGlobals
           }).then((code) => {
             satellite.code = code;
           })

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rollup-plugin-iife-split",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "type": "module",
   "description": "Rollup plugin for intelligent IIFE code-splitting",
   "main": "dist/index.js",
@@ -12,15 +12,15 @@
     "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",
     "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",
@@ -30,11 +30,16 @@
     "bundle"
   ],
   "license": "MIT",
+  "homepage": "https://github.com/arshaw/rollup-plugin-iife-split",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/arshaw/rollup-plugin-iife-split.git"
+  },
   "scripts": {
     "clean": "rm -rf dist",
     "build": "tsup src/index.ts --format esm --dts",
     "typecheck": "tsc --noEmit",
-    "test": "vitest",
-    "test:run": "vitest run"
+    "test": "vitest run",
+    "test:dev": "vitest"
   }
 }