From bbff7403fbf46f9ad92240ac213df8d30ef31b64 Mon Sep 17 00:00:00 2001 From: Florian Dold Date: Thu, 20 Sep 2018 02:56:13 +0200 Subject: update packages --- node_modules/webpack/lib/Chunk.js | 1312 +++++++++++++++++++++++-------------- 1 file changed, 833 insertions(+), 479 deletions(-) (limited to 'node_modules/webpack/lib/Chunk.js') diff --git a/node_modules/webpack/lib/Chunk.js b/node_modules/webpack/lib/Chunk.js index 48ca2d1a3..f0bb2ea72 100644 --- a/node_modules/webpack/lib/Chunk.js +++ b/node_modules/webpack/lib/Chunk.js @@ -1,479 +1,833 @@ -/* - MIT License http://www.opensource.org/licenses/mit-license.php - Author Tobias Koppers @sokra -*/ -"use strict"; - -const util = require("util"); -const compareLocations = require("./compareLocations"); -const SortableSet = require("./util/SortableSet"); -let debugId = 1000; - -const sortById = (a, b) => { - if(a.id < b.id) return -1; - if(b.id < a.id) return 1; - return 0; -}; - -const sortByIdentifier = (a, b) => { - if(a.identifier() > b.identifier()) return 1; - if(a.identifier() < b.identifier()) return -1; - return 0; -}; - -class Chunk { - - constructor(name, module, loc) { - this.id = null; - this.ids = null; - this.debugId = debugId++; - this.name = name; - this._modules = new SortableSet(undefined, sortByIdentifier); - this.entrypoints = []; - this.chunks = []; - this.parents = []; - this.blocks = []; - this.origins = []; - this.files = []; - this.rendered = false; - if(module) { - this.origins.push({ - module, - loc, - name - }); - } - } - - get entry() { - throw new Error("Chunk.entry was removed. Use hasRuntime()"); - } - - set entry(data) { - throw new Error("Chunk.entry was removed. Use hasRuntime()"); - } - - get initial() { - throw new Error("Chunk.initial was removed. Use isInitial()"); - } - - set initial(data) { - throw new Error("Chunk.initial was removed. Use isInitial()"); - } - - hasRuntime() { - if(this.entrypoints.length === 0) return false; - return this.entrypoints[0].chunks[0] === this; - } - - isInitial() { - return this.entrypoints.length > 0; - } - - hasEntryModule() { - return !!this.entryModule; - } - - addToCollection(collection, item) { - if(item === this) { - return false; - } - - if(collection.indexOf(item) > -1) { - return false; - } - - collection.push(item); - return true; - } - - addChunk(chunk) { - return this.addToCollection(this.chunks, chunk); - } - - addParent(parentChunk) { - return this.addToCollection(this.parents, parentChunk); - } - - addModule(module) { - if(!this._modules.has(module)) { - this._modules.add(module); - return true; - } - return false; - } - - addBlock(block) { - return this.addToCollection(this.blocks, block); - } - - removeModule(module) { - if(this._modules.delete(module)) { - module.removeChunk(this); - return true; - } - return false; - } - - removeChunk(chunk) { - const idx = this.chunks.indexOf(chunk); - if(idx >= 0) { - this.chunks.splice(idx, 1); - chunk.removeParent(this); - return true; - } - return false; - } - - removeParent(chunk) { - const idx = this.parents.indexOf(chunk); - if(idx >= 0) { - this.parents.splice(idx, 1); - chunk.removeChunk(this); - return true; - } - return false; - } - - addOrigin(module, loc) { - this.origins.push({ - module, - loc, - name: this.name - }); - } - - setModules(modules) { - this._modules = new SortableSet(modules, sortByIdentifier); - } - - getNumberOfModules() { - return this._modules.size; - } - - get modulesIterable() { - return this._modules; - } - - forEachModule(fn) { - this._modules.forEach(fn); - } - - mapModules(fn) { - return Array.from(this._modules, fn); - } - - compareTo(otherChunk) { - this._modules.sort(); - otherChunk._modules.sort(); - if(this._modules.size > otherChunk._modules.size) return -1; - if(this._modules.size < otherChunk._modules.size) return 1; - const a = this._modules[Symbol.iterator](); - const b = otherChunk._modules[Symbol.iterator](); - while(true) { // eslint-disable-line - const aItem = a.next(); - const bItem = b.next(); - if(aItem.done) return 0; - const aModuleIdentifier = aItem.value.identifier(); - const bModuleIdentifier = bItem.value.identifier(); - if(aModuleIdentifier > bModuleIdentifier) return -1; - if(aModuleIdentifier < bModuleIdentifier) return 1; - } - } - - containsModule(module) { - return this._modules.has(module); - } - - getModules() { - return Array.from(this._modules); - } - - getModulesIdent() { - this._modules.sort(); - let str = ""; - this._modules.forEach(m => { - str += m.identifier() + "#"; - }); - return str; - } - - remove(reason) { - // cleanup modules - // Array.from is used here to create a clone, because removeChunk modifies this._modules - Array.from(this._modules).forEach(module => { - module.removeChunk(this); - }); - - // cleanup parents - this.parents.forEach(parentChunk => { - // remove this chunk from its parents - const idx = parentChunk.chunks.indexOf(this); - if(idx >= 0) { - parentChunk.chunks.splice(idx, 1); - } - - // cleanup "sub chunks" - this.chunks.forEach(chunk => { - /** - * remove this chunk as "intermediary" and connect - * it "sub chunks" and parents directly - */ - // add parent to each "sub chunk" - chunk.addParent(parentChunk); - // add "sub chunk" to parent - parentChunk.addChunk(chunk); - }); - }); - - /** - * we need to iterate again over the chunks - * to remove this from the chunks parents. - * This can not be done in the above loop - * as it is not garuanteed that `this.parents` contains anything. - */ - this.chunks.forEach(chunk => { - // remove this as parent of every "sub chunk" - const idx = chunk.parents.indexOf(this); - if(idx >= 0) { - chunk.parents.splice(idx, 1); - } - }); - - // cleanup blocks - this.blocks.forEach(block => { - const idx = block.chunks.indexOf(this); - if(idx >= 0) { - block.chunks.splice(idx, 1); - if(block.chunks.length === 0) { - block.chunks = null; - block.chunkReason = reason; - } - } - }); - } - - moveModule(module, otherChunk) { - module.removeChunk(this); - module.addChunk(otherChunk); - otherChunk.addModule(module); - module.rewriteChunkInReasons(this, [otherChunk]); - } - - replaceChunk(oldChunk, newChunk) { - const idx = this.chunks.indexOf(oldChunk); - if(idx >= 0) { - this.chunks.splice(idx, 1); - } - if(this !== newChunk && newChunk.addParent(this)) { - this.addChunk(newChunk); - } - } - - replaceParentChunk(oldParentChunk, newParentChunk) { - const idx = this.parents.indexOf(oldParentChunk); - if(idx >= 0) { - this.parents.splice(idx, 1); - } - if(this !== newParentChunk && newParentChunk.addChunk(this)) { - this.addParent(newParentChunk); - } - } - - integrate(otherChunk, reason) { - if(!this.canBeIntegrated(otherChunk)) { - return false; - } - - // Array.from is used here to create a clone, because moveModule modifies otherChunk._modules - const otherChunkModules = Array.from(otherChunk._modules); - otherChunkModules.forEach(module => otherChunk.moveModule(module, this)); - otherChunk._modules.clear(); - - otherChunk.parents.forEach(parentChunk => parentChunk.replaceChunk(otherChunk, this)); - otherChunk.parents.length = 0; - - otherChunk.chunks.forEach(chunk => chunk.replaceParentChunk(otherChunk, this)); - otherChunk.chunks.length = 0; - - otherChunk.blocks.forEach(b => { - b.chunks = b.chunks ? b.chunks.map(c => { - return c === otherChunk ? this : c; - }) : [this]; - b.chunkReason = reason; - this.addBlock(b); - }); - otherChunk.blocks.length = 0; - - otherChunk.origins.forEach(origin => { - this.origins.push(origin); - }); - this.blocks.forEach(b => { - b.chunkReason = reason; - }); - this.origins.forEach(origin => { - if(!origin.reasons) { - origin.reasons = [reason]; - } else if(origin.reasons[0] !== reason) { - origin.reasons.unshift(reason); - } - }); - this.chunks = this.chunks.filter(chunk => { - return chunk !== otherChunk && chunk !== this; - }); - this.parents = this.parents.filter(parentChunk => { - return parentChunk !== otherChunk && parentChunk !== this; - }); - return true; - } - - split(newChunk) { - this.blocks.forEach(block => { - newChunk.blocks.push(block); - block.chunks.push(newChunk); - }); - this.chunks.forEach(chunk => { - newChunk.chunks.push(chunk); - chunk.parents.push(newChunk); - }); - this.parents.forEach(parentChunk => { - parentChunk.chunks.push(newChunk); - newChunk.parents.push(parentChunk); - }); - this.entrypoints.forEach(entrypoint => { - entrypoint.insertChunk(newChunk, this); - }); - } - - isEmpty() { - return this._modules.size === 0; - } - - updateHash(hash) { - hash.update(`${this.id} `); - hash.update(this.ids ? this.ids.join(",") : ""); - hash.update(`${this.name || ""} `); - this._modules.forEach(m => m.updateHash(hash)); - } - - canBeIntegrated(otherChunk) { - if(otherChunk.isInitial()) { - return false; - } - if(this.isInitial()) { - if(otherChunk.parents.length !== 1 || otherChunk.parents[0] !== this) { - return false; - } - } - return true; - } - - addMultiplierAndOverhead(size, options) { - const overhead = typeof options.chunkOverhead === "number" ? options.chunkOverhead : 10000; - const multiplicator = this.isInitial() ? (options.entryChunkMultiplicator || 10) : 1; - - return size * multiplicator + overhead; - } - - modulesSize() { - let count = 0; - for(const module of this._modules) { - count += module.size(); - } - return count; - } - - size(options) { - return this.addMultiplierAndOverhead(this.modulesSize(), options); - } - - integratedSize(otherChunk, options) { - // Chunk if it's possible to integrate this chunk - if(!this.canBeIntegrated(otherChunk)) { - return false; - } - - let integratedModulesSize = this.modulesSize(); - // only count modules that do not exist in this chunk! - for(const otherModule of otherChunk._modules) { - if(!this._modules.has(otherModule)) { - integratedModulesSize += otherModule.size(); - } - } - - return this.addMultiplierAndOverhead(integratedModulesSize, options); - } - - getChunkMaps(includeEntries, realHash) { - const chunksProcessed = []; - const chunkHashMap = {}; - const chunkNameMap = {}; - (function addChunk(chunk) { - if(chunksProcessed.indexOf(chunk) >= 0) return; - chunksProcessed.push(chunk); - if(!chunk.hasRuntime() || includeEntries) { - chunkHashMap[chunk.id] = realHash ? chunk.hash : chunk.renderedHash; - if(chunk.name) - chunkNameMap[chunk.id] = chunk.name; - } - chunk.chunks.forEach(addChunk); - }(this)); - return { - hash: chunkHashMap, - name: chunkNameMap - }; - } - - sortModules(sortByFn) { - this._modules.sortWith(sortByFn || sortById); - } - - sortItems() { - this.sortModules(); - this.origins.sort((a, b) => { - const aIdent = a.module.identifier(); - const bIdent = b.module.identifier(); - if(aIdent < bIdent) return -1; - if(aIdent > bIdent) return 1; - return compareLocations(a.loc, b.loc); - }); - this.origins.forEach(origin => { - if(origin.reasons) - origin.reasons.sort(); - }); - this.parents.sort(sortById); - this.chunks.sort(sortById); - } - - toString() { - return `Chunk[${Array.from(this._modules).join()}]`; - } - - checkConstraints() { - const chunk = this; - chunk.chunks.forEach((child, idx) => { - if(chunk.chunks.indexOf(child) !== idx) - throw new Error(`checkConstraints: duplicate child in chunk ${chunk.debugId} ${child.debugId}`); - if(child.parents.indexOf(chunk) < 0) - throw new Error(`checkConstraints: child missing parent ${chunk.debugId} -> ${child.debugId}`); - }); - chunk.parents.forEach((parentChunk, idx) => { - if(chunk.parents.indexOf(parentChunk) !== idx) - throw new Error(`checkConstraints: duplicate parent in chunk ${chunk.debugId} ${parentChunk.debugId}`); - if(parentChunk.chunks.indexOf(chunk) < 0) - throw new Error(`checkConstraints: parent missing child ${parentChunk.debugId} <- ${chunk.debugId}`); - }); - } -} - -Object.defineProperty(Chunk.prototype, "modules", { - configurable: false, - get: util.deprecate(function() { - return Array.from(this._modules); - }, "Chunk.modules is deprecated. Use Chunk.getNumberOfModules/mapModules/forEachModule/containsModule instead."), - set: util.deprecate(function(value) { - this.setModules(value); - }, "Chunk.modules is deprecated. Use Chunk.addModule/removeModule instead.") -}); - -module.exports = Chunk; +/* +MIT License http://www.opensource.org/licenses/mit-license.php +Author Tobias Koppers @sokra +*/ +"use strict"; + +const util = require("util"); +const SortableSet = require("./util/SortableSet"); +const intersect = require("./util/SetHelpers").intersect; +const GraphHelpers = require("./GraphHelpers"); +const Entrypoint = require("./Entrypoint"); +let debugId = 1000; +const ERR_CHUNK_ENTRY = "Chunk.entry was removed. Use hasRuntime()"; +const ERR_CHUNK_INITIAL = + "Chunk.initial was removed. Use canBeInitial/isOnlyInitial()"; + +/** @typedef {import("./Module")} Module */ +/** @typedef {import("./ChunkGroup")} ChunkGroup */ +/** @typedef {import("./ModuleReason")} ModuleReason */ +/** @typedef {import("webpack-sources").Source} Source */ +/** @typedef {import("./util/createHash").Hash} Hash */ + +/** + * @typedef {Object} WithId an object who has an id property * + * @property {string | number} id the id of the object + */ + +/** + * Compare two Modules based on their ids for sorting + * @param {Module} a module + * @param {Module} b module + * @returns {-1|0|1} sort value + */ + +// TODO use @callback +/** @typedef {(a: Module, b: Module) => -1|0|1} ModuleSortPredicate */ +/** @typedef {(m: Module) => boolean} ModuleFilterPredicate */ +/** @typedef {(c: Chunk) => boolean} ChunkFilterPredicate */ + +const sortModuleById = (a, b) => { + if (a.id < b.id) return -1; + if (b.id < a.id) return 1; + return 0; +}; + +/** + * Compare two ChunkGroups based on their ids for sorting + * @param {ChunkGroup} a chunk group + * @param {ChunkGroup} b chunk group + * @returns {-1|0|1} sort value + */ +const sortChunkGroupById = (a, b) => { + if (a.id < b.id) return -1; + if (b.id < a.id) return 1; + return 0; +}; + +/** + * Compare two Identifiables , based on their ids for sorting + * @param {Module} a first object with ident fn + * @param {Module} b second object with ident fn + * @returns {-1|0|1} The order number of the sort + */ +const sortByIdentifier = (a, b) => { + if (a.identifier() > b.identifier()) return 1; + if (a.identifier() < b.identifier()) return -1; + return 0; +}; + +/** + * @returns {string} a concatenation of module identifiers sorted + * @param {SortableSet} set to pull module identifiers from + */ +const getModulesIdent = set => { + set.sort(); + let str = ""; + for (const m of set) { + str += m.identifier() + "#"; + } + return str; +}; + +/** + * @template T + * @param {SortableSet} set the sortable set to convert to array + * @returns {Array} the array returned from Array.from(set) + */ +const getArray = set => Array.from(set); + +/** + * @param {SortableSet} set the sortable Set to get the count/size of + * @returns {number} the size of the modules + */ +const getModulesSize = set => { + let size = 0; + for (const module of set) { + size += module.size(); + } + return size; +}; + +/** + * A Chunk is a unit of encapsulation for Modules. + * Chunks are "rendered" into bundles that get emitted when the build completes. + */ +class Chunk { + /** + * @param {string=} name of chunk being created, is optional (for subclasses) + */ + constructor(name) { + /** @type {number | null} */ + this.id = null; + /** @type {number[] | null} */ + this.ids = null; + /** @type {number} */ + this.debugId = debugId++; + /** @type {string} */ + this.name = name; + /** @type {boolean} */ + this.preventIntegration = false; + /** @type {Module=} */ + this.entryModule = undefined; + /** @private @type {SortableSet} */ + this._modules = new SortableSet(undefined, sortByIdentifier); + /** @type {string?} */ + this.filenameTemplate = undefined; + /** @private @type {SortableSet} */ + this._groups = new SortableSet(undefined, sortChunkGroupById); + /** @type {string[]} */ + this.files = []; + /** @type {boolean} */ + this.rendered = false; + /** @type {string=} */ + this.hash = undefined; + /** @type {Object} */ + this.contentHash = Object.create(null); + /** @type {string=} */ + this.renderedHash = undefined; + /** @type {string=} */ + this.chunkReason = undefined; + /** @type {boolean} */ + this.extraAsync = false; + this.removedModules = undefined; + } + + /** + * @deprecated Chunk.entry has been deprecated. Please use .hasRuntime() instead + * @returns {never} Throws an error trying to access this property + */ + get entry() { + throw new Error(ERR_CHUNK_ENTRY); + } + + /** + * @deprecated .entry has been deprecated. Please use .hasRuntime() instead + * @param {never} data The data that was attempting to be set + * @returns {never} Throws an error trying to access this property + */ + set entry(data) { + throw new Error(ERR_CHUNK_ENTRY); + } + + /** + * @deprecated Chunk.initial was removed. Use canBeInitial/isOnlyInitial() + * @returns {never} Throws an error trying to access this property + */ + get initial() { + throw new Error(ERR_CHUNK_INITIAL); + } + + /** + * @deprecated Chunk.initial was removed. Use canBeInitial/isOnlyInitial() + * @param {never} data The data attempting to be set + * @returns {never} Throws an error trying to access this property + */ + set initial(data) { + throw new Error(ERR_CHUNK_INITIAL); + } + + /** + * @returns {boolean} whether or not the Chunk will have a runtime + */ + hasRuntime() { + for (const chunkGroup of this._groups) { + // We only need to check the first one + return ( + chunkGroup.isInitial() && + chunkGroup instanceof Entrypoint && + chunkGroup.getRuntimeChunk() === this + ); + } + return false; + } + + /** + * @returns {boolean} whether or not this chunk can be an initial chunk + */ + canBeInitial() { + for (const chunkGroup of this._groups) { + if (chunkGroup.isInitial()) return true; + } + return false; + } + + /** + * @returns {boolean} whether this chunk can only be an initial chunk + */ + isOnlyInitial() { + if (this._groups.size <= 0) return false; + for (const chunkGroup of this._groups) { + if (!chunkGroup.isInitial()) return false; + } + return true; + } + + /** + * @returns {boolean} if this chunk contains the entry module + */ + hasEntryModule() { + return !!this.entryModule; + } + + /** + * @param {Module} module the module that will be added to this chunk. + * @returns {boolean} returns true if the chunk doesn't have the module and it was added + */ + addModule(module) { + if (!this._modules.has(module)) { + this._modules.add(module); + return true; + } + return false; + } + + /** + * @param {Module} module the module that will be removed from this chunk + * @returns {boolean} returns true if chunk exists and is successfully deleted + */ + removeModule(module) { + if (this._modules.delete(module)) { + module.removeChunk(this); + return true; + } + return false; + } + + /** + * @param {Module[]} modules the new modules to be set + * @returns {void} set new modules to this chunk and return nothing + */ + setModules(modules) { + this._modules = new SortableSet(modules, sortByIdentifier); + } + + /** + * @returns {number} the amount of modules in chunk + */ + getNumberOfModules() { + return this._modules.size; + } + + /** + * @returns {SortableSet} return the modules SortableSet for this chunk + */ + get modulesIterable() { + return this._modules; + } + + /** + * @param {ChunkGroup} chunkGroup the chunkGroup the chunk is being added + * @returns {boolean} returns true if chunk is not apart of chunkGroup and is added successfully + */ + addGroup(chunkGroup) { + if (this._groups.has(chunkGroup)) return false; + this._groups.add(chunkGroup); + return true; + } + + /** + * @param {ChunkGroup} chunkGroup the chunkGroup the chunk is being removed from + * @returns {boolean} returns true if chunk does exist in chunkGroup and is removed + */ + removeGroup(chunkGroup) { + if (!this._groups.has(chunkGroup)) return false; + this._groups.delete(chunkGroup); + return true; + } + + /** + * @param {ChunkGroup} chunkGroup the chunkGroup to check + * @returns {boolean} returns true if chunk has chunkGroup reference and exists in chunkGroup + */ + isInGroup(chunkGroup) { + return this._groups.has(chunkGroup); + } + + /** + * @returns {number} the amount of groups said chunk is in + */ + getNumberOfGroups() { + return this._groups.size; + } + + /** + * @returns {SortableSet} the chunkGroups that said chunk is referenced in + */ + get groupsIterable() { + return this._groups; + } + + /** + * @param {Chunk} otherChunk the chunk to compare itself with + * @returns {-1|0|1} this is a comparitor function like sort and returns -1, 0, or 1 based on sort order + */ + compareTo(otherChunk) { + if (this._modules.size > otherChunk._modules.size) return -1; + if (this._modules.size < otherChunk._modules.size) return 1; + this._modules.sort(); + otherChunk._modules.sort(); + const a = this._modules[Symbol.iterator](); + const b = otherChunk._modules[Symbol.iterator](); + // eslint-disable-next-line no-constant-condition + while (true) { + const aItem = a.next(); + if (aItem.done) return 0; + const bItem = b.next(); + const aModuleIdentifier = aItem.value.identifier(); + const bModuleIdentifier = bItem.value.identifier(); + if (aModuleIdentifier < bModuleIdentifier) return -1; + if (aModuleIdentifier > bModuleIdentifier) return 1; + } + } + + /** + * @param {Module} module Module to check + * @returns {boolean} returns true if module does exist in this chunk + */ + containsModule(module) { + return this._modules.has(module); + } + + getModules() { + return this._modules.getFromCache(getArray); + } + + getModulesIdent() { + return this._modules.getFromUnorderedCache(getModulesIdent); + } + + remove() { + // cleanup modules + // Array.from is used here to create a clone, because removeChunk modifies this._modules + for (const module of Array.from(this._modules)) { + module.removeChunk(this); + } + for (const chunkGroup of this._groups) { + chunkGroup.removeChunk(this); + } + } + + /** + * + * @param {Module} module module to move + * @param {Chunk} otherChunk other chunk to move it to + * @returns {void} + */ + moveModule(module, otherChunk) { + GraphHelpers.disconnectChunkAndModule(this, module); + GraphHelpers.connectChunkAndModule(otherChunk, module); + module.rewriteChunkInReasons(this, [otherChunk]); + } + + /** + * + * @param {Chunk} otherChunk the chunk to integrate with + * @param {ModuleReason} reason reason why the module is being integrated + * @returns {boolean} returns true or false if integration succeeds or fails + */ + integrate(otherChunk, reason) { + if (!this.canBeIntegrated(otherChunk)) { + return false; + } + + // Array.from is used here to create a clone, because moveModule modifies otherChunk._modules + for (const module of Array.from(otherChunk._modules)) { + otherChunk.moveModule(module, this); + } + otherChunk._modules.clear(); + + for (const chunkGroup of otherChunk._groups) { + chunkGroup.replaceChunk(otherChunk, this); + this.addGroup(chunkGroup); + } + otherChunk._groups.clear(); + + if (this.name && otherChunk.name) { + if (this.name.length !== otherChunk.name.length) { + this.name = + this.name.length < otherChunk.name.length + ? this.name + : otherChunk.name; + } else { + this.name = this.name < otherChunk.name ? this.name : otherChunk.name; + } + } + + return true; + } + + /** + * @param {Chunk} newChunk the new chunk that will be split out of, and then chunk raphi twil= + * @returns {void} + */ + split(newChunk) { + for (const chunkGroup of this._groups) { + chunkGroup.insertChunk(newChunk, this); + newChunk.addGroup(chunkGroup); + } + } + + isEmpty() { + return this._modules.size === 0; + } + + updateHash(hash) { + hash.update(`${this.id} `); + hash.update(this.ids ? this.ids.join(",") : ""); + hash.update(`${this.name || ""} `); + for (const m of this._modules) { + hash.update(m.hash); + } + } + + canBeIntegrated(otherChunk) { + const isAvailable = (a, b) => { + const queue = new Set(b.groupsIterable); + for (const chunkGroup of queue) { + if (a.isInGroup(chunkGroup)) continue; + if (chunkGroup.isInitial()) return false; + for (const parent of chunkGroup.parentsIterable) { + queue.add(parent); + } + } + return true; + }; + + if (this.preventIntegration || otherChunk.preventIntegration) { + return false; + } + + if (this.hasRuntime() !== otherChunk.hasRuntime()) { + if (this.hasRuntime()) { + return isAvailable(this, otherChunk); + } else if (otherChunk.hasRuntime()) { + return isAvailable(otherChunk, this); + } else { + return false; + } + } + + if (this.hasEntryModule() || otherChunk.hasEntryModule()) { + return false; + } + + return true; + } + + /** + * + * @param {number} size the size + * @param {Object} options the options passed in + * @returns {number} the multiplier returned + */ + addMultiplierAndOverhead(size, options) { + const overhead = + typeof options.chunkOverhead === "number" ? options.chunkOverhead : 10000; + const multiplicator = this.canBeInitial() + ? options.entryChunkMultiplicator || 10 + : 1; + + return size * multiplicator + overhead; + } + + /** + * @returns {number} the size of all modules + */ + modulesSize() { + return this._modules.getFromUnorderedCache(getModulesSize); + } + + /** + * @param {Object} options the size display options + * @returns {number} the chunk size + */ + size(options) { + return this.addMultiplierAndOverhead(this.modulesSize(), options); + } + + /** + * @param {Chunk} otherChunk the other chunk + * @param {TODO} options the options for this function + * @returns {number | false} the size, or false if it can't be integrated + */ + integratedSize(otherChunk, options) { + // Chunk if it's possible to integrate this chunk + if (!this.canBeIntegrated(otherChunk)) { + return false; + } + + let integratedModulesSize = this.modulesSize(); + // only count modules that do not exist in this chunk! + for (const otherModule of otherChunk._modules) { + if (!this._modules.has(otherModule)) { + integratedModulesSize += otherModule.size(); + } + } + + return this.addMultiplierAndOverhead(integratedModulesSize, options); + } + + /** + * @param {function(Module, Module): -1|0|1=} sortByFn a predicate function used to sort modules + * @returns {void} + */ + sortModules(sortByFn) { + this._modules.sortWith(sortByFn || sortModuleById); + } + + sortItems() { + this.sortModules(); + } + + /** + * @returns {Set} a set of all the async chunks + */ + getAllAsyncChunks() { + const queue = new Set(); + const chunks = new Set(); + + const initialChunks = intersect( + Array.from(this.groupsIterable, g => new Set(g.chunks)) + ); + + for (const chunkGroup of this.groupsIterable) { + for (const child of chunkGroup.childrenIterable) { + queue.add(child); + } + } + + for (const chunkGroup of queue) { + for (const chunk of chunkGroup.chunks) { + if (!initialChunks.has(chunk)) { + chunks.add(chunk); + } + } + for (const child of chunkGroup.childrenIterable) { + queue.add(child); + } + } + + return chunks; + } + + /** + * @typedef {Object} ChunkMaps + * @property {Record} hash + * @property {Record>} contentHash + * @property {Record} name + */ + + /** + * @param {boolean} realHash should the full hash or the rendered hash be used + * @returns {ChunkMaps} the chunk map information + */ + getChunkMaps(realHash) { + /** @type {Record} */ + const chunkHashMap = Object.create(null); + /** @type {Record>} */ + const chunkContentHashMap = Object.create(null); + /** @type {Record} */ + const chunkNameMap = Object.create(null); + + for (const chunk of this.getAllAsyncChunks()) { + chunkHashMap[chunk.id] = realHash ? chunk.hash : chunk.renderedHash; + for (const key of Object.keys(chunk.contentHash)) { + if (!chunkContentHashMap[key]) { + chunkContentHashMap[key] = Object.create(null); + } + chunkContentHashMap[key][chunk.id] = chunk.contentHash[key]; + } + if (chunk.name) { + chunkNameMap[chunk.id] = chunk.name; + } + } + + return { + hash: chunkHashMap, + contentHash: chunkContentHashMap, + name: chunkNameMap + }; + } + + /** + * @returns {Record[]>} a record object of names to lists of child ids(?) + */ + getChildIdsByOrders() { + const lists = new Map(); + for (const group of this.groupsIterable) { + if (group.chunks[group.chunks.length - 1] === this) { + for (const childGroup of group.childrenIterable) { + // TODO webpack 5 remove this check for options + if (typeof childGroup.options === "object") { + for (const key of Object.keys(childGroup.options)) { + if (key.endsWith("Order")) { + const name = key.substr(0, key.length - "Order".length); + let list = lists.get(name); + if (list === undefined) lists.set(name, (list = [])); + list.push({ + order: childGroup.options[key], + group: childGroup + }); + } + } + } + } + } + } + const result = Object.create(null); + for (const [name, list] of lists) { + list.sort((a, b) => { + const cmp = b.order - a.order; + if (cmp !== 0) return cmp; + // TODO webpack 5 remove this check of compareTo + if (a.group.compareTo) { + return a.group.compareTo(b.group); + } + return 0; + }); + result[name] = Array.from( + list.reduce((set, item) => { + for (const chunk of item.group.chunks) { + set.add(chunk.id); + } + return set; + }, new Set()) + ); + } + return result; + } + + getChildIdsByOrdersMap(includeDirectChildren) { + const chunkMaps = Object.create(null); + + const addChildIdsByOrdersToMap = chunk => { + const data = chunk.getChildIdsByOrders(); + for (const key of Object.keys(data)) { + let chunkMap = chunkMaps[key]; + if (chunkMap === undefined) { + chunkMaps[key] = chunkMap = Object.create(null); + } + chunkMap[chunk.id] = data[key]; + } + }; + + if (includeDirectChildren) { + addChildIdsByOrdersToMap(this); + } + + for (const chunk of this.getAllAsyncChunks()) { + addChildIdsByOrdersToMap(chunk); + } + + return chunkMaps; + } + + /** + * @typedef {Object} ChunkModuleMaps + * @property {Record} id + * @property {Record} hash + */ + + /** + * @param {ModuleFilterPredicate} filterFn function used to filter modules + * @returns {ChunkModuleMaps} module map information + */ + getChunkModuleMaps(filterFn) { + /** @type {Record} */ + const chunkModuleIdMap = Object.create(null); + /** @type {Record} */ + const chunkModuleHashMap = Object.create(null); + + for (const chunk of this.getAllAsyncChunks()) { + /** @type {(string|number)[]} */ + let array; + for (const module of chunk.modulesIterable) { + if (filterFn(module)) { + if (array === undefined) { + array = []; + chunkModuleIdMap[chunk.id] = array; + } + array.push(module.id); + chunkModuleHashMap[module.id] = module.renderedHash; + } + } + if (array !== undefined) { + array.sort(); + } + } + + return { + id: chunkModuleIdMap, + hash: chunkModuleHashMap + }; + } + + /** + * + * @param {function(Module): boolean} filterFn predicate function used to filter modules + * @param {function(Chunk): boolean} filterChunkFn predicate function used to filter chunks + * @returns {boolean} return true if module exists in graph + */ + hasModuleInGraph(filterFn, filterChunkFn) { + const queue = new Set(this.groupsIterable); + const chunksProcessed = new Set(); + + for (const chunkGroup of queue) { + for (const chunk of chunkGroup.chunks) { + if (!chunksProcessed.has(chunk)) { + chunksProcessed.add(chunk); + if (!filterChunkFn || filterChunkFn(chunk)) { + for (const module of chunk.modulesIterable) { + if (filterFn(module)) { + return true; + } + } + } + } + } + for (const child of chunkGroup.childrenIterable) { + queue.add(child); + } + } + return false; + } + + toString() { + return `Chunk[${Array.from(this._modules).join()}]`; + } +} + +// TODO remove in webpack 5 +Object.defineProperty(Chunk.prototype, "forEachModule", { + configurable: false, + value: util.deprecate( + /** + * @deprecated + * @this {Chunk} + * @typedef {function(any, any, Set): void} ForEachModuleCallback + * @param {ForEachModuleCallback} fn Callback function + * @returns {void} + */ + function(fn) { + this._modules.forEach(fn); + }, + "Chunk.forEachModule: Use for(const module of chunk.modulesIterable) instead" + ) +}); + +// TODO remove in webpack 5 +Object.defineProperty(Chunk.prototype, "mapModules", { + configurable: false, + value: util.deprecate( + /** + * @deprecated + * @this {Chunk} + * @typedef {function(any, number): any} MapModulesCallback + * @param {MapModulesCallback} fn Callback function + * @returns {TODO[]} result of mapped modules + */ + function(fn) { + return Array.from(this._modules, fn); + }, + "Chunk.mapModules: Use Array.from(chunk.modulesIterable, fn) instead" + ) +}); + +// TODO remove in webpack 5 +Object.defineProperty(Chunk.prototype, "chunks", { + configurable: false, + get() { + throw new Error("Chunk.chunks: Use ChunkGroup.getChildren() instead"); + }, + set() { + throw new Error("Chunk.chunks: Use ChunkGroup.add/removeChild() instead"); + } +}); + +// TODO remove in webpack 5 +Object.defineProperty(Chunk.prototype, "parents", { + configurable: false, + get() { + throw new Error("Chunk.parents: Use ChunkGroup.getParents() instead"); + }, + set() { + throw new Error("Chunk.parents: Use ChunkGroup.add/removeParent() instead"); + } +}); + +// TODO remove in webpack 5 +Object.defineProperty(Chunk.prototype, "blocks", { + configurable: false, + get() { + throw new Error("Chunk.blocks: Use ChunkGroup.getBlocks() instead"); + }, + set() { + throw new Error("Chunk.blocks: Use ChunkGroup.add/removeBlock() instead"); + } +}); + +// TODO remove in webpack 5 +Object.defineProperty(Chunk.prototype, "entrypoints", { + configurable: false, + get() { + throw new Error( + "Chunk.entrypoints: Use Chunks.groupsIterable and filter by instanceof Entrypoint instead" + ); + }, + set() { + throw new Error("Chunk.entrypoints: Use Chunks.addGroup instead"); + } +}); + +module.exports = Chunk; -- cgit v1.2.3