@module-federation/enhanced/dist/src/lib/container/ContainerPlugin.js

This package provides enhanced features for module federation.

Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
const require_runtime = require('../../_virtual/_rolldown/runtime.js');
const require_lib_container_options = require('./options.js');
const require_lib_container_ContainerEntryDependency = require('./ContainerEntryDependency.js');
const require_lib_container_ContainerExposedDependency = require('./ContainerExposedDependency.js');
const require_lib_container_ContainerEntryModuleFactory = require('./ContainerEntryModuleFactory.js');
const require_lib_container_runtime_FederationModulesPlugin = require('./runtime/FederationModulesPlugin.js');
const require_lib_container_runtime_FederationRuntimeDependency = require('./runtime/FederationRuntimeDependency.js');
const require_lib_container_runtime_FederationRuntimePlugin = require('./runtime/FederationRuntimePlugin.js');
let _module_federation_sdk_normalize_webpack_path = require("@module-federation/sdk/normalize-webpack-path");

//#region src/lib/container/ContainerPlugin.ts
const ModuleDependency = require((0, _module_federation_sdk_normalize_webpack_path.normalizeWebpackPath)("webpack/lib/dependencies/ModuleDependency"));
const EntryDependency = require((0, _module_federation_sdk_normalize_webpack_path.normalizeWebpackPath)("webpack/lib/dependencies/EntryDependency"));
require((0, _module_federation_sdk_normalize_webpack_path.normalizeWebpackPath)("webpack/lib/util/create-schema-validation"));
const PLUGIN_NAME = "ContainerPlugin";
var ContainerPlugin = class ContainerPlugin {
	constructor(options) {
		this.name = PLUGIN_NAME;
		this._options = {
			name: options.name,
			shareScope: options.shareScope || "default",
			library: options.library || {
				type: "global",
				name: options.name
			},
			runtime: options.runtime,
			filename: options.filename || void 0,
			exposes: require_lib_container_options.parseOptions(options.exposes, (item) => ({
				import: Array.isArray(item) ? item : [item],
				name: void 0
			}), (item) => ({
				import: Array.isArray(item.import) ? item.import : [item.import],
				name: item.name || void 0
			})),
			runtimePlugins: options.runtimePlugins,
			dataPrefetch: options.dataPrefetch
		};
	}
	static patchChunkSplit(compiler, name) {
		const { splitChunks } = compiler.options.optimization;
		const patchChunkSplit = (cacheGroup) => {
			switch (typeof cacheGroup) {
				case "boolean":
				case "string":
				case "function": break;
				case "object":
					if (cacheGroup instanceof RegExp) break;
					if (!cacheGroup.chunks) break;
					if (typeof cacheGroup.chunks === "function") {
						const prevChunks = cacheGroup.chunks;
						cacheGroup.chunks = (chunk) => {
							if (chunk.name && (chunk.name === name || chunk.name === name + "_partial")) return false;
							return prevChunks(chunk);
						};
						break;
					}
					if (cacheGroup.chunks === "all") {
						cacheGroup.chunks = (chunk) => {
							if (chunk.name && (chunk.name === name || chunk.name === name + "_partial")) return false;
							return true;
						};
						break;
					}
					if (cacheGroup.chunks === "initial") {
						cacheGroup.chunks = (chunk) => {
							if (chunk.name && (chunk.name === name || chunk.name === name + "_partial")) return false;
							return chunk.isOnlyInitial();
						};
						break;
					}
					break;
			}
		};
		if (!splitChunks) return;
		patchChunkSplit(splitChunks);
		const cacheGroups = splitChunks.cacheGroups;
		if (!cacheGroups) return;
		Object.keys(cacheGroups).forEach((cacheGroupKey) => {
			patchChunkSplit(cacheGroups[cacheGroupKey]);
		});
	}
	apply(compiler) {
		if (!compiler.options.plugins.find((p) => {
			if (typeof p !== "object" || !p) return false;
			return p["name"] === "ModuleFederationPlugin";
		})) ContainerPlugin.patchChunkSplit(compiler, this._options.name);
		const federationRuntimePluginInstance = new require_lib_container_runtime_FederationRuntimePlugin.default();
		federationRuntimePluginInstance.apply(compiler);
		const { name, exposes, shareScope, filename, library, runtime } = this._options;
		if (library && compiler.options.output && compiler.options.output.enabledLibraryTypes && !compiler.options.output.enabledLibraryTypes.includes(library.type)) compiler.options.output.enabledLibraryTypes.push(library.type);
		compiler.hooks.make.tapAsync(PLUGIN_NAME, async (compilation, callback) => {
			const hooks = require_lib_container_runtime_FederationModulesPlugin.default.getCompilationHooks(compilation);
			const federationRuntimeDependency = federationRuntimePluginInstance.getDependency(compiler);
			const dep = new require_lib_container_ContainerEntryDependency.default(name, exposes, shareScope, federationRuntimePluginInstance.entryFilePath, this._options.dataPrefetch);
			dep.loc = { name };
			await new Promise((resolve, reject) => {
				compilation.addEntry(compilation.options.context || "", dep, {
					name,
					filename,
					runtime,
					library
				}, (error) => {
					if (error) return reject(error);
					hooks.addContainerEntryDependency.call(dep);
					resolve(void 0);
				});
			}).catch(callback);
			await new Promise((resolve, reject) => {
				compilation.addInclude(compiler.context, federationRuntimeDependency, { name: void 0 }, (err, module) => {
					if (err) return reject(err);
					hooks.addFederationRuntimeDependency.call(federationRuntimeDependency);
					resolve(void 0);
				});
			}).catch(callback);
			callback();
		});
		compiler.hooks.finishMake.tapAsync(PLUGIN_NAME, (compilation, callback) => {
			if (compilation.compiler.parentCompilation && compilation.compiler.parentCompilation !== compilation) return callback();
			const hooks = require_lib_container_runtime_FederationModulesPlugin.default.getCompilationHooks(compilation);
			const createdRuntimes = /* @__PURE__ */ new Set();
			for (const entry of compilation.entries.values()) {
				const runtime = entry.options.runtime;
				if (runtime) createdRuntimes.add(runtime);
			}
			if (createdRuntimes.size === 0 && !compilation.options?.optimization?.runtimeChunk) return callback();
			const dep = new require_lib_container_ContainerEntryDependency.default(name, exposes, shareScope, federationRuntimePluginInstance.entryFilePath, this._options.dataPrefetch);
			dep.loc = { name };
			compilation.addInclude(compilation.options.context || "", dep, { name: void 0 }, (error) => {
				if (error) return callback(error);
				hooks.addContainerEntryDependency.call(dep);
				callback();
			});
		});
		compiler.hooks.thisCompilation.tap(PLUGIN_NAME, (compilation, { normalModuleFactory }) => {
			compilation.dependencyFactories.set(require_lib_container_ContainerEntryDependency.default, new require_lib_container_ContainerEntryModuleFactory.default());
			compilation.dependencyFactories.set(require_lib_container_ContainerExposedDependency.default, normalModuleFactory);
			if (!compilation.dependencyFactories.has(EntryDependency)) compilation.dependencyFactories.set(EntryDependency, normalModuleFactory);
		});
		compiler.hooks.thisCompilation.tap(PLUGIN_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());
		});
	}
};

//#endregion
exports.default = ContainerPlugin;
//# sourceMappingURL=ContainerPlugin.js.map