Diffusion Open Access Compliance Check Tool (OACCT) (drf-api-tracking) Browse

ModuleConcatenationPlugin.js
9045e4d5dbe1drf-api-tracking

ModuleConcatenationPlugin.js
View Options

			/*
			MIT License http://www.opensource.org/licenses/mit-license.php
			Author Tobias Koppers @sokra
			*/

			"use strict";

			const asyncLib = require("neo-async");
			const ChunkGraph = require("../ChunkGraph");
			const ModuleGraph = require("../ModuleGraph");
			const ModuleRestoreError = require("../ModuleRestoreError");
			const ModuleStoreError = require("../ModuleStoreError");
			const { STAGE_DEFAULT } = require("../OptimizationStages");
			const HarmonyImportDependency = require("../dependencies/HarmonyImportDependency");
			const StackedMap = require("../util/StackedMap");
			const { compareModulesByIdentifier } = require("../util/comparators");
			const {
			intersectRuntime,
			mergeRuntimeOwned,
			filterRuntime,
			runtimeToString,
			mergeRuntime
			} = require("../util/runtime");
			const ConcatenatedModule = require("./ConcatenatedModule");

			/** @typedef {import("../Compilation")} Compilation */
			/** @typedef {import("../Compiler")} Compiler */
			/** @typedef {import("../Module")} Module */
			/** @typedef {import("../RequestShortener")} RequestShortener */
			/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */

			const formatBailoutReason = msg => {
			return "ModuleConcatenation bailout: " + msg;
			};

			class ModuleConcatenationPlugin {
			constructor(options) {
			if (typeof options !== "object") options = {};
			this.options = options;
			}

			/**
			* Apply the plugin
			* @param {Compiler} compiler the compiler instance
			* @returns {void}
			*/
			apply(compiler) {
			compiler.hooks.compilation.tap(
			"ModuleConcatenationPlugin",
			(compilation, { normalModuleFactory }) => {
			const moduleGraph = compilation.moduleGraph;
			const bailoutReasonMap = new Map();
			const cache = compilation.getCache("ModuleConcatenationPlugin");

			const setBailoutReason = (module, reason) => {
			setInnerBailoutReason(module, reason);
			moduleGraph
			.getOptimizationBailout(module)
			.push(
			typeof reason === "function"
			? rs => formatBailoutReason(reason(rs))
			: formatBailoutReason(reason)
			);
			};

			const setInnerBailoutReason = (module, reason) => {
			bailoutReasonMap.set(module, reason);
			};

			const getInnerBailoutReason = (module, requestShortener) => {
			const reason = bailoutReasonMap.get(module);
			if (typeof reason === "function") return reason(requestShortener);
			return reason;
			};

			const formatBailoutWarning = (module, problem) => requestShortener => {
			if (typeof problem === "function") {
			return formatBailoutReason(
			`Cannot concat with ${module.readableIdentifier(
			requestShortener
			)}: ${problem(requestShortener)}`
			);
			}
			const reason = getInnerBailoutReason(module, requestShortener);
			const reasonWithPrefix = reason ? `: ${reason}` : "";
			if (module === problem) {
			return formatBailoutReason(
			`Cannot concat with ${module.readableIdentifier(
			requestShortener
			)}${reasonWithPrefix}`
			);
			} else {
			return formatBailoutReason(
			`Cannot concat with ${module.readableIdentifier(
			requestShortener
			)} because of ${problem.readableIdentifier(
			requestShortener
			)}${reasonWithPrefix}`
			);
			}
			};

			compilation.hooks.optimizeChunkModules.tapAsync(
			{
			name: "ModuleConcatenationPlugin",
			stage: STAGE_DEFAULT
			},
			(allChunks, modules, callback) => {
			const logger = compilation.getLogger("ModuleConcatenationPlugin");
			const { chunkGraph, moduleGraph } = compilation;
			const relevantModules = [];
			const possibleInners = new Set();
			const context = {
			chunkGraph,
			moduleGraph
			};
			logger.time("select relevant modules");
			for (const module of modules) {
			let canBeRoot = true;
			let canBeInner = true;

			const bailoutReason = module.getConcatenationBailoutReason(
			context
			);
			if (bailoutReason) {
			setBailoutReason(module, bailoutReason);
			continue;
			}

			// Must not be an async module
			if (moduleGraph.isAsync(module)) {
			setBailoutReason(module, `Module is async`);
			continue;
			}

			// Must be in strict mode
			if (!module.buildInfo.strict) {
			setBailoutReason(module, `Module is not in strict mode`);
			continue;
			}

			// Module must be in any chunk (we don't want to do useless work)
			if (chunkGraph.getNumberOfModuleChunks(module) === 0) {
			setBailoutReason(module, "Module is not in any chunk");
			continue;
			}

			// Exports must be known (and not dynamic)
			const exportsInfo = moduleGraph.getExportsInfo(module);
			const relevantExports = exportsInfo.getRelevantExports(undefined);
			const unknownReexports = relevantExports.filter(exportInfo => {
			return (
			exportInfo.isReexport() && !exportInfo.getTarget(moduleGraph)
			);
			});
			if (unknownReexports.length > 0) {
			setBailoutReason(
			module,
			`Reexports in this module do not have a static target (${Array.from(
			unknownReexports,
			exportInfo =>
			`${
			exportInfo.name \|\| "other exports"
			}: ${exportInfo.getUsedInfo()}`
			).join(", ")})`
			);
			continue;
			}

			// Root modules must have a static list of exports
			const unknownProvidedExports = relevantExports.filter(
			exportInfo => {
			return exportInfo.provided !== true;
			}
			);
			if (unknownProvidedExports.length > 0) {
			setBailoutReason(
			module,
			`List of module exports is dynamic (${Array.from(
			unknownProvidedExports,
			exportInfo =>
			`${
			exportInfo.name \|\| "other exports"
			}: ${exportInfo.getProvidedInfo()} and ${exportInfo.getUsedInfo()}`
			).join(", ")})`
			);
			canBeRoot = false;
			}

			// Module must not be an entry point
			if (chunkGraph.isEntryModule(module)) {
			setInnerBailoutReason(module, "Module is an entry point");
			canBeInner = false;
			}

			if (canBeRoot) relevantModules.push(module);
			if (canBeInner) possibleInners.add(module);
			}
			logger.timeEnd("select relevant modules");
			logger.debug(
			`${relevantModules.length} potential root modules, ${possibleInners.size} potential inner modules`
			);
			// sort by depth
			// modules with lower depth are more likely suited as roots
			// this improves performance, because modules already selected as inner are skipped
			logger.time("sort relevant modules");
			relevantModules.sort((a, b) => {
			return moduleGraph.getDepth(a) - moduleGraph.getDepth(b);
			});
			logger.timeEnd("sort relevant modules");

			logger.time("find modules to concatenate");
			const concatConfigurations = [];
			const usedAsInner = new Set();
			for (const currentRoot of relevantModules) {
			// when used by another configuration as inner:
			// the other configuration is better and we can skip this one
			if (usedAsInner.has(currentRoot)) continue;

			let chunkRuntime = undefined;
			for (const r of chunkGraph.getModuleRuntimes(currentRoot)) {
			chunkRuntime = mergeRuntimeOwned(chunkRuntime, r);
			}
			const exportsInfo = moduleGraph.getExportsInfo(currentRoot);
			const filteredRuntime = filterRuntime(chunkRuntime, r =>
			exportsInfo.isModuleUsed(r)
			);
			const activeRuntime =
			filteredRuntime === true
			? chunkRuntime
			: filteredRuntime === false
			? undefined
			: filteredRuntime;

			// create a configuration with the root
			const currentConfiguration = new ConcatConfiguration(
			currentRoot,
			activeRuntime
			);

			// cache failures to add modules
			const failureCache = new Map();

			// potential optional import candidates
			/** @type {Set<Module>} */
			const candidates = new Set();

			// try to add all imports
			for (const imp of this._getImports(
			compilation,
			currentRoot,
			activeRuntime
			)) {
			candidates.add(imp);
			}

			for (const imp of candidates) {
			// _tryToAdd modifies the config even if it fails
			// so make sure to only accept changes when it succeed
			const backup = currentConfiguration.snapshot();
			const impCandidates = new Set();
			const problem = this._tryToAdd(
			compilation,
			currentConfiguration,
			imp,
			chunkRuntime,
			activeRuntime,
			possibleInners,
			impCandidates,
			failureCache,
			chunkGraph
			);
			if (problem) {
			failureCache.set(imp, problem);
			currentConfiguration.addWarning(imp, problem);

			// roll back
			currentConfiguration.rollback(backup);
			} else {
			for (const c of impCandidates) {
			candidates.add(c);
			}
			}
			}
			if (!currentConfiguration.isEmpty()) {
			concatConfigurations.push(currentConfiguration);
			for (const module of currentConfiguration.getModules()) {
			if (module !== currentConfiguration.rootModule) {
			usedAsInner.add(module);
			}
			}
			} else {
			const optimizationBailouts = moduleGraph.getOptimizationBailout(
			currentRoot
			);
			for (const warning of currentConfiguration.getWarningsSorted()) {
			optimizationBailouts.push(
			formatBailoutWarning(warning[0], warning[1])
			);
			}
			}
			}
			logger.timeEnd("find modules to concatenate");
			logger.debug(
			`${concatConfigurations.length} concat configurations`
			);
			// HACK: Sort configurations by length and start with the longest one
			// to get the biggest groups possible. Used modules are marked with usedModules
			// TODO: Allow to reuse existing configuration while trying to add dependencies.
			// This would improve performance. O(n^2) -> O(n)
			logger.time(`sort concat configurations`);
			concatConfigurations.sort((a, b) => {
			return b.modules.size - a.modules.size;
			});
			logger.timeEnd(`sort concat configurations`);
			const usedModules = new Set();

			logger.time("create concatenated modules");
			asyncLib.each(
			concatConfigurations,
			(concatConfiguration, callback) => {
			const rootModule = concatConfiguration.rootModule;

			// Avoid overlapping configurations
			// TODO: remove this when todo above is fixed
			if (usedModules.has(rootModule)) return callback();
			const modules = concatConfiguration.getModules();
			for (const m of modules) {
			usedModules.add(m);
			}

			// Create a new ConcatenatedModule
			let newModule = ConcatenatedModule.create(
			rootModule,
			modules,
			concatConfiguration.runtime,
			compiler.root
			);

			const cacheItem = cache.getItemCache(
			newModule.identifier(),
			null
			);

			const restore = () => {
			cacheItem.get((err, cacheModule) => {
			if (err) {
			return callback(new ModuleRestoreError(newModule, err));
			}

			if (cacheModule) {
			cacheModule.updateCacheModule(newModule);
			newModule = cacheModule;
			}

			build();
			});
			};

			const build = () => {
			newModule.build(
			compiler.options,
			compilation,
			null,
			null,
			err => {
			if (err) {
			if (!err.module) {
			err.module = newModule;
			}
			return callback(err);
			}
			integrateAndStore();
			}
			);
			};

			const integrateAndStore = () => {
			ChunkGraph.setChunkGraphForModule(newModule, chunkGraph);
			ModuleGraph.setModuleGraphForModule(newModule, moduleGraph);

			for (const warning of concatConfiguration.getWarningsSorted()) {
			moduleGraph
			.getOptimizationBailout(newModule)
			.push(formatBailoutWarning(warning[0], warning[1]));
			}
			moduleGraph.cloneModuleAttributes(rootModule, newModule);
			for (const m of modules) {
			// add to builtModules when one of the included modules was built
			if (compilation.builtModules.has(m)) {
			compilation.builtModules.add(newModule);
			}
			if (m !== rootModule) {
			// attach external references to the concatenated module too
			moduleGraph.copyOutgoingModuleConnections(
			m,
			newModule,
			c => {
			return (
			c.originModule === m &&
			!(
			c.dependency instanceof HarmonyImportDependency &&
			modules.has(c.module)
			)
			);
			}
			);
			// remove module from chunk
			for (const chunk of chunkGraph.getModuleChunksIterable(
			rootModule
			)) {
			chunkGraph.disconnectChunkAndModule(chunk, m);
			}
			}
			}
			compilation.modules.delete(rootModule);
			// remove module from chunk
			chunkGraph.replaceModule(rootModule, newModule);
			// replace module references with the concatenated module
			moduleGraph.moveModuleConnections(
			rootModule,
			newModule,
			c => {
			const otherModule =
			c.module === rootModule ? c.originModule : c.module;
			const innerConnection =
			c.dependency instanceof HarmonyImportDependency &&
			modules.has(otherModule);
			return !innerConnection;
			}
			);
			// add concatenated module to the compilation
			compilation.modules.add(newModule);

			// TODO check if module needs build to avoid caching it without change
			cacheItem.store(newModule, err => {
			if (err) {
			return callback(new ModuleStoreError(newModule, err));
			}

			callback();
			});
			};

			restore();
			},
			err => {
			logger.timeEnd("create concatenated modules");
			process.nextTick(() => callback(err));
			}
			);
			}
			);
			}
			);
			}

			/**
			* @param {Compilation} compilation the compilation
			* @param {Module} module the module to be added
			* @param {RuntimeSpec} runtime the runtime scope
			* @returns {Set<Module>} the imported modules
			*/
			_getImports(compilation, module, runtime) {
			const moduleGraph = compilation.moduleGraph;
			const set = new Set();
			for (const dep of module.dependencies) {
			// Get reference info only for harmony Dependencies
			if (!(dep instanceof HarmonyImportDependency)) continue;

			const connection = moduleGraph.getConnection(dep);
			// Reference is valid and has a module
			if (
			!connection \|\|
			!connection.module \|\|
			!connection.isTargetActive(runtime)
			) {
			continue;
			}

			const importedNames = compilation.getDependencyReferencedExports(
			dep,
			undefined
			);

			if (
			importedNames.every(i =>
			Array.isArray(i) ? i.length > 0 : i.name.length > 0
			) \|\|
			Array.isArray(moduleGraph.getProvidedExports(module))
			) {
			set.add(connection.module);
			}
			}
			return set;
			}

			/**
			* @param {Compilation} compilation webpack compilation
			* @param {ConcatConfiguration} config concat configuration (will be modified when added)
			* @param {Module} module the module to be added
			* @param {RuntimeSpec} runtime the runtime scope of the generated code
			* @param {RuntimeSpec} activeRuntime the runtime scope of the root module
			* @param {Set<Module>} possibleModules modules that are candidates
			* @param {Set<Module>} candidates list of potential candidates (will be added to)
			* @param {Map<Module, Module \| function(RequestShortener): string>} failureCache cache for problematic modules to be more performant
			* @param {ChunkGraph} chunkGraph the chunk graph
			* @returns {Module \| function(RequestShortener): string} the problematic module
			*/
			_tryToAdd(
			compilation,
			config,
			module,
			runtime,
			activeRuntime,
			possibleModules,
			candidates,
			failureCache,
			chunkGraph
			) {
			const cacheEntry = failureCache.get(module);
			if (cacheEntry) {
			return cacheEntry;
			}

			// Already added?
			if (config.has(module)) {
			return null;
			}

			// Not possible to add?
			if (!possibleModules.has(module)) {
			failureCache.set(module, module); // cache failures for performance
			return module;
			}

			// Module must be in the correct chunks
			const missingChunks = Array.from(
			chunkGraph.getModuleChunksIterable(config.rootModule)
			)
			.filter(chunk => !chunkGraph.isModuleInChunk(module, chunk))
			.map(chunk => chunk.name \|\| "unnamed chunk(s)");
			if (missingChunks.length > 0) {
			const missingChunksList = Array.from(new Set(missingChunks)).sort();
			const chunks = Array.from(
			new Set(
			Array.from(chunkGraph.getModuleChunksIterable(module)).map(
			chunk => chunk.name \|\| "unnamed chunk(s)"
			)
			)
			).sort();
			const problem = requestShortener =>
			`Module ${module.readableIdentifier(
			requestShortener
			)} is not in the same chunk(s) (expected in chunk(s) ${missingChunksList.join(
			", "
			)}, module is in chunk(s) ${chunks.join(", ")})`;
			failureCache.set(module, problem); // cache failures for performance
			return problem;
			}

			// Add the module
			config.add(module);

			const moduleGraph = compilation.moduleGraph;

			const incomingConnections = Array.from(
			moduleGraph.getIncomingConnections(module)
			).filter(connection => {
			// We are not interested in inactive connections
			if (!connection.isActive(runtime)) return false;

			// Include, but do not analyse further, connections from non-modules
			if (!connection.originModule) return true;

			// Ignore connection from orphan modules
			if (chunkGraph.getNumberOfModuleChunks(connection.originModule) === 0)
			return false;

			// We don't care for connections from other runtimes
			let originRuntime = undefined;
			for (const r of chunkGraph.getModuleRuntimes(connection.originModule)) {
			originRuntime = mergeRuntimeOwned(originRuntime, r);
			}

			return intersectRuntime(runtime, originRuntime);
			});

			const nonHarmonyConnections = incomingConnections.filter(
			connection =>
			!connection.originModule \|\|
			!connection.dependency \|\|
			!(connection.dependency instanceof HarmonyImportDependency)
			);
			if (nonHarmonyConnections.length > 0) {
			const problem = requestShortener => {
			const importingModules = new Set(
			nonHarmonyConnections.map(c => c.originModule).filter(Boolean)
			);
			const importingExplanations = new Set(
			nonHarmonyConnections.map(c => c.explanation).filter(Boolean)
			);
			const importingModuleTypes = new Map(
			Array.from(importingModules).map(
			m =>
			/** @type {[Module, Set<string>]} */ ([
			m,
			new Set(
			nonHarmonyConnections
			.filter(c => c.originModule === m)
			.map(c => c.dependency.type)
			.sort()
			)
			])
			)
			);
			const names = Array.from(importingModules)
			.map(
			m =>
			`${m.readableIdentifier(
			requestShortener
			)} (referenced with ${Array.from(
			importingModuleTypes.get(m)
			).join(", ")})`
			)
			.sort();
			const explanations = Array.from(importingExplanations).sort();
			if (names.length > 0 && explanations.length === 0) {
			return `Module ${module.readableIdentifier(
			requestShortener
			)} is referenced from these modules with unsupported syntax: ${names.join(
			", "
			)}`;
			} else if (names.length === 0 && explanations.length > 0) {
			return `Module ${module.readableIdentifier(
			requestShortener
			)} is referenced by: ${explanations.join(", ")}`;
			} else if (names.length > 0 && explanations.length > 0) {
			return `Module ${module.readableIdentifier(
			requestShortener
			)} is referenced from these modules with unsupported syntax: ${names.join(
			", "
			)} and by: ${explanations.join(", ")}`;
			} else {
			return `Module ${module.readableIdentifier(
			requestShortener
			)} is referenced in a unsupported way`;
			}
			};
			failureCache.set(module, problem); // cache failures for performance
			return problem;
			}

			// Module must be in the same chunks like the referencing module
			const otherChunkConnections = incomingConnections.filter(connection => {
			for (const chunk of chunkGraph.getModuleChunksIterable(
			config.rootModule
			)) {
			if (!chunkGraph.isModuleInChunk(connection.originModule, chunk)) {
			return true;
			}
			}
			return false;
			});
			if (otherChunkConnections.length > 0) {
			const problem = requestShortener => {
			const importingModules = new Set(
			otherChunkConnections.map(c => c.originModule)
			);
			const names = Array.from(importingModules)
			.map(m => m.readableIdentifier(requestShortener))
			.sort();
			return `Module ${module.readableIdentifier(
			requestShortener
			)} is referenced from different chunks by these modules: ${names.join(
			", "
			)}`;
			};
			failureCache.set(module, problem); // cache failures for performance
			return problem;
			}

			if (runtime !== undefined && typeof runtime !== "string") {
			// Module must be consistently referenced in the same runtimes
			/** @type {Map<Module, boolean \| RuntimeSpec>} */
			const runtimeConditionMap = new Map();
			for (const connection of incomingConnections) {
			const runtimeCondition = filterRuntime(runtime, runtime => {
			return connection.isTargetActive(runtime);
			});
			if (runtimeCondition === false) continue;
			const old = runtimeConditionMap.get(connection.originModule) \|\| false;
			if (old === true) continue;
			if (old !== false && runtimeCondition !== true) {
			runtimeConditionMap.set(
			connection.originModule,
			mergeRuntime(old, runtimeCondition)
			);
			} else {
			runtimeConditionMap.set(connection.originModule, runtimeCondition);
			}
			}
			const otherRuntimeConnections = Array.from(runtimeConditionMap).filter(
			([, runtimeCondition]) => typeof runtimeCondition !== "boolean"
			);
			if (otherRuntimeConnections.length > 0) {
			const problem = requestShortener => {
			return `Module ${module.readableIdentifier(
			requestShortener
			)} is runtime-dependent referenced by these modules: ${Array.from(
			otherRuntimeConnections,
			([module, runtimeCondition]) =>
			`${module.readableIdentifier(
			requestShortener
			)} (expected runtime ${runtimeToString(
			runtime
			)}, module is only referenced in ${runtimeToString(
			/** @type {RuntimeSpec} */ (runtimeCondition)
			)})`
			).join(", ")}`;
			};
			failureCache.set(module, problem); // cache failures for performance
			return problem;
			}
			}

			const incomingModules = Array.from(
			new Set(incomingConnections.map(c => c.originModule))
			).sort(compareModulesByIdentifier);

			// Every module which depends on the added module must be in the configuration too.
			for (const originModule of incomingModules) {
			const problem = this._tryToAdd(
			compilation,
			config,
			originModule,
			runtime,
			activeRuntime,
			possibleModules,
			candidates,
			failureCache,
			chunkGraph
			);
			if (problem) {
			failureCache.set(module, problem); // cache failures for performance
			return problem;
			}
			}

			// Add imports to possible candidates list
			for (const imp of this._getImports(compilation, module, runtime)) {
			candidates.add(imp);
			}
			return null;
			}
			}

			class ConcatConfiguration {
			/**
			* @param {Module} rootModule the root module
			* @param {RuntimeSpec} runtime the runtime
			*/
			constructor(rootModule, runtime) {
			this.rootModule = rootModule;
			this.runtime = runtime;
			/** @type {StackedMap<Module, true>} */
			this.modules = new StackedMap();
			this.modules.set(rootModule, true);
			/** @type {StackedMap<Module, Module \| function(RequestShortener): string>} */
			this.warnings = new StackedMap();
			}

			add(module) {
			this.modules.set(module, true);
			}

			has(module) {
			return this.modules.has(module);
			}

			isEmpty() {
			return this.modules.size === 1;
			}

			addWarning(module, problem) {
			this.warnings.set(module, problem);
			}

			getWarningsSorted() {
			return new Map(
			this.warnings.asPairArray().sort((a, b) => {
			const ai = a[0].identifier();
			const bi = b[0].identifier();
			if (ai < bi) return -1;
			if (ai > bi) return 1;
			return 0;
			})
			);
			}

			/**
			* @returns {Set<Module>} modules as set
			*/
			getModules() {
			return this.modules.asSet();
			}

			snapshot() {
			const base = this.modules;
			this.modules = this.modules.createChild();
			return base;
			}

			rollback(snapshot) {
			this.modules = snapshot;
			}
			}

			module.exports = ModuleConcatenationPlugin;

rOACCT/node_modules/webpack/lib/optimize/ModuleConcatenationPlugin.js9045e4d5dbe1drf-api-tracking

ModuleConcatenationPlugin.jsView Options

rOACCT/node_modules/webpack/lib/optimize/ModuleConcatenationPlugin.js
9045e4d5dbe1drf-api-tracking

ModuleConcatenationPlugin.js
View Options