@module-federation/modern-js 0.0.0-next-20250526074234 → 0.0.0-next-20250527094526

package/dist/esm/cli/ssrPlugin.js

@@ -2,13 +2,13 @@ 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 "@modern-js/utils";
+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 { updateStatsAndManifest } from "./manifest";
-import logger from "../logger";
-import { isDev } from "./utils";
+import { isDev } from "./constant";
+import logger from "./logger";
 import { isWebTarget, skipByTarget } from "./utils";
 function setEnv() {
   process.env["MF_DISABLE_EMIT_STATS"] = "true";
@@ -85,23 +85,15 @@ var moduleFederationSSRPlugin = function(pluginOptions) {
           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()) {
+            if (!isDev) {
               return {
                 entrypoint,
                 plugins
               };
             }
             plugins.push({
-              name: "mfSSRDev",
-              path: "@module-federation/modern-js/ssr-dev-plugin",
+              name: "mfSSR",
+              path: "@module-federation/modern-js/ssr-runtime",
               config: {}
             });
             return {
@@ -109,18 +101,6 @@ var moduleFederationSSRPlugin = function(pluginOptions) {
               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)) {
@@ -141,7 +121,7 @@ var moduleFederationSSRPlugin = function(pluginOptions) {
             }
             if (!isWeb) {
               chain.target("async-node");
-              if (isDev()) {
+              if (isDev) {
                 chain.plugin("UniverseEntryChunkTrackerPlugin").use(UniverseEntryChunkTrackerPlugin);
               }
               var userSSRConfig = pluginOptions.userConfig.ssr ? _type_of(pluginOptions.userConfig.ssr) === "object" ? pluginOptions.userConfig.ssr : {} : {};
@@ -150,7 +130,7 @@ var moduleFederationSSRPlugin = function(pluginOptions) {
                 chain.output.publicPath("".concat(publicPath).concat(userSSRConfig.distOutputDir, "/"));
               }
             }
-            if (isDev() && isWeb) {
+            if (isDev && isWeb) {
               chain.externals({
                 "@module-federation/node/utils": "NOT_USED_IN_BROWSER"
               });

package/dist/esm/cli/utils.js

@@ -42,12 +42,8 @@ var skipByTarget = function(target) {
   }
   return false;
 };
-function isDev() {
-  return process.env.NODE_ENV === "development";
-}
 export {
   getIPV4,
-  isDev,
   isWebTarget,
   skipByTarget
 };

package/dist/esm/constant.js

@@ -1,42 +1,6 @@
 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
+  PLUGIN_IDENTIFIER
 };

package/dist/esm/runtime/createRemoteSSRComponent.js

@@ -0,0 +1,191 @@
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _object_spread } from "@swc/helpers/_/_object_spread";
+import { _ as _object_spread_props } from "@swc/helpers/_/_object_spread_props";
+import { _ as _object_without_properties } from "@swc/helpers/_/_object_without_properties";
+import { _ as _to_consumable_array } from "@swc/helpers/_/_to_consumable_array";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import React from "react";
+import { getInstance } from "@module-federation/enhanced/runtime";
+import { ErrorBoundary } from "react-error-boundary";
+function getLoadedRemoteInfos(instance, id) {
+  var _ref = instance.remoteHandler.idToRemoteMap[id] || {}, name = _ref.name, expose = _ref.expose;
+  if (!name) {
+    return;
+  }
+  var module = instance.moduleCache.get(name);
+  if (!module) {
+    return;
+  }
+  var remoteSnapshot = instance.snapshotHandler.getGlobalRemoteInfo(module.remoteInfo).remoteSnapshot;
+  return _object_spread_props(_object_spread({}, module.remoteInfo), {
+    snapshot: remoteSnapshot,
+    expose
+  });
+}
+function getTargetModuleInfo(id) {
+  var instance = getInstance();
+  if (!instance) {
+    return;
+  }
+  var loadedRemoteInfo = getLoadedRemoteInfos(instance, id);
+  if (!loadedRemoteInfo) {
+    return;
+  }
+  var snapshot = loadedRemoteInfo.snapshot;
+  if (!snapshot) {
+    return;
+  }
+  var publicPath = "publicPath" in snapshot ? snapshot.publicPath : "getPublicPath" in snapshot ? new Function(snapshot.getPublicPath)() : "";
+  if (!publicPath) {
+    return;
+  }
+  var modules = "modules" in snapshot ? snapshot.modules : [];
+  var targetModule = modules.find(function(m) {
+    return m.modulePath === loadedRemoteInfo.expose;
+  });
+  if (!targetModule) {
+    return;
+  }
+  var remoteEntry = "remoteEntry" in snapshot ? snapshot.remoteEntry : "";
+  if (!remoteEntry) {
+    return;
+  }
+  return {
+    module: targetModule,
+    publicPath,
+    remoteEntry
+  };
+}
+function collectSSRAssets(options) {
+  var _ref = typeof options === "string" ? {
+    id: options
+  } : options, id = _ref.id, _ref_injectLink = _ref.injectLink, injectLink = _ref_injectLink === void 0 ? true : _ref_injectLink, _ref_injectScript = _ref.injectScript, injectScript = _ref_injectScript === void 0 ? true : _ref_injectScript;
+  var links = [];
+  var scripts = [];
+  var instance = getInstance();
+  if (!instance || !injectLink && !injectScript) {
+    return _to_consumable_array(scripts).concat(_to_consumable_array(links));
+  }
+  var moduleAndPublicPath = getTargetModuleInfo(id);
+  if (!moduleAndPublicPath) {
+    return _to_consumable_array(scripts).concat(_to_consumable_array(links));
+  }
+  var targetModule = moduleAndPublicPath.module, publicPath = moduleAndPublicPath.publicPath, remoteEntry = moduleAndPublicPath.remoteEntry;
+  if (injectLink) {
+    _to_consumable_array(targetModule.assets.css.sync).concat(_to_consumable_array(targetModule.assets.css.async)).forEach(function(file, index) {
+      links.push(/* @__PURE__ */ _jsx("link", {
+        href: "".concat(publicPath).concat(file),
+        rel: "stylesheet",
+        type: "text/css"
+      }, "".concat(file.split(".")[0], "_").concat(index)));
+    });
+  }
+  if (injectScript) {
+    scripts.push(/* @__PURE__ */ _jsx("script", {
+      async: true,
+      src: "".concat(publicPath).concat(remoteEntry),
+      crossOrigin: "anonymous"
+    }, remoteEntry.split(".")[0]));
+    _to_consumable_array(targetModule.assets.js.sync).forEach(function(file, index) {
+      scripts.push(/* @__PURE__ */ _jsx("script", {
+        async: true,
+        src: "".concat(publicPath).concat(file),
+        crossOrigin: "anonymous"
+      }, "".concat(file.split(".")[0], "_").concat(index)));
+    });
+  }
+  return _to_consumable_array(scripts).concat(_to_consumable_array(links));
+}
+function createRemoteSSRComponent(info) {
+  var exportName = (info === null || info === void 0 ? void 0 : info.export) || "default";
+  var LazyComponent = /* @__PURE__ */ React.lazy(/* @__PURE__ */ _async_to_generator(function() {
+    var m, moduleId, assets, Com, err, FallbackFunctionComponent, FallbackNode;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          _state.trys.push([
+            0,
+            2,
+            ,
+            3
+          ]);
+          return [
+            4,
+            info.loader()
+          ];
+        case 1:
+          m = _state.sent();
+          if (!m) {
+            throw new Error("load remote failed");
+          }
+          moduleId = m && m[Symbol.for("mf_module_id")];
+          assets = collectSSRAssets({
+            id: moduleId
+          });
+          Com = m[exportName];
+          if (exportName in m && typeof Com === "function") {
+            return [
+              2,
+              {
+                default: function(props) {
+                  return /* @__PURE__ */ _jsxs(_Fragment, {
+                    children: [
+                      assets,
+                      /* @__PURE__ */ _jsx(Com, _object_spread({}, props))
+                    ]
+                  });
+                }
+              }
+            ];
+          } else {
+            throw Error("Make sure that ".concat(moduleId, " has the correct export when export is ").concat(String(exportName)));
+          }
+          return [
+            3,
+            3
+          ];
+        case 2:
+          err = _state.sent();
+          if (!info.fallback) {
+            throw err;
+          }
+          FallbackFunctionComponent = info.fallback;
+          FallbackNode = /* @__PURE__ */ _jsx(FallbackFunctionComponent, {
+            error: err,
+            resetErrorBoundary: function() {
+              console.log('SSR mode not support "resetErrorBoundary" !');
+            }
+          });
+          return [
+            2,
+            {
+              default: function() {
+                return FallbackNode;
+              }
+            }
+          ];
+        case 3:
+          return [
+            2
+          ];
+      }
+    });
+  }));
+  return function(props) {
+    var key = props.key, args = _object_without_properties(props, [
+      "key"
+    ]);
+    return /* @__PURE__ */ _jsx(ErrorBoundary, {
+      FallbackComponent: info.fallback,
+      children: /* @__PURE__ */ _jsx(React.Suspense, {
+        fallback: info.loading,
+        children: /* @__PURE__ */ _jsx(LazyComponent, _object_spread({}, args))
+      })
+    });
+  };
+}
+export {
+  collectSSRAssets,
+  createRemoteSSRComponent
+};

package/dist/esm/runtime/index.js

@@ -1,22 +1,12 @@
 export * from "@module-federation/enhanced/runtime";
-import { ERROR_TYPE } from "../constant";
 var kit = {
   get createRemoteSSRComponent() {
-    return require("./createRemoteComponent").createRemoteSSRComponent;
-  },
-  get createRemoteComponent() {
-    return require("./createRemoteComponent").createRemoteComponent;
+    return require("./createRemoteSSRComponent").createRemoteSSRComponent;
   },
   get collectSSRAssets() {
-    return require("./createRemoteComponent").collectSSRAssets;
-  },
-  get wrapNoSSR() {
-    return require("./wrapNoSSR").wrapNoSSR;
+    return require("./createRemoteSSRComponent").collectSSRAssets;
   }
 };
-import { setSSREnv } from "../ssr-runtime/injectDataFetchFunctionPlugin";
 export {
-  ERROR_TYPE,
-  kit,
-  setSSREnv
+  kit
 };

package/dist/esm/server/fileCache.js

@@ -0,0 +1,98 @@
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _class_call_check } from "@swc/helpers/_/_class_call_check";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
+import fs from "fs-extra";
+import { LRUCache } from "lru-cache";
+var FileCache = /* @__PURE__ */ function() {
+  "use strict";
+  function FileCache2() {
+    _class_call_check(this, FileCache2);
+    this.cache = new LRUCache({
+      maxSize: 200 * 1024 * 1024
+    });
+  }
+  var _proto = FileCache2.prototype;
+  _proto.getFile = function getFile(filepath) {
+    var _this = this;
+    return _async_to_generator(function() {
+      var stat, currentModified, cachedEntry, content, newEntry, err;
+      return _ts_generator(this, function(_state) {
+        switch (_state.label) {
+          case 0:
+            return [
+              4,
+              fs.pathExists(filepath)
+            ];
+          case 1:
+            if (!_state.sent()) {
+              return [
+                2,
+                null
+              ];
+            }
+            _state.label = 2;
+          case 2:
+            _state.trys.push([
+              2,
+              5,
+              ,
+              6
+            ]);
+            return [
+              4,
+              fs.lstat(filepath)
+            ];
+          case 3:
+            stat = _state.sent();
+            currentModified = stat.mtimeMs;
+            cachedEntry = _this.cache.get(filepath);
+            if (cachedEntry && currentModified <= cachedEntry.lastModified) {
+              return [
+                2,
+                {
+                  content: cachedEntry.content,
+                  lastModified: cachedEntry.lastModified
+                }
+              ];
+            }
+            return [
+              4,
+              fs.readFile(filepath, "utf-8")
+            ];
+          case 4:
+            content = _state.sent();
+            newEntry = {
+              content,
+              lastModified: currentModified
+            };
+            _this.cache.set(filepath, newEntry, {
+              size: stat.size || content.length
+            });
+            return [
+              2,
+              {
+                content,
+                lastModified: currentModified
+              }
+            ];
+          case 5:
+            err = _state.sent();
+            return [
+              2,
+              null
+            ];
+          case 6:
+            return [
+              2
+            ];
+        }
+      });
+    })();
+  };
+  return FileCache2;
+}();
+var fileCache = new FileCache();
+export {
+  FileCache,
+  fileCache
+};

package/dist/esm/server/fileCache.spec.js

@@ -0,0 +1,50 @@
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
+import { it, expect, describe, vi, beforeAll } from "vitest";
+import { FileCache } from "./fileCache";
+beforeAll(function() {
+  vi.mock("fs-extra", function() {
+    return {
+      default: {
+        pathExists: function() {
+          return true;
+        },
+        lstat: function() {
+          return {
+            mtimeMs: Date.now(),
+            size: 4
+          };
+        },
+        readFile: function() {
+          return "test";
+        }
+      }
+    };
+  });
+});
+describe("modern serve static file cache", /* @__PURE__ */ _async_to_generator(function() {
+  return _ts_generator(this, function(_state) {
+    it("should cache file", /* @__PURE__ */ _async_to_generator(function() {
+      var cache, result;
+      return _ts_generator(this, function(_state2) {
+        switch (_state2.label) {
+          case 0:
+            cache = new FileCache();
+            return [
+              4,
+              cache.getFile("test.txt")
+            ];
+          case 1:
+            result = _state2.sent();
+            expect(result === null || result === void 0 ? void 0 : result.content).toBe("test");
+            return [
+              2
+            ];
+        }
+      });
+    }));
+    return [
+      2
+    ];
+  });
+}));

package/dist/esm/server/index.js

@@ -0,0 +1,36 @@
+import { createStaticMiddleware } from "./staticMiddleware";
+var staticServePlugin = function() {
+  return {
+    name: "@modern-js/module-federation/server",
+    setup: function(api) {
+      api.onPrepare(function() {
+        var _config_output, _config_server;
+        console.log(process.env.NODE_ENV);
+        if (process.env.NODE_ENV === "development") {
+          return;
+        }
+        var middlewares = api.getServerContext().middlewares;
+        var config = api.getServerConfig();
+        var assetPrefix = ((_config_output = config.output) === null || _config_output === void 0 ? void 0 : _config_output.assetPrefix) || "";
+        if (!((_config_server = config.server) === null || _config_server === void 0 ? void 0 : _config_server.ssr)) {
+          return;
+        }
+        var context = api.getServerContext();
+        var pwd = context.distDirectory;
+        var serverStaticMiddleware = createStaticMiddleware({
+          assetPrefix,
+          pwd
+        });
+        middlewares.push({
+          name: "module-federation-serve-manifest",
+          handler: serverStaticMiddleware
+        });
+      });
+    }
+  };
+};
+var server_default = staticServePlugin;
+export {
+  server_default as default,
+  staticServePlugin
+};

package/dist/esm/server/staticMiddleware.js

@@ -0,0 +1,81 @@
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
+import fs from "fs-extra";
+import path from "node:path";
+import { fileCache } from "./fileCache";
+var bundlesAssetPrefix = "/bundles";
+var removeHost = function(url) {
+  try {
+    var hasProtocol = url.includes("://");
+    var hasDomain = hasProtocol || url.startsWith("//");
+    var pathname = hasDomain ? new URL(hasProtocol ? url : "http:".concat(url)).pathname : url;
+    return pathname;
+  } catch (e) {
+    return url;
+  }
+};
+var createStaticMiddleware = function(options) {
+  var assetPrefix = options.assetPrefix, pwd = options.pwd;
+  return function() {
+    var _ref = _async_to_generator(function(c, next) {
+      var pathname, prefixWithoutHost, prefixWithBundle, pathnameWithoutPrefix, filepath, fileResult;
+      return _ts_generator(this, function(_state) {
+        switch (_state.label) {
+          case 0:
+            pathname = c.req.path;
+            if (path.extname(pathname) !== ".js") {
+              return [
+                2,
+                next()
+              ];
+            }
+            prefixWithoutHost = removeHost(assetPrefix);
+            prefixWithBundle = path.join(prefixWithoutHost, bundlesAssetPrefix);
+            if (!pathname.startsWith(prefixWithBundle)) {
+              return [
+                2,
+                next()
+              ];
+            }
+            pathnameWithoutPrefix = pathname.replace(prefixWithBundle, "");
+            filepath = path.join(pwd, bundlesAssetPrefix, pathnameWithoutPrefix);
+            return [
+              4,
+              fs.pathExists(filepath)
+            ];
+          case 1:
+            if (!_state.sent()) {
+              return [
+                2,
+                next()
+              ];
+            }
+            return [
+              4,
+              fileCache.getFile(filepath)
+            ];
+          case 2:
+            fileResult = _state.sent();
+            if (!fileResult) {
+              return [
+                2,
+                next()
+              ];
+            }
+            c.header("Content-Type", "application/javascript");
+            c.header("Content-Length", String(fileResult.content.length));
+            return [
+              2,
+              c.body(fileResult.content, 200)
+            ];
+        }
+      });
+    });
+    return function(c, next) {
+      return _ref.apply(this, arguments);
+    };
+  }();
+};
+export {
+  createStaticMiddleware
+};