@module-federation/esbuild 0.0.0-next-20240524225331 → 0.0.0-next-20240528203231

package/dist/esbuild.cjs.js

@@ -12,8 +12,7 @@ var esModuleLexer = require('es-module-lexer');
 var cjsModuleLexer = require('cjs-module-lexer');
 var util = require('util');
 var enhancedResolve = require('enhanced-resolve');
-var federationBuilder = require('./federation-builder.cjs.js');
-require('npmlog');
+var getExternals = require('./get-externals.cjs.js');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
@@ -116,20 +115,17 @@ const writeRemoteManifest = async (config, result)=>{
             name: config.name
         };
     }
-    const mfConfig = config;
     var _process_env_NODE_ENV;
     const envType = process.env['NODE_ENV'] === 'development' ? 'local' : (_process_env_NODE_ENV = process.env['NODE_ENV']) != null ? _process_env_NODE_ENV : '';
     const publicPath = config.publicPath || 'auto';
     let containerName = '';
     const outputMap = Object.entries(((_result_metafile = result.metafile) == null ? void 0 : _result_metafile.outputs) || {}).reduce((acc, [chunkKey, chunkValue])=>{
-        //@ts-ignore
-        const { entryPoint, kind = 'static-import' } = chunkValue;
+        const { entryPoint } = chunkValue;
         const key = entryPoint || chunkKey;
-        if (key.startsWith('container:') && key.endsWith(mfConfig.filename)) {
+        if (key.startsWith('container:') && key.endsWith(config.filename)) {
             containerName = key;
         }
         acc[key] = _extends$2({}, chunkValue, {
-            kind,
             chunk: chunkKey
         });
         return acc;
@@ -172,7 +168,7 @@ const writeRemoteManifest = async (config, result)=>{
         }
         return assets;
     };
-    const shared = mfConfig.shared ? await Promise.all(Object.entries(mfConfig.shared).map(async ([pkg, config])=>{
+    const shared = config.shared ? await Promise.all(Object.entries(config.shared).map(async ([pkg, config])=>{
         const meta = outputMap['esm-shares:' + pkg];
         const chunks = getChunks(meta, outputMap);
         let { version } = config;
@@ -187,7 +183,7 @@ const writeRemoteManifest = async (config, result)=>{
             }
         }
         return {
-            id: `${mfConfig.name}:${pkg}`,
+            id: `${config.name}:${pkg}`,
             name: pkg,
             version: version || config.version,
             singleton: config.singleton || false,
@@ -195,7 +191,7 @@ const writeRemoteManifest = async (config, result)=>{
             assets: chunks
         };
     })) : [];
-    const remotes = mfConfig.remotes ? Object.entries(mfConfig.remotes).map(([alias, remote])=>{
+    const remotes = config.remotes ? Object.entries(config.remotes).map(([alias, remote])=>{
         const [federationContainerName, entry] = remote.includes('@') ? remote.split('@') : [
             alias,
             remote
@@ -207,11 +203,11 @@ const writeRemoteManifest = async (config, result)=>{
             entry
         };
     }) : [];
-    const exposes = mfConfig.exposes ? await Promise.all(Object.entries(mfConfig.exposes).map(async ([expose, value])=>{
+    const exposes = config.exposes ? await Promise.all(Object.entries(config.exposes).map(async ([expose, value])=>{
         const exposedFound = outputMapWithoutExt[value.replace('./', '')];
         const chunks = getChunks(exposedFound, outputMap);
         return {
-            id: `${mfConfig.name}:${expose.replace(/^\.\//, '')}`,
+            id: `${config.name}:${expose.replace(/^\.\//, '')}`,
             name: expose.replace(/^\.\//, ''),
             assets: chunks,
             path: expose
@@ -225,22 +221,22 @@ const writeRemoteManifest = async (config, result)=>{
     };
     var _packageJson_name;
     const manifest = {
-        id: mfConfig.name,
-        name: mfConfig.name,
+        id: config.name,
+        name: config.name,
         metaData: {
-            name: mfConfig.name,
+            name: config.name,
             type: 'app',
             buildInfo: {
                 buildVersion: envType,
                 buildName: ((_packageJson_name = packageJson.name) != null ? _packageJson_name : 'default').replace(/[^a-zA-Z0-9]/g, '_')
             },
             remoteEntry: {
-                name: mfConfig.filename,
+                name: config.filename,
                 path: outputMap[containerName] ? path__default["default"].dirname(outputMap[containerName].chunk) : '',
                 type: 'esm'
             },
             types,
-            globalName: mfConfig.name,
+            globalName: config.name,
             pluginVersion: version,
             publicPath
         },
@@ -434,9 +430,7 @@ const createContainer = (federationOptions) => {
   return __webpack_exports__;
 }`;
 
-//replace with createContainer from bundler runtime
-//@ts-ignore
-const buildContainerHost = ({ config })=>{
+const buildContainerHost = (config)=>{
     const { name, remotes = {}, shared = {}, exposes = {} } = config;
     const remoteConfigs = Object.entries(remotes).map(([remoteAlias, remote])=>({
             type: 'esm',
@@ -504,7 +498,6 @@ const buildContainerHost = ({ config })=>{
 
             await Promise.all(remotePrefetch);
 
-console.log('module map',moduleMap);
             const map = Object.keys(moduleMap).reduce((acc, expose) => {
                 const importMap = importShim.getImportMap().imports;
                 const key = args.origin.name + expose.replace('.', '');
@@ -517,7 +510,6 @@ console.log('module map',moduleMap);
                 return acc;
             }, {});
             await importShim.addImportMap({ imports: map });
-            console.log('final map', importShim.getImportMap());
 
             return args;
         }
@@ -543,11 +535,11 @@ console.log('module map',moduleMap);
 const createContainerPlugin = (config)=>({
         name: 'createContainer',
         setup (build) {
-            const { externals, config: { filename } } = config;
+            const { filename } = config;
             const filter = new RegExp([
                 filename
             ].map((name)=>`${name}$`).join('|'));
-            const sharedExternals = new RegExp(Object.keys(federationBuilder.federationBuilder.config.shared || {}).map((name)=>`${name}$`).join('|'));
+            const sharedExternals = new RegExp(Object.keys(config.shared || {}).map((name)=>`${name}$`).join('|'));
             build.onResolve({
                 filter
             }, async (args)=>({
@@ -609,8 +601,8 @@ const createContainerPlugin = (config)=>({
     });
 
 // Builds the federation host code
-const buildFederationHost = ()=>{
-    const { name, remotes, shared } = federationBuilder.federationBuilder.config;
+const buildFederationHost = (config)=>{
+    const { name, remotes, shared } = config;
     const remoteConfigs = remotes ? JSON.stringify(Object.entries(remotes).map(([remoteAlias, remote])=>({
             name: remoteAlias,
             entry: remote,
@@ -696,104 +688,103 @@ const buildFederationHost = ()=>{
     });
   `;
 };
-const initializeHostPlugin = {
-    name: 'host-initialization',
-    setup (build) {
-        build.onResolve({
-            filter: /federation-host/
-        }, (args)=>({
-                path: args.path,
-                namespace: 'federation-host',
-                pluginData: {
-                    kind: args.kind,
-                    resolveDir: args.resolveDir
-                }
-            }));
-        build.onLoad({
-            filter: /.*/,
-            namespace: 'federation-host'
-        }, async (args)=>({
-                contents: buildFederationHost(),
-                resolveDir: args.pluginData.resolveDir
-            }));
-        // Add custom loaders
-        const loaders = build.initialOptions.loader || {};
-        // Apply custom loaders
-        for (const [ext, loader] of Object.entries(loaders)){
+const initializeHostPlugin = (config)=>({
+        name: 'host-initialization',
+        setup (build) {
+            build.onResolve({
+                filter: /federation-host/
+            }, (args)=>({
+                    path: args.path,
+                    namespace: 'federation-host',
+                    pluginData: {
+                        kind: args.kind,
+                        resolveDir: args.resolveDir
+                    }
+                }));
             build.onLoad({
-                filter: new RegExp(`\\${ext}$`),
+                filter: /.*/,
+                namespace: 'federation-host'
+            }, async (args)=>({
+                    contents: buildFederationHost(config),
+                    resolveDir: args.pluginData.resolveDir
+                }));
+            // Add custom loaders
+            const loaders = build.initialOptions.loader || {};
+            // Apply custom loaders
+            for (const [ext, loader] of Object.entries(loaders)){
+                build.onLoad({
+                    filter: new RegExp(`\\${ext}$`),
+                    namespace: 'file'
+                }, async (args)=>{
+                    const contents = await fs__default["default"].promises.readFile(args.path, 'utf8');
+                    return {
+                        contents: buildFederationHost(config) + contents,
+                        loader
+                    };
+                });
+            }
+            // Fallback loader for files not matched by custom loaders
+            const fallbackFilter = new RegExp(Object.keys(loaders).map((ext)=>`\\${ext}$`).join('|'));
+            build.onLoad({
+                filter: /.*\.(ts|js|mjs)$/,
                 namespace: 'file'
-            }, async (args)=>{
-                const contents = await fs__default["default"].promises.readFile(args.path, 'utf8');
-                return {
-                    contents: buildFederationHost() + contents,
-                    loader
-                };
+            }, //@ts-ignore
+            async (args)=>{
+                if (!fallbackFilter.test(args.path)) {
+                    if (!build.initialOptions.entryPoints.some((e)=>args.path.includes(e))) {
+                        return;
+                    }
+                    const contents = await fs__default["default"].promises.readFile(args.path, 'utf8');
+                    return {
+                        contents: 'import "federation-host"; \n ' + contents
+                    };
+                }
             });
         }
-        // Fallback loader for files not matched by custom loaders
-        const fallbackFilter = new RegExp(Object.keys(loaders).map((ext)=>`\\${ext}$`).join('|'));
-        build.onLoad({
-            filter: /.*\.(ts|js|mjs)$/,
-            namespace: 'file'
-        }, //@ts-ignore
-        async (args)=>{
-            if (!fallbackFilter.test(args.path)) {
-                if (!build.initialOptions.entryPoints.some((e)=>args.path.includes(e))) {
-                    return;
-                }
-                const contents = await fs__default["default"].promises.readFile(args.path, 'utf8');
-                return {
-                    contents: buildFederationHost() + contents
-                };
-            }
-        });
-    }
-};
+    });
 
 // relys on import map since i dont know the named exports of a remote to return.
 const createVirtualRemoteModule = (name, ref)=>`
 export * from ${JSON.stringify('federationRemote/' + ref)}
 `;
-const linkRemotesPlugin = {
-    name: 'linkRemotes',
-    setup (build) {
-        //@ts-ignore
-        const remotes = federationBuilder.federationBuilder.config.remotes || {};
-        const filter = new RegExp(Object.keys(remotes).reduce((acc, key)=>{
-            if (!key) return acc;
-            acc.push(`^${key}`);
-            return acc;
-        }, []).join('|'));
-        build.onResolve({
-            filter: filter
-        }, async (args)=>{
-            return {
-                path: args.path,
+const linkRemotesPlugin = (config)=>({
+        name: 'linkRemotes',
+        setup (build) {
+            const remotes = config.remotes || {};
+            const filter = new RegExp(Object.keys(remotes).reduce((acc, key)=>{
+                if (!key) return acc;
+                acc.push(`^${key}`);
+                return acc;
+            }, []).join('|'));
+            build.onResolve({
+                filter: filter
+            }, async (args)=>{
+                return {
+                    path: args.path,
+                    namespace: 'remote-module'
+                };
+            });
+            build.onResolve({
+                filter: /^federationRemote/
+            }, async (args)=>{
+                return {
+                    path: args.path.replace('federationRemote/', ''),
+                    external: true,
+                    namespace: 'externals'
+                };
+            });
+            build.onLoad({
+                filter,
                 namespace: 'remote-module'
-            };
-        });
-        build.onResolve({
-            filter: /^federationRemote/
-        }, async (args)=>{
-            return {
-                path: args.path.replace('federationRemote/', ''),
-                external: true,
-                namespace: 'externals'
-            };
-        });
-        build.onLoad({
-            filter,
-            namespace: 'remote-module'
-        }, async (args)=>{
-            return {
-                contents: createVirtualRemoteModule(federationBuilder.federationBuilder.config.name, args.path),
-                loader: 'js',
-                resolveDir: path__default["default"].dirname(args.path)
-            };
-        });
-    }
-};
+            }, async (args)=>{
+                return {
+                    contents: createVirtualRemoteModule(config.name, args.path),
+                    loader: 'js',
+                    resolveDir: path__default["default"].dirname(args.path)
+                };
+            });
+        }
+    });
 
 function _extends$1() {
     _extends$1 = Object.assign || function(target) {
@@ -859,28 +850,14 @@ const cjsToEsmPlugin = {
     }
 };
 // Plugin to link shared dependencies
-const linkSharedPlugin = {
-    name: 'linkShared',
-    setup (build) {
-        const filter = new RegExp(Object.keys(federationBuilder.federationBuilder.config.shared || {}).map((name)=>`${name}$`).join('|'));
-        build.onResolve({
-            filter
-        }, (args)=>{
-            if (args.namespace === 'esm-shares') return null;
-            return {
-                path: args.path,
-                namespace: 'virtual-share-module',
-                pluginData: {
-                    kind: args.kind,
-                    resolveDir: args.resolveDir
-                }
-            };
-        });
-        build.onResolve({
-            filter: /.*/,
-            namespace: 'esm-shares'
-        }, (args)=>{
-            if (filter.test(args.path)) {
+const linkSharedPlugin = (config)=>({
+        name: 'linkShared',
+        setup (build) {
+            const filter = new RegExp(Object.keys(config.shared || {}).map((name)=>`${name}$`).join('|'));
+            build.onResolve({
+                filter
+            }, (args)=>{
+                if (args.namespace === 'esm-shares') return null;
                 return {
                     path: args.path,
                     namespace: 'virtual-share-module',
@@ -889,58 +866,83 @@ const linkSharedPlugin = {
                         resolveDir: args.resolveDir
                     }
                 };
-            }
-            if (filter.test(args.importer)) {
-                return {
-                    path: args.path,
+            });
+            build.onResolve({
+                filter: /.*/,
+                namespace: 'esm-shares'
+            }, (args)=>{
+                if (filter.test(args.path)) {
+                    return {
+                        path: args.path,
+                        namespace: 'virtual-share-module',
+                        pluginData: {
+                            kind: args.kind,
+                            resolveDir: args.resolveDir
+                        }
+                    };
+                }
+                if (filter.test(args.importer)) {
+                    return {
+                        path: args.path,
+                        namespace: 'esm-shares',
+                        pluginData: {
+                            kind: args.kind,
+                            resolveDir: args.resolveDir
+                        }
+                    };
+                }
+                return undefined;
+            });
+            build.onResolve({
+                filter: /^federationShare/
+            }, async (args)=>({
+                    path: args.path.replace('federationShare/', ''),
                     namespace: 'esm-shares',
                     pluginData: {
                         kind: args.kind,
                         resolveDir: args.resolveDir
                     }
+                }));
+            build.onLoad({
+                filter,
+                namespace: 'virtual-share-module'
+            }, async (args)=>{
+                const exp = await getExports(args.path);
+                return {
+                    contents: createVirtualShareModule(config.name, args.path, exp),
+                    loader: 'js',
+                    resolveDir: path__default["default"].dirname(args.path)
                 };
-            }
-            return undefined;
-        });
-        build.onResolve({
-            filter: /^federationShare/
-        }, async (args)=>({
-                path: args.path.replace('federationShare/', ''),
-                namespace: 'esm-shares',
-                pluginData: {
-                    kind: args.kind,
-                    resolveDir: args.resolveDir
-                }
-            }));
-        build.onLoad({
-            filter,
-            namespace: 'virtual-share-module'
-        }, async (args)=>{
-            const exp = await getExports(args.path);
-            return {
-                contents: createVirtualShareModule(federationBuilder.federationBuilder.config.name, args.path, exp),
-                loader: 'js',
-                resolveDir: path__default["default"].dirname(args.path)
-            };
-        });
-    }
-};
+            });
+        }
+    });
 // Main module federation plugin
 const moduleFederationPlugin = (config)=>({
         name: 'module-federation',
         setup (build) {
             build.initialOptions.metafile = true;
+            const externals = getExternals.getExternals(config);
+            if (build.initialOptions.external) {
+                build.initialOptions.external = [
+                    ...new Set([
+                        ...build.initialOptions.external,
+                        ...externals
+                    ])
+                ];
+            } else {
+                build.initialOptions.external = externals;
+            }
             const pluginStack = [];
-            const remotes = Object.keys(federationBuilder.federationBuilder.config.remotes || {}).length;
-            const shared = Object.keys(federationBuilder.federationBuilder.config.shared || {}).length;
-            const exposes = Object.keys(federationBuilder.federationBuilder.config.exposes || {}).length;
+            const remotes = Object.keys(config.remotes || {}).length;
+            const shared = Object.keys(config.shared || {}).length;
+            const exposes = Object.keys(config.exposes || {}).length;
             const entryPoints = build.initialOptions.entryPoints;
-            const filename = federationBuilder.federationBuilder.config.filename || 'remoteEntry.js';
+            const filename = config.filename || 'remoteEntry.js';
             if (remotes) {
-                pluginStack.push(linkRemotesPlugin);
+                pluginStack.push(linkRemotesPlugin(config));
             }
             if (shared) {
-                pluginStack.push(linkSharedPlugin);
+                pluginStack.push(linkSharedPlugin(config));
             }
             if (!entryPoints) {
                 build.initialOptions.entryPoints = [];
@@ -957,7 +959,7 @@ const moduleFederationPlugin = (config)=>({
                 }
             }
             [
-                initializeHostPlugin,
+                initializeHostPlugin(config),
                 createContainerPlugin(config),
                 cjsToEsmPlugin,
                 ...pluginStack
@@ -965,8 +967,8 @@ const moduleFederationPlugin = (config)=>({
             build.onEnd(async (result)=>{
                 if (!result.metafile) return;
                 if (exposes) {
-                    const exposedConfig = federationBuilder.federationBuilder.config.exposes || {};
-                    const remoteFile = federationBuilder.federationBuilder.config.filename;
+                    const exposedConfig = config.exposes || {};
+                    const remoteFile = config.filename;
                     const exposedEntries = {};
                     const outputMapWithoutExt = Object.entries(result.metafile.outputs).reduce((acc, [chunkKey, chunkValue])=>{
                         //@ts-ignore
@@ -999,7 +1001,7 @@ const moduleFederationPlugin = (config)=>({
                         fs__default["default"].writeFileSync(outputPath, withExports, 'utf-8');
                     }
                 }
-                await writeRemoteManifest(federationBuilder.federationBuilder.config, result);
+                await writeRemoteManifest(config, result);
                 console.log(`build ended with ${result.errors.length} errors`);
             });
         }