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

package/dist/cjs/cli/configPlugin.js

@@ -148,6 +148,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 && (0, import_utils3.isDev)()) {
     injectRuntimePlugins(require.resolve("@module-federation/modern-js/resolve-entry-ipv4"), runtimePlugins);
   }

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

@@ -61,6 +61,7 @@ const mfConfig = {
       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")
       ],
@@ -89,7 +90,7 @@ const mfConfig = {
       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/cjs/cli/mfRuntimePlugins/auto-fetch-data.js

@@ -0,0 +1,100 @@
+"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 auto_fetch_data_exports = {};
+__export(auto_fetch_data_exports, {
+  default: () => auto_fetch_data_default
+});
+module.exports = __toCommonJS(auto_fetch_data_exports);
+var import_utils = require("../../utils");
+var import_logger = __toESM(require("../../logger"));
+var import_dataFetch = require("../../utils/dataFetch");
+var import_constant = require("../../constant");
+var import_constant2 = require("@module-federation/rsbuild-plugin/constant");
+const autoFetchData = () => ({
+  name: "auto-fetch-data-plugin",
+  beforeInit(args) {
+    (0, import_utils.initDataFetchMap)();
+    return args;
+  },
+  afterLoadSnapshot(args) {
+    const { id, moduleInfo, remoteSnapshot, host } = args;
+    if (typeof id === "string" && (0, import_dataFetch.isDataLoaderExpose)(id)) {
+      return args;
+    }
+    if (!remoteSnapshot || !id || !("modules" in remoteSnapshot)) {
+      return args;
+    }
+    const { name, alias } = moduleInfo;
+    const dataFetchInfo = (0, import_utils.getDataFetchInfo)({
+      name,
+      alias,
+      id,
+      remoteSnapshot
+    });
+    if (!dataFetchInfo) {
+      return args;
+    }
+    const { dataFetchId, dataFetchName } = dataFetchInfo;
+    const dataFetchMapKey = (0, import_dataFetch.getDataFetchMapKey)(dataFetchInfo, {
+      name: host.name,
+      version: host.options.version
+    });
+    import_logger.default.debug("======= auto fetch plugin dataFetchMapKey: ", dataFetchMapKey);
+    if (!dataFetchMapKey) {
+      return args;
+    }
+    const dataFetchItem = (0, import_utils.getDataFetchItem)(dataFetchMapKey);
+    if (dataFetchItem) {
+      return args;
+    }
+    const dataFetchMap = (0, import_utils.getDataFetchMap)();
+    const hasSSRAsset = Boolean(remoteSnapshot.ssrRemoteEntry);
+    const hasDataFetchClient = Boolean(remoteSnapshot.modules.find((module2) => module2.moduleName === `${dataFetchName}${import_constant2.DATA_FETCH_CLIENT_SUFFIX}`));
+    const downgradeType = hasDataFetchClient ? import_constant.MF_DATA_FETCH_TYPE.FETCH_CLIENT : hasSSRAsset ? import_constant.MF_DATA_FETCH_TYPE.FETCH_SERVER : import_constant.MF_DATA_FETCH_TYPE.FETCH_CLIENT;
+    let finalDataFetchId = dataFetchId;
+    if (typeof window !== "undefined") {
+      finalDataFetchId = downgradeType === import_constant.MF_DATA_FETCH_TYPE.FETCH_CLIENT ? hasDataFetchClient ? `${dataFetchId}${import_constant2.DATA_FETCH_CLIENT_SUFFIX}` : dataFetchId : dataFetchId;
+    }
+    const getDataFetchGetter = () => (0, import_dataFetch.loadDataFetchModule)(host, finalDataFetchId);
+    const dataFetchFnItem = [
+      getDataFetchGetter,
+      downgradeType
+    ];
+    if (typeof window === "undefined" || (0, import_utils.isCSROnly)()) {
+      dataFetchFnItem.push(getDataFetchGetter());
+    }
+    dataFetchMap[dataFetchMapKey] = [
+      dataFetchFnItem,
+      void 0,
+      import_constant.MF_DATA_FETCH_STATUS.AWAIT
+    ];
+    return args;
+  }
+});
+var auto_fetch_data_default = autoFetchData;

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

@@ -31,7 +31,148 @@ __export(data_fetch_server_plugin_exports, {
   default: () => data_fetch_server_plugin_default
 });
 module.exports = __toCommonJS(data_fetch_server_plugin_exports);
-var import_data_fetch_server_middleware = __toESM(require("@module-federation/bridge-react/data-fetch-server-middleware"));
+var import_constant = require("../../constant");
+var import_logger = __toESM(require("../../logger"));
+var import_utils = require("../../utils");
+var import_dataFetch = require("../../utils/dataFetch");
+var import_sdk = require("@module-federation/sdk");
+function wrapSetTimeout(targetPromise, delay = 2e4, id) {
+  if (targetPromise && typeof targetPromise.then === "function") {
+    return new Promise((resolve, reject) => {
+      const timeoutId = setTimeout(() => {
+        import_logger.default.warn(`Data fetch for ID ${id} timed out after 20 seconds.`);
+        reject(new Error(`Data fetch for ID ${id} timed out after 20 seconds`));
+      }, delay);
+      targetPromise.then((value) => {
+        clearTimeout(timeoutId);
+        resolve(value);
+      }).catch((err) => {
+        clearTimeout(timeoutId);
+        reject(err);
+      });
+    });
+  }
+}
+function addProtocol(url) {
+  if (url.startsWith("//")) {
+    return "https:" + url;
+  }
+  return url;
+}
+const getDecodeQuery = (url, name) => {
+  const res = url.searchParams.get(name);
+  if (!res) {
+    return null;
+  }
+  return decodeURIComponent(res);
+};
+const middleware = async (ctx, next) => {
+  var _globalThis___FEDERATION__;
+  let url;
+  let dataFetchId;
+  let params;
+  let remoteInfo;
+  try {
+    url = new URL(ctx.req.url);
+    dataFetchId = getDecodeQuery(url, import_constant.DATA_FETCH_QUERY);
+    params = JSON.parse(getDecodeQuery(url, "params") || "{}");
+    const remoteInfoQuery = getDecodeQuery(url, "remoteInfo");
+    remoteInfo = remoteInfoQuery ? JSON.parse(remoteInfoQuery) : null;
+  } catch (e) {
+    import_logger.default.error("fetch data from server, error: ", e);
+    return next();
+  }
+  if (!dataFetchId) {
+    return next();
+  }
+  import_logger.default.log("fetch data from server, dataFetchId: ", dataFetchId);
+  import_logger.default.debug("fetch data from server, moduleInfo: ", (_globalThis___FEDERATION__ = globalThis.__FEDERATION__) === null || _globalThis___FEDERATION__ === void 0 ? void 0 : _globalThis___FEDERATION__.moduleInfo);
+  try {
+    var _dataFetchMap_dataFetchId, _dataFetchMap_dataFetchId1;
+    const dataFetchMap = (0, import_utils.getDataFetchMap)();
+    if (!dataFetchMap) {
+      (0, import_dataFetch.initDataFetchMap)();
+    }
+    const fetchDataPromise = (_dataFetchMap_dataFetchId = dataFetchMap[dataFetchId]) === null || _dataFetchMap_dataFetchId === void 0 ? void 0 : _dataFetchMap_dataFetchId[1];
+    import_logger.default.debug("fetch data from server, fetchDataPromise: ", fetchDataPromise);
+    if (fetchDataPromise && ((_dataFetchMap_dataFetchId1 = dataFetchMap[dataFetchId]) === null || _dataFetchMap_dataFetchId1 === void 0 ? void 0 : _dataFetchMap_dataFetchId1[2]) !== import_constant.MF_DATA_FETCH_STATUS.ERROR) {
+      const targetPromise = fetchDataPromise[0];
+      const wrappedPromise = wrapSetTimeout(targetPromise, 2e4, dataFetchId);
+      if (wrappedPromise) {
+        const res = await wrappedPromise;
+        import_logger.default.log("fetch data from server, fetchDataPromise res: ", res);
+        return ctx.json(res);
+      }
+      import_logger.default.error(`Expected a Promise from fetchDataPromise[0] for dataFetchId ${dataFetchId}, but received:`, targetPromise, "Will try call new dataFetch again...");
+    }
+    if (remoteInfo) {
+      try {
+        const hostInstance2 = globalThis.__FEDERATION__.__INSTANCES__[0];
+        const remoteEntry = `${addProtocol(remoteInfo.ssrPublicPath) + remoteInfo.ssrRemoteEntry}`;
+        if (!hostInstance2) {
+          throw new Error("host instance not found!");
+        }
+        const remote = hostInstance2.options.remotes.find((remote2) => remote2.name === remoteInfo.name);
+        import_logger.default.debug("find remote: ", JSON.stringify(remote));
+        if (!remote) {
+          hostInstance2.registerRemotes([
+            {
+              name: remoteInfo.name,
+              entry: remoteEntry,
+              entryGlobalName: remoteInfo.globalName
+            }
+          ]);
+        } else if (!("entry" in remote) || !remote.entry.includes(import_sdk.MANIFEST_EXT)) {
+          const { hostGlobalSnapshot, remoteSnapshot } = hostInstance2.snapshotHandler.getGlobalRemoteInfo(remoteInfo);
+          import_logger.default.debug("find hostGlobalSnapshot: ", JSON.stringify(hostGlobalSnapshot));
+          import_logger.default.debug("find remoteSnapshot: ", JSON.stringify(remoteSnapshot));
+          if (!hostGlobalSnapshot || !remoteSnapshot) {
+            if ("version" in remote) {
+              delete remote.version;
+            }
+            remote.entry = remoteEntry;
+            remote.entryGlobalName = remoteInfo.globalName;
+          }
+        }
+      } catch (e) {
+        ctx.status(500);
+        return ctx.text(`failed to fetch ${remoteInfo.name} data, error:
+ ${e}`);
+      }
+    }
+    const dataFetchItem = dataFetchMap[dataFetchId];
+    import_logger.default.debug("fetch data from server, dataFetchItem: ", dataFetchItem);
+    if (dataFetchItem) {
+      const callFetchDataPromise = (0, import_dataFetch.fetchData)(dataFetchId, {
+        ...params,
+        isDowngrade: !remoteInfo
+      });
+      const wrappedPromise = wrapSetTimeout(callFetchDataPromise, 2e4, dataFetchId);
+      if (wrappedPromise) {
+        const res = await wrappedPromise;
+        import_logger.default.log("fetch data from server, dataFetchItem res: ", res);
+        return ctx.json(res);
+      }
+    }
+    const remoteId = dataFetchId.split(import_sdk.SEPARATOR)[0];
+    const hostInstance = globalThis.__FEDERATION__.__INSTANCES__[0];
+    if (!hostInstance) {
+      throw new Error("host instance not found!");
+    }
+    const dataFetchFn = await (0, import_dataFetch.loadDataFetchModule)(hostInstance, remoteId);
+    const data = await dataFetchFn({
+      ...params,
+      isDowngrade: !remoteInfo
+    });
+    import_logger.default.log("fetch data from server, loadDataFetchModule res: ", data);
+    return ctx.json(data);
+  } catch (e) {
+    import_logger.default.error("server plugin data fetch error: ", e);
+    ctx.status(500);
+    return ctx.text(`failed to fetch ${remoteInfo.name} data, error:
+ ${e}`);
+  }
+};
 const dataFetchServePlugin = () => ({
   name: "mf-data-fetch-server-plugin",
   setup: (api) => {
@@ -40,7 +181,7 @@ const dataFetchServePlugin = () => ({
       middlewares.push({
         name: "module-federation-serve-manifest",
         // @ts-ignore type error
-        handler: import_data_fetch_server_middleware.default
+        handler: middleware
       });
     });
   }

package/dist/cjs/constant.js

@@ -18,14 +18,61 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var constant_exports = {};
 __export(constant_exports, {
+  DATA_FETCH_ERROR_PREFIX: () => DATA_FETCH_ERROR_PREFIX,
+  DATA_FETCH_FUNCTION: () => DATA_FETCH_FUNCTION,
+  DATA_FETCH_MAP_KEY: () => DATA_FETCH_MAP_KEY,
+  DATA_FETCH_QUERY: () => DATA_FETCH_QUERY,
+  DOWNGRADE_KEY: () => DOWNGRADE_KEY,
+  ERROR_TYPE: () => ERROR_TYPE,
+  FS_HREF: () => FS_HREF,
+  LOAD_REMOTE_ERROR_PREFIX: () => LOAD_REMOTE_ERROR_PREFIX,
   LOCALHOST: () => LOCALHOST,
-  PLUGIN_IDENTIFIER: () => PLUGIN_IDENTIFIER
+  MF_DATA_FETCH_STATUS: () => MF_DATA_FETCH_STATUS,
+  MF_DATA_FETCH_TYPE: () => MF_DATA_FETCH_TYPE,
+  PLUGIN_IDENTIFIER: () => PLUGIN_IDENTIFIER,
+  WRAP_DATA_FETCH_ID_IDENTIFIER: () => WRAP_DATA_FETCH_ID_IDENTIFIER
 });
 module.exports = __toCommonJS(constant_exports);
 const LOCALHOST = "localhost";
 const PLUGIN_IDENTIFIER = "[ Modern.js Module Federation ]";
+const DATA_FETCH_QUERY = "x-mf-data-fetch";
+const DATA_FETCH_ERROR_PREFIX = "caught the following error during dataFetch: ";
+const LOAD_REMOTE_ERROR_PREFIX = "caught the following error during loadRemote: ";
+const DOWNGRADE_KEY = "_mfSSRDowngrade";
+const DATA_FETCH_MAP_KEY = "__MF_DATA_FETCH_MAP__";
+const DATA_FETCH_FUNCTION = "_mfDataFetch";
+const FS_HREF = "_mfFSHref";
+const ERROR_TYPE = {
+  DATA_FETCH: 1,
+  LOAD_REMOTE: 2,
+  UNKNOWN: 3
+};
+const 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 = {}));
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  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
 });

package/dist/cjs/interfaces/global.js

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var global_exports = {};
+module.exports = __toCommonJS(global_exports);

package/dist/cjs/runtime/AwaitDataFetch.js

@@ -0,0 +1,144 @@
+"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 AwaitDataFetch_exports = {};
+__export(AwaitDataFetch_exports, {
+  AwaitDataFetch: () => AwaitDataFetch,
+  transformError: () => transformError
+});
+module.exports = __toCommonJS(AwaitDataFetch_exports);
+var import_jsx_runtime = require("react/jsx-runtime");
+var import_react = require("react");
+var import_logger = __toESM(require("../logger"));
+var import_constant = require("../constant");
+var import_utils = require("../utils");
+function isPromise(obj) {
+  return !!obj && (typeof obj === "object" || typeof obj === "function") && typeof obj.then === "function";
+}
+const AWAIT_ERROR_PREFIX = "<Await /> caught the following error during render: ";
+const transformError = (err) => {
+  const errMsg = err instanceof Error ? err.message : err;
+  const originalMsg = errMsg.replace(AWAIT_ERROR_PREFIX, "");
+  const dataFetchMapKey = (0, import_utils.getDataFetchIdWithErrorMsgs)(originalMsg);
+  if (originalMsg.indexOf(import_constant.DATA_FETCH_ERROR_PREFIX) === 0) {
+    return {
+      error: new Error(originalMsg.replace(import_constant.DATA_FETCH_ERROR_PREFIX, "").replace((0, import_utils.wrapDataFetchId)(dataFetchMapKey), "")),
+      errorType: import_constant.ERROR_TYPE.DATA_FETCH,
+      dataFetchMapKey
+    };
+  }
+  if (originalMsg.indexOf(import_constant.LOAD_REMOTE_ERROR_PREFIX) === 0) {
+    return {
+      error: new Error(originalMsg.replace(import_constant.LOAD_REMOTE_ERROR_PREFIX, "").replace((0, import_utils.wrapDataFetchId)(dataFetchMapKey), "")),
+      errorType: import_constant.ERROR_TYPE.LOAD_REMOTE,
+      dataFetchMapKey
+    };
+  }
+  return {
+    error: new Error(originalMsg.replace((0, import_utils.wrapDataFetchId)(dataFetchMapKey), "")),
+    errorType: import_constant.ERROR_TYPE.UNKNOWN,
+    dataFetchMapKey
+  };
+};
+const DefaultLoading = /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_jsx_runtime.Fragment, {});
+const DefaultErrorElement = (_data) => /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", {
+  children: "Error"
+});
+function AwaitDataFetch({ resolve, loading = DefaultLoading, errorElement = DefaultErrorElement, children, params }) {
+  const dataRef = (0, import_react.useRef)(void 0);
+  const data = dataRef.current || resolve;
+  const getData = isPromise(data) ? fetchData(data, dataRef) : () => data;
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(AwaitSuspense, {
+    params,
+    loading,
+    errorElement,
+    // @ts-ignore
+    resolve: getData,
+    children
+  });
+}
+function AwaitSuspense({ resolve, children, loading = DefaultLoading, errorElement = DefaultErrorElement }) {
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_react.Suspense, {
+    fallback: loading,
+    children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(ResolveAwait, {
+      resolve,
+      errorElement,
+      children
+    })
+  });
+}
+function ResolveAwait({ children, resolve, errorElement, params }) {
+  const data = resolve();
+  import_logger.default.debug("resolve data: ", data);
+  if (typeof data === "string" && data.indexOf(AWAIT_ERROR_PREFIX) === 0) {
+    const transformedError = transformError(data);
+    return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_jsx_runtime.Fragment, {
+      children: typeof errorElement === "function" ? /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_jsx_runtime.Fragment, {
+        children: [
+          globalThis.FEDERATION_SSR && /* @__PURE__ */ (0, import_jsx_runtime.jsx)("script", {
+            suppressHydrationWarning: true,
+            dangerouslySetInnerHTML: {
+              __html: String.raw`
+                  globalThis['${import_constant.DATA_FETCH_FUNCTION}'] = globalThis['${import_constant.DATA_FETCH_FUNCTION}']  || []
+                  globalThis['${import_constant.DATA_FETCH_FUNCTION}'].push([${transformedError.dataFetchMapKey ? `'${transformedError.dataFetchMapKey}'` : ""},${params ? JSON.stringify(params) : null},true]);`
+            }
+          }),
+          errorElement(transformedError)
+        ]
+      }) : errorElement
+    });
+  }
+  const toRender = typeof children === "function" ? children(data) : children;
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_jsx_runtime.Fragment, {
+    children: toRender
+  });
+}
+const fetchData = (promise, ref) => {
+  let data;
+  let status = "pending";
+  const suspender = promise.then((res) => {
+    status = "success";
+    data = res;
+    ref.current = res;
+  }).catch((e) => {
+    status = "success";
+    console.warn(e);
+    data = AWAIT_ERROR_PREFIX + e;
+  });
+  return () => {
+    if (status === "pending") {
+      throw suspender;
+    }
+    return data;
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AwaitDataFetch,
+  transformError
+});