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

package/lib/RuleSet.js

@@ -0,0 +1,369 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+/*
+<rules>: <rule>
+<rules>: [<rule>]
+<rule>: {
+	resource: {
+		test: <condition>,
+		include: <condition>,
+		exclude: <condition>,
+	},
+	resource: <condition>, -> resource.test
+	test: <condition>, -> resource.test
+	include: <condition>, -> resource.include
+	exclude: <condition>, -> resource.exclude
+	issuer: {
+		test: <condition>,
+		include: <condition>,
+		exclude: <condition>,
+	},
+	issuer: <condition>, -> issuer.test
+	use: "loader", -> use[0].loader
+	loader: <>, -> use[0].loader
+	loaders: <>, -> use
+	options: {}, -> use[0].options,
+	query: {}, -> options
+	parser: {},
+	use: [
+		"loader" -> use[x].loader
+	],
+	use: [
+		{
+			loader: "loader",
+			options: {}
+		}
+	],
+	rules: [
+		<rule>
+	],
+	oneOf: [
+		<rule>
+	]
+}
+
+<condition>: /regExp/
+<condition>: function(arg) {}
+<condition>: "starting"
+<condition>: [<condition>] // or
+<condition>: { and: [<condition>] }
+<condition>: { or: [<condition>] }
+<condition>: { not: [<condition>] }
+<condition>: { test: <condition>, include: <condition>, exclude: <codition> }
+
+
+normalized:
+
+{
+	resource: function(),
+	issuer: function(),
+	use: [
+		{
+			loader: string,
+			options: string,
+			<any>: <any>
+		}
+	],
+	rules: [<rule>],
+	oneOf: [<rule>],
+	<any>: <any>,
+}
+
+*/
+
+function RuleSet(rules) {
+	this.rules = RuleSet.normalizeRules(rules);
+}
+
+module.exports = RuleSet;
+
+RuleSet.normalizeRules = function(rules) {
+	if(Array.isArray(rules)) {
+		return rules.map(function(rule) {
+			return RuleSet.normalizeRule(rule);
+		});
+	} else if(rules) {
+		return [RuleSet.normalizeRule(rules)]
+	} else {
+		return [];
+	}
+};
+
+RuleSet.normalizeRule = function(rule) {
+	if(typeof rule === "string")
+		return {
+			use: [{
+				loader: rule
+			}]
+		};
+	if(!rule)
+		throw new Error("Unexcepted null when object was expected as rule");
+	if(typeof rule !== "object")
+		throw new Error("Unexcepted " + typeof rule + " when object was expected as rule (" + rule + ")");
+
+	var newRule = {};
+	var useSource;
+	var resourceSource;
+
+	if(rule.test || rule.include || rule.exclude) {
+		checkResourceSource("test + include + exclude");
+		newRule.resource = RuleSet.normalizeCondition({
+			test: rule.test,
+			include: rule.include,
+			exclude: rule.exclude
+		});
+	}
+
+	if(rule.resource) {
+		checkResourceSource("resource");
+		newRule.resource = RuleSet.normalizeCondition(rule.resource);
+	}
+
+	if(rule.issuer) {
+		newRule.issuer = RuleSet.normalizeCondition(rule.issuer);
+	}
+
+	if(rule.loader && rule.loaders)
+		throw new Error("Provided loader and loaders for rule");
+
+	var loader = rule.loaders || rule.loader;
+	if(typeof loader === "string" && !rule.options && !rule.query) {
+		checkUseSource("loader");
+		newRule.use = RuleSet.normalizeUse(loader.split("!"));
+	} else if(typeof loader === "string" && (rule.options || rule.query)) {
+		checkUseSource("loader + options/query");
+		newRule.use = RuleSet.normalizeUse({
+			loader: loader,
+			options: rule.options,
+			query: rule.query
+		});
+	} else if(loader && (rule.options || rule.query)) {
+		throw new Error("options/query cannot be used with loaders");
+	} else if(loader) {
+		checkUseSource("loaders");
+		newRule.use = RuleSet.normalizeUse(loader);
+	}
+
+	if(rule.use) {
+		checkUseSource("use");
+		newRule.use = RuleSet.normalizeUse(rule.use);
+	}
+
+	if(rule.rules)
+		newRule.rules = RuleSet.normalizeRules(rule.rules);
+
+	if(rule.oneOf)
+		newRule.oneOf = RuleSet.normalizeRules(rule.oneOf);
+
+	var keys = Object.keys(rule).filter(function(key) {
+		return ["resource", "test", "include", "exclude", "issuer", "loader", "options", "query", "loaders", "use", "rules", "oneOf"].indexOf(key) < 0;
+	});
+	keys.forEach(function(key) {
+		newRule[key] = rule[key];
+	});
+
+	function checkUseSource(newSource) {
+		if(useSource && useSource !== newSource)
+			throw new Error("Rule can only have one result source (provided " + newSource + " and " + useSource + ")");
+		useSource = newSource;
+	}
+
+	function checkResourceSource(newSource) {
+		if(resourceSource && resourceSource !== newSource)
+			throw new Error("Rule can only have one resource source (provided " + newSource + " and " + resourceSource + ")");
+		resourceSource = newSource;
+	}
+
+	return newRule;
+};
+
+RuleSet.normalizeUse = function normalizeUse(use) {
+	if(Array.isArray(use)) {
+		return use.map(RuleSet.normalizeUse).reduce(function(arr, items) {
+			return arr.concat(items);
+		}, []);
+	}
+	return [RuleSet.normalizeUseItem(use)];
+};
+
+RuleSet.normalizeUseItem = function normalizeUseItem(item) {
+	if(typeof item === "function")
+		return item;
+
+	if(typeof item === "string") {
+		var idx = item.indexOf("?");
+		if(idx >= 0) {
+			return {
+				loader: item.substr(0, idx),
+				options: item.substr(idx + 1)
+			};
+		}
+		return {
+			loader: item
+		};
+	}
+
+	var newItem = {};
+
+	if(item.options && item.query)
+		throw new Error("Provided options and query in use");
+
+	if(!item.loader)
+		throw new Error("No loader specified");
+
+	newItem.options = item.options || item.query;
+
+	var keys = Object.keys(item).filter(function(key) {
+		return ["options", "query"].indexOf(key) < 0;
+	});
+
+	keys.forEach(function(key) {
+		newItem[key] = item[key];
+	});
+
+	return newItem;
+}
+
+RuleSet.normalizeCondition = function normalizeCondition(condition) {
+	if(!condition)
+		throw new Error("Expected condition but got falsy value");
+	if(typeof condition === "string") {
+		return function(str) {
+			return str.indexOf(condition) === 0;
+		};
+	}
+	if(typeof condition === "function") {
+		return condition;
+	}
+	if(condition instanceof RegExp) {
+		return condition.test.bind(condition);
+	}
+	if(Array.isArray(condition)) {
+		var items = condition.map(function(c) {
+			return RuleSet.normalizeCondition(c);
+		});
+		return orMatcher(items);
+	}
+	if(typeof condition !== "object")
+		throw Error("Unexcepted " + typeof condition + " when condition was expected (" + condition + ")");
+	var matchers = [];
+	Object.keys(condition).forEach(function(key) {
+		var value = condition[key];
+		switch(key) {
+			case "or":
+			case "include":
+			case "test":
+				if(value)
+					matchers.push(RuleSet.normalizeCondition(value));
+				break;
+			case "and":
+				if(value) {
+					var items = value.map(function(c) {
+						return RuleSet.normalizeCondition(c);
+					});
+					matchers.push(andMatcher(items));
+				}
+				break;
+			case "not":
+			case "exclude":
+				if(value) {
+					var matcher = RuleSet.normalizeCondition(value);
+					matchers.push(notMatcher(matcher));
+				}
+				break;
+			default:
+				throw new Error("Unexcepted property " + key + " in condition");
+		}
+	});
+	if(matchers.length === 0)
+		throw new Error("Excepted condition but got " + condition);
+	if(matchers.length === 1)
+		return matchers[0];
+	return andMatcher(matchers);
+};
+
+function notMatcher(matcher) {
+	return function(str) {
+		return !matcher(str);
+	}
+}
+
+function orMatcher(items) {
+	return function(str) {
+		for(var i = 0; i < items.length; i++) {
+			if(items[i](str))
+				return true;
+		}
+		return false;
+	}
+}
+
+function andMatcher(items) {
+	return function(str) {
+		for(var i = 0; i < items.length; i++) {
+			if(!items[i](str))
+				return false;
+		}
+		return true;
+	}
+}
+
+RuleSet.prototype.exec = function(data) {
+	var result = [];
+	this._run(data, {
+		rules: this.rules
+	}, result);
+	return result;
+};
+
+RuleSet.prototype._run = function _run(data, rule, result) {
+	// test conditions
+	if(rule.resource && !data.resource)
+		return false;
+	if(rule.issuer && !data.issuer)
+		return false;
+	if(rule.resource && !rule.resource(data.resource))
+		return false;
+	if(data.issuer && rule.issuer && !rule.issuer(data.issuer))
+		return false;
+
+	// apply
+	var keys = Object.keys(rule).filter(function(key) {
+		return ["resource", "issuer", "rules", "oneOf", "use", "enforce"].indexOf(key) < 0;
+	});
+	keys.forEach(function(key) {
+		result.push({
+			type: key,
+			value: rule[key]
+		});
+	});
+
+	if(rule.use) {
+		rule.use.forEach(function(use) {
+			result.push({
+				type: "use",
+				value: typeof use === "function" ? use(data) : use,
+				enforce: rule.enforce
+			});
+		});
+	}
+
+	var i;
+
+	if(rule.rules) {
+		for(i = 0; i < rule.rules.length; i++) {
+			this._run(data, rule.rules[i], result);
+		}
+	}
+
+	if(rule.oneOf) {
+		for(i = 0; i < rule.oneOf.length; i++) {
+			if(this._run(data, rule.oneOf[i], result))
+				break;
+		}
+	}
+
+	return true;
+};

package/lib/Stats.js

@@ -43,6 +43,7 @@ Stats.prototype.toJson = function toJson(options, forToString) {
 	var showCachedAssets = d(options.cachedAssets, true);
 	var showReasons = d(options.reasons, !forToString);
 	var showUsedExports = d(options.usedExports, !forToString);
+	var showProvidedExports = d(options.providedExports, !forToString);
 	var showChildren = d(options.children, true);
 	var showSource = d(options.source, !forToString);
 	var showErrors = d(options.errors, true);
@@ -258,6 +259,9 @@ Stats.prototype.toJson = function toJson(options, forToString) {
 		if(showUsedExports) {
 			obj.usedExports = module.used ? module.usedExports : false;
 		}
+		if(showProvidedExports) {
+			obj.providedExports = Array.isArray(module.providedExports) ? module.providedExports : null;
+		}
 		if(showSource && module._source) {
 			obj.source = module._source.source();
 		}
@@ -498,9 +502,72 @@ Stats.jsonToString = function jsonToString(obj, useColors) {
 		});
 	}
 
-	function processProfile(module) {
+	function processModuleAttributes(module) {
+		colors.normal(" ");
+		colors.normal(formatSize(module.size));
+		if(module.chunks) {
+			module.chunks.forEach(function(chunk) {
+				colors.normal(" {");
+				colors.yellow(chunk);
+				colors.normal("}");
+			});
+		}
+		if(!module.cacheable) {
+			colors.red(" [not cacheable]");
+		}
+		if(module.optional) {
+			colors.yellow(" [optional]");
+		}
+		if(module.built) {
+			colors.green(" [built]");
+		}
+		if(module.prefetched) {
+			colors.magenta(" [prefetched]");
+		}
+		if(module.failed)
+			colors.red(" [failed]");
+		if(module.warnings)
+			colors.yellow(" [" + module.warnings + " warning" + (module.warnings === 1 ? "" : "s") + "]");
+		if(module.errors)
+			colors.red(" [" + module.errors + " error" + (module.errors === 1 ? "" : "s") + "]");
+	}
+
+	function processModuleContent(module, prefix) {
+		if(Array.isArray(module.providedExports)) {
+			colors.normal(prefix);
+			colors.cyan("[exports: " + module.providedExports.join(", ") + "]");
+			newline();
+		}
+		if(module.usedExports !== undefined) {
+			if(module.usedExports !== true) {
+				colors.normal(prefix);
+				if(module.usedExports === false)
+					colors.cyan("[no exports used]");
+				else
+					colors.cyan("[only some exports used: " + module.usedExports.join(", ") + "]");
+				newline();
+			}
+		}
+		if(module.reasons) {
+			module.reasons.forEach(function(reason) {
+				colors.normal(prefix);
+				colors.normal(reason.type);
+				colors.normal(" ");
+				colors.cyan(reason.userRequest);
+				if(reason.templateModules) colors.cyan(reason.templateModules.join(" "));
+				colors.normal(" [");
+				colors.normal(reason.moduleId);
+				colors.normal("] ");
+				colors.magenta(reason.module);
+				if(reason.loc) {
+					colors.normal(" ");
+					colors.normal(reason.loc);
+				}
+				newline();
+			});
+		}
 		if(module.profile) {
-			colors.normal("      ");
+			colors.normal(prefix);
 			var sum = 0;
 			var path = [];
 			var current = module;
@@ -508,7 +575,7 @@ Stats.jsonToString = function jsonToString(obj, useColors) {
 				path.unshift(current = current.issuer);
 			}
 			path.forEach(function(module) {
-				colors.normal(" [");
+				colors.normal("[");
 				colors.normal(module.id);
 				colors.normal("] ");
 				if(module.profile) {
@@ -531,35 +598,6 @@ Stats.jsonToString = function jsonToString(obj, useColors) {
 		}
 	}
 
-	function processModuleAttributes(module) {
-		colors.normal(" ");
-		colors.normal(formatSize(module.size));
-		if(module.chunks) {
-			module.chunks.forEach(function(chunk) {
-				colors.normal(" {");
-				colors.yellow(chunk);
-				colors.normal("}");
-			});
-		}
-		if(!module.cacheable) {
-			colors.red(" [not cacheable]");
-		}
-		if(module.optional) {
-			colors.yellow(" [optional]");
-		}
-		if(module.built) {
-			colors.green(" [built]");
-		}
-		if(module.prefetched) {
-			colors.magenta(" [prefetched]");
-		}
-		if(module.failed)
-			colors.red(" [failed]");
-		if(module.warnings)
-			colors.yellow(" [" + module.warnings + " warning" + (module.warnings === 1 ? "" : "s") + "]");
-		if(module.errors)
-			colors.red(" [" + module.errors + " error" + (module.errors === 1 ? "" : "s") + "]");
-	}
 	if(obj.chunks) {
 		obj.chunks.forEach(function(chunk) {
 			colors.normal("chunk ");
@@ -633,35 +671,7 @@ Stats.jsonToString = function jsonToString(obj, useColors) {
 					colors.bold(module.name);
 					processModuleAttributes(module);
 					newline();
-					if(module.usedExports !== undefined) {
-						if(module.usedExports !== true) {
-							colors.normal("        ");
-							if(module.usedExports === false)
-								colors.cyan("[no exports used]");
-							else
-								colors.cyan("[only some exports used: " + module.usedExports.join(", ") + "]");
-							newline();
-						}
-					}
-					if(module.reasons) {
-						module.reasons.forEach(function(reason) {
-							colors.normal("        ");
-							colors.normal(reason.type);
-							colors.normal(" ");
-							colors.cyan(reason.userRequest);
-							if(reason.templateModules) colors.cyan(reason.templateModules.join(" "));
-							colors.normal(" [");
-							colors.normal(reason.moduleId);
-							colors.normal("] ");
-							colors.magenta(reason.module);
-							if(reason.loc) {
-								colors.normal(" ");
-								colors.normal(reason.loc);
-							}
-							newline();
-						});
-					}
-					processProfile(module);
+					processModuleContent(module, "        ");
 				});
 				if(chunk.filteredModules > 0) {
 					colors.normal("     + " + chunk.filteredModules + " hidden modules");
@@ -681,35 +691,7 @@ Stats.jsonToString = function jsonToString(obj, useColors) {
 			colors.bold(module.name || module.identifier);
 			processModuleAttributes(module);
 			newline();
-			if(module.usedExports !== undefined) {
-				if(module.usedExports !== true) {
-					colors.normal("       ");
-					if(module.usedExports === false)
-						colors.cyan("[no exports used]");
-					else
-						colors.cyan("[only some exports used: " + module.usedExports.join(", ") + "]");
-					newline();
-				}
-			}
-			if(module.reasons) {
-				module.reasons.forEach(function(reason) {
-					colors.normal("       ");
-					colors.normal(reason.type);
-					colors.normal(" ");
-					colors.cyan(reason.userRequest);
-					if(reason.templateModules) colors.cyan(reason.templateModules.join(" "));
-					colors.normal(" [");
-					colors.normal(reason.moduleId);
-					colors.normal("] ");
-					colors.magenta(reason.module);
-					if(reason.loc) {
-						colors.normal(" ");
-						colors.normal(reason.loc);
-					}
-					newline();
-				});
-			}
-			processProfile(module);
+			processModuleContent(module, "       ");
 		});
 		if(obj.filteredModules > 0) {
 			colors.normal("    + " + obj.filteredModules + " hidden modules");
@@ -768,6 +750,7 @@ Stats.presetToOptions = function(name) {
 			modules: false,
 			reasons: false,
 			usedExports: false,
+			providedExports: false,
 			children: false,
 			source: false,
 			errors: false,
@@ -788,6 +771,7 @@ Stats.presetToOptions = function(name) {
 			errorDetails: pn !== "errors-only" && pn !== "minimal",
 			reasons: pn === "verbose",
 			usedExports: pn === "verbose",
+			providedExports: pn === "verbose",
 			colors: true
 		};
 	}

package/lib/UseStrictPlugin.js

@@ -11,12 +11,16 @@ function UseStrictPlugin() {}
 module.exports = UseStrictPlugin;
 
 UseStrictPlugin.prototype.apply = function(compiler) {
-	compiler.parser.plugin("program", function(ast) {
-		var body = ast.body[0]
-		if(body &&
-			body.type === "ExpressionStatement" &&
-			body.expression.type === "Literal" &&
-			body.expression.value === "use strict")
-			this.state.module.strict = true;
-	});
+	compiler.plugin("compilation", function(compilation, params) {
+		params.normalModuleFactory.plugin("parser", function(parser) {
+			parser.plugin("program", function(ast) {
+				var body = ast.body[0]
+				if(body &&
+					body.type === "ExpressionStatement" &&
+					body.expression.type === "Literal" &&
+					body.expression.value === "use strict")
+					this.state.module.strict = true;
+			});
+		})
+	})
 };

package/lib/WebpackOptionsApply.js

@@ -40,6 +40,7 @@ var MergeDuplicateChunksPlugin = require("./optimize/MergeDuplicateChunksPlugin"
 var FlagIncludedChunksPlugin = require("./optimize/FlagIncludedChunksPlugin");
 var OccurrenceOrderPlugin = require("./optimize/OccurrenceOrderPlugin");
 var FlagDependencyUsagePlugin = require("./FlagDependencyUsagePlugin");
+var FlagDependencyExportsPlugin = require("./FlagDependencyExportsPlugin");
 
 var ResolverFactory = require("enhanced-resolve").ResolverFactory;
 
@@ -61,6 +62,7 @@ WebpackOptionsApply.prototype.process = function(options, compiler) {
 	compiler.recordsInputPath = options.recordsInputPath || options.recordsPath;
 	compiler.recordsOutputPath = options.recordsOutputPath || options.recordsPath;
 	compiler.name = options.name;
+	compiler.dependencies = options.dependencies;
 	if(typeof options.target === "string") {
 		var JsonpTemplatePlugin;
 		var NodeSourcePlugin;
@@ -256,6 +258,7 @@ WebpackOptionsApply.prototype.process = function(options, compiler) {
 		new MergeDuplicateChunksPlugin(),
 		new FlagIncludedChunksPlugin(),
 		new OccurrenceOrderPlugin(true),
+		new FlagDependencyExportsPlugin(),
 		new FlagDependencyUsagePlugin()
 	);
 
@@ -284,16 +287,3 @@ WebpackOptionsApply.prototype.process = function(options, compiler) {
 	compiler.applyPlugins("after-resolvers", compiler);
 	return options;
 };
-
-function makeRootPlugin(name, root) {
-	if(typeof root === "string")
-		return new ModulesInRootPlugin(name, root);
-	else if(Array.isArray(root)) {
-		return function() {
-			root.forEach(function(root) {
-				this.apply(new ModulesInRootPlugin(name, root));
-			}, this);
-		};
-	}
-	return function() {};
-}

package/lib/WebpackOptionsDefaulter.js

@@ -7,7 +7,6 @@ var Template = require("./Template");
 
 function WebpackOptionsDefaulter() {
 	OptionsDefaulter.call(this);
-	this.set("debug", false);
 	this.set("devtool", false);
 	this.set("cache", true);