@module-federation/vite 1.0.0-alpha-54ad191 → 1.0.0-alpha-4a73cd4

package/lib/index.modern.js

@@ -1,60 +1,89 @@
-import { createFilter } from '@rollup/pluginutils';
-import * as path from 'path';
-import path__default from 'path';
 import * as fs from 'fs';
+import { writeFileSync } from 'fs';
+import * as path from 'pathe';
+import { resolve } from 'pathe';
+import { createFilter } from '@rollup/pluginutils';
 import { walk } from 'estree-walker';
 import MagicString from 'magic-string';
 
-var aliasToArrayPlugin = {
-  name: 'alias-transform-plugin',
-  config: (config, {
-    command
-  }) => {
-    if (!config.resolve) config.resolve = {};
-    if (!config.resolve.alias) config.resolve.alias = [];
-    const {
-      alias
-    } = config.resolve;
-    if (typeof alias === 'object' && !Array.isArray(alias)) {
-      config.resolve.alias = Object.entries(alias).map(([find, replacement]) => ({
-        find,
-        replacement
-      }));
-    }
-  }
-};
-
-var normalizeBuildPlugin = (singleChunkModules => ({
-  name: 'normalizeBuild',
-  config: (config, {
-    command
-  }) => {
-    if (!config.build) config.build = {};
-    if (!config.build.rollupOptions) config.build.rollupOptions = {};
-    let {
-      rollupOptions
-    } = config.build;
-    if (!rollupOptions.output) rollupOptions.output = {};
-    normalizeManualChunks(rollupOptions.output, singleChunkModules);
-  }
-}));
-function normalizeManualChunks(output, singleChunkModules) {
-  const pattern = new RegExp(`node_modules/(${singleChunkModules.join('|')})/`);
-  if (!output.manualChunks) output.manualChunks = {};
-  const wrapManualChunks = original => (id, ...args) => {
-    const [_, moduleName] = id.match(pattern) || [];
-    if (moduleName) {
-      return moduleName;
-    }
-    if (typeof original === 'function') {
-      return original(id, ...args);
+const addEntry = ({
+  entryName,
+  entryPath,
+  fileName
+}) => {
+  let entryFiles = [];
+  let htmlFilePath;
+  return [{
+    name: 'add-entry',
+    apply: "serve",
+    configureServer(server) {
+      var _server$httpServer;
+      (_server$httpServer = server.httpServer) == null || _server$httpServer.once == null || _server$httpServer.once('listening', () => {
+        const {
+          port
+        } = server.config.server;
+        fetch(path.join(`http://localhost:${port}`, `${entryPath}`)).catch(e => {});
+      });
+      server.middlewares.use((req, res, next) => {
+        if (!fileName) {
+          next();
+          return;
+        }
+        if (req.url && req.url.startsWith(fileName.replace(/^\/?/, '/'))) {
+          req.url = entryPath;
+        }
+        next();
+      });
+    },
+    transformIndexHtml(c) {
+      return c.replace('<head>', `<head><script type="module" src=${JSON.stringify(entryPath.replace(/.+?\:([/\\])[/\\]?/, '$1').replace(/\\\\?/g, '/'))}></script>`);
     }
-    if (typeof original === 'object' && original) {
-      return original[id];
+  }, {
+    name: "add-entry",
+    enforce: "post",
+    apply: "build",
+    configResolved(config) {
+      const inputOptions = config.build.rollupOptions.input;
+      if (!inputOptions) {
+        htmlFilePath = path.resolve(config.root, 'index.html');
+      } else if (typeof inputOptions === 'string') {
+        entryFiles = [inputOptions];
+        htmlFilePath = path.resolve(config.root, inputOptions);
+      } else if (Array.isArray(inputOptions)) {
+        entryFiles = inputOptions;
+        htmlFilePath = path.resolve(config.root, inputOptions[0]);
+      } else if (typeof inputOptions === 'object') {
+        entryFiles = Object.values(inputOptions);
+        htmlFilePath = path.resolve(config.root, Object.values(inputOptions)[0]);
+      }
+    },
+    buildStart() {
+      const hasHash = fileName == null || fileName.includes == null ? void 0 : fileName.includes("[hash");
+      this.emitFile({
+        [hasHash ? "name" : "fileName"]: fileName,
+        type: 'chunk',
+        id: entryPath,
+        preserveSignature: 'strict'
+      });
+      if (htmlFilePath) {
+        const htmlContent = fs.readFileSync(htmlFilePath, 'utf-8');
+        const scriptRegex = /<script\s+[^>]*src=["']([^"']+)["'][^>]*>/gi;
+        let match;
+        while ((match = scriptRegex.exec(htmlContent)) !== null) {
+          entryFiles.push(match[1]);
+        }
+      }
+    },
+    transform(code, id) {
+      if (entryFiles.some(file => id.endsWith(file))) {
+        const injection = `
+          import ${JSON.stringify(entryPath)};
+          `;
+        return injection + code;
+      }
     }
-  };
-  output.manualChunks = wrapManualChunks(output.manualChunks);
-}
+  }];
+};
 
 function normalizeExposesItem(key, item) {
   let importPath = '';
@@ -72,7 +101,7 @@ function normalizeExposes(exposes) {
   if (!exposes) return {};
   const res = {};
   Object.keys(exposes).forEach(key => {
-    res[key.replace(/^\.?\/?/, './')] = normalizeExposesItem(key, exposes[key]);
+    res[key] = normalizeExposesItem(key, exposes[key]);
   });
   return res;
 }
@@ -108,7 +137,7 @@ function normalizeRemoteItem(key, remote) {
 function normalizeShareItem(key, shareItem) {
   let version;
   try {
-    version = require(path__default.join(key, 'package.json')).version;
+    version = require(path.join(key, 'package.json')).version;
   } catch (e) {
     console.log(e);
   }
@@ -156,8 +185,12 @@ function normalizeLibrary(library) {
   if (!library) return undefined;
   return library;
 }
+let config;
+function getNormalizeModuleFederationOptions() {
+  return config;
+}
 function normalizeModuleFederationOptions(options) {
-  return {
+  return config = {
     exposes: normalizeExposes(options.exposes),
     filename: options.filename || 'remoteEntry-[hash]',
     library: normalizeLibrary(options.library),
@@ -176,197 +209,82 @@ function normalizeModuleFederationOptions(options) {
   };
 }
 
-var normalizeOptimizeDepsPlugin = {
-  name: 'normalizeOptimizeDeps',
-  config: (config, {
-    command
-  }) => {
-    let {
-      optimizeDeps
-    } = config;
-    if (!optimizeDeps) {
-      config.optimizeDeps = {};
-      optimizeDeps = config.optimizeDeps;
-    }
-    if (!optimizeDeps.include) optimizeDeps.include = [];
-    if (!optimizeDeps.needsInterop) optimizeDeps.needsInterop = [];
-  }
-};
-
-const addEntry = ({
-  entryName,
-  entryPath,
-  fileName
-}) => {
-  let entryFiles = [];
-  let htmlFilePath;
-  return [{
-    name: 'add-entry',
-    apply: "serve",
-    configureServer(server) {
-      var _server$httpServer;
-      (_server$httpServer = server.httpServer) == null || _server$httpServer.once == null || _server$httpServer.once('listening', () => {
-        const {
-          port
-        } = server.config.server;
-        fetch(`http://localhost:${port}${entryPath}`);
-      });
-      server.middlewares.use((req, res, next) => {
-        if (!fileName) {
-          next();
-          return;
-        }
-        if (req.url && req.url.startsWith(fileName.replace(/^\/?/, '/'))) {
-          req.url = entryPath;
-        }
-        next();
-      });
-    },
-    transformIndexHtml(c) {
-      return c.replace('<head>', `<head><script type="module" src=${JSON.stringify(entryPath.replace(/.+?\:([/\\])[/\\]?/, '$1').replace(/\\\\/g, '/'))}></script>`);
-    }
-  }, {
-    name: "add-entry",
-    enforce: "post",
-    apply: "build",
-    configResolved(config) {
-      const inputOptions = config.build.rollupOptions.input;
-      if (!inputOptions) {
-        htmlFilePath = path.resolve(config.root, 'index.html');
-      } else if (typeof inputOptions === 'string') {
-        entryFiles = [inputOptions];
-        htmlFilePath = path.resolve(config.root, inputOptions);
-      } else if (Array.isArray(inputOptions)) {
-        entryFiles = inputOptions;
-        htmlFilePath = path.resolve(config.root, inputOptions[0]);
-      } else if (typeof inputOptions === 'object') {
-        entryFiles = Object.values(inputOptions);
-        htmlFilePath = path.resolve(config.root, Object.values(inputOptions)[0]);
-      }
-    },
-    buildStart() {
-      const hasHash = fileName == null || fileName.includes == null ? void 0 : fileName.includes("[hash");
-      this.emitFile({
-        [hasHash ? "name" : "fileName"]: fileName,
-        type: 'chunk',
-        id: entryPath,
-        preserveSignature: 'strict'
-      });
-      if (htmlFilePath) {
-        const htmlContent = fs.readFileSync(htmlFilePath, 'utf-8');
-        const scriptRegex = /<script\s+[^>]*src=["']([^"']+)["'][^>]*>/gi;
-        let match;
-        while ((match = scriptRegex.exec(htmlContent)) !== null) {
-          entryFiles.push(match[1]);
-        }
-      }
-    },
-    transform(code, id) {
-      if (entryFiles.some(file => id.endsWith(file))) {
-        const injection = `
-          import ${JSON.stringify(entryPath)};
-          `;
-        return injection + code;
-      }
-    }
-  }];
-};
-
-function overrideModule(options = {}) {
-  let {
-    override: _override = [],
-    include,
-    exclude
-  } = options;
-  const override = new Set(_override);
-  const filterFunction = createFilter(include, exclude);
-  const alias = {};
-  const keys = override.keys();
-  for (const key of keys) {
-    alias['__overrideModule__' + key] = require.resolve(`an-empty-js-file`) + `?__overrideModule__=${encodeURIComponent(key)}`;
-  }
-  return {
-    name: 'overrideModule',
-    enforce: 'post',
-    config(config) {
-      if (!config.optimizeDeps) config.optimizeDeps = {};
-      if (!config.optimizeDeps.needsInterop) config.optimizeDeps.needsInterop = [];
-      Object.keys(alias).forEach(key => {
-        var _config$optimizeDeps;
-        (_config$optimizeDeps = config.optimizeDeps) == null || (_config$optimizeDeps = _config$optimizeDeps.needsInterop) == null || _config$optimizeDeps.push(key);
-      });
-      config.optimizeDeps.needsInterop.push('an-empty-js-file');
-      config.resolve.alias.push(...Object.keys(alias).map(key => ({
-        find: key,
-        replacement: alias[key]
-      })));
-    },
-    resolveId(id) {
-      return alias[id];
-    },
-    transform: {
-      handler(code, id) {
-        if (!filterFunction(id)) return null;
-        let ast;
-        try {
-          ast = this.parse(code, {
-            allowReturnOutsideFunction: true
-          });
-        } catch (e) {
-          throw new Error(`${id}: ${e}`);
+/**
+ * Even the resolveId hook cannot interfere with vite pre-build,
+ * and adding query parameter virtual modules will also fail.
+ * You can only proxy to the real file through alias
+ */
+const emptyNpmDir = resolve(require.resolve("an-empty-js-file"), "../");
+/**
+ * The original shared module is proxied by getLoadShareModulePath, and the new shared module is prebuilt here
+ */
+const cacheMap2 = {};
+function getPreBuildLibPath(pkg) {
+  if (!cacheMap2[pkg]) cacheMap2[pkg] = `__mf__prebuildwrap_${npmPackageNameToFileName(pkg)}.js`;
+  const filename = cacheMap2[pkg];
+  return filename;
+}
+function getLocalSharedImportMapFileName() {
+  const {
+    name
+  } = getNormalizeModuleFederationOptions();
+  return npmPackageNameToFileName(name) + "_" + "__mf__localSharedImportMap.js";
+}
+// Only npm package name import can trigger pre-build, absolute path cannot
+function getLocalSharedImportMapId() {
+  return `an-empty-js-file/${getLocalSharedImportMapFileName()}`;
+}
+function getLocalSharedImportMapPath() {
+  return resolve(emptyNpmDir, getLocalSharedImportMapFileName());
+}
+function writeLocalSharedImportMap(pkgList) {
+  writeFileSync(getLocalSharedImportMapPath(), `
+    export default {
+      ${pkgList.map(pkg => `
+        ${JSON.stringify(pkg)}: async () => {
+          let pkg = await import("${getPreBuildLibPath(pkg)}")
+          return pkg
         }
-        const s = new MagicString(code);
-        walk(ast, {
-          enter(node) {
-            const replaceIfMatch = sourceNode => {
-              if (sourceNode && sourceNode.value) {
-                if (override.has(sourceNode.value)) {
-                  const start = sourceNode.start + 1; // Skip the opening quote
-                  const end = sourceNode.end - 1; // Skip the closing quote
-                  s.overwrite(start, end, '__overrideModule__' + sourceNode.value);
-                }
-              }
-            };
-            if (node.type === 'ImportDeclaration') {
-              replaceIfMatch(node.source);
-            }
-            if (node.type === 'ExportNamedDeclaration' || node.type === 'ExportAllDeclaration') {
-              replaceIfMatch(node.source);
-            }
-            if (node.type === 'CallExpression' && node.callee.type === 'Import' && node.arguments.length && node.arguments[0].type === 'Literal') {
-              replaceIfMatch(node.arguments[0]);
-            }
-            if (node.type === 'CallExpression' && node.callee.name === 'require' && node.arguments.length && node.arguments[0].type === 'Literal') {
-              replaceIfMatch(node.arguments[0]);
-            }
-          }
-        });
-        return {
-          code: s.toString(),
-          map: s.generateMap({
-            hires: true
-          })
-        };
-      }
+      `).join(",")}
     }
-  };
+    `);
 }
-
-const emptyPath = require.resolve('an-empty-js-file');
-const filter = createFilter();
-let command = '';
-function wrapRemoteEntry() {
-  return `
-  import {init, get} from "__mf__cwdRemoteEntry"
-  export {init, get}
-  `;
+/**
+ * generate loadShare virtual module
+ */
+const cacheMap1 = {};
+function getLoadShareModulePath(pkg) {
+  const {
+    name
+  } = getNormalizeModuleFederationOptions();
+  if (!cacheMap1[pkg]) cacheMap1[pkg] = npmPackageNameToFileName(name) + "_" + `__mf__loadShare_${npmPackageNameToFileName(pkg)}.js`;
+  const filename = cacheMap1[pkg];
+  return resolve(emptyNpmDir, filename);
 }
-function wrapHostInit() {
-  return `
-    import {init} from "__mf__cwdRemoteEntry"
-    init()
-    `;
+function writeLoadShareModule(pkg, shareItem, command) {
+  writeFileSync(getLoadShareModulePath(pkg), `
+    const {loadShare} = require("@module-federation/runtime")
+    const res = loadShare(${JSON.stringify(pkg)}, {
+    customShareInfo: {shareConfig:{
+      singleton: ${shareItem.shareConfig.singleton},
+      strictVersion: ${shareItem.shareConfig.strictVersion},
+      requiredVersion: ${JSON.stringify(shareItem.shareConfig.requiredVersion)}
+    }}})
+    const exportModule = ${command !== "build" ? "/*mf top-level-await placeholder replacement mf*/" : "await "}res.then(factory => factory())
+    module.exports = exportModule
+  `);
+}
+function npmPackageNameToFileName(packageName) {
+  // 1. 去掉包名前的 "@"
+  // 2. 将包名中的 "/" 替换为 "__" 以避免文件路径问题
+  // 3. 去掉不合法的文件名字符
+  return packageName.replace(/^@/, '') // 移除作用域前缀 "@"
+  .replace(/\//g, '__') // 将 "/" 替换为 "__"
+  .replace(/[^a-zA-Z0-9_.-]/g, '_'); // 替换其他非法字符为 "_"
 }
+
+const emptyPath = require.resolve('an-empty-js-file');
+const REMOTE_ENTRY_ID = "REMOTE_ENTRY_ID";
 function generateRemoteEntry(options) {
   const pluginImportNames = options.runtimePlugins.map((p, i) => [`$runtimePlugin_${i}`, `import $runtimePlugin_${i} from "${p}";`]);
   return `
@@ -390,6 +308,7 @@ function generateRemoteEntry(options) {
       `;
   }).join(',')}
   }
+  import localSharedImportMap from "${getLocalSharedImportMapId()}"
   async function init(shared = {}) {
     const localShared = {
       ${Object.keys(options.shared).map(key => {
@@ -403,9 +322,10 @@ function generateRemoteEntry(options) {
             from: ${JSON.stringify(options.name)},
             async get () {
               localShared[${JSON.stringify(key)}].loaded = true
-              const pkg = await import(${JSON.stringify(key)})
+              const {${JSON.stringify(key)}: pkgDynamicImport} = localSharedImportMap 
+              const res = await pkgDynamicImport()
               return function () {
-                return pkg
+                return res
               }
             },
             shareConfig: {
@@ -447,71 +367,319 @@ function generateRemoteEntry(options) {
   }
   `;
 }
-function wrapShare(id, shared) {
-  const shareConfig = shared[id].shareConfig;
+const WRAP_REMOTE_ENTRY_PATH = emptyPath + '?__mf__wrapRemoteEntry__';
+function generateWrapRemoteEntry() {
+  return `
+  import {init, get} from "${REMOTE_ENTRY_ID}"
+  export {init, get}
+  `;
+}
+/**
+ * Inject entry file, automatically init when used as host,
+ * and will not inject remoteEntry
+ */
+const HOST_AUTO_INIT = emptyPath + '?__mf__isHostInit';
+function generateWrapHostInit() {
+  return `
+    import {init} from "${REMOTE_ENTRY_ID}"
+    init()
+    `;
+}
+
+const filter$1 = createFilter();
+function pluginProxyRemoteEntry () {
   return {
-    code: `
-        import {loadShare} from "@module-federation/runtime"
-        const res = await loadShare(${JSON.stringify(id)}, {
-        customShareInfo: {shareConfig:{
-          singleton: ${shareConfig.singleton},
-          strictVersion: ${JSON.stringify(shareConfig.strictVersion)},
-          requiredVersion: ${JSON.stringify(shareConfig.requiredVersion)}
-        }}})
-        export default res()
-      `,
-    map: null,
-    syntheticNamedExports: 'default'
+    name: 'proxyRemoteEntry',
+    enforce: 'post',
+    resolveId(id) {
+      if (id === REMOTE_ENTRY_ID) {
+        return REMOTE_ENTRY_ID;
+      }
+    },
+    load(id) {
+      if (id === REMOTE_ENTRY_ID) {
+        return generateRemoteEntry(getNormalizeModuleFederationOptions());
+      }
+    },
+    async transform(code, id) {
+      if (!filter$1(id)) return;
+      if (id === REMOTE_ENTRY_ID) {
+        return generateRemoteEntry(getNormalizeModuleFederationOptions());
+      }
+      if (id.includes(WRAP_REMOTE_ENTRY_PATH)) {
+        return generateWrapRemoteEntry();
+      }
+      if (id.includes(HOST_AUTO_INIT)) {
+        return generateWrapHostInit();
+      }
+    }
   };
 }
-let con;
-function wrapRemote(id) {
+
+function generateRemotes(id, command) {
   return {
     code: `
     import {loadRemote} from "@module-federation/runtime"
-    export ${command !== 'build' ? 'default' : 'const dynamicExport = '} await loadRemote(${JSON.stringify(id)})
+    const exportModule = await loadRemote(${JSON.stringify(id)})
+    ${command === "build" && `
+        export default 'default' in (exportModule || {}) ? exportModule.default : undefined
+        export const __mf__dynamicExports = exportModule
+        ` || ""}
+      ${command !== "build" && `
+        export default exportModule
+        ` || ""}
   `,
     map: null,
-    syntheticNamedExports: 'dynamicExport'
+    // TODO: vite dev mode invalid, use optimizeDeps.needsInterop
+    syntheticNamedExports: '__mf__dynamicExports'
   };
 }
+
+const filter = createFilter();
+function pluginProxyRemotes (options) {
+  let command;
+  const {
+    remotes
+  } = options;
+  const matchRemotesList = Object.keys(remotes).map(item => item.replace(/\//g, "_"));
+  return {
+    name: "proxyRemotes",
+    config(config, {
+      command: _command
+    }) {
+      command = _command;
+      Object.keys(remotes).forEach(key => {
+        const remote = remotes[key];
+        config.resolve.alias.push({
+          find: new RegExp(`(${remote.name}(\/.*|$)?)`),
+          replacement: '$1',
+          customResolver(source) {
+            if (!config.optimizeDeps) config.optimizeDeps = {};
+            if (!config.optimizeDeps.needsInterop) config.optimizeDeps.needsInterop = [];
+            if (config.optimizeDeps.needsInterop.indexOf(source) === -1) config.optimizeDeps.needsInterop.push(source);
+            return this.resolve(require.resolve('an-empty-js-file') + '?__moduleRemote__=' + encodeURIComponent(source));
+          }
+        });
+      });
+    },
+    async transform(code, id) {
+      if (!filter(id)) return;
+      let [devRemoteModuleName] = matchRemotesList.length && id.match(new RegExp(`\/(${matchRemotesList.join('|')})(\_.*\.js|\.js)`)) || [];
+      if (devRemoteModuleName) {
+        return generateRemotes(devRemoteModuleName.replace('/', '').replace(/_/g, '/').replace('.js', ''), command);
+      }
+      let [prodRemoteName] = id.match(/\_\_moduleRemote\_\_=[^&]+/) || [];
+      if (prodRemoteName) {
+        return generateRemotes(decodeURIComponent(prodRemoteName.replace('__moduleRemote__=', '')), command);
+      }
+    }
+  };
+}
+
+function proxySharedModule(options) {
+  let {
+    shared = {},
+    include,
+    exclude
+  } = options;
+  const filterFunction = createFilter(include, exclude);
+  writeLocalSharedImportMap(Object.keys(shared));
+  return [{
+    name: 'preBuildShared',
+    enforce: 'post',
+    config(config, {
+      command
+    }) {
+      // config?.optimizeDeps?.include?.push?.("an-empty-js-file");
+      // config.optimizeDeps.needsInterop.push('an-empty-js-file');
+      config.resolve.alias.push(...Object.keys(shared).map(key => {
+        var _config$optimizeDeps;
+        config == null || (_config$optimizeDeps = config.optimizeDeps) == null || (_config$optimizeDeps = _config$optimizeDeps.include) == null || _config$optimizeDeps.push == null || _config$optimizeDeps.push(getPreBuildLibPath(key));
+        // write proxyFile
+        writeLoadShareModule(key, shared[key], command);
+        const preBuildLibPath = getLoadShareModulePath(key);
+        return {
+          // Intercept all dependency requests to the proxy module
+          // Dependency requests issued by localSharedImportMap are allowed without proxying.
+          find: new RegExp(`^${key}$`),
+          replacement: preBuildLibPath,
+          customResolver(source, importer) {
+            if (importer.includes(`node_modules/${key}/`)) {
+              return this.resolve(key);
+            }
+            return this.resolve(preBuildLibPath);
+          }
+        };
+      }));
+      config.resolve.alias.push(...Object.keys(shared).map(key => {
+        return {
+          find: new RegExp(`^${getPreBuildLibPath(key)}$`),
+          customResolver(source, importer) {
+            return this.resolve(key);
+          }
+        };
+      }));
+    }
+  }, {
+    name: "prebuild-top-level-await",
+    apply: "serve",
+    transform(code, id) {
+      if (!code.includes("/*mf top-level-await placeholder replacement mf*/")) {
+        return null;
+      }
+      if (!filterFunction(id)) return null;
+      let ast;
+      try {
+        ast = this.parse(code, {
+          allowReturnOutsideFunction: true
+        });
+      } catch (e) {
+        throw new Error(`${id}: ${e}`);
+      }
+      const magicString = new MagicString(code);
+      walk(ast, {
+        enter(node) {
+          // 处理命名导出
+          if (node.type === 'ExportNamedDeclaration' && node.specifiers) {
+            const exportSpecifiers = node.specifiers.map(specifier => specifier.exported.name);
+            const proxyStatements = exportSpecifiers.map(name => `
+                const __mfproxy__await${name} = await ${name}();
+                const __mfproxy__${name} = () => __mfproxy__await${name};
+              `).join('\n');
+            const exportStatements = exportSpecifiers.map(name => `__mfproxy__${name} as ${name}`).join(', ');
+            const start = node.start;
+            const end = node.end;
+            const replacement = `${proxyStatements}\nexport { ${exportStatements} };`;
+            magicString.overwrite(start, end, replacement);
+          }
+          // 处理默认导出
+          if (node.type === 'ExportDefaultDeclaration') {
+            const declaration = node.declaration;
+            const start = node.start;
+            const end = node.end;
+            let proxyStatement;
+            let exportStatement = 'default';
+            if (declaration.type === 'Identifier') {
+              // 处理标识符 (如: export default foo;)
+              proxyStatement = `
+                  const __mfproxy__awaitdefault = await ${declaration.name}();
+                  const __mfproxy__default = __mfproxy__awaitdefault;
+                `;
+            } else if (declaration.type === 'CallExpression' || declaration.type === 'FunctionDeclaration') {
+              // 处理调用表达式或函数声明 (如: export default someFunction();)
+              const declarationCode = code.slice(declaration.start, declaration.end);
+              proxyStatement = `
+                  const __mfproxy__awaitdefault = await (${declarationCode});
+                  const __mfproxy__default = __mfproxy__awaitdefault;
+                `;
+            } else {
+              // 其他类型 (可以根据需要添加更多处理逻辑)
+              proxyStatement = `
+                  const __mfproxy__awaitdefault = await (${code.slice(declaration.start, declaration.end)});
+                  const __mfproxy__default = __mfproxy__awaitdefault;
+                `;
+            }
+            const replacement = `${proxyStatement}\nexport { __mfproxy__default as ${exportStatement} };`;
+            magicString.overwrite(start, end, replacement);
+          }
+        }
+      });
+      return {
+        code: magicString.toString(),
+        map: magicString.generateMap({
+          hires: true
+        })
+      };
+    }
+  }];
+}
+
+var aliasToArrayPlugin = {
+  name: 'alias-transform-plugin',
+  config: (config, {
+    command
+  }) => {
+    if (!config.resolve) config.resolve = {};
+    if (!config.resolve.alias) config.resolve.alias = [];
+    const {
+      alias
+    } = config.resolve;
+    if (typeof alias === 'object' && !Array.isArray(alias)) {
+      config.resolve.alias = Object.entries(alias).map(([find, replacement]) => ({
+        find,
+        replacement
+      }));
+    }
+  }
+};
+
+var normalizeBuildPlugin = (singleChunkModules => ({
+  name: 'normalizeBuild',
+  config: (config, {
+    command
+  }) => {
+    if (!config.build) config.build = {};
+    if (!config.build.rollupOptions) config.build.rollupOptions = {};
+    let {
+      rollupOptions
+    } = config.build;
+    if (!rollupOptions.output) rollupOptions.output = {};
+    normalizeManualChunks(rollupOptions.output, singleChunkModules);
+  }
+}));
+function normalizeManualChunks(output, singleChunkModules) {
+  const pattern = new RegExp(`node_modules/(${singleChunkModules.join('|')})/`);
+  if (!output.manualChunks) output.manualChunks = {};
+  const wrapManualChunks = original => (id, ...args) => {
+    const [_, moduleName] = id.match(pattern) || [];
+    if (moduleName) {
+      return moduleName;
+    }
+    if (typeof original === 'function') {
+      return original(id, ...args);
+    }
+    if (typeof original === 'object' && original) {
+      return original[id];
+    }
+  };
+  output.manualChunks = wrapManualChunks(output.manualChunks);
+}
+
+var normalizeOptimizeDepsPlugin = {
+  name: 'normalizeOptimizeDeps',
+  config: (config, {
+    command
+  }) => {
+    let {
+      optimizeDeps
+    } = config;
+    if (!optimizeDeps) {
+      config.optimizeDeps = {};
+      optimizeDeps = config.optimizeDeps;
+    }
+    if (!optimizeDeps.include) optimizeDeps.include = [];
+    if (!optimizeDeps.needsInterop) optimizeDeps.needsInterop = [];
+  }
+};
+
 function federation(mfUserOptions) {
   const options = normalizeModuleFederationOptions(mfUserOptions);
   const {
+    name,
     remotes,
     shared,
     filename
   } = options;
-  const alias = [{
-    find: '@module-federation/runtime',
-    replacement: require.resolve('@module-federation/runtime')
-  }];
-  Object.keys(remotes).forEach(key => {
-    const remote = remotes[key];
-    alias.push({
-      find: new RegExp(`(${remote.name}(\/.*|$)?)`),
-      replacement: '$1',
-      customResolver(source) {
-        if (!con.optimizeDeps) con.optimizeDeps = {};
-        if (!con.optimizeDeps.needsInterop) con.optimizeDeps.needsInterop = [];
-        if (con.optimizeDeps.needsInterop.indexOf(source) === -1) con.optimizeDeps.needsInterop.push(source);
-        return this.resolve(require.resolve('an-empty-js-file') + '?__moduleRemote__=' + encodeURIComponent(source));
-      }
-    });
-  });
-  const remotePrefixList = Object.keys(remotes);
-  // pkgname will be escaped, and matching path also needs to be processed in the same way:
-  // @json2csv/plainjs --> .vite/deps/@json2csv_plainjs
-  const sharedKeyMatchList = Object.keys(shared).map(item => `__overrideModule__${item.replace('/', '_')}`);
+  if (!name) throw new Error("name is required");
   return [aliasToArrayPlugin, normalizeOptimizeDepsPlugin, normalizeBuildPlugin([...Object.keys(shared), "@module-federation/runtime"]), ...addEntry({
     entryName: 'remoteEntry',
-    entryPath: emptyPath + '?__mf__wrapRemoteEntry__',
+    entryPath: WRAP_REMOTE_ENTRY_PATH,
     fileName: filename
   }), ...addEntry({
     entryName: 'hostInit',
-    entryPath: emptyPath + '?__mf__isHostInit'
-  }), overrideModule({
-    override: Object.keys(shared)
+    entryPath: HOST_AUTO_INIT
+  }), pluginProxyRemoteEntry(), pluginProxyRemotes(options), ...proxySharedModule({
+    shared
   }), {
     name: 'module-federation-vite',
     enforce: 'post',
@@ -519,55 +687,14 @@ function federation(mfUserOptions) {
       command: _command
     }) {
       var _config$optimizeDeps;
-      con = config;
-      command = _command;
-      config.resolve.alias.push(...alias);
-      (_config$optimizeDeps = config.optimizeDeps) == null || (_config$optimizeDeps = _config$optimizeDeps.include) == null || _config$optimizeDeps.push('@module-federation/runtime');
-      Object.keys(shared).forEach(key => {
-        var _config$optimizeDeps2;
-        (_config$optimizeDeps2 = config.optimizeDeps) == null || (_config$optimizeDeps2 = _config$optimizeDeps2.include) == null || _config$optimizeDeps2.push(key);
+      config.resolve.alias.push({
+        find: '@module-federation/runtime',
+        replacement: require.resolve('@module-federation/runtime')
       });
-    },
-    resolveId(id) {
-      if (id === '__mf__cwdRemoteEntry') {
-        return '__mf__cwdRemoteEntry';
-      }
-    },
-    load(id) {
-      if (id === '__mf__cwdRemoteEntry') {
-        return generateRemoteEntry(options);
-      }
-    },
-    async transform(code, id) {
-      if (!filter(id)) return;
-      if (id === '__mf__cwdRemoteEntry') {
-        return generateRemoteEntry(options);
-      }
-      if (id.indexOf('__mf__wrapRemoteEntry__') > -1) {
-        return wrapRemoteEntry();
-      }
-      if (id.indexOf('__mf__isHostInit') > -1) {
-        return wrapHostInit();
-      }
-      if (id.indexOf('__mf__cwdRemoteEntry') > -1) {
-        return generateRemoteEntry(options);
-      }
-      let [devSharedModuleName] = sharedKeyMatchList.length && id.match(new RegExp(`\/(${sharedKeyMatchList.join('|')})(\_.*\.js|\.js)`)) || [];
-      if (devSharedModuleName) {
-        return wrapShare(devSharedModuleName.replace('/__overrideModule__', '').replace(/_/g, '/').replace('.js', ''), shared);
-      }
-      let [prodSharedName] = id.match(/\_\_overrideModule\_\_=[^&]+/) || [];
-      if (prodSharedName) {
-        return wrapShare(decodeURIComponent(prodSharedName.replace('__overrideModule__=', '')), shared);
-      }
-      let [devRemoteModuleName] = remotePrefixList.length && id.match(new RegExp(`\/(${remotePrefixList.join('|')})(\_.*\.js|\.js)`)) || [];
-      if (devRemoteModuleName) {
-        return wrapRemote(devRemoteModuleName.replace('/', '').replace(/_/g, '/').replace('.js', ''));
-      }
-      let [prodRemoteName] = id.match(/\_\_moduleRemote\_\_=[^&]+/) || [];
-      if (prodRemoteName) {
-        return wrapRemote(decodeURIComponent(prodRemoteName.replace('__moduleRemote__=', '')));
-      }
+      (_config$optimizeDeps = config.optimizeDeps) == null || (_config$optimizeDeps = _config$optimizeDeps.include) == null || _config$optimizeDeps.push('@module-federation/runtime');
+      // Object.keys(shared).forEach((key) => {
+      //   config.optimizeDeps?.include?.push(key);
+      // });
     }
   }];
 }