@module-federation/modern-js 0.14.3 → 0.15.0

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

package/dist/cjs/runtime/createRemoteComponent.js

@@ -0,0 +1,327 @@
+"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 createRemoteComponent_exports = {};
+__export(createRemoteComponent_exports, {
+  collectSSRAssets: () => collectSSRAssets,
+  createRemoteComponent: () => createRemoteComponent,
+  createRemoteSSRComponent: () => createRemoteSSRComponent
+});
+module.exports = __toCommonJS(createRemoteComponent_exports);
+var import_jsx_runtime = require("react/jsx-runtime");
+var import_react = __toESM(require("react"));
+var import_logger = __toESM(require("../logger"));
+var import_runtime = require("@module-federation/enhanced/runtime");
+var import_AwaitDataFetch = require("./AwaitDataFetch");
+var import_dataFetch = require("../utils/dataFetch");
+var import_utils = require("../utils");
+var import_constant = require("../constant");
+function getTargetModuleInfo(id) {
+  const instance = (0, import_runtime.getInstance)();
+  if (!instance) {
+    return;
+  }
+  const loadedRemoteInfo = (0, import_utils.getLoadedRemoteInfos)(id, instance);
+  if (!loadedRemoteInfo) {
+    return;
+  }
+  const snapshot = loadedRemoteInfo.snapshot;
+  if (!snapshot) {
+    return;
+  }
+  const publicPath = "publicPath" in snapshot ? snapshot.publicPath : "getPublicPath" in snapshot ? new Function(snapshot.getPublicPath)() : "";
+  if (!publicPath) {
+    return;
+  }
+  const modules = "modules" in snapshot ? snapshot.modules : [];
+  const targetModule = modules.find((m) => m.modulePath === loadedRemoteInfo.expose);
+  if (!targetModule) {
+    return;
+  }
+  const remoteEntry = "remoteEntry" in snapshot ? snapshot.remoteEntry : "";
+  if (!remoteEntry) {
+    return;
+  }
+  return {
+    module: targetModule,
+    publicPath,
+    remoteEntry
+  };
+}
+function collectSSRAssets(options) {
+  const { id, injectLink = true, injectScript = false } = typeof options === "string" ? {
+    id: options
+  } : options;
+  const links = [];
+  const scripts = [];
+  const instance = (0, import_runtime.getInstance)();
+  if (!instance || !injectLink && !injectScript) {
+    return [
+      ...scripts,
+      ...links
+    ];
+  }
+  const moduleAndPublicPath = getTargetModuleInfo(id);
+  if (!moduleAndPublicPath) {
+    return [
+      ...scripts,
+      ...links
+    ];
+  }
+  const { module: targetModule, publicPath, remoteEntry } = moduleAndPublicPath;
+  if (injectLink) {
+    [
+      ...targetModule.assets.css.sync,
+      ...targetModule.assets.css.async
+    ].sort().forEach((file, index) => {
+      links.push(/* @__PURE__ */ (0, import_jsx_runtime.jsx)("link", {
+        href: `${publicPath}${file}`,
+        rel: "stylesheet",
+        type: "text/css"
+      }, `${file.split(".")[0]}_${index}`));
+    });
+  }
+  if (injectScript) {
+    scripts.push(/* @__PURE__ */ (0, import_jsx_runtime.jsx)("script", {
+      async: true,
+      src: `${publicPath}${remoteEntry}`,
+      crossOrigin: "anonymous"
+    }, remoteEntry.split(".")[0]));
+    [
+      ...targetModule.assets.js.sync
+    ].sort().forEach((file, index) => {
+      scripts.push(/* @__PURE__ */ (0, import_jsx_runtime.jsx)("script", {
+        async: true,
+        src: `${publicPath}${file}`,
+        crossOrigin: "anonymous"
+      }, `${file.split(".")[0]}_${index}`));
+    });
+  }
+  return [
+    ...scripts,
+    ...links
+  ];
+}
+function getServerNeedRemoteInfo(loadedRemoteInfo, id, noSSR) {
+  if (noSSR || typeof window !== "undefined" && window.location.href !== window[import_constant.FS_HREF]) {
+    var _dataFetchItem_;
+    if (!(loadedRemoteInfo === null || loadedRemoteInfo === void 0 ? void 0 : loadedRemoteInfo.version)) {
+      throw new Error(`${loadedRemoteInfo === null || loadedRemoteInfo === void 0 ? void 0 : loadedRemoteInfo.name} version is empty`);
+    }
+    const { snapshot } = loadedRemoteInfo;
+    if (!snapshot) {
+      throw new Error(`${loadedRemoteInfo === null || loadedRemoteInfo === void 0 ? void 0 : loadedRemoteInfo.name} snapshot is empty`);
+    }
+    const dataFetchItem = (0, import_dataFetch.getDataFetchItem)(id);
+    const isFetchServer = (dataFetchItem === null || dataFetchItem === void 0 ? void 0 : (_dataFetchItem_ = dataFetchItem[0]) === null || _dataFetchItem_ === void 0 ? void 0 : _dataFetchItem_[1]) === import_constant.MF_DATA_FETCH_TYPE.FETCH_SERVER;
+    if (isFetchServer && (!("ssrPublicPath" in snapshot) || !snapshot.ssrPublicPath)) {
+      throw new Error(`ssrPublicPath is required while fetching ${loadedRemoteInfo === null || loadedRemoteInfo === void 0 ? void 0 : loadedRemoteInfo.name} data in SSR project!`);
+    }
+    if (isFetchServer && (!("ssrRemoteEntry" in snapshot) || !snapshot.ssrRemoteEntry)) {
+      throw new Error(`ssrRemoteEntry is required while loading ${loadedRemoteInfo === null || loadedRemoteInfo === void 0 ? void 0 : loadedRemoteInfo.name} data loader in SSR project!`);
+    }
+    return {
+      name: loadedRemoteInfo.name,
+      version: loadedRemoteInfo.version,
+      ssrPublicPath: "ssrPublicPath" in snapshot ? snapshot.ssrPublicPath || "" : "",
+      ssrRemoteEntry: "ssrRemoteEntry" in snapshot ? snapshot.ssrRemoteEntry || "" : "",
+      globalName: loadedRemoteInfo.entryGlobalName
+    };
+  }
+  return;
+}
+function createRemoteComponent(options) {
+  const exportName = (options === null || options === void 0 ? void 0 : options.export) || "default";
+  const callLoader = async () => {
+    import_logger.default.debug("callLoader start", Date.now());
+    const m = await options.loader();
+    import_logger.default.debug("callLoader end", Date.now());
+    if (!m) {
+      throw new Error("load remote failed");
+    }
+    return m;
+  };
+  const getData = async (noSSR) => {
+    let loadedRemoteInfo;
+    let moduleId;
+    const instance = (0, import_runtime.getInstance)();
+    try {
+      const m = await callLoader();
+      moduleId = m && m[Symbol.for("mf_module_id")];
+      if (!moduleId) {
+        throw new Error("moduleId is empty");
+      }
+      loadedRemoteInfo = (0, import_utils.getLoadedRemoteInfos)(moduleId, instance);
+      if (!loadedRemoteInfo) {
+        throw new Error(`can not find loaded remote('${moduleId}') info!`);
+      }
+    } catch (e) {
+      const errMsg = `${import_constant.LOAD_REMOTE_ERROR_PREFIX}${e}`;
+      import_logger.default.debug(e);
+      throw new Error(errMsg);
+    }
+    let dataFetchMapKey;
+    try {
+      dataFetchMapKey = (0, import_dataFetch.getDataFetchMapKey)((0, import_utils.getDataFetchInfo)({
+        name: loadedRemoteInfo.name,
+        alias: loadedRemoteInfo.alias,
+        id: moduleId,
+        remoteSnapshot: loadedRemoteInfo.snapshot
+      }), {
+        name: instance.name,
+        version: instance === null || instance === void 0 ? void 0 : instance.options.version
+      });
+      import_logger.default.debug("getData dataFetchMapKey: ", dataFetchMapKey);
+      if (!dataFetchMapKey) {
+        return;
+      }
+      const data = await (0, import_dataFetch.fetchData)(dataFetchMapKey, {
+        ...options.dataFetchParams,
+        isDowngrade: false
+      }, getServerNeedRemoteInfo(loadedRemoteInfo, dataFetchMapKey, noSSR));
+      (0, import_utils.setDataFetchItemLoadedStatus)(dataFetchMapKey);
+      import_logger.default.debug("get data res: \n", data);
+      return data;
+    } catch (err) {
+      const errMsg = `${import_constant.DATA_FETCH_ERROR_PREFIX}${(0, import_utils.wrapDataFetchId)(dataFetchMapKey)}${err}`;
+      import_logger.default.debug(errMsg);
+      throw new Error(errMsg);
+    }
+  };
+  const LazyComponent = /* @__PURE__ */ import_react.default.lazy(async () => {
+    const m = await callLoader();
+    const moduleId = m && m[Symbol.for("mf_module_id")];
+    const instance = (0, import_runtime.getInstance)();
+    const loadedRemoteInfo = (0, import_utils.getLoadedRemoteInfos)(moduleId, instance);
+    loadedRemoteInfo === null || loadedRemoteInfo === void 0 ? void 0 : loadedRemoteInfo.snapshot;
+    const dataFetchMapKey = loadedRemoteInfo ? (0, import_dataFetch.getDataFetchMapKey)((0, import_utils.getDataFetchInfo)({
+      name: loadedRemoteInfo.name,
+      alias: loadedRemoteInfo.alias,
+      id: moduleId,
+      remoteSnapshot: loadedRemoteInfo.snapshot
+    }), {
+      name: instance.name,
+      version: instance === null || instance === void 0 ? void 0 : instance.options.version
+    }) : void 0;
+    import_logger.default.debug("LazyComponent dataFetchMapKey: ", dataFetchMapKey);
+    const assets = collectSSRAssets({
+      id: moduleId
+    });
+    const Com = m[exportName];
+    if (exportName in m && typeof Com === "function") {
+      return {
+        default: (props) => /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_jsx_runtime.Fragment, {
+          children: [
+            globalThis.FEDERATION_SSR && dataFetchMapKey && /* @__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(['${dataFetchMapKey}',${JSON.stringify(props.mfData)}]);
+                  `
+              }
+            }),
+            globalThis.FEDERATION_SSR && assets,
+            /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Com, {
+              ...props
+            })
+          ]
+        })
+      };
+    } else {
+      throw Error(`Make sure that ${moduleId} has the correct export when export is ${String(exportName)}`);
+    }
+  });
+  return (props) => {
+    const { key, ...args } = props;
+    if (globalThis.FEDERATION_SSR && !options.noSSR) {
+      const { key: key2, ...args2 } = props;
+      return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_AwaitDataFetch.AwaitDataFetch, {
+        resolve: getData(options.noSSR),
+        loading: options.loading,
+        errorElement: options.fallback,
+        children: (data) => /* @__PURE__ */ (0, import_jsx_runtime.jsx)(LazyComponent, {
+          ...args2,
+          mfData: data
+        })
+      });
+    } else {
+      const [data, setData] = (0, import_react.useState)(null);
+      const [loading, setLoading] = (0, import_react.useState)(true);
+      const [error, setError] = (0, import_react.useState)(null);
+      (0, import_react.useEffect)(() => {
+        let isMounted = true;
+        const fetchDataAsync = async () => {
+          try {
+            setLoading(true);
+            const result = await getData(options.noSSR);
+            if (isMounted) {
+              setData(result);
+            }
+          } catch (e) {
+            if (isMounted) {
+              setError((0, import_AwaitDataFetch.transformError)(e));
+            }
+          } finally {
+            if (isMounted) {
+              setLoading(false);
+            }
+          }
+        };
+        fetchDataAsync();
+        return () => {
+          isMounted = false;
+        };
+      }, []);
+      if (loading) {
+        return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_jsx_runtime.Fragment, {
+          children: options.loading
+        });
+      }
+      if (error) {
+        return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_jsx_runtime.Fragment, {
+          children: typeof options.fallback === "function" ? options.fallback(error) : options.fallback
+        });
+      }
+      return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(LazyComponent, {
+        ...args,
+        mfData: data
+      });
+    }
+  };
+}
+function createRemoteSSRComponent(options) {
+  import_logger.default.warn("createRemoteSSRComponent is deprecated, please use createRemoteComponent instead!");
+  return createRemoteComponent(options);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  collectSSRAssets,
+  createRemoteComponent,
+  createRemoteSSRComponent
+});

package/dist/cjs/runtime/index.js

@@ -19,20 +19,32 @@ var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "defau
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var runtime_exports = {};
 __export(runtime_exports, {
-  kit: () => kit
+  ERROR_TYPE: () => import_constant.ERROR_TYPE,
+  kit: () => kit,
+  setSSREnv: () => import_injectDataFetchFunctionPlugin.setSSREnv
 });
 module.exports = __toCommonJS(runtime_exports);
 __reExport(runtime_exports, require("@module-federation/enhanced/runtime"), module.exports);
+var import_constant = require("../constant");
+var import_injectDataFetchFunctionPlugin = require("../ssr-runtime/injectDataFetchFunctionPlugin");
 const kit = {
   get createRemoteSSRComponent() {
-    return require("./createRemoteSSRComponent").createRemoteSSRComponent;
+    return require("./createRemoteComponent").createRemoteSSRComponent;
+  },
+  get createRemoteComponent() {
+    return require("./createRemoteComponent").createRemoteComponent;
   },
   get collectSSRAssets() {
-    return require("./createRemoteSSRComponent").collectSSRAssets;
+    return require("./createRemoteComponent").collectSSRAssets;
+  },
+  get wrapNoSSR() {
+    return require("./wrapNoSSR").wrapNoSSR;
   }
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  ERROR_TYPE,
   kit,
+  setSSREnv,
   ...require("@module-federation/enhanced/runtime")
 });

package/dist/cjs/{cli/constant.js → runtime/wrapNoSSR.js}

@@ -16,13 +16,20 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var constant_exports = {};
-__export(constant_exports, {
-  isDev: () => isDev
+var wrapNoSSR_exports = {};
+__export(wrapNoSSR_exports, {
+  wrapNoSSR: () => wrapNoSSR
 });
-module.exports = __toCommonJS(constant_exports);
-const isDev = process.env.NODE_ENV === "development";
+module.exports = __toCommonJS(wrapNoSSR_exports);
+function wrapNoSSR(createComponentFn) {
+  return (options) => {
+    return createComponentFn({
+      ...options,
+      noSSR: true
+    });
+  };
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  isDev
+  wrapNoSSR
 });

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

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

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

@@ -0,0 +1,114 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var downgrade_exports = {};
+__export(downgrade_exports, {
+  callAllDowngrade: () => callAllDowngrade,
+  callDowngrade: () => callDowngrade,
+  getDowngradeTag: () => getDowngradeTag
+});
+module.exports = __toCommonJS(downgrade_exports);
+var import_constant = require("../constant");
+var import_constant2 = require("../constant");
+var import_utils = require("../utils");
+function getDowngradeTag() {
+  return globalThis[import_constant.DOWNGRADE_KEY];
+}
+function callAllDowngrade() {
+  const dataFetchMap = (0, import_utils.getDataFetchMap)();
+  if (!dataFetchMap) {
+    return;
+  }
+  Object.keys(dataFetchMap).forEach((key) => {
+    callDowngrade(key);
+  });
+}
+async function callDowngrade(id, params, remoteInfo) {
+  const dataFetchMap = (0, import_utils.getDataFetchMap)();
+  if (!dataFetchMap) {
+    return;
+  }
+  const mfDataFetch = dataFetchMap[id];
+  if ((mfDataFetch === null || mfDataFetch === void 0 ? void 0 : mfDataFetch[2]) === import_constant2.MF_DATA_FETCH_STATUS.AWAIT) {
+    mfDataFetch[2] = import_constant2.MF_DATA_FETCH_STATUS.LOADING;
+    let promise, res, rej;
+    if (mfDataFetch[1]) {
+      promise = mfDataFetch[1][0];
+      res = mfDataFetch[1][1];
+      rej = mfDataFetch[1][2];
+    } else {
+      promise = new Promise((resolve, reject) => {
+        res = resolve;
+        rej = reject;
+      });
+      mfDataFetch[1] = [
+        promise,
+        res,
+        rej
+      ];
+    }
+    const dataFetchType = mfDataFetch[0][1];
+    if (dataFetchType === import_constant2.MF_DATA_FETCH_TYPE.FETCH_CLIENT) {
+      try {
+        mfDataFetch[0][0]().then((getDataFetchFn) => {
+          return getDataFetchFn({
+            ...params,
+            isDowngrade: true
+          }).then((data) => {
+            mfDataFetch[2] = import_constant2.MF_DATA_FETCH_STATUS.LOADED;
+            res(data);
+          });
+        });
+      } catch (e) {
+        mfDataFetch[2] = import_constant2.MF_DATA_FETCH_STATUS.ERROR;
+        rej(e);
+      }
+    } else if (dataFetchType === import_constant2.MF_DATA_FETCH_TYPE.FETCH_SERVER) {
+      try {
+        const currentUrl = new URL(window.location.href);
+        currentUrl.searchParams.set(import_constant.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)));
+        }
+        const fetchServerQuery = globalThis.FEDERATION_SERVER_QUERY;
+        if (fetchServerQuery && typeof fetchServerQuery === "object") {
+          Object.keys(fetchServerQuery).forEach((key) => {
+            currentUrl.searchParams.set(key, JSON.stringify(fetchServerQuery[key]));
+          });
+        }
+        const fetchUrl = currentUrl.toString();
+        const data = await fetch(fetchUrl).then((res2) => res2.json());
+        mfDataFetch[2] = import_constant2.MF_DATA_FETCH_STATUS.LOADED;
+        res(data);
+      } catch (e) {
+        mfDataFetch[2] = import_constant2.MF_DATA_FETCH_STATUS.ERROR;
+        rej(e);
+      }
+    }
+    return promise;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  callAllDowngrade,
+  callDowngrade,
+  getDowngradeTag
+});