webpack 2.3.3 → 2.5.1

package/lib/NormalModuleFactory.js

@@ -1,13 +1,15 @@
 /*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-var async = require("async");
-var Tapable = require("tapable");
-var NormalModule = require("./NormalModule");
-var RawModule = require("./RawModule");
-var Parser = require("./Parser");
-var RuleSet = require("./RuleSet");
+ MIT License http://www.opensource.org/licenses/mit-license.php
+ Author Tobias Koppers @sokra
+ */
+"use strict";
+
+const asyncLib = require("async");
+const Tapable = require("tapable");
+const NormalModule = require("./NormalModule");
+const RawModule = require("./RawModule");
+const Parser = require("./Parser");
+const RuleSet = require("./RuleSet");
 
 function loaderToIdent(data) {
 	if(!data.options)
@@ -22,8 +24,8 @@ function loaderToIdent(data) {
 }
 
 function identToLoaderRequest(resultString) {
-	var idx = resultString.indexOf("?");
-	var options;
+	const idx = resultString.indexOf("?");
+	let options;
 
 	if(idx >= 0) {
 		options = resultString.substr(idx + 1);
@@ -31,7 +33,7 @@ function identToLoaderRequest(resultString) {
 
 		return {
 			loader: resultString,
-			options: options
+			options
 		};
 	} else {
 		return {
@@ -40,261 +42,263 @@ function identToLoaderRequest(resultString) {
 	}
 }
 
-function NormalModuleFactory(context, resolvers, options) {
-	Tapable.call(this);
-	this.resolvers = resolvers;
-	this.ruleSet = new RuleSet(options.rules || options.loaders);
-	this.cachePredicate = typeof options.unsafeCache === "function" ? options.unsafeCache : Boolean.bind(null, options.unsafeCache);
-	this.context = context || "";
-	this.parserCache = {};
-	this.plugin("factory", function() {
-		var _this = this;
-		return function(result, callback) {
-			var resolver = _this.applyPluginsWaterfall0("resolver", null);
-
-			// Ignored
-			if(!resolver) return callback();
-
-			resolver(result, function onDoneResolving(err, data) {
-				if(err) return callback(err);
+class NormalModuleFactory extends Tapable {
+	constructor(context, resolvers, options) {
+		super();
+		this.resolvers = resolvers;
+		this.ruleSet = new RuleSet(options.rules || options.loaders);
+		this.cachePredicate = typeof options.unsafeCache === "function" ? options.unsafeCache : Boolean.bind(null, options.unsafeCache);
+		this.context = context || "";
+		this.parserCache = {};
+		this.plugin("factory", function() {
+			/* beautify preserve:start */
+            // js-beautify consider to concat "return" and "("
+            // but it сontradicts eslint rule (keyword-spacing)
+			return (result, callback) => {
+				/* beautify preserve:end */
+				let resolver = this.applyPluginsWaterfall0("resolver", null);
 
 				// Ignored
-				if(!data) return callback();
-
-				// direct module
-				if(typeof data.source === "function")
-					return callback(null, data);
+				if(!resolver) return callback();
 
-				_this.applyPluginsAsyncWaterfall("after-resolve", data, function(err, result) {
+				resolver(result, (err, data) => {
 					if(err) return callback(err);
 
 					// Ignored
-					if(!result) return callback();
+					if(!data) return callback();
+
+					// direct module
+					if(typeof data.source === "function")
+						return callback(null, data);
+
+					this.applyPluginsAsyncWaterfall("after-resolve", data, (err, result) => {
+						if(err) return callback(err);
+
+						// Ignored
+						if(!result) return callback();
+
+						let createdModule = this.applyPluginsBailResult("create-module", result);
+						if(!createdModule) {
 
-					var createdModule = _this.applyPluginsBailResult("create-module", result);
-					if(!createdModule) {
+							if(!result.request) {
+								return callback(new Error("Empty dependency (no request)"));
+							}
 
-						if(!result.request) {
-							return callback(new Error("Empty dependency (no request)"));
+							createdModule = new NormalModule(
+								result.request,
+								result.userRequest,
+								result.rawRequest,
+								result.loaders,
+								result.resource,
+								result.parser
+							);
 						}
 
-						createdModule = new NormalModule(
-							result.request,
-							result.userRequest,
-							result.rawRequest,
-							result.loaders,
-							result.resource,
-							result.parser
+						createdModule = this.applyPluginsWaterfall0("module", createdModule);
+
+						return callback(null, createdModule);
+					});
+				});
+			};
+		});
+		this.plugin("resolver", function() {
+			/* beautify preserve:start */
+            // js-beautify consider to concat "return" and "("
+            // but it сontradicts eslint rule (keyword-spacing)
+			return (data, callback) => {
+				/* beautify preserve:end */
+				const contextInfo = data.contextInfo;
+				const context = data.context;
+				const request = data.request;
+
+				const noAutoLoaders = /^-?!/.test(request);
+				const noPrePostAutoLoaders = /^!!/.test(request);
+				const noPostAutoLoaders = /^-!/.test(request);
+				let elements = request.replace(/^-?!+/, "").replace(/!!+/g, "!").split("!");
+				let resource = elements.pop();
+				elements = elements.map(identToLoaderRequest);
+
+				asyncLib.parallel([
+					callback => this.resolveRequestArray(contextInfo, context, elements, this.resolvers.loader, callback),
+					callback => {
+						if(resource === "" || resource[0] === "?")
+							return callback(null, {
+								resource
+							});
+
+						this.resolvers.normal.resolve(contextInfo, context, resource, (err, resource, resourceResolveData) => {
+							if(err) return callback(err);
+							callback(null, {
+								resourceResolveData,
+								resource
+							});
+						});
+					}
+				], (err, results) => {
+					if(err) return callback(err);
+					let loaders = results[0];
+					const resourceResolveData = results[1].resourceResolveData;
+					resource = results[1].resource;
+
+					// translate option idents
+					try {
+						loaders.forEach(item => {
+							if(typeof item.options === "string" && /^\?/.test(item.options)) {
+								item.options = this.ruleSet.findOptionsByIdent(item.options.substr(1));
+							}
+						});
+					} catch(e) {
+						return callback(e);
+					}
+
+					if(resource === false) {
+						// ignored
+						return callback(null,
+							new RawModule(
+								"/* (ignored) */",
+								`ignored ${context} ${request}`,
+								`${request} (ignored)`
+							)
 						);
 					}
 
-					createdModule = _this.applyPluginsWaterfall0("module", createdModule);
+					const userRequest = loaders.map(loaderToIdent).concat([resource]).join("!");
 
-					return callback(null, createdModule);
-				});
-			});
-		};
-	});
-	this.plugin("resolver", function() {
-		var _this = this;
-		return function(data, callback) {
-			var contextInfo = data.contextInfo;
-			var context = data.context;
-			var request = data.request;
-			var resolveContextInfo = {};
-
-			var noAutoLoaders = /^-?!/.test(request);
-			var noPrePostAutoLoaders = /^!!/.test(request);
-			var noPostAutoLoaders = /^-!/.test(request);
-			var elements = request.replace(/^-?!+/, "").replace(/!!+/g, "!").split("!");
-			var resource = elements.pop();
-			elements = elements.map(identToLoaderRequest);
-
-			async.parallel([
-				function(callback) {
-					_this.resolveRequestArray(resolveContextInfo, context, elements, _this.resolvers.loader, callback);
-				},
-				function(callback) {
-					if(resource === "" || resource[0] === "?")
-						return callback(null, {
-							resource: resource
-						});
+					let resourcePath = resource;
+					let resourceQuery = "";
+					const queryIndex = resourcePath.indexOf("?");
+					if(queryIndex >= 0) {
+						resourceQuery = resourcePath.substr(queryIndex);
+						resourcePath = resourcePath.substr(0, queryIndex);
+					}
 
-					_this.resolvers.normal.resolve(resolveContextInfo, context, resource, function(err, resource, resourceResolveData) {
-						if(err) return callback(err);
-						callback(null, {
-							resourceResolveData: resourceResolveData,
-							resource: resource,
-						});
+					const result = this.ruleSet.exec({
+						resource: resourcePath,
+						resourceQuery,
+						issuer: contextInfo.issuer,
+						compiler: contextInfo.compiler
 					});
-				}
-			], function(err, results) {
-				if(err) return callback(err);
-				var loaders = results[0];
-				var resourceResolveData = results[1].resourceResolveData;
-				resource = results[1].resource;
-
-				// translate option idents
-				try {
-					loaders.forEach(function(item) {
-						if(typeof item.options === "string" && /^\?/.test(item.options)) {
-							item.options = _this.ruleSet.findOptionsByIdent(item.options.substr(1));
+					const settings = {};
+					const useLoadersPost = [];
+					const useLoaders = [];
+					const useLoadersPre = [];
+					result.forEach(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;
 						}
 					});
-				} catch(e) {
-					return callback(e);
-				}
-
-				if(resource === false)
-					return callback(null,
-						new RawModule("/* (ignored) */",
-							"ignored " + context + " " + request,
-							request + " (ignored)")); // ignored
+					asyncLib.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)
+					], (err, results) => {
+						if(err) return callback(err);
+						loaders = results[0].concat(loaders, results[1], results[2]);
+						process.nextTick(() => {
+							callback(null, {
+								context: context,
+								request: loaders.map(loaderToIdent).concat([resource]).join("!"),
+								dependencies: data.dependencies,
+								userRequest,
+								rawRequest: request,
+								loaders,
+								resource,
+								resourceResolveData,
+								parser: this.getParser(settings.parser)
+							});
+						});
+					});
+				});
+			};
+		});
+	}
 
-				var userRequest = loaders.map(loaderToIdent).concat([resource]).join("!");
+	create(data, callback) {
+		const dependencies = data.dependencies;
+		const cacheEntry = dependencies[0].__NormalModuleFactoryCache;
+		if(cacheEntry) return callback(null, cacheEntry);
+		const context = data.context || this.context;
+		const request = dependencies[0].request;
+		const contextInfo = data.contextInfo || {};
+		this.applyPluginsAsyncWaterfall("before-resolve", {
+			contextInfo,
+			context,
+			request,
+			dependencies
+		}, (err, result) => {
+			if(err) return callback(err);
 
-				var resourcePath = resource;
-				var resourceQuery = "";
-				var queryIndex = resourcePath.indexOf("?");
-				if(queryIndex >= 0) {
-					resourceQuery = resourcePath.substr(queryIndex);
-					resourcePath = resourcePath.substr(0, queryIndex);
-				}
+			// Ignored
+			if(!result) return callback();
 
-				var result = _this.ruleSet.exec({
-					resource: resourcePath,
-					resourceQuery: resourceQuery,
-					issuer: contextInfo.issuer,
-					compiler: contextInfo.compiler
-				});
-				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, resolveContextInfo, _this.context, useLoadersPost, _this.resolvers.loader),
-					_this.resolveRequestArray.bind(_this, resolveContextInfo, _this.context, useLoaders, _this.resolvers.loader),
-					_this.resolveRequestArray.bind(_this, resolveContextInfo, _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]);
-					process.nextTick(onDoneResolving);
-				});
+			const factory = this.applyPluginsWaterfall0("factory", null);
 
-				function onDoneResolving() {
-					callback(null, {
-						context: context,
-						request: loaders.map(loaderToIdent).concat([resource]).join("!"),
-						dependencies: data.dependencies,
-						userRequest: userRequest,
-						rawRequest: request,
-						loaders: loaders,
-						resource: resource,
-						resourceResolveData: resourceResolveData,
-						parser: _this.getParser(settings.parser)
-					});
-				}
-			});
-		};
-	});
-}
-module.exports = NormalModuleFactory;
+			// Ignored
+			if(!factory) return callback();
 
-NormalModuleFactory.prototype = Object.create(Tapable.prototype);
-NormalModuleFactory.prototype.constructor = NormalModuleFactory;
-
-NormalModuleFactory.prototype.create = function(data, callback) {
-	var _this = this;
-	var dependencies = data.dependencies;
-	var cacheEntry = dependencies[0].__NormalModuleFactoryCache;
-	if(cacheEntry) return callback(null, cacheEntry);
-	var context = data.context || this.context;
-	var request = dependencies[0].request;
-	var contextInfo = data.contextInfo || {};
-	_this.applyPluginsAsyncWaterfall("before-resolve", {
-		contextInfo: contextInfo,
-		context: context,
-		request: request,
-		dependencies: dependencies
-	}, function(err, result) {
-		if(err) return callback(err);
-
-		// Ignored
-		if(!result) return callback();
-
-		var factory = _this.applyPluginsWaterfall0("factory", null);
-
-		// Ignored
-		if(!factory) return callback();
-
-		factory(result, function(err, module) {
-			if(err) return callback(err);
+			factory(result, (err, module) => {
+				if(err) return callback(err);
 
-			if(module && _this.cachePredicate(module)) {
-				dependencies.forEach(function(d) {
-					d.__NormalModuleFactoryCache = module;
-				});
-			}
+				if(module && this.cachePredicate(module)) {
+					dependencies.forEach(d => d.__NormalModuleFactoryCache = module);
+				}
 
-			callback(null, module);
+				callback(null, module);
+			});
 		});
+	}
 
-	});
-};
-
-NormalModuleFactory.prototype.resolveRequestArray = function resolveRequestArray(contextInfo, context, array, resolver, callback) {
-	if(array.length === 0) return callback(null, []);
-	async.map(array, function(item, callback) {
-		resolver.resolve(contextInfo, context, item.loader, function(err, result) {
-			if(err && /^[^/]*$/.test(item.loader) && !/-loader$/.test(item.loader)) {
-				return resolver.resolve(contextInfo, context, item.loader + "-loader", function(err2) {
-					if(!err2) {
-						err.message = err.message + "\n" +
-							"BREAKING CHANGE: It's no longer allowed to omit the '-loader' suffix when using loaders.\n" +
-							"                 You need to specify '" + item.loader + "-loader' instead of '" + item.loader + "',\n" +
-							"                 see https://webpack.js.org/guides/migrating/#automatic-loader-module-name-extension-removed";
-					}
-					callback(err);
-				});
-			}
-			if(err) return callback(err);
+	resolveRequestArray(contextInfo, context, array, resolver, callback) {
+		if(array.length === 0) return callback(null, []);
+		asyncLib.map(array, (item, callback) => {
+			resolver.resolve(contextInfo, context, item.loader, (err, result) => {
+				if(err && /^[^/]*$/.test(item.loader) && !/-loader$/.test(item.loader)) {
+					return resolver.resolve(contextInfo, context, item.loader + "-loader", err2 => {
+						if(!err2) {
+							err.message = err.message + "\n" +
+								"BREAKING CHANGE: It's no longer allowed to omit the '-loader' suffix when using loaders.\n" +
+								`                 You need to specify '${item.loader}-loader' instead of '${item.loader}',\n` +
+								"                 see https://webpack.js.org/guides/migrating/#automatic-loader-module-name-extension-removed";
+						}
+						callback(err);
+					});
+				}
+				if(err) return callback(err);
 
-			var optionsOnly = item.options ? {
-				options: item.options
-			} : undefined;
-			return callback(null, Object.assign({}, item, identToLoaderRequest(result), optionsOnly));
-		});
-	}, callback);
-};
-
-NormalModuleFactory.prototype.getParser = function getParser(parserOptions) {
-	var ident = "null";
-	if(parserOptions) {
-		if(parserOptions.ident)
-			ident = parserOptions.ident;
-		else
-			ident = JSON.stringify(parserOptions);
+				const optionsOnly = item.options ? {
+					options: item.options
+				} : undefined;
+				return callback(null, Object.assign({}, item, identToLoaderRequest(result), optionsOnly));
+			});
+		}, callback);
 	}
-	var parser = this.parserCache[ident];
-	if(parser)
+
+	getParser(parserOptions) {
+		let ident = "null";
+		if(parserOptions) {
+			if(parserOptions.ident)
+				ident = parserOptions.ident;
+			else
+				ident = JSON.stringify(parserOptions);
+		}
+		const parser = this.parserCache[ident];
+		if(parser)
+			return parser;
+		return this.parserCache[ident] = this.createParser(parserOptions);
+	}
+
+	createParser(parserOptions) {
+		const parser = new Parser();
+		this.applyPlugins2("parser", parser, parserOptions || {});
 		return parser;
-	return this.parserCache[ident] = this.createParser(parserOptions);
-};
-
-NormalModuleFactory.prototype.createParser = function createParser(parserOptions) {
-	var parser = new Parser();
-	this.applyPlugins2("parser", parser, parserOptions || {});
-	return parser;
-};
+	}
+}
+
+module.exports = NormalModuleFactory;