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

package/bin/config-yargs.js

@@ -22,6 +22,12 @@ module.exports = function(yargs) {
 				describe: "Enviroment passed to the config, when it is a function",
 				group: CONFIG_GROUP
 			},
+			"version": {
+				type: "string",
+				describe: "Webpack version",
+				alias: "v",
+				group: BASIC_GROUP,
+			},
 			"context": {
 				type: "string",
 				describe: "The root directory for resolving entry point and stats",
@@ -184,11 +190,6 @@ module.exports = function(yargs) {
 				group: BASIC_GROUP,
 				requiresArg: true
 			},
-			"progress": {
-				type: "boolean",
-				describe: "Print compilation progress in percentage",
-				group: BASIC_GROUP
-			},
 			"resolve-alias": {
 				type: "string",
 				describe: "Setup a module alias for resolving (Example: jquery-plugin=jquery.plugin)",

package/bin/convert-argv.js

@@ -4,15 +4,22 @@ fs.existsSync = fs.existsSync || path.existsSync;
 var resolve = require("enhanced-resolve");
 var interpret = require("interpret");
 var WebpackOptionsDefaulter = require("../lib/WebpackOptionsDefaulter");
+var validateWebpackOptions = require("../lib/validateWebpackOptions");
 
 module.exports = function(optimist, argv, convertOptions) {
 
-	var options = {};
+	var options = [];
 
 	// Help
 	if(argv.help) {
 		optimist.showHelp();
-		process.exit(-1); // eslint-disable-line
+		process.exit(0); // eslint-disable-line
+	}
+
+	// Version
+	if(argv.v || argv.version) {
+		console.log(require("../package.json").version);
+		process.exit(0); // eslint-disable-line
 	}
 
 	// Shortcuts
@@ -29,11 +36,11 @@ module.exports = function(optimist, argv, convertOptions) {
 	}
 
 	var configFileLoaded = false;
-	var configPath, ext;
+	var configFiles = [];
 	var extensions = Object.keys(interpret.extensions).sort(function(a, b) {
 		return a === '.js' ? -1 : b === '.js' ? 1 : a.length - b.length;
 	});
-	var configFiles = ["webpack.config", "webpackfile"].map(function(filename) {
+	var defaultConfigFiles = ["webpack.config", "webpackfile"].map(function(filename) {
 		return extensions.map(function(ext) {
 			return {
 				path: path.resolve(filename + ext),
@@ -46,30 +53,41 @@ module.exports = function(optimist, argv, convertOptions) {
 
 	var i;
 	if(argv.config) {
-		configPath = path.resolve(argv.config);
-		for(i = extensions.length - 1; i >= 0; i--) {
-			var tmpExt = extensions[i];
-			if(configPath.indexOf(tmpExt, configPath.length - tmpExt.length) > -1) {
-				ext = tmpExt;
-				break;
+		function getConfigExtension(configPath) {
+			for(i = extensions.length - 1; i >= 0; i--) {
+				var tmpExt = extensions[i];
+				if(configPath.indexOf(tmpExt, configPath.length - tmpExt.length) > -1) {
+					return tmpExt;
+				}
 			}
+			return path.extname(configPath);
 		}
-		if(!ext) {
-			ext = path.extname(configPath);
+
+		function mapConfigArg(configArg) {
+			var resolvedPath = path.resolve(configArg);
+			var extension = getConfigExtension(resolvedPath);
+			return {
+				path: resolvedPath,
+				ext: extension
+			};
 		}
+
+		var configArgList = Array.isArray(argv.config) ? argv.config : [argv.config];
+		configFiles = configArgList.map(mapConfigArg);
 	} else {
-		for(i = 0; i < configFiles.length; i++) {
-			var webpackConfig = configFiles[i].path;
+		for(i = 0; i < defaultConfigFiles.length; i++) {
+			var webpackConfig = defaultConfigFiles[i].path;
 			if(fs.existsSync(webpackConfig)) {
-				ext = configFiles[i].ext;
-				configPath = webpackConfig;
+				configFiles.push({
+					path: webpackConfig,
+					ext: defaultConfigFiles[i].ext
+				});
 				break;
 			}
 		}
 	}
 
-	if(configPath) {
-
+	if(configFiles.length > 0) {
 		function registerCompiler(moduleDescriptor) {
 			if(moduleDescriptor) {
 				if(typeof moduleDescriptor === "string") {
@@ -89,22 +107,33 @@ module.exports = function(optimist, argv, convertOptions) {
 			}
 		}
 
-		registerCompiler(interpret.extensions[ext]);
-		options = require(configPath);
+		function requireConfig(configPath) {
+			var options = require(configPath);
+			var isES6DefaultExportedFunc = (
+				typeof options === "object" && options !== null && typeof options.default === "function"
+			);
+			if(typeof options === "function" || isES6DefaultExportedFunc) {
+				options = isES6DefaultExportedFunc ? options.default : options;
+				options = options(argv.env, argv);
+			}
+			return options;
+		}
+
+		configFiles.forEach(function(file) {
+			registerCompiler(interpret.extensions[file.ext]);
+			options.push(requireConfig(file.path));
+		});
 		configFileLoaded = true;
 	}
 
-	var isES6DefaultExportedFunc = (
-		typeof options === "object" && options !== null && typeof options.default === "function"
-	);
-
-	if(typeof options === "function" || isES6DefaultExportedFunc) {
-		options = isES6DefaultExportedFunc ? options.default : options;
-		options = options(argv.env, argv);
+	if(!configFileLoaded) {
+		return processConfiguredOptions({});
+	} else if(options.length === 1) {
+		return processConfiguredOptions(options[0]);
+	} else {
+		return processConfiguredOptions(options);
 	}
 
-	return processConfiguredOptions(options);
-
 	function processConfiguredOptions(options) {
 		if(options === null || typeof options !== "object") {
 			console.error("Config did not export an object or a function returning an object.");
@@ -162,7 +191,6 @@ module.exports = function(optimist, argv, convertOptions) {
 
 	function processOptions(options) {
 		var noOutputFilenameDefined = !options.output || !options.output.filename;
-		new WebpackOptionsDefaulter().process(options);
 
 		function ifArg(name, fn, init, finalize) {
 			if(Array.isArray(argv[name])) {
@@ -537,7 +565,7 @@ module.exports = function(optimist, argv, convertOptions) {
 		}
 
 		if(!options.entry) {
-			if(configPath) {
+			if(configFileLoaded) {
 				console.error("Configuration file found but no entry configured.");
 			} else {
 				console.error("No configuration file found and no entry configured via CLI option.");

package/bin/webpack.js

@@ -21,6 +21,7 @@ var yargs = require("yargs")
 require("./config-yargs")(yargs);
 
 var DISPLAY_GROUP = "Stats options:";
+var BASIC_GROUP = "Basic options:";
 
 yargs.options({
 	"json": {
@@ -28,6 +29,11 @@ yargs.options({
 		alias: "j",
 		describe: "Prints the result as JSON."
 	},
+	"progress": {
+		type: "boolean",
+		describe: "Print compilation progress in percentage",
+		group: BASIC_GROUP
+	},
 	"color": {
 		type: "boolean",
 		alias: "colors",
@@ -102,6 +108,11 @@ yargs.options({
 		group: DISPLAY_GROUP,
 		describe: "Display information about used exports in modules (Tree Shaking)"
 	},
+	"display-provided-exports": {
+		type: "boolean",
+		group: DISPLAY_GROUP,
+		describe: "Display information about exports provided from modules"
+	},
 	"display-error-details": {
 		type: "boolean",
 		group: DISPLAY_GROUP,
@@ -110,7 +121,6 @@ yargs.options({
 	"verbose": {
 		type: "boolean",
 		group: DISPLAY_GROUP,
-		alias: "v",
 		describe: "Show more details"
 	}
 });
@@ -121,6 +131,7 @@ if(argv.verbose) {
 	argv["display-reasons"] = true;
 	argv["display-entrypoints"] = true;
 	argv["display-used-exports"] = true;
+	argv["display-provided-exports"] = true;
 	argv["display-error-details"] = true;
 	argv["display-modules"] = true;
 	argv["display-cached"] = true;
@@ -207,6 +218,10 @@ function processOptions(options) {
 			outputOptions.usedExports = bool;
 		});
 
+		ifArg("display-provided-exports", function(bool) {
+			outputOptions.providedExports = bool;
+		});
+
 		ifArg("display-error-details", function(bool) {
 			outputOptions.errorDetails = bool;
 		});
@@ -255,7 +270,20 @@ function processOptions(options) {
 
 	Error.stackTraceLimit = 30;
 	var lastHash = null;
-	var compiler = webpack(options);
+	var compiler;
+	try {
+		compiler = webpack(options);
+	} catch(e) {
+		var WebpackOptionsValidationError = require("../lib/WebpackOptionsValidationError");
+		if(e instanceof WebpackOptionsValidationError) {
+			if(argv.color)
+				console.error("\u001b[1m\u001b[31m" + e.message + "\u001b[39m\u001b[22m");
+			else
+				console.error(e.message);
+			process.exit(1);
+		}
+		throw e;
+	}
 
 	if(argv.progress) {
 		var ProgressPlugin = require("../lib/ProgressPlugin");

package/lib/APIPlugin.js

@@ -26,24 +26,27 @@ var REPLACEMENT_TYPES = {
 };
 var IGNORES = [];
 APIPlugin.prototype.apply = function(compiler) {
-	compiler.plugin("compilation", function(compilation) {
+	compiler.plugin("compilation", function(compilation, params) {
 		compilation.dependencyFactories.set(ConstDependency, new NullFactory());
 		compilation.dependencyTemplates.set(ConstDependency, new ConstDependency.Template());
-	});
-	Object.keys(REPLACEMENTS).forEach(function(key) {
-		compiler.parser.plugin("expression " + key, function(expr) {
-			var dep = new ConstDependency(REPLACEMENTS[key], expr.range);
-			dep.loc = expr.loc;
-			this.state.current.addDependency(dep);
-			return true;
-		});
-		compiler.parser.plugin("evaluate typeof " + key, function(expr) {
-			return new BasicEvaluatedExpression().setString(REPLACEMENT_TYPES[key]).setRange(expr.range);
-		});
-	});
-	IGNORES.forEach(function(key) {
-		compiler.parser.plugin(key, function() {
-			return true;
+
+		params.normalModuleFactory.plugin("parser", function(parser) {
+			Object.keys(REPLACEMENTS).forEach(function(key) {
+				parser.plugin("expression " + key, function(expr) {
+					var dep = new ConstDependency(REPLACEMENTS[key], expr.range);
+					dep.loc = expr.loc;
+					this.state.current.addDependency(dep);
+					return true;
+				});
+				parser.plugin("evaluate typeof " + key, function(expr) {
+					return new BasicEvaluatedExpression().setString(REPLACEMENT_TYPES[key]).setRange(expr.range);
+				});
+			});
+			IGNORES.forEach(function(key) {
+				parser.plugin(key, function() {
+					return true;
+				});
+			});
 		});
 	});
 };

package/lib/Chunk.js

@@ -279,7 +279,7 @@ Chunk.prototype.integratedSize = function(other, options) {
 		return false;
 	}
 
-	var CHUNK_OVERHEAD = options.chunkOverhead || 10000;
+	var CHUNK_OVERHEAD = typeof options.chunkOverhead === "number" ? options.chunkOverhead : 10000;
 	var ENTRY_CHUNK_MULTIPLICATOR = options.entryChunkMultiplicator || 10;
 
 	var mergedModules = this.modules.slice();

package/lib/CommonJsHarmonyMainTemplatePlugin.js

@@ -0,0 +1,21 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+var ConcatSource = require("webpack-sources").ConcatSource;
+
+function CommonJsHarmonyMainTemplatePlugin() {}
+
+module.exports = CommonJsHarmonyMainTemplatePlugin;
+
+CommonJsHarmonyMainTemplatePlugin.prototype.apply = function(compilation) {
+	var mainTemplate = compilation.mainTemplate;
+	compilation.templatesPlugin("render-with-entry", function(source, chunk, hash) {
+		var prefix = "module.exports =\n";
+		var postfix = "\nObject.defineProperty(module.exports, \"__esModule\", { value: true });";
+		return new ConcatSource(prefix, source, postfix);
+	});
+	mainTemplate.plugin("hash", function(hash) {
+		hash.update("commonjs harmony");
+	});
+};

package/lib/CompatibilityPlugin.js

@@ -11,24 +11,31 @@ function CompatibilityPlugin() {}
 module.exports = CompatibilityPlugin;
 
 CompatibilityPlugin.prototype.apply = function(compiler) {
-	compiler.plugin("compilation", function(compilation) {
+	compiler.plugin("compilation", function(compilation, params) {
 		compilation.dependencyFactories.set(ConstDependency, new NullFactory());
 		compilation.dependencyTemplates.set(ConstDependency, new ConstDependency.Template());
-	});
-	compiler.parser.plugin("call require", function(expr) {
-		// support for browserify style require delegator: "require(o, !0)"
-		if(expr.arguments.length !== 2) return;
-		var second = this.evaluateExpression(expr.arguments[1]);
-		if(!second.isBoolean()) return;
-		if(second.asBool() !== true) return;
-		var dep = new ConstDependency("require", expr.callee.range);
-		dep.loc = expr.loc;
-		if(this.state.current.dependencies.length > 1) {
-			var last = this.state.current.dependencies[this.state.current.dependencies.length - 1];
-			if(last.critical && last.request === "." && last.userRequest === "." && last.recursive)
-				this.state.current.dependencies.pop();
-		}
-		this.state.current.addDependency(dep);
-		return true;
+
+		params.normalModuleFactory.plugin("parser", function(parser, parserOptions) {
+
+			if(typeof parserOptions.browserify !== "undefined" && !parserOptions.browserify)
+				return;
+
+			parser.plugin("call require", function(expr) {
+				// support for browserify style require delegator: "require(o, !0)"
+				if(expr.arguments.length !== 2) return;
+				var second = this.evaluateExpression(expr.arguments[1]);
+				if(!second.isBoolean()) return;
+				if(second.asBool() !== true) return;
+				var dep = new ConstDependency("require", expr.callee.range);
+				dep.loc = expr.loc;
+				if(this.state.current.dependencies.length > 1) {
+					var last = this.state.current.dependencies[this.state.current.dependencies.length - 1];
+					if(last.critical && last.request === "." && last.userRequest === "." && last.recursive)
+						this.state.current.dependencies.pop();
+				}
+				this.state.current.addDependency(dep);
+				return true;
+			});
+		});
 	});
 };

package/lib/Compilation.js

@@ -209,6 +209,9 @@ Compilation.prototype.addModuleDependencies = function(module, dependencies, bai
 
 		var factory = item[0];
 		factory.create({
+			contextInfo: {
+				issuer: module.nameForCondition && module.nameForCondition()
+			},
 			context: module.context,
 			dependencies: dependencies
 		}, function(err, dependentModule) {
@@ -424,6 +427,11 @@ Compilation.prototype._addModuleChain = function process(context, dependency, on
 };
 
 Compilation.prototype.addEntry = function process(context, entry, name, callback) {
+	var slot = {
+		name: name,
+		module: null
+	};
+	this.preparedChunks.push(slot);
 	this._addModuleChain(context, entry, function(module) {
 
 		entry.module = module;
@@ -436,10 +444,10 @@ Compilation.prototype.addEntry = function process(context, entry, name, callback
 		}
 
 		if(module) {
-			this.preparedChunks.push({
-				name: name,
-				module: module
-			});
+			slot.module = module;
+		} else {
+			var idx = this.preparedChunks.indexOf(slot);
+			this.preparedChunks.splice(idx, 1);
 		}
 		return callback();
 	}.bind(this));
@@ -511,11 +519,6 @@ Compilation.prototype.unseal = function unseal() {
 
 Compilation.prototype.seal = function seal(callback) {
 	this.applyPlugins("seal");
-	this.preparedChunks.sort(function(a, b) {
-		if(a.name < b.name) return -1;
-		if(a.name > b.name) return 1;
-		return 0;
-	});
 	this.nextFreeModuleIndex = 0;
 	this.nextFreeModuleIndex2 = 0;
 	this.preparedChunks.forEach(function(preparedChunk) {
@@ -561,7 +564,9 @@ Compilation.prototype.seal = function seal(callback) {
 
 		this.applyPlugins("revive-modules", this.modules, this.records);
 		this.applyPlugins("optimize-module-order", this.modules);
+		this.applyPlugins("advanced-optimize-module-order", this.modules);
 		this.applyPlugins("before-module-ids", this.modules);
+		this.applyPlugins("module-ids", this.modules);
 		this.applyModuleIds();
 		this.applyPlugins("optimize-module-ids", this.modules);
 		this.applyPlugins("after-optimize-module-ids", this.modules);
@@ -742,10 +747,24 @@ Compilation.prototype.removeChunkFromDependencies = function removeChunkFromDepe
 Compilation.prototype.applyModuleIds = function applyModuleIds() {
 	var unusedIds = [];
 	var nextFreeModuleId = 0;
+	var usedIds = [];
+	var usedIdMap = {};
 	if(this.usedModuleIds) {
-		var usedIds = Object.keys(this.usedModuleIds).map(function(key) {
-			return this.usedModuleIds[key];
-		}, this).sort();
+		Object.keys(this.usedModuleIds).forEach(function(key) {
+			var id = this.usedModuleIds[key];
+			if(typeof usedIdMap[id] === "undefined") {
+				usedIds.push(id);
+				usedIdMap[id] = id;
+			}
+		}, this);
+	}
+	this.modules.forEach(function(module) {
+		if(module.id !== null && typeof usedIdMap[module.id] === "undefined") {
+			usedIds.push(module.id);
+			usedIdMap[module.id] = module.id;
+		}
+	});
+	if(usedIds.length > 0) {
 		var usedNumberIds = usedIds.filter(function(id) {
 			return typeof id === "number";
 		});
@@ -753,7 +772,7 @@ Compilation.prototype.applyModuleIds = function applyModuleIds() {
 			return Math.max(a, b);
 		}, -1) + 1;
 		for(var i = 0; i < nextFreeModuleId; i++) {
-			if(this.usedModuleIds[i] !== i)
+			if(usedIdMap[i] !== i)
 				unusedIds.push(i);
 		}
 		unusedIds.reverse();
@@ -801,7 +820,9 @@ Compilation.prototype.applyChunkIds = function applyChunkIds() {
 };
 
 function byId(a, b) {
-	return a.id - b.id;
+	if(a.id < b.id) return -1;
+	if(a.id > b.id) return 1;
+	return 0;
 }
 
 Compilation.prototype.sortItemsBeforeIds = function sortItemsBeforeIds() {
@@ -834,7 +855,7 @@ Compilation.prototype.summarizeDependencies = function summarizeDependencies() {
 		}
 		return newArray;
 	}
-	this.fileDependencies = [];
+	this.fileDependencies = (this.compilationDependencies || []).slice();
 	this.contextDependencies = [];
 	this.missingDependencies = [];
 	this.children.forEach(function(child) {

package/lib/Compiler.js

@@ -7,7 +7,6 @@ var assign = require("object-assign");
 var Tapable = require("tapable");
 
 var Compilation = require("./Compilation");
-var Parser = require("./Parser");
 var Resolver = require("enhanced-resolve/lib/Resolver");
 
 var NormalModuleFactory = require("./NormalModuleFactory");
@@ -160,7 +159,36 @@ function Compiler() {
 		loader: new Resolver(null),
 		context: new Resolver(null)
 	};
-	this.parser = new Parser();
+	var deprecationReported = false;
+	this.parser = {
+		plugin: function(hook, fn) {
+			if(!deprecationReported) {
+				console.warn("webpack: Using compiler.parser is deprecated.\n" +
+					"Use compiler.plugin(\"compilation\", function(compilation, data) {\n  data.normalModuleFactory.plugin(\"parser\", function(parser, options) { parser.plugin(/* ... */); });\n}); instead. " +
+					"It was called " + new Error().stack.split("\n")[2].trim() + ".");
+				deprecationReported = true;
+			}
+			this.plugin("compilation", function(compilation, data) {
+				data.normalModuleFactory.plugin("parser", function(parser) {
+					parser.plugin(hook, fn);
+				});
+			});
+		}.bind(this),
+		apply: function() {
+			var args = arguments;
+			if(!deprecationReported) {
+				console.warn("webpack: Using compiler.parser is deprecated.\n" +
+					"Use compiler.plugin(\"compilation\", function(compilation, data) {\n  data.normalModuleFactory.plugin(\"parser\", function(parser, options) { parser.apply(/* ... */); });\n}); instead. " +
+					"It was called " + new Error().stack.split("\n")[2].trim() + ".");
+				deprecationReported = true;
+			}
+			this.plugin("compilation", function(compilation, data) {
+				data.normalModuleFactory.plugin("parser", function(parser) {
+					parser.apply.apply(parser, args);
+				});
+			});
+		}.bind(this)
+	}
 
 	this.options = {};
 }
@@ -369,7 +397,6 @@ Compiler.prototype.createChildCompiler = function(compilation, compilerName, out
 	childCompiler.inputFileSystem = this.inputFileSystem;
 	childCompiler.outputFileSystem = null;
 	childCompiler.resolvers = this.resolvers;
-	childCompiler.parser = this.parser;
 	childCompiler.fileTimestamps = this.fileTimestamps;
 	childCompiler.contextTimestamps = this.contextTimestamps;
 	if(!this.records[compilerName]) this.records[compilerName] = [];
@@ -397,13 +424,14 @@ Compiler.prototype.newCompilation = function(params) {
 	compilation.contextTimestamps = this.contextTimestamps;
 	compilation.name = this.name;
 	compilation.records = this.records;
+	compilation.compilationDependencies = params.compilationDependencies;
 	this.applyPlugins("this-compilation", compilation, params);
 	this.applyPlugins("compilation", compilation, params);
 	return compilation;
 };
 
 Compiler.prototype.createNormalModuleFactory = function() {
-	var normalModuleFactory = new NormalModuleFactory(this.options.context, this.resolvers, this.parser, this.options.module || {});
+	var normalModuleFactory = new NormalModuleFactory(this.options.context, this.resolvers, this.options.module || {});
 	this.applyPlugins("normal-module-factory", normalModuleFactory);
 	return normalModuleFactory;
 };
@@ -417,30 +445,35 @@ Compiler.prototype.createContextModuleFactory = function() {
 Compiler.prototype.newCompilationParams = function() {
 	var params = {
 		normalModuleFactory: this.createNormalModuleFactory(),
-		contextModuleFactory: this.createContextModuleFactory()
+		contextModuleFactory: this.createContextModuleFactory(),
+		compilationDependencies: []
 	};
 	return params;
 };
 
 Compiler.prototype.compile = function(callback) {
 	var params = this.newCompilationParams();
-	this.applyPlugins("compile", params);
-
-	var compilation = this.newCompilation(params);
-
-	this.applyPluginsParallel("make", compilation, function(err) {
+	this.applyPluginsAsync("before-compile", params, function(err) {
 		if(err) return callback(err);
 
-		compilation.finish();
+		this.applyPlugins("compile", params);
 
-		compilation.seal(function(err) {
+		var compilation = this.newCompilation(params);
+
+		this.applyPluginsParallel("make", compilation, function(err) {
 			if(err) return callback(err);
 
-			this.applyPluginsAsync("after-compile", compilation, function(err) {
+			compilation.finish();
+
+			compilation.seal(function(err) {
 				if(err) return callback(err);
 
-				return callback(null, compilation);
-			});
+				this.applyPluginsAsync("after-compile", compilation, function(err) {
+					if(err) return callback(err);
+
+					return callback(null, compilation);
+				});
+			}.bind(this));
 		}.bind(this));
 	}.bind(this));
 };