@module-federation/modern-js 0.14.2 → 0.14.3

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/SSRLiveReload.js

@@ -0,0 +1,19 @@
+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`
+      if(${globalThis.shouldUpdate}){
+        location.reload();
+      }
+   `
+    }
+  });
+}
+export {
+  SSRLiveReload
+};

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

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

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

@@ -0,0 +1,34 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { SSRLiveReload } from "./SSRLiveReload";
+const mfSSRPlugin = () => ({
+  name: "@module-federation/modern-js",
+  setup: (api) => {
+    api.onBeforeRender(async () => {
+      if (typeof window !== "undefined") {
+        return;
+      }
+      globalThis.shouldUpdate = false;
+      const nodeUtils = await import("@module-federation/node/utils");
+      const shouldUpdate = await nodeUtils.revalidate();
+      if (shouldUpdate) {
+        console.log("should RELOAD", shouldUpdate);
+        await nodeUtils.flushChunks();
+        globalThis.shouldUpdate = true;
+      }
+    });
+    api.wrapRoot((App) => {
+      const AppWrapper = (props) => /* @__PURE__ */ _jsxs(_Fragment, {
+        children: [
+          /* @__PURE__ */ _jsx(SSRLiveReload, {}),
+          /* @__PURE__ */ _jsx(App, {
+            ...props
+          })
+        ]
+      });
+      return AppWrapper;
+    });
+  }
+});
+export {
+  mfSSRPlugin
+};

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

@@ -0,0 +1,21 @@
+import { isWebTarget, skipByTarget } from './utils';
+import { moduleFederationPlugin } from '@module-federation/sdk';
+import { PluginOptions } from '../types';
+import type { InternalModernPluginOptions } from '../types';
+import type { AppTools, webpack, UserConfig, Rspack, CliPluginFuture } from '@modern-js/app-tools';
+import type { BundlerChainConfig } from '../interfaces/bundler';
+export type ConfigType<T> = T extends 'webpack' ? webpack.Configuration : T extends 'rspack' ? Rspack.Configuration : never;
+export declare function setEnv(enableSSR: boolean): void;
+export declare const getMFConfig: (userConfig: PluginOptions) => Promise<moduleFederationPlugin.ModuleFederationPluginOptions>;
+export declare const patchMFConfig: (mfConfig: moduleFederationPlugin.ModuleFederationPluginOptions, isServer: boolean, remoteIpStrategy?: "ipv4" | "inherit") => moduleFederationPlugin.ModuleFederationPluginOptions;
+export declare function addMyTypes2Ignored(chain: BundlerChainConfig, mfConfig: moduleFederationPlugin.ModuleFederationPluginOptions): void;
+export declare function patchBundlerConfig(options: {
+    chain: BundlerChainConfig;
+    isServer: boolean;
+    modernjsConfig: UserConfig<AppTools>;
+    mfConfig: moduleFederationPlugin.ModuleFederationPluginOptions;
+    enableSSR: boolean;
+}): void;
+export declare const moduleFederationConfigPlugin: (userConfig: InternalModernPluginOptions) => CliPluginFuture<AppTools>;
+export default moduleFederationConfigPlugin;
+export { isWebTarget, skipByTarget };

package/dist/types/cli/configPlugin.spec.d.ts

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

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

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

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

@@ -0,0 +1,5 @@
+import type { CliPluginFuture, AppTools } from '@modern-js/app-tools';
+import type { PluginOptions } from '../types';
+export declare const moduleFederationPlugin: (userConfig?: PluginOptions) => CliPluginFuture<AppTools>;
+export default moduleFederationPlugin;
+export { createModuleFederationConfig } from '@module-federation/enhanced';

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

@@ -0,0 +1,2 @@
+declare const logger: import("@module-federation/sdk").Logger;
+export default logger;

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

@@ -0,0 +1,2 @@
+import { BundlerPlugin } from '../types';
+export declare function updateStatsAndManifest(nodePlugin: BundlerPlugin, browserPlugin: BundlerPlugin, outputDir: string): void;

package/dist/types/cli/mfRuntimePlugins/inject-node-fetch.d.ts

@@ -0,0 +1,3 @@
+import type { FederationRuntimePlugin } from '@module-federation/enhanced/runtime';
+declare const injectNodeFetchPlugin: () => FederationRuntimePlugin;
+export default injectNodeFetchPlugin;

package/dist/types/cli/mfRuntimePlugins/resolve-entry-ipv4.d.ts

@@ -0,0 +1,3 @@
+import type { FederationRuntimePlugin } from '@module-federation/enhanced/runtime';
+declare const resolveEntryIpv4Plugin: () => FederationRuntimePlugin;
+export default resolveEntryIpv4Plugin;

package/dist/types/cli/mfRuntimePlugins/shared-strategy.d.ts

@@ -0,0 +1,3 @@
+import type { FederationRuntimePlugin } from '@module-federation/enhanced/runtime';
+declare const sharedStrategy: () => FederationRuntimePlugin;
+export default sharedStrategy;

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

@@ -0,0 +1,6 @@
+import type { CliPluginFuture, AppTools } from '@modern-js/app-tools';
+import type { InternalModernPluginOptions } from '../types';
+export declare function setEnv(): void;
+export declare const CHAIN_MF_PLUGIN_ID = "plugin-module-federation-server";
+export declare const moduleFederationSSRPlugin: (pluginOptions: Required<InternalModernPluginOptions>) => CliPluginFuture<AppTools>;
+export default moduleFederationSSRPlugin;

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

@@ -0,0 +1,5 @@
+import type { webpack, Rspack } from '@modern-js/app-tools';
+export type ConfigType<T> = T extends 'webpack' ? webpack.Configuration : T extends 'rspack' ? Rspack.Configuration : never;
+export declare const getIPV4: () => string;
+export declare const isWebTarget: (target: string[] | string) => boolean;
+export declare const skipByTarget: (target: string[] | string) => boolean;

package/dist/types/constant.d.ts

@@ -0,0 +1,2 @@
+export declare const LOCALHOST = "localhost";
+export declare const PLUGIN_IDENTIFIER = "[ Modern.js Module Federation ]";

package/dist/types/interfaces/bundler.d.ts

@@ -0,0 +1,18 @@
+import type { AppTools, Bundler, UserConfig } from '@modern-js/app-tools';
+type AppToolsUserConfig<T extends Bundler> = AppTools<T>['userConfig']['tools'];
+type ExcludeUndefined<T> = T extends undefined ? never : T;
+type ExtractObjectType<T> = T extends (...args: any[]) => any ? never : T;
+type OmitArrayConfiguration<T> = T extends Array<any> ? (T extends (infer U)[] ? U : T) : ExtractObjectType<T>;
+type WebpackConfigs = ExcludeUndefined<AppToolsUserConfig<'webpack'>> extends {
+    webpack?: infer U;
+} ? U : never;
+type ObjectWebpack = ExtractObjectType<OmitArrayConfiguration<WebpackConfigs>>;
+type RspackConfigs = ExcludeUndefined<AppToolsUserConfig<'rspack'>> extends {
+    rspack?: infer U;
+} ? U : never;
+type ObjectRspack = ExtractObjectType<OmitArrayConfiguration<RspackConfigs>>;
+type BundlerChain = ExcludeUndefined<ExcludeUndefined<UserConfig<AppTools>['tools']>['bundlerChain']>;
+type BundlerChainFunc = Extract<BundlerChain, (chain: any, utils: any) => any>;
+export type BundlerChainConfig = Parameters<BundlerChainFunc>[0];
+export type BundlerConfig<T extends Bundler> = T extends 'rspack' ? ObjectRspack : ObjectWebpack;
+export {};

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

@@ -0,0 +1,5 @@
+export * from '@module-federation/enhanced/runtime';
+export declare const kit: {
+    readonly createRemoteSSRComponent: any;
+    readonly collectSSRAssets: any;
+};

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/SSRLiveReload.d.ts

@@ -0,0 +1 @@
+export declare function SSRLiveReload(): import("react").JSX.Element | null;

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

@@ -0,0 +1,22 @@
+import { moduleFederationPlugin } from '@module-federation/sdk';
+import type { ModuleFederationPlugin as WebpackModuleFederationPlugin } from '@module-federation/enhanced';
+import type { ModuleFederationPlugin as RspackModuleFederationPlugin } from '@module-federation/enhanced/rspack';
+export interface PluginOptions {
+    config?: moduleFederationPlugin.ModuleFederationPluginOptions;
+    configPath?: string;
+    ssr?: {
+        distOutputDir?: string;
+    } | boolean;
+    remoteIpStrategy?: 'ipv4' | 'inherit';
+}
+export interface InternalModernPluginOptions {
+    csrConfig?: moduleFederationPlugin.ModuleFederationPluginOptions;
+    ssrConfig?: moduleFederationPlugin.ModuleFederationPluginOptions;
+    distOutputDir: string;
+    originPluginOptions: PluginOptions;
+    browserPlugin?: BundlerPlugin;
+    nodePlugin?: BundlerPlugin;
+    remoteIpStrategy?: 'ipv4' | 'inherit';
+    userConfig?: PluginOptions;
+}
+export type BundlerPlugin = WebpackModuleFederationPlugin | RspackModuleFederationPlugin;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@module-federation/modern-js",
-  "version": "0.14.2",
+  "version": "0.14.3",
   "files": [
     "dist/",
     "types.d.ts",
@@ -97,11 +97,11 @@
     "@swc/helpers": "0.5.13",
     "node-fetch": "~3.3.0",
     "react-error-boundary": "4.1.2",
-    "@module-federation/rsbuild-plugin": "0.14.2",
-    "@module-federation/enhanced": "0.14.2",
-    "@module-federation/node": "2.7.5",
-    "@module-federation/sdk": "0.14.2",
-    "@module-federation/cli": "0.14.2"
+    "@module-federation/rsbuild-plugin": "0.14.3",
+    "@module-federation/enhanced": "0.14.3",
+    "@module-federation/node": "2.7.6",
+    "@module-federation/sdk": "0.14.3",
+    "@module-federation/cli": "0.14.3"
   },
   "devDependencies": {
     "@rsbuild/core": "1.2.8",
@@ -110,7 +110,7 @@
     "@modern-js/module-tools": "2.67.6",
     "@modern-js/runtime": "2.67.6",
     "@modern-js/tsconfig": "2.67.6",
-    "@module-federation/manifest": "0.14.2"
+    "@module-federation/manifest": "0.14.3"
   },
   "peerDependencies": {
     "react": ">=17",