webpack 4.10.1 → 4.12.0

package/lib/RecordIdsPlugin.js

@@ -6,16 +6,53 @@
 
 const identifierUtils = require("./util/identifier");
 
+/** @typedef {import("./Compiler")} Compiler */
+/** @typedef {import("./Chunk")} Chunk */
+/** @typedef {import("./Module")} Module */
+
+/**
+ * @typedef {Object} RecordsChunks
+ * @property {Record<string, number>=} byName
+ * @property {Record<string, number>=} bySource
+ * @property {number[]=} usedIds
+ */
+
+/**
+ * @typedef {Object} RecordsModules
+ * @property {Record<string, number>=} byIdentifier
+ * @property {Record<string, number>=} bySource
+ * @property {Record<number, number>=} usedIds
+ */
+
+/**
+ * @typedef {Object} Records
+ * @property {RecordsChunks=} chunks
+ * @property {RecordsModules=} modules
+ */
+
 class RecordIdsPlugin {
+	/**
+	 * @param {Object} options Options object
+	 * @param {boolean=} options.portableIds true, when ids need to be portable
+	 */
 	constructor(options) {
 		this.options = options || {};
 	}
 
+	/**
+	 * @param {Compiler} compiler the Compiler
+	 * @returns {void}
+	 */
 	apply(compiler) {
 		const portableIds = this.options.portableIds;
 		compiler.hooks.compilation.tap("RecordIdsPlugin", compilation => {
 			compilation.hooks.recordModules.tap(
 				"RecordIdsPlugin",
+				/**
+				 * @param {Module[]} modules the modules array
+				 * @param {Records} records the records object
+				 * @returns {void}
+				 */
 				(modules, records) => {
 					if (!records.modules) records.modules = {};
 					if (!records.modules.byIdentifier) records.modules.byIdentifier = {};
@@ -36,9 +73,15 @@ class RecordIdsPlugin {
 			);
 			compilation.hooks.reviveModules.tap(
 				"RecordIdsPlugin",
+				/**
+				 * @param {Module[]} modules the modules array
+				 * @param {Records} records the records object
+				 * @returns {void}
+				 */
 				(modules, records) => {
 					if (!records.modules) return;
 					if (records.modules.byIdentifier) {
+						/** @type {Set<number>} */
 						const usedIds = new Set();
 						for (const module of modules) {
 							if (module.id !== null) continue;
@@ -56,47 +99,59 @@ class RecordIdsPlugin {
 							module.id = id;
 						}
 					}
-					if (Array.isArray(records.modules.usedIds))
+					if (Array.isArray(records.modules.usedIds)) {
 						compilation.usedModuleIds = new Set(records.modules.usedIds);
+					}
 				}
 			);
 
+			/**
+			 * @param {Module} module the module
+			 * @returns {string} the (portable) identifier
+			 */
 			const getModuleIdentifier = module => {
-				if (portableIds)
+				if (portableIds) {
 					return identifierUtils.makePathsRelative(
 						compiler.context,
 						module.identifier(),
 						compilation.cache
 					);
+				}
 				return module.identifier();
 			};
 
+			/**
+			 * @param {Chunk} chunk the chunk
+			 * @returns {string[]} sources of the chunk
+			 */
 			const getChunkSources = chunk => {
+				/** @type {string[]} */
 				const sources = [];
 				for (const chunkGroup of chunk.groupsIterable) {
 					const index = chunkGroup.chunks.indexOf(chunk);
 					for (const origin of chunkGroup.origins) {
 						if (origin.module) {
-							if (origin.request)
+							if (origin.request) {
 								sources.push(
 									`${index} ${getModuleIdentifier(origin.module)} ${
 										origin.request
 									}`
 								);
-							else if (typeof origin.loc === "string")
+							} else if (typeof origin.loc === "string") {
 								sources.push(
 									`${index} ${getModuleIdentifier(origin.module)} ${origin.loc}`
 								);
-							else if (
+							} else if (
 								origin.loc &&
 								typeof origin.loc === "object" &&
 								origin.loc.start
-							)
+							) {
 								sources.push(
 									`${index} ${getModuleIdentifier(
 										origin.module
 									)} ${JSON.stringify(origin.loc.start)}`
 								);
+							}
 						}
 					}
 				}
@@ -105,10 +160,16 @@ class RecordIdsPlugin {
 
 			compilation.hooks.recordChunks.tap(
 				"RecordIdsPlugin",
+				/**
+				 * @param {Chunk[]} chunks the chunks array
+				 * @param {Records} records the records object
+				 * @returns {void}
+				 */
 				(chunks, records) => {
 					if (!records.chunks) records.chunks = {};
 					if (!records.chunks.byName) records.chunks.byName = {};
 					if (!records.chunks.bySource) records.chunks.bySource = {};
+					/** @type {Set<number>} */
 					const usedIds = new Set();
 					for (const chunk of chunks) {
 						if (typeof chunk.id !== "number") continue;
@@ -125,8 +186,14 @@ class RecordIdsPlugin {
 			);
 			compilation.hooks.reviveChunks.tap(
 				"RecordIdsPlugin",
+				/**
+				 * @param {Chunk[]} chunks the chunks array
+				 * @param {Records} records the records object
+				 * @returns {void}
+				 */
 				(chunks, records) => {
 					if (!records.chunks) return;
+					/** @type {Set<number>} */
 					const usedIds = new Set();
 					if (records.chunks.byName) {
 						for (const chunk of chunks) {
@@ -145,15 +212,16 @@ class RecordIdsPlugin {
 							for (const source of sources) {
 								const id = records.chunks.bySource[source];
 								if (id === undefined) continue;
-								if (usedIds[id]) continue;
-								usedIds[id] = true;
+								if (usedIds.has(id)) continue;
+								usedIds.add(id);
 								chunk.id = id;
 								break;
 							}
 						}
 					}
-					if (Array.isArray(records.chunks.usedIds))
+					if (Array.isArray(records.chunks.usedIds)) {
 						compilation.usedChunkIds = new Set(records.chunks.usedIds);
+					}
 				}
 			);
 		});

package/lib/RemovedPluginError.js

@@ -4,9 +4,7 @@ const WebpackError = require("./WebpackError");
 
 module.exports = class RemovedPluginError extends WebpackError {
 	constructor(message) {
-		super();
-
-		this.message = message;
+		super(message);
 
 		Error.captureStackTrace(this, this.constructor);
 	}

package/lib/RequestShortener.js

@@ -10,6 +10,7 @@ const PATH_CHARS_REGEXP = /[-[\]{}()*+?.,\\^$|#\s]/g;
 const SEPARATOR_REGEXP = /[/\\]$/;
 const FRONT_OR_BACK_BANG_REGEXP = /^!|!$/g;
 const INDEX_JS_REGEXP = /\/index.js(!|\?|\(query\))/g;
+const MATCH_RESOURCE_REGEXP = /!=!/;
 
 const normalizeBackSlashDirection = request => {
 	return request.replace(NORMALIZE_SLASH_DIRECTION_REGEXP, "/");
@@ -23,8 +24,9 @@ const createRegExpForPath = path => {
 class RequestShortener {
 	constructor(directory) {
 		directory = normalizeBackSlashDirection(directory);
-		if (SEPARATOR_REGEXP.test(directory))
+		if (SEPARATOR_REGEXP.test(directory)) {
 			directory = directory.substr(0, directory.length - 1);
+		}
 
 		if (directory) {
 			this.currentDirectoryRegExp = createRegExpForPath(directory);
@@ -54,18 +56,25 @@ class RequestShortener {
 	shorten(request) {
 		if (!request) return request;
 		const cacheEntry = this.cache.get(request);
-		if (cacheEntry !== undefined) return cacheEntry;
+		if (cacheEntry !== undefined) {
+			return cacheEntry;
+		}
 		let result = normalizeBackSlashDirection(request);
-		if (this.buildinsAsModule && this.buildinsRegExp)
+		if (this.buildinsAsModule && this.buildinsRegExp) {
 			result = result.replace(this.buildinsRegExp, "!(webpack)");
-		if (this.currentDirectoryRegExp)
+		}
+		if (this.currentDirectoryRegExp) {
 			result = result.replace(this.currentDirectoryRegExp, "!.");
-		if (this.parentDirectoryRegExp)
+		}
+		if (this.parentDirectoryRegExp) {
 			result = result.replace(this.parentDirectoryRegExp, "!..");
-		if (!this.buildinsAsModule && this.buildinsRegExp)
+		}
+		if (!this.buildinsAsModule && this.buildinsRegExp) {
 			result = result.replace(this.buildinsRegExp, "!(webpack)");
+		}
 		result = result.replace(INDEX_JS_REGEXP, "$1");
 		result = result.replace(FRONT_OR_BACK_BANG_REGEXP, "");
+		result = result.replace(MATCH_RESOURCE_REGEXP, " = ");
 		this.cache.set(request, result);
 		return result;
 	}

package/lib/RuleSet.js

@@ -117,7 +117,7 @@ module.exports = class RuleSet {
 	}
 
 	static normalizeRule(rule, refs, ident) {
-		if (typeof rule === "string")
+		if (typeof rule === "string") {
 			return {
 				use: [
 					{
@@ -125,9 +125,11 @@ module.exports = class RuleSet {
 					}
 				]
 			};
-		if (!rule)
+		}
+		if (!rule) {
 			throw new Error("Unexcepted null when object was expected as rule");
-		if (typeof rule !== "object")
+		}
+		if (typeof rule !== "object") {
 			throw new Error(
 				"Unexcepted " +
 					typeof rule +
@@ -135,6 +137,7 @@ module.exports = class RuleSet {
 					rule +
 					")"
 			);
+		}
 
 		const newRule = {};
 		let useSource;
@@ -142,7 +145,7 @@ module.exports = class RuleSet {
 		let condition;
 
 		const checkUseSource = newSource => {
-			if (useSource && useSource !== newSource)
+			if (useSource && useSource !== newSource) {
 				throw new Error(
 					RuleSet.buildErrorMessage(
 						rule,
@@ -155,11 +158,12 @@ module.exports = class RuleSet {
 						)
 					)
 				);
+			}
 			useSource = newSource;
 		};
 
 		const checkResourceSource = newSource => {
-			if (resourceSource && resourceSource !== newSource)
+			if (resourceSource && resourceSource !== newSource) {
 				throw new Error(
 					RuleSet.buildErrorMessage(
 						rule,
@@ -172,6 +176,7 @@ module.exports = class RuleSet {
 						)
 					)
 				);
+			}
 			resourceSource = newSource;
 		};
 
@@ -198,6 +203,14 @@ module.exports = class RuleSet {
 			}
 		}
 
+		if (rule.realResource) {
+			try {
+				newRule.realResource = RuleSet.normalizeCondition(rule.realResource);
+			} catch (error) {
+				throw new Error(RuleSet.buildErrorMessage(rule.realResource, error));
+			}
+		}
+
 		if (rule.resourceQuery) {
 			try {
 				newRule.resourceQuery = RuleSet.normalizeCondition(rule.resourceQuery);
@@ -222,7 +235,7 @@ module.exports = class RuleSet {
 			}
 		}
 
-		if (rule.loader && rule.loaders)
+		if (rule.loader && rule.loaders) {
 			throw new Error(
 				RuleSet.buildErrorMessage(
 					rule,
@@ -231,6 +244,7 @@ module.exports = class RuleSet {
 					)
 				)
 			);
+		}
 
 		const loader = rule.loaders || rule.loader;
 		if (typeof loader === "string" && !rule.options && !rule.query) {
@@ -274,19 +288,21 @@ module.exports = class RuleSet {
 			newRule.use = RuleSet.normalizeUse(rule.use, ident);
 		}
 
-		if (rule.rules)
+		if (rule.rules) {
 			newRule.rules = RuleSet.normalizeRules(
 				rule.rules,
 				refs,
 				`${ident}-rules`
 			);
+		}
 
-		if (rule.oneOf)
+		if (rule.oneOf) {
 			newRule.oneOf = RuleSet.normalizeRules(
 				rule.oneOf,
 				refs,
 				`${ident}-oneOf`
 			);
+		}
 
 		const keys = Object.keys(rule).filter(key => {
 			return ![
@@ -365,16 +381,22 @@ module.exports = class RuleSet {
 
 		const newItem = {};
 
-		if (item.options && item.query)
+		if (item.options && item.query) {
 			throw new Error("Provided options and query in use");
+		}
 
-		if (!item.loader) throw new Error("No loader specified");
+		if (!item.loader) {
+			throw new Error("No loader specified");
+		}
 
 		newItem.options = item.options || item.query;
 
 		if (typeof newItem.options === "object" && newItem.options) {
-			if (newItem.options.ident) newItem.ident = newItem.options.ident;
-			else newItem.ident = ident;
+			if (newItem.options.ident) {
+				newItem.ident = newItem.options.ident;
+			} else {
+				newItem.ident = ident;
+			}
 		}
 
 		const keys = Object.keys(item).filter(function(key) {
@@ -403,7 +425,7 @@ module.exports = class RuleSet {
 			const items = condition.map(c => RuleSet.normalizeCondition(c));
 			return orMatcher(items);
 		}
-		if (typeof condition !== "object")
+		if (typeof condition !== "object") {
 			throw Error(
 				"Unexcepted " +
 					typeof condition +
@@ -411,6 +433,7 @@ module.exports = class RuleSet {
 					condition +
 					")"
 			);
+		}
 
 		const matchers = [];
 		Object.keys(condition).forEach(key => {
@@ -438,9 +461,12 @@ module.exports = class RuleSet {
 					throw new Error("Unexcepted property " + key + " in condition");
 			}
 		});
-		if (matchers.length === 0)
+		if (matchers.length === 0) {
 			throw new Error("Excepted condition but got " + condition);
-		if (matchers.length === 1) return matchers[0];
+		}
+		if (matchers.length === 1) {
+			return matchers[0];
+		}
 		return andMatcher(matchers);
 	}
 
@@ -459,24 +485,30 @@ module.exports = class RuleSet {
 	_run(data, rule, result) {
 		// test conditions
 		if (rule.resource && !data.resource) return false;
+		if (rule.realResource && !data.realResource) return false;
 		if (rule.resourceQuery && !data.resourceQuery) return false;
 		if (rule.compiler && !data.compiler) return false;
 		if (rule.issuer && !data.issuer) return false;
 		if (rule.resource && !rule.resource(data.resource)) return false;
+		if (rule.realResource && !rule.realResource(data.realResource))
+			return false;
 		if (data.issuer && rule.issuer && !rule.issuer(data.issuer)) return false;
 		if (
 			data.resourceQuery &&
 			rule.resourceQuery &&
 			!rule.resourceQuery(data.resourceQuery)
-		)
+		) {
 			return false;
-		if (data.compiler && rule.compiler && !rule.compiler(data.compiler))
+		}
+		if (data.compiler && rule.compiler && !rule.compiler(data.compiler)) {
 			return false;
+		}
 
 		// apply
 		const keys = Object.keys(rule).filter(key => {
 			return ![
 				"resource",
+				"realResource",
 				"resourceQuery",
 				"compiler",
 				"issuer",
@@ -527,8 +559,9 @@ module.exports = class RuleSet {
 
 	findOptionsByIdent(ident) {
 		const options = this.references[ident];
-		if (!options)
+		if (!options) {
 			throw new Error("Can't find options with ident '" + ident + "'");
+		}
 		return options;
 	}
 };

package/lib/RuntimeTemplate.js

@@ -79,10 +79,11 @@ module.exports = class RuntimeTemplate {
 	}
 
 	moduleRaw({ module, request }) {
-		if (!module)
+		if (!module) {
 			return this.missingModule({
 				request
 			});
+		}
 		return `__webpack_require__(${this.moduleId({ module, request })})`;
 	}
 
@@ -94,10 +95,11 @@ module.exports = class RuntimeTemplate {
 	}
 
 	moduleNamespace({ module, request, strict }) {
-		if (!module)
+		if (!module) {
 			return this.missingModule({
 				request
 			});
+		}
 		const moduleId = this.moduleId({
 			module,
 			request
@@ -205,10 +207,11 @@ module.exports = class RuntimeTemplate {
 			content += `/* harmony import */ ${optDeclaration}${importVar}_default = /*#__PURE__*/__webpack_require__.n(${importVar});\n`;
 		}
 		if (exportsType === "named") {
-			if (Array.isArray(module.buildMeta.providedExports))
+			if (Array.isArray(module.buildMeta.providedExports)) {
 				content += `${optDeclaration}${importVar}_namespace = /*#__PURE__*/__webpack_require__.t(${moduleId}, 1);\n`;
-			else
+			} else {
 				content += `${optDeclaration}${importVar}_namespace = /*#__PURE__*/__webpack_require__.t(${moduleId});\n`;
+			}
 		}
 		return content;
 	}
@@ -223,18 +226,23 @@ module.exports = class RuntimeTemplate {
 		callContext,
 		importVar
 	}) {
-		if (!module)
+		if (!module) {
 			return this.missingModule({
 				request
 			});
+		}
 		const exportsType = module.buildMeta && module.buildMeta.exportsType;
 
 		if (!exportsType) {
 			if (exportName === "default") {
 				if (!originModule.buildMeta.strictHarmonyModule) {
-					if (isCall) return `${importVar}_default()`;
-					else if (asiSafe) return `(${importVar}_default())`;
-					else return `${importVar}_default.a`;
+					if (isCall) {
+						return `${importVar}_default()`;
+					} else if (asiSafe) {
+						return `(${importVar}_default())`;
+					} else {
+						return `${importVar}_default.a`;
+					}
 				} else {
 					return importVar;
 				}
@@ -261,8 +269,11 @@ module.exports = class RuntimeTemplate {
 				used !== exportName ? Template.toNormalComment(exportName) + " " : "";
 			const access = `${importVar}[${comment}${JSON.stringify(used)}]`;
 			if (isCall) {
-				if (callContext === false && asiSafe) return `(0,${access})`;
-				else if (callContext === false) return `Object(${access})`;
+				if (callContext === false && asiSafe) {
+					return `(0,${access})`;
+				} else if (callContext === false) {
+					return `Object(${access})`;
+				}
 			}
 			return access;
 		} else {

package/lib/SourceMapDevToolPlugin.js

@@ -53,10 +53,11 @@ const getTaskForFile = (file, chunk, options, compilation) => {
 
 class SourceMapDevToolPlugin {
 	constructor(options) {
-		if (arguments.length > 1)
+		if (arguments.length > 1) {
 			throw new Error(
 				"SourceMapDevToolPlugin only takes one argument (pass an options object)"
 			);
+		}
 
 		validateOptions(schema, options || {}, "SourceMap DevTool Plugin");
 
@@ -121,7 +122,7 @@ class SourceMapDevToolPlugin {
 					const tasks = [];
 					files.forEach(({ file, chunk }, idx) => {
 						reportProgress(
-							0.5 * idx / files.length,
+							(0.5 * idx) / files.length,
 							file,
 							"generate SourceMap"
 						);
@@ -205,7 +206,7 @@ class SourceMapDevToolPlugin {
 					}
 					tasks.forEach((task, index) => {
 						reportProgress(
-							0.5 + 0.5 * index / tasks.length,
+							0.5 + (0.5 * index) / tasks.length,
 							task.file,
 							"attach SourceMap"
 						);