@eriche/webpack 4.47.0

package/lib/dependencies/LoaderPlugin.js

@@ -0,0 +1,115 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+
+const LoaderDependency = require("./LoaderDependency");
+const NormalModule = require("../NormalModule");
+
+/** @typedef {import("../Module")} Module */
+
+/**
+ * @callback LoadModuleCallback
+ * @param {Error=} err error object
+ * @param {string=} source source code
+ * @param {object=} map source map
+ * @param {Module=} module loaded module if successful
+ */
+
+class LoaderPlugin {
+	apply(compiler) {
+		compiler.hooks.compilation.tap(
+			"LoaderPlugin",
+			(compilation, { normalModuleFactory }) => {
+				compilation.dependencyFactories.set(
+					LoaderDependency,
+					normalModuleFactory
+				);
+			}
+		);
+
+		compiler.hooks.compilation.tap("LoaderPlugin", compilation => {
+			compilation.hooks.normalModuleLoader.tap(
+				"LoaderPlugin",
+				(loaderContext, module) => {
+					/**
+					 * @param {string} request the request string to load the module from
+					 * @param {LoadModuleCallback} callback callback returning the loaded module or error
+					 * @returns {void}
+					 */
+					loaderContext.loadModule = (request, callback) => {
+						const dep = new LoaderDependency(request);
+						dep.loc = {
+							name: request
+						};
+						const factory = compilation.dependencyFactories.get(
+							dep.constructor
+						);
+						if (factory === undefined) {
+							return callback(
+								new Error(
+									`No module factory available for dependency type: ${dep.constructor.name}`
+								)
+							);
+						}
+						compilation.semaphore.release();
+						compilation.addModuleDependencies(
+							module,
+							[
+								{
+									factory,
+									dependencies: [dep]
+								}
+							],
+							true,
+							"lm",
+							true,
+							err => {
+								compilation.semaphore.acquire(() => {
+									if (err) {
+										return callback(err);
+									}
+									if (!dep.module) {
+										return callback(new Error("Cannot load the module"));
+									}
+									// TODO consider removing this in webpack 5
+									if (dep.module instanceof NormalModule && dep.module.error) {
+										return callback(dep.module.error);
+									}
+									if (!dep.module._source) {
+										throw new Error(
+											"The module created for a LoaderDependency must have a property _source"
+										);
+									}
+									let source, map;
+									const moduleSource = dep.module._source;
+									if (moduleSource.sourceAndMap) {
+										const sourceAndMap = moduleSource.sourceAndMap();
+										map = sourceAndMap.map;
+										source = sourceAndMap.source;
+									} else {
+										map = moduleSource.map();
+										source = moduleSource.source();
+									}
+									if (dep.module.buildInfo.fileDependencies) {
+										for (const d of dep.module.buildInfo.fileDependencies) {
+											loaderContext.addDependency(d);
+										}
+									}
+									if (dep.module.buildInfo.contextDependencies) {
+										for (const d of dep.module.buildInfo.contextDependencies) {
+											loaderContext.addContextDependency(d);
+										}
+									}
+									return callback(null, source, map, dep.module);
+								});
+							}
+						);
+					};
+				}
+			);
+		});
+	}
+}
+module.exports = LoaderPlugin;

package/lib/dependencies/LocalModule.js

@@ -0,0 +1,23 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+
+class LocalModule {
+	constructor(module, name, idx) {
+		this.module = module;
+		this.name = name;
+		this.idx = idx;
+		this.used = false;
+	}
+
+	flagUsed() {
+		this.used = true;
+	}
+
+	variableName() {
+		return "__WEBPACK_LOCAL_MODULE_" + this.idx + "__";
+	}
+}
+module.exports = LocalModule;

package/lib/dependencies/LocalModuleDependency.js

@@ -0,0 +1,28 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+const NullDependency = require("./NullDependency");
+
+class LocalModuleDependency extends NullDependency {
+	constructor(localModule, range, callNew) {
+		super();
+		localModule.flagUsed();
+		this.localModule = localModule;
+		this.range = range;
+		this.callNew = callNew;
+	}
+}
+
+LocalModuleDependency.Template = class LocalModuleDependencyTemplate {
+	apply(dep, source) {
+		if (!dep.range) return;
+		const moduleInstance = dep.callNew
+			? `new (function () { return ${dep.localModule.variableName()}; })()`
+			: dep.localModule.variableName();
+		source.replace(dep.range[0], dep.range[1] - 1, moduleInstance);
+	}
+};
+
+module.exports = LocalModuleDependency;

package/lib/dependencies/LocalModulesHelpers.js

@@ -0,0 +1,52 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+
+const LocalModule = require("./LocalModule");
+const LocalModulesHelpers = exports;
+
+const lookup = (parent, mod) => {
+	if (mod.charAt(0) !== ".") return mod;
+
+	var path = parent.split("/");
+	var segs = mod.split("/");
+	path.pop();
+
+	for (let i = 0; i < segs.length; i++) {
+		const seg = segs[i];
+		if (seg === "..") {
+			path.pop();
+		} else if (seg !== ".") {
+			path.push(seg);
+		}
+	}
+
+	return path.join("/");
+};
+
+LocalModulesHelpers.addLocalModule = (state, name) => {
+	if (!state.localModules) {
+		state.localModules = [];
+	}
+	const m = new LocalModule(state.module, name, state.localModules.length);
+	state.localModules.push(m);
+	return m;
+};
+
+LocalModulesHelpers.getLocalModule = (state, name, namedModule) => {
+	if (!state.localModules) return null;
+	if (namedModule) {
+		// resolve dependency name relative to the defining named module
+		name = lookup(namedModule, name);
+	}
+	for (let i = 0; i < state.localModules.length; i++) {
+		if (state.localModules[i].name === name) {
+			return state.localModules[i];
+		}
+	}
+	return null;
+};
+
+module.exports = LocalModulesHelpers;

package/lib/dependencies/ModuleDependency.js

@@ -0,0 +1,23 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+const Dependency = require("../Dependency");
+
+class ModuleDependency extends Dependency {
+	/**
+	 * @param {string} request request path which needs resolving
+	 */
+	constructor(request) {
+		super();
+		this.request = request;
+		this.userRequest = request;
+	}
+
+	getResourceIdentifier() {
+		return `module${this.request}`;
+	}
+}
+
+module.exports = ModuleDependency;

package/lib/dependencies/ModuleDependencyTemplateAsId.js

@@ -0,0 +1,17 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+
+class ModuleDependencyTemplateAsId {
+	apply(dep, source, runtime) {
+		if (!dep.range) return;
+		const content = runtime.moduleId({
+			module: dep.module,
+			request: dep.request
+		});
+		source.replace(dep.range[0], dep.range[1] - 1, content);
+	}
+}
+module.exports = ModuleDependencyTemplateAsId;

package/lib/dependencies/ModuleDependencyTemplateAsRequireId.js

@@ -0,0 +1,17 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+
+class ModuleDependencyTemplateAsRequireId {
+	apply(dep, source, runtime) {
+		if (!dep.range) return;
+		const content = runtime.moduleExports({
+			module: dep.module,
+			request: dep.request
+		});
+		source.replace(dep.range[0], dep.range[1] - 1, content);
+	}
+}
+module.exports = ModuleDependencyTemplateAsRequireId;

package/lib/dependencies/ModuleHotAcceptDependency.js

@@ -0,0 +1,23 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+const ModuleDependency = require("./ModuleDependency");
+const ModuleDependencyTemplateAsId = require("./ModuleDependencyTemplateAsId");
+
+class ModuleHotAcceptDependency extends ModuleDependency {
+	constructor(request, range) {
+		super(request);
+		this.range = range;
+		this.weak = true;
+	}
+
+	get type() {
+		return "module.hot.accept";
+	}
+}
+
+ModuleHotAcceptDependency.Template = ModuleDependencyTemplateAsId;
+
+module.exports = ModuleHotAcceptDependency;

package/lib/dependencies/ModuleHotDeclineDependency.js

@@ -0,0 +1,23 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+const ModuleDependency = require("./ModuleDependency");
+const ModuleDependencyTemplateAsId = require("./ModuleDependencyTemplateAsId");
+
+class ModuleHotDeclineDependency extends ModuleDependency {
+	constructor(request, range) {
+		super(request);
+		this.range = range;
+		this.weak = true;
+	}
+
+	get type() {
+		return "module.hot.decline";
+	}
+}
+
+ModuleHotDeclineDependency.Template = ModuleDependencyTemplateAsId;
+
+module.exports = ModuleHotDeclineDependency;

package/lib/dependencies/MultiEntryDependency.js

@@ -0,0 +1,25 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+/** @typedef {import("./SingleEntryDependency")} SingleEntryDependency */
+const Dependency = require("../Dependency");
+
+class MultiEntryDependency extends Dependency {
+	/**
+	 * @param {SingleEntryDependency[]} dependencies an array of SingleEntryDependencies
+	 * @param {string} name entry name
+	 */
+	constructor(dependencies, name) {
+		super();
+		this.dependencies = dependencies;
+		this.name = name;
+	}
+
+	get type() {
+		return "multi entry";
+	}
+}
+
+module.exports = MultiEntryDependency;

package/lib/dependencies/NullDependency.js

@@ -0,0 +1,20 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+const Dependency = require("../Dependency");
+
+class NullDependency extends Dependency {
+	get type() {
+		return "null";
+	}
+
+	updateHash() {}
+}
+
+NullDependency.Template = class NullDependencyTemplate {
+	apply() {}
+};
+
+module.exports = NullDependency;

package/lib/dependencies/PrefetchDependency.js

@@ -0,0 +1,18 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+const ModuleDependency = require("./ModuleDependency");
+
+class PrefetchDependency extends ModuleDependency {
+	constructor(request) {
+		super(request);
+	}
+
+	get type() {
+		return "prefetch";
+	}
+}
+
+module.exports = PrefetchDependency;

package/lib/dependencies/RequireContextDependency.js

@@ -0,0 +1,22 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+const ContextDependency = require("./ContextDependency");
+const ModuleDependencyTemplateAsRequireId = require("./ModuleDependencyTemplateAsRequireId");
+
+class RequireContextDependency extends ContextDependency {
+	constructor(options, range) {
+		super(options);
+		this.range = range;
+	}
+
+	get type() {
+		return "require.context";
+	}
+}
+
+RequireContextDependency.Template = ModuleDependencyTemplateAsRequireId;
+
+module.exports = RequireContextDependency;

package/lib/dependencies/RequireContextDependencyParserPlugin.js

@@ -0,0 +1,56 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+
+const RequireContextDependency = require("./RequireContextDependency");
+
+module.exports = class RequireContextDependencyParserPlugin {
+	apply(parser) {
+		parser.hooks.call
+			.for("require.context")
+			.tap("RequireContextDependencyParserPlugin", expr => {
+				let regExp = /^\.\/.*$/;
+				let recursive = true;
+				let mode = "sync";
+				switch (expr.arguments.length) {
+					case 4: {
+						const modeExpr = parser.evaluateExpression(expr.arguments[3]);
+						if (!modeExpr.isString()) return;
+						mode = modeExpr.string;
+					}
+					// falls through
+					case 3: {
+						const regExpExpr = parser.evaluateExpression(expr.arguments[2]);
+						if (!regExpExpr.isRegExp()) return;
+						regExp = regExpExpr.regExp;
+					}
+					// falls through
+					case 2: {
+						const recursiveExpr = parser.evaluateExpression(expr.arguments[1]);
+						if (!recursiveExpr.isBoolean()) return;
+						recursive = recursiveExpr.bool;
+					}
+					// falls through
+					case 1: {
+						const requestExpr = parser.evaluateExpression(expr.arguments[0]);
+						if (!requestExpr.isString()) return;
+						const dep = new RequireContextDependency(
+							{
+								request: requestExpr.string,
+								recursive,
+								regExp,
+								mode
+							},
+							expr.range
+						);
+						dep.loc = expr.loc;
+						dep.optional = parser.scope.inTry;
+						parser.state.current.addDependency(dep);
+						return true;
+					}
+				}
+			});
+	}
+};

package/lib/dependencies/RequireContextPlugin.js

@@ -0,0 +1,143 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+
+const RequireContextDependency = require("./RequireContextDependency");
+const ContextElementDependency = require("./ContextElementDependency");
+
+const RequireContextDependencyParserPlugin = require("./RequireContextDependencyParserPlugin");
+
+class RequireContextPlugin {
+	constructor(modulesDirectories, extensions, mainFiles) {
+		if (!Array.isArray(modulesDirectories)) {
+			throw new Error("modulesDirectories must be an array");
+		}
+		if (!Array.isArray(extensions)) {
+			throw new Error("extensions must be an array");
+		}
+		this.modulesDirectories = modulesDirectories;
+		this.extensions = extensions;
+		this.mainFiles = mainFiles;
+	}
+
+	apply(compiler) {
+		compiler.hooks.compilation.tap(
+			"RequireContextPlugin",
+			(compilation, { contextModuleFactory, normalModuleFactory }) => {
+				compilation.dependencyFactories.set(
+					RequireContextDependency,
+					contextModuleFactory
+				);
+				compilation.dependencyTemplates.set(
+					RequireContextDependency,
+					new RequireContextDependency.Template()
+				);
+
+				compilation.dependencyFactories.set(
+					ContextElementDependency,
+					normalModuleFactory
+				);
+
+				const handler = (parser, parserOptions) => {
+					if (
+						parserOptions.requireContext !== undefined &&
+						!parserOptions.requireContext
+					)
+						return;
+
+					new RequireContextDependencyParserPlugin().apply(parser);
+				};
+
+				normalModuleFactory.hooks.parser
+					.for("javascript/auto")
+					.tap("RequireContextPlugin", handler);
+				normalModuleFactory.hooks.parser
+					.for("javascript/dynamic")
+					.tap("RequireContextPlugin", handler);
+
+				contextModuleFactory.hooks.alternatives.tap(
+					"RequireContextPlugin",
+					items => {
+						if (items.length === 0) return items;
+						return items
+							.map(obj => {
+								return this.extensions
+									.filter(ext => {
+										const l = obj.request.length;
+										return (
+											l > ext.length &&
+											obj.request.substr(l - ext.length, l) === ext
+										);
+									})
+									.map(ext => {
+										const l = obj.request.length;
+										return {
+											context: obj.context,
+											request: obj.request.substr(0, l - ext.length)
+										};
+									})
+									.concat(obj);
+							})
+							.reduce((a, b) => a.concat(b), []);
+					}
+				);
+
+				contextModuleFactory.hooks.alternatives.tap(
+					"RequireContextPlugin",
+					items => {
+						if (items.length === 0) return items;
+						return items
+							.map(obj => {
+								return this.mainFiles
+									.filter(mainFile => {
+										const l = obj.request.length;
+										return (
+											l > mainFile.length + 1 &&
+											obj.request.substr(l - mainFile.length - 1, l) ===
+												"/" + mainFile
+										);
+									})
+									.map(mainFile => {
+										const l = obj.request.length;
+										return [
+											{
+												context: obj.context,
+												request: obj.request.substr(0, l - mainFile.length)
+											},
+											{
+												context: obj.context,
+												request: obj.request.substr(0, l - mainFile.length - 1)
+											}
+										];
+									})
+									.reduce((a, b) => a.concat(b), [])
+									.concat(obj);
+							})
+							.reduce((a, b) => a.concat(b), []);
+					}
+				);
+
+				contextModuleFactory.hooks.alternatives.tap(
+					"RequireContextPlugin",
+					items => {
+						if (items.length === 0) return items;
+						return items.map(obj => {
+							for (let i = 0; i < this.modulesDirectories.length; i++) {
+								const dir = this.modulesDirectories[i];
+								const idx = obj.request.indexOf("./" + dir + "/");
+								if (idx === 0) {
+									obj.request = obj.request.slice(dir.length + 3);
+									break;
+								}
+							}
+							return obj;
+						});
+					}
+				);
+			}
+		);
+	}
+}
+module.exports = RequireContextPlugin;

package/lib/dependencies/RequireEnsureDependenciesBlock.js

@@ -0,0 +1,33 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+const AsyncDependenciesBlock = require("../AsyncDependenciesBlock");
+const RequireEnsureDependency = require("./RequireEnsureDependency");
+
+module.exports = class RequireEnsureDependenciesBlock extends AsyncDependenciesBlock {
+	constructor(
+		expr,
+		successExpression,
+		errorExpression,
+		chunkName,
+		chunkNameRange,
+		module,
+		loc
+	) {
+		super(chunkName, module, loc, null);
+		this.expr = expr;
+		const successBodyRange =
+			successExpression &&
+			successExpression.body &&
+			successExpression.body.range;
+		if (successBodyRange) {
+			this.range = [successBodyRange[0] + 1, successBodyRange[1] - 1];
+		}
+		this.chunkNameRange = chunkNameRange;
+		const dep = new RequireEnsureDependency(this);
+		dep.loc = loc;
+		this.addDependency(dep);
+	}
+};