@module-federation/modern-js 0.0.0-release-v0-21-5-20251120103315 → 0.0.0-release-v0-23-0-20260123023720

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 };

package/dist/esm/server/staticMiddleware.mjs

@@ -0,0 +1,87 @@
+import { _ } from "@swc/helpers/_/_async_to_generator";
+import { _ as _ts_generator__ } from "@swc/helpers/_/_ts_generator";
+import fs_extra from "fs-extra";
+import path from "path";
+import { fileCache } from "./fileCache.mjs";
+var bundlesAssetPrefix = '/bundles';
+var removeHost = function(url) {
+    try {
+        var hasProtocol = url.includes('://');
+        var hasDomain = hasProtocol || url.startsWith('//');
+        var pathname = hasDomain ? new URL(hasProtocol ? url : "http:".concat(url)).pathname : url;
+        return pathname;
+    } catch (e) {
+        return url;
+    }
+};
+var createStaticMiddleware = function(options) {
+    var assetPrefix = options.assetPrefix, pwd = options.pwd;
+    return function(c, next) {
+        return _(function() {
+            var pathname, prefixWithoutHost, prefixWithBundle, pathnameWithoutPrefix, filepath, fileResult;
+            return _ts_generator__(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        pathname = c.req.path;
+                        if ('.js' !== path.extname(pathname)) return [
+                            2,
+                            next()
+                        ];
+                        prefixWithoutHost = removeHost(assetPrefix);
+                        prefixWithBundle = path.join(prefixWithoutHost, bundlesAssetPrefix);
+                        if (!pathname.startsWith(prefixWithBundle)) return [
+                            2,
+                            next()
+                        ];
+                        pathnameWithoutPrefix = pathname.replace(prefixWithBundle, '');
+                        filepath = path.join(pwd, bundlesAssetPrefix, pathnameWithoutPrefix);
+                        return [
+                            4,
+                            fs_extra.pathExists(filepath)
+                        ];
+                    case 1:
+                        if (!_state.sent()) return [
+                            2,
+                            next()
+                        ];
+                        return [
+                            4,
+                            fileCache.getFile(filepath)
+                        ];
+                    case 2:
+                        fileResult = _state.sent();
+                        if (!fileResult) return [
+                            2,
+                            next()
+                        ];
+                        c.header('Content-Type', "application/javascript");
+                        c.header('Content-Length', String(fileResult.content.length));
+                        return [
+                            2,
+                            c.body(fileResult.content, 200)
+                        ];
+                }
+            });
+        })();
+    };
+};
+var createCorsMiddleware = function() {
+    return function(c, next) {
+        return _(function() {
+            var pathname;
+            return _ts_generator__(this, function(_state) {
+                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 [
+                    2,
+                    next()
+                ];
+            });
+        })();
+    };
+};
+export { createCorsMiddleware, createStaticMiddleware };

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

@@ -0,0 +1,22 @@
+import { _ } from "@swc/helpers/_/_tagged_template_literal";
+import { jsx } from "react/jsx-runtime";
+function SSRLiveReload_templateObject() {
+    var data = _([
+        "\n      if(",
+        "){\n        location.reload();\n      }\n   "
+    ]);
+    SSRLiveReload_templateObject = function() {
+        return data;
+    };
+    return data;
+}
+function SSRLiveReload() {
+    if ('development' !== process.env.NODE_ENV) return null;
+    return /*#__PURE__*/ jsx("script", {
+        suppressHydrationWarning: true,
+        dangerouslySetInnerHTML: {
+            __html: String.raw(SSRLiveReload_templateObject(), globalThis.shouldUpdate)
+        }
+    });
+}
+export { SSRLiveReload };

package/dist/esm/ssr-runtime/devPlugin.mjs

@@ -0,0 +1,70 @@
+import { _ } from "@swc/helpers/_/_async_to_generator";
+import { _ as _object_spread__ } from "@swc/helpers/_/_object_spread";
+import { _ as _ts_generator__ } from "@swc/helpers/_/_ts_generator";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { SSRLiveReload } from "./SSRLiveReload.mjs";
+import { flushDataFetch } from "@module-federation/bridge-react/lazy-utils";
+var mfSSRDevPlugin = function() {
+    return {
+        name: '@module-federation/modern-js',
+        setup: function(api) {
+            api.onBeforeRender(function() {
+                return _(function() {
+                    var nodeUtils, shouldUpdate;
+                    return _ts_generator__(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                if ("u" > typeof window) return [
+                                    2
+                                ];
+                                globalThis.shouldUpdate = false;
+                                return [
+                                    4,
+                                    import("@module-federation/node/utils")
+                                ];
+                            case 1:
+                                nodeUtils = _state.sent();
+                                return [
+                                    4,
+                                    nodeUtils.revalidate()
+                                ];
+                            case 2:
+                                shouldUpdate = _state.sent();
+                                console.log('shouldUpdate: ', shouldUpdate);
+                                if (!shouldUpdate) return [
+                                    3,
+                                    4
+                                ];
+                                console.log('should RELOAD', shouldUpdate);
+                                return [
+                                    4,
+                                    nodeUtils.flushChunks()
+                                ];
+                            case 3:
+                                _state.sent();
+                                flushDataFetch();
+                                globalThis.shouldUpdate = true;
+                                _state.label = 4;
+                            case 4:
+                                return [
+                                    2
+                                ];
+                        }
+                    });
+                })();
+            });
+            api.wrapRoot(function(App) {
+                var AppWrapper = function(props) {
+                    return /*#__PURE__*/ jsxs(Fragment, {
+                        children: [
+                            /*#__PURE__*/ jsx(SSRLiveReload, {}),
+                            /*#__PURE__*/ jsx(App, _object_spread__({}, props))
+                        ]
+                    });
+                };
+                return AppWrapper;
+            });
+        }
+    };
+};
+export { mfSSRDevPlugin };

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

@@ -0,0 +1,34 @@
+import { _ } from "@swc/helpers/_/_async_to_generator";
+import { _ as _ts_generator__ } from "@swc/helpers/_/_ts_generator";
+import { callDataFetch } from "@module-federation/bridge-react/data-fetch-utils";
+import { setSSREnv } from "@module-federation/bridge-react/lazy-utils";
+var injectDataFetchFunctionPlugin = function(param) {
+    var fetchServerQuery = param.fetchServerQuery;
+    return {
+        name: '@module-federation/inject-data-fetch-function-plugin',
+        setup: function(api) {
+            api.onBeforeRender(function() {
+                return _(function() {
+                    return _ts_generator__(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                setSSREnv({
+                                    fetchServerQuery: fetchServerQuery
+                                });
+                                return [
+                                    4,
+                                    callDataFetch()
+                                ];
+                            case 1:
+                                _state.sent();
+                                return [
+                                    2
+                                ];
+                        }
+                    });
+                })();
+            });
+        }
+    };
+};
+export { injectDataFetchFunctionPlugin };