| /* |
| MIT License http://www.opensource.org/licenses/mit-license.php |
| Author Tobias Koppers @sokra |
| */ |
| "use strict"; |
| |
| const DependenciesBlockVariable = require("./DependenciesBlockVariable"); |
| |
| /** @typedef {import("./ChunkGroup")} ChunkGroup */ |
| /** @typedef {import("./Dependency")} Dependency */ |
| /** @typedef {import("./AsyncDependenciesBlock")} AsyncDependenciesBlock */ |
| /** @typedef {import("./DependenciesBlockVariable")} DependenciesBlockVariable */ |
| /** @typedef {(d: Dependency) => boolean} DependencyFilterFunction */ |
| /** @typedef {import("./util/createHash").Hash} Hash */ |
| |
| class DependenciesBlock { |
| constructor() { |
| /** @type {Dependency[]} */ |
| this.dependencies = []; |
| /** @type {AsyncDependenciesBlock[]} */ |
| this.blocks = []; |
| /** @type {DependenciesBlockVariable[]} */ |
| this.variables = []; |
| } |
| |
| /** |
| * Adds a DependencyBlock to DependencyBlock relationship. |
| * This is used for when a Module has a AsyncDependencyBlock tie (for code-splitting) |
| * |
| * @param {AsyncDependenciesBlock} block block being added |
| * @returns {void} |
| */ |
| addBlock(block) { |
| this.blocks.push(block); |
| block.parent = this; |
| } |
| |
| /** |
| * @param {string} name name of dependency |
| * @param {string} expression expression string for variable |
| * @param {Dependency[]} dependencies dependency instances tied to variable |
| * @returns {void} |
| */ |
| addVariable(name, expression, dependencies) { |
| for (let v of this.variables) { |
| if (v.name === name && v.expression === expression) { |
| return; |
| } |
| } |
| this.variables.push( |
| new DependenciesBlockVariable(name, expression, dependencies) |
| ); |
| } |
| |
| /** |
| * @param {Dependency} dependency dependency being tied to block. |
| * This is an "edge" pointing to another "node" on module graph. |
| * @returns {void} |
| */ |
| addDependency(dependency) { |
| this.dependencies.push(dependency); |
| } |
| |
| /** |
| * @param {Dependency} dependency dependency being removed |
| * @returns {void} |
| */ |
| removeDependency(dependency) { |
| const idx = this.dependencies.indexOf(dependency); |
| if (idx >= 0) { |
| this.dependencies.splice(idx, 1); |
| } |
| } |
| |
| /** |
| * @param {Hash} hash the hash used to track dependencies |
| * @returns {void} |
| */ |
| updateHash(hash) { |
| for (const dep of this.dependencies) dep.updateHash(hash); |
| for (const block of this.blocks) block.updateHash(hash); |
| for (const variable of this.variables) variable.updateHash(hash); |
| } |
| |
| disconnect() { |
| for (const dep of this.dependencies) dep.disconnect(); |
| for (const block of this.blocks) block.disconnect(); |
| for (const variable of this.variables) variable.disconnect(); |
| } |
| |
| unseal() { |
| for (const block of this.blocks) block.unseal(); |
| } |
| |
| /** |
| * @param {DependencyFilterFunction} filter filter function for dependencies, gets passed all dependency ties from current instance |
| * @returns {boolean} returns boolean for filter |
| */ |
| hasDependencies(filter) { |
| if (filter) { |
| for (const dep of this.dependencies) { |
| if (filter(dep)) return true; |
| } |
| } else { |
| if (this.dependencies.length > 0) { |
| return true; |
| } |
| } |
| |
| for (const block of this.blocks) { |
| if (block.hasDependencies(filter)) return true; |
| } |
| for (const variable of this.variables) { |
| if (variable.hasDependencies(filter)) return true; |
| } |
| return false; |
| } |
| |
| sortItems() { |
| for (const block of this.blocks) block.sortItems(); |
| } |
| } |
| |
| module.exports = DependenciesBlock; |