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

package/dist/esm/ssr-runtime/downgrade.js

@@ -0,0 +1,150 @@
+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 _type_of } from "@swc/helpers/_/_type_of";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
+import { DATA_FETCH_QUERY, DOWNGRADE_KEY } from "../constant";
+import { MF_DATA_FETCH_STATUS, MF_DATA_FETCH_TYPE } from "../constant";
+import { getDataFetchMap } from "../utils";
+function getDowngradeTag() {
+  return globalThis[DOWNGRADE_KEY];
+}
+function callAllDowngrade() {
+  var dataFetchMap = getDataFetchMap();
+  if (!dataFetchMap) {
+    return;
+  }
+  Object.keys(dataFetchMap).forEach(function(key) {
+    callDowngrade(key);
+  });
+}
+function callDowngrade(id, params, remoteInfo) {
+  return _callDowngrade.apply(this, arguments);
+}
+function _callDowngrade() {
+  _callDowngrade = _async_to_generator(function(id, params, remoteInfo) {
+    var dataFetchMap, mfDataFetch, promise, res, rej, dataFetchType, currentUrl, fetchServerQuery, fetchUrl, data, e;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          dataFetchMap = getDataFetchMap();
+          if (!dataFetchMap) {
+            return [
+              2
+            ];
+          }
+          mfDataFetch = dataFetchMap[id];
+          if (!((mfDataFetch === null || mfDataFetch === void 0 ? void 0 : mfDataFetch[2]) === MF_DATA_FETCH_STATUS.AWAIT))
+            return [
+              3,
+              6
+            ];
+          mfDataFetch[2] = MF_DATA_FETCH_STATUS.LOADING;
+          if (mfDataFetch[1]) {
+            promise = mfDataFetch[1][0];
+            res = mfDataFetch[1][1];
+            rej = mfDataFetch[1][2];
+          } else {
+            promise = new Promise(function(resolve, reject) {
+              res = resolve;
+              rej = reject;
+            });
+            mfDataFetch[1] = [
+              promise,
+              res,
+              rej
+            ];
+          }
+          dataFetchType = mfDataFetch[0][1];
+          if (!(dataFetchType === MF_DATA_FETCH_TYPE.FETCH_CLIENT))
+            return [
+              3,
+              1
+            ];
+          try {
+            mfDataFetch[0][0]().then(function(getDataFetchFn) {
+              return getDataFetchFn(_object_spread_props(_object_spread({}, params), {
+                isDowngrade: true
+              })).then(function(data2) {
+                mfDataFetch[2] = MF_DATA_FETCH_STATUS.LOADED;
+                res(data2);
+              });
+            });
+          } catch (e2) {
+            mfDataFetch[2] = MF_DATA_FETCH_STATUS.ERROR;
+            rej(e2);
+          }
+          return [
+            3,
+            5
+          ];
+        case 1:
+          if (!(dataFetchType === MF_DATA_FETCH_TYPE.FETCH_SERVER))
+            return [
+              3,
+              5
+            ];
+          _state.label = 2;
+        case 2:
+          _state.trys.push([
+            2,
+            4,
+            ,
+            5
+          ]);
+          currentUrl = new URL(window.location.href);
+          currentUrl.searchParams.set(DATA_FETCH_QUERY, encodeURIComponent(id));
+          if (params) {
+            currentUrl.searchParams.set("params", encodeURIComponent(JSON.stringify(params)));
+          }
+          if (remoteInfo) {
+            currentUrl.searchParams.set("remoteInfo", encodeURIComponent(JSON.stringify(remoteInfo)));
+          }
+          fetchServerQuery = globalThis.FEDERATION_SERVER_QUERY;
+          if (fetchServerQuery && (typeof fetchServerQuery === "undefined" ? "undefined" : _type_of(fetchServerQuery)) === "object") {
+            Object.keys(fetchServerQuery).forEach(function(key) {
+              currentUrl.searchParams.set(key, JSON.stringify(fetchServerQuery[key]));
+            });
+          }
+          fetchUrl = currentUrl.toString();
+          return [
+            4,
+            fetch(fetchUrl).then(function(res2) {
+              return res2.json();
+            })
+          ];
+        case 3:
+          data = _state.sent();
+          mfDataFetch[2] = MF_DATA_FETCH_STATUS.LOADED;
+          res(data);
+          return [
+            3,
+            5
+          ];
+        case 4:
+          e = _state.sent();
+          mfDataFetch[2] = MF_DATA_FETCH_STATUS.ERROR;
+          rej(e);
+          return [
+            3,
+            5
+          ];
+        case 5:
+          return [
+            2,
+            promise
+          ];
+        case 6:
+          return [
+            2
+          ];
+      }
+    });
+  });
+  return _callDowngrade.apply(this, arguments);
+}
+export {
+  callAllDowngrade,
+  callDowngrade,
+  getDowngradeTag
+};

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

@@ -1,25 +1,167 @@
 import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _sliced_to_array } from "@swc/helpers/_/_sliced_to_array";
 import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
-import { callDataFetch } from "@module-federation/bridge-react/data-fetch-utils";
-import { setSSREnv } from "@module-federation/bridge-react/lazy-utils";
+import { DATA_FETCH_FUNCTION, DOWNGRADE_KEY, FS_HREF, MF_DATA_FETCH_STATUS, MF_DATA_FETCH_TYPE } from "../constant";
+import logger from "../logger";
+import { getDataFetchMap, getDataFetchItem, initDataFetchMap } from "../utils";
+import { callAllDowngrade, callDowngrade, getDowngradeTag } from "./downgrade";
+function setSSREnv(param) {
+  var fetchServerQuery = param.fetchServerQuery;
+  globalThis.FEDERATION_SSR = true;
+  globalThis.FEDERATION_SERVER_QUERY = fetchServerQuery;
+}
 var injectDataFetchFunctionPlugin = function(param) {
   var fetchServerQuery = param.fetchServerQuery;
   return {
     name: "@module-federation/inject-data-fetch-function-plugin",
     setup: function(api) {
       api.onBeforeRender(/* @__PURE__ */ _async_to_generator(function() {
+        var _globalThis, _DATA_FETCH_FUNCTION, dataFetchFunction, dataFetch;
         return _ts_generator(this, function(_state) {
           switch (_state.label) {
             case 0:
               setSSREnv({
                 fetchServerQuery
               });
+              if (typeof window === "undefined") {
+                return [
+                  2
+                ];
+              }
+              dataFetchFunction = function() {
+                var _ref = _async_to_generator(function(options) {
+                  var _options, id, data, downgrade, dataFetchItem, _dataFetchItem__, _dataFetchItem_, dataFetchMap, res, rej, p, mfDowngrade, mfDowngrade1;
+                  return _ts_generator(this, function(_state2) {
+                    _options = _sliced_to_array(options, 3), id = _options[0], data = _options[1], downgrade = _options[2];
+                    logger.debug("==========call data fetch function!");
+                    if (data) {
+                      if (!id) {
+                        throw new Error("id is required!");
+                      }
+                      if (!getDataFetchMap()) {
+                        initDataFetchMap();
+                      }
+                      dataFetchItem = getDataFetchItem(id);
+                      if (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] = MF_DATA_FETCH_STATUS.LOADED;
+                        return [
+                          2
+                        ];
+                      }
+                      if (!dataFetchItem) {
+                        dataFetchMap = getDataFetchMap();
+                        ;
+                        ;
+                        p = new Promise(function(resolve, reject) {
+                          res = resolve;
+                          rej = reject;
+                        });
+                        dataFetchMap[id] = [
+                          [
+                            /* @__PURE__ */ _async_to_generator(function() {
+                              return _ts_generator(this, function(_state3) {
+                                return [
+                                  2,
+                                  _async_to_generator(function() {
+                                    return _ts_generator(this, function(_state4) {
+                                      return [
+                                        2,
+                                        ""
+                                      ];
+                                    });
+                                  })
+                                ];
+                              });
+                            }),
+                            MF_DATA_FETCH_TYPE.FETCH_SERVER
+                          ],
+                          [
+                            p,
+                            res,
+                            rej
+                          ],
+                          MF_DATA_FETCH_STATUS.LOADED
+                        ];
+                        res(data);
+                        return [
+                          2
+                        ];
+                      }
+                    }
+                    if (downgrade) {
+                      mfDowngrade = getDowngradeTag();
+                      if (!mfDowngrade) {
+                        globalThis[DOWNGRADE_KEY] = id ? [
+                          id
+                        ] : true;
+                      } else if (Array.isArray(mfDowngrade) && id && !mfDowngrade.includes(id)) {
+                        mfDowngrade.push(id);
+                      }
+                    }
+                    mfDowngrade1 = getDowngradeTag();
+                    if (typeof mfDowngrade1 === "boolean") {
+                      return [
+                        2,
+                        callAllDowngrade()
+                      ];
+                    }
+                    if (Array.isArray(mfDowngrade1)) {
+                      if (!id) {
+                        globalThis[DOWNGRADE_KEY] = true;
+                        return [
+                          2,
+                          callAllDowngrade()
+                        ];
+                      }
+                      if (!mfDowngrade1.includes(id)) {
+                        mfDowngrade1.push(id);
+                      }
+                      return [
+                        2,
+                        callDowngrade(id)
+                      ];
+                    }
+                    return [
+                      2
+                    ];
+                  });
+                });
+                return function dataFetchFunction2(options) {
+                  return _ref.apply(this, arguments);
+                };
+              }();
+              globalThis[FS_HREF] = window.location.href;
+              (_globalThis = globalThis)[_DATA_FETCH_FUNCTION = DATA_FETCH_FUNCTION] || (_globalThis[_DATA_FETCH_FUNCTION] = []);
+              dataFetch = globalThis[DATA_FETCH_FUNCTION];
               return [
                 4,
-                callDataFetch()
+                Promise.all(dataFetch.map(function() {
+                  var _ref = _async_to_generator(function(options) {
+                    return _ts_generator(this, function(_state2) {
+                      switch (_state2.label) {
+                        case 0:
+                          return [
+                            4,
+                            dataFetchFunction(options)
+                          ];
+                        case 1:
+                          _state2.sent();
+                          return [
+                            2
+                          ];
+                      }
+                    });
+                  });
+                  return function(options) {
+                    return _ref.apply(this, arguments);
+                  };
+                }()))
               ];
             case 1:
               _state.sent();
+              dataFetch.push = dataFetchFunction;
               return [
                 2
               ];
@@ -30,5 +172,6 @@ var injectDataFetchFunctionPlugin = function(param) {
   };
 };
 export {
-  injectDataFetchFunctionPlugin
+  injectDataFetchFunctionPlugin,
+  setSSREnv
 };

package/dist/esm/utils/dataFetch.js

@@ -0,0 +1,237 @@
+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 _to_array } from "@swc/helpers/_/_to_array";
+import { _ as _type_of } from "@swc/helpers/_/_type_of";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
+import { isBrowserEnv, composeKeyWithSeparator } from "@module-federation/sdk";
+import { isCSROnly } from "../utils";
+import logger from "../logger";
+import { callDowngrade, getDowngradeTag } from "../ssr-runtime/downgrade";
+import { DOWNGRADE_KEY, MF_DATA_FETCH_STATUS, WRAP_DATA_FETCH_ID_IDENTIFIER } from "../constant";
+import { DATA_FETCH_CLIENT_SUFFIX, DATA_FETCH_IDENTIFIER } from "@module-federation/rsbuild-plugin/constant";
+var getDataFetchInfo = function(param) {
+  var name = param.name, alias = param.alias, id = param.id, remoteSnapshot = param.remoteSnapshot;
+  if (!remoteSnapshot) {
+    return;
+  }
+  if (!("modules" in remoteSnapshot)) {
+    return;
+  }
+  var regex = new RegExp("^".concat(name, "(/[^/].*|)$"));
+  var nameOrAlias = regex.test(id) ? name : alias || name;
+  var expose = id.replace(nameOrAlias, "");
+  var dataFetchName = "";
+  var dataFetchId = "";
+  if (expose.startsWith("/")) {
+    dataFetchName = "".concat(expose.slice(1), ".").concat(DATA_FETCH_IDENTIFIER);
+    dataFetchId = "".concat(id, ".").concat(DATA_FETCH_IDENTIFIER);
+  } else if (expose === "") {
+    dataFetchName = DATA_FETCH_IDENTIFIER;
+    dataFetchId = "".concat(id, "/").concat(DATA_FETCH_IDENTIFIER);
+  } else {
+    return;
+  }
+  if (!dataFetchName || !dataFetchId) {
+    return;
+  }
+  if (!remoteSnapshot.modules.find(function(module) {
+    return module.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__;
+}
+var flushDataFetch = function() {
+  globalThis.__MF_DATA_FETCH_MAP__ = {};
+  globalThis[DOWNGRADE_KEY] = void 0;
+};
+function setDataFetchItemLoadedStatus(id) {
+  var dataFetchItem = getDataFetchItem(id);
+  if (!dataFetchItem) {
+    return;
+  }
+  dataFetchItem[2] = MF_DATA_FETCH_STATUS.LOADED;
+}
+var wrapDataFetchId = function(id) {
+  return "".concat(WRAP_DATA_FETCH_ID_IDENTIFIER).concat(id).concat(WRAP_DATA_FETCH_ID_IDENTIFIER);
+};
+var getDataFetchIdWithErrorMsgs = function(errMsgs) {
+  var firstIdentifierIndex = errMsgs.indexOf(WRAP_DATA_FETCH_ID_IDENTIFIER);
+  if (firstIdentifierIndex === -1) {
+    return void 0;
+  }
+  var secondIdentifierIndex = errMsgs.indexOf(WRAP_DATA_FETCH_ID_IDENTIFIER, firstIdentifierIndex + WRAP_DATA_FETCH_ID_IDENTIFIER.length);
+  if (secondIdentifierIndex === -1) {
+    return void 0;
+  }
+  return errMsgs.substring(firstIdentifierIndex + WRAP_DATA_FETCH_ID_IDENTIFIER.length, secondIdentifierIndex);
+};
+function fetchData(id, params, remoteInfo) {
+  return _fetchData.apply(this, arguments);
+}
+function _fetchData() {
+  _fetchData = _async_to_generator(function(id, params, remoteInfo) {
+    var callFetchData, _dataFetchItem_, dataFetchItem, mfDowngrade, res, rej, p;
+    return _ts_generator(this, function(_state) {
+      callFetchData = function() {
+        var _ref = _async_to_generator(function() {
+          var item, _item, fetchDataFnArr, _rest, fetchDataFn;
+          return _ts_generator(this, function(_state2) {
+            switch (_state2.label) {
+              case 0:
+                item = getDataFetchItem(id);
+                if (!item) {
+                  return [
+                    2
+                  ];
+                }
+                _item = _to_array(item), fetchDataFnArr = _item[0], _rest = _item.slice(1);
+                return [
+                  4,
+                  fetchDataFnArr[2]
+                ];
+              case 1:
+                fetchDataFn = _state2.sent();
+                if (!fetchDataFn) {
+                  return [
+                    2
+                  ];
+                }
+                return [
+                  2,
+                  fetchDataFn(params)
+                ];
+            }
+          });
+        });
+        return function callFetchData2() {
+          return _ref.apply(this, arguments);
+        };
+      }();
+      if (isBrowserEnv()) {
+        ;
+        dataFetchItem = getDataFetchItem(id);
+        if (!dataFetchItem) {
+          throw new Error("dataFetchItem not found, id: ".concat(id));
+        }
+        if ((_dataFetchItem_ = dataFetchItem[1]) === null || _dataFetchItem_ === void 0 ? void 0 : _dataFetchItem_[0]) {
+          return [
+            2,
+            dataFetchItem[1][0]
+          ];
+        }
+        if (isCSROnly()) {
+          logger.debug("==========csr only!");
+          return [
+            2,
+            callFetchData()
+          ];
+        }
+        if (remoteInfo) {
+          return [
+            2,
+            callDowngrade(id, params, remoteInfo)
+          ];
+        }
+        mfDowngrade = getDowngradeTag();
+        if (mfDowngrade) {
+          if (typeof mfDowngrade === "boolean") {
+            return [
+              2,
+              callDowngrade(id, _object_spread_props(_object_spread({}, params), {
+                isDowngrade: true
+              }))
+            ];
+          }
+          if (mfDowngrade.includes(id)) {
+            return [
+              2,
+              callDowngrade(id, _object_spread_props(_object_spread({}, params), {
+                isDowngrade: true
+              }))
+            ];
+          }
+        }
+        ;
+        ;
+        p = new Promise(function(resolve, reject) {
+          res = resolve;
+          rej = reject;
+        });
+        dataFetchItem[1] = [
+          p,
+          res,
+          rej
+        ];
+        dataFetchItem[2] = MF_DATA_FETCH_STATUS.AWAIT;
+        return [
+          2,
+          dataFetchItem[1][0]
+        ];
+      }
+      return [
+        2,
+        callFetchData()
+      ];
+    });
+  });
+  return _fetchData.apply(this, arguments);
+}
+function getDataFetchMapKey(dataFetchInfo, hostInfo) {
+  if (!dataFetchInfo || !hostInfo) {
+    return;
+  }
+  var dataFetchId = dataFetchInfo.dataFetchId;
+  return composeKeyWithSeparator(dataFetchId, hostInfo.name, hostInfo.version);
+}
+function loadDataFetchModule(instance, id) {
+  return _loadDataFetchModule.apply(this, arguments);
+}
+function _loadDataFetchModule() {
+  _loadDataFetchModule = _async_to_generator(function(instance, id) {
+    return _ts_generator(this, function(_state) {
+      return [
+        2,
+        instance.loadRemote(id).then(function(m) {
+          if (m && (typeof m === "undefined" ? "undefined" : _type_of(m)) === "object" && "fetchData" in m && typeof m.fetchData === "function") {
+            return m.fetchData;
+          }
+          throw new Error("fetchData not found in remote ".concat(id, ", ").concat(JSON.stringify(m)));
+        })
+      ];
+    });
+  });
+  return _loadDataFetchModule.apply(this, arguments);
+}
+function isDataLoaderExpose(exposeKey) {
+  return exposeKey.endsWith(DATA_FETCH_IDENTIFIER) || exposeKey.endsWith(DATA_FETCH_CLIENT_SUFFIX);
+}
+export {
+  fetchData,
+  flushDataFetch,
+  getDataFetchIdWithErrorMsgs,
+  getDataFetchInfo,
+  getDataFetchItem,
+  getDataFetchMap,
+  getDataFetchMapKey,
+  initDataFetchMap,
+  isDataLoaderExpose,
+  loadDataFetchModule,
+  setDataFetchItemLoadedStatus,
+  wrapDataFetchId
+};

package/dist/esm/utils/index.js

@@ -0,0 +1,28 @@
+import { _ as _object_spread } from "@swc/helpers/_/_object_spread";
+import { _ as _object_spread_props } from "@swc/helpers/_/_object_spread_props";
+function getLoadedRemoteInfos(id, instance) {
+  if (!instance) {
+    return;
+  }
+  var _ref = instance.remoteHandler.idToRemoteMap[id] || {}, name = _ref.name, expose = _ref.expose;
+  if (!name) {
+    return;
+  }
+  var module = instance.moduleCache.get(name);
+  if (!module) {
+    return;
+  }
+  var remoteSnapshot = instance.snapshotHandler.getGlobalRemoteInfo(module.remoteInfo).remoteSnapshot;
+  return _object_spread_props(_object_spread({}, module.remoteInfo), {
+    snapshot: remoteSnapshot,
+    expose
+  });
+}
+function isCSROnly() {
+  return window._SSR_DATA === void 0;
+}
+export * from "./dataFetch";
+export {
+  getLoadedRemoteInfos,
+  isCSROnly
+};

package/dist/esm-node/cli/configPlugin.js

@@ -107,6 +107,7 @@ const patchMFConfig = (mfConfig, isServer, remoteIpStrategy, enableSSR) => {
   ];
   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-node/cli/configPlugin.spec.js

@@ -38,6 +38,7 @@ describe("patchMFConfig", async () => {
       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")
       ],
@@ -66,7 +67,7 @@ describe("patchMFConfig", async () => {
       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-node/cli/mfRuntimePlugins/auto-fetch-data.js

@@ -0,0 +1,70 @@
+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";
+const autoFetchData = () => ({
+  name: "auto-fetch-data-plugin",
+  beforeInit(args) {
+    initDataFetchMap();
+    return args;
+  },
+  afterLoadSnapshot(args) {
+    const { id, moduleInfo, remoteSnapshot, host } = args;
+    if (typeof id === "string" && isDataLoaderExpose(id)) {
+      return args;
+    }
+    if (!remoteSnapshot || !id || !("modules" in remoteSnapshot)) {
+      return args;
+    }
+    const { name, alias } = moduleInfo;
+    const dataFetchInfo = getDataFetchInfo({
+      name,
+      alias,
+      id,
+      remoteSnapshot
+    });
+    if (!dataFetchInfo) {
+      return args;
+    }
+    const { dataFetchId, dataFetchName } = dataFetchInfo;
+    const dataFetchMapKey = getDataFetchMapKey(dataFetchInfo, {
+      name: host.name,
+      version: host.options.version
+    });
+    logger.debug("======= auto fetch plugin dataFetchMapKey: ", dataFetchMapKey);
+    if (!dataFetchMapKey) {
+      return args;
+    }
+    const dataFetchItem = getDataFetchItem(dataFetchMapKey);
+    if (dataFetchItem) {
+      return args;
+    }
+    const dataFetchMap = getDataFetchMap();
+    const hasSSRAsset = Boolean(remoteSnapshot.ssrRemoteEntry);
+    const hasDataFetchClient = Boolean(remoteSnapshot.modules.find((module) => module.moduleName === `${dataFetchName}${DATA_FETCH_CLIENT_SUFFIX}`));
+    const downgradeType = hasDataFetchClient ? MF_DATA_FETCH_TYPE.FETCH_CLIENT : hasSSRAsset ? MF_DATA_FETCH_TYPE.FETCH_SERVER : MF_DATA_FETCH_TYPE.FETCH_CLIENT;
+    let finalDataFetchId = dataFetchId;
+    if (typeof window !== "undefined") {
+      finalDataFetchId = downgradeType === MF_DATA_FETCH_TYPE.FETCH_CLIENT ? hasDataFetchClient ? `${dataFetchId}${DATA_FETCH_CLIENT_SUFFIX}` : dataFetchId : dataFetchId;
+    }
+    const getDataFetchGetter = () => loadDataFetchModule(host, finalDataFetchId);
+    const 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
+};