simple-squiggle

RecordIdsPlugin.js (6821B)

---

 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
 	Author Tobias Koppers @sokra
 */
 
 "use strict";
 
 const { compareNumbers } = require("./util/comparators");
 const identifierUtils = require("./util/identifier");
 
 /** @typedef {import("./Chunk")} Chunk */
 /** @typedef {import("./Compiler")} Compiler */
 /** @typedef {import("./Module")} Module */
 
 /**
  * @typedef {Object} RecordsChunks
  * @property {Record<string, number>=} byName
  * @property {Record<string, number>=} bySource
  * @property {number[]=} usedIds
  */
 
 /**
  * @typedef {Object} RecordsModules
  * @property {Record<string, number>=} byIdentifier
  * @property {Record<string, number>=} bySource
  * @property {number[]=} usedIds
  */
 
 /**
  * @typedef {Object} Records
  * @property {RecordsChunks=} chunks
  * @property {RecordsModules=} modules
  */
 
 class RecordIdsPlugin {
 	/**
 	 * @param {Object} options Options object
 	 * @param {boolean=} options.portableIds true, when ids need to be portable
 	 */
 	constructor(options) {
 		this.options = options || {};
 	}
 
 	/**
 	 * @param {Compiler} compiler the Compiler
 	 * @returns {void}
 	 */
 	apply(compiler) {
 		const portableIds = this.options.portableIds;
 
 		const makePathsRelative =
 			identifierUtils.makePathsRelative.bindContextCache(
 				compiler.context,
 				compiler.root
 			);
 
 		/**
 		 * @param {Module} module the module
 		 * @returns {string} the (portable) identifier
 		 */
 		const getModuleIdentifier = module => {
 			if (portableIds) {
 				return makePathsRelative(module.identifier());
 			}
 			return module.identifier();
 		};
 
 		compiler.hooks.compilation.tap("RecordIdsPlugin", compilation => {
 			compilation.hooks.recordModules.tap(
 				"RecordIdsPlugin",
 				/**
 				 * @param {Module[]} modules the modules array
 				 * @param {Records} records the records object
 				 * @returns {void}
 				 */
 				(modules, records) => {
 					const chunkGraph = compilation.chunkGraph;
 					if (!records.modules) records.modules = {};
 					if (!records.modules.byIdentifier) records.modules.byIdentifier = {};
 					/** @type {Set<number>} */
 					const usedIds = new Set();
 					for (const module of modules) {
 						const moduleId = chunkGraph.getModuleId(module);
 						if (typeof moduleId !== "number") continue;
 						const identifier = getModuleIdentifier(module);
 						records.modules.byIdentifier[identifier] = moduleId;
 						usedIds.add(moduleId);
 					}
 					records.modules.usedIds = Array.from(usedIds).sort(compareNumbers);
 				}
 			);
 			compilation.hooks.reviveModules.tap(
 				"RecordIdsPlugin",
 				/**
 				 * @param {Module[]} modules the modules array
 				 * @param {Records} records the records object
 				 * @returns {void}
 				 */
 				(modules, records) => {
 					if (!records.modules) return;
 					if (records.modules.byIdentifier) {
 						const chunkGraph = compilation.chunkGraph;
 						/** @type {Set<number>} */
 						const usedIds = new Set();
 						for (const module of modules) {
 							const moduleId = chunkGraph.getModuleId(module);
 							if (moduleId !== null) continue;
 							const identifier = getModuleIdentifier(module);
 							const id = records.modules.byIdentifier[identifier];
 							if (id === undefined) continue;
 							if (usedIds.has(id)) continue;
 							usedIds.add(id);
 							chunkGraph.setModuleId(module, id);
 						}
 					}
 					if (Array.isArray(records.modules.usedIds)) {
 						compilation.usedModuleIds = new Set(records.modules.usedIds);
 					}
 				}
 			);
 
 			/**
 			 * @param {Chunk} chunk the chunk
 			 * @returns {string[]} sources of the chunk
 			 */
 			const getChunkSources = chunk => {
 				/** @type {string[]} */
 				const sources = [];
 				for (const chunkGroup of chunk.groupsIterable) {
 					const index = chunkGroup.chunks.indexOf(chunk);
 					if (chunkGroup.name) {
 						sources.push(`${index} ${chunkGroup.name}`);
 					} else {
 						for (const origin of chunkGroup.origins) {
 							if (origin.module) {
 								if (origin.request) {
 									sources.push(
 										`${index} ${getModuleIdentifier(origin.module)} ${
 											origin.request
 										}`
 									);
 								} else if (typeof origin.loc === "string") {
 									sources.push(
 										`${index} ${getModuleIdentifier(origin.module)} ${
 											origin.loc
 										}`
 									);
 								} else if (
 									origin.loc &&
 									typeof origin.loc === "object" &&
 									"start" in origin.loc
 								) {
 									sources.push(
 										`${index} ${getModuleIdentifier(
 											origin.module
 										)} ${JSON.stringify(origin.loc.start)}`
 									);
 								}
 							}
 						}
 					}
 				}
 				return sources;
 			};
 
 			compilation.hooks.recordChunks.tap(
 				"RecordIdsPlugin",
 				/**
 				 * @param {Chunk[]} chunks the chunks array
 				 * @param {Records} records the records object
 				 * @returns {void}
 				 */
 				(chunks, records) => {
 					if (!records.chunks) records.chunks = {};
 					if (!records.chunks.byName) records.chunks.byName = {};
 					if (!records.chunks.bySource) records.chunks.bySource = {};
 					/** @type {Set<number>} */
 					const usedIds = new Set();
 					for (const chunk of chunks) {
 						if (typeof chunk.id !== "number") continue;
 						const name = chunk.name;
 						if (name) records.chunks.byName[name] = chunk.id;
 						const sources = getChunkSources(chunk);
 						for (const source of sources) {
 							records.chunks.bySource[source] = chunk.id;
 						}
 						usedIds.add(chunk.id);
 					}
 					records.chunks.usedIds = Array.from(usedIds).sort(compareNumbers);
 				}
 			);
 			compilation.hooks.reviveChunks.tap(
 				"RecordIdsPlugin",
 				/**
 				 * @param {Chunk[]} chunks the chunks array
 				 * @param {Records} records the records object
 				 * @returns {void}
 				 */
 				(chunks, records) => {
 					if (!records.chunks) return;
 					/** @type {Set<number>} */
 					const usedIds = new Set();
 					if (records.chunks.byName) {
 						for (const chunk of chunks) {
 							if (chunk.id !== null) continue;
 							if (!chunk.name) continue;
 							const id = records.chunks.byName[chunk.name];
 							if (id === undefined) continue;
 							if (usedIds.has(id)) continue;
 							usedIds.add(id);
 							chunk.id = id;
 							chunk.ids = [id];
 						}
 					}
 					if (records.chunks.bySource) {
 						for (const chunk of chunks) {
 							if (chunk.id !== null) continue;
 							const sources = getChunkSources(chunk);
 							for (const source of sources) {
 								const id = records.chunks.bySource[source];
 								if (id === undefined) continue;
 								if (usedIds.has(id)) continue;
 								usedIds.add(id);
 								chunk.id = id;
 								chunk.ids = [id];
 								break;
 							}
 						}
 					}
 					if (Array.isArray(records.chunks.usedIds)) {
 						compilation.usedChunkIds = new Set(records.chunks.usedIds);
 					}
 				}
 			);
 		});
 	}
 }
 module.exports = RecordIdsPlugin;