webpack 2.3.1 → 2.4.1

package/lib/ContextModuleFactory.js

@@ -2,7 +2,7 @@
 	MIT License http://www.opensource.org/licenses/mit-license.php
 	Author Tobias Koppers @sokra
 */
-var async = require("async");
+var asyncLib = require("async");
 var path = require("path");
 
 var Tapable = require("tapable");
@@ -61,7 +61,7 @@ ContextModuleFactory.prototype.create = function(data, callback) {
 
 		var resolvers = module.resolvers;
 
-		async.parallel([
+		asyncLib.parallel([
 			function(callback) {
 				resolvers.context.resolve({}, context, resource, function(err, result) {
 					if(err) return callback(err);
@@ -69,7 +69,7 @@ ContextModuleFactory.prototype.create = function(data, callback) {
 				});
 			},
 			function(callback) {
-				async.map(loaders, function(loader, callback) {
+				asyncLib.map(loaders, function(loader, callback) {
 					resolvers.loader.resolve({}, context, loader, function(err, result) {
 						if(err) return callback(err);
 						callback(null, result);
@@ -93,7 +93,7 @@ ContextModuleFactory.prototype.create = function(data, callback) {
 				// Ignored
 				if(!result) return callback();
 
-				return callback(null, new ContextModule(result.resolveDependencies, result.resource, result.recursive, result.regExp, result.loaders, result.async));
+				return callback(null, new ContextModule(result.resolveDependencies, result.resource, result.recursive, result.regExp, result.loaders, result.async, dependency.chunkName));
 			});
 		});
 	});
@@ -106,7 +106,7 @@ ContextModuleFactory.prototype.resolveDependencies = function resolveDependencie
 		fs.readdir(directory, function(err, files) {
 			if(err) return callback(err);
 			if(!files || files.length === 0) return callback(null, []);
-			async.map(files.filter(function(p) {
+			asyncLib.map(files.filter(function(p) {
 				return p.indexOf(".") !== 0;
 			}), function(seqment, callback) {
 

package/lib/DelegatedModule.js

@@ -2,79 +2,83 @@
 	MIT License http://www.opensource.org/licenses/mit-license.php
 	Author Tobias Koppers @sokra
 */
-var Module = require("./Module");
-var OriginalSource = require("webpack-sources").OriginalSource;
-var RawSource = require("webpack-sources").RawSource;
-var WebpackMissingModule = require("./dependencies/WebpackMissingModule");
-var DelegatedSourceDependency = require("./dependencies/DelegatedSourceDependency");
+"use strict";
 
-function DelegatedModule(sourceRequest, data, type, userRequest) {
-	Module.call(this);
-	this.sourceRequest = sourceRequest;
-	this.request = data.id;
-	this.meta = data.meta;
-	this.type = type;
-	this.userRequest = userRequest;
-	this.built = false;
-	this.delegateData = data;
-}
-module.exports = DelegatedModule;
+const Module = require("./Module");
+const OriginalSource = require("webpack-sources").OriginalSource;
+const RawSource = require("webpack-sources").RawSource;
+const WebpackMissingModule = require("./dependencies/WebpackMissingModule");
+const DelegatedSourceDependency = require("./dependencies/DelegatedSourceDependency");
+
+class DelegatedModule extends Module {
+	constructor(sourceRequest, data, type, userRequest) {
+		super();
+		this.sourceRequest = sourceRequest;
+		this.request = data.id;
+		this.meta = data.meta;
+		this.type = type;
+		this.userRequest = userRequest;
+		this.built = false;
+		this.delegated = true;
+		this.delegateData = data;
+	}
 
-DelegatedModule.prototype = Object.create(Module.prototype);
-DelegatedModule.prototype.constructor = DelegatedModule;
+	identifier() {
+		return `delegated ${JSON.stringify(this.request)} from ${this.sourceRequest}`;
+	}
+
+	readableIdentifier() {
+		return `delegated ${this.userRequest} from ${this.sourceRequest}`;
+	}
 
-DelegatedModule.prototype.delegated = true;
+	needRebuild() {
+		return false;
+	}
 
-DelegatedModule.prototype.identifier = function() {
-	return "delegated " + JSON.stringify(this.request) + " from " + this.sourceRequest;
-};
+	build(options, compilation, resolver, fs, callback) {
+		this.built = true;
+		this.builtTime = new Date().getTime();
+		this.usedExports = true;
+		this.providedExports = this.delegateData.exports || true;
+		this.dependencies.length = 0;
+		this.addDependency(new DelegatedSourceDependency(this.sourceRequest));
+		callback();
+	}
 
-DelegatedModule.prototype.readableIdentifier = function() {
-	return "delegated " + this.userRequest + " from " + this.sourceRequest;
-};
+	unbuild() {
+		this.built = false;
+		super.unbuild();
+	}
 
-DelegatedModule.prototype.needRebuild = function() {
-	return false;
-};
+	source() {
+		const sourceModule = this.dependencies[0].module;
+		let str;
 
-DelegatedModule.prototype.build = function(options, compilation, resolver, fs, callback) {
-	this.built = true;
-	this.builtTime = new Date().getTime();
-	this.usedExports = true;
-	this.providedExports = this.delegateData.exports || true;
-	this.dependencies.length = 0;
-	this.addDependency(new DelegatedSourceDependency(this.sourceRequest));
-	callback();
-};
+		if(!sourceModule) {
+			str = WebpackMissingModule.moduleCode(this.sourceRequest);
+		} else {
+			str = `module.exports = (__webpack_require__(${sourceModule.id}))`;
 
-DelegatedModule.prototype.unbuild = function() {
-	this.built = false;
-	Module.prototype.unbuild.call(this);
-};
+			switch(this.type) {
+				case "require":
+					str += `(${JSON.stringify(this.request)})`;
+					break;
+				case "object":
+					str += `[${JSON.stringify(this.request)}]`;
+					break;
+			}
+		}
 
-DelegatedModule.prototype.source = function() {
-	var sourceModule = this.dependencies[0].module;
-	var str;
-	if(!sourceModule) {
-		str = WebpackMissingModule.moduleCode(this.sourceRequest);
-	} else {
-		str = "module.exports = (__webpack_require__(" + sourceModule.id + "))";
-		switch(this.type) {
-			case "require":
-				str += "(" + JSON.stringify(this.request) + ");";
-				break;
-			case "object":
-				str += "[" + JSON.stringify(this.request) + "];";
-				break;
+		if(this.useSourceMap) {
+			return new OriginalSource(str, this.identifier());
+		} else {
+			return new RawSource(str);
 		}
 	}
-	if(this.useSourceMap) {
-		return new OriginalSource(str, this.identifier());
-	} else {
-		return new RawSource(str);
+
+	size() {
+		return 42;
 	}
-};
+}
 
-DelegatedModule.prototype.size = function() {
-	return 42;
-};
+module.exports = DelegatedModule;

package/lib/DependenciesBlock.js

@@ -1,75 +1,81 @@
 /*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-var DependenciesBlockVariable = require("./DependenciesBlockVariable");
+ MIT License http://www.opensource.org/licenses/mit-license.php
+ Author Tobias Koppers @sokra
+ */
+"use strict";
 
-function DependenciesBlock() {
-	this.dependencies = [];
-	this.blocks = [];
-	this.variables = [];
+const DependenciesBlockVariable = require("./DependenciesBlockVariable");
+
+function disconnect(i) {
+	i.disconnect();
 }
-module.exports = DependenciesBlock;
 
-DependenciesBlock.prototype.addBlock = function(block) {
-	this.blocks.push(block);
-	block.parent = this;
-};
+function unseal(i) {
+	i.unseal();
+}
+
+class DependenciesBlock {
+	constructor() {
+		this.dependencies = [];
+		this.blocks = [];
+		this.variables = [];
+	}
+
+	addBlock(block) {
+		this.blocks.push(block);
+		block.parent = this;
+	}
+
+	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));
+	}
 
-DependenciesBlock.prototype.addVariable = function(name, expression, dependencies) {
-	for(var i = 0; i < this.variables.length; i++) {
-		var v = this.variables[i];
-		if(v.name === name && v.expression === expression) return;
+	addDependency(dependency) {
+		this.dependencies.push(dependency);
 	}
-	this.variables.push(new DependenciesBlockVariable(name, expression, dependencies));
-};
 
-DependenciesBlock.prototype.addDependency = function(dependency) {
-	this.dependencies.push(dependency);
-};
+	updateHash(hash) {
+		function updateHash(i) {
+			i.updateHash(hash);
+		}
 
-DependenciesBlock.prototype.updateHash = function(hash) {
-	this.dependencies.forEach(function(d) {
-		d.updateHash(hash);
-	});
-	this.blocks.forEach(function(b) {
-		b.updateHash(hash);
-	});
-	this.variables.forEach(function(v) {
-		v.updateHash(hash);
-	});
-};
+		this.dependencies.forEach(updateHash);
+		this.blocks.forEach(updateHash);
+		this.variables.forEach(updateHash);
+	}
 
-DependenciesBlock.prototype.disconnect = function() {
-	function disconnect(i) {
-		i.disconnect();
+	disconnect() {
+		this.dependencies.forEach(disconnect);
+		this.blocks.forEach(disconnect);
+		this.variables.forEach(disconnect);
 	}
-	this.dependencies.forEach(disconnect);
-	this.blocks.forEach(disconnect);
-	this.variables.forEach(disconnect);
-};
 
-DependenciesBlock.prototype.unseal = function() {
-	function unseal(i) {
-		i.unseal();
+	unseal() {
+		this.blocks.forEach(unseal);
 	}
-	this.blocks.forEach(unseal);
-};
 
-DependenciesBlock.prototype.hasDependencies = function(filter) {
-	if(filter) {
-		if(this.dependencies.some(filter)) return true;
-	} else {
-		if(this.dependencies.length > 0) return true;
+	hasDependencies(filter) {
+		if(filter) {
+			if(this.dependencies.some(filter)) {
+				return true;
+			}
+		} else {
+			if(this.dependencies.length > 0) {
+				return true;
+			}
+		}
+
+		return this.blocks.concat(this.variables).some(item => item.hasDependencies(filter));
 	}
 
-	return this.blocks.concat(this.variables).some(function(item) {
-		return item.hasDependencies(filter);
-	});
-};
+	sortItems() {
+		this.blocks.forEach(block => block.sortItems());
+	}
+}
 
-DependenciesBlock.prototype.sortItems = function() {
-	this.blocks.forEach(function(block) {
-		block.sortItems();
-	});
-};
+module.exports = DependenciesBlock;

package/lib/Dependency.js

@@ -44,6 +44,7 @@ class Dependency {
 		this.module = null;
 	}
 
+	// TODO: remove in webpack 3
 	compare(a, b) {
 		return compareLocations(a.loc, b.loc);
 	}

package/lib/EntryModuleNotFoundError.js

@@ -2,15 +2,21 @@
 	MIT License http://www.opensource.org/licenses/mit-license.php
 	Author Tobias Koppers @sokra
 */
-function EntryModuleNotFoundError(err) {
-	Error.call(this);
-	this.name = "EntryModuleNotFoundError";
-	this.message = "Entry module not found: " + err;
-	this.details = err.details;
-	this.error = err;
-	Error.captureStackTrace(this, EntryModuleNotFoundError);
+"use strict";
+
+const WebpackError = require("./WebpackError");
+
+class EntryModuleNotFoundError extends WebpackError {
+	constructor(err) {
+		super();
+
+		this.name = "EntryModuleNotFoundError";
+		this.message = "Entry module not found: " + err;
+		this.details = err.details;
+		this.error = err;
+
+		Error.captureStackTrace(this, this.constructor);
+	}
 }
-module.exports = EntryModuleNotFoundError;
 
-EntryModuleNotFoundError.prototype = Object.create(Error.prototype);
-EntryModuleNotFoundError.prototype.constructor = EntryModuleNotFoundError;
+module.exports = EntryModuleNotFoundError;

package/lib/ExtendedAPIPlugin.js

@@ -9,10 +9,12 @@ const ParserHelpers = require("./ParserHelpers");
 const NullFactory = require("./NullFactory");
 
 const REPLACEMENTS = {
-	__webpack_hash__: "__webpack_require__.h" // eslint-disable-line camelcase
+	__webpack_hash__: "__webpack_require__.h", // eslint-disable-line camelcase
+	__webpack_chunkname__: "__webpack_require__.cn" // eslint-disable-line camelcase
 };
 const REPLACEMENT_TYPES = {
-	__webpack_hash__: "string" // eslint-disable-line camelcase
+	__webpack_hash__: "string", // eslint-disable-line camelcase
+	__webpack_chunkname__: "string" // eslint-disable-line camelcase
 };
 
 class ExtendedAPIPlugin {
@@ -25,6 +27,9 @@ class ExtendedAPIPlugin {
 				buf.push("");
 				buf.push("// __webpack_hash__");
 				buf.push(`${this.requireFn}.h = ${JSON.stringify(hash)};`);
+				buf.push("");
+				buf.push("// __webpack_chunkname__");
+				buf.push(`${this.requireFn}.cn = ${JSON.stringify(chunk.name)};`);
 				return this.asString(buf);
 			});
 			compilation.mainTemplate.plugin("global-hash", () => true);

package/lib/ExternalModuleFactoryPlugin.js

@@ -2,20 +2,21 @@
 	MIT License http://www.opensource.org/licenses/mit-license.php
 	Author Tobias Koppers @sokra
 */
-var ExternalModule = require("./ExternalModule");
+"use strict";
 
-function ExternalModuleFactoryPlugin(type, externals) {
-	this.type = type;
-	this.externals = externals;
-}
-module.exports = ExternalModuleFactoryPlugin;
+const ExternalModule = require("./ExternalModule");
+
+class ExternalModuleFactoryPlugin {
+	constructor(type, externals) {
+		this.type = type;
+		this.externals = externals;
+	}
 
-ExternalModuleFactoryPlugin.prototype.apply = function(normalModuleFactory) {
-	var globalType = this.type;
-	normalModuleFactory.plugin("factory", function(factory) {
-		return function(data, callback) {
-			var context = data.context;
-			var dependency = data.dependencies[0];
+	apply(normalModuleFactory) {
+		const globalType = this.type;
+		normalModuleFactory.plugin("factory", factory => (data, callback) => {
+			const context = data.context;
+			const dependency = data.dependencies[0];
 
 			function handleExternal(value, type, callback) {
 				if(typeof type === "function") {
@@ -25,7 +26,7 @@ ExternalModuleFactoryPlugin.prototype.apply = function(normalModuleFactory) {
 				if(value === false) return factory(data, callback);
 				if(value === true) value = dependency.request;
 				if(typeof type === "undefined" && /^[a-z0-9]+ /.test(value)) {
-					var idx = value.indexOf(" ");
+					const idx = value.indexOf(" ");
 					type = value.substr(0, idx);
 					value = value.substr(idx + 1);
 				}
@@ -38,13 +39,14 @@ ExternalModuleFactoryPlugin.prototype.apply = function(normalModuleFactory) {
 						return handleExternal(dependency.request, callback);
 					}
 				} else if(Array.isArray(externals)) {
-					var i = 0;
+					let i = 0;
 					(function next() {
-						var handleExternalsAndCallback = function handleExternalsAndCallback(err, module) {
+						let asyncFlag;
+						const handleExternalsAndCallback = function handleExternalsAndCallback(err, module) {
 							if(err) return callback(err);
 							if(!module) {
-								if(async) {
-									async = false;
+								if(asyncFlag) {
+									asyncFlag = false;
 									return;
 								}
 								return next();
@@ -53,11 +55,11 @@ ExternalModuleFactoryPlugin.prototype.apply = function(normalModuleFactory) {
 						};
 
 						do {
-							var async = true;
+							asyncFlag = true;
 							if(i >= externals.length) return callback();
 							handleExternals(externals[i++], handleExternalsAndCallback);
-						} while (!async); // eslint-disable-line keyword-spacing
-						async = false;
+						} while (!asyncFlag); // eslint-disable-line keyword-spacing
+						asyncFlag = false;
 					}());
 					return;
 				} else if(externals instanceof RegExp) {
@@ -83,6 +85,7 @@ ExternalModuleFactoryPlugin.prototype.apply = function(normalModuleFactory) {
 				if(!module) return handleExternal(false, callback);
 				return callback(null, module);
 			}));
-		}.bind(this);
-	}.bind(this));
-};
+		});
+	}
+}
+module.exports = ExternalModuleFactoryPlugin;

package/lib/FlagDependencyUsagePlugin.js

@@ -2,92 +2,80 @@
 	MIT License http://www.opensource.org/licenses/mit-license.php
 	Author Tobias Koppers @sokra
 */
-function FlagDependencyUsagePlugin() {
+"use strict";
 
-}
-module.exports = FlagDependencyUsagePlugin;
+class FlagDependencyUsagePlugin {
+	apply(compiler) {
+		compiler.plugin("compilation", compilation => {
+			compilation.plugin("optimize-modules-advanced", modules => {
 
-FlagDependencyUsagePlugin.prototype.apply = function(compiler) {
-	compiler.plugin("compilation", function(compilation) {
-		compilation.plugin("optimize-modules-advanced", function(modules) {
+				modules.forEach(module => module.used = false);
 
-			modules.forEach(function(module) {
-				module.used = false;
-			});
+				const queue = [];
+				compilation.chunks.forEach(chunk => {
+					if(chunk.entryModule) {
+						processModule(chunk.entryModule, true);
+					}
+				});
 
-			var queue = [];
-			compilation.chunks.forEach(function(chunk) {
-				if(chunk.entryModule) {
-					processModule(chunk.entryModule, true);
+				while(queue.length) {
+					const queueItem = queue.pop();
+					processDependenciesBlock(queueItem[0], queueItem[1]);
 				}
-			});
-
-			while(queue.length) {
-				var queueItem = queue.pop();
-				processDependenciesBlock(queueItem[0], queueItem[1]);
-			}
 
-			function processModule(module, usedExports) {
-				module.used = true;
-				if(module.usedExports === true)
-					return;
-				else if(usedExports === true)
-					module.usedExports = true;
-				else if(Array.isArray(usedExports)) {
-					var old = module.usedExports ? module.usedExports.length : -1;
-					module.usedExports = addToSet(module.usedExports || [], usedExports);
-					if(module.usedExports.length === old)
+				function processModule(module, usedExports) {
+					module.used = true;
+					if(module.usedExports === true)
 						return;
-				} else if(Array.isArray(module.usedExports))
-					return;
-				else
-					module.usedExports = false;
-
-				queue.push([module, module.usedExports]);
-			}
+					else if(usedExports === true)
+						module.usedExports = true;
+					else if(Array.isArray(usedExports)) {
+						var old = module.usedExports ? module.usedExports.length : -1;
+						module.usedExports = addToSet(module.usedExports || [], usedExports);
+						if(module.usedExports.length === old)
+							return;
+					} else if(Array.isArray(module.usedExports))
+						return;
+					else
+						module.usedExports = false;
 
-			function processDependenciesBlock(depBlock, usedExports) {
-				depBlock.dependencies.forEach(function(dep) {
-					processDependency(dep, usedExports);
-				});
-				depBlock.variables.forEach(function(variable) {
-					variable.dependencies.forEach(function(dep) {
-						processDependency(dep, usedExports);
-					});
-				});
-				depBlock.blocks.forEach(function(block) {
-					queue.push([block, usedExports]);
-				});
-			}
+					queue.push([module, module.usedExports]);
+				}
 
-			function processDependency(dep, usedExports) {
-				var reference = dep.getReference && dep.getReference();
-				if(!reference) return;
-				var module = reference.module;
-				var importedNames = reference.importedNames;
-				var oldUsed = module.used;
-				var oldUsedExports = module.usedExports;
-				if(!oldUsed || (importedNames && (!oldUsedExports || !isSubset(oldUsedExports, importedNames)))) {
-					processModule(module, importedNames);
+				function processDependenciesBlock(depBlock, usedExports) {
+					depBlock.dependencies.forEach(dep => processDependency(dep));
+					depBlock.variables.forEach(variable => variable.dependencies.forEach(dep => processDependency(dep)));
+					depBlock.blocks.forEach(block => queue.push([block, usedExports]));
 				}
-			}
 
-		});
+				function processDependency(dep) {
+					const reference = dep.getReference && dep.getReference();
+					if(!reference) return;
+					const module = reference.module;
+					const importedNames = reference.importedNames;
+					const oldUsed = module.used;
+					const oldUsedExports = module.usedExports;
+					if(!oldUsed || (importedNames && (!oldUsedExports || !isSubset(oldUsedExports, importedNames)))) {
+						processModule(module, importedNames);
+					}
+				}
 
-		function addToSet(a, b) {
-			b.forEach(function(item) {
-				if(a.indexOf(item) < 0)
-					a.push(item);
 			});
-			return a;
-		}
 
-		function isSubset(biggerSet, subset) {
-			if(biggerSet === true) return true;
-			if(subset === true) return false;
-			return subset.every(function(item) {
-				return biggerSet.indexOf(item) >= 0;
-			});
-		}
-	});
-};
+			function addToSet(a, b) {
+				b.forEach(item => {
+					if(a.indexOf(item) < 0)
+						a.push(item);
+				});
+				return a;
+			}
+
+			function isSubset(biggerSet, subset) {
+				if(biggerSet === true) return true;
+				if(subset === true) return false;
+				return subset.every(item => biggerSet.indexOf(item) >= 0);
+			}
+		});
+	}
+}
+module.exports = FlagDependencyUsagePlugin;