webpack 2.1.0-beta.21 → 2.1.0-beta.25

package/lib/dependencies/HarmonyModulesPlugin.js

@@ -46,9 +46,16 @@ HarmonyModulesPlugin.prototype.apply = function(compiler) {
 
 		compilation.dependencyFactories.set(HarmonyAcceptImportDependency, normalModuleFactory);
 		compilation.dependencyTemplates.set(HarmonyAcceptImportDependency, new HarmonyAcceptImportDependency.Template());
+
+		params.normalModuleFactory.plugin("parser", function(parser, parserOptions) {
+
+			if(typeof parserOptions.harmony !== "undefined" && !parserOptions.harmony)
+				return;
+
+			parser.apply(
+				new HarmonyImportDependencyParserPlugin(),
+				new HarmonyExportDependencyParserPlugin()
+			);
+		});
 	});
-	compiler.parser.apply(
-		new HarmonyImportDependencyParserPlugin(),
-		new HarmonyExportDependencyParserPlugin()
-	);
 };

package/lib/dependencies/RequireContextPlugin.js

@@ -28,9 +28,16 @@ RequireContextPlugin.prototype.apply = function(compiler) {
 		compilation.dependencyTemplates.set(RequireContextDependency, new RequireContextDependency.Template());
 
 		compilation.dependencyFactories.set(ContextElementDependency, normalModuleFactory);
-	});
-	compiler.plugin("context-module-factory", function(cmf) {
-		cmf.plugin("alternatives", function(items, callback) {
+
+		params.normalModuleFactory.plugin("parser", function(parser, parserOptions) {
+
+			if(typeof parserOptions.requireContext !== "undefined" && !parserOptions.requireContext)
+				return;
+
+			parser.apply(new RequireContextDependencyParserPlugin());
+		});
+
+		params.contextModuleFactory.plugin("alternatives", function(items, callback) {
 			if(items.length === 0) return callback(null, items);
 
 			callback(null, items.map(function(obj) {
@@ -48,7 +55,8 @@ RequireContextPlugin.prototype.apply = function(compiler) {
 				return a.concat(b);
 			}, []));
 		});
-		cmf.plugin("alternatives", function(items, callback) {
+
+		params.contextModuleFactory.plugin("alternatives", function(items, callback) {
 			if(items.length === 0) return callback(null, items);
 
 			callback(null, items.map(function(obj) {
@@ -64,5 +72,4 @@ RequireContextPlugin.prototype.apply = function(compiler) {
 			}));
 		});
 	});
-	new RequireContextDependencyParserPlugin().apply(compiler.parser);
 };

package/lib/dependencies/RequireEnsurePlugin.js

@@ -24,15 +24,22 @@ RequireEnsurePlugin.prototype.apply = function(compiler) {
 
 		compilation.dependencyFactories.set(RequireEnsureDependency, new NullFactory());
 		compilation.dependencyTemplates.set(RequireEnsureDependency, new RequireEnsureDependency.Template());
-	});
-	new RequireEnsureDependenciesBlockParserPlugin().apply(compiler.parser);
-	compiler.parser.plugin("evaluate typeof require.ensure", function(expr) {
-		return new BasicEvaluatedExpression().setString("function").setRange(expr.range);
-	});
-	compiler.parser.plugin("typeof require.ensure", function(expr) {
-		var dep = new ConstDependency("'function'", expr.range);
-		dep.loc = expr.loc;
-		this.state.current.addDependency(dep);
-		return true;
+
+		params.normalModuleFactory.plugin("parser", function(parser, parserOptions) {
+
+			if(typeof parserOptions.requireEnsure !== "undefined" && !parserOptions.requireEnsure)
+				return;
+
+			parser.apply(new RequireEnsureDependenciesBlockParserPlugin());
+			parser.plugin("evaluate typeof require.ensure", function(expr) {
+				return new BasicEvaluatedExpression().setString("function").setRange(expr.range);
+			});
+			parser.plugin("typeof require.ensure", function(expr) {
+				var dep = new ConstDependency("'function'", expr.range);
+				dep.loc = expr.loc;
+				this.state.current.addDependency(dep);
+				return true;
+			});
+		});
 	});
 };

package/lib/dependencies/RequireIncludePlugin.js

@@ -17,15 +17,23 @@ RequireIncludePlugin.prototype.apply = function(compiler) {
 
 		compilation.dependencyFactories.set(RequireIncludeDependency, normalModuleFactory);
 		compilation.dependencyTemplates.set(RequireIncludeDependency, new RequireIncludeDependency.Template());
-	});
-	new RequireIncludeDependencyParserPlugin().apply(compiler.parser);
-	compiler.parser.plugin("evaluate typeof require.include", function(expr) {
-		return new BasicEvaluatedExpression().setString("function").setRange(expr.range);
-	});
-	compiler.parser.plugin("typeof require.include", function(expr) {
-		var dep = new ConstDependency("'function'", expr.range);
-		dep.loc = expr.loc;
-		this.state.current.addDependency(dep);
-		return true;
+
+		params.normalModuleFactory.plugin("parser", function(parser, parserOptions) {
+
+			if(typeof parserOptions.requireInclude !== "undefined" && !parserOptions.requireInclude)
+				return;
+
+			parser.apply(new RequireIncludeDependencyParserPlugin());
+			parser.plugin("evaluate typeof require.include", function(expr) {
+				return new BasicEvaluatedExpression().setString("function").setRange(expr.range);
+			});
+			parser.plugin("typeof require.include", function(expr) {
+				var dep = new ConstDependency("'function'", expr.range);
+				dep.loc = expr.loc;
+				this.state.current.addDependency(dep);
+				return true;
+			});
+
+		});
 	});
 };

package/lib/dependencies/SystemPlugin.js

@@ -17,28 +17,7 @@ function SystemPlugin(options) {
 module.exports = SystemPlugin;
 
 SystemPlugin.prototype.apply = function(compiler) {
-	function setTypeof(expr, value) {
-		compiler.parser.plugin("evaluate typeof " + expr, function(expr) {
-			return new BasicEvaluatedExpression().setString(value).setRange(expr.range);
-		});
-		compiler.parser.plugin("typeof " + expr, function(expr) {
-			var dep = new ConstDependency(JSON.stringify(value), expr.range);
-			dep.loc = expr.loc;
-			this.state.current.addDependency(dep);
-			return true;
-		});
-	}
-
-	function setNotSupported(expr) {
-		compiler.parser.plugin("expression " + expr, function(expr) {
-			var dep = new ConstDependency("(void 0)", expr.range);
-			dep.loc = expr.loc;
-			this.state.current.addDependency(dep);
-			if(!this.state.module) return;
-			this.state.module.warnings.push(new UnsupportedFeatureWarning(this.state.module, expr + " is not supported by webpack."));
-			return true;
-		});
-	}
+	var options = this.options;
 	compiler.plugin("compilation", function(compilation, params) {
 		var normalModuleFactory = params.normalModuleFactory;
 		var contextModuleFactory = params.contextModuleFactory;
@@ -48,12 +27,52 @@ SystemPlugin.prototype.apply = function(compiler) {
 
 		compilation.dependencyFactories.set(SystemImportContextDependency, contextModuleFactory);
 		compilation.dependencyTemplates.set(SystemImportContextDependency, new SystemImportContextDependency.Template());
+
+		params.normalModuleFactory.plugin("parser", function(parser, parserOptions) {
+
+			if(typeof parserOptions.system !== "undefined" && !parserOptions.system)
+				return;
+
+			function setTypeof(expr, value) {
+				parser.plugin("evaluate typeof " + expr, function(expr) {
+					return new BasicEvaluatedExpression().setString(value).setRange(expr.range);
+				});
+				parser.plugin("typeof " + expr, function(expr) {
+					var dep = new ConstDependency(JSON.stringify(value), expr.range);
+					dep.loc = expr.loc;
+					this.state.current.addDependency(dep);
+					return true;
+				});
+			}
+
+			function setNotSupported(name) {
+				parser.plugin("evaluate typeof " + name, function(expr) {
+					return new BasicEvaluatedExpression().setString("undefined").setRange(expr.range);
+				});
+				parser.plugin("expression " + name, function(expr) {
+					var dep = new ConstDependency("(void 0)", expr.range);
+					dep.loc = expr.loc;
+					this.state.current.addDependency(dep);
+					if(!this.state.module) return;
+					this.state.module.warnings.push(new UnsupportedFeatureWarning(this.state.module, name + " is not supported by webpack."));
+					return true;
+				});
+			}
+
+			setTypeof("System", "object");
+			setTypeof("System.import", "function");
+			setNotSupported("System.set");
+			setNotSupported("System.get");
+			setNotSupported("System.register");
+			parser.plugin("expression System", function(expr) {
+				var dep = new ConstDependency("{}", expr.range);
+				dep.loc = expr.loc;
+				this.state.current.addDependency(dep);
+				return true;
+			});
+			parser.apply(
+				new SystemImportParserPlugin(options)
+			);
+		});
 	});
-	setTypeof("System", "object");
-	setTypeof("System.import", "function");
-	setNotSupported("System.set");
-	setNotSupported("System.get");
-	compiler.parser.apply(
-		new SystemImportParserPlugin(this.options)
-	);
 };

package/lib/node/NodeMainTemplate.runtime.js

@@ -2,7 +2,7 @@
 	MIT License http://www.opensource.org/licenses/mit-license.php
 	Author Tobias Koppers @sokra
 */
-/*global $hotChunkFilename$ hotAddUpdateChunk $hotMainFilename$ */
+/*global installedChunks $hotChunkFilename$ hotAddUpdateChunk $hotMainFilename$ */
 module.exports = function() {
 	function hotDownloadUpdateChunk(chunkId) { // eslint-disable-line no-unused-vars
 		var chunk = require("./" + $hotChunkFilename$);
@@ -18,7 +18,7 @@ module.exports = function() {
 		return Promise.resolve(update);
 	}
 
-	function hotDiposeChunk(chunkId) {
+	function hotDisposeChunk(chunkId) {
 		delete installedChunks[chunkId];
 	}
 };

package/lib/node/NodeMainTemplateAsync.runtime.js

@@ -2,7 +2,7 @@
 	MIT License http://www.opensource.org/licenses/mit-license.php
 	Author Tobias Koppers @sokra
 */
-/*global $hotChunkFilename$ $require$ hotAddUpdateChunk $hotMainFilename$ */
+/*global installedChunks $hotChunkFilename$ $require$ hotAddUpdateChunk $hotMainFilename$ */
 module.exports = function() {
 	function hotDownloadUpdateChunk(chunkId) { // eslint-disable-line no-unused-vars
 		var filename = require("path").join(__dirname, $hotChunkFilename$);
@@ -34,7 +34,7 @@ module.exports = function() {
 		});
 	}
 
-	function hotDiposeChunk(chunkId) {
+	function hotDisposeChunk(chunkId) {
 		delete installedChunks[chunkId];
 	}
 };

package/lib/node/NodeSourcePlugin.js

@@ -1,71 +1,84 @@
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-var AliasPlugin = require("enhanced-resolve/lib/AliasPlugin");
-var ModuleParserHelpers = require("../ModuleParserHelpers");
-var nodeLibsBrowser = require("node-libs-browser");
-
-function NodeSourcePlugin(options) {
-	this.options = options;
-}
-module.exports = NodeSourcePlugin;
-NodeSourcePlugin.prototype.apply = function(compiler) {
-	function getPathToModule(module, type) {
-		if(type === true || (type === undefined && nodeLibsBrowser[module])) {
-			if(!nodeLibsBrowser[module]) throw new Error("No browser version for node.js core module '" + module + "' available");
-			return nodeLibsBrowser[module];
-		} else if(type === "mock") {
-			return require.resolve("node-libs-browser/mock/" + module);
-		} else if(type === "empty") {
-			return require.resolve("node-libs-browser/mock/empty");
-		} else return module;
-	}
-	if(this.options.process) {
-		var processType = this.options.process;
-		compiler.parser.plugin("expression process", function() {
-			return ModuleParserHelpers.addParsedVariable(this, "process", "require(" + JSON.stringify(getPathToModule("process", processType)) + ")");
-		});
-	}
-	if(this.options.global) {
-		compiler.parser.plugin("expression global", function() {
-			return ModuleParserHelpers.addParsedVariable(this, "global", "require(" + JSON.stringify(require.resolve("../../buildin/global.js")) + ")");
-		});
-	}
-	if(this.options.console) {
-		var consoleType = this.options.console;
-		compiler.parser.plugin("expression console", function() {
-			return ModuleParserHelpers.addParsedVariable(this, "console", "require(" + JSON.stringify(getPathToModule("console", consoleType)) + ")");
-		});
-	}
-	var bufferType = this.options.Buffer;
-	if(bufferType) {
-		compiler.parser.plugin("expression Buffer", function() {
-			return ModuleParserHelpers.addParsedVariable(this, "Buffer", "require(" + JSON.stringify(getPathToModule("buffer", bufferType)) + ").Buffer");
-		});
-	}
-	if(this.options.setImmediate) {
-		var setImmediateType = this.options.setImmediate;
-		compiler.parser.plugin("expression setImmediate", function() {
-			return ModuleParserHelpers.addParsedVariable(this, "setImmediate", "require(" + JSON.stringify(getPathToModule("timers", setImmediateType)) + ").setImmediate");
-		});
-		compiler.parser.plugin("expression clearImmediate", function() {
-			return ModuleParserHelpers.addParsedVariable(this, "clearImmediate", "require(" + JSON.stringify(getPathToModule("timers", setImmediateType)) + ").clearImmediate");
-		});
-	}
-	var options = this.options;
-	compiler.plugin("after-resolvers", function(compiler) {
-		var alias = {};
-		Object.keys(nodeLibsBrowser).forEach(function(lib) {
-			if(options[lib] !== false) {
-				compiler.resolvers.normal.apply(
-					new AliasPlugin("described-resolve", {
-						name: lib,
-						onlyModule: true,
-						alias: getPathToModule(lib, options[lib])
-					}, "resolve")
-				);
-			}
-		});
-	});
-};
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+var AliasPlugin = require("enhanced-resolve/lib/AliasPlugin");
+var ModuleParserHelpers = require("../ModuleParserHelpers");
+var nodeLibsBrowser = require("node-libs-browser");
+
+function NodeSourcePlugin(options) {
+	this.options = options;
+}
+module.exports = NodeSourcePlugin;
+NodeSourcePlugin.prototype.apply = function(compiler) {
+	var options = this.options;
+
+	function getPathToModule(module, type) {
+		if(type === true || (type === undefined && nodeLibsBrowser[module])) {
+			if(!nodeLibsBrowser[module]) throw new Error("No browser version for node.js core module '" + module + "' available");
+			return nodeLibsBrowser[module];
+		} else if(type === "mock") {
+			return require.resolve("node-libs-browser/mock/" + module);
+		} else if(type === "empty") {
+			return require.resolve("node-libs-browser/mock/empty");
+		} else return module;
+	}
+	compiler.plugin("compilation", function(compilation, params) {
+		params.normalModuleFactory.plugin("parser", function(parser, parserOptions) {
+
+			if(parserOptions.node === false)
+				return;
+
+			var localOptions = options;
+			if(parserOptions.node)
+				localOptions = Object.assign({}, localOptions, parserOptions.node);
+
+			if(localOptions.process) {
+				var processType = localOptions.process;
+				parser.plugin("expression process", function() {
+					return ModuleParserHelpers.addParsedVariable(this, "process", "require(" + JSON.stringify(getPathToModule("process", processType)) + ")");
+				});
+			}
+			if(localOptions.global) {
+				parser.plugin("expression global", function() {
+					return ModuleParserHelpers.addParsedVariable(this, "global", "require(" + JSON.stringify(require.resolve("../../buildin/global.js")) + ")");
+				});
+			}
+			if(localOptions.console) {
+				var consoleType = localOptions.console;
+				parser.plugin("expression console", function() {
+					return ModuleParserHelpers.addParsedVariable(this, "console", "require(" + JSON.stringify(getPathToModule("console", consoleType)) + ")");
+				});
+			}
+			var bufferType = localOptions.Buffer;
+			if(bufferType) {
+				parser.plugin("expression Buffer", function() {
+					return ModuleParserHelpers.addParsedVariable(this, "Buffer", "require(" + JSON.stringify(getPathToModule("buffer", bufferType)) + ").Buffer");
+				});
+			}
+			if(localOptions.setImmediate) {
+				var setImmediateType = localOptions.setImmediate;
+				parser.plugin("expression setImmediate", function() {
+					return ModuleParserHelpers.addParsedVariable(this, "setImmediate", "require(" + JSON.stringify(getPathToModule("timers", setImmediateType)) + ").setImmediate");
+				});
+				parser.plugin("expression clearImmediate", function() {
+					return ModuleParserHelpers.addParsedVariable(this, "clearImmediate", "require(" + JSON.stringify(getPathToModule("timers", setImmediateType)) + ").clearImmediate");
+				});
+			}
+		});
+	});
+	compiler.plugin("after-resolvers", function(compiler) {
+		var alias = {};
+		Object.keys(nodeLibsBrowser).forEach(function(lib) {
+			if(options[lib] !== false) {
+				compiler.resolvers.normal.apply(
+					new AliasPlugin("described-resolve", {
+						name: lib,
+						onlyModule: true,
+						alias: getPathToModule(lib, options[lib])
+					}, "resolve")
+				);
+			}
+		});
+	});
+};

package/lib/optimize/ChunkModuleIdRangePlugin.js

@@ -0,0 +1,52 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+function ChunkModuleIdRangePlugin(options) {
+	this.options = options;
+}
+module.exports = ChunkModuleIdRangePlugin;
+ChunkModuleIdRangePlugin.prototype.apply = function(compiler) {
+	var options = this.options;
+	compiler.plugin("compilation", function(compilation) {
+		compilation.plugin("module-ids", function(modules) {
+			var chunk = this.chunks.filter(function(chunk) {
+				return chunk.name === options.name;
+			})[0];
+			if(!chunk) throw new Error("ChunkModuleIdRangePlugin: Chunk with name '" + options.name + "' was not found");
+			var currentId = options.start;
+			var chunkModules;
+			if(options.order) {
+				chunkModules = chunk.modules.slice();
+				switch(options.order) {
+					case "index":
+						chunkModules.sort(function(a, b) {
+							return a.index - b.index;
+						});
+						break;
+					case "index2":
+						chunkModules.sort(function(a, b) {
+							return a.index2 - b.index2;
+						});
+						break;
+					default:
+						throw new Error("ChunkModuleIdRangePlugin: unexpected value of order");
+				}
+
+			} else {
+				chunkModules = modules.filter(function(m) {
+					return m.chunks.indexOf(chunk) >= 0;
+				});
+			}
+			console.log(chunkModules);
+			for(var i = 0; i < chunkModules.length; i++) {
+				var m = chunkModules[i];
+				if(m.id === null) {
+					m.id = currentId++;
+				}
+				if(options.end && currentId > options.end)
+					break;
+			}
+		});
+	});
+};

package/lib/optimize/EnsureChunkConditionsPlugin.js

@@ -13,10 +13,15 @@ EnsureChunkConditionsPlugin.prototype.apply = function(compiler) {
 				chunk.modules.slice().forEach(function(module) {
 					if(!module.chunkCondition) return;
 					if(!module.chunkCondition(chunk)) {
+						var usedChunks = module._EnsureChunkConditionsPlugin_usedChunks = (module._EnsureChunkConditionsPlugin_usedChunks || []).concat(chunk);
+						var newChunks = [];
 						chunk.parents.forEach(function(parent) {
-							parent.addModule(module);
+							if(usedChunks.indexOf(parent) < 0) {
+								parent.addModule(module);
+								newChunks.push(parent);
+							}
 						});
-						module.rewriteChunkInReasons(chunk, chunk.parents);
+						module.rewriteChunkInReasons(chunk, newChunks);
 						chunk.removeModule(module);
 						changed = true;
 					}

package/lib/validateWebpackOptions.js

@@ -0,0 +1,63 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Gajus Kuizinas @gajus
+*/
+var webpackOptionsSchema = require("../schemas/webpackOptionsSchema.json");
+var Ajv = require("ajv");
+var ajv = new Ajv({
+	errorDataPath: "configuration",
+	allErrors: true,
+	verbose: true
+});
+var validate = ajv.compile(webpackOptionsSchema);
+
+function validateWebpackOptions(options) {
+	if(Array.isArray(options)) {
+		var errors = options.map(validateObject);
+		errors.forEach(function(list, idx) {
+			list.forEach(function applyPrefix(err) {
+				err.dataPath = "[" + idx + "]" + err.dataPath;
+				if(err.children) {
+					err.children.forEach(applyPrefix);
+				}
+			});
+		});
+		return errors.reduce(function(arr, items) {
+			return arr.concat(items);
+		}, []);
+	} else {
+		return validateObject(options);
+	}
+}
+
+function validateObject(options) {
+	var valid = validate(options);
+	return valid ? [] : filterErrors(validate.errors);
+}
+
+function filterErrors(errors) {
+	var errorsByDataPath = {};
+	var newErrors = [];
+	errors.forEach(function(err) {
+		var dataPath = err.dataPath;
+		var key = "$" + dataPath;
+		if(errorsByDataPath[key]) {
+			var oldError = errorsByDataPath[key];
+			var idx = newErrors.indexOf(oldError);
+			newErrors.splice(idx, 1);
+			if(oldError.children) {
+				var children = oldError.children;
+				delete oldError.children;
+				children.push(oldError);
+				err.children = children;
+			} else {
+				err.children = [oldError];
+			}
+		}
+		errorsByDataPath[key] = err;
+		newErrors.push(err);
+	});
+	return newErrors;
+}
+
+module.exports = validateWebpackOptions;

package/lib/webpack.js

@@ -7,17 +7,20 @@ var MultiCompiler = require("./MultiCompiler");
 var NodeEnvironmentPlugin = require("./node/NodeEnvironmentPlugin");
 var WebpackOptionsApply = require("./WebpackOptionsApply");
 var WebpackOptionsDefaulter = require("./WebpackOptionsDefaulter");
+var validateWebpackOptions = require("./validateWebpackOptions");
+var WebpackOptionsValidationError = require("./WebpackOptionsValidationError");
 
 function webpack(options, callback) {
+	var webpackOptionsValidationErrors = validateWebpackOptions(options);
+	if(webpackOptionsValidationErrors.length) {
+		throw new WebpackOptionsValidationError(webpackOptionsValidationErrors);
+	}
 	var compiler;
 	if(Array.isArray(options)) {
 		compiler = new MultiCompiler(options.map(function(options) {
 			return webpack(options);
 		}));
 	} else if(typeof options === "object") {
-		if(!options.entry && !options.plugins) {
-			throw new Error("Passed 'options' object does not look like a valid webpack configuration");
-		}
 		new WebpackOptionsDefaulter().process(options);
 
 		compiler = new Compiler();
@@ -49,6 +52,7 @@ webpack.WebpackOptionsApply = WebpackOptionsApply;
 webpack.Compiler = Compiler;
 webpack.MultiCompiler = MultiCompiler;
 webpack.NodeEnvironmentPlugin = NodeEnvironmentPlugin;
+webpack.validate = validateWebpackOptions;
 
 function exportPlugins(exports, path, plugins) {
 	plugins.forEach(function(name) {
@@ -100,12 +104,11 @@ exportPlugins(exports.optimize = {}, "./optimize", [
 	"AggressiveMergingPlugin",
 	"AggressiveSplittingPlugin",
 	"CommonsChunkPlugin",
+	"ChunkModuleIdRangePlugin",
 	"DedupePlugin",
 	"LimitChunkCountPlugin",
 	"MinChunkSizePlugin",
 	"OccurrenceOrderPlugin",
 	"UglifyJsPlugin"
 ]);
-exportPlugins(exports.dependencies = {}, "./dependencies", [
-	"LabeledModulesPlugin"
-]);
+exportPlugins(exports.dependencies = {}, "./dependencies", []);