@depup/webpack 5.105.4-depup.37

package/lib/container/FallbackDependency.js

@@ -0,0 +1,66 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const Dependency = require("../Dependency");
+const makeSerializable = require("../util/makeSerializable");
+
+/** @typedef {import("./RemoteModule").ExternalRequests} ExternalRequests */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+
+class FallbackDependency extends Dependency {
+	/**
+	 * @param {ExternalRequests} requests requests
+	 */
+	constructor(requests) {
+		super();
+		/** @type {ExternalRequests} */
+		this.requests = requests;
+	}
+
+	/**
+	 * @returns {string | null} an identifier to merge equal requests
+	 */
+	getResourceIdentifier() {
+		return `fallback ${this.requests.join(" ")}`;
+	}
+
+	get type() {
+		return "fallback";
+	}
+
+	get category() {
+		return "esm";
+	}
+
+	/**
+	 * @param {ObjectSerializerContext} context context
+	 */
+	serialize(context) {
+		const { write } = context;
+		write(this.requests);
+		super.serialize(context);
+	}
+
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 * @returns {FallbackDependency} deserialize fallback dependency
+	 */
+	static deserialize(context) {
+		const { read } = context;
+		const obj = new FallbackDependency(read());
+		obj.deserialize(context);
+		return obj;
+	}
+}
+
+makeSerializable(
+	FallbackDependency,
+	"webpack/lib/container/FallbackDependency"
+);
+
+module.exports = FallbackDependency;

package/lib/container/FallbackItemDependency.js

@@ -0,0 +1,34 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const ModuleDependency = require("../dependencies/ModuleDependency");
+const makeSerializable = require("../util/makeSerializable");
+
+class FallbackItemDependency extends ModuleDependency {
+	/**
+	 * @param {string} request request
+	 */
+	constructor(request) {
+		/** @type {string} */
+		super(request);
+	}
+
+	get type() {
+		return "fallback item";
+	}
+
+	get category() {
+		return "esm";
+	}
+}
+
+makeSerializable(
+	FallbackItemDependency,
+	"webpack/lib/container/FallbackItemDependency"
+);
+
+module.exports = FallbackItemDependency;

package/lib/container/FallbackModule.js

@@ -0,0 +1,193 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra and Zackary Jackson @ScriptedAlchemy
+*/
+
+"use strict";
+
+const { RawSource } = require("webpack-sources");
+const Module = require("../Module");
+const {
+	JAVASCRIPT_TYPE,
+	JAVASCRIPT_TYPES
+} = require("../ModuleSourceTypeConstants");
+const { WEBPACK_MODULE_TYPE_FALLBACK } = require("../ModuleTypeConstants");
+const RuntimeGlobals = require("../RuntimeGlobals");
+const Template = require("../Template");
+const makeSerializable = require("../util/makeSerializable");
+const FallbackItemDependency = require("./FallbackItemDependency");
+
+/** @typedef {import("../config/defaults").WebpackOptionsNormalizedWithDefaults} WebpackOptions */
+/** @typedef {import("../Chunk")} Chunk */
+/** @typedef {import("../Compilation")} Compilation */
+/** @typedef {import("../Module").BuildCallback} BuildCallback */
+/** @typedef {import("../Module").CodeGenerationContext} CodeGenerationContext */
+/** @typedef {import("../Module").CodeGenerationResult} CodeGenerationResult */
+/** @typedef {import("../Module").LibIdentOptions} LibIdentOptions */
+/** @typedef {import("../Module").LibIdent} LibIdent */
+/** @typedef {import("../Module").NameForCondition} NameForCondition */
+/** @typedef {import("../Module").NeedBuildCallback} NeedBuildCallback */
+/** @typedef {import("../Module").NeedBuildContext} NeedBuildContext */
+/** @typedef {import("../Module").Sources} Sources */
+/** @typedef {import("../Module").SourceTypes} SourceTypes */
+/** @typedef {import("../RequestShortener")} RequestShortener */
+/** @typedef {import("../ResolverFactory").ResolverWithOptions} ResolverWithOptions */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+/** @typedef {import("../util/fs").InputFileSystem} InputFileSystem */
+/** @typedef {import("./RemoteModule").ExternalRequests} ExternalRequests */
+
+const RUNTIME_REQUIREMENTS = new Set([RuntimeGlobals.module]);
+
+class FallbackModule extends Module {
+	/**
+	 * @param {ExternalRequests} requests list of requests to choose one
+	 */
+	constructor(requests) {
+		super(WEBPACK_MODULE_TYPE_FALLBACK);
+		/** @type {ExternalRequests} */
+		this.requests = requests;
+		/** @type {string} */
+		this._identifier = `fallback ${this.requests.join(" ")}`;
+	}
+
+	/**
+	 * @returns {string} a unique identifier of the module
+	 */
+	identifier() {
+		return this._identifier;
+	}
+
+	/**
+	 * @param {RequestShortener} requestShortener the request shortener
+	 * @returns {string} a user readable identifier of the module
+	 */
+	readableIdentifier(requestShortener) {
+		return this._identifier;
+	}
+
+	/**
+	 * @param {LibIdentOptions} options options
+	 * @returns {LibIdent | null} an identifier for library inclusion
+	 */
+	libIdent(options) {
+		return `${this.layer ? `(${this.layer})/` : ""}webpack/container/fallback/${
+			this.requests[0]
+		}/and ${this.requests.length - 1} more`;
+	}
+
+	/**
+	 * @param {Chunk} chunk the chunk which condition should be checked
+	 * @param {Compilation} compilation the compilation
+	 * @returns {boolean} true, if the chunk is ok for the module
+	 */
+	chunkCondition(chunk, { chunkGraph }) {
+		return chunkGraph.getNumberOfEntryModules(chunk) > 0;
+	}
+
+	/**
+	 * @param {NeedBuildContext} context context info
+	 * @param {NeedBuildCallback} callback callback function, returns true, if the module needs a rebuild
+	 * @returns {void}
+	 */
+	needBuild(context, callback) {
+		callback(null, !this.buildInfo);
+	}
+
+	/**
+	 * @param {WebpackOptions} options webpack options
+	 * @param {Compilation} compilation the compilation
+	 * @param {ResolverWithOptions} resolver the resolver
+	 * @param {InputFileSystem} fs the file system
+	 * @param {BuildCallback} callback callback function
+	 * @returns {void}
+	 */
+	build(options, compilation, resolver, fs, callback) {
+		this.buildMeta = {};
+		this.buildInfo = {
+			strict: true
+		};
+
+		this.clearDependenciesAndBlocks();
+		for (const request of this.requests) {
+			this.addDependency(new FallbackItemDependency(request));
+		}
+
+		callback();
+	}
+
+	/**
+	 * @param {string=} type the source type for which the size should be estimated
+	 * @returns {number} the estimated size of the module (must be non-zero)
+	 */
+	size(type) {
+		return this.requests.length * 5 + 42;
+	}
+
+	/**
+	 * @returns {SourceTypes} types available (do not mutate)
+	 */
+	getSourceTypes() {
+		return JAVASCRIPT_TYPES;
+	}
+
+	/**
+	 * @param {CodeGenerationContext} context context for code generation
+	 * @returns {CodeGenerationResult} result
+	 */
+	codeGeneration({ runtimeTemplate, moduleGraph, chunkGraph }) {
+		const ids = this.dependencies.map((dep) =>
+			chunkGraph.getModuleId(/** @type {Module} */ (moduleGraph.getModule(dep)))
+		);
+		const code = Template.asString([
+			`var ids = ${JSON.stringify(ids)};`,
+			"var error, result, i = 0;",
+			`var loop = ${runtimeTemplate.basicFunction("next", [
+				"while(i < ids.length) {",
+				Template.indent([
+					`try { next = ${RuntimeGlobals.require}(ids[i++]); } catch(e) { return handleError(e); }`,
+					"if(next) return next.then ? next.then(handleResult, handleError) : handleResult(next);"
+				]),
+				"}",
+				"if(error) throw error;"
+			])}`,
+			`var handleResult = ${runtimeTemplate.basicFunction("result", [
+				"if(result) return result;",
+				"return loop();"
+			])};`,
+			`var handleError = ${runtimeTemplate.basicFunction("e", [
+				"error = e;",
+				"return loop();"
+			])};`,
+			"module.exports = loop();"
+		]);
+		/** @type {Sources} */
+		const sources = new Map();
+		sources.set(JAVASCRIPT_TYPE, new RawSource(code));
+		return { sources, runtimeRequirements: RUNTIME_REQUIREMENTS };
+	}
+
+	/**
+	 * @param {ObjectSerializerContext} context context
+	 */
+	serialize(context) {
+		const { write } = context;
+		write(this.requests);
+		super.serialize(context);
+	}
+
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 * @returns {FallbackModule} deserialized fallback module
+	 */
+	static deserialize(context) {
+		const { read } = context;
+		const obj = new FallbackModule(read());
+		obj.deserialize(context);
+		return obj;
+	}
+}
+
+makeSerializable(FallbackModule, "webpack/lib/container/FallbackModule");
+
+module.exports = FallbackModule;

package/lib/container/FallbackModuleFactory.js

@@ -0,0 +1,27 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra, Zackary Jackson @ScriptedAlchemy, Marais Rossouw @maraisr
+*/
+
+"use strict";
+
+const ModuleFactory = require("../ModuleFactory");
+const FallbackModule = require("./FallbackModule");
+
+/** @typedef {import("../ModuleFactory").ModuleFactoryCallback} ModuleFactoryCallback */
+/** @typedef {import("../ModuleFactory").ModuleFactoryCreateData} ModuleFactoryCreateData */
+/** @typedef {import("./FallbackDependency")} FallbackDependency */
+
+module.exports = class FallbackModuleFactory extends ModuleFactory {
+	/**
+	 * @param {ModuleFactoryCreateData} data data object
+	 * @param {ModuleFactoryCallback} callback callback
+	 * @returns {void}
+	 */
+	create({ dependencies: [dependency] }, callback) {
+		const dep = /** @type {FallbackDependency} */ (dependency);
+		callback(null, {
+			module: new FallbackModule(dep.requests)
+		});
+	}
+};

package/lib/container/HoistContainerReferencesPlugin.js

@@ -0,0 +1,256 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Zackary Jackson @ScriptedAlchemy
+*/
+
+"use strict";
+
+const AsyncDependenciesBlock = require("../AsyncDependenciesBlock");
+const ExternalModule = require("../ExternalModule");
+const { STAGE_ADVANCED } = require("../OptimizationStages");
+const memoize = require("../util/memoize");
+const { forEachRuntime } = require("../util/runtime");
+
+/** @typedef {import("../Compilation")} Compilation */
+/** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../Module")} Module */
+
+const getModuleFederationPlugin = memoize(() =>
+	require("./ModuleFederationPlugin")
+);
+
+const PLUGIN_NAME = "HoistContainerReferences";
+
+/**
+ * This class is used to hoist container references in the code.
+ */
+class HoistContainerReferences {
+	/**
+	 * Apply the plugin to the compiler.
+	 * @param {Compiler} compiler The webpack compiler instance.
+	 */
+	apply(compiler) {
+		compiler.hooks.thisCompilation.tap(PLUGIN_NAME, (compilation) => {
+			const hooks =
+				getModuleFederationPlugin().getCompilationHooks(compilation);
+			/** @type {Set<Dependency>} */
+			const depsToTrace = new Set();
+			/** @type {Set<Dependency>} */
+			const entryExternalsToHoist = new Set();
+			hooks.addContainerEntryDependency.tap(PLUGIN_NAME, (dep) => {
+				depsToTrace.add(dep);
+			});
+			hooks.addFederationRuntimeDependency.tap(PLUGIN_NAME, (dep) => {
+				depsToTrace.add(dep);
+			});
+
+			compilation.hooks.addEntry.tap(PLUGIN_NAME, (entryDep) => {
+				if (entryDep.type === "entry") {
+					entryExternalsToHoist.add(entryDep);
+				}
+			});
+
+			// Hook into the optimizeChunks phase
+			compilation.hooks.optimizeChunks.tap(
+				{
+					name: PLUGIN_NAME,
+					// advanced stage is where SplitChunksPlugin runs.
+					stage: STAGE_ADVANCED + 1
+				},
+				(_chunks) => {
+					this.hoistModulesInChunks(
+						compilation,
+						depsToTrace,
+						entryExternalsToHoist
+					);
+				}
+			);
+		});
+	}
+
+	/**
+	 * Hoist modules in chunks.
+	 * @param {Compilation} compilation The webpack compilation instance.
+	 * @param {Set<Dependency>} depsToTrace Set of container entry dependencies.
+	 * @param {Set<Dependency>} entryExternalsToHoist Set of container entry dependencies to hoist.
+	 */
+	hoistModulesInChunks(compilation, depsToTrace, entryExternalsToHoist) {
+		const { chunkGraph, moduleGraph } = compilation;
+
+		// loop over entry points
+		for (const dep of entryExternalsToHoist) {
+			const entryModule = moduleGraph.getModule(dep);
+			if (!entryModule) continue;
+			// get all the external module types and hoist them to the runtime chunk, this will get RemoteModule externals
+			const allReferencedModules = getAllReferencedModules(
+				compilation,
+				entryModule,
+				"external",
+				false
+			);
+
+			const containerRuntimes = chunkGraph.getModuleRuntimes(entryModule);
+			/** @type {Set<string>} */
+			const runtimes = new Set();
+
+			for (const runtimeSpec of containerRuntimes) {
+				forEachRuntime(runtimeSpec, (runtimeKey) => {
+					if (runtimeKey) {
+						runtimes.add(runtimeKey);
+					}
+				});
+			}
+
+			for (const runtime of runtimes) {
+				const runtimeChunk = compilation.namedChunks.get(runtime);
+				if (!runtimeChunk) continue;
+
+				for (const module of allReferencedModules) {
+					if (!chunkGraph.isModuleInChunk(module, runtimeChunk)) {
+						chunkGraph.connectChunkAndModule(runtimeChunk, module);
+					}
+				}
+			}
+			this.cleanUpChunks(compilation, allReferencedModules);
+		}
+
+		// handle container entry specifically
+		for (const dep of depsToTrace) {
+			const containerEntryModule = moduleGraph.getModule(dep);
+			if (!containerEntryModule) continue;
+			const allReferencedModules = getAllReferencedModules(
+				compilation,
+				containerEntryModule,
+				"initial",
+				false
+			);
+
+			const allRemoteReferences = getAllReferencedModules(
+				compilation,
+				containerEntryModule,
+				"external",
+				false
+			);
+
+			for (const remote of allRemoteReferences) {
+				allReferencedModules.add(remote);
+			}
+
+			const containerRuntimes =
+				chunkGraph.getModuleRuntimes(containerEntryModule);
+			/** @type {Set<string>} */
+			const runtimes = new Set();
+
+			for (const runtimeSpec of containerRuntimes) {
+				forEachRuntime(runtimeSpec, (runtimeKey) => {
+					if (runtimeKey) {
+						runtimes.add(runtimeKey);
+					}
+				});
+			}
+
+			for (const runtime of runtimes) {
+				const runtimeChunk = compilation.namedChunks.get(runtime);
+				if (!runtimeChunk) continue;
+
+				for (const module of allReferencedModules) {
+					if (!chunkGraph.isModuleInChunk(module, runtimeChunk)) {
+						chunkGraph.connectChunkAndModule(runtimeChunk, module);
+					}
+				}
+			}
+			this.cleanUpChunks(compilation, allReferencedModules);
+		}
+	}
+
+	/**
+	 * Clean up chunks by disconnecting unused modules.
+	 * @param {Compilation} compilation The webpack compilation instance.
+	 * @param {Set<Module>} modules Set of modules to clean up.
+	 */
+	cleanUpChunks(compilation, modules) {
+		const { chunkGraph } = compilation;
+		for (const module of modules) {
+			for (const chunk of chunkGraph.getModuleChunks(module)) {
+				if (!chunk.hasRuntime()) {
+					chunkGraph.disconnectChunkAndModule(chunk, module);
+					if (
+						chunkGraph.getNumberOfChunkModules(chunk) === 0 &&
+						chunkGraph.getNumberOfEntryModules(chunk) === 0
+					) {
+						chunkGraph.disconnectChunk(chunk);
+						compilation.chunks.delete(chunk);
+						if (chunk.name) {
+							compilation.namedChunks.delete(chunk.name);
+						}
+					}
+				}
+			}
+		}
+		modules.clear();
+	}
+}
+
+/**
+ * Helper method to collect all referenced modules recursively.
+ * @param {Compilation} compilation The webpack compilation instance.
+ * @param {Module} module The module to start collecting from.
+ * @param {string} type The type of modules to collect ("initial", "external", or "all").
+ * @param {boolean} includeInitial Should include the referenced module passed
+ * @returns {Set<Module>} Set of collected modules.
+ */
+function getAllReferencedModules(compilation, module, type, includeInitial) {
+	const collectedModules = new Set(includeInitial ? [module] : []);
+	/** @type {WeakSet<Module>} */
+	const visitedModules = new WeakSet([module]);
+	/** @type {Module[]} */
+	const stack = [module];
+
+	while (stack.length > 0) {
+		const currentModule = stack.pop();
+		if (!currentModule) continue;
+
+		const outgoingConnections =
+			compilation.moduleGraph.getOutgoingConnections(currentModule);
+		if (outgoingConnections) {
+			for (const connection of outgoingConnections) {
+				const connectedModule = connection.module;
+
+				// Skip if module has already been visited
+				if (!connectedModule || visitedModules.has(connectedModule)) {
+					continue;
+				}
+
+				// Handle 'initial' type (skipping async blocks)
+				if (type === "initial") {
+					const parentBlock = compilation.moduleGraph.getParentBlock(
+						/** @type {Dependency} */
+						(connection.dependency)
+					);
+					if (parentBlock instanceof AsyncDependenciesBlock) {
+						continue;
+					}
+				}
+
+				// Handle 'external' type (collecting only external modules)
+				if (type === "external") {
+					if (connection.module instanceof ExternalModule) {
+						collectedModules.add(connectedModule);
+					}
+				} else {
+					// Handle 'all' or unspecified types
+					collectedModules.add(connectedModule);
+				}
+
+				// Add connected module to the stack and mark it as visited
+				visitedModules.add(connectedModule);
+				stack.push(connectedModule);
+			}
+		}
+	}
+
+	return collectedModules;
+}
+
+module.exports = HoistContainerReferences;

package/lib/container/ModuleFederationPlugin.js

@@ -0,0 +1,131 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra and Zackary Jackson @ScriptedAlchemy
+*/
+
+"use strict";
+
+const { SyncHook } = require("tapable");
+const isValidExternalsType = require("../../schemas/plugins/container/ExternalsType.check");
+const Compilation = require("../Compilation");
+const SharePlugin = require("../sharing/SharePlugin");
+const createSchemaValidation = require("../util/create-schema-validation");
+const ContainerPlugin = require("./ContainerPlugin");
+const ContainerReferencePlugin = require("./ContainerReferencePlugin");
+const HoistContainerReferences = require("./HoistContainerReferencesPlugin");
+
+/** @typedef {import("../../declarations/plugins/container/ModuleFederationPlugin").ExternalsType} ExternalsType */
+/** @typedef {import("../../declarations/plugins/container/ModuleFederationPlugin").ModuleFederationPluginOptions} ModuleFederationPluginOptions */
+/** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../Dependency")} Dependency */
+
+/**
+ * @typedef {object} CompilationHooks
+ * @property {SyncHook<Dependency>} addContainerEntryDependency
+ * @property {SyncHook<Dependency>} addFederationRuntimeDependency
+ */
+
+const validate = createSchemaValidation(
+	require("../../schemas/plugins/container/ModuleFederationPlugin.check"),
+	() => require("../../schemas/plugins/container/ModuleFederationPlugin.json"),
+	{
+		name: "Module Federation Plugin",
+		baseDataPath: "options"
+	}
+);
+
+/** @type {WeakMap<Compilation, CompilationHooks>} */
+const compilationHooksMap = new WeakMap();
+const PLUGIN_NAME = "ModuleFederationPlugin";
+
+class ModuleFederationPlugin {
+	/**
+	 * @param {ModuleFederationPluginOptions} options options
+	 */
+	constructor(options) {
+		validate(options);
+		/** @type {ModuleFederationPluginOptions} */
+		this._options = options;
+	}
+
+	/**
+	 * Get the compilation hooks associated with this plugin.
+	 * @param {Compilation} compilation The compilation instance.
+	 * @returns {CompilationHooks} The hooks for the compilation.
+	 */
+	static getCompilationHooks(compilation) {
+		if (!(compilation instanceof Compilation)) {
+			throw new TypeError(
+				"The 'compilation' argument must be an instance of Compilation"
+			);
+		}
+		let hooks = compilationHooksMap.get(compilation);
+		if (!hooks) {
+			hooks = {
+				addContainerEntryDependency: new SyncHook(["dependency"]),
+				addFederationRuntimeDependency: new SyncHook(["dependency"])
+			};
+			compilationHooksMap.set(compilation, hooks);
+		}
+		return hooks;
+	}
+
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		const { _options: options } = this;
+		const library = options.library || { type: "var", name: options.name };
+		const remoteType =
+			options.remoteType ||
+			(options.library && isValidExternalsType(options.library.type)
+				? /** @type {ExternalsType} */ (options.library.type)
+				: "script");
+		if (
+			library &&
+			!compiler.options.output.enabledLibraryTypes.includes(library.type)
+		) {
+			compiler.options.output.enabledLibraryTypes.push(library.type);
+		}
+		compiler.hooks.afterPlugins.tap(PLUGIN_NAME, () => {
+			if (
+				options.exposes &&
+				(Array.isArray(options.exposes)
+					? options.exposes.length > 0
+					: Object.keys(options.exposes).length > 0)
+			) {
+				new ContainerPlugin({
+					name: /** @type {string} */ (options.name),
+					library,
+					filename: options.filename,
+					runtime: options.runtime,
+					shareScope: options.shareScope,
+					exposes: options.exposes
+				}).apply(compiler);
+			}
+			if (
+				options.remotes &&
+				(Array.isArray(options.remotes)
+					? options.remotes.length > 0
+					: Object.keys(options.remotes).length > 0)
+			) {
+				new ContainerReferencePlugin({
+					remoteType,
+					shareScope: options.shareScope,
+					remotes: options.remotes
+				}).apply(compiler);
+			}
+			if (options.shared) {
+				new SharePlugin({
+					shared: options.shared,
+					shareScope: options.shareScope
+				}).apply(compiler);
+			}
+			new HoistContainerReferences().apply(compiler);
+		});
+	}
+}
+
+module.exports = ModuleFederationPlugin;