@module-federation/modern-js 0.21.6 → 0.22.0

package/dist/esm/cli/index.mjs

@@ -0,0 +1,83 @@
+import { _ } from "@swc/helpers/_/_async_to_generator";
+import { _ as _object_spread__ } from "@swc/helpers/_/_object_spread";
+import { _ as _type_of__ } from "@swc/helpers/_/_type_of";
+import { _ as _ts_generator__ } from "@swc/helpers/_/_ts_generator";
+import { AsyncBoundaryPlugin, ModuleFederationPlugin, createModuleFederationConfig } from "@module-federation/enhanced";
+import { ModuleFederationPlugin as rspack_ModuleFederationPlugin } from "@module-federation/enhanced/rspack";
+import { moduleFederationConfigPlugin } from "./configPlugin.mjs";
+import { moduleFederationSSRPlugin } from "./ssrPlugin.mjs";
+import { isWebTarget } from "./utils.mjs";
+var moduleFederationPlugin = function() {
+    var userConfig = arguments.length > 0 && void 0 !== arguments[0] ? arguments[0] : {};
+    var _userConfig_fetchServerQuery;
+    var internalModernPluginOptions = {
+        csrConfig: void 0,
+        ssrConfig: void 0,
+        browserPlugin: void 0,
+        nodePlugin: void 0,
+        assetResources: {},
+        distOutputDir: '',
+        originPluginOptions: _object_spread__({}, userConfig),
+        remoteIpStrategy: null == userConfig ? void 0 : userConfig.remoteIpStrategy,
+        userConfig: userConfig || {},
+        assetFileNames: {},
+        fetchServerQuery: null != (_userConfig_fetchServerQuery = userConfig.fetchServerQuery) ? _userConfig_fetchServerQuery : void 0
+    };
+    return {
+        name: '@modern-js/plugin-module-federation',
+        setup: function(api) {
+            return _(function() {
+                var modernjsConfig;
+                return _ts_generator__(this, function(_state) {
+                    modernjsConfig = api.getConfig();
+                    api.modifyBundlerChain(function(chain) {
+                        var bundlerType = 'rspack' === api.getAppContext().bundlerType ? 'rspack' : 'webpack';
+                        var browserPluginOptions = internalModernPluginOptions.csrConfig;
+                        var MFPlugin = 'webpack' === bundlerType ? ModuleFederationPlugin : rspack_ModuleFederationPlugin;
+                        if (isWebTarget(chain.get('target'))) chain.plugin('plugin-module-federation').use(MFPlugin, [
+                            browserPluginOptions
+                        ]).init(function(Plugin, args) {
+                            internalModernPluginOptions.browserPlugin = new Plugin(args[0]);
+                            return internalModernPluginOptions.browserPlugin;
+                        });
+                        if ('webpack' === bundlerType) {
+                            var _modernjsConfig_source;
+                            var enableAsyncEntry = null == (_modernjsConfig_source = modernjsConfig.source) ? void 0 : _modernjsConfig_source.enableAsyncEntry;
+                            if (!enableAsyncEntry && false !== browserPluginOptions.async) {
+                                var asyncBoundaryPluginOptions = 'object' === _type_of__(browserPluginOptions.async) ? browserPluginOptions.async : {
+                                    eager: function(module) {
+                                        return module && /\.federation/.test((null == module ? void 0 : module.request) || '');
+                                    },
+                                    excludeChunk: function(chunk) {
+                                        return chunk.name === browserPluginOptions.name;
+                                    }
+                                };
+                                chain.plugin('async-boundary-plugin').use(AsyncBoundaryPlugin, [
+                                    asyncBoundaryPluginOptions
+                                ]);
+                            }
+                        }
+                    });
+                    api._internalServerPlugins(function(param) {
+                        var plugins = param.plugins;
+                        plugins.push({
+                            name: '@module-federation/modern-js/server'
+                        });
+                        return {
+                            plugins: plugins
+                        };
+                    });
+                    return [
+                        2
+                    ];
+                });
+            })();
+        },
+        usePlugins: [
+            moduleFederationConfigPlugin(internalModernPluginOptions),
+            moduleFederationSSRPlugin(internalModernPluginOptions)
+        ]
+    };
+};
+var cli = moduleFederationPlugin;
+export { createModuleFederationConfig, cli as default, moduleFederationPlugin };

package/dist/esm/cli/mfRuntimePlugins/inject-node-fetch.mjs

@@ -0,0 +1,12 @@
+import node_fetch from "node-fetch";
+var injectNodeFetchPlugin = function() {
+    return {
+        name: 'inject-node-fetch-plugin',
+        beforeInit: function(args) {
+            if (!globalThis.fetch) globalThis.fetch = node_fetch;
+            return args;
+        }
+    };
+};
+var inject_node_fetch = injectNodeFetchPlugin;
+export { inject_node_fetch as default };

package/dist/esm/cli/mfRuntimePlugins/resolve-entry-ipv4.mjs

@@ -0,0 +1,58 @@
+import { _ } from "@swc/helpers/_/_async_to_generator";
+import { _ as _ts_generator__ } from "@swc/helpers/_/_ts_generator";
+import { LOCALHOST } from "../../constant.mjs";
+var ipv4 = "u" > typeof FEDERATION_IPV4 ? FEDERATION_IPV4 : '127.0.0.1';
+var remoteIpStrategy = "u" > typeof REMOTE_IP_STRATEGY ? REMOTE_IP_STRATEGY : 'inherit';
+function replaceObjectLocalhost(key, obj) {
+    if ('ipv4' !== remoteIpStrategy) return;
+    if (!(key in obj)) return;
+    var remote = obj[key];
+    if (remote && 'string' == typeof remote && remote.includes(LOCALHOST)) obj[key] = replaceLocalhost(remote);
+}
+function replaceLocalhost(url) {
+    return url.replace(LOCALHOST, ipv4);
+}
+var resolveEntryIpv4Plugin = function() {
+    return {
+        name: 'resolve-entry-ipv4',
+        beforeRegisterRemote: function(args) {
+            var remote = args.remote;
+            replaceObjectLocalhost('entry', remote);
+            return args;
+        },
+        afterResolve: function(args) {
+            return _(function() {
+                var remoteInfo;
+                return _ts_generator__(this, function(_state) {
+                    remoteInfo = args.remoteInfo;
+                    replaceObjectLocalhost('entry', remoteInfo);
+                    return [
+                        2,
+                        args
+                    ];
+                });
+            })();
+        },
+        beforeLoadRemoteSnapshot: function(args) {
+            var moduleInfo = args.moduleInfo;
+            if ('entry' in moduleInfo) {
+                replaceObjectLocalhost('entry', moduleInfo);
+                return args;
+            }
+            if ('version' in moduleInfo) replaceObjectLocalhost('version', moduleInfo);
+            return args;
+        },
+        loadRemoteSnapshot: function(args) {
+            var remoteSnapshot = args.remoteSnapshot;
+            if ('publicPath' in remoteSnapshot) replaceObjectLocalhost('publicPath', remoteSnapshot);
+            if ('getPublicPath' in remoteSnapshot) replaceObjectLocalhost('getPublicPath', remoteSnapshot);
+            if (remoteSnapshot.remotesInfo) Object.keys(remoteSnapshot.remotesInfo).forEach(function(key) {
+                var remoteInfo = remoteSnapshot.remotesInfo[key];
+                replaceObjectLocalhost('matchedVersion', remoteInfo);
+            });
+            return args;
+        }
+    };
+};
+var resolve_entry_ipv4 = resolveEntryIpv4Plugin;
+export { resolve_entry_ipv4 as default };

package/dist/esm/cli/mfRuntimePlugins/shared-strategy.mjs

@@ -0,0 +1,21 @@
+var sharedStrategy = function() {
+    return {
+        name: 'shared-strategy-plugin',
+        beforeInit: function(args) {
+            var userOptions = args.userOptions;
+            var shared = userOptions.shared;
+            if (shared) Object.keys(shared).forEach(function(sharedKey) {
+                var sharedConfigs = shared[sharedKey];
+                var arraySharedConfigs = Array.isArray(sharedConfigs) ? sharedConfigs : [
+                    sharedConfigs
+                ];
+                arraySharedConfigs.forEach(function(s) {
+                    s.strategy = 'loaded-first';
+                });
+            });
+            return args;
+        }
+    };
+};
+var shared_strategy = sharedStrategy;
+export { shared_strategy as default };

package/dist/esm/cli/server/data-fetch-server-plugin.mjs

@@ -0,0 +1,17 @@
+import data_fetch_server_middleware from "@module-federation/bridge-react/data-fetch-server-middleware";
+var dataFetchServePlugin = function() {
+    return {
+        name: 'mf-data-fetch-server-plugin',
+        setup: function(api) {
+            api.onPrepare(function() {
+                var middlewares = api.getServerContext().middlewares;
+                middlewares.push({
+                    name: 'module-federation-serve-manifest',
+                    handler: data_fetch_server_middleware
+                });
+            });
+        }
+    };
+};
+var data_fetch_server_plugin = dataFetchServePlugin;
+export { data_fetch_server_plugin as default };

package/dist/esm/cli/ssrPlugin.mjs

@@ -0,0 +1,254 @@
+import { _ } from "@swc/helpers/_/_async_to_generator";
+import { _ as _instanceof__ } from "@swc/helpers/_/_instanceof";
+import { _ as _type_of__ } from "@swc/helpers/_/_type_of";
+import { _ as _ts_generator__ } from "@swc/helpers/_/_ts_generator";
+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';
+}
+var CHAIN_MF_PLUGIN_ID = 'plugin-module-federation-server';
+function getManifestAssetFileNames(manifestOption) {
+    if (!manifestOption) return {
+        statsFileName: StatsFileName,
+        manifestFileName: ManifestFileName
+    };
+    var JSON_EXT = '.json';
+    var filePath = 'boolean' == typeof manifestOption ? '' : manifestOption.filePath || '';
+    var baseFileName = 'boolean' == typeof manifestOption ? '' : manifestOption.fileName || '';
+    var ensureExt = function(name) {
+        return name.endsWith(JSON_EXT) ? name : "".concat(name).concat(JSON_EXT);
+    };
+    var withSuffix = function(name, suffix) {
+        return name.replace(JSON_EXT, "".concat(suffix).concat(JSON_EXT));
+    };
+    var manifestFileName = baseFileName ? ensureExt(baseFileName) : ManifestFileName;
+    var statsFileName = baseFileName ? withSuffix(manifestFileName, '-stats') : StatsFileName;
+    return {
+        statsFileName: simpleJoinRemoteEntry(filePath, statsFileName),
+        manifestFileName: simpleJoinRemoteEntry(filePath, manifestFileName)
+    };
+}
+var mfSSRRsbuildPlugin = function(pluginOptions) {
+    return {
+        name: '@modern-js/plugin-mf-post-config',
+        pre: [
+            '@modern-js/builder-plugin-ssr'
+        ],
+        setup: function(api) {
+            var _pluginOptions_csrConfig, _pluginOptions_assetFileNames, _pluginOptions_ssrConfig;
+            if (pluginOptions.csrConfig.getPublicPath) return;
+            var csrOutputPath = '';
+            var ssrOutputPath = '';
+            var ssrEnv = '';
+            var csrEnv = '';
+            var browserAssetFileNames = pluginOptions.assetFileNames.browser || getManifestAssetFileNames(null == (_pluginOptions_csrConfig = pluginOptions.csrConfig) ? void 0 : _pluginOptions_csrConfig.manifest);
+            var nodeAssetFileNames = (null == (_pluginOptions_assetFileNames = pluginOptions.assetFileNames) ? void 0 : _pluginOptions_assetFileNames.node) || getManifestAssetFileNames(null == (_pluginOptions_ssrConfig = pluginOptions.ssrConfig) ? void 0 : _pluginOptions_ssrConfig.manifest);
+            var collectAssets = function(assets, fileNames, tag) {
+                var statsAsset = assets[fileNames.statsFileName];
+                var manifestAsset = assets[fileNames.manifestFileName];
+                if (!statsAsset || !manifestAsset) return;
+                try {
+                    var statsRaw = statsAsset.source();
+                    var manifestRaw = manifestAsset.source();
+                    var statsContent = 'string' == typeof statsRaw ? statsRaw : statsRaw.toString();
+                    var 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) {
+                    var message = _instanceof__(err, Error) ? err.message : String(err);
+                    logger.error("Failed to parse ".concat(tag, " manifest assets: ").concat(message));
+                    return;
+                }
+            };
+            api.modifyEnvironmentConfig(function(config, param) {
+                var name = param.name;
+                var 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;
+            });
+            var modifySSRPublicPath = function(config, utils) {
+                if (ssrEnv !== utils.environment.name) return config;
+                var userSSRConfig = pluginOptions.userConfig.ssr ? 'object' === _type_of__(pluginOptions.userConfig.ssr) ? pluginOptions.userConfig.ssr : {} : {};
+                if (!userSSRConfig.distOutputDir) return;
+                config.output.publicPath = "".concat(config.output.publicPath).concat(path.relative(csrOutputPath, ssrOutputPath), "/");
+                return config;
+            };
+            api.modifyWebpackConfig(function(config, utils) {
+                modifySSRPublicPath(config, utils);
+                return config;
+            });
+            api.modifyRspackConfig(function(config, utils) {
+                modifySSRPublicPath(config, utils);
+                return config;
+            });
+            api.processAssets({
+                stage: 'report'
+            }, function(param) {
+                var assets = param.assets, envContext = param.environment;
+                var _pluginOptions_csrConfig, _pluginOptions_ssrConfig;
+                var envName = envContext.name;
+                if ((null == (_pluginOptions_csrConfig = pluginOptions.csrConfig) ? void 0 : _pluginOptions_csrConfig.manifest) !== false && csrEnv && envName === csrEnv) {
+                    var 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) {
+                    var nodeAssets = collectAssets(assets, nodeAssetFileNames, 'node');
+                    if (nodeAssets) pluginOptions.assetResources.node = nodeAssets;
+                }
+            });
+        }
+    };
+};
+var moduleFederationSSRPlugin = function(pluginOptions) {
+    return {
+        name: '@modern-js/plugin-module-federation-ssr',
+        pre: [
+            '@modern-js/plugin-module-federation-config',
+            '@modern-js/plugin-module-federation'
+        ],
+        setup: function(api) {
+            return _(function() {
+                var _pluginOptions_userConfig, _modernjsConfig_server, modernjsConfig, _ref, enableSSR, writeMergedManifest;
+                return _ts_generator__(this, function(_state) {
+                    modernjsConfig = api.getConfig();
+                    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 [
+                        2
+                    ];
+                    setEnv();
+                    api._internalRuntimePlugins(function(param) {
+                        var entrypoint = param.entrypoint, plugins = param.plugins;
+                        var fetchServerQuery = pluginOptions.fetchServerQuery;
+                        plugins.push({
+                            name: 'injectDataFetchFunction',
+                            path: '@module-federation/modern-js/ssr-inject-data-fetch-function-plugin',
+                            config: {
+                                fetchServerQuery: fetchServerQuery
+                            }
+                        });
+                        if (!isDev()) return {
+                            entrypoint: entrypoint,
+                            plugins: plugins
+                        };
+                        plugins.push({
+                            name: 'mfSSRDev',
+                            path: '@module-federation/modern-js/ssr-dev-plugin',
+                            config: {}
+                        });
+                        return {
+                            entrypoint: entrypoint,
+                            plugins: plugins
+                        };
+                    });
+                    if (pluginOptions.ssrConfig.remotes) api._internalServerPlugins(function(param) {
+                        var plugins = param.plugins;
+                        plugins.push({
+                            name: '@module-federation/modern-js/data-fetch-server-plugin',
+                            options: {}
+                        });
+                        return {
+                            plugins: plugins
+                        };
+                    });
+                    api.modifyBundlerChain(function(chain) {
+                        var target = chain.get('target');
+                        if (skipByTarget(target)) return;
+                        var bundlerType = 'rspack' === api.getAppContext().bundlerType ? 'rspack' : 'webpack';
+                        var MFPlugin = 'webpack' === bundlerType ? ModuleFederationPlugin : rspack_ModuleFederationPlugin;
+                        var isWeb = isWebTarget(target);
+                        if (!isWeb) {
+                            if (!chain.plugins.has(CHAIN_MF_PLUGIN_ID)) chain.plugin(CHAIN_MF_PLUGIN_ID).use(MFPlugin, [
+                                pluginOptions.ssrConfig
+                            ]).init(function(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(function() {
+                        return {
+                            builderPlugins: [
+                                mfSSRRsbuildPlugin(pluginOptions)
+                            ],
+                            tools: {
+                                devServer: {
+                                    before: [
+                                        function(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'))) {
+                                                    var filepath = path.join(process.cwd(), "dist".concat(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();
+                                            }
+                                        }
+                                    ]
+                                }
+                            }
+                        };
+                    });
+                    writeMergedManifest = function() {
+                        var distOutputDir = pluginOptions.distOutputDir, assetResources = pluginOptions.assetResources;
+                        var browserAssets = assetResources.browser;
+                        var nodeAssets = assetResources.node;
+                        if (!distOutputDir || !browserAssets || !nodeAssets) return;
+                        try {
+                            updateStatsAndManifest(nodeAssets, browserAssets, distOutputDir);
+                        } catch (err) {
+                            logger.error(err);
+                        }
+                    };
+                    api.onAfterBuild(function() {
+                        writeMergedManifest();
+                    });
+                    api.onDevCompileDone(function() {
+                        writeMergedManifest();
+                    });
+                    return [
+                        2
+                    ];
+                });
+            })();
+        }
+    };
+};
+var ssrPlugin = moduleFederationSSRPlugin;
+export { CHAIN_MF_PLUGIN_ID, ssrPlugin as default, moduleFederationSSRPlugin, setEnv };

package/dist/esm/cli/utils.mjs

@@ -0,0 +1,40 @@
+import os from "os";
+var localIpv4 = '127.0.0.1';
+var getIpv4Interfaces = function() {
+    try {
+        var interfaces = os.networkInterfaces();
+        var ipv4Interfaces = [];
+        Object.values(interfaces).forEach(function(detail) {
+            null == detail || detail.forEach(function(detail) {
+                var familyV4Value = 'string' == typeof detail.family ? 'IPv4' : 4;
+                if (detail.family === familyV4Value && detail.address !== localIpv4) ipv4Interfaces.push(detail);
+            });
+        });
+        return ipv4Interfaces;
+    } catch (_err) {
+        return [];
+    }
+};
+var getIPV4 = function() {
+    var ipv4Interfaces = getIpv4Interfaces();
+    var ipv4Interface = ipv4Interfaces[0] || {
+        address: localIpv4
+    };
+    return ipv4Interface.address;
+};
+var isWebTarget = function(target) {
+    var WEB_TARGET = 'web';
+    if (Array.isArray(target)) return target.includes(WEB_TARGET);
+    if ('string' == typeof target) return target === WEB_TARGET;
+    return false;
+};
+var skipByTarget = function(target) {
+    var 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/constant.mjs

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

package/dist/esm/logger.mjs

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

package/dist/esm/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/server/fileCache.mjs

@@ -0,0 +1,90 @@
+import { _ } from "@swc/helpers/_/_async_to_generator";
+import { _ as _class_call_check__ } from "@swc/helpers/_/_class_call_check";
+import { _ as _ts_generator__ } from "@swc/helpers/_/_ts_generator";
+import fs_extra from "fs-extra";
+import { LRUCache } from "lru-cache";
+var fileCache_FileCache = /*#__PURE__*/ function() {
+    "use strict";
+    function FileCache() {
+        _class_call_check__(this, FileCache);
+        this.cache = new LRUCache({
+            maxSize: 209715200
+        });
+    }
+    var _proto = FileCache.prototype;
+    _proto.getFile = function(filepath) {
+        return _(function() {
+            var stat, currentModified, cachedEntry, content, newEntry;
+            return _ts_generator__(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        return [
+                            4,
+                            fs_extra.pathExists(filepath)
+                        ];
+                    case 1:
+                        if (!_state.sent()) return [
+                            2,
+                            null
+                        ];
+                        _state.label = 2;
+                    case 2:
+                        _state.trys.push([
+                            2,
+                            5,
+                            ,
+                            6
+                        ]);
+                        return [
+                            4,
+                            fs_extra.lstat(filepath)
+                        ];
+                    case 3:
+                        stat = _state.sent();
+                        currentModified = stat.mtimeMs;
+                        cachedEntry = this.cache.get(filepath);
+                        if (cachedEntry && currentModified <= cachedEntry.lastModified) return [
+                            2,
+                            {
+                                content: cachedEntry.content,
+                                lastModified: cachedEntry.lastModified
+                            }
+                        ];
+                        return [
+                            4,
+                            fs_extra.readFile(filepath, 'utf-8')
+                        ];
+                    case 4:
+                        content = _state.sent();
+                        newEntry = {
+                            content: content,
+                            lastModified: currentModified
+                        };
+                        this.cache.set(filepath, newEntry, {
+                            size: stat.size || content.length
+                        });
+                        return [
+                            2,
+                            {
+                                content: content,
+                                lastModified: currentModified
+                            }
+                        ];
+                    case 5:
+                        _state.sent();
+                        return [
+                            2,
+                            null
+                        ];
+                    case 6:
+                        return [
+                            2
+                        ];
+                }
+            });
+        }).call(this);
+    };
+    return FileCache;
+}();
+var fileCache = new fileCache_FileCache();
+export { fileCache_FileCache as FileCache, fileCache };

package/dist/esm/server/index.mjs

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