@module-federation/modern-js 0.14.3 → 0.16.0

package/dist/cjs/ssr-runtime/injectDataFetchFunctionPlugin.js

@@ -0,0 +1,136 @@
+"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 injectDataFetchFunctionPlugin_exports = {};
+__export(injectDataFetchFunctionPlugin_exports, {
+  injectDataFetchFunctionPlugin: () => injectDataFetchFunctionPlugin,
+  setSSREnv: () => setSSREnv
+});
+module.exports = __toCommonJS(injectDataFetchFunctionPlugin_exports);
+var import_constant = require("../constant");
+var import_logger = __toESM(require("../logger"));
+var import_utils = require("../utils");
+var import_downgrade = require("./downgrade");
+function setSSREnv({ fetchServerQuery }) {
+  globalThis.FEDERATION_SSR = true;
+  globalThis.FEDERATION_SERVER_QUERY = fetchServerQuery;
+}
+const injectDataFetchFunctionPlugin = ({ fetchServerQuery }) => ({
+  name: "@module-federation/inject-data-fetch-function-plugin",
+  setup: (api) => {
+    api.onBeforeRender(async () => {
+      var _globalThis, _DATA_FETCH_FUNCTION;
+      setSSREnv({
+        fetchServerQuery
+      });
+      if (typeof window === "undefined") {
+        return;
+      }
+      const dataFetchFunction = async function(options) {
+        const [id, data, downgrade] = options;
+        import_logger.default.debug("==========call data fetch function!");
+        if (data) {
+          if (!id) {
+            throw new Error("id is required!");
+          }
+          if (!(0, import_utils.getDataFetchMap)()) {
+            (0, import_utils.initDataFetchMap)();
+          }
+          const dataFetchItem = (0, import_utils.getDataFetchItem)(id);
+          if (dataFetchItem) {
+            var _dataFetchItem__, _dataFetchItem_;
+            (_dataFetchItem_ = dataFetchItem[1]) === null || _dataFetchItem_ === void 0 ? void 0 : (_dataFetchItem__ = _dataFetchItem_[1]) === null || _dataFetchItem__ === void 0 ? void 0 : _dataFetchItem__.call(_dataFetchItem_, data);
+            dataFetchItem[2] = import_constant.MF_DATA_FETCH_STATUS.LOADED;
+            return;
+          }
+          if (!dataFetchItem) {
+            const dataFetchMap = (0, import_utils.getDataFetchMap)();
+            let res;
+            let rej;
+            const p = new Promise((resolve, reject) => {
+              res = resolve;
+              rej = reject;
+            });
+            dataFetchMap[id] = [
+              [
+                async () => async () => {
+                  return "";
+                },
+                import_constant.MF_DATA_FETCH_TYPE.FETCH_SERVER
+              ],
+              [
+                p,
+                res,
+                rej
+              ],
+              import_constant.MF_DATA_FETCH_STATUS.LOADED
+            ];
+            res(data);
+            return;
+          }
+        }
+        if (downgrade) {
+          const mfDowngrade2 = (0, import_downgrade.getDowngradeTag)();
+          if (!mfDowngrade2) {
+            globalThis[import_constant.DOWNGRADE_KEY] = id ? [
+              id
+            ] : true;
+          } else if (Array.isArray(mfDowngrade2) && id && !mfDowngrade2.includes(id)) {
+            mfDowngrade2.push(id);
+          }
+        }
+        const mfDowngrade = (0, import_downgrade.getDowngradeTag)();
+        if (typeof mfDowngrade === "boolean") {
+          return (0, import_downgrade.callAllDowngrade)();
+        }
+        if (Array.isArray(mfDowngrade)) {
+          if (!id) {
+            globalThis[import_constant.DOWNGRADE_KEY] = true;
+            return (0, import_downgrade.callAllDowngrade)();
+          }
+          if (!mfDowngrade.includes(id)) {
+            mfDowngrade.push(id);
+          }
+          return (0, import_downgrade.callDowngrade)(id);
+        }
+      };
+      globalThis[import_constant.FS_HREF] = window.location.href;
+      (_globalThis = globalThis)[_DATA_FETCH_FUNCTION = import_constant.DATA_FETCH_FUNCTION] || (_globalThis[_DATA_FETCH_FUNCTION] = []);
+      const dataFetch = globalThis[import_constant.DATA_FETCH_FUNCTION];
+      await Promise.all(dataFetch.map(async (options) => {
+        await dataFetchFunction(options);
+      }));
+      dataFetch.push = dataFetchFunction;
+    });
+  }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  injectDataFetchFunctionPlugin,
+  setSSREnv
+});

package/dist/cjs/utils/dataFetch.js

@@ -0,0 +1,211 @@
+"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 dataFetch_exports = {};
+__export(dataFetch_exports, {
+  fetchData: () => fetchData,
+  flushDataFetch: () => flushDataFetch,
+  getDataFetchIdWithErrorMsgs: () => getDataFetchIdWithErrorMsgs,
+  getDataFetchInfo: () => getDataFetchInfo,
+  getDataFetchItem: () => getDataFetchItem,
+  getDataFetchMap: () => getDataFetchMap,
+  getDataFetchMapKey: () => getDataFetchMapKey,
+  initDataFetchMap: () => initDataFetchMap,
+  isDataLoaderExpose: () => isDataLoaderExpose,
+  loadDataFetchModule: () => loadDataFetchModule,
+  setDataFetchItemLoadedStatus: () => setDataFetchItemLoadedStatus,
+  wrapDataFetchId: () => wrapDataFetchId
+});
+module.exports = __toCommonJS(dataFetch_exports);
+var import_sdk = require("@module-federation/sdk");
+var import_utils = require("../utils");
+var import_logger = __toESM(require("../logger"));
+var import_downgrade = require("../ssr-runtime/downgrade");
+var import_constant = require("../constant");
+var import_constant2 = require("@module-federation/rsbuild-plugin/constant");
+const getDataFetchInfo = ({ name, alias, id, remoteSnapshot }) => {
+  if (!remoteSnapshot) {
+    return;
+  }
+  if (!("modules" in remoteSnapshot)) {
+    return;
+  }
+  const regex = new RegExp(`^${name}(/[^/].*|)$`);
+  const nameOrAlias = regex.test(id) ? name : alias || name;
+  const expose = id.replace(nameOrAlias, "");
+  let dataFetchName = "";
+  let dataFetchId = "";
+  if (expose.startsWith("/")) {
+    dataFetchName = `${expose.slice(1)}.${import_constant2.DATA_FETCH_IDENTIFIER}`;
+    dataFetchId = `${id}.${import_constant2.DATA_FETCH_IDENTIFIER}`;
+  } else if (expose === "") {
+    dataFetchName = import_constant2.DATA_FETCH_IDENTIFIER;
+    dataFetchId = `${id}/${import_constant2.DATA_FETCH_IDENTIFIER}`;
+  } else {
+    return;
+  }
+  if (!dataFetchName || !dataFetchId) {
+    return;
+  }
+  if (!remoteSnapshot.modules.find((module2) => module2.moduleName === dataFetchName)) {
+    return;
+  }
+  return {
+    dataFetchName,
+    dataFetchId
+  };
+};
+function initDataFetchMap() {
+  var _globalThis;
+  (_globalThis = globalThis).__MF_DATA_FETCH_MAP__ || (_globalThis.__MF_DATA_FETCH_MAP__ = {});
+}
+function getDataFetchItem(id) {
+  var _globalThis___MF_DATA_FETCH_MAP__;
+  return (_globalThis___MF_DATA_FETCH_MAP__ = globalThis.__MF_DATA_FETCH_MAP__) === null || _globalThis___MF_DATA_FETCH_MAP__ === void 0 ? void 0 : _globalThis___MF_DATA_FETCH_MAP__[id];
+}
+function getDataFetchMap() {
+  return globalThis.__MF_DATA_FETCH_MAP__;
+}
+const flushDataFetch = () => {
+  globalThis.__MF_DATA_FETCH_MAP__ = {};
+  globalThis[import_constant.DOWNGRADE_KEY] = void 0;
+};
+function setDataFetchItemLoadedStatus(id) {
+  const dataFetchItem = getDataFetchItem(id);
+  if (!dataFetchItem) {
+    return;
+  }
+  dataFetchItem[2] = import_constant.MF_DATA_FETCH_STATUS.LOADED;
+}
+const wrapDataFetchId = (id) => {
+  return `${import_constant.WRAP_DATA_FETCH_ID_IDENTIFIER}${id}${import_constant.WRAP_DATA_FETCH_ID_IDENTIFIER}`;
+};
+const getDataFetchIdWithErrorMsgs = (errMsgs) => {
+  const firstIdentifierIndex = errMsgs.indexOf(import_constant.WRAP_DATA_FETCH_ID_IDENTIFIER);
+  if (firstIdentifierIndex === -1) {
+    return void 0;
+  }
+  const secondIdentifierIndex = errMsgs.indexOf(import_constant.WRAP_DATA_FETCH_ID_IDENTIFIER, firstIdentifierIndex + import_constant.WRAP_DATA_FETCH_ID_IDENTIFIER.length);
+  if (secondIdentifierIndex === -1) {
+    return void 0;
+  }
+  return errMsgs.substring(firstIdentifierIndex + import_constant.WRAP_DATA_FETCH_ID_IDENTIFIER.length, secondIdentifierIndex);
+};
+async function fetchData(id, params, remoteInfo) {
+  const callFetchData = async () => {
+    const item = getDataFetchItem(id);
+    if (!item) {
+      return;
+    }
+    const [fetchDataFnArr, ..._rest] = item;
+    const fetchDataFn = await fetchDataFnArr[2];
+    if (!fetchDataFn) {
+      return;
+    }
+    return fetchDataFn(params);
+  };
+  if ((0, import_sdk.isBrowserEnv)()) {
+    var _dataFetchItem_;
+    const dataFetchItem = getDataFetchItem(id);
+    if (!dataFetchItem) {
+      throw new Error(`dataFetchItem not found, id: ${id}`);
+    }
+    if ((_dataFetchItem_ = dataFetchItem[1]) === null || _dataFetchItem_ === void 0 ? void 0 : _dataFetchItem_[0]) {
+      return dataFetchItem[1][0];
+    }
+    if ((0, import_utils.isCSROnly)()) {
+      import_logger.default.debug("==========csr only!");
+      return callFetchData();
+    }
+    if (remoteInfo) {
+      return (0, import_downgrade.callDowngrade)(id, params, remoteInfo);
+    }
+    const mfDowngrade = (0, import_downgrade.getDowngradeTag)();
+    if (mfDowngrade) {
+      if (typeof mfDowngrade === "boolean") {
+        return (0, import_downgrade.callDowngrade)(id, {
+          ...params,
+          isDowngrade: true
+        });
+      }
+      if (mfDowngrade.includes(id)) {
+        return (0, import_downgrade.callDowngrade)(id, {
+          ...params,
+          isDowngrade: true
+        });
+      }
+    }
+    let res;
+    let rej;
+    const p = new Promise((resolve, reject) => {
+      res = resolve;
+      rej = reject;
+    });
+    dataFetchItem[1] = [
+      p,
+      res,
+      rej
+    ];
+    dataFetchItem[2] = import_constant.MF_DATA_FETCH_STATUS.AWAIT;
+    return dataFetchItem[1][0];
+  }
+  return callFetchData();
+}
+function getDataFetchMapKey(dataFetchInfo, hostInfo) {
+  if (!dataFetchInfo || !hostInfo) {
+    return;
+  }
+  const { dataFetchId } = dataFetchInfo;
+  return (0, import_sdk.composeKeyWithSeparator)(dataFetchId, hostInfo.name, hostInfo.version);
+}
+async function loadDataFetchModule(instance, id) {
+  return instance.loadRemote(id).then((m) => {
+    if (m && typeof m === "object" && "fetchData" in m && typeof m.fetchData === "function") {
+      return m.fetchData;
+    }
+    throw new Error(`fetchData not found in remote ${id}, ${JSON.stringify(m)}`);
+  });
+}
+function isDataLoaderExpose(exposeKey) {
+  return exposeKey.endsWith(import_constant2.DATA_FETCH_IDENTIFIER) || exposeKey.endsWith(import_constant2.DATA_FETCH_CLIENT_SUFFIX);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  fetchData,
+  flushDataFetch,
+  getDataFetchIdWithErrorMsgs,
+  getDataFetchInfo,
+  getDataFetchItem,
+  getDataFetchMap,
+  getDataFetchMapKey,
+  initDataFetchMap,
+  isDataLoaderExpose,
+  loadDataFetchModule,
+  setDataFetchItemLoadedStatus,
+  wrapDataFetchId
+});

package/dist/cjs/utils/index.js

@@ -0,0 +1,54 @@
+"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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var utils_exports = {};
+__export(utils_exports, {
+  getLoadedRemoteInfos: () => getLoadedRemoteInfos,
+  isCSROnly: () => isCSROnly
+});
+module.exports = __toCommonJS(utils_exports);
+__reExport(utils_exports, require("./dataFetch"), module.exports);
+function getLoadedRemoteInfos(id, instance) {
+  if (!instance) {
+    return;
+  }
+  const { name, expose } = instance.remoteHandler.idToRemoteMap[id] || {};
+  if (!name) {
+    return;
+  }
+  const module2 = instance.moduleCache.get(name);
+  if (!module2) {
+    return;
+  }
+  const { remoteSnapshot } = instance.snapshotHandler.getGlobalRemoteInfo(module2.remoteInfo);
+  return {
+    ...module2.remoteInfo,
+    snapshot: remoteSnapshot,
+    expose
+  };
+}
+function isCSROnly() {
+  return window._SSR_DATA === void 0;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getLoadedRemoteInfos,
+  isCSROnly,
+  ...require("./dataFetch")
+});

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 } from "@module-federation/rsbuild-plugin/utils";
-import logger from "./logger";
+import { autoDeleteSplitChunkCacheGroups, addDataFetchExposes } from "@module-federation/rsbuild-plugin/utils";
+import logger from "../logger";
+import { isDev } from "./utils";
 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";
@@ -126,8 +126,9 @@ var patchDTSConfig = function(mfConfig, isServer) {
     }
   }
 };
-var patchMFConfig = function(mfConfig, isServer, remoteIpStrategy) {
+var patchMFConfig = function(mfConfig, isServer, remoteIpStrategy, enableSSR) {
   replaceRemoteUrl(mfConfig, remoteIpStrategy);
+  addDataFetchExposes(mfConfig.exposes, isServer);
   if (mfConfig.remoteType === void 0) {
     mfConfig.remoteType = "script";
   }
@@ -137,12 +138,13 @@ 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);
-  if (isDev) {
+  injectRuntimePlugins(require.resolve("@module-federation/modern-js/auto-fetch-data"), runtimePlugins);
+  if (enableSSR && 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);
@@ -240,7 +242,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, "/");
@@ -250,11 +252,11 @@ function patchBundlerConfig(options) {
     var uniqueName = mfConfig.name || chain.output.get("uniqueName");
     var chunkFileName = chain.output.get("chunkFilename");
     if (typeof chunkFileName === "string" && uniqueName && !chunkFileName.includes(uniqueName)) {
-      var suffix = "".concat(encodeName(uniqueName), "-[chunkhash].js");
+      var suffix = "".concat(encodeName(uniqueName), "-[contenthash].js");
       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) {
@@ -296,9 +298,8 @@ var moduleFederationConfigPlugin = function(userConfig) {
                 var isWeb = isWebTarget(target);
                 addMyTypes2Ignored(chain, !isWeb ? ssrConfig : csrConfig);
                 var targetMFConfig = !isWeb ? ssrConfig : csrConfig;
-                patchMFConfig(targetMFConfig, !isWeb, userConfig.remoteIpStrategy || "ipv4");
+                patchMFConfig(targetMFConfig, !isWeb, userConfig.remoteIpStrategy || "ipv4", enableSSR);
                 patchBundlerConfig({
-                  // @ts-expect-error chain type is not correct
                   chain,
                   isServer: !isWeb,
                   modernjsConfig,
@@ -335,6 +336,12 @@ var moduleFederationConfigPlugin = function(userConfig) {
                   "Access-Control-Allow-Methods": "GET, POST, PUT, DELETE, PATCH, OPTIONS",
                   "Access-Control-Allow-Headers": "*"
                 } : void 0;
+                var defineConfig = {
+                  REMOTE_IP_STRATEGY: JSON.stringify(userConfig.remoteIpStrategy)
+                };
+                if (enableSSR && isDev()) {
+                  defineConfig["FEDERATION_IPV4"] = JSON.stringify(ipv4);
+                }
                 var _modernjsConfig_source_enableAsyncEntry;
                 return {
                   tools: {
@@ -347,10 +354,7 @@ var moduleFederationConfigPlugin = function(userConfig) {
                       // TODO: deprecated
                       "@modern-js/runtime/mf": require.resolve("@module-federation/modern-js/runtime")
                     },
-                    define: {
-                      FEDERATION_IPV4: JSON.stringify(ipv4),
-                      REMOTE_IP_STRATEGY: JSON.stringify(userConfig.remoteIpStrategy)
-                    },
+                    define: defineConfig,
                     enableAsyncEntry: bundlerType === "rspack" ? (_modernjsConfig_source_enableAsyncEntry = (_modernjsConfig_source = modernjsConfig.source) === null || _modernjsConfig_source === void 0 ? void 0 : _modernjsConfig_source.enableAsyncEntry) !== null && _modernjsConfig_source_enableAsyncEntry !== void 0 ? _modernjsConfig_source_enableAsyncEntry : true : (_modernjsConfig_source1 = modernjsConfig.source) === null || _modernjsConfig_source1 === void 0 ? void 0 : _modernjsConfig_source1.enableAsyncEntry
                   },
                   dev: {

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

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

package/dist/esm/cli/index.js

@@ -8,6 +8,7 @@ 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,
@@ -16,7 +17,8 @@ var moduleFederationPlugin = function() {
     distOutputDir: "",
     originPluginOptions: userConfig,
     remoteIpStrategy: userConfig === null || userConfig === void 0 ? void 0 : userConfig.remoteIpStrategy,
-    userConfig: userConfig || {}
+    userConfig: userConfig || {},
+    fetchServerQuery: (_userConfig_fetchServerQuery = userConfig.fetchServerQuery) !== null && _userConfig_fetchServerQuery !== void 0 ? _userConfig_fetchServerQuery : void 0
   };
   return {
     name: "@modern-js/plugin-module-federation",

package/dist/esm/cli/mfRuntimePlugins/auto-fetch-data.js

@@ -0,0 +1,76 @@
+import { getDataFetchInfo, initDataFetchMap, getDataFetchItem, getDataFetchMap, isCSROnly } from "../../utils";
+import logger from "../../logger";
+import { getDataFetchMapKey, isDataLoaderExpose, loadDataFetchModule } from "../../utils/dataFetch";
+import { MF_DATA_FETCH_TYPE, MF_DATA_FETCH_STATUS } from "../../constant";
+import { DATA_FETCH_CLIENT_SUFFIX } from "@module-federation/rsbuild-plugin/constant";
+var autoFetchData = function() {
+  return {
+    name: "auto-fetch-data-plugin",
+    beforeInit: function beforeInit(args) {
+      initDataFetchMap();
+      return args;
+    },
+    afterLoadSnapshot: function afterLoadSnapshot(args) {
+      var id = args.id, moduleInfo = args.moduleInfo, remoteSnapshot = args.remoteSnapshot, host = args.host;
+      if (typeof id === "string" && isDataLoaderExpose(id)) {
+        return args;
+      }
+      if (!remoteSnapshot || !id || !("modules" in remoteSnapshot)) {
+        return args;
+      }
+      var name = moduleInfo.name, alias = moduleInfo.alias;
+      var dataFetchInfo = getDataFetchInfo({
+        name,
+        alias,
+        id,
+        remoteSnapshot
+      });
+      if (!dataFetchInfo) {
+        return args;
+      }
+      var dataFetchId = dataFetchInfo.dataFetchId, dataFetchName = dataFetchInfo.dataFetchName;
+      var dataFetchMapKey = getDataFetchMapKey(dataFetchInfo, {
+        name: host.name,
+        version: host.options.version
+      });
+      logger.debug("======= auto fetch plugin dataFetchMapKey: ", dataFetchMapKey);
+      if (!dataFetchMapKey) {
+        return args;
+      }
+      var dataFetchItem = getDataFetchItem(dataFetchMapKey);
+      if (dataFetchItem) {
+        return args;
+      }
+      var dataFetchMap = getDataFetchMap();
+      var hasSSRAsset = Boolean(remoteSnapshot.ssrRemoteEntry);
+      var hasDataFetchClient = Boolean(remoteSnapshot.modules.find(function(module) {
+        return module.moduleName === "".concat(dataFetchName).concat(DATA_FETCH_CLIENT_SUFFIX);
+      }));
+      var downgradeType = hasDataFetchClient ? MF_DATA_FETCH_TYPE.FETCH_CLIENT : hasSSRAsset ? MF_DATA_FETCH_TYPE.FETCH_SERVER : MF_DATA_FETCH_TYPE.FETCH_CLIENT;
+      var finalDataFetchId = dataFetchId;
+      if (typeof window !== "undefined") {
+        finalDataFetchId = downgradeType === MF_DATA_FETCH_TYPE.FETCH_CLIENT ? hasDataFetchClient ? "".concat(dataFetchId).concat(DATA_FETCH_CLIENT_SUFFIX) : dataFetchId : dataFetchId;
+      }
+      var getDataFetchGetter = function() {
+        return loadDataFetchModule(host, finalDataFetchId);
+      };
+      var dataFetchFnItem = [
+        getDataFetchGetter,
+        downgradeType
+      ];
+      if (typeof window === "undefined" || isCSROnly()) {
+        dataFetchFnItem.push(getDataFetchGetter());
+      }
+      dataFetchMap[dataFetchMapKey] = [
+        dataFetchFnItem,
+        void 0,
+        MF_DATA_FETCH_STATUS.AWAIT
+      ];
+      return args;
+    }
+  };
+};
+var auto_fetch_data_default = autoFetchData;
+export {
+  auto_fetch_data_default as default
+};