@depup/webpack 5.105.4-depup.37

package/lib/DelegatedModule.js

@@ -0,0 +1,279 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const { OriginalSource, RawSource } = require("webpack-sources");
+const Module = require("./Module");
+const {
+	JAVASCRIPT_TYPE,
+	JAVASCRIPT_TYPES
+} = require("./ModuleSourceTypeConstants");
+const { JAVASCRIPT_MODULE_TYPE_DYNAMIC } = require("./ModuleTypeConstants");
+const RuntimeGlobals = require("./RuntimeGlobals");
+const DelegatedSourceDependency = require("./dependencies/DelegatedSourceDependency");
+const StaticExportsDependency = require("./dependencies/StaticExportsDependency");
+const makeSerializable = require("./util/makeSerializable");
+
+/** @typedef {import("../declarations/plugins/DllReferencePlugin").DllReferencePluginOptions} DllReferencePluginOptions */
+/** @typedef {import("./config/defaults").WebpackOptionsNormalizedWithDefaults} WebpackOptions */
+/** @typedef {import("./Compilation")} Compilation */
+/** @typedef {import("./Dependency").UpdateHashContext} UpdateHashContext */
+/** @typedef {import("./Generator").SourceTypes} SourceTypes */
+/** @typedef {import("./LibManifestPlugin").ManifestModuleData} ManifestModuleData */
+/** @typedef {import("./Module").ModuleId} ModuleId */
+/** @typedef {import("./Module").BuildCallback} BuildCallback */
+/** @typedef {import("./Module").BuildMeta} BuildMeta */
+/** @typedef {import("./Module").CodeGenerationContext} CodeGenerationContext */
+/** @typedef {import("./Module").CodeGenerationResult} CodeGenerationResult */
+/** @typedef {import("./Module").LibIdentOptions} LibIdentOptions */
+/** @typedef {import("./Module").LibIdent} LibIdent */
+/** @typedef {import("./Module").NeedBuildCallback} NeedBuildCallback */
+/** @typedef {import("./Module").NeedBuildContext} NeedBuildContext */
+/** @typedef {import("./Module").Sources} Sources */
+/** @typedef {import("./Module").RuntimeRequirements} RuntimeRequirements */
+/** @typedef {import("./RequestShortener")} RequestShortener */
+/** @typedef {import("./ResolverFactory").ResolverWithOptions} ResolverWithOptions */
+/** @typedef {import("./serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
+/** @typedef {import("./serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+/** @typedef {import("./dependencies/StaticExportsDependency").Exports} Exports */
+/** @typedef {import("./util/Hash")} Hash */
+/** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
+
+/** @typedef {string} DelegatedModuleSourceRequest */
+
+/** @typedef {NonNullable<DllReferencePluginOptions["type"]>} DelegatedModuleType */
+
+/**
+ * @typedef {object} DelegatedModuleData
+ * @property {BuildMeta=} buildMeta build meta
+ * @property {Exports=} exports exports
+ * @property {ModuleId} id module id
+ */
+
+const RUNTIME_REQUIREMENTS = new Set([
+	RuntimeGlobals.module,
+	RuntimeGlobals.require
+]);
+
+class DelegatedModule extends Module {
+	/**
+	 * @param {DelegatedModuleSourceRequest} sourceRequest source request
+	 * @param {DelegatedModuleData} data data
+	 * @param {DelegatedModuleType} type type
+	 * @param {string} userRequest user request
+	 * @param {string | Module} originalRequest original request
+	 */
+	constructor(sourceRequest, data, type, userRequest, originalRequest) {
+		super(JAVASCRIPT_MODULE_TYPE_DYNAMIC, null);
+
+		// Info from Factory
+		this.sourceRequest = sourceRequest;
+		this.request = data.id;
+		this.delegationType = type;
+		this.userRequest = userRequest;
+		this.originalRequest = originalRequest;
+		this.delegateData = data;
+
+		// Build info
+		/** @type {undefined | DelegatedSourceDependency} */
+		this.delegatedSourceDependency = undefined;
+	}
+
+	/**
+	 * @returns {SourceTypes} types available (do not mutate)
+	 */
+	getSourceTypes() {
+		return JAVASCRIPT_TYPES;
+	}
+
+	/**
+	 * @param {LibIdentOptions} options options
+	 * @returns {LibIdent | null} an identifier for library inclusion
+	 */
+	libIdent(options) {
+		return typeof this.originalRequest === "string"
+			? this.originalRequest
+			: this.originalRequest.libIdent(options);
+	}
+
+	/**
+	 * @returns {string} a unique identifier of the module
+	 */
+	identifier() {
+		return `delegated ${JSON.stringify(this.request)} from ${
+			this.sourceRequest
+		}`;
+	}
+
+	/**
+	 * @param {RequestShortener} requestShortener the request shortener
+	 * @returns {string} a user readable identifier of the module
+	 */
+	readableIdentifier(requestShortener) {
+		return `delegated ${this.userRequest} from ${this.sourceRequest}`;
+	}
+
+	/**
+	 * @param {NeedBuildContext} context context info
+	 * @param {NeedBuildCallback} callback callback function, returns true, if the module needs a rebuild
+	 * @returns {void}
+	 */
+	needBuild(context, callback) {
+		return callback(null, !this.buildMeta);
+	}
+
+	/**
+	 * @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) {
+		const delegateData = /** @type {ManifestModuleData} */ (this.delegateData);
+		this.buildMeta = { ...delegateData.buildMeta };
+		this.buildInfo = {};
+		this.dependencies.length = 0;
+		this.delegatedSourceDependency = new DelegatedSourceDependency(
+			this.sourceRequest
+		);
+		this.addDependency(this.delegatedSourceDependency);
+		this.addDependency(
+			new StaticExportsDependency(delegateData.exports || true, false)
+		);
+		callback();
+	}
+
+	/**
+	 * @param {CodeGenerationContext} context context for code generation
+	 * @returns {CodeGenerationResult} result
+	 */
+	codeGeneration({ runtimeTemplate, moduleGraph, chunkGraph }) {
+		const dep = /** @type {DelegatedSourceDependency} */ (this.dependencies[0]);
+		const sourceModule = moduleGraph.getModule(dep);
+		/** @type {string} */
+		let str;
+
+		if (!sourceModule) {
+			str = runtimeTemplate.throwMissingModuleErrorBlock({
+				request: this.sourceRequest
+			});
+		} else {
+			str = `module.exports = (${runtimeTemplate.moduleExports({
+				module: sourceModule,
+				chunkGraph,
+				request: dep.request,
+				/** @type {RuntimeRequirements} */
+				runtimeRequirements: new Set()
+			})})`;
+
+			switch (this.delegationType) {
+				case "require":
+					str += `(${JSON.stringify(this.request)})`;
+					break;
+				case "object":
+					str += `[${JSON.stringify(this.request)}]`;
+					break;
+			}
+
+			str += ";";
+		}
+
+		/** @type {Sources} */
+		const sources = new Map();
+		if (this.useSourceMap || this.useSimpleSourceMap) {
+			sources.set(JAVASCRIPT_TYPE, new OriginalSource(str, this.identifier()));
+		} else {
+			sources.set(JAVASCRIPT_TYPE, new RawSource(str));
+		}
+
+		return {
+			sources,
+			runtimeRequirements: RUNTIME_REQUIREMENTS
+		};
+	}
+
+	/**
+	 * @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 42;
+	}
+
+	/**
+	 * @param {Hash} hash the hash used to track dependencies
+	 * @param {UpdateHashContext} context context
+	 * @returns {void}
+	 */
+	updateHash(hash, context) {
+		hash.update(this.delegationType);
+		hash.update(JSON.stringify(this.request));
+		super.updateHash(hash, context);
+	}
+
+	/**
+	 * @param {ObjectSerializerContext} context context
+	 */
+	serialize(context) {
+		const { write } = context;
+		// constructor
+		write(this.sourceRequest);
+		write(this.delegateData);
+		write(this.delegationType);
+		write(this.userRequest);
+		write(this.originalRequest);
+		super.serialize(context);
+	}
+
+	/**
+	 * @param {ObjectDeserializerContext} context context\
+	 * @returns {DelegatedModule} DelegatedModule
+	 */
+	static deserialize(context) {
+		const { read } = context;
+		const obj = new DelegatedModule(
+			read(), // sourceRequest
+			read(), // delegateData
+			read(), // delegationType
+			read(), // userRequest
+			read() // originalRequest
+		);
+		obj.deserialize(context);
+		return obj;
+	}
+
+	/**
+	 * Assuming this module is in the cache. Update the (cached) module with
+	 * the fresh module from the factory. Usually updates internal references
+	 * and properties.
+	 * @param {Module} module fresh module
+	 * @returns {void}
+	 */
+	updateCacheModule(module) {
+		super.updateCacheModule(module);
+		const m = /** @type {DelegatedModule} */ (module);
+		this.delegationType = m.delegationType;
+		this.userRequest = m.userRequest;
+		this.originalRequest = m.originalRequest;
+		this.delegateData = m.delegateData;
+	}
+
+	/**
+	 * Assuming this module is in the cache. Remove internal references to allow freeing some memory.
+	 */
+	cleanupForCache() {
+		super.cleanupForCache();
+		this.delegateData =
+			/** @type {EXPECTED_ANY} */
+			(undefined);
+	}
+}
+
+makeSerializable(DelegatedModule, "webpack/lib/DelegatedModule");
+
+module.exports = DelegatedModule;

package/lib/DelegatedModuleFactoryPlugin.js

@@ -0,0 +1,116 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const DelegatedModule = require("./DelegatedModule");
+
+/** @typedef {import("../declarations/plugins/DllReferencePlugin").DllReferencePluginOptions} DllReferencePluginOptions */
+/** @typedef {import("../declarations/plugins/DllReferencePlugin").DllReferencePluginOptionsContent} DllReferencePluginOptionsContent */
+/** @typedef {import("./DelegatedModule").DelegatedModuleData} DelegatedModuleData */
+/** @typedef {import("./DelegatedModule").DelegatedModuleSourceRequest} DelegatedModuleSourceRequest */
+/** @typedef {import("./DelegatedModule").DelegatedModuleType} DelegatedModuleType */
+/** @typedef {import("./NormalModuleFactory")} NormalModuleFactory */
+/** @typedef {import("./util/identifier").AssociatedObjectForCache} AssociatedObjectForCache */
+
+/**
+ * @typedef {object} Options
+ * @property {DelegatedModuleSourceRequest} source source
+ * @property {NonNullable<DllReferencePluginOptions["context"]>} context absolute context path to which lib ident is relative to
+ * @property {DllReferencePluginOptionsContent} content content
+ * @property {DllReferencePluginOptions["type"]} type type
+ * @property {DllReferencePluginOptions["extensions"]} extensions extensions
+ * @property {DllReferencePluginOptions["scope"]} scope scope
+ * @property {AssociatedObjectForCache=} associatedObjectForCache object for caching
+ */
+
+const PLUGIN_NAME = "DelegatedModuleFactoryPlugin";
+
+class DelegatedModuleFactoryPlugin {
+	/**
+	 * @param {Options} options options
+	 */
+	constructor(options) {
+		this.options = options;
+		options.type = options.type || "require";
+		options.extensions = options.extensions || ["", ".js", ".json", ".wasm"];
+	}
+
+	/**
+	 * @param {NormalModuleFactory} normalModuleFactory the normal module factory
+	 * @returns {void}
+	 */
+	apply(normalModuleFactory) {
+		const scope = this.options.scope;
+		if (scope) {
+			normalModuleFactory.hooks.factorize.tapAsync(
+				PLUGIN_NAME,
+				(data, callback) => {
+					const [dependency] = data.dependencies;
+					const { request } = dependency;
+					if (request && request.startsWith(`${scope}/`)) {
+						const innerRequest = `.${request.slice(scope.length)}`;
+						/** @type {undefined | DelegatedModuleData} */
+						let resolved;
+						if (innerRequest in this.options.content) {
+							resolved = this.options.content[innerRequest];
+							return callback(
+								null,
+								new DelegatedModule(
+									this.options.source,
+									resolved,
+									/** @type {DelegatedModuleType} */
+									(this.options.type),
+									innerRequest,
+									request
+								)
+							);
+						}
+						const extensions =
+							/** @type {string[]} */
+							(this.options.extensions);
+						for (let i = 0; i < extensions.length; i++) {
+							const extension = extensions[i];
+							const requestPlusExt = innerRequest + extension;
+							if (requestPlusExt in this.options.content) {
+								resolved = this.options.content[requestPlusExt];
+								return callback(
+									null,
+									new DelegatedModule(
+										this.options.source,
+										resolved,
+										/** @type {DelegatedModuleType} */
+										(this.options.type),
+										requestPlusExt,
+										request + extension
+									)
+								);
+							}
+						}
+					}
+					return callback();
+				}
+			);
+		} else {
+			normalModuleFactory.hooks.module.tap(PLUGIN_NAME, (module) => {
+				const request = module.libIdent(this.options);
+				if (request && request in this.options.content) {
+					const resolved = this.options.content[request];
+					return new DelegatedModule(
+						this.options.source,
+						resolved,
+						/** @type {DelegatedModuleType} */
+						(this.options.type),
+						request,
+						module
+					);
+				}
+				return module;
+			});
+		}
+	}
+}
+
+module.exports = DelegatedModuleFactoryPlugin;

package/lib/DelegatedPlugin.js

@@ -0,0 +1,49 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const DelegatedModuleFactoryPlugin = require("./DelegatedModuleFactoryPlugin");
+const DelegatedSourceDependency = require("./dependencies/DelegatedSourceDependency");
+
+/** @typedef {import("./Compiler")} Compiler */
+/** @typedef {import("./DelegatedModuleFactoryPlugin").Options} Options */
+
+const PLUGIN_NAME = "DelegatedPlugin";
+
+class DelegatedPlugin {
+	/**
+	 * @param {Options} options options
+	 */
+	constructor(options) {
+		this.options = options;
+	}
+
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		compiler.hooks.compilation.tap(
+			PLUGIN_NAME,
+			(compilation, { normalModuleFactory }) => {
+				compilation.dependencyFactories.set(
+					DelegatedSourceDependency,
+					normalModuleFactory
+				);
+			}
+		);
+
+		compiler.hooks.compile.tap(PLUGIN_NAME, ({ normalModuleFactory }) => {
+			new DelegatedModuleFactoryPlugin({
+				associatedObjectForCache: compiler.root,
+				...this.options
+			}).apply(normalModuleFactory);
+		});
+	}
+}
+
+module.exports = DelegatedPlugin;

package/lib/DependenciesBlock.js

@@ -0,0 +1,120 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const makeSerializable = require("./util/makeSerializable");
+
+/** @typedef {import("./AsyncDependenciesBlock")} AsyncDependenciesBlock */
+/** @typedef {import("./Dependency")} Dependency */
+/** @typedef {import("./Dependency").UpdateHashContext} UpdateHashContext */
+/** @typedef {import("./serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
+/** @typedef {import("./serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+/** @typedef {import("./util/Hash")} Hash */
+
+/** @typedef {(d: Dependency) => boolean} DependencyFilterFunction */
+
+/**
+ * DependenciesBlock is the base class for all Module classes in webpack. It describes a
+ * "block" of dependencies which are pointers to other DependenciesBlock instances. For example
+ * when a Module has a CommonJs require statement, the DependencyBlock for the CommonJs module
+ * would be added as a dependency to the Module. DependenciesBlock is inherited by two types of classes:
+ * Module subclasses and AsyncDependenciesBlock subclasses. The only difference between the two is that
+ * AsyncDependenciesBlock subclasses are used for code-splitting (async boundary) and Module subclasses are not.
+ */
+class DependenciesBlock {
+	constructor() {
+		/** @type {Dependency[]} */
+		this.dependencies = [];
+		/** @type {AsyncDependenciesBlock[]} */
+		this.blocks = [];
+		/** @type {DependenciesBlock | undefined} */
+		this.parent = undefined;
+	}
+
+	getRootBlock() {
+		/** @type {DependenciesBlock} */
+		let current = this;
+		while (current.parent) current = current.parent;
+		return current;
+	}
+
+	/**
+	 * Adds a DependencyBlock to DependencyBlock relationship.
+	 * This is used for when a Module has a AsyncDependencyBlock tie (for code-splitting)
+	 * @param {AsyncDependenciesBlock} block block being added
+	 * @returns {void}
+	 */
+	addBlock(block) {
+		this.blocks.push(block);
+		block.parent = this;
+	}
+
+	/**
+	 * @param {Dependency} dependency dependency being tied to block.
+	 * This is an "edge" pointing to another "node" on module graph.
+	 * @returns {void}
+	 */
+	addDependency(dependency) {
+		this.dependencies.push(dependency);
+	}
+
+	/**
+	 * @param {Dependency} dependency dependency being removed
+	 * @returns {void}
+	 */
+	removeDependency(dependency) {
+		const idx = this.dependencies.indexOf(dependency);
+		if (idx >= 0) {
+			this.dependencies.splice(idx, 1);
+		}
+	}
+
+	/**
+	 * Removes all dependencies and blocks
+	 * @returns {void}
+	 */
+	clearDependenciesAndBlocks() {
+		this.dependencies.length = 0;
+		this.blocks.length = 0;
+	}
+
+	/**
+	 * @param {Hash} hash the hash used to track dependencies
+	 * @param {UpdateHashContext} context context
+	 * @returns {void}
+	 */
+	updateHash(hash, context) {
+		for (const dep of this.dependencies) {
+			dep.updateHash(hash, context);
+		}
+		for (const block of this.blocks) {
+			block.updateHash(hash, context);
+		}
+	}
+
+	/**
+	 * @param {ObjectSerializerContext} context context
+	 */
+	serialize({ write }) {
+		write(this.dependencies);
+		write(this.blocks);
+	}
+
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 */
+	deserialize({ read }) {
+		this.dependencies = read();
+		this.blocks = read();
+		for (const block of this.blocks) {
+			block.parent = this;
+		}
+	}
+}
+
+makeSerializable(DependenciesBlock, "webpack/lib/DependenciesBlock");
+
+module.exports = DependenciesBlock;