@eriche/webpack 4.47.0

package/lib/DelegatedModule.js

@@ -0,0 +1,114 @@
+/*
+	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 WebpackMissingModule = require("./dependencies/WebpackMissingModule");
+const DelegatedSourceDependency = require("./dependencies/DelegatedSourceDependency");
+const DelegatedExportsDependency = require("./dependencies/DelegatedExportsDependency");
+
+/** @typedef {import("./dependencies/ModuleDependency")} ModuleDependency */
+/** @typedef {import("./util/createHash").Hash} Hash */
+
+class DelegatedModule extends Module {
+	constructor(sourceRequest, data, type, userRequest, originalRequest) {
+		super("javascript/dynamic", null);
+
+		// Info from Factory
+		this.sourceRequest = sourceRequest;
+		this.request = data.id;
+		this.type = type;
+		this.userRequest = userRequest;
+		this.originalRequest = originalRequest;
+		this.delegateData = data;
+
+		// Build info
+		this.delegatedSourceDependency = undefined;
+	}
+
+	libIdent(options) {
+		return typeof this.originalRequest === "string"
+			? this.originalRequest
+			: this.originalRequest.libIdent(options);
+	}
+
+	identifier() {
+		return `delegated ${JSON.stringify(this.request)} from ${
+			this.sourceRequest
+		}`;
+	}
+
+	readableIdentifier() {
+		return `delegated ${this.userRequest} from ${this.sourceRequest}`;
+	}
+
+	needRebuild() {
+		return false;
+	}
+
+	build(options, compilation, resolver, fs, callback) {
+		this.built = true;
+		this.buildMeta = Object.assign({}, this.delegateData.buildMeta);
+		this.buildInfo = {};
+		this.delegatedSourceDependency = new DelegatedSourceDependency(
+			this.sourceRequest
+		);
+		this.addDependency(this.delegatedSourceDependency);
+		this.addDependency(
+			new DelegatedExportsDependency(this, this.delegateData.exports || true)
+		);
+		callback();
+	}
+
+	source(depTemplates, runtime) {
+		const dep = /** @type {DelegatedSourceDependency} */ (this.dependencies[0]);
+		const sourceModule = dep.module;
+		let str;
+
+		if (!sourceModule) {
+			str = WebpackMissingModule.moduleCode(this.sourceRequest);
+		} else {
+			str = `module.exports = (${runtime.moduleExports({
+				module: sourceModule,
+				request: dep.request
+			})})`;
+
+			switch (this.type) {
+				case "require":
+					str += `(${JSON.stringify(this.request)})`;
+					break;
+				case "object":
+					str += `[${JSON.stringify(this.request)}]`;
+					break;
+			}
+
+			str += ";";
+		}
+
+		if (this.useSourceMap) {
+			return new OriginalSource(str, this.identifier());
+		} else {
+			return new RawSource(str);
+		}
+	}
+
+	size() {
+		return 42;
+	}
+
+	/**
+	 * @param {Hash} hash the hash used to track dependencies
+	 * @returns {void}
+	 */
+	updateHash(hash) {
+		hash.update(this.type);
+		hash.update(JSON.stringify(this.request));
+		super.updateHash(hash);
+	}
+}
+
+module.exports = DelegatedModule;

package/lib/DelegatedModuleFactoryPlugin.js

@@ -0,0 +1,95 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+
+const DelegatedModule = require("./DelegatedModule");
+
+// options.source
+// options.type
+// options.context
+// options.scope
+// options.content
+class DelegatedModuleFactoryPlugin {
+	constructor(options) {
+		this.options = options;
+		options.type = options.type || "require";
+		options.extensions = options.extensions || [
+			"",
+			".wasm",
+			".mjs",
+			".js",
+			".json"
+		];
+	}
+
+	apply(normalModuleFactory) {
+		const scope = this.options.scope;
+		if (scope) {
+			normalModuleFactory.hooks.factory.tap(
+				"DelegatedModuleFactoryPlugin",
+				factory => (data, callback) => {
+					const dependency = data.dependencies[0];
+					const request = dependency.request;
+					if (request && request.indexOf(scope + "/") === 0) {
+						const innerRequest = "." + request.substr(scope.length);
+						let resolved;
+						if (innerRequest in this.options.content) {
+							resolved = this.options.content[innerRequest];
+							return callback(
+								null,
+								new DelegatedModule(
+									this.options.source,
+									resolved,
+									this.options.type,
+									innerRequest,
+									request
+								)
+							);
+						}
+						for (let i = 0; i < this.options.extensions.length; i++) {
+							const extension = this.options.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,
+										this.options.type,
+										requestPlusExt,
+										request + extension
+									)
+								);
+							}
+						}
+					}
+					return factory(data, callback);
+				}
+			);
+		} else {
+			normalModuleFactory.hooks.module.tap(
+				"DelegatedModuleFactoryPlugin",
+				module => {
+					if (module.libIdent) {
+						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,
+								this.options.type,
+								request,
+								module
+							);
+						}
+					}
+					return module;
+				}
+			);
+		}
+	}
+}
+module.exports = DelegatedModuleFactoryPlugin;

package/lib/DelegatedPlugin.js

@@ -0,0 +1,39 @@
+/*
+	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");
+const DelegatedExportsDependency = require("./dependencies/DelegatedExportsDependency");
+const NullFactory = require("./NullFactory");
+
+class DelegatedPlugin {
+	constructor(options) {
+		this.options = options;
+	}
+
+	apply(compiler) {
+		compiler.hooks.compilation.tap(
+			"DelegatedPlugin",
+			(compilation, { normalModuleFactory }) => {
+				compilation.dependencyFactories.set(
+					DelegatedSourceDependency,
+					normalModuleFactory
+				);
+				compilation.dependencyFactories.set(
+					DelegatedExportsDependency,
+					new NullFactory()
+				);
+			}
+		);
+
+		compiler.hooks.compile.tap("DelegatedPlugin", ({ normalModuleFactory }) => {
+			new DelegatedModuleFactoryPlugin(this.options).apply(normalModuleFactory);
+		});
+	}
+}
+
+module.exports = DelegatedPlugin;

package/lib/DependenciesBlock.js

@@ -0,0 +1,124 @@
+/*
+ MIT License http://www.opensource.org/licenses/mit-license.php
+ Author Tobias Koppers @sokra
+ */
+"use strict";
+
+const DependenciesBlockVariable = require("./DependenciesBlockVariable");
+
+/** @typedef {import("./ChunkGroup")} ChunkGroup */
+/** @typedef {import("./Dependency")} Dependency */
+/** @typedef {import("./AsyncDependenciesBlock")} AsyncDependenciesBlock */
+/** @typedef {import("./DependenciesBlockVariable")} DependenciesBlockVariable */
+/** @typedef {(d: Dependency) => boolean} DependencyFilterFunction */
+/** @typedef {import("./util/createHash").Hash} Hash */
+
+class DependenciesBlock {
+	constructor() {
+		/** @type {Dependency[]} */
+		this.dependencies = [];
+		/** @type {AsyncDependenciesBlock[]} */
+		this.blocks = [];
+		/** @type {DependenciesBlockVariable[]} */
+		this.variables = [];
+	}
+
+	/**
+	 * 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 {string} name name of dependency
+	 * @param {string} expression expression string for variable
+	 * @param {Dependency[]} dependencies dependency instances tied to variable
+	 * @returns {void}
+	 */
+	addVariable(name, expression, dependencies) {
+		for (let v of this.variables) {
+			if (v.name === name && v.expression === expression) {
+				return;
+			}
+		}
+		this.variables.push(
+			new DependenciesBlockVariable(name, expression, dependencies)
+		);
+	}
+
+	/**
+	 * @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);
+		}
+	}
+
+	/**
+	 * @param {Hash} hash the hash used to track dependencies
+	 * @returns {void}
+	 */
+	updateHash(hash) {
+		for (const dep of this.dependencies) dep.updateHash(hash);
+		for (const block of this.blocks) block.updateHash(hash);
+		for (const variable of this.variables) variable.updateHash(hash);
+	}
+
+	disconnect() {
+		for (const dep of this.dependencies) dep.disconnect();
+		for (const block of this.blocks) block.disconnect();
+		for (const variable of this.variables) variable.disconnect();
+	}
+
+	unseal() {
+		for (const block of this.blocks) block.unseal();
+	}
+
+	/**
+	 * @param {DependencyFilterFunction} filter filter function for dependencies, gets passed all dependency ties from current instance
+	 * @returns {boolean} returns boolean for filter
+	 */
+	hasDependencies(filter) {
+		if (filter) {
+			for (const dep of this.dependencies) {
+				if (filter(dep)) return true;
+			}
+		} else {
+			if (this.dependencies.length > 0) {
+				return true;
+			}
+		}
+
+		for (const block of this.blocks) {
+			if (block.hasDependencies(filter)) return true;
+		}
+		for (const variable of this.variables) {
+			if (variable.hasDependencies(filter)) return true;
+		}
+		return false;
+	}
+
+	sortItems() {
+		for (const block of this.blocks) block.sortItems();
+	}
+}
+
+module.exports = DependenciesBlock;

package/lib/DependenciesBlockVariable.js

@@ -0,0 +1,72 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+
+const { RawSource, ReplaceSource } = require("webpack-sources");
+
+/** @typedef {import("./Dependency")} Dependency */
+/** @typedef {import("./Dependency").DependencyTemplate} DependencyTemplate */
+/** @typedef {import("./RuntimeTemplate")} RuntimeTemplate */
+/** @typedef {import("./util/createHash").Hash} Hash */
+/** @typedef {(d: Dependency) => boolean} DependencyFilterFunction */
+/** @typedef {Map<Function, DependencyTemplate>} DependencyTemplates */
+
+class DependenciesBlockVariable {
+	/**
+	 * Creates an instance of DependenciesBlockVariable.
+	 * @param {string} name name of DependenciesBlockVariable
+	 * @param {string} expression expression string
+	 * @param {Dependency[]=} dependencies dependencies tied to this varaiable
+	 */
+	constructor(name, expression, dependencies) {
+		this.name = name;
+		this.expression = expression;
+		this.dependencies = dependencies || [];
+	}
+
+	/**
+	 * @param {Hash} hash hash for instance to update
+	 * @returns {void}
+	 */
+	updateHash(hash) {
+		hash.update(this.name);
+		hash.update(this.expression);
+		for (const d of this.dependencies) {
+			d.updateHash(hash);
+		}
+	}
+
+	/**
+	 * @param {DependencyTemplates} dependencyTemplates Dependency constructors and templates Map.
+	 * @param {RuntimeTemplate} runtimeTemplate runtimeTemplate to generate expression souce
+	 * @returns {ReplaceSource} returns constructed source for expression via templates
+	 */
+	expressionSource(dependencyTemplates, runtimeTemplate) {
+		const source = new ReplaceSource(new RawSource(this.expression));
+		for (const dep of this.dependencies) {
+			const template = dependencyTemplates.get(dep.constructor);
+			if (!template) {
+				throw new Error(`No template for dependency: ${dep.constructor.name}`);
+			}
+			template.apply(dep, source, runtimeTemplate, dependencyTemplates);
+		}
+		return source;
+	}
+
+	disconnect() {
+		for (const d of this.dependencies) {
+			d.disconnect();
+		}
+	}
+
+	hasDependencies(filter) {
+		if (filter) {
+			return this.dependencies.some(filter);
+		}
+		return this.dependencies.length > 0;
+	}
+}
+
+module.exports = DependenciesBlockVariable;

package/lib/Dependency.js

@@ -0,0 +1,89 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+
+const util = require("util");
+const compareLocations = require("./compareLocations");
+const DependencyReference = require("./dependencies/DependencyReference");
+
+/** @typedef {import("./Module")} Module */
+/** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("./RuntimeTemplate")} RuntimeTemplate */
+
+/**
+ * @typedef {Object} DependencyTemplate
+ * @property {function(Dependency, Source, RuntimeTemplate, Map<Function, DependencyTemplate>): void} apply
+ */
+
+/** @typedef {Object} SourcePosition
+ *  @property {number} line
+ *  @property {number=} column
+ */
+
+/** @typedef {Object} RealDependencyLocation
+ *  @property {SourcePosition} start
+ *  @property {SourcePosition=} end
+ *  @property {number=} index
+ */
+
+/** @typedef {Object} SynteticDependencyLocation
+ *  @property {string} name
+ *  @property {number=} index
+ */
+
+/** @typedef {SynteticDependencyLocation|RealDependencyLocation} DependencyLocation */
+
+class Dependency {
+	constructor() {
+		/** @type {Module|null} */
+		this.module = null;
+		// TODO remove in webpack 5
+		/** @type {boolean} */
+		this.weak = false;
+		/** @type {boolean} */
+		this.optional = false;
+		/** @type {DependencyLocation} */
+		this.loc = undefined;
+	}
+
+	getResourceIdentifier() {
+		return null;
+	}
+
+	// Returns the referenced module and export
+	getReference() {
+		if (!this.module) return null;
+		return new DependencyReference(this.module, true, this.weak);
+	}
+
+	// Returns the exported names
+	getExports() {
+		return null;
+	}
+
+	getWarnings() {
+		return null;
+	}
+
+	getErrors() {
+		return null;
+	}
+
+	updateHash(hash) {
+		hash.update((this.module && this.module.id) + "");
+	}
+
+	disconnect() {
+		this.module = null;
+	}
+}
+
+// TODO remove in webpack 5
+Dependency.compare = util.deprecate(
+	(a, b) => compareLocations(a.loc, b.loc),
+	"Dependency.compare is deprecated and will be removed in the next major version"
+);
+
+module.exports = Dependency;

package/lib/DllEntryPlugin.js

@@ -0,0 +1,54 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+
+const DllEntryDependency = require("./dependencies/DllEntryDependency");
+const SingleEntryDependency = require("./dependencies/SingleEntryDependency");
+const DllModuleFactory = require("./DllModuleFactory");
+
+class DllEntryPlugin {
+	constructor(context, entries, name) {
+		this.context = context;
+		this.entries = entries;
+		this.name = name;
+	}
+
+	apply(compiler) {
+		compiler.hooks.compilation.tap(
+			"DllEntryPlugin",
+			(compilation, { normalModuleFactory }) => {
+				const dllModuleFactory = new DllModuleFactory();
+				compilation.dependencyFactories.set(
+					DllEntryDependency,
+					dllModuleFactory
+				);
+				compilation.dependencyFactories.set(
+					SingleEntryDependency,
+					normalModuleFactory
+				);
+			}
+		);
+		compiler.hooks.make.tapAsync("DllEntryPlugin", (compilation, callback) => {
+			compilation.addEntry(
+				this.context,
+				new DllEntryDependency(
+					this.entries.map((e, idx) => {
+						const dep = new SingleEntryDependency(e);
+						dep.loc = {
+							name: this.name,
+							index: idx
+						};
+						return dep;
+					}),
+					this.name
+				),
+				this.name,
+				callback
+			);
+		});
+	}
+}
+
+module.exports = DllEntryPlugin;

package/lib/DllModule.js

@@ -0,0 +1,60 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+	*/
+"use strict";
+
+const { RawSource } = require("webpack-sources");
+const Module = require("./Module");
+
+/** @typedef {import("./util/createHash").Hash} Hash */
+
+class DllModule extends Module {
+	constructor(context, dependencies, name, type) {
+		super("javascript/dynamic", context);
+
+		// Info from Factory
+		this.dependencies = dependencies;
+		this.name = name;
+		this.type = type;
+	}
+
+	identifier() {
+		return `dll ${this.name}`;
+	}
+
+	readableIdentifier() {
+		return `dll ${this.name}`;
+	}
+
+	build(options, compilation, resolver, fs, callback) {
+		this.built = true;
+		this.buildMeta = {};
+		this.buildInfo = {};
+		return callback();
+	}
+
+	source() {
+		return new RawSource("module.exports = __webpack_require__;");
+	}
+
+	needRebuild() {
+		return false;
+	}
+
+	size() {
+		return 12;
+	}
+
+	/**
+	 * @param {Hash} hash the hash used to track dependencies
+	 * @returns {void}
+	 */
+	updateHash(hash) {
+		hash.update("dll module");
+		hash.update(this.name || "");
+		super.updateHash(hash);
+	}
+}
+
+module.exports = DllModule;

package/lib/DllModuleFactory.js

@@ -0,0 +1,29 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+
+const { Tapable } = require("tapable");
+const DllModule = require("./DllModule");
+
+class DllModuleFactory extends Tapable {
+	constructor() {
+		super();
+		this.hooks = {};
+	}
+	create(data, callback) {
+		const dependency = data.dependencies[0];
+		callback(
+			null,
+			new DllModule(
+				data.context,
+				dependency.dependencies,
+				dependency.name,
+				dependency.type
+			)
+		);
+	}
+}
+
+module.exports = DllModuleFactory;