webpack 检出图 第 十一 节 lib/ChunkGraph.js

ChunkGraphChunk 类

• 用于表示 ChunkGraph 中与某个 chunk 相关的模块信息和运行时依赖。

• 包含以下重要属性：

  • modules：当前 chunk 中的模块集合（SortableSet<Module>）。
  • sourceTypesByModule：每个模块对应的 sourceType 集合。
  • entryModules：当前 chunk 中的入口模块及其对应的 entrypoint。
  • runtimeModules：该 chunk 所需的运行时代码模块集合。
  • fullHashModules：影响 chunk 的整体 hash 的 RuntimeModules。
  • dependentHashModules：仅影响 dependent hash 的 RuntimeModules。
  • runtimeRequirements：当前 chunk 的运行时依赖标识（如 __webpack_require__）。
  • runtimeRequirementsInTree：当前 chunk 所属 chunk tree 的运行时依赖。
  • _modulesBySourceType：缓存的模块按 sourceType 分类的默认映射。

---

ChunkGraph 类（静态方法部分）

主要用于在 Webpack 5 中提供对模块和 chunk 关联 ChunkGraph 的临时访问方式（兼容旧 API），将在 Webpack 6 中移除。

• getChunkGraphForModule(module, msg, code)：

  • 获取模块对应的 ChunkGraph（含弃用提示）。

• setChunkGraphForModule(module, chunkGraph)：

  • 设置某模块对应的 ChunkGraph（旧 API）。

• clearChunkGraphForModule(module)：

  • 清除某模块与 ChunkGraph 的绑定。

• getChunkGraphForChunk(chunk, msg, code)：

  • 获取 chunk 对应的 ChunkGraph（含弃用提示）。

• setChunkGraphForChunk(chunk, chunkGraph)：

  • 设置某 chunk 对应的 ChunkGraph（旧 API）。

• clearChunkGraphForChunk(chunk)：

  • 清除 chunk 对 ChunkGraph 的绑定。

---

兼容用到的数据结构（将被移除）

• chunkGraphForModuleMap (WeakMap)：

  • 存储 Module → ChunkGraph 的映射。

• chunkGraphForChunkMap (WeakMap)：

  • 存储 Chunk → ChunkGraph 的映射。

• deprecateGetChunkGraphForModuleMap (Map)：

  • 缓存每条弃用信息对应的 module 获取函数。

• deprecateGetChunkGraphForChunkMap (Map)：

  • 缓存每条弃用信息对应的 chunk 获取函数。

---

模块导出

• module.exports = ChunkGraph：导出 ChunkGraph 类，供其他模块使用。

class ChunkGraphChunk {
	constructor() {
		/** @type {SortableSet<Module>} */
		this.modules = new SortableSet(); // 当前 chunk 中包含的模块集合（可排序、去重）

		/** @type {WeakMap<Module, Set<string>> | undefined} */
		this.sourceTypesByModule = undefined; // 每个模块对应的 sourceType 集合，例如 "javascript", "css"

		/** @type {Map<Module, Entrypoint>} */
		this.entryModules = new Map(); // 标记 chunk 中哪些模块是入口模块及其对应的入口信息

		/** @type {SortableSet<RuntimeModule>} */
		this.runtimeModules = new SortableSet(); // 当前 chunk 中包含的 RuntimeModules（用于运行时逻辑）

		/** @type {Set<RuntimeModule> | undefined} */
		this.fullHashModules = undefined; // 会影响 chunk 的 fullHash 的 RuntimeModules 集合

		/** @type {Set<RuntimeModule> | undefined} */
		this.dependentHashModules = undefined; // 只影响 dependentHash 的 RuntimeModules 集合

		/** @type {Set<string> | undefined} */
		this.runtimeRequirements = undefined; // 当前 chunk 所需的运行时依赖（如 __webpack_require__, chunk 加载逻辑等）

		/** @type {Set<string>} */
		this.runtimeRequirementsInTree = new Set(); // 当前 chunk 所属的 chunk tree 中所有 chunk 的运行时依赖集合

		this._modulesBySourceType = defaultModulesBySourceType; // 每种 sourceType 映射到的模块集合
	}
}

class ChunkGraph {
	// TODO remove in webpack 6
	/**
	 * 获取某个模块对应的 ChunkGraph（用于兼容旧版本）
	 */
	static getChunkGraphForModule(module, deprecateMessage, deprecationCode) {
		const fn = deprecateGetChunkGraphForModuleMap.get(deprecateMessage); // 从缓存中获取对应的弃用函数
		if (fn) return fn(module); // 如果存在已缓存函数则直接调用

		const newFn = util.deprecate(
			module => {
				const chunkGraph = chunkGraphForModuleMap.get(module); // 获取模块对应的 ChunkGraph
				if (!chunkGraph)
					throw new Error(
						`${deprecateMessage}: There was no ChunkGraph assigned to the Module for backward-compat (Use the new API)`
					); // 未找到 ChunkGraph 时抛出错误
				return chunkGraph;
			},
			`${deprecateMessage}: Use new ChunkGraph API`, // 弃用警告信息
			deprecationCode // 弃用代码（供工具识别）
		);
		deprecateGetChunkGraphForModuleMap.set(deprecateMessage, newFn); // 缓存新的弃用函数
		return newFn(module); // 调用函数并返回 ChunkGraph
	}

	// TODO remove in webpack 6
	/**
	 * 将 ChunkGraph 与模块绑定（用于旧 API）
	 */
	static setChunkGraphForModule(module, chunkGraph) {
		chunkGraphForModuleMap.set(module, chunkGraph); // 将模块与 ChunkGraph 绑定在 WeakMap 中
	}

	// TODO remove in webpack 6
	/**
	 * 清除某模块的 ChunkGraph 映射
	 */
	static clearChunkGraphForModule(module) {
		chunkGraphForModuleMap.delete(module); // 删除绑定关系
	}

	// TODO remove in webpack 6
	/**
	 * 获取某个 chunk 对应的 ChunkGraph（旧版本兼容）
	 */
	static getChunkGraphForChunk(chunk, deprecateMessage, deprecationCode) {
		const fn = deprecateGetChunkGraphForChunkMap.get(deprecateMessage); // 获取缓存的弃用函数
		if (fn) return fn(chunk); // 已存在则直接返回

		const newFn = util.deprecate(
			chunk => {
				const chunkGraph = chunkGraphForChunkMap.get(chunk); // 获取 chunk 对应的 ChunkGraph
				if (!chunkGraph)
					throw new Error(
						`${deprecateMessage}There was no ChunkGraph assigned to the Chunk for backward-compat (Use the new API)`
					); // 如果未绑定 ChunkGraph，则抛出错误
				return chunkGraph;
			},
			`${deprecateMessage}: Use new ChunkGraph API`, // 弃用提示信息
			deprecationCode // 弃用代码
		);
		deprecateGetChunkGraphForChunkMap.set(deprecateMessage, newFn); // 缓存函数
		return newFn(chunk); // 返回 chunk 对应的 ChunkGraph
	}

	// TODO remove in webpack 6
	/**
	 * 将 ChunkGraph 与 chunk 绑定（旧 API 用法）
	 */
	static setChunkGraphForChunk(chunk, chunkGraph) {
		chunkGraphForChunkMap.set(chunk, chunkGraph); // 设置 chunk -> ChunkGraph 的映射
	}

	// TODO remove in webpack 6
	/**
	 * 清除某 chunk 的 ChunkGraph 映射
	 */
	static clearChunkGraphForChunk(chunk) {
		chunkGraphForChunkMap.delete(chunk); // 删除映射
	}
}

// TODO remove in webpack 6
/** @type {WeakMap<Module, ChunkGraph>} */
const chunkGraphForModuleMap = new WeakMap(); // 存储 Module -> ChunkGraph 的映射关系（旧 API）

// TODO remove in webpack 6
/** @type {WeakMap<Chunk, ChunkGraph>} */
const chunkGraphForChunkMap = new WeakMap(); // 存储 Chunk -> ChunkGraph 的映射关系（旧 API）

// TODO remove in webpack 6
/** @type {Map<string, (module: Module) => ChunkGraph>} */
const deprecateGetChunkGraphForModuleMap = new Map(); // 缓存每个弃用信息对应的函数（Module）

// TODO remove in webpack 6
/** @type {Map<string, (chunk: Chunk) => ChunkGraph>} */
const deprecateGetChunkGraphForChunkMap = new Map(); // 缓存每个弃用信息对应的函数（Chunk）

module.exports = ChunkGraph; // 导出 ChunkGraph 模块