@module-federation/modern-js 0.21.6 → 0.22.0

package/dist/esm-node/cli/ssrPlugin.mjs

@@ -0,0 +1,228 @@
+import path from "path";
+import fs_extra from "fs-extra";
+import { ModuleFederationPlugin } from "@module-federation/enhanced/webpack";
+import { ModuleFederationPlugin as rspack_ModuleFederationPlugin } from "@module-federation/enhanced/rspack";
+import universe_entry_chunk_tracker_plugin from "@module-federation/node/universe-entry-chunk-tracker-plugin";
+import logger from "../logger.mjs";
+import { isDev, isWebTarget, skipByTarget } from "./utils.mjs";
+import { updateStatsAndManifest } from "@module-federation/rsbuild-plugin/utils";
+import { ManifestFileName, StatsFileName, simpleJoinRemoteEntry } from "@module-federation/sdk";
+function setEnv() {
+    process.env['MF_SSR_PRJ'] = 'true';
+}
+const CHAIN_MF_PLUGIN_ID = 'plugin-module-federation-server';
+function getManifestAssetFileNames(manifestOption) {
+    if (!manifestOption) return {
+        statsFileName: StatsFileName,
+        manifestFileName: ManifestFileName
+    };
+    const JSON_EXT = '.json';
+    const filePath = 'boolean' == typeof manifestOption ? '' : manifestOption.filePath || '';
+    const baseFileName = 'boolean' == typeof manifestOption ? '' : manifestOption.fileName || '';
+    const ensureExt = (name)=>name.endsWith(JSON_EXT) ? name : `${name}${JSON_EXT}`;
+    const withSuffix = (name, suffix)=>name.replace(JSON_EXT, `${suffix}${JSON_EXT}`);
+    const manifestFileName = baseFileName ? ensureExt(baseFileName) : ManifestFileName;
+    const statsFileName = baseFileName ? withSuffix(manifestFileName, '-stats') : StatsFileName;
+    return {
+        statsFileName: simpleJoinRemoteEntry(filePath, statsFileName),
+        manifestFileName: simpleJoinRemoteEntry(filePath, manifestFileName)
+    };
+}
+const mfSSRRsbuildPlugin = (pluginOptions)=>({
+        name: '@modern-js/plugin-mf-post-config',
+        pre: [
+            '@modern-js/builder-plugin-ssr'
+        ],
+        setup (api) {
+            var _pluginOptions_csrConfig, _pluginOptions_assetFileNames, _pluginOptions_ssrConfig;
+            if (pluginOptions.csrConfig.getPublicPath) return;
+            let csrOutputPath = '';
+            let ssrOutputPath = '';
+            let ssrEnv = '';
+            let csrEnv = '';
+            const browserAssetFileNames = pluginOptions.assetFileNames.browser || getManifestAssetFileNames(null == (_pluginOptions_csrConfig = pluginOptions.csrConfig) ? void 0 : _pluginOptions_csrConfig.manifest);
+            const nodeAssetFileNames = (null == (_pluginOptions_assetFileNames = pluginOptions.assetFileNames) ? void 0 : _pluginOptions_assetFileNames.node) || getManifestAssetFileNames(null == (_pluginOptions_ssrConfig = pluginOptions.ssrConfig) ? void 0 : _pluginOptions_ssrConfig.manifest);
+            const collectAssets = (assets, fileNames, tag)=>{
+                const statsAsset = assets[fileNames.statsFileName];
+                const manifestAsset = assets[fileNames.manifestFileName];
+                if (!statsAsset || !manifestAsset) return;
+                try {
+                    const statsRaw = statsAsset.source();
+                    const manifestRaw = manifestAsset.source();
+                    const statsContent = 'string' == typeof statsRaw ? statsRaw : statsRaw.toString();
+                    const manifestContent = 'string' == typeof manifestRaw ? manifestRaw : manifestRaw.toString();
+                    return {
+                        stats: {
+                            data: JSON.parse(statsContent),
+                            filename: fileNames.statsFileName
+                        },
+                        manifest: {
+                            data: JSON.parse(manifestContent),
+                            filename: fileNames.manifestFileName
+                        }
+                    };
+                } catch (err) {
+                    const message = err instanceof Error ? err.message : String(err);
+                    logger.error(`Failed to parse ${tag} manifest assets: ${message}`);
+                    return;
+                }
+            };
+            api.modifyEnvironmentConfig((config, { name })=>{
+                const target = config.output.target;
+                if (skipByTarget(target)) return config;
+                if (isWebTarget(target)) {
+                    csrOutputPath = config.output.distPath.root;
+                    csrEnv = name;
+                } else {
+                    ssrOutputPath = config.output.distPath.root;
+                    ssrEnv = name;
+                }
+                return config;
+            });
+            const modifySSRPublicPath = (config, utils)=>{
+                if (ssrEnv !== utils.environment.name) return config;
+                const userSSRConfig = pluginOptions.userConfig.ssr ? 'object' == typeof pluginOptions.userConfig.ssr ? pluginOptions.userConfig.ssr : {} : {};
+                if (!userSSRConfig.distOutputDir) return;
+                config.output.publicPath = `${config.output.publicPath}${path.relative(csrOutputPath, ssrOutputPath)}/`;
+                return config;
+            };
+            api.modifyWebpackConfig((config, utils)=>{
+                modifySSRPublicPath(config, utils);
+                return config;
+            });
+            api.modifyRspackConfig((config, utils)=>{
+                modifySSRPublicPath(config, utils);
+                return config;
+            });
+            api.processAssets({
+                stage: 'report'
+            }, ({ assets, environment: envContext })=>{
+                var _pluginOptions_csrConfig, _pluginOptions_ssrConfig;
+                const envName = envContext.name;
+                if ((null == (_pluginOptions_csrConfig = pluginOptions.csrConfig) ? void 0 : _pluginOptions_csrConfig.manifest) !== false && csrEnv && envName === csrEnv) {
+                    const browserAssets = collectAssets(assets, browserAssetFileNames, 'browser');
+                    if (browserAssets) pluginOptions.assetResources.browser = browserAssets;
+                }
+                if ((null == (_pluginOptions_ssrConfig = pluginOptions.ssrConfig) ? void 0 : _pluginOptions_ssrConfig.manifest) !== false && ssrEnv && envName === ssrEnv) {
+                    const nodeAssets = collectAssets(assets, nodeAssetFileNames, 'node');
+                    if (nodeAssets) pluginOptions.assetResources.node = nodeAssets;
+                }
+            });
+        }
+    });
+const moduleFederationSSRPlugin = (pluginOptions)=>({
+        name: '@modern-js/plugin-module-federation-ssr',
+        pre: [
+            '@modern-js/plugin-module-federation-config',
+            '@modern-js/plugin-module-federation'
+        ],
+        setup: async (api)=>{
+            var _pluginOptions_userConfig, _modernjsConfig_server;
+            const modernjsConfig = api.getConfig();
+            var _ref;
+            const enableSSR = null != (_ref = null == (_pluginOptions_userConfig = pluginOptions.userConfig) ? void 0 : _pluginOptions_userConfig.ssr) ? _ref : Boolean(null == modernjsConfig ? void 0 : null == (_modernjsConfig_server = modernjsConfig.server) ? void 0 : _modernjsConfig_server.ssr);
+            if (!enableSSR) return;
+            setEnv();
+            api._internalRuntimePlugins(({ entrypoint, plugins })=>{
+                const { fetchServerQuery } = pluginOptions;
+                plugins.push({
+                    name: 'injectDataFetchFunction',
+                    path: '@module-federation/modern-js/ssr-inject-data-fetch-function-plugin',
+                    config: {
+                        fetchServerQuery
+                    }
+                });
+                if (!isDev()) return {
+                    entrypoint,
+                    plugins
+                };
+                plugins.push({
+                    name: 'mfSSRDev',
+                    path: '@module-federation/modern-js/ssr-dev-plugin',
+                    config: {}
+                });
+                return {
+                    entrypoint,
+                    plugins
+                };
+            });
+            if (pluginOptions.ssrConfig.remotes) api._internalServerPlugins(({ plugins })=>{
+                plugins.push({
+                    name: '@module-federation/modern-js/data-fetch-server-plugin',
+                    options: {}
+                });
+                return {
+                    plugins
+                };
+            });
+            api.modifyBundlerChain((chain)=>{
+                const target = chain.get('target');
+                if (skipByTarget(target)) return;
+                const bundlerType = 'rspack' === api.getAppContext().bundlerType ? 'rspack' : 'webpack';
+                const MFPlugin = 'webpack' === bundlerType ? ModuleFederationPlugin : rspack_ModuleFederationPlugin;
+                const isWeb = isWebTarget(target);
+                if (!isWeb) {
+                    if (!chain.plugins.has(CHAIN_MF_PLUGIN_ID)) chain.plugin(CHAIN_MF_PLUGIN_ID).use(MFPlugin, [
+                        pluginOptions.ssrConfig
+                    ]).init((Plugin, args)=>{
+                        pluginOptions.nodePlugin = new Plugin(args[0]);
+                        return pluginOptions.nodePlugin;
+                    });
+                }
+                if (!isWeb) {
+                    chain.target('async-node');
+                    if (isDev()) chain.plugin('UniverseEntryChunkTrackerPlugin').use(universe_entry_chunk_tracker_plugin);
+                }
+                if (isDev() && isWeb) chain.externals({
+                    '@module-federation/node/utils': 'NOT_USED_IN_BROWSER'
+                });
+            });
+            api.config(()=>({
+                    builderPlugins: [
+                        mfSSRRsbuildPlugin(pluginOptions)
+                    ],
+                    tools: {
+                        devServer: {
+                            before: [
+                                (req, res, next)=>{
+                                    if (!enableSSR) return void next();
+                                    try {
+                                        var _req_url, _req_url1;
+                                        if ((null == (_req_url = req.url) ? void 0 : _req_url.includes('.json')) && !(null == (_req_url1 = req.url) ? void 0 : _req_url1.includes('hot-update'))) {
+                                            const filepath = path.join(process.cwd(), `dist${req.url}`);
+                                            fs_extra.statSync(filepath);
+                                            res.setHeader('Access-Control-Allow-Origin', '*');
+                                            res.setHeader('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, PATCH, OPTIONS');
+                                            res.setHeader('Access-Control-Allow-Headers', '*');
+                                            fs_extra.createReadStream(filepath).pipe(res);
+                                        } else next();
+                                    } catch (err) {
+                                        logger.debug(err);
+                                        next();
+                                    }
+                                }
+                            ]
+                        }
+                    }
+                }));
+            const writeMergedManifest = ()=>{
+                const { distOutputDir, assetResources } = pluginOptions;
+                const browserAssets = assetResources.browser;
+                const nodeAssets = assetResources.node;
+                if (!distOutputDir || !browserAssets || !nodeAssets) return;
+                try {
+                    updateStatsAndManifest(nodeAssets, browserAssets, distOutputDir);
+                } catch (err) {
+                    logger.error(err);
+                }
+            };
+            api.onAfterBuild(()=>{
+                writeMergedManifest();
+            });
+            api.onDevCompileDone(()=>{
+                writeMergedManifest();
+            });
+        }
+    });
+const ssrPlugin = moduleFederationSSRPlugin;
+export { CHAIN_MF_PLUGIN_ID, ssrPlugin as default, moduleFederationSSRPlugin, setEnv };

package/dist/esm-node/cli/utils.mjs

@@ -0,0 +1,40 @@
+import os from "os";
+const localIpv4 = '127.0.0.1';
+const getIpv4Interfaces = ()=>{
+    try {
+        const interfaces = os.networkInterfaces();
+        const ipv4Interfaces = [];
+        Object.values(interfaces).forEach((detail)=>{
+            null == detail || detail.forEach((detail)=>{
+                const familyV4Value = 'string' == typeof detail.family ? 'IPv4' : 4;
+                if (detail.family === familyV4Value && detail.address !== localIpv4) ipv4Interfaces.push(detail);
+            });
+        });
+        return ipv4Interfaces;
+    } catch (_err) {
+        return [];
+    }
+};
+const getIPV4 = ()=>{
+    const ipv4Interfaces = getIpv4Interfaces();
+    const ipv4Interface = ipv4Interfaces[0] || {
+        address: localIpv4
+    };
+    return ipv4Interface.address;
+};
+const isWebTarget = (target)=>{
+    const WEB_TARGET = 'web';
+    if (Array.isArray(target)) return target.includes(WEB_TARGET);
+    if ('string' == typeof target) return target === WEB_TARGET;
+    return false;
+};
+const skipByTarget = (target)=>{
+    const IGNORE_TARGET = 'webworker';
+    if (Array.isArray(target)) return target.includes(IGNORE_TARGET);
+    if ('string' == typeof target) return target === IGNORE_TARGET;
+    return false;
+};
+function isDev() {
+    return 'development' === process.env.NODE_ENV;
+}
+export { getIPV4, isDev, isWebTarget, skipByTarget };

package/dist/esm-node/constant.mjs

@@ -0,0 +1,3 @@
+const LOCALHOST = 'localhost';
+const PLUGIN_IDENTIFIER = '[ Modern.js Module Federation ]';
+export { LOCALHOST, PLUGIN_IDENTIFIER };

package/dist/esm-node/logger.mjs

@@ -0,0 +1,5 @@
+import { createLogger } from "@module-federation/sdk";
+import { PLUGIN_IDENTIFIER } from "./constant.mjs";
+const logger = createLogger(PLUGIN_IDENTIFIER);
+const src_logger = logger;
+export { src_logger as default };

package/dist/esm-node/react/plugin.mjs

@@ -0,0 +1,3 @@
+import bridge_react_plugin from "@module-federation/bridge-react/plugin";
+export * from "@module-federation/bridge-react/plugin";
+export { bridge_react_plugin as default };

package/dist/esm-node/server/fileCache.mjs

@@ -0,0 +1,37 @@
+import fs_extra from "fs-extra";
+import { LRUCache } from "lru-cache";
+class FileCache {
+    async getFile(filepath) {
+        if (!await fs_extra.pathExists(filepath)) return null;
+        try {
+            const stat = await fs_extra.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_extra.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: 209715200
+        });
+    }
+}
+const fileCache = new FileCache();
+export { FileCache, fileCache };

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

@@ -0,0 +1,34 @@
+import { createCorsMiddleware, createStaticMiddleware } from "./staticMiddleware.mjs";
+const staticServePlugin = ()=>({
+        name: '@modern-js/module-federation/server',
+        setup: (api)=>{
+            api.onPrepare(()=>{
+                var _config_output, _config_server;
+                if ('development' === process.env.NODE_ENV) return;
+                const { middlewares } = api.getServerContext();
+                const config = api.getServerConfig();
+                const assetPrefix = (null == (_config_output = config.output) ? void 0 : _config_output.assetPrefix) || '';
+                if (null == (_config_server = config.server) ? void 0 : _config_server.ssr) {
+                    const context = api.getServerContext();
+                    const pwd = context.distDirectory;
+                    const serverStaticMiddleware = createStaticMiddleware({
+                        assetPrefix,
+                        pwd
+                    });
+                    middlewares.push({
+                        name: 'module-federation-serve-manifest',
+                        handler: serverStaticMiddleware
+                    });
+                }
+                if (process.env.MODERN_MF_AUTO_CORS) {
+                    const corsMiddleware = createCorsMiddleware();
+                    middlewares.push({
+                        name: 'module-federation-cors',
+                        handler: corsMiddleware
+                    });
+                }
+            });
+        }
+    });
+const server = staticServePlugin;
+export { server as default, staticServePlugin };

package/dist/esm-node/server/staticMiddleware.mjs

@@ -0,0 +1,42 @@
+import fs_extra from "fs-extra";
+import path from "path";
+import { fileCache } from "./fileCache.mjs";
+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 ('.js' !== path.extname(pathname)) 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_extra.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);
+    };
+};
+const createCorsMiddleware = ()=>async (c, next)=>{
+        const pathname = c.req.path;
+        if (path.extname(pathname)) {
+            c.header('Access-Control-Allow-Origin', '*');
+            c.header('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, PATCH, OPTIONS');
+            c.header('Access-Control-Allow-Headers', '*');
+        }
+        return next();
+    };
+export { createCorsMiddleware, createStaticMiddleware };

package/dist/esm-node/ssr-runtime/SSRLiveReload.mjs

@@ -0,0 +1,15 @@
+import { jsx } from "react/jsx-runtime";
+function SSRLiveReload() {
+    if ('development' !== process.env.NODE_ENV) 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/devPlugin.mjs

@@ -0,0 +1,33 @@
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { SSRLiveReload } from "./SSRLiveReload.mjs";
+import { flushDataFetch } from "@module-federation/bridge-react/lazy-utils";
+const mfSSRDevPlugin = ()=>({
+        name: '@module-federation/modern-js',
+        setup: (api)=>{
+            api.onBeforeRender(async ()=>{
+                if ("u" > typeof window) return;
+                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;
+                }
+            });
+            api.wrapRoot((App)=>{
+                const AppWrapper = (props)=>/*#__PURE__*/ jsxs(Fragment, {
+                        children: [
+                            /*#__PURE__*/ jsx(SSRLiveReload, {}),
+                            /*#__PURE__*/ jsx(App, {
+                                ...props
+                            })
+                        ]
+                    });
+                return AppWrapper;
+            });
+        }
+    });
+export { mfSSRDevPlugin };

package/dist/esm-node/ssr-runtime/injectDataFetchFunctionPlugin.mjs

@@ -0,0 +1,14 @@
+import { callDataFetch } from "@module-federation/bridge-react/data-fetch-utils";
+import { setSSREnv } from "@module-federation/bridge-react/lazy-utils";
+const injectDataFetchFunctionPlugin = ({ fetchServerQuery })=>({
+        name: '@module-federation/inject-data-fetch-function-plugin',
+        setup: (api)=>{
+            api.onBeforeRender(async ()=>{
+                setSSREnv({
+                    fetchServerQuery
+                });
+                await callDataFetch();
+            });
+        }
+    });
+export { injectDataFetchFunctionPlugin };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@module-federation/modern-js",
-  "version": "0.21.6",
+  "version": "0.22.0",
   "files": [
     "dist/",
     "types.d.ts",
@@ -17,60 +17,60 @@
   "exports": {
     ".": {
       "types": "./dist/types/cli/index.d.ts",
-      "import": "./dist/esm/cli/index.js",
+      "import": "./dist/esm/cli/index.mjs",
       "require": "./dist/cjs/cli/index.js"
     },
     "./runtime": {
       "types": "./dist/types/runtime/index.d.ts",
-      "default": "./dist/esm/runtime/index.js"
+      "default": "./dist/esm/runtime/index.mjs"
     },
     "./react": {
       "types": "./dist/types/react/index.d.ts",
-      "default": "./dist/esm/react/index.js"
+      "default": "./dist/esm/react/index.mjs"
     },
     "./react-v18": {
       "types": "./dist/types/react/v18.d.ts",
-      "default": "./dist/esm/react/v18.js"
+      "default": "./dist/esm/react/v18.mjs"
     },
     "./react-v19": {
       "types": "./dist/types/react/v19.d.ts",
-      "default": "./dist/esm/react/v19.js"
+      "default": "./dist/esm/react/v19.mjs"
     },
     "./react-plugin": {
       "types": "./dist/types/react/plugin.d.ts",
-      "default": "./dist/esm/react/plugin.js"
+      "default": "./dist/esm/react/plugin.mjs"
     },
     "./ssr-dev-plugin": {
       "types": "./dist/types/ssr-runtime/devPlugin.d.ts",
-      "default": "./dist/esm/ssr-runtime/devPlugin.js"
+      "default": "./dist/esm/ssr-runtime/devPlugin.mjs"
     },
     "./ssr-inject-data-fetch-function-plugin": {
       "types": "./dist/types/ssr-runtime/injectDataFetchFunctionPlugin.d.ts",
-      "default": "./dist/esm/ssr-runtime/injectDataFetchFunctionPlugin.js"
+      "default": "./dist/esm/ssr-runtime/injectDataFetchFunctionPlugin.mjs"
     },
     "./config-plugin": {
       "types": "./dist/types/cli/configPlugin.d.ts",
-      "import": "./dist/esm/cli/configPlugin.js",
+      "import": "./dist/esm/cli/configPlugin.mjs",
       "require": "./dist/cjs/cli/configPlugin.js"
     },
     "./ssr-plugin": {
       "types": "./dist/types/cli/ssrPlugin.d.ts",
-      "import": "./dist/esm/cli/ssrPlugin.js",
+      "import": "./dist/esm/cli/ssrPlugin.mjs",
       "require": "./dist/cjs/cli/ssrPlugin.js"
     },
     "./shared-strategy": {
       "types": "./dist/types/cli/mfRuntimePlugins/shared-strategy.d.ts",
-      "import": "./dist/esm/cli/mfRuntimePlugins/shared-strategy.js",
+      "import": "./dist/esm/cli/mfRuntimePlugins/shared-strategy.mjs",
       "require": "./dist/cjs/cli/mfRuntimePlugins/shared-strategy.js"
     },
     "./resolve-entry-ipv4": {
       "types": "./dist/types/cli/mfRuntimePlugins/resolve-entry-ipv4.d.ts",
-      "import": "./dist/esm/cli/mfRuntimePlugins/resolve-entry-ipv4.js",
+      "import": "./dist/esm/cli/mfRuntimePlugins/resolve-entry-ipv4.mjs",
       "require": "./dist/cjs/cli/mfRuntimePlugins/resolve-entry-ipv4.js"
     },
     "./inject-node-fetch": {
       "types": "./dist/types/cli/mfRuntimePlugins/inject-node-fetch.d.ts",
-      "import": "./dist/esm/cli/mfRuntimePlugins/inject-node-fetch.js",
+      "import": "./dist/esm/cli/mfRuntimePlugins/inject-node-fetch.mjs",
       "require": "./dist/cjs/cli/mfRuntimePlugins/inject-node-fetch.js"
     },
     "./data-fetch-server-plugin": {
@@ -133,32 +133,33 @@
   "author": "hanric <hanric.zhang@gmail.com>",
   "license": "MIT",
   "dependencies": {
-    "@modern-js/utils": "2.68.2",
-    "@modern-js/node-bundle-require": "2.68.2",
+    "@modern-js/utils": "2.69.3",
+    "@modern-js/node-bundle-require": "2.69.3",
     "fs-extra": "11.3.0",
     "lru-cache": "10.4.3",
     "@swc/helpers": "^0.5.17",
     "node-fetch": "~3.3.0",
     "react-error-boundary": "4.1.2",
-    "@module-federation/rsbuild-plugin": "0.21.6",
-    "@module-federation/node": "2.7.25",
-    "@module-federation/runtime": "0.21.6",
-    "@module-federation/enhanced": "0.21.6",
-    "@module-federation/cli": "0.21.6",
-    "@module-federation/sdk": "0.21.6",
-    "@module-federation/bridge-react": "0.21.6"
+    "@module-federation/rsbuild-plugin": "0.22.0",
+    "@module-federation/enhanced": "0.22.0",
+    "@module-federation/runtime": "0.22.0",
+    "@module-federation/node": "2.7.26",
+    "@module-federation/sdk": "0.22.0",
+    "@module-federation/bridge-react": "0.22.0",
+    "@module-federation/cli": "0.22.0"
   },
   "devDependencies": {
-    "@modern-js/core": "2.68.2",
+    "@rsbuild/plugin-react": "1.4.2",
+    "@rslib/core": "0.18.5",
     "@rsbuild/core": "1.3.21",
-    "@modern-js/app-tools": "2.68.2",
-    "@modern-js/server-runtime": "2.68.2",
-    "@modern-js/module-tools": "2.68.2",
-    "@modern-js/runtime": "2.68.2",
-    "@modern-js/tsconfig": "2.68.2",
+    "@modern-js/app-tools": "2.69.3",
+    "@modern-js/server-runtime": "2.69.3",
+    "@modern-js/module-tools": "2.69.3",
+    "@modern-js/runtime": "2.69.3",
+    "@modern-js/tsconfig": "2.69.3",
     "@types/react": "^18.3.11",
     "@types/react-dom": "^18.3.0",
-    "@module-federation/manifest": "0.21.6"
+    "@module-federation/manifest": "0.22.0"
   },
   "peerDependencies": {
     "react": ">=17",
@@ -183,6 +184,6 @@
     }
   },
   "scripts": {
-    "build": "modern-module build"
+    "build": "rslib build"
   }
 }