@module-federation/modern-js 0.0.0-next-20250618045528 → 0.0.0-next-20250618090118

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/lazy-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 { callDataFetch, injectDataFetch } from "@module-federation/bridge-react/data-fetch-utils";
+import { setSSREnv } from "@module-federation/bridge-react/lazy-utils";
+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
+};