You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
875 lines
23 KiB
875 lines
23 KiB
/*
|
|
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<T>} set the sortable set to convert to array
|
|
* @returns {Array<T>} the array returned from Array.from(set)
|
|
*/
|
|
const getArray = set => Array.from(set);
|
|
|
|
/**
|
|
* @param {SortableSet<Module>} 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<Module>} */
|
|
this._modules = new SortableSet(undefined, sortByIdentifier);
|
|
/** @type {string?} */
|
|
this.filenameTemplate = undefined;
|
|
/** @private @type {SortableSet<ChunkGroup>} */
|
|
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) {
|
|
if (
|
|
chunkGroup.isInitial() &&
|
|
chunkGroup instanceof Entrypoint &&
|
|
chunkGroup.getRuntimeChunk() === this
|
|
) {
|
|
return true;
|
|
}
|
|
}
|
|
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<ChunkGroup>} 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.name && !otherChunk.name) return -1;
|
|
if (!this.name && otherChunk.name) return 1;
|
|
if (this.name < otherChunk.name) return -1;
|
|
if (this.name > otherChunk.name) return 1;
|
|
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);
|
|
}
|
|
|
|
/**
|
|
* @returns {Module[]} an array of modules (do not modify)
|
|
*/
|
|
getModules() {
|
|
return this._modules.getFromCache(getArray);
|
|
}
|
|
|
|
getModulesIdent() {
|
|
return this._modules.getFromUnorderedCache(getModulesIdent);
|
|
}
|
|
|
|
/**
|
|
* @param {string=} reason reason why chunk is removed
|
|
* @returns {void}
|
|
*/
|
|
remove(reason) {
|
|
// 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 {string} 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;
|
|
}
|
|
|
|
// Pick a new name for the integrated chunk
|
|
if (this.name && otherChunk.name) {
|
|
if (this.hasEntryModule() === otherChunk.hasEntryModule()) {
|
|
// When both chunks have entry modules or none have one, use
|
|
// shortest 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;
|
|
}
|
|
} else if (otherChunk.hasEntryModule()) {
|
|
// Pick the name of the chunk with the entry module
|
|
this.name = otherChunk.name;
|
|
}
|
|
} else if (otherChunk.name) {
|
|
this.name = otherChunk.name;
|
|
}
|
|
|
|
// 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();
|
|
|
|
if (otherChunk.entryModule) {
|
|
this.entryModule = otherChunk.entryModule;
|
|
}
|
|
|
|
for (const chunkGroup of otherChunk._groups) {
|
|
chunkGroup.replaceChunk(otherChunk, this);
|
|
this.addGroup(chunkGroup);
|
|
}
|
|
otherChunk._groups.clear();
|
|
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* @param {Chunk} newChunk the new chunk that will be split out of the current chunk
|
|
* @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) {
|
|
if (this.preventIntegration || otherChunk.preventIntegration) {
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* @param {Chunk} a chunk
|
|
* @param {Chunk} b chunk
|
|
* @returns {boolean} true, if a is always available when b is reached
|
|
*/
|
|
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;
|
|
};
|
|
|
|
const selfHasRuntime = this.hasRuntime();
|
|
const otherChunkHasRuntime = otherChunk.hasRuntime();
|
|
|
|
if (selfHasRuntime !== otherChunkHasRuntime) {
|
|
if (selfHasRuntime) {
|
|
return isAvailable(this, otherChunk);
|
|
} else if (otherChunkHasRuntime) {
|
|
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<Chunk>} 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<string|number, string>} hash
|
|
* @property {Record<string|number, Record<string, string>>} contentHash
|
|
* @property {Record<string|number, string>} name
|
|
*/
|
|
|
|
/**
|
|
* @param {boolean} realHash should the full hash or the rendered hash be used
|
|
* @returns {ChunkMaps} the chunk map information
|
|
*/
|
|
getChunkMaps(realHash) {
|
|
/** @type {Record<string|number, string>} */
|
|
const chunkHashMap = Object.create(null);
|
|
/** @type {Record<string|number, Record<string, string>>} */
|
|
const chunkContentHashMap = Object.create(null);
|
|
/** @type {Record<string|number, string>} */
|
|
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<string, Set<TODO>[]>} 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) {
|
|
const chunks = new Set();
|
|
for (const chunkGroup of this.groupsIterable) {
|
|
for (const chunk of chunkGroup.chunks) {
|
|
chunks.add(chunk);
|
|
}
|
|
}
|
|
for (const chunk of chunks) {
|
|
addChildIdsByOrdersToMap(chunk);
|
|
}
|
|
}
|
|
|
|
for (const chunk of this.getAllAsyncChunks()) {
|
|
addChildIdsByOrdersToMap(chunk);
|
|
}
|
|
|
|
return chunkMaps;
|
|
}
|
|
|
|
/**
|
|
* @typedef {Object} ChunkModuleMaps
|
|
* @property {Record<string|number, (string|number)[]>} id
|
|
* @property {Record<string|number, string>} hash
|
|
*/
|
|
|
|
/**
|
|
* @param {ModuleFilterPredicate} filterFn function used to filter modules
|
|
* @returns {ChunkModuleMaps} module map information
|
|
*/
|
|
getChunkModuleMaps(filterFn) {
|
|
/** @type {Record<string|number, (string|number)[]>} */
|
|
const chunkModuleIdMap = Object.create(null);
|
|
/** @type {Record<string|number, string>} */
|
|
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<any>): 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;
|