webpack 3.6.0 → 3.8.1

package/lib/ContextModuleFactory.js

@@ -18,7 +18,6 @@ module.exports = class ContextModuleFactory extends Tapable {
 	}
 
 	create(data, callback) {
-		const module = this;
 		const context = data.context;
 		const dependencies = data.dependencies;
 		const dependency = dependencies[0];
@@ -59,7 +58,7 @@ module.exports = class ContextModuleFactory extends Tapable {
 				resource = request;
 			}
 
-			const resolvers = module.resolvers;
+			const resolvers = this.resolvers;
 
 			asyncLib.parallel([
 				function(callback) {
@@ -79,14 +78,14 @@ module.exports = class ContextModuleFactory extends Tapable {
 			], (err, result) => {
 				if(err) return callback(err);
 
-				module.applyPluginsAsyncWaterfall("after-resolve", {
+				this.applyPluginsAsyncWaterfall("after-resolve", {
 					loaders: loadersPrefix + result[1].join("!") + (result[1].length > 0 ? "!" : ""),
 					resource: result[0],
 					recursive: recursive,
 					regExp: regExp,
 					async: asyncContext,
 					dependencies: dependencies,
-					resolveDependencies: module.resolveDependencies.bind(module)
+					resolveDependencies: this.resolveDependencies.bind(this)
 				}, function(err, result) {
 					if(err) return callback(err);
 
@@ -100,11 +99,13 @@ module.exports = class ContextModuleFactory extends Tapable {
 	}
 
 	resolveDependencies(fs, resource, recursive, regExp, callback) {
+		const cmf = this;
 		if(!regExp || !resource)
 			return callback(null, []);
 		(function addDirectory(directory, callback) {
 			fs.readdir(directory, (err, files) => {
 				if(err) return callback(err);
+				files = cmf.applyPluginsWaterfall("context-module-files", files);
 				if(!files || files.length === 0) return callback(null, []);
 				asyncLib.map(files.filter(function(p) {
 					return p.indexOf(".") !== 0;
@@ -113,7 +114,15 @@ module.exports = class ContextModuleFactory extends Tapable {
 					const subResource = path.join(directory, seqment);
 
 					fs.stat(subResource, (err, stat) => {
-						if(err) return callback(err);
+						if(err) {
+							if(err.code === "ENOENT") {
+								// ENOENT is ok here because the file may have been deleted between
+								// the readdir and stat calls.
+								return callback();
+							} else {
+								return callback(err);
+							}
+						}
 
 						if(stat.isDirectory()) {
 

package/lib/ContextReplacementPlugin.js

@@ -1,111 +1,111 @@
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-"use strict";
-
-const path = require("path");
-const ContextElementDependency = require("./dependencies/ContextElementDependency");
-
-class ContextReplacementPlugin {
-	constructor(resourceRegExp, newContentResource, newContentRecursive, newContentRegExp) {
-		this.resourceRegExp = resourceRegExp;
-
-		if(typeof newContentResource === "function") {
-			this.newContentCallback = newContentResource;
-		} else if(typeof newContentResource === "string" && typeof newContentRecursive === "object") {
-			this.newContentResource = newContentResource;
-			this.newContentCreateContextMap = (fs, callback) => {
-				callback(null, newContentRecursive);
-			};
-		} else if(typeof newContentResource === "string" && typeof newContentRecursive === "function") {
-			this.newContentResource = newContentResource;
-			this.newContentCreateContextMap = newContentRecursive;
-		} else {
-			if(typeof newContentResource !== "string") {
-				newContentRegExp = newContentRecursive;
-				newContentRecursive = newContentResource;
-				newContentResource = undefined;
-			}
-			if(typeof newContentRecursive !== "boolean") {
-				newContentRegExp = newContentRecursive;
-				newContentRecursive = undefined;
-			}
-			this.newContentResource = newContentResource;
-			this.newContentRecursive = newContentRecursive;
-			this.newContentRegExp = newContentRegExp;
-		}
-	}
-
-	apply(compiler) {
-		const resourceRegExp = this.resourceRegExp;
-		const newContentCallback = this.newContentCallback;
-		const newContentResource = this.newContentResource;
-		const newContentRecursive = this.newContentRecursive;
-		const newContentRegExp = this.newContentRegExp;
-		const newContentCreateContextMap = this.newContentCreateContextMap;
-
-		compiler.plugin("context-module-factory", (cmf) => {
-			cmf.plugin("before-resolve", (result, callback) => {
-				if(!result) return callback();
-				if(resourceRegExp.test(result.request)) {
-					if(typeof newContentResource !== "undefined")
-						result.request = newContentResource;
-					if(typeof newContentRecursive !== "undefined")
-						result.recursive = newContentRecursive;
-					if(typeof newContentRegExp !== "undefined")
-						result.regExp = newContentRegExp;
-					if(typeof newContentCallback === "function") {
-						newContentCallback(result);
-					} else {
-						result.dependencies.forEach((d) => {
-							if(d.critical)
-								d.critical = false;
-						});
-					}
-				}
-				return callback(null, result);
-			});
-			cmf.plugin("after-resolve", (result, callback) => {
-				if(!result) return callback();
-				if(resourceRegExp.test(result.resource)) {
-					if(typeof newContentResource !== "undefined")
-						result.resource = path.resolve(result.resource, newContentResource);
-					if(typeof newContentRecursive !== "undefined")
-						result.recursive = newContentRecursive;
-					if(typeof newContentRegExp !== "undefined")
-						result.regExp = newContentRegExp;
-					if(typeof newContentCreateContextMap === "function")
-						result.resolveDependencies = createResolveDependenciesFromContextMap(newContentCreateContextMap);
-					if(typeof newContentCallback === "function") {
-						const origResource = result.resource;
-						newContentCallback(result);
-						if(result.resource !== origResource) {
-							result.resource = path.resolve(origResource, result.resource);
-						}
-					} else {
-						result.dependencies.forEach((d) => {
-							if(d.critical)
-								d.critical = false;
-						});
-					}
-				}
-				return callback(null, result);
-			});
-		});
-	}
-}
-
-const createResolveDependenciesFromContextMap = (createContextMap) => {
-	return function resolveDependenciesFromContextMap(fs, resource, recursive, regExp, callback) {
-		createContextMap(fs, (err, map) => {
-			if(err) return callback(err);
-			const dependencies = Object.keys(map).map((key) => {
-				return new ContextElementDependency(map[key], key);
-			});
-			callback(null, dependencies);
-		});
-	};
-};
-
-module.exports = ContextReplacementPlugin;
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+
+const path = require("path");
+const ContextElementDependency = require("./dependencies/ContextElementDependency");
+
+class ContextReplacementPlugin {
+	constructor(resourceRegExp, newContentResource, newContentRecursive, newContentRegExp) {
+		this.resourceRegExp = resourceRegExp;
+
+		if(typeof newContentResource === "function") {
+			this.newContentCallback = newContentResource;
+		} else if(typeof newContentResource === "string" && typeof newContentRecursive === "object") {
+			this.newContentResource = newContentResource;
+			this.newContentCreateContextMap = (fs, callback) => {
+				callback(null, newContentRecursive);
+			};
+		} else if(typeof newContentResource === "string" && typeof newContentRecursive === "function") {
+			this.newContentResource = newContentResource;
+			this.newContentCreateContextMap = newContentRecursive;
+		} else {
+			if(typeof newContentResource !== "string") {
+				newContentRegExp = newContentRecursive;
+				newContentRecursive = newContentResource;
+				newContentResource = undefined;
+			}
+			if(typeof newContentRecursive !== "boolean") {
+				newContentRegExp = newContentRecursive;
+				newContentRecursive = undefined;
+			}
+			this.newContentResource = newContentResource;
+			this.newContentRecursive = newContentRecursive;
+			this.newContentRegExp = newContentRegExp;
+		}
+	}
+
+	apply(compiler) {
+		const resourceRegExp = this.resourceRegExp;
+		const newContentCallback = this.newContentCallback;
+		const newContentResource = this.newContentResource;
+		const newContentRecursive = this.newContentRecursive;
+		const newContentRegExp = this.newContentRegExp;
+		const newContentCreateContextMap = this.newContentCreateContextMap;
+
+		compiler.plugin("context-module-factory", (cmf) => {
+			cmf.plugin("before-resolve", (result, callback) => {
+				if(!result) return callback();
+				if(resourceRegExp.test(result.request)) {
+					if(typeof newContentResource !== "undefined")
+						result.request = newContentResource;
+					if(typeof newContentRecursive !== "undefined")
+						result.recursive = newContentRecursive;
+					if(typeof newContentRegExp !== "undefined")
+						result.regExp = newContentRegExp;
+					if(typeof newContentCallback === "function") {
+						newContentCallback(result);
+					} else {
+						result.dependencies.forEach((d) => {
+							if(d.critical)
+								d.critical = false;
+						});
+					}
+				}
+				return callback(null, result);
+			});
+			cmf.plugin("after-resolve", (result, callback) => {
+				if(!result) return callback();
+				if(resourceRegExp.test(result.resource)) {
+					if(typeof newContentResource !== "undefined")
+						result.resource = path.resolve(result.resource, newContentResource);
+					if(typeof newContentRecursive !== "undefined")
+						result.recursive = newContentRecursive;
+					if(typeof newContentRegExp !== "undefined")
+						result.regExp = newContentRegExp;
+					if(typeof newContentCreateContextMap === "function")
+						result.resolveDependencies = createResolveDependenciesFromContextMap(newContentCreateContextMap);
+					if(typeof newContentCallback === "function") {
+						const origResource = result.resource;
+						newContentCallback(result);
+						if(result.resource !== origResource) {
+							result.resource = path.resolve(origResource, result.resource);
+						}
+					} else {
+						result.dependencies.forEach((d) => {
+							if(d.critical)
+								d.critical = false;
+						});
+					}
+				}
+				return callback(null, result);
+			});
+		});
+	}
+}
+
+const createResolveDependenciesFromContextMap = (createContextMap) => {
+	return function resolveDependenciesFromContextMap(fs, resource, recursive, regExp, callback) {
+		createContextMap(fs, (err, map) => {
+			if(err) return callback(err);
+			const dependencies = Object.keys(map).map((key) => {
+				return new ContextElementDependency(map[key], key);
+			});
+			callback(null, dependencies);
+		});
+	};
+};
+
+module.exports = ContextReplacementPlugin;

package/lib/DefinePlugin.js

@@ -1,123 +1,123 @@
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-"use strict";
-
-const ConstDependency = require("./dependencies/ConstDependency");
-const BasicEvaluatedExpression = require("./BasicEvaluatedExpression");
-const ParserHelpers = require("./ParserHelpers");
-const NullFactory = require("./NullFactory");
-
-class DefinePlugin {
-	constructor(definitions) {
-		this.definitions = definitions;
-	}
-
-	apply(compiler) {
-		const definitions = this.definitions;
-		compiler.plugin("compilation", (compilation, params) => {
-			compilation.dependencyFactories.set(ConstDependency, new NullFactory());
-			compilation.dependencyTemplates.set(ConstDependency, new ConstDependency.Template());
-
-			params.normalModuleFactory.plugin("parser", (parser) => {
-				(function walkDefinitions(definitions, prefix) {
-					Object.keys(definitions).forEach((key) => {
-						const code = definitions[key];
-						if(code && typeof code === "object" && !(code instanceof RegExp)) {
-							walkDefinitions(code, prefix + key + ".");
-							applyObjectDefine(prefix + key, code);
-							return;
-						}
-						applyDefineKey(prefix, key);
-						applyDefine(prefix + key, code);
-					});
-				}(definitions, ""));
-
-				function stringifyObj(obj) {
-					return "Object({" + Object.keys(obj).map((key) => {
-						const code = obj[key];
-						return JSON.stringify(key) + ":" + toCode(code);
-					}).join(",") + "})";
-				}
-
-				function toCode(code) {
-					if(code === null) return "null";
-					else if(code === undefined) return "undefined";
-					else if(code instanceof RegExp && code.toString) return code.toString();
-					else if(typeof code === "function" && code.toString) return "(" + code.toString() + ")";
-					else if(typeof code === "object") return stringifyObj(code);
-					else return code + "";
-				}
-
-				function applyDefineKey(prefix, key) {
-					const splittedKey = key.split(".");
-					splittedKey.slice(1).forEach((_, i) => {
-						const fullKey = prefix + splittedKey.slice(0, i + 1).join(".");
-						parser.plugin("can-rename " + fullKey, ParserHelpers.approve);
-					});
-				}
-
-				function applyDefine(key, code) {
-					const isTypeof = /^typeof\s+/.test(key);
-					if(isTypeof) key = key.replace(/^typeof\s+/, "");
-					let recurse = false;
-					let recurseTypeof = false;
-					code = toCode(code);
-					if(!isTypeof) {
-						parser.plugin("can-rename " + key, ParserHelpers.approve);
-						parser.plugin("evaluate Identifier " + key, (expr) => {
-							/**
-							 * this is needed in case there is a recursion in the DefinePlugin
-							 * to prevent an endless recursion
-							 * e.g.: new DefinePlugin({
-							 * "a": "b",
-							 * "b": "a"
-							 * });
-							 */
-							if(recurse) return;
-							recurse = true;
-							const res = parser.evaluate(code);
-							recurse = false;
-							res.setRange(expr.range);
-							return res;
-						});
-						parser.plugin("expression " + key, ParserHelpers.toConstantDependency(code));
-					}
-					const typeofCode = isTypeof ? code : "typeof (" + code + ")";
-					parser.plugin("evaluate typeof " + key, (expr) => {
-						/**
-						 * this is needed in case there is a recursion in the DefinePlugin
-						 * to prevent an endless recursion
-						 * e.g.: new DefinePlugin({
-						 * "typeof a": "tyepof b",
-						 * "typeof b": "typeof a"
-						 * });
-						 */
-						if(recurseTypeof) return;
-						recurseTypeof = true;
-						const res = parser.evaluate(typeofCode);
-						recurseTypeof = false;
-						res.setRange(expr.range);
-						return res;
-					});
-					parser.plugin("typeof " + key, (expr) => {
-						const res = parser.evaluate(typeofCode);
-						if(!res.isString()) return;
-						return ParserHelpers.toConstantDependency(JSON.stringify(res.string)).bind(parser)(expr);
-					});
-				}
-
-				function applyObjectDefine(key, obj) {
-					const code = stringifyObj(obj);
-					parser.plugin("can-rename " + key, ParserHelpers.approve);
-					parser.plugin("evaluate Identifier " + key, (expr) => new BasicEvaluatedExpression().setTruthy().setRange(expr.range));
-					parser.plugin("evaluate typeof " + key, ParserHelpers.evaluateToString("object"));
-					parser.plugin("expression " + key, ParserHelpers.toConstantDependency(code));
-					parser.plugin("typeof " + key, ParserHelpers.toConstantDependency(JSON.stringify("object")));
-				}
-			});
-		});
-	}
-}
-module.exports = DefinePlugin;
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+
+const ConstDependency = require("./dependencies/ConstDependency");
+const BasicEvaluatedExpression = require("./BasicEvaluatedExpression");
+const ParserHelpers = require("./ParserHelpers");
+const NullFactory = require("./NullFactory");
+
+class DefinePlugin {
+	constructor(definitions) {
+		this.definitions = definitions;
+	}
+
+	apply(compiler) {
+		const definitions = this.definitions;
+		compiler.plugin("compilation", (compilation, params) => {
+			compilation.dependencyFactories.set(ConstDependency, new NullFactory());
+			compilation.dependencyTemplates.set(ConstDependency, new ConstDependency.Template());
+
+			params.normalModuleFactory.plugin("parser", (parser) => {
+				(function walkDefinitions(definitions, prefix) {
+					Object.keys(definitions).forEach((key) => {
+						const code = definitions[key];
+						if(code && typeof code === "object" && !(code instanceof RegExp)) {
+							walkDefinitions(code, prefix + key + ".");
+							applyObjectDefine(prefix + key, code);
+							return;
+						}
+						applyDefineKey(prefix, key);
+						applyDefine(prefix + key, code);
+					});
+				}(definitions, ""));
+
+				function stringifyObj(obj) {
+					return "Object({" + Object.keys(obj).map((key) => {
+						const code = obj[key];
+						return JSON.stringify(key) + ":" + toCode(code);
+					}).join(",") + "})";
+				}
+
+				function toCode(code) {
+					if(code === null) return "null";
+					else if(code === undefined) return "undefined";
+					else if(code instanceof RegExp && code.toString) return code.toString();
+					else if(typeof code === "function" && code.toString) return "(" + code.toString() + ")";
+					else if(typeof code === "object") return stringifyObj(code);
+					else return code + "";
+				}
+
+				function applyDefineKey(prefix, key) {
+					const splittedKey = key.split(".");
+					splittedKey.slice(1).forEach((_, i) => {
+						const fullKey = prefix + splittedKey.slice(0, i + 1).join(".");
+						parser.plugin("can-rename " + fullKey, ParserHelpers.approve);
+					});
+				}
+
+				function applyDefine(key, code) {
+					const isTypeof = /^typeof\s+/.test(key);
+					if(isTypeof) key = key.replace(/^typeof\s+/, "");
+					let recurse = false;
+					let recurseTypeof = false;
+					code = toCode(code);
+					if(!isTypeof) {
+						parser.plugin("can-rename " + key, ParserHelpers.approve);
+						parser.plugin("evaluate Identifier " + key, (expr) => {
+							/**
+							 * this is needed in case there is a recursion in the DefinePlugin
+							 * to prevent an endless recursion
+							 * e.g.: new DefinePlugin({
+							 * "a": "b",
+							 * "b": "a"
+							 * });
+							 */
+							if(recurse) return;
+							recurse = true;
+							const res = parser.evaluate(code);
+							recurse = false;
+							res.setRange(expr.range);
+							return res;
+						});
+						parser.plugin("expression " + key, ParserHelpers.toConstantDependency(code));
+					}
+					const typeofCode = isTypeof ? code : "typeof (" + code + ")";
+					parser.plugin("evaluate typeof " + key, (expr) => {
+						/**
+						 * this is needed in case there is a recursion in the DefinePlugin
+						 * to prevent an endless recursion
+						 * e.g.: new DefinePlugin({
+						 * "typeof a": "tyepof b",
+						 * "typeof b": "typeof a"
+						 * });
+						 */
+						if(recurseTypeof) return;
+						recurseTypeof = true;
+						const res = parser.evaluate(typeofCode);
+						recurseTypeof = false;
+						res.setRange(expr.range);
+						return res;
+					});
+					parser.plugin("typeof " + key, (expr) => {
+						const res = parser.evaluate(typeofCode);
+						if(!res.isString()) return;
+						return ParserHelpers.toConstantDependency(JSON.stringify(res.string)).bind(parser)(expr);
+					});
+				}
+
+				function applyObjectDefine(key, obj) {
+					const code = stringifyObj(obj);
+					parser.plugin("can-rename " + key, ParserHelpers.approve);
+					parser.plugin("evaluate Identifier " + key, (expr) => new BasicEvaluatedExpression().setTruthy().setRange(expr.range));
+					parser.plugin("evaluate typeof " + key, ParserHelpers.evaluateToString("object"));
+					parser.plugin("expression " + key, ParserHelpers.toConstantDependency(code));
+					parser.plugin("typeof " + key, ParserHelpers.toConstantDependency(JSON.stringify("object")));
+				}
+			});
+		});
+	}
+}
+module.exports = DefinePlugin;