@module-federation/modern-js 0.0.0-chore-bump-node-22-20260710161714

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

@@ -0,0 +1,258 @@
+import path from "path";
+import fs from "fs";
+import { ModuleFederationPlugin, TreeShakingSharedPlugin as enhanced_TreeShakingSharedPlugin } from "@module-federation/enhanced";
+import { ModuleFederationPlugin as rspack_ModuleFederationPlugin, TreeShakingSharedPlugin as rspack_TreeShakingSharedPlugin } 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 STATIC_ASSET_MODULE_TYPES = [
+    'asset',
+    'asset/resource'
+];
+const preserveStaticAssetPublicPath = (config, publicPath)=>{
+    var _config, _moduleConfig;
+    if ('string' != typeof publicPath || '' === publicPath || 'auto' === publicPath) return;
+    (_config = config).module || (_config.module = {});
+    const moduleConfig = config.module;
+    (_moduleConfig = moduleConfig).generator || (_moduleConfig.generator = {});
+    for (const moduleType of STATIC_ASSET_MODULE_TYPES){
+        var _moduleConfig_generator, _moduleType, _moduleConfig_generator_moduleType;
+        (_moduleConfig_generator = moduleConfig.generator)[_moduleType = moduleType] || (_moduleConfig_generator[_moduleType] = {});
+        null != (_moduleConfig_generator_moduleType = moduleConfig.generator[moduleType]).publicPath || (_moduleConfig_generator_moduleType.publicPath = publicPath);
+    }
+};
+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;
+                const publicPath = config.output.publicPath;
+                preserveStaticAssetPublicPath(config, publicPath);
+                config.output.publicPath = `${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 _ref;
+            var _pluginOptions_userConfig, _modernjsConfig_server;
+            const modernjsConfig = api.getConfig();
+            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);
+            const { secondarySharedTreeShaking } = pluginOptions;
+            if (!enableSSR) return;
+            setEnv();
+            api._internalRuntimePlugins(({ entrypoint, plugins })=>{
+                if (secondarySharedTreeShaking) return {
+                    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 TreeShakingSharedPlugin = 'webpack' === bundlerType ? enhanced_TreeShakingSharedPlugin : rspack_TreeShakingSharedPlugin;
+                const isWeb = isWebTarget(target);
+                if (!isWeb) {
+                    if (!chain.plugins.has(CHAIN_MF_PLUGIN_ID)) if (secondarySharedTreeShaking) chain.plugin(CHAIN_MF_PLUGIN_ID).use(TreeShakingSharedPlugin, [
+                        {
+                            mfConfig: pluginOptions.ssrConfig,
+                            secondary: true
+                        }
+                    ]);
+                    else chain.plugin(CHAIN_MF_PLUGIN_ID).use(MFPlugin, [
+                        pluginOptions.ssrConfig
+                    ]).init((Plugin, args)=>{
+                        pluginOptions.nodePlugin = new Plugin(args[0]);
+                        return pluginOptions.nodePlugin;
+                    });
+                }
+                if (!isWeb && !secondarySharedTreeShaking) {
+                    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.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.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/data-fetch.mjs

@@ -0,0 +1 @@
+export * from "@module-federation/bridge-react/data-fetch";

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

@@ -0,0 +1 @@
+export * from "@module-federation/bridge-react";

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/react/v18.mjs

@@ -0,0 +1 @@
+export * from "@module-federation/bridge-react/v18";

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

@@ -0,0 +1 @@
+export * from "@module-federation/bridge-react/v19";

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

@@ -0,0 +1 @@
+export * from "@module-federation/enhanced/runtime";

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

@@ -0,0 +1,45 @@
+import { access, lstat, readFile } from "fs/promises";
+import { LRUCache } from "lru-cache";
+const pathExists = async (filepath)=>{
+    try {
+        await access(filepath);
+        return true;
+    } catch  {
+        return false;
+    }
+};
+class FileCache {
+    async getFile(filepath) {
+        if (!await pathExists(filepath)) return null;
+        try {
+            const stat = await 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 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,50 @@
+import { access } from "fs/promises";
+import path from "path";
+import { fileCache } from "./fileCache.mjs";
+const pathExists = async (filepath)=>{
+    try {
+        await access(filepath);
+        return true;
+    } catch  {
+        return false;
+    }
+};
+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 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,16 @@
+import { jsx } from "react/jsx-runtime";
+import "react";
+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/data-fetch";
+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,13 @@
+import { callDataFetch, setSSREnv } from "@module-federation/bridge-react/data-fetch";
+const injectDataFetchFunctionPlugin = ({ fetchServerQuery })=>({
+        name: '@module-federation/inject-data-fetch-function-plugin',
+        setup: (api)=>{
+            api.onBeforeRender(async ()=>{
+                setSSREnv({
+                    fetchServerQuery
+                });
+                await callDataFetch();
+            });
+        }
+    });
+export { injectDataFetchFunctionPlugin };

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) => 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/index.d.ts

@@ -0,0 +1,6 @@
+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';
+export type { ModuleFederationRuntimePlugin } from '@module-federation/enhanced/runtime';

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

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

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

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

package/dist/types/cli/server/data-fetch-server-plugin.d.ts

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

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

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

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

@@ -0,0 +1,6 @@
+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;
+export declare function isDev(): 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/logger.d.ts

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

package/dist/types/react/data-fetch.d.ts

@@ -0,0 +1 @@
+export * from '@module-federation/bridge-react/data-fetch';

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

@@ -0,0 +1 @@
+export * from '@module-federation/bridge-react';

package/dist/types/react/plugin.d.ts

@@ -0,0 +1,2 @@
+export * from '@module-federation/bridge-react/plugin';
+export { default } from '@module-federation/bridge-react/plugin';

package/dist/types/react/v18.d.ts

@@ -0,0 +1 @@
+export * from '@module-federation/bridge-react/v18';

package/dist/types/react/v19.d.ts

@@ -0,0 +1 @@
+export * from '@module-federation/bridge-react/v19';