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

package/dist/esm-node/runtime/createRemoteSSRComponent.js

@@ -0,0 +1,166 @@
+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) {
+  const { name, expose } = instance.remoteHandler.idToRemoteMap[id] || {};
+  if (!name) {
+    return;
+  }
+  const module = instance.moduleCache.get(name);
+  if (!module) {
+    return;
+  }
+  const { remoteSnapshot } = instance.snapshotHandler.getGlobalRemoteInfo(module.remoteInfo);
+  return {
+    ...module.remoteInfo,
+    snapshot: remoteSnapshot,
+    expose
+  };
+}
+function getTargetModuleInfo(id) {
+  const instance = getInstance();
+  if (!instance) {
+    return;
+  }
+  const loadedRemoteInfo = getLoadedRemoteInfos(instance, id);
+  if (!loadedRemoteInfo) {
+    return;
+  }
+  const snapshot = loadedRemoteInfo.snapshot;
+  if (!snapshot) {
+    return;
+  }
+  const publicPath = "publicPath" in snapshot ? snapshot.publicPath : "getPublicPath" in snapshot ? new Function(snapshot.getPublicPath)() : "";
+  if (!publicPath) {
+    return;
+  }
+  const modules = "modules" in snapshot ? snapshot.modules : [];
+  const targetModule = modules.find((m) => m.modulePath === loadedRemoteInfo.expose);
+  if (!targetModule) {
+    return;
+  }
+  const remoteEntry = "remoteEntry" in snapshot ? snapshot.remoteEntry : "";
+  if (!remoteEntry) {
+    return;
+  }
+  return {
+    module: targetModule,
+    publicPath,
+    remoteEntry
+  };
+}
+function collectSSRAssets(options) {
+  const { id, injectLink = true, injectScript = true } = typeof options === "string" ? {
+    id: options
+  } : options;
+  const links = [];
+  const scripts = [];
+  const instance = getInstance();
+  if (!instance || !injectLink && !injectScript) {
+    return [
+      ...scripts,
+      ...links
+    ];
+  }
+  const moduleAndPublicPath = getTargetModuleInfo(id);
+  if (!moduleAndPublicPath) {
+    return [
+      ...scripts,
+      ...links
+    ];
+  }
+  const { module: targetModule, publicPath, remoteEntry } = moduleAndPublicPath;
+  if (injectLink) {
+    [
+      ...targetModule.assets.css.sync,
+      ...targetModule.assets.css.async
+    ].forEach((file, index) => {
+      links.push(/* @__PURE__ */ _jsx("link", {
+        href: `${publicPath}${file}`,
+        rel: "stylesheet",
+        type: "text/css"
+      }, `${file.split(".")[0]}_${index}`));
+    });
+  }
+  if (injectScript) {
+    scripts.push(/* @__PURE__ */ _jsx("script", {
+      async: true,
+      src: `${publicPath}${remoteEntry}`,
+      crossOrigin: "anonymous"
+    }, remoteEntry.split(".")[0]));
+    [
+      ...targetModule.assets.js.sync
+    ].forEach((file, index) => {
+      scripts.push(/* @__PURE__ */ _jsx("script", {
+        async: true,
+        src: `${publicPath}${file}`,
+        crossOrigin: "anonymous"
+      }, `${file.split(".")[0]}_${index}`));
+    });
+  }
+  return [
+    ...scripts,
+    ...links
+  ];
+}
+function createRemoteSSRComponent(info) {
+  const exportName = (info === null || info === void 0 ? void 0 : info.export) || "default";
+  const LazyComponent = /* @__PURE__ */ React.lazy(async () => {
+    try {
+      const m = await info.loader();
+      if (!m) {
+        throw new Error("load remote failed");
+      }
+      const moduleId = m && m[Symbol.for("mf_module_id")];
+      const assets = collectSSRAssets({
+        id: moduleId
+      });
+      const Com = m[exportName];
+      if (exportName in m && typeof Com === "function") {
+        return {
+          default: (props) => /* @__PURE__ */ _jsxs(_Fragment, {
+            children: [
+              assets,
+              /* @__PURE__ */ _jsx(Com, {
+                ...props
+              })
+            ]
+          })
+        };
+      } else {
+        throw Error(`Make sure that ${moduleId} has the correct export when export is ${String(exportName)}`);
+      }
+    } catch (err) {
+      if (!info.fallback) {
+        throw err;
+      }
+      const FallbackFunctionComponent = info.fallback;
+      const FallbackNode = /* @__PURE__ */ _jsx(FallbackFunctionComponent, {
+        error: err,
+        resetErrorBoundary: () => {
+          console.log('SSR mode not support "resetErrorBoundary" !');
+        }
+      });
+      return {
+        default: () => FallbackNode
+      };
+    }
+  });
+  return (props) => {
+    const { key, ...args } = props;
+    return /* @__PURE__ */ _jsx(ErrorBoundary, {
+      FallbackComponent: info.fallback,
+      children: /* @__PURE__ */ _jsx(React.Suspense, {
+        fallback: info.loading,
+        children: /* @__PURE__ */ _jsx(LazyComponent, {
+          ...args
+        })
+      })
+    });
+  };
+}
+export {
+  collectSSRAssets,
+  createRemoteSSRComponent
+};

package/dist/esm-node/runtime/index.js

@@ -1,22 +1,12 @@
 export * from "@module-federation/enhanced/runtime";
-import { ERROR_TYPE } from "../constant";
 const 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-node/server/fileCache.js

@@ -0,0 +1,49 @@
+import fs from "fs-extra";
+import { LRUCache } from "lru-cache";
+class FileCache {
+  /**
+  * Check if file exists and return file info
+  * @param filepath Path to the file
+  * @returns FileResult or null if file doesn't exist
+  */
+  async getFile(filepath) {
+    if (!await fs.pathExists(filepath)) {
+      return null;
+    }
+    try {
+      const stat = await fs.lstat(filepath);
+      const currentModified = stat.mtimeMs;
+      const cachedEntry = this.cache.get(filepath);
+      if (cachedEntry && currentModified <= cachedEntry.lastModified) {
+        return {
+          content: cachedEntry.content,
+          lastModified: cachedEntry.lastModified
+        };
+      }
+      const content = await fs.readFile(filepath, "utf-8");
+      const newEntry = {
+        content,
+        lastModified: currentModified
+      };
+      this.cache.set(filepath, newEntry, {
+        size: stat.size || content.length
+      });
+      return {
+        content,
+        lastModified: currentModified
+      };
+    } catch (err) {
+      return null;
+    }
+  }
+  constructor() {
+    this.cache = new LRUCache({
+      maxSize: 200 * 1024 * 1024
+    });
+  }
+}
+const fileCache = new FileCache();
+export {
+  FileCache,
+  fileCache
+};

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

@@ -0,0 +1,27 @@
+import { it, expect, describe, vi, beforeAll } from "vitest";
+import { FileCache } from "./fileCache";
+beforeAll(() => {
+  vi.mock("fs-extra", () => ({
+    default: {
+      pathExists: () => {
+        return true;
+      },
+      lstat: () => {
+        return {
+          mtimeMs: Date.now(),
+          size: 4
+        };
+      },
+      readFile: () => {
+        return "test";
+      }
+    }
+  }));
+});
+describe("modern serve static file cache", async () => {
+  it("should cache file", async () => {
+    const cache = new FileCache();
+    const result = await cache.getFile("test.txt");
+    expect(result === null || result === void 0 ? void 0 : result.content).toBe("test");
+  });
+});

package/dist/esm-node/server/index.js

@@ -0,0 +1,34 @@
+import { createStaticMiddleware } from "./staticMiddleware";
+const staticServePlugin = () => ({
+  name: "@modern-js/module-federation/server",
+  setup: (api) => {
+    api.onPrepare(() => {
+      var _config_output, _config_server;
+      console.log(process.env.NODE_ENV);
+      if (process.env.NODE_ENV === "development") {
+        return;
+      }
+      const { middlewares } = api.getServerContext();
+      const config = api.getServerConfig();
+      const 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;
+      }
+      const context = api.getServerContext();
+      const pwd = context.distDirectory;
+      const 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-node/server/staticMiddleware.js

@@ -0,0 +1,43 @@
+import fs from "fs-extra";
+import path from "node:path";
+import { fileCache } from "./fileCache";
+const bundlesAssetPrefix = "/bundles";
+const removeHost = (url) => {
+  try {
+    const hasProtocol = url.includes("://");
+    const hasDomain = hasProtocol || url.startsWith("//");
+    const pathname = hasDomain ? new URL(hasProtocol ? url : `http:${url}`).pathname : url;
+    return pathname;
+  } catch (e) {
+    return url;
+  }
+};
+const createStaticMiddleware = (options) => {
+  const { assetPrefix, pwd } = options;
+  return async (c, next) => {
+    const pathname = c.req.path;
+    if (path.extname(pathname) !== ".js") {
+      return next();
+    }
+    const prefixWithoutHost = removeHost(assetPrefix);
+    const prefixWithBundle = path.join(prefixWithoutHost, bundlesAssetPrefix);
+    if (!pathname.startsWith(prefixWithBundle)) {
+      return next();
+    }
+    const pathnameWithoutPrefix = pathname.replace(prefixWithBundle, "");
+    const filepath = path.join(pwd, bundlesAssetPrefix, pathnameWithoutPrefix);
+    if (!await fs.pathExists(filepath)) {
+      return next();
+    }
+    const fileResult = await fileCache.getFile(filepath);
+    if (!fileResult) {
+      return next();
+    }
+    c.header("Content-Type", "application/javascript");
+    c.header("Content-Length", String(fileResult.content.length));
+    return c.body(fileResult.content, 200);
+  };
+};
+export {
+  createStaticMiddleware
+};

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

@@ -0,0 +1,162 @@
+import { it, expect, describe, vi, beforeEach } from "vitest";
+import { createStaticMiddleware } from "./staticMiddleware";
+vi.mock("fs-extra", () => ({
+  default: {
+    pathExists: vi.fn()
+  }
+}));
+vi.mock("./fileCache", () => ({
+  fileCache: {
+    getFile: vi.fn()
+  }
+}));
+import fs from "fs-extra";
+import { fileCache } from "./fileCache";
+describe("staticMiddleware", () => {
+  let middleware;
+  let mockContext;
+  let nextSpy;
+  beforeEach(() => {
+    vi.clearAllMocks();
+    middleware = createStaticMiddleware({
+      assetPrefix: "",
+      pwd: "/test/path"
+    });
+    nextSpy = vi.fn();
+    mockContext = {
+      req: {
+        path: ""
+      },
+      header: vi.fn(),
+      body: vi.fn()
+    };
+  });
+  describe("file extension filtering", () => {
+    it("should call next() for non-js files", async () => {
+      mockContext.req.path = "/bundles/test.css";
+      await middleware(mockContext, nextSpy);
+      expect(nextSpy).toHaveBeenCalledOnce();
+      expect(mockContext.header).not.toHaveBeenCalled();
+      expect(mockContext.body).not.toHaveBeenCalled();
+    });
+    it("should call next() for files without extension", async () => {
+      mockContext.req.path = "/bundles/test";
+      await middleware(mockContext, nextSpy);
+      expect(nextSpy).toHaveBeenCalledOnce();
+      expect(mockContext.header).not.toHaveBeenCalled();
+      expect(mockContext.body).not.toHaveBeenCalled();
+    });
+    it("should process .js files", async () => {
+      mockContext.req.path = "/bundles/test.js";
+      fs.pathExists.mockResolvedValue(false);
+      await middleware(mockContext, nextSpy);
+      expect(fs.pathExists).toHaveBeenCalled();
+    });
+  });
+  describe("asset prefix filtering", () => {
+    it("should call next() for paths not starting with /bundles", async () => {
+      mockContext.req.path = "/assets/test.js";
+      await middleware(mockContext, nextSpy);
+      expect(nextSpy).toHaveBeenCalledOnce();
+      expect(fs.pathExists).not.toHaveBeenCalled();
+      expect(mockContext.header).not.toHaveBeenCalled();
+      expect(mockContext.body).not.toHaveBeenCalled();
+    });
+    it("should call next() for root path", async () => {
+      mockContext.req.path = "/test.js";
+      await middleware(mockContext, nextSpy);
+      expect(nextSpy).toHaveBeenCalledOnce();
+      expect(fs.pathExists).not.toHaveBeenCalled();
+    });
+    it("should process paths starting with /bundles", async () => {
+      mockContext.req.path = "/bundles/test.js";
+      fs.pathExists.mockResolvedValue(false);
+      await middleware(mockContext, nextSpy);
+      expect(fs.pathExists).toHaveBeenCalledWith("/test/path/bundles/test.js");
+    });
+  });
+  describe("file existence check", () => {
+    it("should call next() when file does not exist", async () => {
+      mockContext.req.path = "/bundles/nonexistent.js";
+      fs.pathExists.mockResolvedValue(false);
+      await middleware(mockContext, nextSpy);
+      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();
+    });
+    it("should proceed to file cache when file exists", async () => {
+      mockContext.req.path = "/bundles/existing.js";
+      fs.pathExists.mockResolvedValue(true);
+      fileCache.getFile.mockResolvedValue(null);
+      await middleware(mockContext, nextSpy);
+      expect(fs.pathExists).toHaveBeenCalledWith("/test/path/bundles/existing.js");
+      expect(fileCache.getFile).toHaveBeenCalledWith("/test/path/bundles/existing.js");
+    });
+  });
+  describe("successful file serving", () => {
+    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";
+      fs.pathExists.mockResolvedValue(true);
+      fileCache.getFile.mockResolvedValue(mockFileResult);
+      mockContext.body.mockReturnValue("response");
+      const result = await middleware(mockContext, nextSpy);
+      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");
+    });
+    it("should handle empty file content", async () => {
+      const mockFileResult = {
+        content: "",
+        lastModified: Date.now()
+      };
+      mockContext.req.path = "/bundles/empty.js";
+      fs.pathExists.mockResolvedValue(true);
+      fileCache.getFile.mockResolvedValue(mockFileResult);
+      mockContext.body.mockReturnValue("empty-response");
+      const result = await middleware(mockContext, nextSpy);
+      expect(mockContext.header).toHaveBeenCalledWith("Content-Length", "0");
+      expect(mockContext.body).toHaveBeenCalledWith(mockFileResult.content, 200);
+      expect(result).toBe("empty-response");
+      expect(nextSpy).not.toHaveBeenCalled();
+    });
+  });
+  describe("asset prefix handling", () => {
+    it("should handle custom asset prefix correctly", async () => {
+      const customMiddleware = createStaticMiddleware({
+        assetPrefix: "/custom-prefix",
+        pwd: "/test/path"
+      });
+      mockContext.req.path = "/bundles/test.js";
+      await customMiddleware(mockContext, nextSpy);
+      expect(nextSpy).toHaveBeenCalledOnce();
+      expect(mockContext.header).not.toHaveBeenCalled();
+      expect(mockContext.body).not.toHaveBeenCalled();
+    });
+    it("should handle asset prefix removal correctly", async () => {
+      const customMiddleware = createStaticMiddleware({
+        assetPrefix: "/prefix",
+        pwd: "/test/path"
+      });
+      const mockFileResult = {
+        content: "test content",
+        lastModified: Date.now()
+      };
+      mockContext.req.path = "/prefix/bundles/test.js";
+      fs.pathExists.mockResolvedValue(true);
+      fileCache.getFile.mockResolvedValue(mockFileResult);
+      await customMiddleware(mockContext, nextSpy);
+      expect(fs.pathExists).toHaveBeenCalledWith("/test/path/bundles/test.js");
+    });
+  });
+});

package/dist/esm-node/ssr-runtime/index.js

@@ -0,0 +1 @@
+export * from "./plugin";

package/dist/esm-node/ssr-runtime/{devPlugin.js → plugin.js}

@@ -1,7 +1,6 @@
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
 import { SSRLiveReload } from "./SSRLiveReload";
-import { flushDataFetch } from "../utils";
-const mfSSRDevPlugin = () => ({
+const mfSSRPlugin = () => ({
   name: "@module-federation/modern-js",
   setup: (api) => {
     api.onBeforeRender(async () => {
@@ -11,11 +10,9 @@ const mfSSRDevPlugin = () => ({
       globalThis.shouldUpdate = false;
       const nodeUtils = await import("@module-federation/node/utils");
       const shouldUpdate = await nodeUtils.revalidate();
-      console.log("shouldUpdate: ", shouldUpdate);
       if (shouldUpdate) {
         console.log("should RELOAD", shouldUpdate);
         await nodeUtils.flushChunks();
-        flushDataFetch();
         globalThis.shouldUpdate = true;
       }
     });
@@ -33,5 +30,5 @@ const mfSSRDevPlugin = () => ({
   }
 });
 export {
-  mfSSRDevPlugin
+  mfSSRPlugin
 };

package/dist/types/cli/constant.d.ts

@@ -0,0 +1 @@
+export declare const isDev: boolean;

package/dist/types/cli/index.d.ts

@@ -3,4 +3,3 @@ import type { PluginOptions } from '../types';
 export declare const moduleFederationPlugin: (userConfig?: PluginOptions) => CliPluginFuture<AppTools>;
 export default moduleFederationPlugin;
 export { createModuleFederationConfig } from '@module-federation/enhanced';
-export type { FederationRuntimePlugin } from '@module-federation/enhanced/runtime';

package/dist/types/cli/utils.d.ts

@@ -3,4 +3,3 @@ export type ConfigType<T> = T extends 'webpack' ? webpack.Configuration : T exte
 export declare const getIPV4: () => string;
 export declare const isWebTarget: (target: string[] | string) => boolean;
 export declare const skipByTarget: (target: string[] | string) => boolean;
-export declare function isDev(): boolean;

package/dist/types/constant.d.ts

@@ -1,25 +1,2 @@
 export declare const LOCALHOST = "localhost";
 export declare const PLUGIN_IDENTIFIER = "[ Modern.js Module Federation ]";
-export declare const DATA_FETCH_QUERY = "x-mf-data-fetch";
-export declare const DATA_FETCH_ERROR_PREFIX = "caught the following error during dataFetch: ";
-export declare const LOAD_REMOTE_ERROR_PREFIX = "caught the following error during loadRemote: ";
-export declare const DOWNGRADE_KEY = "_mfSSRDowngrade";
-export declare const DATA_FETCH_MAP_KEY = "__MF_DATA_FETCH_MAP__";
-export declare const DATA_FETCH_FUNCTION = "_mfDataFetch";
-export declare const FS_HREF = "_mfFSHref";
-export declare const ERROR_TYPE: {
-    DATA_FETCH: number;
-    LOAD_REMOTE: number;
-    UNKNOWN: number;
-};
-export declare const WRAP_DATA_FETCH_ID_IDENTIFIER = "wrap_dfip_identifier";
-export declare const enum MF_DATA_FETCH_TYPE {
-    FETCH_SERVER = 1,
-    FETCH_CLIENT = 2
-}
-export declare const enum MF_DATA_FETCH_STATUS {
-    LOADED = 1,
-    LOADING = 2,
-    AWAIT = 0,
-    ERROR = 3
-}

package/dist/types/runtime/createRemoteSSRComponent.d.ts

@@ -0,0 +1,18 @@
+import React from 'react';
+import { ErrorBoundaryPropsWithComponent } from 'react-error-boundary';
+type IProps = {
+    id: string;
+    injectScript?: boolean;
+    injectLink?: boolean;
+};
+type ReactKey = {
+    key?: React.Key | null;
+};
+export declare function collectSSRAssets(options: IProps): React.ReactNode[];
+export declare function createRemoteSSRComponent<T, E extends keyof T>(info: {
+    loader: () => Promise<T>;
+    loading: React.ReactNode;
+    fallback: ErrorBoundaryPropsWithComponent['FallbackComponent'];
+    export?: E;
+}): (props: T[E] extends (...args: any) => any ? Parameters<T[E]>[0] extends undefined ? ReactKey : Parameters<T[E]>[0] & ReactKey : ReactKey) => React.JSX.Element;
+export {};

package/dist/types/runtime/index.d.ts

@@ -1,10 +1,5 @@
 export * from '@module-federation/enhanced/runtime';
-export type { DataFetchParams } from '../interfaces/global';
-export { ERROR_TYPE } from '../constant';
 export declare const kit: {
-    readonly createRemoteSSRComponent: typeof import("./createRemoteComponent").createRemoteSSRComponent;
-    readonly createRemoteComponent: typeof import("./createRemoteComponent").createRemoteComponent;
-    readonly collectSSRAssets: typeof import("./createRemoteComponent").collectSSRAssets;
-    readonly wrapNoSSR: typeof import("./wrapNoSSR").wrapNoSSR;
+    readonly createRemoteSSRComponent: any;
+    readonly collectSSRAssets: any;
 };
-export { setSSREnv } from '../ssr-runtime/injectDataFetchFunctionPlugin';

package/dist/types/server/fileCache.d.ts

@@ -0,0 +1,14 @@
+export interface FileResult {
+    content: string;
+    lastModified: number;
+}
+export declare class FileCache {
+    private cache;
+    /**
+     * Check if file exists and return file info
+     * @param filepath Path to the file
+     * @returns FileResult or null if file doesn't exist
+     */
+    getFile(filepath: string): Promise<FileResult | null>;
+}
+export declare const fileCache: FileCache;

package/dist/types/server/fileCache.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/server/index.d.ts

@@ -0,0 +1,4 @@
+import type { ServerPlugin } from '@modern-js/server-runtime';
+declare const staticServePlugin: () => ServerPlugin;
+export default staticServePlugin;
+export { staticServePlugin };

package/dist/types/server/staticMiddleware.d.ts

@@ -0,0 +1,6 @@
+import type { MiddlewareHandler } from '@modern-js/server-runtime';
+declare const createStaticMiddleware: (options: {
+    assetPrefix: string;
+    pwd: string;
+}) => MiddlewareHandler;
+export { createStaticMiddleware };

package/dist/types/server/staticMiddleware.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/ssr-runtime/index.d.ts

@@ -0,0 +1 @@
+export * from './plugin';

package/dist/types/ssr-runtime/plugin.d.ts

@@ -0,0 +1,2 @@
+import type { RuntimePluginFuture } from '@modern-js/runtime';
+export declare const mfSSRPlugin: () => RuntimePluginFuture;

package/dist/types/types/index.d.ts

@@ -8,7 +8,6 @@ export interface PluginOptions {
         distOutputDir?: string;
     } | boolean;
     remoteIpStrategy?: 'ipv4' | 'inherit';
-    fetchServerQuery?: Record<string, unknown>;
 }
 export interface InternalModernPluginOptions {
     csrConfig?: moduleFederationPlugin.ModuleFederationPluginOptions;
@@ -19,6 +18,5 @@ export interface InternalModernPluginOptions {
     nodePlugin?: BundlerPlugin;
     remoteIpStrategy?: 'ipv4' | 'inherit';
     userConfig?: PluginOptions;
-    fetchServerQuery?: Record<string, unknown>;
 }
 export type BundlerPlugin = WebpackModuleFederationPlugin | RspackModuleFederationPlugin;