webpack 3.8.1 → 3.11.0

package/lib/CompatibilityPlugin.js

@@ -1,57 +1,57 @@
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-"use strict";
-
-const ConstDependency = require("./dependencies/ConstDependency");
-
-const NullFactory = require("./NullFactory");
-
-const jsonLoaderPath = require.resolve("json-loader");
-const matchJson = /\.json$/i;
-
-class CompatibilityPlugin {
-
-	apply(compiler) {
-		compiler.plugin("compilation", (compilation, params) => {
-			compilation.dependencyFactories.set(ConstDependency, new NullFactory());
-			compilation.dependencyTemplates.set(ConstDependency, new ConstDependency.Template());
-
-			params.normalModuleFactory.plugin("parser", (parser, parserOptions) => {
-
-				if(typeof parserOptions.browserify !== "undefined" && !parserOptions.browserify)
-					return;
-
-				parser.plugin("call require", (expr) => {
-					// support for browserify style require delegator: "require(o, !0)"
-					if(expr.arguments.length !== 2) return;
-					const second = parser.evaluateExpression(expr.arguments[1]);
-					if(!second.isBoolean()) return;
-					if(second.asBool() !== true) return;
-					const dep = new ConstDependency("require", expr.callee.range);
-					dep.loc = expr.loc;
-					if(parser.state.current.dependencies.length > 1) {
-						const last = parser.state.current.dependencies[parser.state.current.dependencies.length - 1];
-						if(last.critical && last.request === "." && last.userRequest === "." && last.recursive)
-							parser.state.current.dependencies.pop();
-					}
-					parser.state.current.addDependency(dep);
-					return true;
-				});
-			});
-
-			params.normalModuleFactory.plugin("after-resolve", (data, done) => {
-				// if this is a json file and there are no loaders active, we use the json-loader in order to avoid parse errors
-				// @see https://github.com/webpack/webpack/issues/3363
-				if(matchJson.test(data.request) && data.loaders.length === 0) {
-					data.loaders.push({
-						loader: jsonLoaderPath
-					});
-				}
-				done(null, data);
-			});
-		});
-	}
-}
-module.exports = CompatibilityPlugin;
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+
+const ConstDependency = require("./dependencies/ConstDependency");
+
+const NullFactory = require("./NullFactory");
+
+const jsonLoaderPath = require.resolve("json-loader");
+const matchJson = /\.json$/i;
+
+class CompatibilityPlugin {
+
+	apply(compiler) {
+		compiler.plugin("compilation", (compilation, params) => {
+			compilation.dependencyFactories.set(ConstDependency, new NullFactory());
+			compilation.dependencyTemplates.set(ConstDependency, new ConstDependency.Template());
+
+			params.normalModuleFactory.plugin("parser", (parser, parserOptions) => {
+
+				if(typeof parserOptions.browserify !== "undefined" && !parserOptions.browserify)
+					return;
+
+				parser.plugin("call require", (expr) => {
+					// support for browserify style require delegator: "require(o, !0)"
+					if(expr.arguments.length !== 2) return;
+					const second = parser.evaluateExpression(expr.arguments[1]);
+					if(!second.isBoolean()) return;
+					if(second.asBool() !== true) return;
+					const dep = new ConstDependency("require", expr.callee.range);
+					dep.loc = expr.loc;
+					if(parser.state.current.dependencies.length > 1) {
+						const last = parser.state.current.dependencies[parser.state.current.dependencies.length - 1];
+						if(last.critical && last.request === "." && last.userRequest === "." && last.recursive)
+							parser.state.current.dependencies.pop();
+					}
+					parser.state.current.addDependency(dep);
+					return true;
+				});
+			});
+
+			params.normalModuleFactory.plugin("after-resolve", (data, done) => {
+				// if this is a json file and there are no loaders active, we use the json-loader in order to avoid parse errors
+				// @see https://github.com/webpack/webpack/issues/3363
+				if(matchJson.test(data.request) && data.loaders.length === 0) {
+					data.loaders.push({
+						loader: jsonLoaderPath
+					});
+				}
+				done(null, data);
+			});
+		});
+	}
+}
+module.exports = CompatibilityPlugin;

package/lib/Compilation.js

@@ -34,7 +34,7 @@ function byId(a, b) {
 
 function iterationBlockVariable(variables, fn) {
 	for(let indexVariable = 0; indexVariable < variables.length; indexVariable++) {
-		let varDep = variables[indexVariable].dependencies;
+		const varDep = variables[indexVariable].dependencies;
 		for(let indexVDep = 0; indexVDep < varDep.length; indexVDep++) {
 			fn(varDep[indexVDep]);
 		}
@@ -116,8 +116,8 @@ class Compilation extends Tapable {
 				cacheModule.disconnect();
 				this._modules[identifier] = cacheModule;
 				this.modules.push(cacheModule);
-				cacheModule.errors.forEach(err => this.errors.push(err), this);
-				cacheModule.warnings.forEach(err => this.warnings.push(err), this);
+				cacheModule.errors.forEach(err => this.errors.push(err));
+				cacheModule.warnings.forEach(err => this.warnings.push(err));
 				return cacheModule;
 			}
 		}
@@ -300,9 +300,7 @@ class Compilation extends Tapable {
 						iterationDependencies(dependencies);
 
 						if(_this.profile) {
-							if(!module.profile) {
-								module.profile = {};
-							}
+							module.profile = module.profile || {};
 							const time = Date.now() - start;
 							if(!module.profile.dependencies || time > module.profile.dependencies) {
 								module.profile.dependencies = time;
@@ -572,112 +570,111 @@ class Compilation extends Tapable {
 	}
 
 	seal(callback) {
-		const self = this;
-		self.applyPlugins0("seal");
-		self.nextFreeModuleIndex = 0;
-		self.nextFreeModuleIndex2 = 0;
-		self.preparedChunks.forEach(preparedChunk => {
+		this.applyPlugins0("seal");
+		this.nextFreeModuleIndex = 0;
+		this.nextFreeModuleIndex2 = 0;
+		this.preparedChunks.forEach(preparedChunk => {
 			const module = preparedChunk.module;
-			const chunk = self.addChunk(preparedChunk.name, module);
-			const entrypoint = self.entrypoints[chunk.name] = new Entrypoint(chunk.name);
+			const chunk = this.addChunk(preparedChunk.name, module);
+			const entrypoint = this.entrypoints[chunk.name] = new Entrypoint(chunk.name);
 			entrypoint.unshiftChunk(chunk);
 
 			chunk.addModule(module);
 			module.addChunk(chunk);
 			chunk.entryModule = module;
-			self.assignIndex(module);
-			self.assignDepth(module);
+			this.assignIndex(module);
+			this.assignDepth(module);
 		});
-		self.processDependenciesBlocksForChunks(self.chunks.slice());
-		self.sortModules(self.modules);
-		self.applyPlugins0("optimize");
+		this.processDependenciesBlocksForChunks(this.chunks.slice());
+		this.sortModules(this.modules);
+		this.applyPlugins0("optimize");
 
-		while(self.applyPluginsBailResult1("optimize-modules-basic", self.modules) ||
-			self.applyPluginsBailResult1("optimize-modules", self.modules) ||
-			self.applyPluginsBailResult1("optimize-modules-advanced", self.modules)) { /* empty */ }
-		self.applyPlugins1("after-optimize-modules", self.modules);
+		while(this.applyPluginsBailResult1("optimize-modules-basic", this.modules) ||
+			this.applyPluginsBailResult1("optimize-modules", this.modules) ||
+			this.applyPluginsBailResult1("optimize-modules-advanced", this.modules)) { /* empty */ }
+		this.applyPlugins1("after-optimize-modules", this.modules);
 
-		while(self.applyPluginsBailResult1("optimize-chunks-basic", self.chunks) ||
-			self.applyPluginsBailResult1("optimize-chunks", self.chunks) ||
-			self.applyPluginsBailResult1("optimize-chunks-advanced", self.chunks)) { /* empty */ }
-		self.applyPlugins1("after-optimize-chunks", self.chunks);
+		while(this.applyPluginsBailResult1("optimize-chunks-basic", this.chunks) ||
+			this.applyPluginsBailResult1("optimize-chunks", this.chunks) ||
+			this.applyPluginsBailResult1("optimize-chunks-advanced", this.chunks)) { /* empty */ }
+		this.applyPlugins1("after-optimize-chunks", this.chunks);
 
-		self.applyPluginsAsyncSeries("optimize-tree", self.chunks, self.modules, function sealPart2(err) {
+		this.applyPluginsAsyncSeries("optimize-tree", this.chunks, this.modules, (err) => {
 			if(err) {
 				return callback(err);
 			}
 
-			self.applyPlugins2("after-optimize-tree", self.chunks, self.modules);
+			this.applyPlugins2("after-optimize-tree", this.chunks, this.modules);
 
-			while(self.applyPluginsBailResult("optimize-chunk-modules-basic", self.chunks, self.modules) ||
-				self.applyPluginsBailResult("optimize-chunk-modules", self.chunks, self.modules) ||
-				self.applyPluginsBailResult("optimize-chunk-modules-advanced", self.chunks, self.modules)) { /* empty */ }
-			self.applyPlugins2("after-optimize-chunk-modules", self.chunks, self.modules);
+			while(this.applyPluginsBailResult("optimize-chunk-modules-basic", this.chunks, this.modules) ||
+				this.applyPluginsBailResult("optimize-chunk-modules", this.chunks, this.modules) ||
+				this.applyPluginsBailResult("optimize-chunk-modules-advanced", this.chunks, this.modules)) { /* empty */ }
+			this.applyPlugins2("after-optimize-chunk-modules", this.chunks, this.modules);
 
-			const shouldRecord = self.applyPluginsBailResult("should-record") !== false;
+			const shouldRecord = this.applyPluginsBailResult("should-record") !== false;
 
-			self.applyPlugins2("revive-modules", self.modules, self.records);
-			self.applyPlugins1("optimize-module-order", self.modules);
-			self.applyPlugins1("advanced-optimize-module-order", self.modules);
-			self.applyPlugins1("before-module-ids", self.modules);
-			self.applyPlugins1("module-ids", self.modules);
-			self.applyModuleIds();
-			self.applyPlugins1("optimize-module-ids", self.modules);
-			self.applyPlugins1("after-optimize-module-ids", self.modules);
+			this.applyPlugins2("revive-modules", this.modules, this.records);
+			this.applyPlugins1("optimize-module-order", this.modules);
+			this.applyPlugins1("advanced-optimize-module-order", this.modules);
+			this.applyPlugins1("before-module-ids", this.modules);
+			this.applyPlugins1("module-ids", this.modules);
+			this.applyModuleIds();
+			this.applyPlugins1("optimize-module-ids", this.modules);
+			this.applyPlugins1("after-optimize-module-ids", this.modules);
 
-			self.sortItemsWithModuleIds();
+			this.sortItemsWithModuleIds();
 
-			self.applyPlugins2("revive-chunks", self.chunks, self.records);
-			self.applyPlugins1("optimize-chunk-order", self.chunks);
-			self.applyPlugins1("before-chunk-ids", self.chunks);
-			self.applyChunkIds();
-			self.applyPlugins1("optimize-chunk-ids", self.chunks);
-			self.applyPlugins1("after-optimize-chunk-ids", self.chunks);
+			this.applyPlugins2("revive-chunks", this.chunks, this.records);
+			this.applyPlugins1("optimize-chunk-order", this.chunks);
+			this.applyPlugins1("before-chunk-ids", this.chunks);
+			this.applyChunkIds();
+			this.applyPlugins1("optimize-chunk-ids", this.chunks);
+			this.applyPlugins1("after-optimize-chunk-ids", this.chunks);
 
-			self.sortItemsWithChunkIds();
+			this.sortItemsWithChunkIds();
 
 			if(shouldRecord)
-				self.applyPlugins2("record-modules", self.modules, self.records);
+				this.applyPlugins2("record-modules", this.modules, this.records);
 			if(shouldRecord)
-				self.applyPlugins2("record-chunks", self.chunks, self.records);
+				this.applyPlugins2("record-chunks", this.chunks, this.records);
 
-			self.applyPlugins0("before-hash");
-			self.createHash();
-			self.applyPlugins0("after-hash");
+			this.applyPlugins0("before-hash");
+			this.createHash();
+			this.applyPlugins0("after-hash");
 
 			if(shouldRecord)
-				self.applyPlugins1("record-hash", self.records);
+				this.applyPlugins1("record-hash", this.records);
 
-			self.applyPlugins0("before-module-assets");
-			self.createModuleAssets();
-			if(self.applyPluginsBailResult("should-generate-chunk-assets") !== false) {
-				self.applyPlugins0("before-chunk-assets");
-				self.createChunkAssets();
+			this.applyPlugins0("before-module-assets");
+			this.createModuleAssets();
+			if(this.applyPluginsBailResult("should-generate-chunk-assets") !== false) {
+				this.applyPlugins0("before-chunk-assets");
+				this.createChunkAssets();
 			}
-			self.applyPlugins1("additional-chunk-assets", self.chunks);
-			self.summarizeDependencies();
+			this.applyPlugins1("additional-chunk-assets", this.chunks);
+			this.summarizeDependencies();
 			if(shouldRecord)
-				self.applyPlugins2("record", self, self.records);
+				this.applyPlugins2("record", this, this.records);
 
-			self.applyPluginsAsync("additional-assets", err => {
+			this.applyPluginsAsync("additional-assets", err => {
 				if(err) {
 					return callback(err);
 				}
-				self.applyPluginsAsync("optimize-chunk-assets", self.chunks, err => {
+				this.applyPluginsAsync("optimize-chunk-assets", this.chunks, err => {
 					if(err) {
 						return callback(err);
 					}
-					self.applyPlugins1("after-optimize-chunk-assets", self.chunks);
-					self.applyPluginsAsync("optimize-assets", self.assets, err => {
+					this.applyPlugins1("after-optimize-chunk-assets", this.chunks);
+					this.applyPluginsAsync("optimize-assets", this.assets, err => {
 						if(err) {
 							return callback(err);
 						}
-						self.applyPlugins1("after-optimize-assets", self.assets);
-						if(self.applyPluginsBailResult("need-additional-seal")) {
-							self.unseal();
-							return self.seal(callback);
+						this.applyPlugins1("after-optimize-assets", this.assets);
+						if(this.applyPluginsBailResult("need-additional-seal")) {
+							this.unseal();
+							return this.seal(callback);
 						}
-						return self.applyPluginsAsync("after-seal", callback);
+						return this.applyPluginsAsync("after-seal", callback);
 					});
 				});
 			});
@@ -685,11 +682,7 @@ class Compilation extends Tapable {
 	}
 
 	sortModules(modules) {
-		modules.sort((a, b) => {
-			if(a.index < b.index) return -1;
-			if(a.index > b.index) return 1;
-			return 0;
-		});
+		modules.sort(byId);
 	}
 
 	reportDependencyErrorsAndWarnings(module, blocks) {
@@ -1097,9 +1090,9 @@ class Compilation extends Tapable {
 	}
 
 	applyModuleIds() {
-		let unusedIds = [];
+		const unusedIds = [];
 		let nextFreeModuleId = 0;
-		let usedIds = [];
+		const usedIds = [];
 		// TODO consider Map when performance has improved https://gist.github.com/sokra/234c077e1299b7369461f1708519c392
 		const usedIdMap = Object.create(null);
 		if(this.usedModuleIds) {
@@ -1218,14 +1211,12 @@ class Compilation extends Tapable {
 	sortItemsWithChunkIds() {
 		this.chunks.sort(byId);
 
-		const modules = this.modules;
-		for(let indexModule = 0; indexModule < modules.length; indexModule++) {
-			modules[indexModule].sortItems(true);
+		for(let indexModule = 0; indexModule < this.modules.length; indexModule++) {
+			this.modules[indexModule].sortItems(true);
 		}
 
-		const chunks = this.chunks;
-		for(let indexChunk = 0; indexChunk < chunks.length; indexChunk++) {
-			chunks[indexChunk].sortItems();
+		for(let indexChunk = 0; indexChunk < this.chunks.length; indexChunk++) {
+			this.chunks[indexChunk].sortItems();
 		}
 
 		const byMessage = (a, b) => {
@@ -1253,18 +1244,16 @@ class Compilation extends Tapable {
 		this.contextDependencies = [];
 		this.missingDependencies = [];
 
-		const children = this.children;
-		for(let indexChildren = 0; indexChildren < children.length; indexChildren++) {
-			const child = children[indexChildren];
+		for(let indexChildren = 0; indexChildren < this.children.length; indexChildren++) {
+			const child = this.children[indexChildren];
 
 			this.fileDependencies = this.fileDependencies.concat(child.fileDependencies);
 			this.contextDependencies = this.contextDependencies.concat(child.contextDependencies);
 			this.missingDependencies = this.missingDependencies.concat(child.missingDependencies);
 		}
 
-		const modules = this.modules;
-		for(let indexModule = 0; indexModule < modules.length; indexModule++) {
-			const module = modules[indexModule];
+		for(let indexModule = 0; indexModule < this.modules.length; indexModule++) {
+			const module = this.modules[indexModule];
 
 			if(module.fileDependencies) {
 				const fileDependencies = module.fileDependencies;
@@ -1425,7 +1414,7 @@ class Compilation extends Tapable {
 	}
 
 	createChildCompiler(name, outputOptions, plugins) {
-		var idx = (this.childrenCounters[name] || 0);
+		const idx = (this.childrenCounters[name] || 0);
 		this.childrenCounters[name] = idx + 1;
 		return this.compiler.createChildCompiler(this, name, idx, outputOptions, plugins);
 	}