webpack 2.4.0 → 2.6.0

package/lib/LibManifestPlugin.js

@@ -46,7 +46,7 @@ class LibManifestPlugin {
 						return obj;
 					}, {})
 				};
-				const content = new Buffer(JSON.stringify(manifest, null, 2), "utf8"); //eslint-disable-line
+				const content = new Buffer(JSON.stringify(manifest), "utf8"); //eslint-disable-line
 				compiler.outputFileSystem.mkdirp(path.dirname(targetPath), err => {
 					if(err) return callback(err);
 					compiler.outputFileSystem.writeFile(targetPath, content, callback);

package/lib/NormalModule.js

@@ -257,7 +257,7 @@ class NormalModule extends Module {
 	}
 
 	build(options, compilation, resolver, fs, callback) {
-		this.buildTimestamp = new Date().getTime();
+		this.buildTimestamp = Date.now();
 		this.built = true;
 		this._source = null;
 		this.error = null;

package/lib/Parser.js

@@ -636,11 +636,16 @@ class Parser extends Tapable {
 	}
 
 	walkFunctionDeclaration(statement) {
+		statement.params.forEach(param => {
+			this.walkPattern(param);
+		});
 		this.inScope(statement.params, function() {
-			if(statement.body.type === "BlockStatement")
+			if(statement.body.type === "BlockStatement") {
+				this.prewalkStatement(statement.body);
 				this.walkStatement(statement.body);
-			else
+			} else {
 				this.walkExpression(statement.body);
+			}
 		}.bind(this));
 	}
 
@@ -795,24 +800,15 @@ class Parser extends Tapable {
 			switch(declarator.type) {
 				case "VariableDeclarator":
 					{
-						const renameIdentifier = declarator.init && this.getRenameIdentifier(declarator.init);
-						if(renameIdentifier && declarator.id.type === "Identifier" && this.applyPluginsBailResult1("can-rename " + renameIdentifier, declarator.init)) {
-							// renaming with "var a = b;"
-							if(!this.applyPluginsBailResult1("rename " + renameIdentifier, declarator.init)) {
-								this.scope.renames["$" + declarator.id.name] = this.scope.renames["$" + renameIdentifier] || renameIdentifier;
-								const idx = this.scope.definitions.indexOf(declarator.id.name);
-								if(idx >= 0) this.scope.definitions.splice(idx, 1);
-							}
-						} else {
-							this.enterPattern(declarator.id, (name, decl) => {
-								if(!this.applyPluginsBailResult1("var-" + declarator.kind + " " + name, decl)) {
-									if(!this.applyPluginsBailResult1("var " + name, decl)) {
-										this.scope.renames["$" + name] = undefined;
+						this.enterPattern(declarator.id, (name, decl) => {
+							if(!this.applyPluginsBailResult1("var-" + declarator.kind + " " + name, decl)) {
+								if(!this.applyPluginsBailResult1("var " + name, decl)) {
+									this.scope.renames["$" + name] = undefined;
+									if(this.scope.definitions.indexOf(name) < 0)
 										this.scope.definitions.push(name);
-									}
 								}
-							});
-						}
+							}
+						});
 						break;
 					}
 			}
@@ -825,7 +821,14 @@ class Parser extends Tapable {
 				case "VariableDeclarator":
 					{
 						const renameIdentifier = declarator.init && this.getRenameIdentifier(declarator.init);
-						if(!renameIdentifier || declarator.id.type !== "Identifier" || !this.applyPluginsBailResult1("can-rename " + renameIdentifier, declarator.init)) {
+						if(renameIdentifier && declarator.id.type === "Identifier" && this.applyPluginsBailResult1("can-rename " + renameIdentifier, declarator.init)) {
+							// renaming with "var a = b;"
+							if(!this.applyPluginsBailResult1("rename " + renameIdentifier, declarator.init)) {
+								this.scope.renames["$" + declarator.id.name] = this.scope.renames["$" + renameIdentifier] || renameIdentifier;
+								const idx = this.scope.definitions.indexOf(declarator.id.name);
+								if(idx >= 0) this.scope.definitions.splice(idx, 1);
+							}
+						} else {
 							this.walkPattern(declarator.id);
 							if(declarator.init)
 								this.walkExpression(declarator.init);
@@ -843,6 +846,11 @@ class Parser extends Tapable {
 			this["walk" + pattern.type](pattern);
 	}
 
+	walkAssignmentPattern(pattern) {
+		this.walkExpression(pattern.right);
+		this.walkPattern(pattern.left);
+	}
+
 	walkObjectPattern(pattern) {
 		for(let i = 0, len = pattern.properties.length; i < len; i++) {
 			const prop = pattern.properties[i];
@@ -910,6 +918,9 @@ class Parser extends Tapable {
 	}
 
 	walkFunctionExpression(expression) {
+		expression.params.forEach(param => {
+			this.walkPattern(param);
+		});
 		this.inScope(expression.params, function() {
 			if(expression.body.type === "BlockStatement") {
 				this.prewalkStatement(expression.body);
@@ -921,6 +932,9 @@ class Parser extends Tapable {
 	}
 
 	walkArrowFunctionExpression(expression) {
+		expression.params.forEach(param => {
+			this.walkPattern(param);
+		});
 		this.inScope(expression.params, function() {
 			if(expression.body.type === "BlockStatement") {
 				this.prewalkStatement(expression.body);
@@ -991,8 +1005,10 @@ class Parser extends Tapable {
 			}
 		} else {
 			this.walkExpression(expression.right);
-			this.scope.renames["$" + expression.left.name] = undefined;
-			this.walkExpression(expression.left);
+			this.walkPattern(expression.left);
+			this.enterPattern(expression.left, (name, decl) => {
+				this.scope.renames["$" + name] = undefined;
+			});
 		}
 	}
 
@@ -1189,7 +1205,6 @@ class Parser extends Tapable {
 
 	enterAssignmentPattern(pattern, onIdent) {
 		this.enterPattern(pattern.left, onIdent);
-		this.walkExpression(pattern.right);
 	}
 
 	evaluateExpression(expression) {

package/lib/ProgressPlugin.js

@@ -157,9 +157,9 @@ class ProgressPlugin {
 				state = state.replace(/^\d+\/\d+\s+/, "");
 				if(percentage === 0) {
 					lastState = null;
-					lastStateTime = +new Date();
+					lastStateTime = Date.now();
 				} else if(state !== lastState || percentage === 1) {
-					const now = +new Date();
+					const now = Date.now();
 					if(lastState) {
 						const stateMsg = `${now - lastStateTime}ms ${lastState}`;
 						goToLineStart(stateMsg);

package/lib/RawModule.js

@@ -36,7 +36,7 @@ module.exports = class RawModule extends Module {
 	}
 
 	build(options, compilations, resolver, fs, callback) {
-		this.builtTime = new Date().getTime();
+		this.builtTime = Date.now();
 		callback();
 	}
 

package/lib/Stats.js

@@ -95,6 +95,7 @@ class Stats {
 		const showProvidedExports = optionOrFallback(options.providedExports, !forToString);
 		const showChildren = optionOrFallback(options.children, true);
 		const showSource = optionOrFallback(options.source, !forToString);
+		const showModuleTrace = optionOrFallback(options.moduleTrace, true);
 		const showErrors = optionOrFallback(options.errors, true);
 		const showErrorDetails = optionOrFallback(options.errorDetails, !forToString);
 		const showWarnings = optionOrFallback(options.warnings, true);
@@ -164,7 +165,7 @@ class Stats {
 			text += e.message;
 			if(showErrorDetails && e.details) text += `\n${e.details}`;
 			if(showErrorDetails && e.missing) text += e.missing.map(item => `\n[${item}]`).join("");
-			if(e.dependencies && e.origin) {
+			if(showModuleTrace && e.dependencies && e.origin) {
 				text += `\n @ ${e.origin.readableIdentifier(requestShortener)}`;
 				e.dependencies.forEach(dep => {
 					if(!dep.loc) return;

package/lib/Template.js

@@ -26,6 +26,11 @@ module.exports = class Template extends Tapable {
 		return str.replace(/^[^a-zA-Z$_]/, "_").replace(/[^a-zA-Z0-9$_]/g, "_");
 	}
 
+	static toPath(str) {
+		if(typeof str !== "string") return "";
+		return str.replace(/[^a-zA-Z0-9_!§$()=\-\^°]+/g, "-").replace(/^-|-$/, "");
+	}
+
 	// map number to a single character a-z, A-Z or <_ + number> if number is too big
 	static numberToIdentifer(n) {
 		// lower case

package/lib/WebpackOptionsApply.js

@@ -206,9 +206,9 @@ class WebpackOptionsApply extends OptionsApply {
 			noSources = options.devtool.indexOf("nosources") >= 0;
 			legacy = options.devtool.indexOf("@") >= 0;
 			modern = options.devtool.indexOf("#") >= 0;
-			comment = legacy && modern ? "\n/*\n//@ sourceMappingURL=[url]\n//# sourceMappingURL=[url]\n*/" :
-				legacy ? "\n/*\n//@ sourceMappingURL=[url]\n*/" :
-				modern ? "\n//# sourceMappingURL=[url]" :
+			comment = legacy && modern ? "\n/*\n//@ source" + "MappingURL=[url]\n//# source" + "MappingURL=[url]\n*/" :
+				legacy ? "\n/*\n//@ source" + "MappingURL=[url]\n*/" :
+				modern ? "\n//# source" + "MappingURL=[url]" :
 				null;
 			let Plugin = evalWrapped ? EvalSourceMapDevToolPlugin : SourceMapDevToolPlugin;
 			compiler.apply(new Plugin({

package/lib/WebpackOptionsDefaulter.js

@@ -60,6 +60,7 @@ class WebpackOptionsDefaulter extends OptionsDefaulter {
 		this.set("output.hotUpdateChunkFilename", "[id].[hash].hot-update.js");
 		this.set("output.hotUpdateMainFilename", "[hash].hot-update.json");
 		this.set("output.crossOriginLoading", false);
+		this.set("output.chunkLoadTimeout", 120000);
 		this.set("output.hashFunction", "md5");
 		this.set("output.hashDigest", "hex");
 		this.set("output.hashDigestLength", 20);

package/lib/dependencies/DepBlockHelpers.js

@@ -33,7 +33,7 @@ DepBlockHelpers.getDepBlockPromise = function(depBlock, outputOptions, requestSh
 				"])";
 		}
 	}
-	return "Promise.resolve()";
+	return "new Promise(function(resolve) { resolve(); })";
 };
 
 function asComment(str) {

package/lib/dependencies/HarmonyCompatibilityDependency.js

@@ -22,7 +22,7 @@ HarmonyCompatibilityDependency.Template = class HarmonyExportDependencyTemplate
 		if(usedExports && !Array.isArray(usedExports)) {
 			const exportName = dep.originModule.exportsArgument || "exports";
 			const content = `Object.defineProperty(${exportName}, \"__esModule\", { value: true });\n`;
-			source.insert(-1, content);
+			source.insert(-10, content);
 		}
 	}
 };

package/lib/dependencies/HarmonyExportDependencyParserPlugin.js

@@ -45,7 +45,7 @@ module.exports = class HarmonyExportDependencyParserPlugin {
 			} else {
 				const immutable = statement.declaration && isImmutableStatement(statement.declaration);
 				const hoisted = statement.declaration && isHoistedStatement(statement.declaration);
-				dep = new HarmonyExportSpecifierDependency(parser.state.module, id, name, !immutable || hoisted ? -0.5 : (statement.range[1] + 0.5), immutable);
+				dep = new HarmonyExportSpecifierDependency(parser.state.module, id, name, !immutable || hoisted ? -2 : (statement.range[1] + 0.5), immutable);
 			}
 			dep.loc = Object.create(statement.loc);
 			dep.loc.index = idx;

package/lib/dependencies/ImportContextDependency.js

@@ -12,7 +12,6 @@ class ImportContextDependency extends ContextDependency {
 		super(request, recursive, regExp);
 		this.range = range;
 		this.valueRange = valueRange;
-		this.async = true;
 		this.chunkName = chunkName;
 	}
 

package/lib/dependencies/ImportDependency.js

@@ -44,7 +44,7 @@ ImportDependency.Template = class ImportDependencyTemplate {
 
 		if(dep.module) {
 			const stringifiedId = JSON.stringify(dep.module.id);
-			return `Promise.resolve(__webpack_require__(${comment}${stringifiedId}))`;
+			return `new Promise(function(resolve) { resolve(__webpack_require__(${comment}${stringifiedId})); })`;
 		}
 
 		return webpackMissingPromiseModule(dep.request);

package/lib/dependencies/ImportEagerContextDependency.js

@@ -0,0 +1,22 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+const ImportContextDependency = require("./ImportContextDependency");
+const ContextDependencyTemplateAsRequireCall = require("./ContextDependencyTemplateAsRequireCall");
+
+class ImportEagerContextDependency extends ImportContextDependency {
+	constructor(request, recursive, regExp, range, valueRange, chunkName) {
+		super(request, recursive, regExp, range, valueRange, chunkName);
+		this.async = "eager";
+	}
+
+	get type() {
+		return "import() context eager";
+	}
+}
+
+ImportEagerContextDependency.Template = ContextDependencyTemplateAsRequireCall;
+
+module.exports = ImportEagerContextDependency;

package/lib/dependencies/ImportEagerDependency.js

@@ -0,0 +1,46 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+const ModuleDependency = require("./ModuleDependency");
+const webpackMissingPromiseModule = require("./WebpackMissingModule").promise;
+
+class ImportEagerDependency extends ModuleDependency {
+	constructor(request, range) {
+		super(request);
+		this.range = range;
+	}
+
+	get type() {
+		return "import()";
+	}
+}
+
+ImportEagerDependency.Template = class ImportEagerDependencyTemplate {
+	apply(dep, source, outputOptions, requestShortener) {
+		const comment = this.getOptionalComment(outputOptions.pathinfo, requestShortener.shorten(dep.request));
+
+		const content = this.getContent(dep, comment);
+		source.replace(dep.range[0], dep.range[1] - 1, content);
+	}
+
+	getOptionalComment(pathinfo, shortenedRequest) {
+		if(!pathinfo) {
+			return "";
+		}
+
+		return `/*! ${shortenedRequest} */ `;
+	}
+
+	getContent(dep, comment) {
+		if(dep.module) {
+			const stringifiedId = JSON.stringify(dep.module.id);
+			return `new Promise(function(resolve) { resolve(__webpack_require__(${comment}${stringifiedId})); })`;
+		}
+
+		return webpackMissingPromiseModule(dep.request);
+	}
+};
+
+module.exports = ImportEagerDependency;

package/lib/dependencies/ImportLazyContextDependency.js

@@ -0,0 +1,22 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+const ImportContextDependency = require("./ImportContextDependency");
+const ContextDependencyTemplateAsRequireCall = require("./ContextDependencyTemplateAsRequireCall");
+
+class ImportLazyContextDependency extends ImportContextDependency {
+	constructor(request, recursive, regExp, range, valueRange, chunkName) {
+		super(request, recursive, regExp, range, valueRange, chunkName);
+		this.async = "lazy";
+	}
+
+	get type() {
+		return "import() context lazy";
+	}
+}
+
+ImportLazyContextDependency.Template = ContextDependencyTemplateAsRequireCall;
+
+module.exports = ImportLazyContextDependency;

package/lib/dependencies/ImportLazyOnceContextDependency.js

@@ -0,0 +1,22 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+const ImportContextDependency = require("./ImportContextDependency");
+const ContextDependencyTemplateAsRequireCall = require("./ContextDependencyTemplateAsRequireCall");
+
+class ImportLazyOnceContextDependency extends ImportContextDependency {
+	constructor(request, recursive, regExp, range, valueRange, chunkName) {
+		super(request, recursive, regExp, range, valueRange, chunkName);
+		this.async = "lazy-once";
+	}
+
+	get type() {
+		return "import() context lazy-once";
+	}
+}
+
+ImportLazyOnceContextDependency.Template = ContextDependencyTemplateAsRequireCall;
+
+module.exports = ImportLazyOnceContextDependency;

package/lib/dependencies/ImportParserPlugin.js

@@ -4,9 +4,13 @@
 */
 "use strict";
 
-const ImportContextDependency = require("./ImportContextDependency");
+const ImportEagerContextDependency = require("./ImportEagerContextDependency");
+const ImportLazyOnceContextDependency = require("./ImportLazyOnceContextDependency");
+const ImportLazyContextDependency = require("./ImportLazyContextDependency");
 const ImportDependenciesBlock = require("./ImportDependenciesBlock");
+const ImportEagerDependency = require("./ImportEagerDependency");
 const ContextDependencyHelpers = require("./ContextDependencyHelpers");
+const UnsupportedFeatureWarning = require("../UnsupportedFeatureWarning");
 
 class ImportParserPlugin {
 	constructor(options) {
@@ -23,22 +27,49 @@ class ImportParserPlugin {
 			const param = parser.evaluateExpression(expr.arguments[0]);
 
 			let chunkName = null;
+			let mode = "lazy";
 
 			const importOptions = parser.getCommentOptions(expr.range);
 			if(importOptions) {
 				if(typeof importOptions.webpackChunkName !== "undefined") {
 					if(typeof importOptions.webpackChunkName !== "string")
-						throw new Error(`\`webpackChunkName\` expected a string, but received: ${importOptions.webpackChunkName}.`);
-					chunkName = importOptions.webpackChunkName;
+						parser.state.module.warnings.push(new UnsupportedFeatureWarning(parser.state.module, `\`webpackChunkName\` expected a string, but received: ${importOptions.webpackChunkName}.`));
+					else
+						chunkName = importOptions.webpackChunkName;
+				}
+				if(typeof importOptions.webpackMode !== "undefined") {
+					if(typeof importOptions.webpackMode !== "string")
+						parser.state.module.warnings.push(new UnsupportedFeatureWarning(parser.state.module, `\`webpackMode\` expected a string, but received: ${importOptions.webpackMode}.`));
+					else
+						mode = importOptions.webpackMode;
 				}
 			}
 
 			if(param.isString()) {
-				const depBlock = new ImportDependenciesBlock(param.string, expr.range, chunkName, parser.state.module, expr.loc);
-				parser.state.current.addBlock(depBlock);
+				if(mode !== "lazy" && mode !== "eager") {
+					parser.state.module.warnings.push(new UnsupportedFeatureWarning(parser.state.module, `\`webpackMode\` expected 'lazy' or 'eager', but received: ${mode}.`));
+				}
+
+				if(mode === "eager") {
+					const dep = new ImportEagerDependency(param.string, expr.range);
+					parser.state.current.addDependency(dep);
+				} else {
+					const depBlock = new ImportDependenciesBlock(param.string, expr.range, chunkName, parser.state.module, expr.loc);
+					parser.state.current.addBlock(depBlock);
+				}
 				return true;
 			} else {
-				const dep = ContextDependencyHelpers.create(ImportContextDependency, expr.range, param, expr, options, chunkName);
+				if(mode !== "lazy" && mode !== "lazy-once" && mode !== "eager") {
+					parser.state.module.warnings.push(new UnsupportedFeatureWarning(parser.state.module, `\`webpackMode\` expected 'lazy', 'lazy-once' or 'eager', but received: ${mode}.`));
+				}
+
+				let Dep = ImportLazyContextDependency;
+				if(mode === "eager") {
+					Dep = ImportEagerContextDependency;
+				} else if(mode === "lazy-once") {
+					Dep = ImportLazyOnceContextDependency;
+				}
+				const dep = ContextDependencyHelpers.create(Dep, expr.range, param, expr, options, chunkName);
 				if(!dep) return;
 				dep.loc = expr.loc;
 				dep.optional = !!parser.scope.inTry;

package/lib/dependencies/ImportPlugin.js

@@ -5,7 +5,10 @@
 "use strict";
 
 const ImportDependency = require("./ImportDependency");
-const ImportContextDependency = require("./ImportContextDependency");
+const ImportEagerDependency = require("./ImportEagerDependency");
+const ImportEagerContextDependency = require("./ImportEagerContextDependency");
+const ImportLazyOnceContextDependency = require("./ImportLazyOnceContextDependency");
+const ImportLazyContextDependency = require("./ImportLazyContextDependency");
 const ImportParserPlugin = require("./ImportParserPlugin");
 
 class ImportPlugin {
@@ -22,8 +25,17 @@ class ImportPlugin {
 			compilation.dependencyFactories.set(ImportDependency, normalModuleFactory);
 			compilation.dependencyTemplates.set(ImportDependency, new ImportDependency.Template());
 
-			compilation.dependencyFactories.set(ImportContextDependency, contextModuleFactory);
-			compilation.dependencyTemplates.set(ImportContextDependency, new ImportContextDependency.Template());
+			compilation.dependencyFactories.set(ImportEagerDependency, normalModuleFactory);
+			compilation.dependencyTemplates.set(ImportEagerDependency, new ImportEagerDependency.Template());
+
+			compilation.dependencyFactories.set(ImportEagerContextDependency, contextModuleFactory);
+			compilation.dependencyTemplates.set(ImportEagerContextDependency, new ImportEagerContextDependency.Template());
+
+			compilation.dependencyFactories.set(ImportLazyOnceContextDependency, contextModuleFactory);
+			compilation.dependencyTemplates.set(ImportLazyOnceContextDependency, new ImportLazyOnceContextDependency.Template());
+
+			compilation.dependencyFactories.set(ImportLazyContextDependency, contextModuleFactory);
+			compilation.dependencyTemplates.set(ImportLazyContextDependency, new ImportLazyContextDependency.Template());
 
 			params.normalModuleFactory.plugin("parser", (parser, parserOptions) => {
 

package/lib/formatLocation.js

@@ -2,36 +2,53 @@
 	MIT License http://www.opensource.org/licenses/mit-license.php
 	Author Tobias Koppers @sokra
 */
-module.exports = function formatLocation(loc) {
-	if(typeof loc === "string")
-		return loc;
-	if(typeof loc === "number")
-		return loc + "";
-	if(loc && typeof loc === "object") {
-		if(loc.start && loc.end) {
-			if(typeof loc.start.line === "number" && typeof loc.end.line === "number" && typeof loc.end.column === "number" && loc.start.line === loc.end.line)
-				return formatPosition(loc.start) + "-" + loc.end.column;
-			return formatPosition(loc.start) + "-" + formatPosition(loc.end);
-		}
-		if(loc.start)
-			return formatPosition(loc.start);
-		return formatPosition(loc);
-	}
-	return "";
 
-	function formatPosition(pos) {
-		if(typeof pos === "string")
+"use strict";
+
+const formatPosition = (pos) => {
+	if(pos === null)
+		return "";
+	const typeOfPos = typeof pos;
+	switch(typeOfPos) {
+		case "string":
 			return pos;
-		if(typeof pos === "number")
-			return pos + "";
-		if(pos && typeof pos === "object") {
+		case "number":
+			return `${pos}`;
+		case "object":
 			if(typeof pos.line === "number" && typeof pos.column === "number")
-				return pos.line + ":" + pos.column;
-			if(typeof pos.line === "number")
-				return pos.line + ":?";
-			if(typeof pos.index === "number")
-				return "+" + pos.index;
-		}
+				return `${pos.line}:${pos.column}`;
+			else if(typeof pos.line === "number")
+				return `${pos.line}:?`;
+			else if(typeof pos.index === "number")
+				return `+${pos.index}`;
+			else
+				return "";
+		default:
+			return "";
+	}
+};
+
+const formatLocation = (loc) => {
+	if(loc === null)
 		return "";
+	const typeOfLoc = typeof loc;
+	switch(typeOfLoc) {
+		case "string":
+			return loc;
+		case "number":
+			return `${loc}`;
+		case "object":
+			if(loc.start && loc.end) {
+				if(typeof loc.start.line === "number" && typeof loc.end.line === "number" && typeof loc.end.column === "number" && loc.start.line === loc.end.line)
+					return `${formatPosition(loc.start)}-${loc.end.column}`;
+				return `${formatPosition(loc.start)}-${formatPosition(loc.end)}`;
+			}
+			if(loc.start)
+				return formatPosition(loc.start);
+			return formatPosition(loc);
+		default:
+			return "";
 	}
 };
+
+module.exports = formatLocation;