@module-federation/modern-js 0.0.0-next-20250613163655 → 0.0.0-next-20250616091910

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

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

@@ -0,0 +1,328 @@
+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, beforeEach } from "vitest";
+import { createStaticMiddleware } from "./staticMiddleware";
+vi.mock("fs-extra", function() {
+  return {
+    default: {
+      pathExists: vi.fn()
+    }
+  };
+});
+vi.mock("./fileCache", function() {
+  return {
+    fileCache: {
+      getFile: vi.fn()
+    }
+  };
+});
+import fs from "fs-extra";
+import { fileCache } from "./fileCache";
+describe("staticMiddleware", function() {
+  var middleware;
+  var mockContext;
+  var nextSpy;
+  beforeEach(function() {
+    vi.clearAllMocks();
+    middleware = createStaticMiddleware({
+      assetPrefix: "",
+      pwd: "/test/path"
+    });
+    nextSpy = vi.fn();
+    mockContext = {
+      req: {
+        path: ""
+      },
+      header: vi.fn(),
+      body: vi.fn()
+    };
+  });
+  describe("file extension filtering", function() {
+    it("should call next() for non-js files", /* @__PURE__ */ _async_to_generator(function() {
+      return _ts_generator(this, function(_state) {
+        switch (_state.label) {
+          case 0:
+            mockContext.req.path = "/bundles/test.css";
+            return [
+              4,
+              middleware(mockContext, nextSpy)
+            ];
+          case 1:
+            _state.sent();
+            expect(nextSpy).toHaveBeenCalledOnce();
+            expect(mockContext.header).not.toHaveBeenCalled();
+            expect(mockContext.body).not.toHaveBeenCalled();
+            return [
+              2
+            ];
+        }
+      });
+    }));
+    it("should call next() for files without extension", /* @__PURE__ */ _async_to_generator(function() {
+      return _ts_generator(this, function(_state) {
+        switch (_state.label) {
+          case 0:
+            mockContext.req.path = "/bundles/test";
+            return [
+              4,
+              middleware(mockContext, nextSpy)
+            ];
+          case 1:
+            _state.sent();
+            expect(nextSpy).toHaveBeenCalledOnce();
+            expect(mockContext.header).not.toHaveBeenCalled();
+            expect(mockContext.body).not.toHaveBeenCalled();
+            return [
+              2
+            ];
+        }
+      });
+    }));
+    it("should process .js files", /* @__PURE__ */ _async_to_generator(function() {
+      return _ts_generator(this, function(_state) {
+        switch (_state.label) {
+          case 0:
+            mockContext.req.path = "/bundles/test.js";
+            fs.pathExists.mockResolvedValue(false);
+            return [
+              4,
+              middleware(mockContext, nextSpy)
+            ];
+          case 1:
+            _state.sent();
+            expect(fs.pathExists).toHaveBeenCalled();
+            return [
+              2
+            ];
+        }
+      });
+    }));
+  });
+  describe("asset prefix filtering", function() {
+    it("should call next() for paths not starting with /bundles", /* @__PURE__ */ _async_to_generator(function() {
+      return _ts_generator(this, function(_state) {
+        switch (_state.label) {
+          case 0:
+            mockContext.req.path = "/assets/test.js";
+            return [
+              4,
+              middleware(mockContext, nextSpy)
+            ];
+          case 1:
+            _state.sent();
+            expect(nextSpy).toHaveBeenCalledOnce();
+            expect(fs.pathExists).not.toHaveBeenCalled();
+            expect(mockContext.header).not.toHaveBeenCalled();
+            expect(mockContext.body).not.toHaveBeenCalled();
+            return [
+              2
+            ];
+        }
+      });
+    }));
+    it("should call next() for root path", /* @__PURE__ */ _async_to_generator(function() {
+      return _ts_generator(this, function(_state) {
+        switch (_state.label) {
+          case 0:
+            mockContext.req.path = "/test.js";
+            return [
+              4,
+              middleware(mockContext, nextSpy)
+            ];
+          case 1:
+            _state.sent();
+            expect(nextSpy).toHaveBeenCalledOnce();
+            expect(fs.pathExists).not.toHaveBeenCalled();
+            return [
+              2
+            ];
+        }
+      });
+    }));
+    it("should process paths starting with /bundles", /* @__PURE__ */ _async_to_generator(function() {
+      return _ts_generator(this, function(_state) {
+        switch (_state.label) {
+          case 0:
+            mockContext.req.path = "/bundles/test.js";
+            fs.pathExists.mockResolvedValue(false);
+            return [
+              4,
+              middleware(mockContext, nextSpy)
+            ];
+          case 1:
+            _state.sent();
+            expect(fs.pathExists).toHaveBeenCalledWith("/test/path/bundles/test.js");
+            return [
+              2
+            ];
+        }
+      });
+    }));
+  });
+  describe("file existence check", function() {
+    it("should call next() when file does not exist", /* @__PURE__ */ _async_to_generator(function() {
+      return _ts_generator(this, function(_state) {
+        switch (_state.label) {
+          case 0:
+            mockContext.req.path = "/bundles/nonexistent.js";
+            fs.pathExists.mockResolvedValue(false);
+            return [
+              4,
+              middleware(mockContext, nextSpy)
+            ];
+          case 1:
+            _state.sent();
+            expect(fs.pathExists).toHaveBeenCalledWith("/test/path/bundles/nonexistent.js");
+            expect(nextSpy).toHaveBeenCalledOnce();
+            expect(fileCache.getFile).not.toHaveBeenCalled();
+            expect(mockContext.header).not.toHaveBeenCalled();
+            expect(mockContext.body).not.toHaveBeenCalled();
+            return [
+              2
+            ];
+        }
+      });
+    }));
+    it("should proceed to file cache when file exists", /* @__PURE__ */ _async_to_generator(function() {
+      return _ts_generator(this, function(_state) {
+        switch (_state.label) {
+          case 0:
+            mockContext.req.path = "/bundles/existing.js";
+            fs.pathExists.mockResolvedValue(true);
+            fileCache.getFile.mockResolvedValue(null);
+            return [
+              4,
+              middleware(mockContext, nextSpy)
+            ];
+          case 1:
+            _state.sent();
+            expect(fs.pathExists).toHaveBeenCalledWith("/test/path/bundles/existing.js");
+            expect(fileCache.getFile).toHaveBeenCalledWith("/test/path/bundles/existing.js");
+            return [
+              2
+            ];
+        }
+      });
+    }));
+  });
+  describe("successful file serving", function() {
+    it("should serve file content with correct headers", /* @__PURE__ */ _async_to_generator(function() {
+      var mockFileContent, mockFileResult, result;
+      return _ts_generator(this, function(_state) {
+        switch (_state.label) {
+          case 0:
+            mockFileContent = 'console.log("test");';
+            mockFileResult = {
+              content: mockFileContent,
+              lastModified: Date.now()
+            };
+            mockContext.req.path = "/bundles/app.js";
+            fs.pathExists.mockResolvedValue(true);
+            fileCache.getFile.mockResolvedValue(mockFileResult);
+            mockContext.body.mockReturnValue("response");
+            return [
+              4,
+              middleware(mockContext, nextSpy)
+            ];
+          case 1:
+            result = _state.sent();
+            expect(fs.pathExists).toHaveBeenCalledWith("/test/path/bundles/app.js");
+            expect(fileCache.getFile).toHaveBeenCalledWith("/test/path/bundles/app.js");
+            expect(nextSpy).not.toHaveBeenCalled();
+            expect(mockContext.header).toHaveBeenCalledWith("Content-Type", "application/javascript");
+            expect(mockContext.header).toHaveBeenCalledWith("Content-Length", String(mockFileResult.content.length));
+            expect(mockContext.body).toHaveBeenCalledWith(mockFileResult.content, 200);
+            expect(result).toBe("response");
+            return [
+              2
+            ];
+        }
+      });
+    }));
+    it("should handle empty file content", /* @__PURE__ */ _async_to_generator(function() {
+      var mockFileResult, result;
+      return _ts_generator(this, function(_state) {
+        switch (_state.label) {
+          case 0:
+            mockFileResult = {
+              content: "",
+              lastModified: Date.now()
+            };
+            mockContext.req.path = "/bundles/empty.js";
+            fs.pathExists.mockResolvedValue(true);
+            fileCache.getFile.mockResolvedValue(mockFileResult);
+            mockContext.body.mockReturnValue("empty-response");
+            return [
+              4,
+              middleware(mockContext, nextSpy)
+            ];
+          case 1:
+            result = _state.sent();
+            expect(mockContext.header).toHaveBeenCalledWith("Content-Length", "0");
+            expect(mockContext.body).toHaveBeenCalledWith(mockFileResult.content, 200);
+            expect(result).toBe("empty-response");
+            expect(nextSpy).not.toHaveBeenCalled();
+            return [
+              2
+            ];
+        }
+      });
+    }));
+  });
+  describe("asset prefix handling", function() {
+    it("should handle custom asset prefix correctly", /* @__PURE__ */ _async_to_generator(function() {
+      var customMiddleware;
+      return _ts_generator(this, function(_state) {
+        switch (_state.label) {
+          case 0:
+            customMiddleware = createStaticMiddleware({
+              assetPrefix: "/custom-prefix",
+              pwd: "/test/path"
+            });
+            mockContext.req.path = "/bundles/test.js";
+            return [
+              4,
+              customMiddleware(mockContext, nextSpy)
+            ];
+          case 1:
+            _state.sent();
+            expect(nextSpy).toHaveBeenCalledOnce();
+            expect(mockContext.header).not.toHaveBeenCalled();
+            expect(mockContext.body).not.toHaveBeenCalled();
+            return [
+              2
+            ];
+        }
+      });
+    }));
+    it("should handle asset prefix removal correctly", /* @__PURE__ */ _async_to_generator(function() {
+      var customMiddleware, mockFileResult;
+      return _ts_generator(this, function(_state) {
+        switch (_state.label) {
+          case 0:
+            customMiddleware = createStaticMiddleware({
+              assetPrefix: "/prefix",
+              pwd: "/test/path"
+            });
+            mockFileResult = {
+              content: "test content",
+              lastModified: Date.now()
+            };
+            mockContext.req.path = "/prefix/bundles/test.js";
+            fs.pathExists.mockResolvedValue(true);
+            fileCache.getFile.mockResolvedValue(mockFileResult);
+            return [
+              4,
+              customMiddleware(mockContext, nextSpy)
+            ];
+          case 1:
+            _state.sent();
+            expect(fs.pathExists).toHaveBeenCalledWith("/test/path/bundles/test.js");
+            return [
+              2
+            ];
+        }
+      });
+    }));
+  });
+});

package/dist/esm/ssr-runtime/SSRLiveReload.js

@@ -0,0 +1,26 @@
+import { _ as _tagged_template_literal } from "@swc/helpers/_/_tagged_template_literal";
+function _templateObject() {
+  var data = _tagged_template_literal([
+    "\n      if(",
+    "){\n        location.reload();\n      }\n   "
+  ]);
+  _templateObject = function _templateObject2() {
+    return data;
+  };
+  return data;
+}
+import { jsx as _jsx } from "react/jsx-runtime";
+function SSRLiveReload() {
+  if (process.env.NODE_ENV !== "development") {
+    return null;
+  }
+  return /* @__PURE__ */ _jsx("script", {
+    suppressHydrationWarning: true,
+    dangerouslySetInnerHTML: {
+      __html: String.raw(_templateObject(), globalThis.shouldUpdate)
+    }
+  });
+}
+export {
+  SSRLiveReload
+};

package/dist/esm/ssr-runtime/devPlugin.js

@@ -0,0 +1,73 @@
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _object_spread } from "@swc/helpers/_/_object_spread";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { SSRLiveReload } from "./SSRLiveReload";
+import { flushDataFetch } from "@module-federation/bridge-react/data-fetch-utils";
+var mfSSRDevPlugin = function() {
+  return {
+    name: "@module-federation/modern-js",
+    setup: function(api) {
+      api.onBeforeRender(/* @__PURE__ */ _async_to_generator(function() {
+        var nodeUtils, shouldUpdate;
+        return _ts_generator(this, function(_state) {
+          switch (_state.label) {
+            case 0:
+              if (typeof window !== "undefined") {
+                return [
+                  2
+                ];
+              }
+              globalThis.shouldUpdate = false;
+              return [
+                4,
+                import("@module-federation/node/utils")
+              ];
+            case 1:
+              nodeUtils = _state.sent();
+              return [
+                4,
+                nodeUtils.revalidate()
+              ];
+            case 2:
+              shouldUpdate = _state.sent();
+              console.log("shouldUpdate: ", shouldUpdate);
+              if (!shouldUpdate)
+                return [
+                  3,
+                  4
+                ];
+              console.log("should RELOAD", shouldUpdate);
+              return [
+                4,
+                nodeUtils.flushChunks()
+              ];
+            case 3:
+              _state.sent();
+              flushDataFetch();
+              globalThis.shouldUpdate = true;
+              _state.label = 4;
+            case 4:
+              return [
+                2
+              ];
+          }
+        });
+      }));
+      api.wrapRoot(function(App) {
+        var AppWrapper = function(props) {
+          return /* @__PURE__ */ _jsxs(_Fragment, {
+            children: [
+              /* @__PURE__ */ _jsx(SSRLiveReload, {}),
+              /* @__PURE__ */ _jsx(App, _object_spread({}, props))
+            ]
+          });
+        };
+        return AppWrapper;
+      });
+    }
+  };
+};
+export {
+  mfSSRDevPlugin
+};

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

@@ -0,0 +1,35 @@
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
+import { kit } from "@module-federation/bridge-react";
+var callDataFetch = kit.callDataFetch, injectDataFetch = kit.injectDataFetch, setSSREnv = kit.setSSREnv;
+var injectDataFetchFunctionPlugin = function(param) {
+  var fetchServerQuery = param.fetchServerQuery;
+  return {
+    name: "@module-federation/inject-data-fetch-function-plugin",
+    setup: function(api) {
+      api.onBeforeRender(/* @__PURE__ */ _async_to_generator(function() {
+        return _ts_generator(this, function(_state) {
+          switch (_state.label) {
+            case 0:
+              setSSREnv({
+                fetchServerQuery
+              });
+              injectDataFetch();
+              return [
+                4,
+                callDataFetch()
+              ];
+            case 1:
+              _state.sent();
+              return [
+                2
+              ];
+          }
+        });
+      }));
+    }
+  };
+};
+export {
+  injectDataFetchFunctionPlugin
+};