webpack 2.2.0-rc.6 → 2.2.1

package/lib/node/NodeWatchFileSystem.js

@@ -2,64 +2,65 @@
 	MIT License http://www.opensource.org/licenses/mit-license.php
 	Author Tobias Koppers @sokra
 */
-var Watchpack = require("watchpack");
+"use strict";
 
-function NodeWatchFileSystem(inputFileSystem) {
-	this.inputFileSystem = inputFileSystem;
-	this.watcherOptions = {
-		aggregateTimeout: 0
-	};
-	this.watcher = new Watchpack(this.watcherOptions);
-}
+const Watchpack = require("watchpack");
 
-module.exports = NodeWatchFileSystem;
+class NodeWatchFileSystem {
+	constructor(inputFileSystem) {
+		this.inputFileSystem = inputFileSystem;
+		this.watcherOptions = {
+			aggregateTimeout: 0
+		};
+		this.watcher = new Watchpack(this.watcherOptions);
+	}
 
-NodeWatchFileSystem.prototype.watch = function watch(files, dirs, missing, startTime, options, callback, callbackUndelayed) {
-	if(!Array.isArray(files))
-		throw new Error("Invalid arguments: 'files'");
-	if(!Array.isArray(dirs))
-		throw new Error("Invalid arguments: 'dirs'");
-	if(!Array.isArray(missing))
-		throw new Error("Invalid arguments: 'missing'");
-	if(typeof callback !== "function")
-		throw new Error("Invalid arguments: 'callback'");
-	if(typeof startTime !== "number" && startTime)
-		throw new Error("Invalid arguments: 'startTime'");
-	if(typeof options !== "object")
-		throw new Error("Invalid arguments: 'options'");
-	if(typeof callbackUndelayed !== "function" && callbackUndelayed)
-		throw new Error("Invalid arguments: 'callbackUndelayed'");
-	var oldWatcher = this.watcher;
-	this.watcher = new Watchpack(options);
+	watch(files, dirs, missing, startTime, options, callback, callbackUndelayed) {
+		if(!Array.isArray(files))
+			throw new Error("Invalid arguments: 'files'");
+		if(!Array.isArray(dirs))
+			throw new Error("Invalid arguments: 'dirs'");
+		if(!Array.isArray(missing))
+			throw new Error("Invalid arguments: 'missing'");
+		if(typeof callback !== "function")
+			throw new Error("Invalid arguments: 'callback'");
+		if(typeof startTime !== "number" && startTime)
+			throw new Error("Invalid arguments: 'startTime'");
+		if(typeof options !== "object")
+			throw new Error("Invalid arguments: 'options'");
+		if(typeof callbackUndelayed !== "function" && callbackUndelayed)
+			throw new Error("Invalid arguments: 'callbackUndelayed'");
+		const oldWatcher = this.watcher;
+		this.watcher = new Watchpack(options);
 
-	if(callbackUndelayed)
-		this.watcher.once("change", callbackUndelayed);
+		if(callbackUndelayed)
+			this.watcher.once("change", callbackUndelayed);
 
-	this.watcher.once("aggregated", function(changes) {
-		if(this.inputFileSystem && this.inputFileSystem.purge) {
-			this.inputFileSystem.purge(changes);
-		}
-		var times = this.watcher.getTimes();
-		callback(null, changes.filter(function(file) {
-			return files.indexOf(file) >= 0;
-		}).sort(), changes.filter(function(file) {
-			return dirs.indexOf(file) >= 0;
-		}).sort(), changes.filter(function(file) {
-			return missing.indexOf(file) >= 0;
-		}).sort(), times, times);
-	}.bind(this));
+		this.watcher.once("aggregated", (changes) => {
+			if(this.inputFileSystem && this.inputFileSystem.purge) {
+				this.inputFileSystem.purge(changes);
+			}
+			const times = this.watcher.getTimes();
+			callback(null,
+				changes.filter(file => files.indexOf(file) >= 0).sort(),
+				changes.filter(file => dirs.indexOf(file) >= 0).sort(),
+				changes.filter(file => missing.indexOf(file) >= 0).sort(), times, times);
+		});
 
-	this.watcher.watch(files.concat(missing), dirs, startTime);
+		this.watcher.watch(files.concat(missing), dirs, startTime);
 
-	if(oldWatcher) {
-		oldWatcher.close();
+		if(oldWatcher) {
+			oldWatcher.close();
+		}
+		return {
+			close: () => {
+				this.watcher.close();
+			},
+			pause: () => {
+				this.watcher.pause();
+			}
+		};
 	}
-	return {
-		close: function() {
-			this.watcher.close();
-		}.bind(this),
-		pause: function() {
-			this.watcher.pause();
-		}.bind(this)
-	};
-};
+}
+
+module.exports = NodeWatchFileSystem;

package/lib/optimize/CommonsChunkPlugin.js

@@ -2,183 +2,180 @@
 	MIT License http://www.opensource.org/licenses/mit-license.php
 	Author Tobias Koppers @sokra
 */
-var nextIdent = 0;
+"use strict";
+let nextIdent = 0;
+class CommonsChunkPlugin {
+	constructor(options) {
+		if(arguments.length > 1) {
+			throw new Error(`Deprecation notice: CommonsChunkPlugin now only takes a single argument. Either an options
+object *or* the name of the chunk.
+Example: if your old code looked like this:
+	new webpack.optimize.CommonsChunkPlugin('vendor', 'vendor.bundle.js')
+You would change it to:
+	new webpack.optimize.CommonsChunkPlugin({ name: 'vendor', filename: 'vendor.bundle.js' })
+The available options are:
+	name: string
+	names: string[]
+	filename: string
+	minChunks: number
+	chunks: string[]
+	children: boolean
+	async: boolean
+	minSize: number`);
+		}
 
-function CommonsChunkPlugin(options) {
-	if(arguments.length > 1) {
-		throw new Error("Deprecation notice: CommonsChunkPlugin now only takes a single argument. Either an options " +
-			"object *or* the name of the chunk.\n" +
-			"Example: if your old code looked like this:\n" +
-			"    new webpack.optimize.CommonsChunkPlugin('vendor', 'vendor.bundle.js')\n\n" +
-			"You would change it to:\n" +
-			"    new webpack.optimize.CommonsChunkPlugin({ name: 'vendor', filename: 'vendor.bundle.js' })\n\n" +
-			"The available options are:\n" +
-			"    name: string\n" +
-			"    names: string[]\n" +
-			"    filename: string\n" +
-			"    minChunks: number\n" +
-			"    chunks: string[]\n" +
-			"    children: boolean\n" +
-			"    async: boolean\n" +
-			"    minSize: number\n");
+		if(Array.isArray(options) || typeof options === "string") {
+			options = {
+				name: options
+			};
+		}
+		this.chunkNames = options.name || options.names;
+		this.filenameTemplate = options.filename;
+		this.minChunks = options.minChunks;
+		this.selectedChunks = options.chunks;
+		if(options.children) this.selectedChunks = false;
+		this.async = options.async;
+		this.minSize = options.minSize;
+		this.ident = __filename + (nextIdent++);
 	}
-	if(Array.isArray(options) || typeof options === "string") {
-		options = {
-			name: options
-		};
-	}
-	this.chunkNames = options.name || options.names;
-	this.filenameTemplate = options.filename;
-	this.minChunks = options.minChunks;
-	this.selectedChunks = options.chunks;
-	if(options.children) this.selectedChunks = false;
-	this.async = options.async;
-	this.minSize = options.minSize;
-	this.ident = __filename + (nextIdent++);
-}
-
-module.exports = CommonsChunkPlugin;
-CommonsChunkPlugin.prototype.apply = function(compiler) {
-	var chunkNames = this.chunkNames;
-	var filenameTemplate = this.filenameTemplate;
-	var minChunks = this.minChunks;
-	var selectedChunks = this.selectedChunks;
-	var asyncOption = this.async;
-	var minSize = this.minSize;
-	var ident = this.ident;
-	compiler.plugin("this-compilation", function(compilation) {
-		compilation.plugin(["optimize-chunks", "optimize-extracted-chunks"], function(chunks) {
-			// only optimize once
-			if(compilation[ident]) return;
-			compilation[ident] = true;
+	apply(compiler) {
+		const chunkNames = this.chunkNames;
+		const filenameTemplate = this.filenameTemplate;
+		const minChunks = this.minChunks;
+		const selectedChunks = this.selectedChunks;
+		const asyncOption = this.async;
+		const minSize = this.minSize;
+		const ident = this.ident;
+		compiler.plugin("this-compilation", (compilation) => {
+			compilation.plugin(["optimize-chunks", "optimize-extracted-chunks"], (chunks) => {
+				// only optimize once
+				if(compilation[ident]) return;
+				compilation[ident] = true;
 
-			var commonChunks;
-			if(!chunkNames && (selectedChunks === false || asyncOption)) {
-				commonChunks = chunks;
-			} else if(Array.isArray(chunkNames) || typeof chunkNames === "string") {
-				commonChunks = [].concat(chunkNames).map(function(chunkName) {
-					var chunk = chunks.filter(function(chunk) {
-						return chunk.name === chunkName;
-					})[0];
-					if(!chunk) {
-						chunk = this.addChunk(chunkName);
-					}
-					return chunk;
-				}, this);
-			} else {
-				throw new Error("Invalid chunkNames argument");
-			}
-			commonChunks.forEach(function processCommonChunk(commonChunk, idx) {
-				var usedChunks;
-				if(Array.isArray(selectedChunks)) {
-					usedChunks = chunks.filter(function(chunk) {
-						if(chunk === commonChunk) return false;
-						return selectedChunks.indexOf(chunk.name) >= 0;
-					});
-				} else if(selectedChunks === false || asyncOption) {
-					usedChunks = (commonChunk.chunks || []).filter(function(chunk) {
-						// we can only move modules from this chunk if the "commonChunk" is the only parent
-						return asyncOption || chunk.parents.length === 1;
+				let commonChunks;
+				if(!chunkNames && (selectedChunks === false || asyncOption)) {
+					commonChunks = chunks;
+				} else if(Array.isArray(chunkNames) || typeof chunkNames === "string") {
+					commonChunks = [].concat(chunkNames).map((chunkName) => {
+						let chunk = chunks.filter((chunk) => chunk.name === chunkName)[0];
+						if(!chunk) {
+							chunk = compilation.addChunk(chunkName);
+						}
+						return chunk;
 					});
 				} else {
-					if(commonChunk.parents.length > 0) {
-						compilation.errors.push(new Error("CommonsChunkPlugin: While running in normal mode it's not allowed to use a non-entry chunk (" + commonChunk.name + ")"));
-						return;
-					}
-					usedChunks = chunks.filter(function(chunk) {
-						var found = commonChunks.indexOf(chunk);
-						if(found >= idx) return false;
-						return chunk.hasRuntime();
-					});
+					throw new Error("Invalid chunkNames argument");
 				}
-				if(asyncOption) {
-					var asyncChunk = this.addChunk(typeof asyncOption === "string" ? asyncOption : undefined);
-					asyncChunk.chunkReason = "async commons chunk";
-					asyncChunk.extraAsync = true;
-					asyncChunk.addParent(commonChunk);
-					commonChunk.addChunk(asyncChunk);
-					commonChunk = asyncChunk;
-				}
-				var reallyUsedModules = [];
-				if(minChunks !== Infinity) {
-					var commonModulesCount = [];
-					var commonModules = [];
-					usedChunks.forEach(function(chunk) {
-						chunk.modules.forEach(function(module) {
-							var idx = commonModules.indexOf(module);
-							if(idx < 0) {
-								commonModules.push(module);
-								commonModulesCount.push(1);
-							} else {
-								commonModulesCount[idx]++;
-							}
+				commonChunks.forEach(function processCommonChunk(commonChunk, idx) {
+					let usedChunks;
+					if(Array.isArray(selectedChunks)) {
+						usedChunks = chunks.filter(chunk => chunk !== commonChunk && selectedChunks.indexOf(chunk.name) >= 0);
+					} else if(selectedChunks === false || asyncOption) {
+						usedChunks = (commonChunk.chunks || []).filter((chunk) => {
+							// we can only move modules from this chunk if the "commonChunk" is the only parent
+							return asyncOption || chunk.parents.length === 1;
 						});
-					});
-					var _minChunks = (minChunks || Math.max(2, usedChunks.length));
-					commonModulesCount.forEach(function(count, idx) {
-						var module = commonModules[idx];
-						if(typeof minChunks === "function") {
-							if(!minChunks(module, count))
-								return;
-						} else if(count < _minChunks) {
+					} else {
+						if(commonChunk.parents.length > 0) {
+							compilation.errors.push(new Error("CommonsChunkPlugin: While running in normal mode it's not allowed to use a non-entry chunk (" + commonChunk.name + ")"));
 							return;
 						}
-						if(module.chunkCondition && !module.chunkCondition(commonChunk))
-							return;
-						reallyUsedModules.push(module);
-					});
-				}
-				if(minSize) {
-					var size = reallyUsedModules.reduce(function(a, b) {
-						return a + b.size();
-					}, 0);
-					if(size < minSize)
-						return;
-				}
-				var reallyUsedChunks = [];
-				reallyUsedModules.forEach(function(module) {
-					usedChunks.forEach(function(chunk) {
-						if(module.removeChunk(chunk)) {
-							if(reallyUsedChunks.indexOf(chunk) < 0)
-								reallyUsedChunks.push(chunk);
-						}
-					});
-					commonChunk.addModule(module);
-					module.addChunk(commonChunk);
-				});
-				if(asyncOption) {
-					reallyUsedChunks.forEach(function(chunk) {
-						if(chunk.isInitial())
-							return;
-						chunk.blocks.forEach(function(block) {
-							block.chunks.unshift(commonChunk);
-							commonChunk.addBlock(block);
+						usedChunks = chunks.filter((chunk) => {
+							const found = commonChunks.indexOf(chunk);
+							if(found >= idx) return false;
+							return chunk.hasRuntime();
 						});
-					});
-					asyncChunk.origins = reallyUsedChunks.map(function(chunk) {
-						return chunk.origins.map(function(origin) {
-							var newOrigin = Object.create(origin);
-							newOrigin.reasons = (origin.reasons || []).slice();
-							newOrigin.reasons.push("async commons");
-							return newOrigin;
+					}
+					let asyncChunk;
+					if(asyncOption) {
+						asyncChunk = compilation.addChunk(typeof asyncOption === "string" ? asyncOption : undefined);
+						asyncChunk.chunkReason = "async commons chunk";
+						asyncChunk.extraAsync = true;
+						asyncChunk.addParent(commonChunk);
+						commonChunk.addChunk(asyncChunk);
+						commonChunk = asyncChunk;
+					}
+					const reallyUsedModules = [];
+					if(minChunks !== Infinity) {
+						const commonModulesCount = [];
+						const commonModules = [];
+						usedChunks.forEach((chunk) => {
+							chunk.modules.forEach((module) => {
+								const idx = commonModules.indexOf(module);
+								if(idx < 0) {
+									commonModules.push(module);
+									commonModulesCount.push(1);
+								} else {
+									commonModulesCount[idx]++;
+								}
+							});
 						});
-					}).reduce(function(arr, a) {
-						arr.push.apply(arr, a);
-						return arr;
-					}, []);
-				} else {
-					usedChunks.forEach(function(chunk) {
-						chunk.parents = [commonChunk];
-						chunk.entrypoints.forEach(function(ep) {
-							ep.insertChunk(commonChunk, chunk);
+						const _minChunks = (minChunks || Math.max(2, usedChunks.length));
+						commonModulesCount.forEach((count, idx) => {
+							const module = commonModules[idx];
+							if(typeof minChunks === "function") {
+								if(!minChunks(module, count))
+									return;
+							} else if(count < _minChunks) {
+								return;
+							}
+							if(module.chunkCondition && !module.chunkCondition(commonChunk))
+								return;
+							reallyUsedModules.push(module);
 						});
-						commonChunk.addChunk(chunk);
+					}
+					if(minSize) {
+						const size = reallyUsedModules.reduce((a, b) => {
+							return a + b.size();
+						}, 0);
+						if(size < minSize)
+							return;
+					}
+					const reallyUsedChunks = new Set();
+					reallyUsedModules.forEach((module) => {
+						usedChunks.forEach((chunk) => {
+							if(module.removeChunk(chunk)) {
+								reallyUsedChunks.add(chunk);
+							}
+						});
+						commonChunk.addModule(module);
+						module.addChunk(commonChunk);
 					});
-				}
-				if(filenameTemplate)
-					commonChunk.filenameTemplate = filenameTemplate;
-			}, this);
-			return true;
+					if(asyncOption) {
+						for(const chunk of reallyUsedChunks) {
+							if(chunk.isInitial()) continue;
+							chunk.blocks.forEach((block) => {
+								block.chunks.unshift(commonChunk);
+								commonChunk.addBlock(block);
+							});
+						}
+						asyncChunk.origins = Array.from(reallyUsedChunks).map((chunk) => {
+							return chunk.origins.map((origin) => {
+								const newOrigin = Object.create(origin);
+								newOrigin.reasons = (origin.reasons || []).slice();
+								newOrigin.reasons.push("async commons");
+								return newOrigin;
+							});
+						}).reduce((arr, a) => {
+							arr.push.apply(arr, a);
+							return arr;
+						}, []);
+					} else {
+						usedChunks.forEach((chunk) => {
+							chunk.parents = [commonChunk];
+							chunk.entrypoints.forEach((ep) => {
+								ep.insertChunk(commonChunk, chunk);
+							});
+							commonChunk.addChunk(chunk);
+						});
+					}
+					if(filenameTemplate)
+						commonChunk.filenameTemplate = filenameTemplate;
+				});
+				return true;
+			});
 		});
-	});
-};
+	}
+}
+
+module.exports = CommonsChunkPlugin;

package/lib/optimize/RemoveParentModulesPlugin.js

@@ -24,32 +24,35 @@ function hasModule(chunk, module, checkedChunks) {
 
 function allHaveModule(someChunks, module, checkedChunks) {
 	if(!checkedChunks) checkedChunks = [];
-	let chunks = [];
+	var chunks = [];
 	for(var i = 0; i < someChunks.length; i++) {
 		checkedChunks.push(someChunks[i]);
-		const subChunks = hasModule(someChunks[i], module, checkedChunks);
+		var subChunks = hasModule(someChunks[i], module, checkedChunks);
 		if(!subChunks) return false;
-		addToSet(chunks, subChunks);
+
+		for(var index = 0; index < subChunks.length; index++) {
+			var item = subChunks[index];
+
+			if(!chunks.length || chunks.indexOf(item) < 0) {
+				chunks.push(item);
+			}
+		}
 	}
 	return chunks;
 }
 
-function addToSet(set, items) {
-	items.forEach((item) => {
-		if(set.indexOf(item) < 0)
-			set.push(item);
-	});
-}
-
 function debugIds(chunks) {
-	const list = chunks.map((chunk) => {
-		return chunk.debugId;
-	});
-	const debugIdMissing = list.some((dId) => {
-		return typeof dId !== "number";
-	});
-	if(debugIdMissing)
-		return "no";
+	var list = [];
+	for(var i = 0; i < chunks.length; i++) {
+		var debugId = chunks[i].debugId;
+
+		if(typeof debugId !== "number") {
+			return "no";
+		}
+
+		list.push(debugId);
+	}
+
 	list.sort();
 	return list.join(",");
 }
@@ -58,13 +61,19 @@ class RemoveParentModulesPlugin {
 	apply(compiler) {
 		compiler.plugin("compilation", (compilation) => {
 			compilation.plugin(["optimize-chunks-basic", "optimize-extracted-chunks-basic"], (chunks) => {
-				chunks.forEach((chunk) => {
-					const cache = {};
-					chunk.modules.slice().forEach((module) => {
-						if(chunk.parents.length === 0) return;
-						const dId = "$" + debugIds(module.chunks);
-						let parentChunksWithModule;
-						if((dId in cache) && dId !== "$no") {
+				for(var index = 0; index < chunks.length; index++) {
+					var chunk = chunks[index];
+
+					// TODO consider Map when performance has improved https://gist.github.com/sokra/b36098368da7b8f6792fd7c85fca6311
+					var cache = Object.create(null);
+					var modules = chunk.modules.slice();
+					for(var i = 0; i < modules.length; i++) {
+						var module = modules[i];
+
+						if(chunk.parents.length === 0) continue;
+						var dId = debugIds(module.chunks);
+						var parentChunksWithModule;
+						if((dId in cache) && dId !== "no") {
 							parentChunksWithModule = cache[dId];
 						} else {
 							parentChunksWithModule = cache[dId] = allHaveModule(chunk.parents, module);
@@ -73,8 +82,8 @@ class RemoveParentModulesPlugin {
 							module.rewriteChunkInReasons(chunk, parentChunksWithModule);
 							chunk.removeModule(module);
 						}
-					});
-				});
+					}
+				}
 			});
 		});
 	}

package/lib/validateSchema.js

@@ -2,8 +2,10 @@
 	MIT License http://www.opensource.org/licenses/mit-license.php
 	Author Gajus Kuizinas @gajus
 */
-var Ajv = require("ajv");
-var ajv = new Ajv({
+"use strict";
+
+const Ajv = require("ajv");
+const ajv = new Ajv({
 	errorDataPath: "configuration",
 	allErrors: true,
 	verbose: true
@@ -12,16 +14,16 @@ require("ajv-keywords")(ajv, ["instanceof"]);
 
 function validateSchema(schema, options) {
 	if(Array.isArray(options)) {
-		var errors = options.map(validateObject.bind(this, schema));
-		errors.forEach(function(list, idx) {
+		const errors = options.map((options) => validateObject(schema, options));
+		errors.forEach((list, idx) => {
 			list.forEach(function applyPrefix(err) {
-				err.dataPath = "[" + idx + "]" + err.dataPath;
+				err.dataPath = `[${idx}]${err.dataPath}`;
 				if(err.children) {
 					err.children.forEach(applyPrefix);
 				}
 			});
 		});
-		return errors.reduce(function(arr, items) {
+		return errors.reduce((arr, items) => {
 			return arr.concat(items);
 		}, []);
 	} else {
@@ -30,22 +32,20 @@ function validateSchema(schema, options) {
 }
 
 function validateObject(schema, options) {
-	var validate = ajv.compile(schema);
-	var valid = validate(options);
+	const validate = ajv.compile(schema);
+	const valid = validate(options);
 	return valid ? [] : filterErrors(validate.errors);
 }
 
 function filterErrors(errors) {
-	var newErrors = [];
-	errors.forEach(function(err) {
-		var dataPath = err.dataPath;
-		var children = [];
-		newErrors = newErrors.filter(function(oldError) {
-			if(oldError.dataPath.indexOf(dataPath) >= 0) {
+	let newErrors = [];
+	errors.forEach((err) => {
+		const dataPath = err.dataPath;
+		let children = [];
+		newErrors = newErrors.filter((oldError) => {
+			if(oldError.dataPath.includes(dataPath)) {
 				if(oldError.children) {
-					oldError.children.forEach(function(child) {
-						children.push(child);
-					});
+					children = children.concat(oldError.children.slice(0));
 				}
 				oldError.children = undefined;
 				children.push(oldError);
@@ -58,7 +58,7 @@ function filterErrors(errors) {
 		}
 		newErrors.push(err);
 	});
-	//console.log(JSON.stringify(newErrors, 0, 2));
+
 	return newErrors;
 }