generate only needed source types

- in ConcatenatedModule generate only js
- in NormalModule generate only used sources

lib/ChunkGraph.js

@@ -85,16 +85,15 @@ const getModuleRuntimes = chunks => {
 };
 
 /**
- * @param {WeakMap<Module, Set<string>> | undefined} sourceTypesByModule sourceTypesByModule
+ * @param {WeakMap<Module, Set<string>>} sourceTypesByModule sourceTypesByModule
  * @returns {function (SortableSet<Module>): Map<string, SortableSet<Module>>} modules by source type
  */
 const modulesBySourceType = sourceTypesByModule => set => {
 	/** @type {Map<string, SortableSet<Module>>} */
 	const map = new Map();
 	for (const module of set) {
 		const sourceTypes =
-			(sourceTypesByModule && sourceTypesByModule.get(module)) ||
-			module.getSourceTypes();
+			sourceTypesByModule.get(module) || module.getSourceTypes();
 		for (const sourceType of sourceTypes) {
 			let innerSet = map.get(sourceType);
 			if (innerSet === undefined) {
@@ -204,8 +203,8 @@ class ChunkGraphChunk {
 	constructor() {
 		/** @type {SortableSet<Module>} */
 		this.modules = new SortableSet();
-		/** @type {WeakMap<Module, Set<string>> | undefined} */
-		this.sourceTypesByModule = undefined;
+		/** @type {WeakMap<Module, Set<string>>} */
+		this.sourceTypesByModule = new WeakMap();
 		/** @type {Map<Module, Entrypoint>} */
 		this.entryModules = new Map();
 		/** @type {SortableSet<RuntimeModule>} */
@@ -218,6 +217,8 @@ class ChunkGraphChunk {
 		this.runtimeRequirements = undefined;
 		/** @type {Set<string>} */
 		this.runtimeRequirementsInTree = new Set();
+
+		this.modulesBySourceType = modulesBySourceType(this.sourceTypesByModule);
 	}
 }
 
@@ -320,7 +321,7 @@ class ChunkGraph {
 		const cgm = this._getChunkGraphModule(module);
 		const cgc = this._getChunkGraphChunk(chunk);
 		cgc.modules.delete(module);
-		if (cgc.sourceTypesByModule) cgc.sourceTypesByModule.delete(module);
+		cgc.sourceTypesByModule.delete(module);
 		cgm.chunks.delete(chunk);
 	}
 
@@ -574,7 +575,7 @@ class ChunkGraph {
 	getChunkModulesIterableBySourceType(chunk, sourceType) {
 		const cgc = this._getChunkGraphChunk(chunk);
 		const modulesWithSourceType = cgc.modules
-			.getFromUnorderedCache(modulesBySourceType(cgc.sourceTypesByModule))
+			.getFromUnorderedCache(cgc.modulesBySourceType)
 			.get(sourceType);
 		return modulesWithSourceType;
 	}
@@ -586,12 +587,44 @@ class ChunkGraph {
 	 */
 	setChunkModuleSourceTypes(chunk, module, sourceTypes) {
 		const cgc = this._getChunkGraphChunk(chunk);
-		if (cgc.sourceTypesByModule === undefined) {
-			cgc.sourceTypesByModule = new WeakMap();
-		}
 		cgc.sourceTypesByModule.set(module, sourceTypes);
 	}
 
+	/**
+	 * @param {Chunk} chunk chunk
+	 * @param {Module} module chunk module
+	 * @returns {Set<string>} source types
+	 */
+	getChunkModuleSourceTypes(chunk, module) {
+		const cgc = this._getChunkGraphChunk(chunk);
+		return cgc.sourceTypesByModule.get(module) || module.getSourceTypes();
+	}
+
+	/**
+	 * @param {Module} module module
+	 * @returns {Set<string>} source types
+	 */
+	getModuleSourceTypes(module) {
+		let newSet = false;
+		let sourceTypes;
+		for (const chunk of this.getModuleChunksIterable(module)) {
+			const cgc = this._getChunkGraphChunk(chunk);
+			const st = cgc.sourceTypesByModule.get(module);
+			if (st) {
+				if (!sourceTypes) {
+					sourceTypes = st;
+					continue;
+				} else if (!newSet) {
+					newSet = true;
+					sourceTypes = new Set(sourceTypes);
+				}
+				for (const type of st) sourceTypes.add(type);
+			}
+		}
+
+		return sourceTypes || module.getSourceTypes();
+	}
+
 	/**
 	 * @param {Chunk} chunk the chunk
 	 * @param {function(Module, Module): -1|0|1} comparator comparator function
@@ -612,7 +645,7 @@ class ChunkGraph {
 	getOrderedChunkModulesIterableBySourceType(chunk, sourceType, comparator) {
 		const cgc = this._getChunkGraphChunk(chunk);
 		const modulesWithSourceType = cgc.modules
-			.getFromUnorderedCache(modulesBySourceType(cgc.sourceTypesByModule))
+			.getFromUnorderedCache(cgc.modulesBySourceType)
 			.get(sourceType);
 		if (modulesWithSourceType === undefined) return undefined;
 		modulesWithSourceType.sortWith(comparator);

lib/Module.js

@@ -60,6 +60,7 @@ const makeSerializable = require("./util/makeSerializable");
  * @property {ConcatenationScope=} concatenationScope when in concatenated module, information about other concatenated modules
  * @property {CodeGenerationResults} codeGenerationResults code generation results of other modules (need to have a codeGenerationDependency to use that)
  * @property {Compilation=} compilation the compilation
+ * @property {Omit<Set<string>, "delete"|"add">=} sourceTypes source types
  */
 
 /**

lib/NormalModule.js

@@ -1176,7 +1176,8 @@ class NormalModule extends Module {
 		chunkGraph,
 		runtime,
 		concatenationScope,
-		codeGenerationResults
+		codeGenerationResults,
+		sourceTypes
 	}) {
 		/** @type {Set<string>} */
 		const runtimeRequirements = new Set();
@@ -1195,7 +1196,7 @@ class NormalModule extends Module {
 		};
 
 		const sources = new Map();
-		for (const type of this.generator.getTypes(this)) {
+		for (const type of sourceTypes || chunkGraph.getModuleSourceTypes(this)) {
 			const source = this.error
 				? new RawSource(
 						"throw new Error(" + JSON.stringify(this.error.message) + ");"

lib/optimize/ConcatenatedModule.js

@@ -1669,7 +1669,8 @@ ${defineGetters}`
 					chunkGraph,
 					runtime,
 					concatenationScope,
-					codeGenerationResults
+					codeGenerationResults,
+					sourceTypes: TYPES
 				});
 				const source = codeGenResult.sources.get("javascript");
 				const data = codeGenResult.data;

lib/optimize/ModuleConcatenationPlugin.js

@@ -425,7 +425,10 @@ class ModuleConcatenationPlugin {
 										for (const chunk of chunkGraph.getModuleChunksIterable(
 											rootModule
 										)) {
-											const sourceTypes = m.getSourceTypes();
+											const sourceTypes = chunkGraph.getChunkModuleSourceTypes(
+												chunk,
+												m
+											);
 											if (sourceTypes.size === 1) {
 												chunkGraph.disconnectChunkAndModule(chunk, m);
 											} else {

test/__snapshots__/StatsTestCases.basictest.js.snap

@@ -179,7 +179,7 @@ webpack x.x.x compiled successfully in X ms"
 
 exports[`StatsTestCases should print correct stats for asset-concat 1`] = `
 "asset 89a353e9c515885abd8e.png 14.6 KiB [emitted] [immutable] [from: images/file.png] (auxiliary name: main)
-asset bundle.js 12.5 KiB [emitted] (name: main)
+asset bundle.js 11.7 KiB [emitted] (name: main)
 asset static/file.html 12 bytes [emitted] [from: static/file.html] (auxiliary name: main)
 orphan modules 9.05 KiB [orphan] 7 modules
 runtime modules 1.06 KiB 2 modules

types.d.ts

@@ -814,6 +814,8 @@ declare class ChunkGraph {
 		module: Module,
 		sourceTypes: Set<string>
 	): void;
+	getChunkModuleSourceTypes(chunk: Chunk, module: Module): Set<string>;
+	getModuleSourceTypes(module: Module): Set<string>;
 	getOrderedChunkModulesIterable(
 		chunk: Chunk,
 		comparator: (arg0: Module, arg1: Module) => 0 | 1 | -1
@@ -1249,6 +1251,11 @@ declare interface CodeGenerationContext {
 	 * the compilation
 	 */
 	compilation?: Compilation;
+
+	/**
+	 * source types
+	 */
+	sourceTypes?: Omit<Set<string>, "delete" | "add">;
 }
 declare interface CodeGenerationResult {
 	/**