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

package/lib/NormalModuleFactory.js

@@ -7,16 +7,27 @@ var async = require("async");
 var Tapable = require("tapable");
 var NormalModule = require("./NormalModule");
 var RawModule = require("./RawModule");
-var LoadersList = require("./LoadersList");
+var Parser = require("./Parser");
+var RuleSet = require("./RuleSet");
+
+function loaderToIdent(data) {
+	if(!data.options)
+		return data.loader;
+	if(typeof data.options === "string")
+		return data.loader + "?" + data.options;
+	if(typeof data.options !== "object")
+		throw new Error("loader options must be string or object");
+	if(data.options.ident)
+		return data.loader + "??" + data.options.ident;
+	return data.loader + "?" + JSON.stringify(data.options);
+}
 
-function NormalModuleFactory(context, resolvers, parser, options) {
+function NormalModuleFactory(context, resolvers, options) {
 	Tapable.call(this);
 	this.resolvers = resolvers;
-	this.parser = parser;
-	this.loaders = new LoadersList(options.loaders);
-	this.preLoaders = new LoadersList(options.preLoaders);
-	this.postLoaders = new LoadersList(options.postLoaders);
+	this.ruleSet = new RuleSet(options.rules || options.loaders);
 	this.context = context || "";
+	this.parserCache = {};
 	this.plugin("factory", function() {
 		var _this = this;
 		return function(result, callback) {
@@ -77,6 +88,18 @@ function NormalModuleFactory(context, resolvers, parser, options) {
 			var noPostAutoLoaders = /^-!/.test(request);
 			var elements = request.replace(/^-?!+/, "").replace(/!!+/g, "!").split("!");
 			var resource = elements.pop();
+			elements = elements.map(function(element) {
+				var idx = element.indexOf("?");
+				var options;
+				if(idx >= 0) {
+					options = element.substr(idx + 1);
+					element = element.substr(0, idx);
+				}
+				return {
+					loader: element,
+					options: options
+				};
+			});
 
 			async.parallel([
 				function(callback) {
@@ -101,46 +124,53 @@ function NormalModuleFactory(context, resolvers, parser, options) {
 							"ignored " + context + " " + request,
 							request + " (ignored)")); // ignored
 
-				var userRequest = loaders.concat([resource]).join("!");
+				var userRequest = loaders.map(loaderToIdent).concat([resource]).join("!");
 
 				var resourcePath = resource;
 				var queryIndex = resourcePath.indexOf("?");
 				if(queryIndex >= 0)
 					resourcePath = resourcePath.substr(0, queryIndex);
 
-				if(noPrePostAutoLoaders)
-					return onDoneResolving();
-				if(noAutoLoaders) {
-					async.parallel([
-						_this.resolveRequestArray.bind(_this, contextInfo, _this.context, noPostAutoLoaders ? [] : _this.postLoaders.match(resourcePath), _this.resolvers.loader),
-						_this.resolveRequestArray.bind(_this, contextInfo, _this.context, _this.preLoaders.match(resourcePath), _this.resolvers.loader)
-					], function(err, results) {
-						if(err) return callback(err);
-						loaders = results[0].concat(loaders).concat(results[1]);
-						onDoneResolving();
-					});
-				} else {
-					async.parallel([
-						_this.resolveRequestArray.bind(_this, contextInfo, _this.context, noPostAutoLoaders ? [] : _this.postLoaders.match(resourcePath), _this.resolvers.loader),
-						_this.resolveRequestArray.bind(_this, contextInfo, _this.context, _this.loaders.match(resourcePath), _this.resolvers.loader),
-						_this.resolveRequestArray.bind(_this, contextInfo, _this.context, _this.preLoaders.match(resourcePath), _this.resolvers.loader)
-					], function(err, results) {
-						if(err) return callback(err);
-						loaders = results[0].concat(loaders).concat(results[1]).concat(results[2]);
-						onDoneResolving();
-					});
-				}
+				var result = _this.ruleSet.exec({
+					resource: resourcePath,
+					issuer: contextInfo.issuer
+				});
+				var settings = {};
+				var useLoadersPost = [];
+				var useLoaders = [];
+				var useLoadersPre = [];
+				result.forEach(function(r) {
+					if(r.type === "use") {
+						if(r.enforce === "post" && !noPostAutoLoaders && !noPrePostAutoLoaders)
+							useLoadersPost.push(r.value);
+						else if(r.enforce === "pre" && !noPrePostAutoLoaders)
+							useLoadersPre.push(r.value);
+						else if(!r.enforce && !noAutoLoaders && !noPrePostAutoLoaders)
+							useLoaders.push(r.value);
+					} else {
+						settings[r.type] = r.value;
+					}
+				});
+				async.parallel([
+					_this.resolveRequestArray.bind(_this, contextInfo, _this.context, useLoadersPost, _this.resolvers.loader),
+					_this.resolveRequestArray.bind(_this, contextInfo, _this.context, useLoaders, _this.resolvers.loader),
+					_this.resolveRequestArray.bind(_this, contextInfo, _this.context, useLoadersPre, _this.resolvers.loader)
+				], function(err, results) {
+					if(err) return callback(err);
+					loaders = results[0].concat(loaders).concat(results[1]).concat(results[2]);
+					onDoneResolving();
+				});
 
 				function onDoneResolving() {
 					callback(null, {
 						context: context,
-						request: loaders.concat([resource]).join("!"),
+						request: loaders.map(loaderToIdent).concat([resource]).join("!"),
 						dependencies: data.dependencies,
 						userRequest: userRequest,
 						rawRequest: request,
 						loaders: loaders,
 						resource: resource,
-						parser: _this.parser
+						parser: _this.getParser(settings.parser)
 					});
 				}
 			});
@@ -182,8 +212,31 @@ NormalModuleFactory.prototype.create = function(data, callback) {
 NormalModuleFactory.prototype.resolveRequestArray = function resolveRequestArray(contextInfo, context, array, resolver, callback) {
 	if(array.length === 0) return callback(null, []);
 	async.map(array, function(item, callback) {
-		if(item === "" || item[0] === "?")
-			return callback(null, item);
-		resolver.resolve(contextInfo, context, item, callback);
+		resolver.resolve(contextInfo, context, item.loader, function(err, result) {
+			if(err) return callback(err);
+			return callback(null, Object.assign({}, item, {
+				loader: result
+			}));
+		});
 	}, callback);
 };
+
+NormalModuleFactory.prototype.getParser = function getParser(parserOptions) {
+	var ident = "null"
+	if(parserOptions) {
+		if(parserOptions.ident)
+			ident = parserOptions.ident;
+		else
+			ident = JSON.stringify(parserOptions);
+	}
+	var parser = this.parserCache[ident];
+	if(parser)
+		return parser;
+	return this.parserCache[ident] = this.createParser(parserOptions);
+};
+
+NormalModuleFactory.prototype.createParser = function createParser(parserOptions) {
+	var parser = new Parser();
+	this.applyPlugins("parser", parser, parserOptions || {});
+	return parser;
+};

package/lib/Parser.js

@@ -817,7 +817,13 @@ Parser.prototype.walkCallExpression = function walkCallExpression(expression) {
 				this.walkExpression(functionExpression.body);
 		}.bind(this));
 	}
-	if(expression.callee.type === "MemberExpression" && expression.callee.object.type === "FunctionExpression" && !expression.callee.computed && ["call", "bind"].indexOf(expression.callee.property.name) >= 0 && expression.arguments && expression.arguments.length > 1) {
+	if(expression.callee.type === "MemberExpression" &&
+		expression.callee.object.type === "FunctionExpression" &&
+		!expression.callee.computed &&
+		(["call", "bind"]).indexOf(expression.callee.property.name) >= 0 &&
+		expression.arguments &&
+		expression.arguments.length > 1
+	) {
 		// (function(...) { }.call/bind(?, ...))
 		walkIIFE.call(this, expression.callee.object, expression.arguments.slice(1));
 		this.walkExpression(expression.arguments[0]);
@@ -1039,10 +1045,12 @@ var POSSIBLE_AST_OPTIONS = [{
 }]
 
 Parser.prototype.parse = function parse(source, initialState) {
-	var ast;
+	var ast, comments = [];
 	for(var i = 0; i < POSSIBLE_AST_OPTIONS.length; i++) {
 		if(!ast) {
 			try {
+				comments.length = 0;
+				POSSIBLE_AST_OPTIONS[i].onComment = comments;
 				ast = acorn.parse(source, POSSIBLE_AST_OPTIONS[i]);
 			} catch(e) {
 				// ignore the error
@@ -1055,7 +1063,8 @@ Parser.prototype.parse = function parse(source, initialState) {
 			ranges: true,
 			locations: true,
 			ecmaVersion: 6,
-			sourceType: "module"
+			sourceType: "module",
+			onComment: comments
 		});
 	}
 	if(!ast || typeof ast !== "object")
@@ -1068,7 +1077,7 @@ Parser.prototype.parse = function parse(source, initialState) {
 		renames: {}
 	};
 	var state = this.state = initialState || {};
-	if(this.applyPluginsBailResult("program", ast) === undefined)
+	if(this.applyPluginsBailResult("program", ast, comments) === undefined)
 		this.walkStatements(ast.body);
 	this.scope = oldScope;
 	this.state = oldState;

package/lib/ProvidePlugin.js

@@ -12,37 +12,40 @@ function ProvidePlugin(definitions) {
 }
 module.exports = ProvidePlugin;
 ProvidePlugin.prototype.apply = function(compiler) {
-	compiler.plugin("compilation", function(compilation) {
+	var definitions = this.definitions;
+	compiler.plugin("compilation", function(compilation, params) {
 		compilation.dependencyFactories.set(ConstDependency, new NullFactory());
 		compilation.dependencyTemplates.set(ConstDependency, new ConstDependency.Template());
-	});
-	Object.keys(this.definitions).forEach(function(name) {
-		var request = this.definitions[name];
-		var splittedName = name.split(".");
-		if(splittedName.length > 0) {
-			splittedName.slice(1).forEach(function(_, i) {
-				var name = splittedName.slice(0, i + 1).join(".");
-				compiler.parser.plugin("can-rename " + name, function() {
+		params.normalModuleFactory.plugin("parser", function(parser, parserOptions) {
+			Object.keys(definitions).forEach(function(name) {
+				var request = definitions[name];
+				var splittedName = name.split(".");
+				if(splittedName.length > 0) {
+					splittedName.slice(1).forEach(function(_, i) {
+						var name = splittedName.slice(0, i + 1).join(".");
+						parser.plugin("can-rename " + name, function() {
+							return true;
+						});
+					});
+				}
+				parser.plugin("expression " + name, function(expr) {
+					var nameIdentifier = name;
+					var scopedName = name.indexOf(".") >= 0;
+					if(scopedName) {
+						nameIdentifier = "__webpack_provided_" + name.replace(/\./g, "_dot_");
+					}
+					if(!ModuleParserHelpers.addParsedVariable(this, nameIdentifier, "require(" + JSON.stringify(request) + ")")) {
+						return false;
+					}
+					if(scopedName) {
+						nameIdentifier = "__webpack_provided_" + name.replace(/\./g, "_dot_");
+						var dep = new ConstDependency(nameIdentifier, expr.range);
+						dep.loc = expr.loc;
+						this.state.current.addDependency(dep);
+					}
 					return true;
 				});
 			});
-		}
-		compiler.parser.plugin("expression " + name, function(expr) {
-			var nameIdentifier = name;
-			var scopedName = name.indexOf(".") >= 0;
-			if(scopedName) {
-				nameIdentifier = "__webpack_provided_" + name.replace(/\./g, "_dot_");
-			}
-			if(!ModuleParserHelpers.addParsedVariable(this, nameIdentifier, "require(" + JSON.stringify(request) + ")")) {
-				return false;
-			}
-			if(scopedName) {
-				nameIdentifier = "__webpack_provided_" + name.replace(/\./g, "_dot_");
-				var dep = new ConstDependency(nameIdentifier, expr.range);
-				dep.loc = expr.loc;
-				this.state.current.addDependency(dep);
-			}
-			return true;
 		});
-	}, this);
+	});
 };

package/lib/RequireJsStuffPlugin.js

@@ -9,30 +9,36 @@ var NullFactory = require("./NullFactory");
 function RequireJsStuffPlugin() {}
 module.exports = RequireJsStuffPlugin;
 RequireJsStuffPlugin.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());
-	});
+		params.normalModuleFactory.plugin("parser", function(parser, parserOptions) {
 
-	function remove(expr) {
-		var dep = new ConstDependency(";", expr.range);
-		dep.loc = expr.loc;
-		this.state.current.addDependency(dep);
-		return true;
-	}
-	compiler.parser.plugin("call require.config", remove);
-	compiler.parser.plugin("call requirejs.config", remove);
+			if(typeof parserOptions.requireJs !== "undefined" && !parserOptions.requireJs)
+				return;
 
-	compiler.parser.plugin("expression require.version", function(expr) {
-		var dep = new ConstDependency(JSON.stringify("0.0.0"), expr.range);
-		dep.loc = expr.loc;
-		this.state.current.addDependency(dep);
-		return true;
-	});
-	compiler.parser.plugin("expression requirejs.onError", function(expr) {
-		var dep = new ConstDependency(JSON.stringify("__webpack_require__.oe"), expr.range);
-		dep.loc = expr.loc;
-		this.state.current.addDependency(dep);
-		return true;
+			function remove(expr) {
+				var dep = new ConstDependency(";", expr.range);
+				dep.loc = expr.loc;
+				this.state.current.addDependency(dep);
+				return true;
+			}
+			parser.plugin("call require.config", remove);
+			parser.plugin("call requirejs.config", remove);
+
+			parser.plugin("expression require.version", function(expr) {
+				var dep = new ConstDependency(JSON.stringify("0.0.0"), expr.range);
+				dep.loc = expr.loc;
+				this.state.current.addDependency(dep);
+				return true;
+			});
+			parser.plugin("expression requirejs.onError", function(expr) {
+				var dep = new ConstDependency(JSON.stringify("__webpack_require__.oe"), expr.range);
+				dep.loc = expr.loc;
+				this.state.current.addDependency(dep);
+				return true;
+			});
+		});
 	});
+
 };