@module-federation/modern-js 0.14.2 → 0.15.0

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

@@ -0,0 +1,185 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var import_vitest = require("vitest");
+var import_staticMiddleware = require("./staticMiddleware");
+var import_fs_extra = __toESM(require("fs-extra"));
+var import_fileCache = require("./fileCache");
+import_vitest.vi.mock("fs-extra", () => ({
+  default: {
+    pathExists: import_vitest.vi.fn()
+  }
+}));
+import_vitest.vi.mock("./fileCache", () => ({
+  fileCache: {
+    getFile: import_vitest.vi.fn()
+  }
+}));
+(0, import_vitest.describe)("staticMiddleware", () => {
+  let middleware;
+  let mockContext;
+  let nextSpy;
+  (0, import_vitest.beforeEach)(() => {
+    import_vitest.vi.clearAllMocks();
+    middleware = (0, import_staticMiddleware.createStaticMiddleware)({
+      assetPrefix: "",
+      pwd: "/test/path"
+    });
+    nextSpy = import_vitest.vi.fn();
+    mockContext = {
+      req: {
+        path: ""
+      },
+      header: import_vitest.vi.fn(),
+      body: import_vitest.vi.fn()
+    };
+  });
+  (0, import_vitest.describe)("file extension filtering", () => {
+    (0, import_vitest.it)("should call next() for non-js files", async () => {
+      mockContext.req.path = "/bundles/test.css";
+      await middleware(mockContext, nextSpy);
+      (0, import_vitest.expect)(nextSpy).toHaveBeenCalledOnce();
+      (0, import_vitest.expect)(mockContext.header).not.toHaveBeenCalled();
+      (0, import_vitest.expect)(mockContext.body).not.toHaveBeenCalled();
+    });
+    (0, import_vitest.it)("should call next() for files without extension", async () => {
+      mockContext.req.path = "/bundles/test";
+      await middleware(mockContext, nextSpy);
+      (0, import_vitest.expect)(nextSpy).toHaveBeenCalledOnce();
+      (0, import_vitest.expect)(mockContext.header).not.toHaveBeenCalled();
+      (0, import_vitest.expect)(mockContext.body).not.toHaveBeenCalled();
+    });
+    (0, import_vitest.it)("should process .js files", async () => {
+      mockContext.req.path = "/bundles/test.js";
+      import_fs_extra.default.pathExists.mockResolvedValue(false);
+      await middleware(mockContext, nextSpy);
+      (0, import_vitest.expect)(import_fs_extra.default.pathExists).toHaveBeenCalled();
+    });
+  });
+  (0, import_vitest.describe)("asset prefix filtering", () => {
+    (0, import_vitest.it)("should call next() for paths not starting with /bundles", async () => {
+      mockContext.req.path = "/assets/test.js";
+      await middleware(mockContext, nextSpy);
+      (0, import_vitest.expect)(nextSpy).toHaveBeenCalledOnce();
+      (0, import_vitest.expect)(import_fs_extra.default.pathExists).not.toHaveBeenCalled();
+      (0, import_vitest.expect)(mockContext.header).not.toHaveBeenCalled();
+      (0, import_vitest.expect)(mockContext.body).not.toHaveBeenCalled();
+    });
+    (0, import_vitest.it)("should call next() for root path", async () => {
+      mockContext.req.path = "/test.js";
+      await middleware(mockContext, nextSpy);
+      (0, import_vitest.expect)(nextSpy).toHaveBeenCalledOnce();
+      (0, import_vitest.expect)(import_fs_extra.default.pathExists).not.toHaveBeenCalled();
+    });
+    (0, import_vitest.it)("should process paths starting with /bundles", async () => {
+      mockContext.req.path = "/bundles/test.js";
+      import_fs_extra.default.pathExists.mockResolvedValue(false);
+      await middleware(mockContext, nextSpy);
+      (0, import_vitest.expect)(import_fs_extra.default.pathExists).toHaveBeenCalledWith("/test/path/bundles/test.js");
+    });
+  });
+  (0, import_vitest.describe)("file existence check", () => {
+    (0, import_vitest.it)("should call next() when file does not exist", async () => {
+      mockContext.req.path = "/bundles/nonexistent.js";
+      import_fs_extra.default.pathExists.mockResolvedValue(false);
+      await middleware(mockContext, nextSpy);
+      (0, import_vitest.expect)(import_fs_extra.default.pathExists).toHaveBeenCalledWith("/test/path/bundles/nonexistent.js");
+      (0, import_vitest.expect)(nextSpy).toHaveBeenCalledOnce();
+      (0, import_vitest.expect)(import_fileCache.fileCache.getFile).not.toHaveBeenCalled();
+      (0, import_vitest.expect)(mockContext.header).not.toHaveBeenCalled();
+      (0, import_vitest.expect)(mockContext.body).not.toHaveBeenCalled();
+    });
+    (0, import_vitest.it)("should proceed to file cache when file exists", async () => {
+      mockContext.req.path = "/bundles/existing.js";
+      import_fs_extra.default.pathExists.mockResolvedValue(true);
+      import_fileCache.fileCache.getFile.mockResolvedValue(null);
+      await middleware(mockContext, nextSpy);
+      (0, import_vitest.expect)(import_fs_extra.default.pathExists).toHaveBeenCalledWith("/test/path/bundles/existing.js");
+      (0, import_vitest.expect)(import_fileCache.fileCache.getFile).toHaveBeenCalledWith("/test/path/bundles/existing.js");
+    });
+  });
+  (0, import_vitest.describe)("successful file serving", () => {
+    (0, import_vitest.it)("should serve file content with correct headers", async () => {
+      const mockFileContent = 'console.log("test");';
+      const mockFileResult = {
+        content: mockFileContent,
+        lastModified: Date.now()
+      };
+      mockContext.req.path = "/bundles/app.js";
+      import_fs_extra.default.pathExists.mockResolvedValue(true);
+      import_fileCache.fileCache.getFile.mockResolvedValue(mockFileResult);
+      mockContext.body.mockReturnValue("response");
+      const result = await middleware(mockContext, nextSpy);
+      (0, import_vitest.expect)(import_fs_extra.default.pathExists).toHaveBeenCalledWith("/test/path/bundles/app.js");
+      (0, import_vitest.expect)(import_fileCache.fileCache.getFile).toHaveBeenCalledWith("/test/path/bundles/app.js");
+      (0, import_vitest.expect)(nextSpy).not.toHaveBeenCalled();
+      (0, import_vitest.expect)(mockContext.header).toHaveBeenCalledWith("Content-Type", "application/javascript");
+      (0, import_vitest.expect)(mockContext.header).toHaveBeenCalledWith("Content-Length", String(mockFileResult.content.length));
+      (0, import_vitest.expect)(mockContext.body).toHaveBeenCalledWith(mockFileResult.content, 200);
+      (0, import_vitest.expect)(result).toBe("response");
+    });
+    (0, import_vitest.it)("should handle empty file content", async () => {
+      const mockFileResult = {
+        content: "",
+        lastModified: Date.now()
+      };
+      mockContext.req.path = "/bundles/empty.js";
+      import_fs_extra.default.pathExists.mockResolvedValue(true);
+      import_fileCache.fileCache.getFile.mockResolvedValue(mockFileResult);
+      mockContext.body.mockReturnValue("empty-response");
+      const result = await middleware(mockContext, nextSpy);
+      (0, import_vitest.expect)(mockContext.header).toHaveBeenCalledWith("Content-Length", "0");
+      (0, import_vitest.expect)(mockContext.body).toHaveBeenCalledWith(mockFileResult.content, 200);
+      (0, import_vitest.expect)(result).toBe("empty-response");
+      (0, import_vitest.expect)(nextSpy).not.toHaveBeenCalled();
+    });
+  });
+  (0, import_vitest.describe)("asset prefix handling", () => {
+    (0, import_vitest.it)("should handle custom asset prefix correctly", async () => {
+      const customMiddleware = (0, import_staticMiddleware.createStaticMiddleware)({
+        assetPrefix: "/custom-prefix",
+        pwd: "/test/path"
+      });
+      mockContext.req.path = "/bundles/test.js";
+      await customMiddleware(mockContext, nextSpy);
+      (0, import_vitest.expect)(nextSpy).toHaveBeenCalledOnce();
+      (0, import_vitest.expect)(mockContext.header).not.toHaveBeenCalled();
+      (0, import_vitest.expect)(mockContext.body).not.toHaveBeenCalled();
+    });
+    (0, import_vitest.it)("should handle asset prefix removal correctly", async () => {
+      const customMiddleware = (0, import_staticMiddleware.createStaticMiddleware)({
+        assetPrefix: "/prefix",
+        pwd: "/test/path"
+      });
+      const mockFileResult = {
+        content: "test content",
+        lastModified: Date.now()
+      };
+      mockContext.req.path = "/prefix/bundles/test.js";
+      import_fs_extra.default.pathExists.mockResolvedValue(true);
+      import_fileCache.fileCache.getFile.mockResolvedValue(mockFileResult);
+      await customMiddleware(mockContext, nextSpy);
+      (0, import_vitest.expect)(import_fs_extra.default.pathExists).toHaveBeenCalledWith("/test/path/bundles/test.js");
+    });
+  });
+});

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

@@ -0,0 +1,43 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var SSRLiveReload_exports = {};
+__export(SSRLiveReload_exports, {
+  SSRLiveReload: () => SSRLiveReload
+});
+module.exports = __toCommonJS(SSRLiveReload_exports);
+var import_jsx_runtime = require("react/jsx-runtime");
+function SSRLiveReload() {
+  if (process.env.NODE_ENV !== "development") {
+    return null;
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)("script", {
+    suppressHydrationWarning: true,
+    dangerouslySetInnerHTML: {
+      __html: String.raw`
+      if(${globalThis.shouldUpdate}){
+        location.reload();
+      }
+   `
+    }
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SSRLiveReload
+});

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

@@ -0,0 +1,71 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var devPlugin_exports = {};
+__export(devPlugin_exports, {
+  mfSSRDevPlugin: () => mfSSRDevPlugin
+});
+module.exports = __toCommonJS(devPlugin_exports);
+var import_jsx_runtime = require("react/jsx-runtime");
+var import_SSRLiveReload = require("./SSRLiveReload");
+var import_utils = require("../utils");
+const mfSSRDevPlugin = () => ({
+  name: "@module-federation/modern-js",
+  setup: (api) => {
+    api.onBeforeRender(async () => {
+      if (typeof window !== "undefined") {
+        return;
+      }
+      globalThis.shouldUpdate = false;
+      const nodeUtils = await Promise.resolve().then(() => __toESM(require("@module-federation/node/utils")));
+      const shouldUpdate = await nodeUtils.revalidate();
+      console.log("shouldUpdate: ", shouldUpdate);
+      if (shouldUpdate) {
+        console.log("should RELOAD", shouldUpdate);
+        await nodeUtils.flushChunks();
+        (0, import_utils.flushDataFetch)();
+        globalThis.shouldUpdate = true;
+      }
+    });
+    api.wrapRoot((App) => {
+      const AppWrapper = (props) => /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_jsx_runtime.Fragment, {
+        children: [
+          /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_SSRLiveReload.SSRLiveReload, {}),
+          /* @__PURE__ */ (0, import_jsx_runtime.jsx)(App, {
+            ...props
+          })
+        ]
+      });
+      return AppWrapper;
+    });
+  }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  mfSSRDevPlugin
+});

package/dist/cjs/ssr-runtime/downgrade.js

@@ -0,0 +1,114 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var downgrade_exports = {};
+__export(downgrade_exports, {
+  callAllDowngrade: () => callAllDowngrade,
+  callDowngrade: () => callDowngrade,
+  getDowngradeTag: () => getDowngradeTag
+});
+module.exports = __toCommonJS(downgrade_exports);
+var import_constant = require("../constant");
+var import_constant2 = require("../constant");
+var import_utils = require("../utils");
+function getDowngradeTag() {
+  return globalThis[import_constant.DOWNGRADE_KEY];
+}
+function callAllDowngrade() {
+  const dataFetchMap = (0, import_utils.getDataFetchMap)();
+  if (!dataFetchMap) {
+    return;
+  }
+  Object.keys(dataFetchMap).forEach((key) => {
+    callDowngrade(key);
+  });
+}
+async function callDowngrade(id, params, remoteInfo) {
+  const dataFetchMap = (0, import_utils.getDataFetchMap)();
+  if (!dataFetchMap) {
+    return;
+  }
+  const mfDataFetch = dataFetchMap[id];
+  if ((mfDataFetch === null || mfDataFetch === void 0 ? void 0 : mfDataFetch[2]) === import_constant2.MF_DATA_FETCH_STATUS.AWAIT) {
+    mfDataFetch[2] = import_constant2.MF_DATA_FETCH_STATUS.LOADING;
+    let promise, res, rej;
+    if (mfDataFetch[1]) {
+      promise = mfDataFetch[1][0];
+      res = mfDataFetch[1][1];
+      rej = mfDataFetch[1][2];
+    } else {
+      promise = new Promise((resolve, reject) => {
+        res = resolve;
+        rej = reject;
+      });
+      mfDataFetch[1] = [
+        promise,
+        res,
+        rej
+      ];
+    }
+    const dataFetchType = mfDataFetch[0][1];
+    if (dataFetchType === import_constant2.MF_DATA_FETCH_TYPE.FETCH_CLIENT) {
+      try {
+        mfDataFetch[0][0]().then((getDataFetchFn) => {
+          return getDataFetchFn({
+            ...params,
+            isDowngrade: true
+          }).then((data) => {
+            mfDataFetch[2] = import_constant2.MF_DATA_FETCH_STATUS.LOADED;
+            res(data);
+          });
+        });
+      } catch (e) {
+        mfDataFetch[2] = import_constant2.MF_DATA_FETCH_STATUS.ERROR;
+        rej(e);
+      }
+    } else if (dataFetchType === import_constant2.MF_DATA_FETCH_TYPE.FETCH_SERVER) {
+      try {
+        const currentUrl = new URL(window.location.href);
+        currentUrl.searchParams.set(import_constant.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)));
+        }
+        const fetchServerQuery = globalThis.FEDERATION_SERVER_QUERY;
+        if (fetchServerQuery && typeof fetchServerQuery === "object") {
+          Object.keys(fetchServerQuery).forEach((key) => {
+            currentUrl.searchParams.set(key, JSON.stringify(fetchServerQuery[key]));
+          });
+        }
+        const fetchUrl = currentUrl.toString();
+        const data = await fetch(fetchUrl).then((res2) => res2.json());
+        mfDataFetch[2] = import_constant2.MF_DATA_FETCH_STATUS.LOADED;
+        res(data);
+      } catch (e) {
+        mfDataFetch[2] = import_constant2.MF_DATA_FETCH_STATUS.ERROR;
+        rej(e);
+      }
+    }
+    return promise;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  callAllDowngrade,
+  callDowngrade,
+  getDowngradeTag
+});

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

@@ -0,0 +1,136 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var injectDataFetchFunctionPlugin_exports = {};
+__export(injectDataFetchFunctionPlugin_exports, {
+  injectDataFetchFunctionPlugin: () => injectDataFetchFunctionPlugin,
+  setSSREnv: () => setSSREnv
+});
+module.exports = __toCommonJS(injectDataFetchFunctionPlugin_exports);
+var import_constant = require("../constant");
+var import_logger = __toESM(require("../logger"));
+var import_utils = require("../utils");
+var import_downgrade = require("./downgrade");
+function setSSREnv({ fetchServerQuery }) {
+  globalThis.FEDERATION_SSR = true;
+  globalThis.FEDERATION_SERVER_QUERY = fetchServerQuery;
+}
+const injectDataFetchFunctionPlugin = ({ fetchServerQuery }) => ({
+  name: "@module-federation/inject-data-fetch-function-plugin",
+  setup: (api) => {
+    api.onBeforeRender(async () => {
+      var _globalThis, _DATA_FETCH_FUNCTION;
+      setSSREnv({
+        fetchServerQuery
+      });
+      if (typeof window === "undefined") {
+        return;
+      }
+      const dataFetchFunction = async function(options) {
+        const [id, data, downgrade] = options;
+        import_logger.default.debug("==========call data fetch function!");
+        if (data) {
+          if (!id) {
+            throw new Error("id is required!");
+          }
+          if (!(0, import_utils.getDataFetchMap)()) {
+            (0, import_utils.initDataFetchMap)();
+          }
+          const dataFetchItem = (0, import_utils.getDataFetchItem)(id);
+          if (dataFetchItem) {
+            var _dataFetchItem__, _dataFetchItem_;
+            (_dataFetchItem_ = dataFetchItem[1]) === null || _dataFetchItem_ === void 0 ? void 0 : (_dataFetchItem__ = _dataFetchItem_[1]) === null || _dataFetchItem__ === void 0 ? void 0 : _dataFetchItem__.call(_dataFetchItem_, data);
+            dataFetchItem[2] = import_constant.MF_DATA_FETCH_STATUS.LOADED;
+            return;
+          }
+          if (!dataFetchItem) {
+            const dataFetchMap = (0, import_utils.getDataFetchMap)();
+            let res;
+            let rej;
+            const p = new Promise((resolve, reject) => {
+              res = resolve;
+              rej = reject;
+            });
+            dataFetchMap[id] = [
+              [
+                async () => async () => {
+                  return "";
+                },
+                import_constant.MF_DATA_FETCH_TYPE.FETCH_SERVER
+              ],
+              [
+                p,
+                res,
+                rej
+              ],
+              import_constant.MF_DATA_FETCH_STATUS.LOADED
+            ];
+            res(data);
+            return;
+          }
+        }
+        if (downgrade) {
+          const mfDowngrade2 = (0, import_downgrade.getDowngradeTag)();
+          if (!mfDowngrade2) {
+            globalThis[import_constant.DOWNGRADE_KEY] = id ? [
+              id
+            ] : true;
+          } else if (Array.isArray(mfDowngrade2) && id && !mfDowngrade2.includes(id)) {
+            mfDowngrade2.push(id);
+          }
+        }
+        const mfDowngrade = (0, import_downgrade.getDowngradeTag)();
+        if (typeof mfDowngrade === "boolean") {
+          return (0, import_downgrade.callAllDowngrade)();
+        }
+        if (Array.isArray(mfDowngrade)) {
+          if (!id) {
+            globalThis[import_constant.DOWNGRADE_KEY] = true;
+            return (0, import_downgrade.callAllDowngrade)();
+          }
+          if (!mfDowngrade.includes(id)) {
+            mfDowngrade.push(id);
+          }
+          return (0, import_downgrade.callDowngrade)(id);
+        }
+      };
+      globalThis[import_constant.FS_HREF] = window.location.href;
+      (_globalThis = globalThis)[_DATA_FETCH_FUNCTION = import_constant.DATA_FETCH_FUNCTION] || (_globalThis[_DATA_FETCH_FUNCTION] = []);
+      const dataFetch = globalThis[import_constant.DATA_FETCH_FUNCTION];
+      await Promise.all(dataFetch.map(async (options) => {
+        await dataFetchFunction(options);
+      }));
+      dataFetch.push = dataFetchFunction;
+    });
+  }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  injectDataFetchFunctionPlugin,
+  setSSREnv
+});

package/dist/cjs/types/index.js

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);