@module-federation/modern-js 0.14.2 → 0.15.0

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 "../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/downgrade.js

@@ -0,0 +1,150 @@
+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 _type_of } from "@swc/helpers/_/_type_of";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
+import { DATA_FETCH_QUERY, DOWNGRADE_KEY } from "../constant";
+import { MF_DATA_FETCH_STATUS, MF_DATA_FETCH_TYPE } from "../constant";
+import { getDataFetchMap } from "../utils";
+function getDowngradeTag() {
+  return globalThis[DOWNGRADE_KEY];
+}
+function callAllDowngrade() {
+  var dataFetchMap = getDataFetchMap();
+  if (!dataFetchMap) {
+    return;
+  }
+  Object.keys(dataFetchMap).forEach(function(key) {
+    callDowngrade(key);
+  });
+}
+function callDowngrade(id, params, remoteInfo) {
+  return _callDowngrade.apply(this, arguments);
+}
+function _callDowngrade() {
+  _callDowngrade = _async_to_generator(function(id, params, remoteInfo) {
+    var dataFetchMap, mfDataFetch, promise, res, rej, dataFetchType, currentUrl, fetchServerQuery, fetchUrl, data, e;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          dataFetchMap = getDataFetchMap();
+          if (!dataFetchMap) {
+            return [
+              2
+            ];
+          }
+          mfDataFetch = dataFetchMap[id];
+          if (!((mfDataFetch === null || mfDataFetch === void 0 ? void 0 : mfDataFetch[2]) === MF_DATA_FETCH_STATUS.AWAIT))
+            return [
+              3,
+              6
+            ];
+          mfDataFetch[2] = MF_DATA_FETCH_STATUS.LOADING;
+          if (mfDataFetch[1]) {
+            promise = mfDataFetch[1][0];
+            res = mfDataFetch[1][1];
+            rej = mfDataFetch[1][2];
+          } else {
+            promise = new Promise(function(resolve, reject) {
+              res = resolve;
+              rej = reject;
+            });
+            mfDataFetch[1] = [
+              promise,
+              res,
+              rej
+            ];
+          }
+          dataFetchType = mfDataFetch[0][1];
+          if (!(dataFetchType === MF_DATA_FETCH_TYPE.FETCH_CLIENT))
+            return [
+              3,
+              1
+            ];
+          try {
+            mfDataFetch[0][0]().then(function(getDataFetchFn) {
+              return getDataFetchFn(_object_spread_props(_object_spread({}, params), {
+                isDowngrade: true
+              })).then(function(data2) {
+                mfDataFetch[2] = MF_DATA_FETCH_STATUS.LOADED;
+                res(data2);
+              });
+            });
+          } catch (e2) {
+            mfDataFetch[2] = MF_DATA_FETCH_STATUS.ERROR;
+            rej(e2);
+          }
+          return [
+            3,
+            5
+          ];
+        case 1:
+          if (!(dataFetchType === MF_DATA_FETCH_TYPE.FETCH_SERVER))
+            return [
+              3,
+              5
+            ];
+          _state.label = 2;
+        case 2:
+          _state.trys.push([
+            2,
+            4,
+            ,
+            5
+          ]);
+          currentUrl = new URL(window.location.href);
+          currentUrl.searchParams.set(DATA_FETCH_QUERY, encodeURIComponent(id));
+          if (params) {
+            currentUrl.searchParams.set("params", encodeURIComponent(JSON.stringify(params)));
+          }
+          if (remoteInfo) {
+            currentUrl.searchParams.set("remoteInfo", encodeURIComponent(JSON.stringify(remoteInfo)));
+          }
+          fetchServerQuery = globalThis.FEDERATION_SERVER_QUERY;
+          if (fetchServerQuery && (typeof fetchServerQuery === "undefined" ? "undefined" : _type_of(fetchServerQuery)) === "object") {
+            Object.keys(fetchServerQuery).forEach(function(key) {
+              currentUrl.searchParams.set(key, JSON.stringify(fetchServerQuery[key]));
+            });
+          }
+          fetchUrl = currentUrl.toString();
+          return [
+            4,
+            fetch(fetchUrl).then(function(res2) {
+              return res2.json();
+            })
+          ];
+        case 3:
+          data = _state.sent();
+          mfDataFetch[2] = MF_DATA_FETCH_STATUS.LOADED;
+          res(data);
+          return [
+            3,
+            5
+          ];
+        case 4:
+          e = _state.sent();
+          mfDataFetch[2] = MF_DATA_FETCH_STATUS.ERROR;
+          rej(e);
+          return [
+            3,
+            5
+          ];
+        case 5:
+          return [
+            2,
+            promise
+          ];
+        case 6:
+          return [
+            2
+          ];
+      }
+    });
+  });
+  return _callDowngrade.apply(this, arguments);
+}
+export {
+  callAllDowngrade,
+  callDowngrade,
+  getDowngradeTag
+};