fix build issues and add typedoc

1 files changed, 133 insertions, 33 deletions

diff --git a/node_modules/webpack/lib/ContextModule.js b/node_modules/webpack/lib/ContextModule.js
index ee7228bac..9771fcd80 100644
--- a/node_modules/webpack/lib/ContextModule.js
+++ b/node_modules/webpack/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)

@@ -99,46 +101,71 @@ class ContextModule extends Module {
 

 	build(options, compilation, resolver, fs, callback) {

 		this.built = true;

-		this.builtTime = new Date().getTime();

+		this.builtTime = Date.now();

 		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)

 		);

 	}