@module-federation/modern-js 0.0.0-next-20250708134245 → 0.0.0-next-20250709032753

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

@@ -138,6 +138,7 @@ var patchMFConfig = function(mfConfig, isServer, remoteIpStrategy, enableSSR) {
   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 (enableSSR && isDev()) {
     injectRuntimePlugins(require.resolve("@module-federation/modern-js/resolve-entry-ipv4"), runtimePlugins);
   }

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")
           ],
@@ -77,7 +78,7 @@ describe("patchMFConfig", /* @__PURE__ */ _async_to_generator(function() {
           remoteType: "script",
           runtimePlugins: [
             require.resolve("@module-federation/modern-js/shared-strategy"),
-            require.resolve("@module-federation/bridge-react/lazy-load-component-plugin")
+            require.resolve("@module-federation/modern-js/auto-fetch-data")
           ],
           shared: {
             react: {

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
+};

package/dist/esm/cli/server/data-fetch-server-plugin.js

@@ -1,4 +1,221 @@
-import dataFetchMiddleWare from "@module-federation/bridge-react/data-fetch-server-middleware";
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _object_spread } from "@swc/helpers/_/_object_spread";
+import { _ as _object_spread_props } from "@swc/helpers/_/_object_spread_props";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
+import { DATA_FETCH_QUERY, MF_DATA_FETCH_STATUS } from "../../constant";
+import logger from "../../logger";
+import { getDataFetchMap } from "../../utils";
+import { fetchData, initDataFetchMap, loadDataFetchModule } from "../../utils/dataFetch";
+import { SEPARATOR, MANIFEST_EXT } from "@module-federation/sdk";
+function wrapSetTimeout(targetPromise) {
+  var delay = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 2e4, id = arguments.length > 2 ? arguments[2] : void 0;
+  if (targetPromise && typeof targetPromise.then === "function") {
+    return new Promise(function(resolve, reject) {
+      var timeoutId = setTimeout(function() {
+        logger.warn("Data fetch for ID ".concat(id, " timed out after 20 seconds."));
+        reject(new Error("Data fetch for ID ".concat(id, " timed out after 20 seconds")));
+      }, delay);
+      targetPromise.then(function(value) {
+        clearTimeout(timeoutId);
+        resolve(value);
+      }).catch(function(err) {
+        clearTimeout(timeoutId);
+        reject(err);
+      });
+    });
+  }
+}
+function addProtocol(url) {
+  if (url.startsWith("//")) {
+    return "https:" + url;
+  }
+  return url;
+}
+var getDecodeQuery = function(url, name) {
+  var res = url.searchParams.get(name);
+  if (!res) {
+    return null;
+  }
+  return decodeURIComponent(res);
+};
+var middleware = function() {
+  var _ref = _async_to_generator(function(ctx, next) {
+    var _globalThis___FEDERATION__, url, dataFetchId, params, remoteInfo, remoteInfoQuery, _dataFetchMap_dataFetchId, _dataFetchMap_dataFetchId1, dataFetchMap, fetchDataPromise, targetPromise, wrappedPromise, res, hostInstance, remoteEntry, remote, _hostInstance_snapshotHandler_getGlobalRemoteInfo, hostGlobalSnapshot, remoteSnapshot, dataFetchItem, callFetchDataPromise, wrappedPromise1, res1, remoteId, hostInstance1, dataFetchFn, data, e;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          try {
+            url = new URL(ctx.req.url);
+            dataFetchId = getDecodeQuery(url, DATA_FETCH_QUERY);
+            params = JSON.parse(getDecodeQuery(url, "params") || "{}");
+            remoteInfoQuery = getDecodeQuery(url, "remoteInfo");
+            remoteInfo = remoteInfoQuery ? JSON.parse(remoteInfoQuery) : null;
+          } catch (e2) {
+            logger.error("fetch data from server, error: ", e2);
+            return [
+              2,
+              next()
+            ];
+          }
+          if (!dataFetchId) {
+            return [
+              2,
+              next()
+            ];
+          }
+          logger.log("fetch data from server, dataFetchId: ", dataFetchId);
+          logger.debug("fetch data from server, moduleInfo: ", (_globalThis___FEDERATION__ = globalThis.__FEDERATION__) === null || _globalThis___FEDERATION__ === void 0 ? void 0 : _globalThis___FEDERATION__.moduleInfo);
+          _state.label = 1;
+        case 1:
+          _state.trys.push([
+            1,
+            9,
+            ,
+            10
+          ]);
+          dataFetchMap = getDataFetchMap();
+          if (!dataFetchMap) {
+            initDataFetchMap();
+          }
+          fetchDataPromise = (_dataFetchMap_dataFetchId = dataFetchMap[dataFetchId]) === null || _dataFetchMap_dataFetchId === void 0 ? void 0 : _dataFetchMap_dataFetchId[1];
+          logger.debug("fetch data from server, fetchDataPromise: ", fetchDataPromise);
+          if (!(fetchDataPromise && ((_dataFetchMap_dataFetchId1 = dataFetchMap[dataFetchId]) === null || _dataFetchMap_dataFetchId1 === void 0 ? void 0 : _dataFetchMap_dataFetchId1[2]) !== MF_DATA_FETCH_STATUS.ERROR))
+            return [
+              3,
+              4
+            ];
+          targetPromise = fetchDataPromise[0];
+          wrappedPromise = wrapSetTimeout(targetPromise, 2e4, dataFetchId);
+          if (!wrappedPromise)
+            return [
+              3,
+              3
+            ];
+          return [
+            4,
+            wrappedPromise
+          ];
+        case 2:
+          res = _state.sent();
+          logger.log("fetch data from server, fetchDataPromise res: ", res);
+          return [
+            2,
+            ctx.json(res)
+          ];
+        case 3:
+          logger.error("Expected a Promise from fetchDataPromise[0] for dataFetchId ".concat(dataFetchId, ", but received:"), targetPromise, "Will try call new dataFetch again...");
+          _state.label = 4;
+        case 4:
+          if (remoteInfo) {
+            try {
+              hostInstance = globalThis.__FEDERATION__.__INSTANCES__[0];
+              remoteEntry = "".concat(addProtocol(remoteInfo.ssrPublicPath) + remoteInfo.ssrRemoteEntry);
+              if (!hostInstance) {
+                throw new Error("host instance not found!");
+              }
+              remote = hostInstance.options.remotes.find(function(remote2) {
+                return remote2.name === remoteInfo.name;
+              });
+              logger.debug("find remote: ", JSON.stringify(remote));
+              if (!remote) {
+                hostInstance.registerRemotes([
+                  {
+                    name: remoteInfo.name,
+                    entry: remoteEntry,
+                    entryGlobalName: remoteInfo.globalName
+                  }
+                ]);
+              } else if (!("entry" in remote) || !remote.entry.includes(MANIFEST_EXT)) {
+                _hostInstance_snapshotHandler_getGlobalRemoteInfo = hostInstance.snapshotHandler.getGlobalRemoteInfo(remoteInfo), hostGlobalSnapshot = _hostInstance_snapshotHandler_getGlobalRemoteInfo.hostGlobalSnapshot, remoteSnapshot = _hostInstance_snapshotHandler_getGlobalRemoteInfo.remoteSnapshot;
+                logger.debug("find hostGlobalSnapshot: ", JSON.stringify(hostGlobalSnapshot));
+                logger.debug("find remoteSnapshot: ", JSON.stringify(remoteSnapshot));
+                if (!hostGlobalSnapshot || !remoteSnapshot) {
+                  if ("version" in remote) {
+                    delete remote.version;
+                  }
+                  remote.entry = remoteEntry;
+                  remote.entryGlobalName = remoteInfo.globalName;
+                }
+              }
+            } catch (e2) {
+              ctx.status(500);
+              return [
+                2,
+                ctx.text("failed to fetch ".concat(remoteInfo.name, " data, error:\n ").concat(e2))
+              ];
+            }
+          }
+          dataFetchItem = dataFetchMap[dataFetchId];
+          logger.debug("fetch data from server, dataFetchItem: ", dataFetchItem);
+          if (!dataFetchItem)
+            return [
+              3,
+              6
+            ];
+          callFetchDataPromise = fetchData(dataFetchId, _object_spread_props(_object_spread({}, params), {
+            isDowngrade: !remoteInfo
+          }));
+          wrappedPromise1 = wrapSetTimeout(callFetchDataPromise, 2e4, dataFetchId);
+          if (!wrappedPromise1)
+            return [
+              3,
+              6
+            ];
+          return [
+            4,
+            wrappedPromise1
+          ];
+        case 5:
+          res1 = _state.sent();
+          logger.log("fetch data from server, dataFetchItem res: ", res1);
+          return [
+            2,
+            ctx.json(res1)
+          ];
+        case 6:
+          remoteId = dataFetchId.split(SEPARATOR)[0];
+          hostInstance1 = globalThis.__FEDERATION__.__INSTANCES__[0];
+          if (!hostInstance1) {
+            throw new Error("host instance not found!");
+          }
+          return [
+            4,
+            loadDataFetchModule(hostInstance1, remoteId)
+          ];
+        case 7:
+          dataFetchFn = _state.sent();
+          return [
+            4,
+            dataFetchFn(_object_spread_props(_object_spread({}, params), {
+              isDowngrade: !remoteInfo
+            }))
+          ];
+        case 8:
+          data = _state.sent();
+          logger.log("fetch data from server, loadDataFetchModule res: ", data);
+          return [
+            2,
+            ctx.json(data)
+          ];
+        case 9:
+          e = _state.sent();
+          logger.error("server plugin data fetch error: ", e);
+          ctx.status(500);
+          return [
+            2,
+            ctx.text("failed to fetch ".concat(remoteInfo.name, " data, error:\n ").concat(e))
+          ];
+        case 10:
+          return [
+            2
+          ];
+      }
+    });
+  });
+  return function middleware2(ctx, next) {
+    return _ref.apply(this, arguments);
+  };
+}();
 var dataFetchServePlugin = function() {
   return {
     name: "mf-data-fetch-server-plugin",
@@ -8,7 +225,7 @@ var dataFetchServePlugin = function() {
         middlewares.push({
           name: "module-federation-serve-manifest",
           // @ts-ignore type error
-          handler: dataFetchMiddleWare
+          handler: middleware
         });
       });
     }

package/dist/esm/constant.js

@@ -1,6 +1,42 @@
 var LOCALHOST = "localhost";
 var PLUGIN_IDENTIFIER = "[ Modern.js Module Federation ]";
+var DATA_FETCH_QUERY = "x-mf-data-fetch";
+var DATA_FETCH_ERROR_PREFIX = "caught the following error during dataFetch: ";
+var LOAD_REMOTE_ERROR_PREFIX = "caught the following error during loadRemote: ";
+var DOWNGRADE_KEY = "_mfSSRDowngrade";
+var DATA_FETCH_MAP_KEY = "__MF_DATA_FETCH_MAP__";
+var DATA_FETCH_FUNCTION = "_mfDataFetch";
+var FS_HREF = "_mfFSHref";
+var ERROR_TYPE = {
+  DATA_FETCH: 1,
+  LOAD_REMOTE: 2,
+  UNKNOWN: 3
+};
+var WRAP_DATA_FETCH_ID_IDENTIFIER = "wrap_dfip_identifier";
+var MF_DATA_FETCH_TYPE;
+(function(MF_DATA_FETCH_TYPE2) {
+  MF_DATA_FETCH_TYPE2[MF_DATA_FETCH_TYPE2["FETCH_SERVER"] = 1] = "FETCH_SERVER";
+  MF_DATA_FETCH_TYPE2[MF_DATA_FETCH_TYPE2["FETCH_CLIENT"] = 2] = "FETCH_CLIENT";
+})(MF_DATA_FETCH_TYPE || (MF_DATA_FETCH_TYPE = {}));
+var MF_DATA_FETCH_STATUS;
+(function(MF_DATA_FETCH_STATUS2) {
+  MF_DATA_FETCH_STATUS2[MF_DATA_FETCH_STATUS2["LOADED"] = 1] = "LOADED";
+  MF_DATA_FETCH_STATUS2[MF_DATA_FETCH_STATUS2["LOADING"] = 2] = "LOADING";
+  MF_DATA_FETCH_STATUS2[MF_DATA_FETCH_STATUS2["AWAIT"] = 0] = "AWAIT";
+  MF_DATA_FETCH_STATUS2[MF_DATA_FETCH_STATUS2["ERROR"] = 3] = "ERROR";
+})(MF_DATA_FETCH_STATUS || (MF_DATA_FETCH_STATUS = {}));
 export {
+  DATA_FETCH_ERROR_PREFIX,
+  DATA_FETCH_FUNCTION,
+  DATA_FETCH_MAP_KEY,
+  DATA_FETCH_QUERY,
+  DOWNGRADE_KEY,
+  ERROR_TYPE,
+  FS_HREF,
+  LOAD_REMOTE_ERROR_PREFIX,
   LOCALHOST,
-  PLUGIN_IDENTIFIER
+  MF_DATA_FETCH_STATUS,
+  MF_DATA_FETCH_TYPE,
+  PLUGIN_IDENTIFIER,
+  WRAP_DATA_FETCH_ID_IDENTIFIER
 };