@module-federation/modern-js 0.0.0-next-20250522125627 → 0.0.0-next-20250522130707

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

@@ -0,0 +1,129 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var injectDataFetchFunctionPlugin_exports = {};
+__export(injectDataFetchFunctionPlugin_exports, {
+  injectDataFetchFunctionPlugin: () => injectDataFetchFunctionPlugin
+});
+module.exports = __toCommonJS(injectDataFetchFunctionPlugin_exports);
+var import_constant = require("../constant");
+var import_logger = __toESM(require("../logger"));
+var import_utils = require("../utils");
+var import_downgrade = require("./downgrade");
+const injectDataFetchFunctionPlugin = () => ({
+  name: "@module-federation/inject-data-fetch-function-plugin",
+  setup: (api) => {
+    api.onBeforeRender(async () => {
+      var _globalThis, _DATA_FETCH_FUNCTION;
+      globalThis.FEDERATION_SSR = true;
+      if (typeof window === "undefined") {
+        return;
+      }
+      const dataFetchFunction = async function(options) {
+        const [id, data, downgrade] = options;
+        import_logger.default.debug("==========call data fetch function!");
+        if (data) {
+          if (!id) {
+            throw new Error("id is required!");
+          }
+          if (!(0, import_utils.getDataFetchMap)()) {
+            (0, import_utils.initDataFetchMap)();
+          }
+          const dataFetchItem = (0, import_utils.getDataFetchItem)(id);
+          if (dataFetchItem) {
+            var _dataFetchItem__, _dataFetchItem_;
+            (_dataFetchItem_ = dataFetchItem[1]) === null || _dataFetchItem_ === void 0 ? void 0 : (_dataFetchItem__ = _dataFetchItem_[1]) === null || _dataFetchItem__ === void 0 ? void 0 : _dataFetchItem__.call(_dataFetchItem_, data);
+            dataFetchItem[2] = import_constant.MF_DATA_FETCH_STATUS.LOADED;
+            return;
+          }
+          if (!dataFetchItem) {
+            const dataFetchMap = (0, import_utils.getDataFetchMap)();
+            let res;
+            let rej;
+            const p = new Promise((resolve, reject) => {
+              res = resolve;
+              rej = reject;
+            });
+            dataFetchMap[id] = [
+              [
+                async () => async () => {
+                  return "";
+                },
+                import_constant.MF_DATA_FETCH_TYPE.FETCH_SERVER
+              ],
+              [
+                p,
+                res,
+                rej
+              ],
+              import_constant.MF_DATA_FETCH_STATUS.LOADED
+            ];
+            res(data);
+            return;
+          }
+        }
+        if (downgrade) {
+          const mfDowngrade2 = (0, import_downgrade.getDowngradeTag)();
+          if (!mfDowngrade2) {
+            globalThis[import_constant.DOWNGRADE_KEY] = id ? [
+              id
+            ] : true;
+          } else if (Array.isArray(mfDowngrade2) && id && !mfDowngrade2.includes(id)) {
+            mfDowngrade2.push(id);
+          }
+        }
+        const mfDowngrade = (0, import_downgrade.getDowngradeTag)();
+        if (typeof mfDowngrade === "boolean") {
+          return (0, import_downgrade.callAllDowngrade)();
+        }
+        if (Array.isArray(mfDowngrade)) {
+          if (!id) {
+            globalThis[import_constant.DOWNGRADE_KEY] = true;
+            return (0, import_downgrade.callAllDowngrade)();
+          }
+          if (mfDowngrade.includes(id)) {
+            return;
+          }
+          mfDowngrade.push(id);
+          return (0, import_downgrade.callDowngrade)(id);
+        }
+      };
+      globalThis[import_constant.FS_HREF] = window.location.href;
+      (_globalThis = globalThis)[_DATA_FETCH_FUNCTION = import_constant.DATA_FETCH_FUNCTION] || (_globalThis[_DATA_FETCH_FUNCTION] = []);
+      const dataFetch = globalThis[import_constant.DATA_FETCH_FUNCTION];
+      await Promise.all(dataFetch.map(async (options) => {
+        await dataFetchFunction(options);
+      }));
+      dataFetch.push = dataFetchFunction;
+    });
+  }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  injectDataFetchFunctionPlugin
+});

package/dist/cjs/types/index.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 types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/dist/cjs/utils/dataFetch.js

@@ -0,0 +1,200 @@
+"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,
+  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);
+      }
+      if (mfDowngrade.includes(id)) {
+        return (0, import_downgrade.callDowngrade)(id, params);
+      }
+    }
+    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)}`);
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  fetchData,
+  flushDataFetch,
+  getDataFetchIdWithErrorMsgs,
+  getDataFetchInfo,
+  getDataFetchItem,
+  getDataFetchMap,
+  getDataFetchMapKey,
+  initDataFetchMap,
+  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")
+});