@module-federation/enhanced 2.1.0 → 2.2.1

package/dist/src/lib/container/runtime/FederationRuntimePlugin.js

@@ -1,363 +1,270 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const fs_1 = __importDefault(require("fs"));
-const path_1 = __importDefault(require("path"));
-const btoa_1 = __importDefault(require("btoa"));
-const normalize_webpack_path_1 = require("@module-federation/sdk/normalize-webpack-path");
-const cli_1 = require("@module-federation/data-prefetch/cli");
-const FederationRuntimeModule_1 = __importDefault(require("./FederationRuntimeModule"));
-const utils_1 = require("./utils");
-const constant_1 = require("../constant");
-const EmbedFederationRuntimePlugin_1 = __importDefault(require("./EmbedFederationRuntimePlugin"));
-const FederationModulesPlugin_1 = __importDefault(require("./FederationModulesPlugin"));
-const HoistContainerReferencesPlugin_1 = __importDefault(require("../HoistContainerReferencesPlugin"));
-const FederationRuntimeDependency_1 = __importDefault(require("./FederationRuntimeDependency"));
-const ModuleDependency = require((0, normalize_webpack_path_1.normalizeWebpackPath)('webpack/lib/dependencies/ModuleDependency'));
-const { RuntimeGlobals, Template } = require((0, normalize_webpack_path_1.normalizeWebpackPath)('webpack'));
-const { mkdirpSync } = require((0, normalize_webpack_path_1.normalizeWebpackPath)('webpack/lib/util/fs'));
-function resolveModule(candidates, options) {
-    let lastError;
-    for (const candidate of candidates) {
-        try {
-            return require.resolve(candidate, options);
-        }
-        catch (error) {
-            lastError = error;
-        }
-    }
-    throw (lastError ??
-        new Error(`Unable to resolve any module from: ${candidates.join(', ')}`));
-}
-function isEsmOutputBuild(compiler) {
-    if (compiler.options.experiments?.outputModule) {
-        return true;
-    }
-    if (compiler.options.output?.module) {
-        return true;
-    }
-    const library = compiler.options.output?.library;
-    if (library &&
-        typeof library === 'object' &&
-        !Array.isArray(library) &&
-        'type' in library) {
-        return library.type === 'module';
-    }
-    return false;
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+const require_runtime = require('../../../_virtual/_rolldown/runtime.js');
+const require_lib_container_runtime_FederationModulesPlugin = require('./FederationModulesPlugin.js');
+const require_lib_container_runtime_utils = require('./utils.js');
+const require_lib_container_runtime_FederationRuntimeModule = require('./FederationRuntimeModule.js');
+const require_lib_container_constant = require('../constant.js');
+const require_lib_container_runtime_EmbedFederationRuntimePlugin = require('./EmbedFederationRuntimePlugin.js');
+const require_lib_container_HoistContainerReferencesPlugin = require('../HoistContainerReferencesPlugin.js');
+const require_lib_container_runtime_FederationRuntimeDependency = require('./FederationRuntimeDependency.js');
+let _module_federation_sdk_normalize_webpack_path = require("@module-federation/sdk/normalize-webpack-path");
+let path = require("path");
+path = require_runtime.__toESM(path);
+let fs = require("fs");
+fs = require_runtime.__toESM(fs);
+let _module_federation_data_prefetch_cli = require("@module-federation/data-prefetch/cli");
+let btoa = require("btoa");
+btoa = require_runtime.__toESM(btoa);
+
+//#region src/lib/container/runtime/FederationRuntimePlugin.ts
+require_lib_container_runtime_FederationModulesPlugin.init_FederationModulesPlugin();
+const ModuleDependency = require((0, _module_federation_sdk_normalize_webpack_path.normalizeWebpackPath)("webpack/lib/dependencies/ModuleDependency"));
+const { RuntimeGlobals, Template } = require((0, _module_federation_sdk_normalize_webpack_path.normalizeWebpackPath)("webpack"));
+const { mkdirpSync } = require((0, _module_federation_sdk_normalize_webpack_path.normalizeWebpackPath)("webpack/lib/util/fs"));
+function resolveRuntimeEntry(spec, implementation, resolve = require.resolve) {
+	const candidates = [
+		spec.bundler,
+		spec.esm,
+		spec.cjs
+	];
+	const modulePaths = implementation ? [implementation] : void 0;
+	let lastError;
+	for (const candidate of candidates) try {
+		return modulePaths ? resolve(candidate, { paths: modulePaths }) : resolve(candidate);
+	} catch (error) {
+		lastError = error;
+	}
+	throw lastError;
 }
-function getModuleCandidates(packageName, preferEsm) {
-    const preferred = preferEsm
-        ? [`${packageName}/dist/index.js`, `${packageName}/dist/index.cjs`]
-        : [`${packageName}/dist/index.cjs`, `${packageName}/dist/index.js`];
-    const legacyFallback = preferEsm
-        ? [`${packageName}/dist/index.esm.js`, `${packageName}/dist/index.cjs.cjs`]
-        : [`${packageName}/dist/index.cjs.cjs`, `${packageName}/dist/index.esm.js`];
-    // Keep legacy dist entry names as fallbacks for mixed plugin/runtime versions.
-    // Resolve package root last to avoid accidentally selecting a CJS export when
-    // an explicit ESM fallback file exists in legacy runtime layouts.
-    return [...preferred, ...legacyFallback, packageName];
+function resolveRuntimeEntryWithFallback(spec, implementation, resolve = require.resolve) {
+	if (implementation) try {
+		return resolveRuntimeEntry(spec, implementation, resolve);
+	} catch {}
+	return resolveRuntimeEntry(spec, void 0, resolve);
 }
-function resolveRuntimePaths(preferEsm, implementation) {
-    const runtimeToolsCandidates = getModuleCandidates('@module-federation/runtime-tools', preferEsm);
-    const bundlerRuntimeCandidates = getModuleCandidates('@module-federation/webpack-bundler-runtime', preferEsm);
-    const runtimeCandidates = getModuleCandidates('@module-federation/runtime', preferEsm);
-    const runtimeToolsPath = resolveModule(runtimeToolsCandidates);
-    const modulePaths = implementation ? [implementation] : [runtimeToolsPath];
-    return {
-        runtimeToolsPath,
-        bundlerRuntimePath: resolveModule(bundlerRuntimeCandidates, {
-            paths: modulePaths,
-        }),
-        runtimePath: resolveModule(runtimeCandidates, {
-            paths: modulePaths,
-        }),
-    };
-}
-const { runtimeToolsPath: RuntimeToolsPath, bundlerRuntimePath: BundlerRuntimePath, runtimePath: RuntimePath, } = resolveRuntimePaths(true);
-const federationGlobal = (0, utils_1.getFederationGlobalScope)(RuntimeGlobals);
-const onceForCompiler = new WeakSet();
-const onceForCompilerEntryMap = new WeakMap();
-class FederationRuntimePlugin {
-    constructor(options) {
-        this.options = options ? { ...options } : undefined;
-        this.entryFilePath = '';
-        this.bundlerRuntimePath = BundlerRuntimePath;
-        this.runtimePath = RuntimePath;
-        this.runtimeToolsPath = RuntimeToolsPath;
-        this.federationRuntimeDependency = undefined; // Initialize as undefined
-    }
-    static getTemplate(compiler, options, bundlerRuntimePath) {
-        // internal runtime plugin
-        const runtimePlugins = options.runtimePlugins;
-        const normalizedBundlerRuntimePath = (0, utils_1.normalizeToPosixPath)(bundlerRuntimePath || BundlerRuntimePath);
-        let runtimePluginTemplates = '';
-        const runtimePluginCalls = [];
-        if (Array.isArray(runtimePlugins)) {
-            runtimePlugins.forEach((runtimePlugin, index) => {
-                if (!runtimePlugin) {
-                    return;
-                }
-                const runtimePluginName = `plugin_${index}`;
-                const runtimePluginEntry = Array.isArray(runtimePlugin)
-                    ? runtimePlugin[0]
-                    : runtimePlugin;
-                const runtimePluginPath = (0, utils_1.normalizeToPosixPath)(path_1.default.isAbsolute(runtimePluginEntry)
-                    ? runtimePluginEntry
-                    : path_1.default.join(process.cwd(), runtimePluginEntry));
-                const paramsStr = Array.isArray(runtimePlugin) && runtimePlugin.length > 1
-                    ? JSON.stringify(runtimePlugin[1])
-                    : 'undefined';
-                runtimePluginTemplates += `import ${runtimePluginName} from '${runtimePluginPath}';\n`;
-                runtimePluginCalls.push(`${runtimePluginName} ? (${runtimePluginName}.default || ${runtimePluginName})(${paramsStr}) : false`);
-            });
-        }
-        const embedRuntimeLines = Template.asString([
-            `if(!${federationGlobal}.runtime || !${federationGlobal}.bundlerRuntime){`,
-            Template.indent([
-                `var prevFederation = ${federationGlobal};`,
-                `${federationGlobal} = {}`,
-                `for(var key in federation){`,
-                Template.indent([`${federationGlobal}[key] = federation[key];`]),
-                '}',
-                `for(var key in prevFederation){`,
-                Template.indent([`${federationGlobal}[key] = prevFederation[key];`]),
-                '}',
-            ]),
-            '}',
-        ]);
-        return Template.asString([
-            `import federation from '${normalizedBundlerRuntimePath}';`,
-            runtimePluginTemplates,
-            embedRuntimeLines,
-            `if(!${federationGlobal}.instance){`,
-            Template.indent([
-                runtimePluginCalls.length
-                    ? Template.asString([
-                        `var pluginsToAdd = [`,
-                        Template.indent(Template.indent(runtimePluginCalls.map((call) => `${call},`))),
-                        `].filter(Boolean);`,
-                        `${federationGlobal}.initOptions.plugins = ${federationGlobal}.initOptions.plugins ? `,
-                        `${federationGlobal}.initOptions.plugins.concat(pluginsToAdd) : pluginsToAdd;`,
-                    ])
-                    : '',
-                // `${federationGlobal}.instance = ${federationGlobal}.runtime.init(${federationGlobal}.initOptions);`,
-                `${federationGlobal}.instance = ${federationGlobal}.bundlerRuntime.init({webpackRequire:${RuntimeGlobals.require}});`,
-                `if(${federationGlobal}.attachShareScopeMap){`,
-                Template.indent([
-                    `${federationGlobal}.attachShareScopeMap(${RuntimeGlobals.require})`,
-                ]),
-                '}',
-                `if(${federationGlobal}.installInitialConsumes){`,
-                Template.indent([`${federationGlobal}.installInitialConsumes()`]),
-                '}',
-            ]),
-            cli_1.PrefetchPlugin.addRuntime(compiler, {
-                name: options.name,
-            }),
-            '}',
-        ]);
-    }
-    getFilePath(compiler) {
-        if (!this.options) {
-            return '';
-        }
-        const existedFilePath = onceForCompilerEntryMap.get(compiler);
-        if (existedFilePath) {
-            return existedFilePath;
-        }
-        let entryFilePath = '';
-        if (!this.options?.virtualRuntimeEntry) {
-            const containerName = this.options.name;
-            const hash = (0, utils_1.createHash)(`${containerName} ${FederationRuntimePlugin.getTemplate(compiler, this.options, this.bundlerRuntimePath)}`);
-            entryFilePath = path_1.default.join(constant_1.TEMP_DIR, `entry.${hash}.js`);
-        }
-        else {
-            entryFilePath = `data:text/javascript;charset=utf-8;base64,${(0, btoa_1.default)(FederationRuntimePlugin.getTemplate(compiler, this.options, this.bundlerRuntimePath))}`;
-        }
-        onceForCompilerEntryMap.set(compiler, entryFilePath);
-        return entryFilePath;
-    }
-    ensureFile(compiler) {
-        if (!this.options) {
-            return;
-        }
-        // skip virtual entry
-        if (this.options?.virtualRuntimeEntry) {
-            return;
-        }
-        const filePath = this.entryFilePath;
-        const outputFs = compiler
-            .outputFileSystem;
-        const fsLike = outputFs &&
-            typeof outputFs.readFileSync === 'function' &&
-            typeof outputFs.writeFileSync === 'function'
-            ? outputFs
-            : fs_1.default;
-        try {
-            fsLike.readFileSync(filePath);
-        }
-        catch (err) {
-            mkdirpSync(fsLike, constant_1.TEMP_DIR);
-            fsLike.writeFileSync(filePath, FederationRuntimePlugin.getTemplate(compiler, this.options, this.bundlerRuntimePath));
-        }
-    }
-    getDependency(compiler) {
-        if (this.federationRuntimeDependency)
-            return this.federationRuntimeDependency;
-        this.ensureFile(compiler);
-        this.federationRuntimeDependency = new FederationRuntimeDependency_1.default(this.entryFilePath);
-        return this.federationRuntimeDependency;
-    }
-    prependEntry(compiler) {
-        if (!this.options?.virtualRuntimeEntry) {
-            this.ensureFile(compiler);
-        }
-        compiler.hooks.thisCompilation.tap(this.constructor.name, (compilation, { normalModuleFactory }) => {
-            compilation.dependencyFactories.set(FederationRuntimeDependency_1.default, normalModuleFactory);
-            compilation.dependencyTemplates.set(FederationRuntimeDependency_1.default, new ModuleDependency.Template());
-        });
-        compiler.hooks.make.tapAsync(this.constructor.name, (compilation, callback) => {
-            const federationRuntimeDependency = this.getDependency(compiler);
-            const hooks = FederationModulesPlugin_1.default.getCompilationHooks(compilation);
-            compilation.addInclude(compiler.context, federationRuntimeDependency, { name: undefined }, (err, module) => {
-                if (err) {
-                    return callback(err);
-                }
-                hooks.addFederationRuntimeDependency.call(federationRuntimeDependency);
-                callback();
-            });
-        });
-    }
-    injectRuntime(compiler) {
-        if (!this.options || !this.options.name) {
-            return;
-        }
-        const name = this.options.name;
-        const initOptionsWithoutShared = (0, utils_1.normalizeRuntimeInitOptionsWithOutShared)(this.options);
-        const federationGlobal = (0, utils_1.getFederationGlobalScope)(RuntimeGlobals || {});
-        compiler.hooks.thisCompilation.tap(this.constructor.name, (compilation) => {
-            const handler = (chunk, runtimeRequirements) => {
-                if (runtimeRequirements.has(federationGlobal))
-                    return;
-                runtimeRequirements.add(federationGlobal);
-                runtimeRequirements.add(RuntimeGlobals.interceptModuleExecution);
-                runtimeRequirements.add(RuntimeGlobals.moduleCache);
-                runtimeRequirements.add(RuntimeGlobals.compatGetDefaultExport);
-                compilation.addRuntimeModule(chunk, new FederationRuntimeModule_1.default(runtimeRequirements, name, initOptionsWithoutShared));
-            };
-            compilation.hooks.additionalTreeRuntimeRequirements.tap(this.constructor.name, (chunk, runtimeRequirements) => {
-                if (!chunk.hasRuntime())
-                    return;
-                if (runtimeRequirements.has(RuntimeGlobals.initializeSharing))
-                    return;
-                if (runtimeRequirements.has(RuntimeGlobals.currentRemoteGetScope))
-                    return;
-                if (runtimeRequirements.has(RuntimeGlobals.shareScopeMap))
-                    return;
-                if (runtimeRequirements.has(federationGlobal))
-                    return;
-                handler(chunk, runtimeRequirements);
-            });
-            // if federation runtime requirements exist
-            // attach runtime module to the chunk
-            compilation.hooks.runtimeRequirementInTree
-                .for(RuntimeGlobals.initializeSharing)
-                .tap(this.constructor.name, handler);
-            compilation.hooks.runtimeRequirementInTree
-                .for(RuntimeGlobals.currentRemoteGetScope)
-                .tap(this.constructor.name, handler);
-            compilation.hooks.runtimeRequirementInTree
-                .for(RuntimeGlobals.shareScopeMap)
-                .tap(this.constructor.name, handler);
-            compilation.hooks.runtimeRequirementInTree
-                .for(federationGlobal)
-                .tap(this.constructor.name, handler);
-        });
-    }
-    getRuntimeAlias(compiler) {
-        const { implementation } = this.options || {};
-        const alias = compiler.options.resolve.alias || {};
-        const resolvedPaths = resolveRuntimePaths(isEsmOutputBuild(compiler), implementation);
-        this.runtimeToolsPath = resolvedPaths.runtimeToolsPath;
-        this.bundlerRuntimePath = resolvedPaths.bundlerRuntimePath;
-        if (alias['@module-federation/runtime$']) {
-            this.runtimePath = alias['@module-federation/runtime$'];
-            return this.runtimePath;
-        }
-        this.runtimePath = resolvedPaths.runtimePath;
-        return this.runtimePath;
-    }
-    setRuntimeAlias(compiler) {
-        const { implementation } = this.options || {};
-        const alias = compiler.options.resolve.alias || {};
-        const runtimePath = this.getRuntimeAlias(compiler);
-        alias['@module-federation/runtime$'] =
-            alias['@module-federation/runtime$'] || runtimePath;
-        alias['@module-federation/runtime-tools$'] =
-            alias['@module-federation/runtime-tools$'] ||
-                implementation ||
-                this.runtimeToolsPath;
-        // Set up aliases for the federation runtime and tools
-        // This ensures that the correct versions are used throughout the project
-        compiler.options.resolve.alias = alias;
-    }
-    apply(compiler) {
-        const useSharedContainerPlugin = compiler.options.plugins.find((p) => {
-            if (typeof p !== 'object' || !p) {
-                return false;
-            }
-            return p['name'] === 'SharedContainerPlugin';
-        });
-        // share container plugin should not inject mf runtime
-        if (useSharedContainerPlugin) {
-            return;
-        }
-        const useModuleFederationPlugin = compiler.options.plugins.find((p) => {
-            if (typeof p !== 'object' || !p) {
-                return false;
-            }
-            return p['name'] === 'ModuleFederationPlugin';
-        });
-        if (useModuleFederationPlugin && !this.options) {
-            this.options = useModuleFederationPlugin._options;
-        }
-        const useContainerPlugin = compiler.options.plugins.find((p) => {
-            if (typeof p !== 'object' || !p) {
-                return false;
-            }
-            return p['name'] === 'ContainerPlugin';
-        });
-        if (useContainerPlugin && !this.options) {
-            this.options = useContainerPlugin._options;
-        }
-        if (!useContainerPlugin && !useModuleFederationPlugin) {
-            this.options = {
-                remotes: {},
-                ...this.options,
-            };
-        }
-        if (this.options && !this.options?.name) {
-            //! the instance may get the same one if the name is the same https://github.com/module-federation/core/blob/main/packages/runtime/src/index.ts#L18
-            this.options.name =
-                compiler.options.output.uniqueName || `container_${Date.now()}`;
-        }
-        const resolvedPaths = resolveRuntimePaths(isEsmOutputBuild(compiler), this.options?.implementation);
-        this.bundlerRuntimePath = resolvedPaths.bundlerRuntimePath;
-        this.runtimePath = resolvedPaths.runtimePath;
-        this.runtimeToolsPath = resolvedPaths.runtimeToolsPath;
-        this.entryFilePath = this.getFilePath(compiler);
-        new EmbedFederationRuntimePlugin_1.default().apply(compiler);
-        new HoistContainerReferencesPlugin_1.default().apply(compiler);
-        // dont run multiple times on every apply()
-        if (!onceForCompiler.has(compiler)) {
-            this.prependEntry(compiler);
-            this.injectRuntime(compiler);
-            this.setRuntimeAlias(compiler);
-            onceForCompiler.add(compiler);
-        }
-    }
+function resolveRuntimePaths(implementation, resolve = require.resolve) {
+	const runtimeToolsPath = resolveRuntimeEntryWithFallback({
+		bundler: "@module-federation/runtime-tools/bundler",
+		esm: "@module-federation/runtime-tools/dist/index.js",
+		cjs: "@module-federation/runtime-tools/dist/index.cjs"
+	}, implementation, resolve);
+	const moduleBase = implementation || runtimeToolsPath;
+	return {
+		runtimeToolsPath,
+		bundlerRuntimePath: resolveRuntimeEntry({
+			bundler: "@module-federation/webpack-bundler-runtime/bundler",
+			esm: "@module-federation/webpack-bundler-runtime/dist/index.js",
+			cjs: "@module-federation/webpack-bundler-runtime/dist/index.cjs"
+		}, moduleBase, resolve),
+		runtimePath: resolveRuntimeEntry({
+			bundler: "@module-federation/runtime/bundler",
+			esm: "@module-federation/runtime/dist/index.js",
+			cjs: "@module-federation/runtime/dist/index.cjs"
+		}, moduleBase, resolve)
+	};
 }
+const { runtimeToolsPath: RuntimeToolsPath, bundlerRuntimePath: BundlerRuntimePath, runtimePath: RuntimePath } = resolveRuntimePaths();
+const federationGlobal = require_lib_container_runtime_utils.getFederationGlobalScope(RuntimeGlobals);
+const onceForCompiler = /* @__PURE__ */ new WeakSet();
+const onceForCompilerEntryMap = /* @__PURE__ */ new WeakMap();
+var FederationRuntimePlugin = class FederationRuntimePlugin {
+	constructor(options) {
+		this.options = options ? { ...options } : void 0;
+		this.entryFilePath = "";
+		this.bundlerRuntimePath = BundlerRuntimePath;
+		this.runtimePath = RuntimePath;
+		this.runtimeToolsPath = RuntimeToolsPath;
+		this.federationRuntimeDependency = void 0;
+	}
+	static getTemplate(compiler, options, bundlerRuntimePath) {
+		const runtimePlugins = options.runtimePlugins;
+		const normalizedBundlerRuntimePath = require_lib_container_runtime_utils.normalizeToPosixPath(bundlerRuntimePath || BundlerRuntimePath);
+		let runtimePluginTemplates = "";
+		const runtimePluginCalls = [];
+		if (Array.isArray(runtimePlugins)) runtimePlugins.forEach((runtimePlugin, index) => {
+			if (!runtimePlugin) return;
+			const runtimePluginName = `plugin_${index}`;
+			const runtimePluginEntry = Array.isArray(runtimePlugin) ? runtimePlugin[0] : runtimePlugin;
+			const runtimePluginPath = require_lib_container_runtime_utils.normalizeToPosixPath(path.default.isAbsolute(runtimePluginEntry) ? runtimePluginEntry : path.default.join(process.cwd(), runtimePluginEntry));
+			const paramsStr = Array.isArray(runtimePlugin) && runtimePlugin.length > 1 ? JSON.stringify(runtimePlugin[1]) : "undefined";
+			runtimePluginTemplates += `import ${runtimePluginName} from '${runtimePluginPath}';\n`;
+			runtimePluginCalls.push(`${runtimePluginName} ? (${runtimePluginName}.default || ${runtimePluginName})(${paramsStr}) : false`);
+		});
+		const embedRuntimeLines = Template.asString([
+			`if(!${federationGlobal}.runtime || !${federationGlobal}.bundlerRuntime){`,
+			Template.indent([
+				`var prevFederation = ${federationGlobal};`,
+				`${federationGlobal} = {}`,
+				`for(var key in federation){`,
+				Template.indent([`${federationGlobal}[key] = federation[key];`]),
+				"}",
+				`for(var key in prevFederation){`,
+				Template.indent([`${federationGlobal}[key] = prevFederation[key];`]),
+				"}"
+			]),
+			"}"
+		]);
+		return Template.asString([
+			`import federation from '${normalizedBundlerRuntimePath}';`,
+			runtimePluginTemplates,
+			embedRuntimeLines,
+			`if(!${federationGlobal}.instance){`,
+			Template.indent([
+				runtimePluginCalls.length ? Template.asString([
+					`var pluginsToAdd = [`,
+					Template.indent(Template.indent(runtimePluginCalls.map((call) => `${call},`))),
+					`].filter(Boolean);`,
+					`${federationGlobal}.initOptions.plugins = ${federationGlobal}.initOptions.plugins ? `,
+					`${federationGlobal}.initOptions.plugins.concat(pluginsToAdd) : pluginsToAdd;`
+				]) : "",
+				`${federationGlobal}.instance = ${federationGlobal}.bundlerRuntime.init({webpackRequire:${RuntimeGlobals.require}});`,
+				`if(${federationGlobal}.attachShareScopeMap){`,
+				Template.indent([`${federationGlobal}.attachShareScopeMap(${RuntimeGlobals.require})`]),
+				"}",
+				`if(${federationGlobal}.installInitialConsumes){`,
+				Template.indent([`${federationGlobal}.installInitialConsumes()`]),
+				"}"
+			]),
+			_module_federation_data_prefetch_cli.PrefetchPlugin.addRuntime(compiler, { name: options.name }),
+			"}"
+		]);
+	}
+	getFilePath(compiler) {
+		if (!this.options) return "";
+		const existedFilePath = onceForCompilerEntryMap.get(compiler);
+		if (existedFilePath) return existedFilePath;
+		let entryFilePath = "";
+		if (!this.options?.virtualRuntimeEntry) {
+			const containerName = this.options.name;
+			const hash = require_lib_container_runtime_utils.createHash(`${containerName} ${FederationRuntimePlugin.getTemplate(compiler, this.options, this.bundlerRuntimePath)}`);
+			entryFilePath = path.default.join(require_lib_container_constant.TEMP_DIR, `entry.${hash}.js`);
+		} else entryFilePath = `data:text/javascript;charset=utf-8;base64,${(0, btoa.default)(FederationRuntimePlugin.getTemplate(compiler, this.options, this.bundlerRuntimePath))}`;
+		onceForCompilerEntryMap.set(compiler, entryFilePath);
+		return entryFilePath;
+	}
+	ensureFile(compiler) {
+		if (!this.options) return;
+		if (this.options?.virtualRuntimeEntry) return;
+		const filePath = this.entryFilePath;
+		const outputFs = compiler.outputFileSystem;
+		const fsLike = outputFs && typeof outputFs.readFileSync === "function" && typeof outputFs.writeFileSync === "function" ? outputFs : fs.default;
+		try {
+			fsLike.readFileSync(filePath);
+		} catch {
+			mkdirpSync(fsLike, require_lib_container_constant.TEMP_DIR);
+			fsLike.writeFileSync(filePath, FederationRuntimePlugin.getTemplate(compiler, this.options, this.bundlerRuntimePath));
+		}
+	}
+	getDependency(compiler) {
+		if (this.federationRuntimeDependency) return this.federationRuntimeDependency;
+		this.ensureFile(compiler);
+		this.federationRuntimeDependency = new require_lib_container_runtime_FederationRuntimeDependency.default(this.entryFilePath);
+		return this.federationRuntimeDependency;
+	}
+	prependEntry(compiler) {
+		if (!this.options?.virtualRuntimeEntry) this.ensureFile(compiler);
+		compiler.hooks.thisCompilation.tap(this.constructor.name, (compilation, { normalModuleFactory }) => {
+			compilation.dependencyFactories.set(require_lib_container_runtime_FederationRuntimeDependency.default, normalModuleFactory);
+			compilation.dependencyTemplates.set(require_lib_container_runtime_FederationRuntimeDependency.default, new ModuleDependency.Template());
+		});
+		compiler.hooks.make.tapAsync(this.constructor.name, (compilation, callback) => {
+			const federationRuntimeDependency = this.getDependency(compiler);
+			const hooks = require_lib_container_runtime_FederationModulesPlugin.default.getCompilationHooks(compilation);
+			compilation.addInclude(compiler.context, federationRuntimeDependency, { name: void 0 }, (err) => {
+				if (err) return callback(err);
+				hooks.addFederationRuntimeDependency.call(federationRuntimeDependency);
+				callback();
+			});
+		});
+	}
+	injectRuntime(compiler) {
+		if (!this.options || !this.options.name) return;
+		const name = this.options.name;
+		const initOptionsWithoutShared = require_lib_container_runtime_utils.normalizeRuntimeInitOptionsWithOutShared(this.options);
+		const federationGlobal = require_lib_container_runtime_utils.getFederationGlobalScope(RuntimeGlobals || {});
+		compiler.hooks.thisCompilation.tap(this.constructor.name, (compilation) => {
+			const handler = (chunk, runtimeRequirements) => {
+				if (runtimeRequirements.has(federationGlobal)) return;
+				runtimeRequirements.add(federationGlobal);
+				runtimeRequirements.add(RuntimeGlobals.interceptModuleExecution);
+				runtimeRequirements.add(RuntimeGlobals.moduleCache);
+				runtimeRequirements.add(RuntimeGlobals.compatGetDefaultExport);
+				compilation.addRuntimeModule(chunk, new require_lib_container_runtime_FederationRuntimeModule.default(runtimeRequirements, name, initOptionsWithoutShared));
+			};
+			compilation.hooks.additionalTreeRuntimeRequirements.tap(this.constructor.name, (chunk, runtimeRequirements) => {
+				if (!chunk.hasRuntime()) return;
+				if (runtimeRequirements.has(RuntimeGlobals.initializeSharing)) return;
+				if (runtimeRequirements.has(RuntimeGlobals.currentRemoteGetScope)) return;
+				if (runtimeRequirements.has(RuntimeGlobals.shareScopeMap)) return;
+				if (runtimeRequirements.has(federationGlobal)) return;
+				handler(chunk, runtimeRequirements);
+			});
+			compilation.hooks.runtimeRequirementInTree.for(RuntimeGlobals.initializeSharing).tap(this.constructor.name, handler);
+			compilation.hooks.runtimeRequirementInTree.for(RuntimeGlobals.currentRemoteGetScope).tap(this.constructor.name, handler);
+			compilation.hooks.runtimeRequirementInTree.for(RuntimeGlobals.shareScopeMap).tap(this.constructor.name, handler);
+			compilation.hooks.runtimeRequirementInTree.for(federationGlobal).tap(this.constructor.name, handler);
+		});
+	}
+	getRuntimeAlias(compiler) {
+		const { implementation } = this.options || {};
+		const alias = compiler.options.resolve.alias || {};
+		const resolvedPaths = resolveRuntimePaths(implementation);
+		this.runtimeToolsPath = resolvedPaths.runtimeToolsPath;
+		this.bundlerRuntimePath = resolvedPaths.bundlerRuntimePath;
+		if (alias["@module-federation/runtime$"]) {
+			this.runtimePath = alias["@module-federation/runtime$"];
+			return this.runtimePath;
+		}
+		this.runtimePath = resolvedPaths.runtimePath;
+		return this.runtimePath;
+	}
+	setRuntimeAlias(compiler) {
+		const { implementation } = this.options || {};
+		const alias = compiler.options.resolve.alias || {};
+		const runtimePath = this.getRuntimeAlias(compiler);
+		alias["@module-federation/runtime$"] = alias["@module-federation/runtime$"] || runtimePath;
+		alias["@module-federation/runtime-tools$"] = alias["@module-federation/runtime-tools$"] || implementation || this.runtimeToolsPath;
+		compiler.options.resolve.alias = alias;
+	}
+	apply(compiler) {
+		if (compiler.options.plugins.find((p) => {
+			if (typeof p !== "object" || !p) return false;
+			return p["name"] === "SharedContainerPlugin";
+		})) return;
+		const useModuleFederationPlugin = compiler.options.plugins.find((p) => {
+			if (typeof p !== "object" || !p) return false;
+			return p["name"] === "ModuleFederationPlugin";
+		});
+		if (useModuleFederationPlugin && !this.options) this.options = useModuleFederationPlugin._options;
+		const useContainerPlugin = compiler.options.plugins.find((p) => {
+			if (typeof p !== "object" || !p) return false;
+			return p["name"] === "ContainerPlugin";
+		});
+		if (useContainerPlugin && !this.options) this.options = useContainerPlugin._options;
+		if (!useContainerPlugin && !useModuleFederationPlugin) this.options = {
+			remotes: {},
+			...this.options
+		};
+		if (this.options && !this.options?.name)
+ //! the instance may get the same one if the name is the same https://github.com/module-federation/core/blob/main/packages/runtime/src/index.ts#L18
+		this.options.name = compiler.options.output.uniqueName || `container_${Date.now()}`;
+		const resolvedPaths = resolveRuntimePaths(this.options?.implementation);
+		this.bundlerRuntimePath = resolvedPaths.bundlerRuntimePath;
+		this.runtimePath = resolvedPaths.runtimePath;
+		this.runtimeToolsPath = resolvedPaths.runtimeToolsPath;
+		this.entryFilePath = this.getFilePath(compiler);
+		new require_lib_container_runtime_EmbedFederationRuntimePlugin.default().apply(compiler);
+		new require_lib_container_HoistContainerReferencesPlugin.default().apply(compiler);
+		if (!onceForCompiler.has(compiler)) {
+			this.prependEntry(compiler);
+			this.injectRuntime(compiler);
+			this.setRuntimeAlias(compiler);
+			onceForCompiler.add(compiler);
+		}
+	}
+};
+
+//#endregion
 exports.default = FederationRuntimePlugin;
+exports.resolveRuntimePaths = resolveRuntimePaths;
 //# sourceMappingURL=FederationRuntimePlugin.js.map