From 7a3df06eb573d36142bd1a8e03c5ce8752d300b3 Mon Sep 17 00:00:00 2001 From: Florian Dold Date: Wed, 24 May 2017 15:10:37 +0200 Subject: fix build issues and add typedoc --- node_modules/webpack/lib/ContextModule.js | 166 ++++++++++++++++++++++++------ 1 file changed, 133 insertions(+), 33 deletions(-) (limited to 'node_modules/webpack/lib/ContextModule.js') 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) ); } -- cgit v1.2.3