@module-federation/modern-js 0.0.0-next-20250526074234 → 0.0.0-next-20250527094526

package/dist/cjs/server/fileCache.js

@@ -0,0 +1,84 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var fileCache_exports = {};
+__export(fileCache_exports, {
+  FileCache: () => FileCache,
+  fileCache: () => fileCache
+});
+module.exports = __toCommonJS(fileCache_exports);
+var import_fs_extra = __toESM(require("fs-extra"));
+var import_lru_cache = require("lru-cache");
+class FileCache {
+  /**
+  * Check if file exists and return file info
+  * @param filepath Path to the file
+  * @returns FileResult or null if file doesn't exist
+  */
+  async getFile(filepath) {
+    if (!await import_fs_extra.default.pathExists(filepath)) {
+      return null;
+    }
+    try {
+      const stat = await import_fs_extra.default.lstat(filepath);
+      const currentModified = stat.mtimeMs;
+      const cachedEntry = this.cache.get(filepath);
+      if (cachedEntry && currentModified <= cachedEntry.lastModified) {
+        return {
+          content: cachedEntry.content,
+          lastModified: cachedEntry.lastModified
+        };
+      }
+      const content = await import_fs_extra.default.readFile(filepath, "utf-8");
+      const newEntry = {
+        content,
+        lastModified: currentModified
+      };
+      this.cache.set(filepath, newEntry, {
+        size: stat.size || content.length
+      });
+      return {
+        content,
+        lastModified: currentModified
+      };
+    } catch (err) {
+      return null;
+    }
+  }
+  constructor() {
+    this.cache = new import_lru_cache.LRUCache({
+      maxSize: 200 * 1024 * 1024
+    });
+  }
+}
+const fileCache = new FileCache();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FileCache,
+  fileCache
+});

package/dist/cjs/server/fileCache.spec.js

@@ -0,0 +1,28 @@
+"use strict";
+var import_vitest = require("vitest");
+var import_fileCache = require("./fileCache");
+(0, import_vitest.beforeAll)(() => {
+  import_vitest.vi.mock("fs-extra", () => ({
+    default: {
+      pathExists: () => {
+        return true;
+      },
+      lstat: () => {
+        return {
+          mtimeMs: Date.now(),
+          size: 4
+        };
+      },
+      readFile: () => {
+        return "test";
+      }
+    }
+  }));
+});
+(0, import_vitest.describe)("modern serve static file cache", async () => {
+  (0, import_vitest.it)("should cache file", async () => {
+    const cache = new import_fileCache.FileCache();
+    const result = await cache.getFile("test.txt");
+    (0, import_vitest.expect)(result === null || result === void 0 ? void 0 : result.content).toBe("test");
+  });
+});

package/dist/cjs/server/index.js

@@ -0,0 +1,58 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var server_exports = {};
+__export(server_exports, {
+  default: () => server_default,
+  staticServePlugin: () => staticServePlugin
+});
+module.exports = __toCommonJS(server_exports);
+var import_staticMiddleware = require("./staticMiddleware");
+const staticServePlugin = () => ({
+  name: "@modern-js/module-federation/server",
+  setup: (api) => {
+    api.onPrepare(() => {
+      var _config_output, _config_server;
+      console.log(process.env.NODE_ENV);
+      if (process.env.NODE_ENV === "development") {
+        return;
+      }
+      const { middlewares } = api.getServerContext();
+      const config = api.getServerConfig();
+      const assetPrefix = ((_config_output = config.output) === null || _config_output === void 0 ? void 0 : _config_output.assetPrefix) || "";
+      if (!((_config_server = config.server) === null || _config_server === void 0 ? void 0 : _config_server.ssr)) {
+        return;
+      }
+      const context = api.getServerContext();
+      const pwd = context.distDirectory;
+      const serverStaticMiddleware = (0, import_staticMiddleware.createStaticMiddleware)({
+        assetPrefix,
+        pwd
+      });
+      middlewares.push({
+        name: "module-federation-serve-manifest",
+        handler: serverStaticMiddleware
+      });
+    });
+  }
+});
+var server_default = staticServePlugin;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  staticServePlugin
+});

package/dist/cjs/server/staticMiddleware.js

@@ -0,0 +1,77 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var staticMiddleware_exports = {};
+__export(staticMiddleware_exports, {
+  createStaticMiddleware: () => createStaticMiddleware
+});
+module.exports = __toCommonJS(staticMiddleware_exports);
+var import_fs_extra = __toESM(require("fs-extra"));
+var import_node_path = __toESM(require("node:path"));
+var import_fileCache = require("./fileCache");
+const bundlesAssetPrefix = "/bundles";
+const removeHost = (url) => {
+  try {
+    const hasProtocol = url.includes("://");
+    const hasDomain = hasProtocol || url.startsWith("//");
+    const pathname = hasDomain ? new URL(hasProtocol ? url : `http:${url}`).pathname : url;
+    return pathname;
+  } catch (e) {
+    return url;
+  }
+};
+const createStaticMiddleware = (options) => {
+  const { assetPrefix, pwd } = options;
+  return async (c, next) => {
+    const pathname = c.req.path;
+    if (import_node_path.default.extname(pathname) !== ".js") {
+      return next();
+    }
+    const prefixWithoutHost = removeHost(assetPrefix);
+    const prefixWithBundle = import_node_path.default.join(prefixWithoutHost, bundlesAssetPrefix);
+    if (!pathname.startsWith(prefixWithBundle)) {
+      return next();
+    }
+    const pathnameWithoutPrefix = pathname.replace(prefixWithBundle, "");
+    const filepath = import_node_path.default.join(pwd, bundlesAssetPrefix, pathnameWithoutPrefix);
+    if (!await import_fs_extra.default.pathExists(filepath)) {
+      return next();
+    }
+    const fileResult = await import_fileCache.fileCache.getFile(filepath);
+    if (!fileResult) {
+      return next();
+    }
+    c.header("Content-Type", "application/javascript");
+    c.header("Content-Length", String(fileResult.content.length));
+    return c.body(fileResult.content, 200);
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createStaticMiddleware
+});

package/dist/cjs/server/staticMiddleware.spec.js

@@ -0,0 +1,185 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var import_vitest = require("vitest");
+var import_staticMiddleware = require("./staticMiddleware");
+var import_fs_extra = __toESM(require("fs-extra"));
+var import_fileCache = require("./fileCache");
+import_vitest.vi.mock("fs-extra", () => ({
+  default: {
+    pathExists: import_vitest.vi.fn()
+  }
+}));
+import_vitest.vi.mock("./fileCache", () => ({
+  fileCache: {
+    getFile: import_vitest.vi.fn()
+  }
+}));
+(0, import_vitest.describe)("staticMiddleware", () => {
+  let middleware;
+  let mockContext;
+  let nextSpy;
+  (0, import_vitest.beforeEach)(() => {
+    import_vitest.vi.clearAllMocks();
+    middleware = (0, import_staticMiddleware.createStaticMiddleware)({
+      assetPrefix: "",
+      pwd: "/test/path"
+    });
+    nextSpy = import_vitest.vi.fn();
+    mockContext = {
+      req: {
+        path: ""
+      },
+      header: import_vitest.vi.fn(),
+      body: import_vitest.vi.fn()
+    };
+  });
+  (0, import_vitest.describe)("file extension filtering", () => {
+    (0, import_vitest.it)("should call next() for non-js files", async () => {
+      mockContext.req.path = "/bundles/test.css";
+      await middleware(mockContext, nextSpy);
+      (0, import_vitest.expect)(nextSpy).toHaveBeenCalledOnce();
+      (0, import_vitest.expect)(mockContext.header).not.toHaveBeenCalled();
+      (0, import_vitest.expect)(mockContext.body).not.toHaveBeenCalled();
+    });
+    (0, import_vitest.it)("should call next() for files without extension", async () => {
+      mockContext.req.path = "/bundles/test";
+      await middleware(mockContext, nextSpy);
+      (0, import_vitest.expect)(nextSpy).toHaveBeenCalledOnce();
+      (0, import_vitest.expect)(mockContext.header).not.toHaveBeenCalled();
+      (0, import_vitest.expect)(mockContext.body).not.toHaveBeenCalled();
+    });
+    (0, import_vitest.it)("should process .js files", async () => {
+      mockContext.req.path = "/bundles/test.js";
+      import_fs_extra.default.pathExists.mockResolvedValue(false);
+      await middleware(mockContext, nextSpy);
+      (0, import_vitest.expect)(import_fs_extra.default.pathExists).toHaveBeenCalled();
+    });
+  });
+  (0, import_vitest.describe)("asset prefix filtering", () => {
+    (0, import_vitest.it)("should call next() for paths not starting with /bundles", async () => {
+      mockContext.req.path = "/assets/test.js";
+      await middleware(mockContext, nextSpy);
+      (0, import_vitest.expect)(nextSpy).toHaveBeenCalledOnce();
+      (0, import_vitest.expect)(import_fs_extra.default.pathExists).not.toHaveBeenCalled();
+      (0, import_vitest.expect)(mockContext.header).not.toHaveBeenCalled();
+      (0, import_vitest.expect)(mockContext.body).not.toHaveBeenCalled();
+    });
+    (0, import_vitest.it)("should call next() for root path", async () => {
+      mockContext.req.path = "/test.js";
+      await middleware(mockContext, nextSpy);
+      (0, import_vitest.expect)(nextSpy).toHaveBeenCalledOnce();
+      (0, import_vitest.expect)(import_fs_extra.default.pathExists).not.toHaveBeenCalled();
+    });
+    (0, import_vitest.it)("should process paths starting with /bundles", async () => {
+      mockContext.req.path = "/bundles/test.js";
+      import_fs_extra.default.pathExists.mockResolvedValue(false);
+      await middleware(mockContext, nextSpy);
+      (0, import_vitest.expect)(import_fs_extra.default.pathExists).toHaveBeenCalledWith("/test/path/bundles/test.js");
+    });
+  });
+  (0, import_vitest.describe)("file existence check", () => {
+    (0, import_vitest.it)("should call next() when file does not exist", async () => {
+      mockContext.req.path = "/bundles/nonexistent.js";
+      import_fs_extra.default.pathExists.mockResolvedValue(false);
+      await middleware(mockContext, nextSpy);
+      (0, import_vitest.expect)(import_fs_extra.default.pathExists).toHaveBeenCalledWith("/test/path/bundles/nonexistent.js");
+      (0, import_vitest.expect)(nextSpy).toHaveBeenCalledOnce();
+      (0, import_vitest.expect)(import_fileCache.fileCache.getFile).not.toHaveBeenCalled();
+      (0, import_vitest.expect)(mockContext.header).not.toHaveBeenCalled();
+      (0, import_vitest.expect)(mockContext.body).not.toHaveBeenCalled();
+    });
+    (0, import_vitest.it)("should proceed to file cache when file exists", async () => {
+      mockContext.req.path = "/bundles/existing.js";
+      import_fs_extra.default.pathExists.mockResolvedValue(true);
+      import_fileCache.fileCache.getFile.mockResolvedValue(null);
+      await middleware(mockContext, nextSpy);
+      (0, import_vitest.expect)(import_fs_extra.default.pathExists).toHaveBeenCalledWith("/test/path/bundles/existing.js");
+      (0, import_vitest.expect)(import_fileCache.fileCache.getFile).toHaveBeenCalledWith("/test/path/bundles/existing.js");
+    });
+  });
+  (0, import_vitest.describe)("successful file serving", () => {
+    (0, import_vitest.it)("should serve file content with correct headers", async () => {
+      const mockFileContent = 'console.log("test");';
+      const mockFileResult = {
+        content: mockFileContent,
+        lastModified: Date.now()
+      };
+      mockContext.req.path = "/bundles/app.js";
+      import_fs_extra.default.pathExists.mockResolvedValue(true);
+      import_fileCache.fileCache.getFile.mockResolvedValue(mockFileResult);
+      mockContext.body.mockReturnValue("response");
+      const result = await middleware(mockContext, nextSpy);
+      (0, import_vitest.expect)(import_fs_extra.default.pathExists).toHaveBeenCalledWith("/test/path/bundles/app.js");
+      (0, import_vitest.expect)(import_fileCache.fileCache.getFile).toHaveBeenCalledWith("/test/path/bundles/app.js");
+      (0, import_vitest.expect)(nextSpy).not.toHaveBeenCalled();
+      (0, import_vitest.expect)(mockContext.header).toHaveBeenCalledWith("Content-Type", "application/javascript");
+      (0, import_vitest.expect)(mockContext.header).toHaveBeenCalledWith("Content-Length", String(mockFileResult.content.length));
+      (0, import_vitest.expect)(mockContext.body).toHaveBeenCalledWith(mockFileResult.content, 200);
+      (0, import_vitest.expect)(result).toBe("response");
+    });
+    (0, import_vitest.it)("should handle empty file content", async () => {
+      const mockFileResult = {
+        content: "",
+        lastModified: Date.now()
+      };
+      mockContext.req.path = "/bundles/empty.js";
+      import_fs_extra.default.pathExists.mockResolvedValue(true);
+      import_fileCache.fileCache.getFile.mockResolvedValue(mockFileResult);
+      mockContext.body.mockReturnValue("empty-response");
+      const result = await middleware(mockContext, nextSpy);
+      (0, import_vitest.expect)(mockContext.header).toHaveBeenCalledWith("Content-Length", "0");
+      (0, import_vitest.expect)(mockContext.body).toHaveBeenCalledWith(mockFileResult.content, 200);
+      (0, import_vitest.expect)(result).toBe("empty-response");
+      (0, import_vitest.expect)(nextSpy).not.toHaveBeenCalled();
+    });
+  });
+  (0, import_vitest.describe)("asset prefix handling", () => {
+    (0, import_vitest.it)("should handle custom asset prefix correctly", async () => {
+      const customMiddleware = (0, import_staticMiddleware.createStaticMiddleware)({
+        assetPrefix: "/custom-prefix",
+        pwd: "/test/path"
+      });
+      mockContext.req.path = "/bundles/test.js";
+      await customMiddleware(mockContext, nextSpy);
+      (0, import_vitest.expect)(nextSpy).toHaveBeenCalledOnce();
+      (0, import_vitest.expect)(mockContext.header).not.toHaveBeenCalled();
+      (0, import_vitest.expect)(mockContext.body).not.toHaveBeenCalled();
+    });
+    (0, import_vitest.it)("should handle asset prefix removal correctly", async () => {
+      const customMiddleware = (0, import_staticMiddleware.createStaticMiddleware)({
+        assetPrefix: "/prefix",
+        pwd: "/test/path"
+      });
+      const mockFileResult = {
+        content: "test content",
+        lastModified: Date.now()
+      };
+      mockContext.req.path = "/prefix/bundles/test.js";
+      import_fs_extra.default.pathExists.mockResolvedValue(true);
+      import_fileCache.fileCache.getFile.mockResolvedValue(mockFileResult);
+      await customMiddleware(mockContext, nextSpy);
+      (0, import_vitest.expect)(import_fs_extra.default.pathExists).toHaveBeenCalledWith("/test/path/bundles/test.js");
+    });
+  });
+});

package/dist/cjs/{interfaces/global.js → ssr-runtime/index.js}

@@ -11,6 +11,12 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var global_exports = {};
-module.exports = __toCommonJS(global_exports);
+var ssr_runtime_exports = {};
+module.exports = __toCommonJS(ssr_runtime_exports);
+__reExport(ssr_runtime_exports, require("./plugin"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./plugin")
+});

package/dist/cjs/ssr-runtime/{devPlugin.js → plugin.js}

@@ -26,15 +26,14 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var devPlugin_exports = {};
-__export(devPlugin_exports, {
-  mfSSRDevPlugin: () => mfSSRDevPlugin
+var plugin_exports = {};
+__export(plugin_exports, {
+  mfSSRPlugin: () => mfSSRPlugin
 });
-module.exports = __toCommonJS(devPlugin_exports);
+module.exports = __toCommonJS(plugin_exports);
 var import_jsx_runtime = require("react/jsx-runtime");
 var import_SSRLiveReload = require("./SSRLiveReload");
-var import_utils = require("../utils");
-const mfSSRDevPlugin = () => ({
+const mfSSRPlugin = () => ({
   name: "@module-federation/modern-js",
   setup: (api) => {
     api.onBeforeRender(async () => {
@@ -44,11 +43,9 @@ const mfSSRDevPlugin = () => ({
       globalThis.shouldUpdate = false;
       const nodeUtils = await Promise.resolve().then(() => __toESM(require("@module-federation/node/utils")));
       const shouldUpdate = await nodeUtils.revalidate();
-      console.log("shouldUpdate: ", shouldUpdate);
       if (shouldUpdate) {
         console.log("should RELOAD", shouldUpdate);
         await nodeUtils.flushChunks();
-        (0, import_utils.flushDataFetch)();
         globalThis.shouldUpdate = true;
       }
     });
@@ -67,5 +64,5 @@ const mfSSRDevPlugin = () => ({
 });
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  mfSSRDevPlugin
+  mfSSRPlugin
 });

package/dist/esm/cli/configPlugin.js

@@ -9,10 +9,10 @@ import { getIPV4, isWebTarget, skipByTarget } from "./utils";
 import { encodeName } from "@module-federation/sdk";
 import { bundle } from "@modern-js/node-bundle-require";
 import { LOCALHOST, PLUGIN_IDENTIFIER } from "../constant";
-import { autoDeleteSplitChunkCacheGroups, addDataFetchExposes } from "@module-federation/rsbuild-plugin/utils";
-import logger from "../logger";
-import { isDev } from "./utils";
+import { autoDeleteSplitChunkCacheGroups } from "@module-federation/rsbuild-plugin/utils";
+import logger from "./logger";
 var defaultPath = path.resolve(process.cwd(), "module-federation.config.ts");
+var isDev = process.env.NODE_ENV === "development";
 function setEnv(enableSSR) {
   if (enableSSR) {
     process.env["MF_DISABLE_EMIT_STATS"] = "true";
@@ -128,7 +128,6 @@ var patchDTSConfig = function(mfConfig, isServer) {
 };
 var patchMFConfig = function(mfConfig, isServer, remoteIpStrategy) {
   replaceRemoteUrl(mfConfig, remoteIpStrategy);
-  addDataFetchExposes(mfConfig.exposes, isServer);
   if (mfConfig.remoteType === void 0) {
     mfConfig.remoteType = "script";
   }
@@ -138,13 +137,12 @@ var patchMFConfig = function(mfConfig, isServer, remoteIpStrategy) {
   var runtimePlugins = _to_consumable_array(mfConfig.runtimePlugins || []);
   patchDTSConfig(mfConfig, isServer);
   injectRuntimePlugins(require.resolve("@module-federation/modern-js/shared-strategy"), runtimePlugins);
-  injectRuntimePlugins(require.resolve("@module-federation/modern-js/auto-fetch-data"), runtimePlugins);
-  if (isDev()) {
+  if (isDev) {
     injectRuntimePlugins(require.resolve("@module-federation/modern-js/resolve-entry-ipv4"), runtimePlugins);
   }
   if (isServer) {
     injectRuntimePlugins(require.resolve("@module-federation/node/runtimePlugin"), runtimePlugins);
-    if (isDev()) {
+    if (isDev) {
       injectRuntimePlugins(require.resolve("@module-federation/node/record-dynamic-remote-entry-hash-plugin"), runtimePlugins);
     }
     injectRuntimePlugins(require.resolve("@module-federation/modern-js/inject-node-fetch"), runtimePlugins);
@@ -242,7 +240,7 @@ function patchBundlerConfig(options) {
     splitChunkConfig.chunks = "async";
     logger.warn('splitChunks.chunks = async is not allowed with stream SSR mode, it will auto changed to "async"');
   }
-  if (isDev() && chain.output.get("publicPath") === "auto") {
+  if (isDev && chain.output.get("publicPath") === "auto") {
     var _modernjsConfig_dev, _modernjsConfig_server;
     var port = ((_modernjsConfig_dev = modernjsConfig.dev) === null || _modernjsConfig_dev === void 0 ? void 0 : _modernjsConfig_dev.port) || ((_modernjsConfig_server = modernjsConfig.server) === null || _modernjsConfig_server === void 0 ? void 0 : _modernjsConfig_server.port) || 8080;
     var publicPath = "http://localhost:".concat(port, "/");
@@ -256,7 +254,7 @@ function patchBundlerConfig(options) {
       chain.output.chunkFilename(chunkFileName.replace(".js", suffix));
     }
   }
-  if (isDev() && enableSSR && !isServer) {
+  if (isDev && enableSSR && !isServer) {
     chain.resolve.fallback.set("crypto", false).set("stream", false).set("vm", false);
   }
   if (((_modernjsConfig_deploy = modernjsConfig.deploy) === null || _modernjsConfig_deploy === void 0 ? void 0 : _modernjsConfig_deploy.microFrontend) && Object.keys(mfConfig.exposes || {}).length) {

package/dist/esm/cli/configPlugin.spec.js

@@ -43,7 +43,6 @@ describe("patchMFConfig", /* @__PURE__ */ _async_to_generator(function() {
           remoteType: "script",
           runtimePlugins: [
             require.resolve("@module-federation/modern-js/shared-strategy"),
-            require.resolve("@module-federation/modern-js/auto-fetch-data"),
             require.resolve("@module-federation/node/runtimePlugin"),
             require.resolve("@module-federation/modern-js/inject-node-fetch")
           ],
@@ -77,8 +76,7 @@ describe("patchMFConfig", /* @__PURE__ */ _async_to_generator(function() {
           },
           remoteType: "script",
           runtimePlugins: [
-            require.resolve("@module-federation/modern-js/shared-strategy"),
-            require.resolve("@module-federation/modern-js/auto-fetch-data")
+            require.resolve("@module-federation/modern-js/shared-strategy")
           ],
           shared: {
             react: {

package/dist/esm/cli/constant.js

@@ -0,0 +1,4 @@
+var isDev = process.env.NODE_ENV === "development";
+export {
+  isDev
+};

package/dist/esm/cli/index.js

@@ -8,7 +8,6 @@ import { moduleFederationSSRPlugin } from "./ssrPlugin";
 import { isWebTarget } from "./utils";
 var moduleFederationPlugin = function() {
   var userConfig = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
-  var _userConfig_fetchServerQuery;
   var internalModernPluginOptions = {
     csrConfig: void 0,
     ssrConfig: void 0,
@@ -17,8 +16,7 @@ var moduleFederationPlugin = function() {
     distOutputDir: "",
     originPluginOptions: userConfig,
     remoteIpStrategy: userConfig === null || userConfig === void 0 ? void 0 : userConfig.remoteIpStrategy,
-    userConfig: userConfig || {},
-    fetchServerQuery: (_userConfig_fetchServerQuery = userConfig.fetchServerQuery) !== null && _userConfig_fetchServerQuery !== void 0 ? _userConfig_fetchServerQuery : void 0
+    userConfig: userConfig || {}
   };
   return {
     name: "@modern-js/plugin-module-federation",
@@ -57,6 +55,15 @@ var moduleFederationPlugin = function() {
               }
             }
           });
+          api._internalServerPlugins(function(param) {
+            var plugins = param.plugins;
+            plugins.push({
+              name: "@module-federation/modern-js/server"
+            });
+            return {
+              plugins
+            };
+          });
           return [
             2
           ];

package/dist/esm/{logger.js → cli/logger.js}

@@ -1,5 +1,5 @@
 import { createLogger } from "@module-federation/sdk";
-import { PLUGIN_IDENTIFIER } from "./constant";
+import { PLUGIN_IDENTIFIER } from "../constant";
 var logger = createLogger(PLUGIN_IDENTIFIER);
 var logger_default = logger;
 export {

package/dist/esm/cli/manifest.js

@@ -1,5 +1,5 @@
 import path from "path";
-import { fs } from "@modern-js/utils";
+import fs from "fs-extra";
 function mergeStats(browserStats, nodeStats) {
   var ssrRemoteEntry = nodeStats.metaData.remoteEntry;
   browserStats.metaData.ssrRemoteEntry = ssrRemoteEntry;