webpack 2.5.1 → 2.6.0

package/lib/ContextModule.js

@@ -8,16 +8,18 @@ const Module = require("./Module");
 const OriginalSource = require("webpack-sources").OriginalSource;
 const RawSource = require("webpack-sources").RawSource;
 const AsyncDependenciesBlock = require("./AsyncDependenciesBlock");
+const DepBlockHelpers = require("./dependencies/DepBlockHelpers");
+const Template = require("./Template");
 
 class ContextModule extends Module {
-	constructor(resolveDependencies, context, recursive, regExp, addon, isAsync, chunkName) {
+	constructor(resolveDependencies, context, recursive, regExp, addon, asyncMode, chunkName) {
 		super();
 		this.resolveDependencies = resolveDependencies;
 		this.context = context;
 		this.recursive = recursive;
 		this.regExp = regExp;
 		this.addon = addon;
-		this.async = !!isAsync;
+		this.async = asyncMode;
 		this.cacheable = true;
 		this.contextDependencies = [context];
 		this.built = false;
@@ -44,7 +46,7 @@ class ContextModule extends Module {
 	identifier() {
 		let identifier = this.context;
 		if(this.async)
-			identifier += " async";
+			identifier += ` ${this.async}`;
 		if(!this.recursive)
 			identifier += " nonrecursive";
 		if(this.addon)
@@ -58,7 +60,7 @@ class ContextModule extends Module {
 	readableIdentifier(requestShortener) {
 		let identifier = requestShortener.shorten(this.context);
 		if(this.async)
-			identifier += " async";
+			identifier += ` ${this.async}`;
 		if(!this.recursive)
 			identifier += " nonrecursive";
 		if(this.addon)
@@ -72,7 +74,7 @@ class ContextModule extends Module {
 	libIdent(options) {
 		let identifier = this.contextify(options.context, this.context);
 		if(this.async)
-			identifier += " async";
+			identifier += ` ${this.async}`;
 		if(this.recursive)
 			identifier += " recursive";
 		if(this.addon)
@@ -103,42 +105,67 @@ class ContextModule extends Module {
 		this.resolveDependencies(fs, this.context, this.recursive, this.regExp, (err, dependencies) => {
 			if(err) return callback(err);
 
+			// Reset children
+			this.dependencies = [];
+			this.blocks = [];
+
+			// abort if something failed
+			// this will create an empty context
 			if(!dependencies) {
-				this.dependencies = [];
 				callback();
 				return;
 			}
 
-			// enhance dependencies
+			// enhance dependencies with meta info
 			dependencies.forEach(dep => {
 				dep.loc = dep.userRequest;
 				dep.request = this.addon + dep.request;
 			});
 
-			// if these we are not a async context
-			// add dependencies and continue
-			if(!this.async) {
+			if(!this.async || this.async === "eager") {
+
+				// if we have an sync or eager context
+				// just add all dependencies and continue
 				this.dependencies = dependencies;
-				callback();
-				return;
-			}
 
-			// if we are async however create a new async dependency block
-			// and add that block to this context
-			dependencies.forEach(dep => {
-				const block = new AsyncDependenciesBlock(this.chunkName, dep.module, dep.loc);
-				block.addDependency(dep);
-				this.addBlock(block);
-			});
+			} else if(this.async === "lazy-once") {
+
+				// for the lazy-once mode create a new async dependency block
+				// and add that block to this context
+				if(dependencies.length > 0) {
+					const block = new AsyncDependenciesBlock(this.chunkName, this);
+					dependencies.forEach(dep => {
+						block.addDependency(dep);
+					});
+					this.addBlock(block);
+				}
+
+			} else {
+
+				// if we are lazy create a new async dependency block per dependency
+				// and add all blocks to this context
+				dependencies.forEach((dep, idx) => {
+					let chunkName = this.chunkName;
+					if(chunkName) {
+						if(!/\[(index|request)\]/.test(chunkName))
+							chunkName += "[index]";
+						chunkName = chunkName.replace(/\[index\]/g, idx);
+						chunkName = chunkName.replace(/\[request\]/g, Template.toPath(dep.userRequest));
+					}
+					const block = new AsyncDependenciesBlock(chunkName, dep.module, dep.loc);
+					block.addDependency(dep);
+					this.addBlock(block);
+				});
+			}
 			callback();
 		});
 	}
 
-	getSourceWithDependencies(dependencies, id) {
+	getUserRequestMap(dependencies) {
 		// if we filter first we get a new array
 		// therefor we dont need to create a clone of dependencies explicitly
 		// therefore the order of this is !important!
-		const map = dependencies
+		return dependencies
 			.filter(dependency => dependency.module)
 			.sort((a, b) => {
 				if(a.userRequest === b.userRequest) {
@@ -149,6 +176,10 @@ class ContextModule extends Module {
 				map[dep.userRequest] = dep.module.id;
 				return map;
 			}, Object.create(null));
+	}
+
+	getSyncSource(dependencies, id) {
+		const map = this.getUserRequestMap(dependencies);
 		return `var map = ${JSON.stringify(map, null, "\t")};
 function webpackContext(req) {
 	return __webpack_require__(webpackContextResolve(req));
@@ -167,7 +198,53 @@ module.exports = webpackContext;
 webpackContext.id = ${JSON.stringify(id)};`;
 	}
 
-	getSourceWithBlocks(blocks, id) {
+	getEagerSource(dependencies, id) {
+		const map = this.getUserRequestMap(dependencies);
+		return `var map = ${JSON.stringify(map, null, "\t")};
+function webpackAsyncContext(req) {
+	return webpackAsyncContextResolve(req).then(__webpack_require__);
+};
+function webpackAsyncContextResolve(req) {
+	return new Promise(function(resolve, reject) {
+		var id = map[req];
+		if(!(id + 1)) // check for number or string
+			reject(new Error("Cannot find module '" + req + "'."));
+		else
+			resolve(id);
+	});
+};
+webpackAsyncContext.keys = function webpackAsyncContextKeys() {
+	return Object.keys(map);
+};
+webpackAsyncContext.resolve = webpackAsyncContextResolve;
+module.exports = webpackAsyncContext;
+webpackAsyncContext.id = ${JSON.stringify(id)};`;
+	}
+
+	getLazyOnceSource(block, dependencies, id, outputOptions, requestShortener) {
+		const promise = DepBlockHelpers.getDepBlockPromise(block, outputOptions, requestShortener, "lazy-once context");
+		const map = this.getUserRequestMap(dependencies);
+		return `var map = ${JSON.stringify(map, null, "\t")};
+function webpackAsyncContext(req) {
+	return webpackAsyncContextResolve(req).then(__webpack_require__);
+};
+function webpackAsyncContextResolve(req) {
+	return ${promise}.then(function() {
+		var id = map[req];
+		if(!(id + 1)) // check for number or string
+			throw new Error("Cannot find module '" + req + "'.");
+		return id;
+	});
+};
+webpackAsyncContext.keys = function webpackAsyncContextKeys() {
+	return Object.keys(map);
+};
+webpackAsyncContext.resolve = webpackAsyncContextResolve;
+module.exports = webpackAsyncContext;
+webpackAsyncContext.id = ${JSON.stringify(id)};`;
+	}
+
+	getLazySource(blocks, id) {
 		let hasMultipleOrNoChunks = false;
 		const map = blocks
 			.filter(block => block.dependencies[0].module)
@@ -219,15 +296,38 @@ module.exports = webpackEmptyContext;
 webpackEmptyContext.id = ${JSON.stringify(id)};`;
 	}
 
-	getSourceString() {
-		if(this.dependencies && this.dependencies.length > 0) {
-			return this.getSourceWithDependencies(this.dependencies, this.id);
-		}
+	getSourceForEmptyAsyncContext(id) {
+		return `function webpackEmptyAsyncContext(req) {
+	return new Promise(function(resolve, reject) { reject(new Error("Cannot find module '" + req + "'.")); });
+}
+webpackEmptyAsyncContext.keys = function() { return []; };
+webpackEmptyAsyncContext.resolve = webpackEmptyAsyncContext;
+module.exports = webpackEmptyAsyncContext;
+webpackEmptyAsyncContext.id = ${JSON.stringify(id)};`;
+	}
 
-		if(this.blocks && this.blocks.length > 0) {
-			return this.getSourceWithBlocks(this.blocks, this.id);
+	getSourceString(asyncMode, outputOptions, requestShortener) {
+		if(asyncMode === "lazy") {
+			if(this.blocks && this.blocks.length > 0) {
+				return this.getLazySource(this.blocks, this.id);
+			}
+			return this.getSourceForEmptyAsyncContext(this.id);
+		}
+		if(asyncMode === "eager") {
+			if(this.dependencies && this.dependencies.length > 0) {
+				return this.getEagerSource(this.dependencies, this.id);
+			}
+			return this.getSourceForEmptyAsyncContext(this.id);
+		} else if(asyncMode === "lazy-once") {
+			const block = this.blocks[0];
+			if(block) {
+				return this.getLazyOnceSource(block, block.dependencies, this.id, outputOptions, requestShortener);
+			}
+			return this.getSourceForEmptyAsyncContext(this.id);
+		}
+		if(this.dependencies && this.dependencies.length > 0) {
+			return this.getSyncSource(this.dependencies, this.id);
 		}
-
 		return this.getSourceForEmptyContext(this.id);
 	}
 
@@ -238,9 +338,9 @@ webpackEmptyContext.id = ${JSON.stringify(id)};`;
 		return new RawSource(sourceString);
 	}
 
-	source() {
+	source(dependencyTemplates, outputOptions, requestShortener) {
 		return this.getSource(
-			this.getSourceString()
+			this.getSourceString(this.async, outputOptions, requestShortener)
 		);
 	}
 

package/lib/HotModuleReplacement.runtime.js

@@ -578,6 +578,8 @@ module.exports = function() {
 		}
 
 		hotSetStatus("idle");
-		return Promise.resolve(outdatedModules);
+		return new Promise(function(resolve) {
+			resolve(outdatedModules);
+		});
 	}
 };

package/lib/JsonpMainTemplatePlugin.js

@@ -19,7 +19,9 @@ class JsonpMainTemplatePlugin {
 					this.indent(
 						chunk.ids.map(id => `${JSON.stringify(id)}: 0`).join(",\n")
 					),
-					"};"
+					"};",
+					"",
+					"var resolvedPromise = new Promise(function(resolve) { resolve(); });"
 				]);
 			}
 			return source;
@@ -28,7 +30,7 @@ class JsonpMainTemplatePlugin {
 			const chunkFilename = this.outputOptions.chunkFilename;
 			const chunkMaps = chunk.getChunkMaps();
 			const crossOriginLoading = this.outputOptions.crossOriginLoading;
-			const chunkLoadTimeout = this.outputOptions.chunkLoadTimeout || 120000;
+			const chunkLoadTimeout = this.outputOptions.chunkLoadTimeout;
 			const scriptSrcPath = this.applyPluginsWaterfall("asset-path", JSON.stringify(chunkFilename), {
 				hash: `" + ${this.renderCurrentHashCode(hash)} + "`,
 				hashWithLength: length => `" + ${this.renderCurrentHashCode(hash, length)} + "`,
@@ -81,7 +83,7 @@ class JsonpMainTemplatePlugin {
 			return this.asString([
 				"if(installedChunks[chunkId] === 0) {",
 				this.indent([
-					"return Promise.resolve();"
+					"return resolvedPromise;"
 				]),
 				"}",
 				"",

package/lib/Parser.js

@@ -636,6 +636,9 @@ class Parser extends Tapable {
 	}
 
 	walkFunctionDeclaration(statement) {
+		statement.params.forEach(param => {
+			this.walkPattern(param);
+		});
 		this.inScope(statement.params, function() {
 			if(statement.body.type === "BlockStatement") {
 				this.prewalkStatement(statement.body);
@@ -797,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;
 					}
 			}
@@ -827,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);
@@ -845,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];
@@ -912,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);
@@ -923,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);
@@ -993,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;
+			});
 		}
 	}
 
@@ -1191,7 +1205,6 @@ class Parser extends Tapable {
 
 	enterAssignmentPattern(pattern, onIdent) {
 		this.enterPattern(pattern.left, onIdent);
-		this.walkExpression(pattern.right);
 	}
 
 	evaluateExpression(expression) {

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/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/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/node/NodeSourcePlugin.js

@@ -2,83 +2,85 @@
 	MIT License http://www.opensource.org/licenses/mit-license.php
 	Author Tobias Koppers @sokra
 */
-var AliasPlugin = require("enhanced-resolve/lib/AliasPlugin");
-var ParserHelpers = require("../ParserHelpers");
-var nodeLibsBrowser = require("node-libs-browser");
+"use strict";
+const AliasPlugin = require("enhanced-resolve/lib/AliasPlugin");
+const ParserHelpers = require("../ParserHelpers");
+const nodeLibsBrowser = require("node-libs-browser");
 
-function NodeSourcePlugin(options) {
-	this.options = options;
-}
-module.exports = NodeSourcePlugin;
-NodeSourcePlugin.prototype.apply = function(compiler) {
-	var options = this.options;
-
-	function getPathToModule(module, type) {
-		if(type === true || (type === undefined && nodeLibsBrowser[module])) {
-			if(!nodeLibsBrowser[module]) throw new Error("No browser version for node.js core module '" + module + "' available");
-			return nodeLibsBrowser[module];
-		} else if(type === "mock") {
-			return require.resolve("node-libs-browser/mock/" + module);
-		} else if(type === "empty") {
-			return require.resolve("node-libs-browser/mock/empty");
-		} else return module;
+module.exports = class NodeSourcePlugin {
+	constructor(options) {
+		this.options = options;
 	}
+	apply(compiler) {
+		const options = this.options;
 
-	function addExpression(parser, name, module, type, suffix) {
-		suffix = suffix || "";
-		parser.plugin("expression " + name, function() {
-			if(this.state.module && this.state.module.resource === getPathToModule(module, type)) return;
-			var mockModule = ParserHelpers.requireFileAsExpression(this.state.module.context, getPathToModule(module, type));
-			return ParserHelpers.addParsedVariableToModule(this, name, mockModule + suffix);
-		});
-	}
+		function getPathToModule(module, type) {
+			if(type === true || (type === undefined && nodeLibsBrowser[module])) {
+				if(!nodeLibsBrowser[module]) throw new Error(`No browser version for node.js core module ${module} available`);
+				return nodeLibsBrowser[module];
+			} else if(type === "mock") {
+				return require.resolve(`node-libs-browser/mock/${module}`);
+			} else if(type === "empty") {
+				return require.resolve("node-libs-browser/mock/empty");
+			} else return module;
+		}
 
-	compiler.plugin("compilation", function(compilation, params) {
-		params.normalModuleFactory.plugin("parser", function(parser, parserOptions) {
+		function addExpression(parser, name, module, type, suffix) {
+			suffix = suffix || "";
+			parser.plugin(`expression ${name}`, function() {
+				if(this.state.module && this.state.module.resource === getPathToModule(module, type)) return;
+				const mockModule = ParserHelpers.requireFileAsExpression(this.state.module.context, getPathToModule(module, type));
+				return ParserHelpers.addParsedVariableToModule(this, name, mockModule + suffix);
+			});
+		}
 
-			if(parserOptions.node === false)
-				return;
+		compiler.plugin("compilation", function(compilation, params) {
+			params.normalModuleFactory.plugin("parser", function(parser, parserOptions) {
 
-			var localOptions = options;
-			if(parserOptions.node)
-				localOptions = Object.assign({}, localOptions, parserOptions.node);
+				if(parserOptions.node === false)
+					return;
 
-			if(localOptions.global) {
-				parser.plugin("expression global", function() {
-					var retrieveGlobalModule = ParserHelpers.requireFileAsExpression(this.state.module.context, require.resolve("../../buildin/global.js"));
-					return ParserHelpers.addParsedVariableToModule(this, "global", retrieveGlobalModule);
-				});
-			}
-			if(localOptions.process) {
-				var processType = localOptions.process;
-				addExpression(parser, "process", "process", processType);
-			}
-			if(localOptions.console) {
-				var consoleType = localOptions.console;
-				addExpression(parser, "console", "console", consoleType);
-			}
-			var bufferType = localOptions.Buffer;
-			if(bufferType) {
-				addExpression(parser, "Buffer", "buffer", bufferType, ".Buffer");
-			}
-			if(localOptions.setImmediate) {
-				var setImmediateType = localOptions.setImmediate;
-				addExpression(parser, "setImmediate", "timers", setImmediateType, ".setImmediate");
-				addExpression(parser, "clearImmediate", "timers", setImmediateType, ".clearImmediate");
-			}
+				let localOptions = options;
+				if(parserOptions.node)
+					localOptions = Object.assign({}, localOptions, parserOptions.node);
+
+				if(localOptions.global) {
+					parser.plugin("expression global", function() {
+						const retrieveGlobalModule = ParserHelpers.requireFileAsExpression(this.state.module.context, require.resolve("../../buildin/global.js"));
+						return ParserHelpers.addParsedVariableToModule(this, "global", retrieveGlobalModule);
+					});
+				}
+				if(localOptions.process) {
+					const processType = localOptions.process;
+					addExpression(parser, "process", "process", processType);
+				}
+				if(localOptions.console) {
+					const consoleType = localOptions.console;
+					addExpression(parser, "console", "console", consoleType);
+				}
+				const bufferType = localOptions.Buffer;
+				if(bufferType) {
+					addExpression(parser, "Buffer", "buffer", bufferType, ".Buffer");
+				}
+				if(localOptions.setImmediate) {
+					const setImmediateType = localOptions.setImmediate;
+					addExpression(parser, "setImmediate", "timers", setImmediateType, ".setImmediate");
+					addExpression(parser, "clearImmediate", "timers", setImmediateType, ".clearImmediate");
+				}
+			});
 		});
-	});
-	compiler.plugin("after-resolvers", function(compiler) {
-		Object.keys(nodeLibsBrowser).forEach(function(lib) {
-			if(options[lib] !== false) {
-				compiler.resolvers.normal.apply(
-					new AliasPlugin("described-resolve", {
-						name: lib,
-						onlyModule: true,
-						alias: getPathToModule(lib, options[lib])
-					}, "resolve")
-				);
-			}
+		compiler.plugin("after-resolvers", (compiler) => {
+			Object.keys(nodeLibsBrowser).forEach((lib) => {
+				if(options[lib] !== false) {
+					compiler.resolvers.normal.apply(
+						new AliasPlugin("described-resolve", {
+							name: lib,
+							onlyModule: true,
+							alias: getPathToModule(lib, options[lib])
+						}, "resolve")
+					);
+				}
+			});
 		});
-	});
+	}
 };

package/lib/webworker/WebWorkerMainTemplatePlugin.js

@@ -21,7 +21,9 @@ class WebWorkerMainTemplatePlugin {
 							return id + ": 1";
 						}).join(",\n")
 					),
-					"};"
+					"};",
+					"",
+					"var resolvedPromise = new Promise(function(resolve) { resolve(); });"
 				]);
 			}
 			return source;
@@ -44,7 +46,7 @@ class WebWorkerMainTemplatePlugin {
 					}) + ");"
 				]),
 				"}",
-				"return Promise.resolve();"
+				"return resolvedPromise;"
 			]);
 		});
 		mainTemplate.plugin("bootstrap", function(source, chunk, hash) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "webpack",
-  "version": "2.5.1",
+  "version": "2.6.0",
   "author": "Tobias Koppers @sokra",
   "description": "Packs CommonJs/AMD modules for the browser. Allows to split your codebase into multiple bundles, which can be loaded on demand. Support loaders to preprocess files, i.e. json, jsx, es7, css, less, ... and your custom stuff.",
   "dependencies": {
@@ -21,7 +21,7 @@
     "source-map": "^0.5.3",
     "supports-color": "^3.1.0",
     "tapable": "~0.2.5",
-    "uglify-js": "^2.8.5",
+    "uglify-js": "^2.8.27",
     "watchpack": "^1.3.1",
     "webpack-sources": "^0.2.3",
     "yargs": "^6.0.0"

package/schemas/webpackOptionsSchema.json

@@ -270,6 +270,10 @@
             "use-credentials"
           ]
         },
+        "chunkLoadTimeout": {
+          "description": "Number of milliseconds before chunk request expires",
+          "type": "number"
+        },
         "devtoolFallbackModuleFilenameTemplate": {
           "description": "Similar to `output.devtoolModuleFilenameTemplate`, but used in the case of duplicate module identifiers.",
           "anyOf": [