@module-federation/modern-js 0.14.2 → 0.15.0

package/dist/cjs/cli/mfRuntimePlugins/auto-fetch-data.js

@@ -0,0 +1,98 @@
+"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 downgradeType = remoteSnapshot.modules.find((module2) => module2.moduleName === `${dataFetchName}${import_constant2.DATA_FETCH_CLIENT_SUFFIX}`) ? import_constant.MF_DATA_FETCH_TYPE.FETCH_CLIENT : import_constant.MF_DATA_FETCH_TYPE.FETCH_SERVER;
+    let finalDataFetchId = dataFetchId;
+    if (typeof window !== "undefined") {
+      finalDataFetchId = downgradeType === import_constant.MF_DATA_FETCH_TYPE.FETCH_CLIENT ? `${dataFetchId}${import_constant2.DATA_FETCH_CLIENT_SUFFIX}` : 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/mfRuntimePlugins/inject-node-fetch.js

@@ -0,0 +1,44 @@
+"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 inject_node_fetch_exports = {};
+__export(inject_node_fetch_exports, {
+  default: () => inject_node_fetch_default
+});
+module.exports = __toCommonJS(inject_node_fetch_exports);
+var import_node_fetch = __toESM(require("node-fetch"));
+const injectNodeFetchPlugin = () => ({
+  name: "inject-node-fetch-plugin",
+  beforeInit(args) {
+    if (!globalThis.fetch) {
+      globalThis.fetch = import_node_fetch.default;
+    }
+    return args;
+  }
+});
+var inject_node_fetch_default = injectNodeFetchPlugin;

package/dist/cjs/cli/mfRuntimePlugins/resolve-entry-ipv4.js

@@ -0,0 +1,82 @@
+"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 resolve_entry_ipv4_exports = {};
+__export(resolve_entry_ipv4_exports, {
+  default: () => resolve_entry_ipv4_default
+});
+module.exports = __toCommonJS(resolve_entry_ipv4_exports);
+var import_constant = require("../../constant");
+const ipv4 = typeof FEDERATION_IPV4 !== "undefined" ? FEDERATION_IPV4 : "127.0.0.1";
+const remoteIpStrategy = typeof REMOTE_IP_STRATEGY !== "undefined" ? REMOTE_IP_STRATEGY : "inherit";
+function replaceObjectLocalhost(key, obj) {
+  if (remoteIpStrategy !== "ipv4") {
+    return;
+  }
+  if (!(key in obj)) {
+    return;
+  }
+  const remote = obj[key];
+  if (remote && typeof remote === "string" && remote.includes(import_constant.LOCALHOST)) {
+    obj[key] = replaceLocalhost(remote);
+  }
+}
+function replaceLocalhost(url) {
+  return url.replace(import_constant.LOCALHOST, ipv4);
+}
+const resolveEntryIpv4Plugin = () => ({
+  name: "resolve-entry-ipv4",
+  beforeRegisterRemote(args) {
+    const { remote } = args;
+    replaceObjectLocalhost("entry", remote);
+    return args;
+  },
+  async afterResolve(args) {
+    const { remoteInfo } = args;
+    replaceObjectLocalhost("entry", remoteInfo);
+    return args;
+  },
+  beforeLoadRemoteSnapshot(args) {
+    const { moduleInfo } = args;
+    if ("entry" in moduleInfo) {
+      replaceObjectLocalhost("entry", moduleInfo);
+      return args;
+    }
+    if ("version" in moduleInfo) {
+      replaceObjectLocalhost("version", moduleInfo);
+    }
+    return args;
+  },
+  loadRemoteSnapshot(args) {
+    const { remoteSnapshot } = args;
+    if ("publicPath" in remoteSnapshot) {
+      replaceObjectLocalhost("publicPath", remoteSnapshot);
+    }
+    if ("getPublicPath" in remoteSnapshot) {
+      replaceObjectLocalhost("getPublicPath", remoteSnapshot);
+    }
+    if (remoteSnapshot.remotesInfo) {
+      Object.keys(remoteSnapshot.remotesInfo).forEach((key) => {
+        const remoteInfo = remoteSnapshot.remotesInfo[key];
+        replaceObjectLocalhost("matchedVersion", remoteInfo);
+      });
+    }
+    return args;
+  }
+});
+var resolve_entry_ipv4_default = resolveEntryIpv4Plugin;

package/dist/cjs/cli/mfRuntimePlugins/shared-strategy.js

@@ -0,0 +1,43 @@
+"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 shared_strategy_exports = {};
+__export(shared_strategy_exports, {
+  default: () => shared_strategy_default
+});
+module.exports = __toCommonJS(shared_strategy_exports);
+const sharedStrategy = () => ({
+  name: "shared-strategy-plugin",
+  beforeInit(args) {
+    const { userOptions } = args;
+    const shared = userOptions.shared;
+    if (shared) {
+      Object.keys(shared).forEach((sharedKey) => {
+        const sharedConfigs = shared[sharedKey];
+        const arraySharedConfigs = Array.isArray(sharedConfigs) ? sharedConfigs : [
+          sharedConfigs
+        ];
+        arraySharedConfigs.forEach((s) => {
+          s.strategy = "loaded-first";
+        });
+      });
+    }
+    return args;
+  }
+});
+var shared_strategy_default = sharedStrategy;

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

@@ -0,0 +1,189 @@
+"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 data_fetch_server_plugin_exports = {};
+__export(data_fetch_server_plugin_exports, {
+  default: () => data_fetch_server_plugin_default
+});
+module.exports = __toCommonJS(data_fetch_server_plugin_exports);
+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) => {
+    api.onPrepare(() => {
+      const { middlewares } = api.getServerContext();
+      middlewares.push({
+        name: "module-federation-serve-manifest",
+        // @ts-ignore type error
+        handler: middleware
+      });
+    });
+  }
+});
+var data_fetch_server_plugin_default = dataFetchServePlugin;