@module-federation/modern-js 0.14.2 → 0.15.0

package/dist/esm/cli/ssrPlugin.js

@@ -0,0 +1,219 @@
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _type_of } from "@swc/helpers/_/_type_of";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
+import path from "path";
+import fs from "fs-extra";
+import { ModuleFederationPlugin } from "@module-federation/enhanced/webpack";
+import { ModuleFederationPlugin as RspackModuleFederationPlugin } from "@module-federation/enhanced/rspack";
+import UniverseEntryChunkTrackerPlugin from "@module-federation/node/universe-entry-chunk-tracker-plugin";
+import logger from "../logger";
+import { isDev } from "./utils";
+import { updateStatsAndManifest } from "@module-federation/rsbuild-plugin/manifest";
+import { isWebTarget, skipByTarget } from "./utils";
+function setEnv() {
+  process.env["MF_DISABLE_EMIT_STATS"] = "true";
+  process.env["MF_SSR_PRJ"] = "true";
+}
+var CHAIN_MF_PLUGIN_ID = "plugin-module-federation-server";
+var mfSSRRsbuildPlugin = function(pluginOptions) {
+  return {
+    name: "@modern-js/plugin-mf-post-config",
+    pre: [
+      "@modern-js/builder-plugin-ssr"
+    ],
+    setup: function setup(api) {
+      if (pluginOptions.csrConfig.getPublicPath) {
+        return;
+      }
+      var csrOutputPath = "";
+      var ssrOutputPath = "";
+      var ssrEnv = "";
+      api.modifyEnvironmentConfig(function(config, param) {
+        var name = param.name;
+        var target = config.output.target;
+        if (skipByTarget(target)) {
+          return config;
+        }
+        if (isWebTarget(target)) {
+          csrOutputPath = config.output.distPath.root;
+        } else {
+          ssrOutputPath = config.output.distPath.root;
+          ssrEnv = name;
+        }
+        return config;
+      });
+      var modifySSRPublicPath = function(config, utils) {
+        if (ssrEnv !== utils.environment.name) {
+          return config;
+        }
+        var userSSRConfig = pluginOptions.userConfig.ssr ? _type_of(pluginOptions.userConfig.ssr) === "object" ? pluginOptions.userConfig.ssr : {} : {};
+        if (userSSRConfig.distOutputDir) {
+          return;
+        }
+        config.output.publicPath = "".concat(config.output.publicPath).concat(path.relative(csrOutputPath, ssrOutputPath), "/");
+        return config;
+      };
+      api.modifyWebpackConfig(function(config, utils) {
+        modifySSRPublicPath(config, utils);
+        return config;
+      });
+      api.modifyRspackConfig(function(config, utils) {
+        modifySSRPublicPath(config, utils);
+        return config;
+      });
+    }
+  };
+};
+var moduleFederationSSRPlugin = function(pluginOptions) {
+  return {
+    name: "@modern-js/plugin-module-federation-ssr",
+    pre: [
+      "@modern-js/plugin-module-federation-config",
+      "@modern-js/plugin-module-federation"
+    ],
+    setup: function() {
+      var _ref = _async_to_generator(function(api) {
+        var _pluginOptions_userConfig, _modernjsConfig_server, modernjsConfig, _pluginOptions_userConfig_ssr, enableSSR;
+        return _ts_generator(this, function(_state) {
+          modernjsConfig = api.getConfig();
+          enableSSR = (_pluginOptions_userConfig_ssr = (_pluginOptions_userConfig = pluginOptions.userConfig) === null || _pluginOptions_userConfig === void 0 ? void 0 : _pluginOptions_userConfig.ssr) !== null && _pluginOptions_userConfig_ssr !== void 0 ? _pluginOptions_userConfig_ssr : Boolean(modernjsConfig === null || modernjsConfig === void 0 ? void 0 : (_modernjsConfig_server = modernjsConfig.server) === null || _modernjsConfig_server === void 0 ? void 0 : _modernjsConfig_server.ssr);
+          if (!enableSSR) {
+            return [
+              2
+            ];
+          }
+          setEnv();
+          api._internalRuntimePlugins(function(param) {
+            var entrypoint = param.entrypoint, plugins = param.plugins;
+            var fetchServerQuery = pluginOptions.fetchServerQuery;
+            plugins.push({
+              name: "injectDataFetchFunction",
+              path: "@module-federation/modern-js/ssr-inject-data-fetch-function-plugin",
+              config: {
+                fetchServerQuery
+              }
+            });
+            if (!isDev()) {
+              return {
+                entrypoint,
+                plugins
+              };
+            }
+            plugins.push({
+              name: "mfSSRDev",
+              path: "@module-federation/modern-js/ssr-dev-plugin",
+              config: {}
+            });
+            return {
+              entrypoint,
+              plugins
+            };
+          });
+          if (pluginOptions.ssrConfig.remotes) {
+            api._internalServerPlugins(function(param) {
+              var plugins = param.plugins;
+              plugins.push({
+                name: "@module-federation/modern-js/data-fetch-server-plugin",
+                options: {}
+              });
+              return {
+                plugins
+              };
+            });
+          }
+          api.modifyBundlerChain(function(chain) {
+            var target = chain.get("target");
+            if (skipByTarget(target)) {
+              return;
+            }
+            var bundlerType = api.getAppContext().bundlerType === "rspack" ? "rspack" : "webpack";
+            var MFPlugin = bundlerType === "webpack" ? ModuleFederationPlugin : RspackModuleFederationPlugin;
+            var isWeb = isWebTarget(target);
+            if (!isWeb) {
+              if (!chain.plugins.has(CHAIN_MF_PLUGIN_ID)) {
+                chain.plugin(CHAIN_MF_PLUGIN_ID).use(MFPlugin, [
+                  pluginOptions.ssrConfig
+                ]).init(function(Plugin, args) {
+                  pluginOptions.nodePlugin = new Plugin(args[0]);
+                  return pluginOptions.nodePlugin;
+                });
+              }
+            }
+            if (!isWeb) {
+              chain.target("async-node");
+              if (isDev()) {
+                chain.plugin("UniverseEntryChunkTrackerPlugin").use(UniverseEntryChunkTrackerPlugin);
+              }
+              var userSSRConfig = pluginOptions.userConfig.ssr ? _type_of(pluginOptions.userConfig.ssr) === "object" ? pluginOptions.userConfig.ssr : {} : {};
+              var publicPath = chain.output.get("publicPath");
+              if (userSSRConfig.distOutputDir && publicPath) {
+                chain.output.publicPath("".concat(publicPath).concat(userSSRConfig.distOutputDir, "/"));
+              }
+            }
+            if (isDev() && isWeb) {
+              chain.externals({
+                "@module-federation/node/utils": "NOT_USED_IN_BROWSER"
+              });
+            }
+          });
+          api.config(function() {
+            return {
+              builderPlugins: [
+                mfSSRRsbuildPlugin(pluginOptions)
+              ],
+              tools: {
+                devServer: {
+                  before: [
+                    function(req, res, next) {
+                      if (!enableSSR) {
+                        next();
+                        return;
+                      }
+                      try {
+                        var _req_url, _req_url1;
+                        if (((_req_url = req.url) === null || _req_url === void 0 ? void 0 : _req_url.includes(".json")) && !((_req_url1 = req.url) === null || _req_url1 === void 0 ? void 0 : _req_url1.includes("hot-update"))) {
+                          var filepath = path.join(process.cwd(), "dist".concat(req.url));
+                          fs.statSync(filepath);
+                          res.setHeader("Access-Control-Allow-Origin", "*");
+                          res.setHeader("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, PATCH, OPTIONS");
+                          res.setHeader("Access-Control-Allow-Headers", "*");
+                          fs.createReadStream(filepath).pipe(res);
+                        } else {
+                          next();
+                        }
+                      } catch (err) {
+                        logger.debug(err);
+                        next();
+                      }
+                    }
+                  ]
+                }
+              }
+            };
+          });
+          api.onAfterBuild(function() {
+            var nodePlugin = pluginOptions.nodePlugin, browserPlugin = pluginOptions.browserPlugin, distOutputDir = pluginOptions.distOutputDir;
+            updateStatsAndManifest(nodePlugin, browserPlugin, distOutputDir);
+          });
+          api.onDevCompileDone(function() {
+            var nodePlugin = pluginOptions.nodePlugin, browserPlugin = pluginOptions.browserPlugin, distOutputDir = pluginOptions.distOutputDir;
+            updateStatsAndManifest(nodePlugin, browserPlugin, distOutputDir);
+          });
+          return [
+            2
+          ];
+        });
+      });
+      return function(api) {
+        return _ref.apply(this, arguments);
+      };
+    }()
+  };
+};
+var ssrPlugin_default = moduleFederationSSRPlugin;
+export {
+  CHAIN_MF_PLUGIN_ID,
+  ssrPlugin_default as default,
+  moduleFederationSSRPlugin,
+  setEnv
+};

package/dist/esm/cli/utils.js

@@ -0,0 +1,53 @@
+import os from "os";
+var localIpv4 = "127.0.0.1";
+var getIpv4Interfaces = function() {
+  try {
+    var interfaces = os.networkInterfaces();
+    var ipv4Interfaces = [];
+    Object.values(interfaces).forEach(function(detail) {
+      detail === null || detail === void 0 ? void 0 : detail.forEach(function(detail2) {
+        var familyV4Value = typeof detail2.family === "string" ? "IPv4" : 4;
+        if (detail2.family === familyV4Value && detail2.address !== localIpv4) {
+          ipv4Interfaces.push(detail2);
+        }
+      });
+    });
+    return ipv4Interfaces;
+  } catch (_err) {
+    return [];
+  }
+};
+var getIPV4 = function() {
+  var ipv4Interfaces = getIpv4Interfaces();
+  var ipv4Interface = ipv4Interfaces[0] || {
+    address: localIpv4
+  };
+  return ipv4Interface.address;
+};
+var isWebTarget = function(target) {
+  var WEB_TARGET = "web";
+  if (Array.isArray(target)) {
+    return target.includes(WEB_TARGET);
+  } else if (typeof target === "string") {
+    return target === WEB_TARGET;
+  }
+  return false;
+};
+var skipByTarget = function(target) {
+  var IGNORE_TARGET = "webworker";
+  if (Array.isArray(target)) {
+    return target.includes(IGNORE_TARGET);
+  } else if (typeof target === "string") {
+    return target === IGNORE_TARGET;
+  }
+  return false;
+};
+function isDev() {
+  return process.env.NODE_ENV === "development";
+}
+export {
+  getIPV4,
+  isDev,
+  isWebTarget,
+  skipByTarget
+};

package/dist/esm/constant.js

@@ -0,0 +1,42 @@
+var LOCALHOST = "localhost";
+var PLUGIN_IDENTIFIER = "[ Modern.js Module Federation ]";
+var DATA_FETCH_QUERY = "x-mf-data-fetch";
+var DATA_FETCH_ERROR_PREFIX = "caught the following error during dataFetch: ";
+var LOAD_REMOTE_ERROR_PREFIX = "caught the following error during loadRemote: ";
+var DOWNGRADE_KEY = "_mfSSRDowngrade";
+var DATA_FETCH_MAP_KEY = "__MF_DATA_FETCH_MAP__";
+var DATA_FETCH_FUNCTION = "_mfDataFetch";
+var FS_HREF = "_mfFSHref";
+var ERROR_TYPE = {
+  DATA_FETCH: 1,
+  LOAD_REMOTE: 2,
+  UNKNOWN: 3
+};
+var 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 = {}));
+export {
+  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,
+  MF_DATA_FETCH_STATUS,
+  MF_DATA_FETCH_TYPE,
+  PLUGIN_IDENTIFIER,
+  WRAP_DATA_FETCH_ID_IDENTIFIER
+};

package/dist/esm/logger.js

@@ -0,0 +1,7 @@
+import { createLogger } from "@module-federation/sdk";
+import { PLUGIN_IDENTIFIER } from "./constant";
+var logger = createLogger(PLUGIN_IDENTIFIER);
+var logger_default = logger;
+export {
+  logger_default as default
+};

package/dist/esm/runtime/AwaitDataFetch.js

@@ -0,0 +1,131 @@
+import { _ as _instanceof } from "@swc/helpers/_/_instanceof";
+import { _ as _tagged_template_literal } from "@swc/helpers/_/_tagged_template_literal";
+import { _ as _type_of } from "@swc/helpers/_/_type_of";
+function _templateObject() {
+  var data = _tagged_template_literal([
+    "\n                  globalThis['",
+    "'] = globalThis['",
+    "']  || []\n                  globalThis['",
+    "'].push([",
+    ",",
+    ",true]);"
+  ]);
+  _templateObject = function _templateObject2() {
+    return data;
+  };
+  return data;
+}
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { Suspense, useRef } from "react";
+import logger from "../logger";
+import { DATA_FETCH_ERROR_PREFIX, LOAD_REMOTE_ERROR_PREFIX, ERROR_TYPE, DATA_FETCH_FUNCTION } from "../constant";
+import { getDataFetchIdWithErrorMsgs, wrapDataFetchId } from "../utils";
+function isPromise(obj) {
+  return !!obj && ((typeof obj === "undefined" ? "undefined" : _type_of(obj)) === "object" || typeof obj === "function") && typeof obj.then === "function";
+}
+var AWAIT_ERROR_PREFIX = "<Await /> caught the following error during render: ";
+var transformError = function(err) {
+  var errMsg = _instanceof(err, Error) ? err.message : err;
+  var originalMsg = errMsg.replace(AWAIT_ERROR_PREFIX, "");
+  var dataFetchMapKey = getDataFetchIdWithErrorMsgs(originalMsg);
+  if (originalMsg.indexOf(DATA_FETCH_ERROR_PREFIX) === 0) {
+    return {
+      error: new Error(originalMsg.replace(DATA_FETCH_ERROR_PREFIX, "").replace(wrapDataFetchId(dataFetchMapKey), "")),
+      errorType: ERROR_TYPE.DATA_FETCH,
+      dataFetchMapKey
+    };
+  }
+  if (originalMsg.indexOf(LOAD_REMOTE_ERROR_PREFIX) === 0) {
+    return {
+      error: new Error(originalMsg.replace(LOAD_REMOTE_ERROR_PREFIX, "").replace(wrapDataFetchId(dataFetchMapKey), "")),
+      errorType: ERROR_TYPE.LOAD_REMOTE,
+      dataFetchMapKey
+    };
+  }
+  return {
+    error: new Error(originalMsg.replace(wrapDataFetchId(dataFetchMapKey), "")),
+    errorType: ERROR_TYPE.UNKNOWN,
+    dataFetchMapKey
+  };
+};
+var DefaultLoading = /* @__PURE__ */ _jsx(_Fragment, {});
+var DefaultErrorElement = function(_data) {
+  return /* @__PURE__ */ _jsx("div", {
+    children: "Error"
+  });
+};
+function AwaitDataFetch(param) {
+  var resolve = param.resolve, _param_loading = param.loading, loading = _param_loading === void 0 ? DefaultLoading : _param_loading, _param_errorElement = param.errorElement, errorElement = _param_errorElement === void 0 ? DefaultErrorElement : _param_errorElement, children = param.children, params = param.params;
+  var dataRef = useRef();
+  var data = dataRef.current || resolve;
+  var getData = isPromise(data) ? fetchData(data, dataRef) : function() {
+    return data;
+  };
+  return /* @__PURE__ */ _jsx(AwaitSuspense, {
+    params,
+    loading,
+    errorElement,
+    // @ts-ignore
+    resolve: getData,
+    children
+  });
+}
+function AwaitSuspense(param) {
+  var resolve = param.resolve, children = param.children, _param_loading = param.loading, loading = _param_loading === void 0 ? DefaultLoading : _param_loading, _param_errorElement = param.errorElement, errorElement = _param_errorElement === void 0 ? DefaultErrorElement : _param_errorElement;
+  return /* @__PURE__ */ _jsx(Suspense, {
+    fallback: loading,
+    children: /* @__PURE__ */ _jsx(ResolveAwait, {
+      resolve,
+      errorElement,
+      children
+    })
+  });
+}
+function ResolveAwait(param) {
+  var children = param.children, resolve = param.resolve, errorElement = param.errorElement, params = param.params;
+  var data = resolve();
+  logger.debug("resolve data: ", data);
+  if (typeof data === "string" && data.indexOf(AWAIT_ERROR_PREFIX) === 0) {
+    var transformedError = transformError(data);
+    return /* @__PURE__ */ _jsx(_Fragment, {
+      children: typeof errorElement === "function" ? /* @__PURE__ */ _jsxs(_Fragment, {
+        children: [
+          globalThis.FEDERATION_SSR && /* @__PURE__ */ _jsx("script", {
+            suppressHydrationWarning: true,
+            dangerouslySetInnerHTML: {
+              __html: String.raw(_templateObject(), DATA_FETCH_FUNCTION, DATA_FETCH_FUNCTION, DATA_FETCH_FUNCTION, transformedError.dataFetchMapKey ? "'".concat(transformedError.dataFetchMapKey, "'") : "", params ? JSON.stringify(params) : null)
+            }
+          }),
+          errorElement(transformedError)
+        ]
+      }) : errorElement
+    });
+  }
+  var toRender = typeof children === "function" ? children(data) : children;
+  return /* @__PURE__ */ _jsx(_Fragment, {
+    children: toRender
+  });
+}
+var fetchData = function(promise, ref) {
+  var data;
+  var status = "pending";
+  var suspender = promise.then(function(res) {
+    status = "success";
+    data = res;
+    ref.current = res;
+  }).catch(function(e) {
+    status = "success";
+    console.warn(e);
+    data = AWAIT_ERROR_PREFIX + e;
+  });
+  return function() {
+    if (status === "pending") {
+      throw suspender;
+    }
+    return data;
+  };
+};
+export {
+  AwaitDataFetch,
+  transformError
+};