webpack 5.18.0 → 5.20.2

package/lib/Compilation.js

@@ -55,6 +55,7 @@ const StatsPrinter = require("./stats/StatsPrinter");
 const { equals: arrayEquals } = require("./util/ArrayHelpers");
 const AsyncQueue = require("./util/AsyncQueue");
 const LazySet = require("./util/LazySet");
+const { provide } = require("./util/MapHelpers");
 const { cachedCleverMerge } = require("./util/cleverMerge");
 const {
 	compareLocations,
@@ -817,23 +818,29 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		/** @type {CodeGenerationResults} */
 		this.codeGenerationResults = undefined;
 
-		/** @type {AsyncQueue<FactorizeModuleOptions, string, Module>} */
-		this.factorizeQueue = new AsyncQueue({
-			name: "factorize",
+		/** @type {AsyncQueue<Module, Module, Module>} */
+		this.processDependenciesQueue = new AsyncQueue({
+			name: "processDependencies",
 			parallelism: options.parallelism || 100,
-			processor: this._factorizeModule.bind(this)
+			processor: this._processModuleDependencies.bind(this)
 		});
 		/** @type {AsyncQueue<Module, string, Module>} */
 		this.addModuleQueue = new AsyncQueue({
 			name: "addModule",
-			parallelism: options.parallelism || 100,
+			parent: this.processDependenciesQueue,
 			getKey: module => module.identifier(),
 			processor: this._addModule.bind(this)
 		});
+		/** @type {AsyncQueue<FactorizeModuleOptions, string, Module>} */
+		this.factorizeQueue = new AsyncQueue({
+			name: "factorize",
+			parent: this.addModuleQueue,
+			processor: this._factorizeModule.bind(this)
+		});
 		/** @type {AsyncQueue<Module, Module, Module>} */
 		this.buildQueue = new AsyncQueue({
 			name: "build",
-			parallelism: options.parallelism || 100,
+			parent: this.factorizeQueue,
 			processor: this._buildModule.bind(this)
 		});
 		/** @type {AsyncQueue<Module, Module, Module>} */
@@ -842,12 +849,6 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 			parallelism: options.parallelism || 100,
 			processor: this._rebuildModule.bind(this)
 		});
-		/** @type {AsyncQueue<Module, Module, Module>} */
-		this.processDependenciesQueue = new AsyncQueue({
-			name: "processDependencies",
-			parallelism: options.parallelism || 100,
-			processor: this._processModuleDependencies.bind(this)
-		});
 
 		/**
 		 * Modules in value are building during the build of Module in key.
@@ -1871,6 +1872,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 				});
 			}
 
+			this.processDependenciesQueue.invalidate(module);
 			this.processModuleDependencies(module, err => {
 				if (err) return callback(err);
 				this.removeReasonsOfDependencyBlock(module, {
@@ -1891,6 +1893,184 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 	}
 
 	finish(callback) {
+		if (this.profile) {
+			this.logger.time("finish module profiles");
+			const ParallelismFactorCalculator = require("./util/ParallelismFactorCalculator");
+			const p = new ParallelismFactorCalculator();
+			const moduleGraph = this.moduleGraph;
+			const modulesWithProfiles = new Map();
+			for (const module of this.modules) {
+				const profile = moduleGraph.getProfile(module);
+				if (!profile) continue;
+				modulesWithProfiles.set(module, profile);
+				p.range(
+					profile.buildingStartTime,
+					profile.buildingEndTime,
+					f => (profile.buildingParallelismFactor = f)
+				);
+				p.range(
+					profile.factoryStartTime,
+					profile.factoryEndTime,
+					f => (profile.factoryParallelismFactor = f)
+				);
+				p.range(
+					profile.integrationStartTime,
+					profile.integrationEndTime,
+					f => (profile.integrationParallelismFactor = f)
+				);
+				p.range(
+					profile.storingStartTime,
+					profile.storingEndTime,
+					f => (profile.storingParallelismFactor = f)
+				);
+				p.range(
+					profile.restoringStartTime,
+					profile.restoringEndTime,
+					f => (profile.restoringParallelismFactor = f)
+				);
+				if (profile.additionalFactoryTimes) {
+					for (const { start, end } of profile.additionalFactoryTimes) {
+						const influence = (end - start) / profile.additionalFactories;
+						p.range(
+							start,
+							end,
+							f =>
+								(profile.additionalFactoriesParallelismFactor += f * influence)
+						);
+					}
+				}
+			}
+			p.calculate();
+
+			const logger = this.getLogger("webpack.Compilation.ModuleProfile");
+			const logByValue = (value, msg) => {
+				if (value > 1000) {
+					logger.error(msg);
+				} else if (value > 500) {
+					logger.warn(msg);
+				} else if (value > 200) {
+					logger.info(msg);
+				} else if (value > 30) {
+					logger.log(msg);
+				} else {
+					logger.debug(msg);
+				}
+			};
+			const logNormalSummary = (category, getDuration, getParallelism) => {
+				let sum = 0;
+				let max = 0;
+				for (const [module, profile] of modulesWithProfiles) {
+					const p = getParallelism(profile);
+					const d = getDuration(profile);
+					if (d === 0 || p === 0) continue;
+					const t = d / p;
+					sum += t;
+					if (t <= 10) continue;
+					logByValue(
+						t,
+						` | ${Math.round(t)} ms${
+							p >= 1.1 ? ` (parallelism ${Math.round(p * 10) / 10})` : ""
+						} ${category} > ${module.readableIdentifier(this.requestShortener)}`
+					);
+					max = Math.max(max, t);
+				}
+				if (sum <= 10) return;
+				logByValue(
+					Math.max(sum / 10, max),
+					`${Math.round(sum)} ms ${category}`
+				);
+			};
+			const logByLoadersSummary = (category, getDuration, getParallelism) => {
+				const map = new Map();
+				for (const [module, profile] of modulesWithProfiles) {
+					const list = provide(
+						map,
+						module.type + "!" + module.identifier().replace(/(!|^)[^!]*$/, ""),
+						() => []
+					);
+					list.push({ module, profile });
+				}
+
+				let sum = 0;
+				let max = 0;
+				for (const [key, modules] of map) {
+					let innerSum = 0;
+					let innerMax = 0;
+					for (const { module, profile } of modules) {
+						const p = getParallelism(profile);
+						const d = getDuration(profile);
+						if (d === 0 || p === 0) continue;
+						const t = d / p;
+						innerSum += t;
+						if (t <= 10) continue;
+						logByValue(
+							t,
+							` |  | ${Math.round(t)} ms${
+								p >= 1.1 ? ` (parallelism ${Math.round(p * 10) / 10})` : ""
+							} ${category} > ${module.readableIdentifier(
+								this.requestShortener
+							)}`
+						);
+						innerMax = Math.max(innerMax, t);
+					}
+					sum += innerSum;
+					if (innerSum <= 10) continue;
+					const idx = key.indexOf("!");
+					const loaders = key.slice(idx + 1);
+					const moduleType = key.slice(0, idx);
+					const t = Math.max(innerSum / 10, innerMax);
+					logByValue(
+						t,
+						` | ${Math.round(innerSum)} ms ${category} > ${
+							loaders
+								? `${
+										modules.length
+								  } x ${moduleType} with ${this.requestShortener.shorten(
+										loaders
+								  )}`
+								: `${modules.length} x ${moduleType}`
+						}`
+					);
+					max = Math.max(max, t);
+				}
+				if (sum <= 10) return;
+				logByValue(
+					Math.max(sum / 10, max),
+					`${Math.round(sum)} ms ${category}`
+				);
+			};
+			logNormalSummary(
+				"resolve to new modules",
+				p => p.factory,
+				p => p.factoryParallelismFactor
+			);
+			logNormalSummary(
+				"resolve to existing modules",
+				p => p.additionalFactories,
+				p => p.additionalFactoriesParallelismFactor
+			);
+			logNormalSummary(
+				"integrate modules",
+				p => p.restoring,
+				p => p.restoringParallelismFactor
+			);
+			logByLoadersSummary(
+				"build modules",
+				p => p.building,
+				p => p.buildingParallelismFactor
+			);
+			logNormalSummary(
+				"store modules",
+				p => p.storing,
+				p => p.storingParallelismFactor
+			);
+			logNormalSummary(
+				"restore modules",
+				p => p.restoring,
+				p => p.restoringParallelismFactor
+			);
+			this.logger.timeEnd("finish module profiles");
+		}
 		this.logger.time("finish modules");
 		const { modules } = this;
 		this.hooks.finishModules.callAsync(modules, err => {

package/lib/Dependency.js

@@ -128,7 +128,7 @@ class Dependency {
 
 	/**
 	 * @param {ModuleGraph} moduleGraph module graph
-	 * @returns {function(ModuleGraphConnection, RuntimeSpec): ConnectionState} function to determine if the connection is active
+	 * @returns {null | false | function(ModuleGraphConnection, RuntimeSpec): ConnectionState} function to determine if the connection is active
 	 */
 	getCondition(moduleGraph) {
 		return null;

package/lib/FlagDependencyUsagePlugin.js

@@ -9,6 +9,7 @@ const Dependency = require("./Dependency");
 const { UsageState } = require("./ExportsInfo");
 const ModuleGraphConnection = require("./ModuleGraphConnection");
 const { STAGE_DEFAULT } = require("./OptimizationStages");
+const ArrayQueue = require("./util/ArrayQueue");
 const TupleQueue = require("./util/TupleQueue");
 const { getEntryRuntime, mergeRuntimeOwned } = require("./util/runtime");
 
@@ -166,9 +167,12 @@ class FlagDependencyUsagePlugin {
 						/** @type {Map<Module, (string[] | ReferencedExport)[] | Map<string, string[] | ReferencedExport>>} */
 						const map = new Map();
 
-						/** @type {DependenciesBlock[]} */
-						const queue = [module];
-						for (const block of queue) {
+						/** @type {ArrayQueue<DependenciesBlock>} */
+						const queue = new ArrayQueue();
+						queue.enqueue(module);
+						for (;;) {
+							const block = queue.dequeue();
+							if (block === undefined) break;
 							for (const b of block.blocks) {
 								if (
 									!this.global &&
@@ -177,7 +181,7 @@ class FlagDependencyUsagePlugin {
 								) {
 									processModule(b, b.groupOptions.entryOptions.runtime);
 								} else {
-									queue.push(b);
+									queue.enqueue(b);
 								}
 							}
 							for (const dep of block.dependencies) {

package/lib/Generator.js

@@ -28,6 +28,7 @@
  * @property {RuntimeSpec} runtime the runtime
  * @property {ConcatenationScope=} concatenationScope when in concatenated module, information about other concatenated modules
  * @property {string} type which kind of code should be generated
+ * @property {function(): Map<string, any>=} getData get access to the code generation data
  */
 
 /**

package/lib/ModuleGraph.js

@@ -655,6 +655,14 @@ class ModuleGraph {
 		return meta;
 	}
 
+	/**
+	 * @param {any} thing any thing
+	 * @returns {Object} metadata
+	 */
+	getMetaIfExisting(thing) {
+		return this._metaMap.get(thing);
+	}
+
 	// TODO remove in webpack 6
 	/**
 	 * @param {Module} module the module

package/lib/ModuleGraphConnection.js

@@ -56,7 +56,7 @@ class ModuleGraphConnection {
 	 * @param {Module} module the referenced module
 	 * @param {string=} explanation some extra detail
 	 * @param {boolean=} weak the reference is weak
-	 * @param {function(ModuleGraphConnection, RuntimeSpec): ConnectionState=} condition condition for the connection
+	 * @param {false | function(ModuleGraphConnection, RuntimeSpec): ConnectionState=} condition condition for the connection
 	 */
 	constructor(
 		originModule,
@@ -73,9 +73,9 @@ class ModuleGraphConnection {
 		this.module = module;
 		this.weak = weak;
 		this.conditional = !!condition;
-		this._active = true;
+		this._active = condition !== false;
 		/** @type {function(ModuleGraphConnection, RuntimeSpec): ConnectionState} */
-		this.condition = condition;
+		this.condition = condition || undefined;
 		/** @type {Set<string>} */
 		this.explanations = undefined;
 		if (explanation) {

package/lib/ModuleProfile.js

@@ -8,12 +8,37 @@
 class ModuleProfile {
 	constructor() {
 		this.startTime = Date.now();
+
+		this.factoryStartTime = 0;
+		this.factoryEndTime = 0;
 		this.factory = 0;
+		this.factoryParallelismFactor = 0;
+
+		this.restoringStartTime = 0;
+		this.restoringEndTime = 0;
 		this.restoring = 0;
+		this.restoringParallelismFactor = 0;
+
+		this.integrationStartTime = 0;
+		this.integrationEndTime = 0;
 		this.integration = 0;
+		this.integrationParallelismFactor = 0;
+
+		this.buildingStartTime = 0;
+		this.buildingEndTime = 0;
 		this.building = 0;
+		this.buildingParallelismFactor = 0;
+
+		this.storingStartTime = 0;
+		this.storingEndTime = 0;
 		this.storing = 0;
+		this.storingParallelismFactor = 0;
+
+		this.additionalFactoryTimes = undefined;
 		this.additionalFactories = 0;
+		this.additionalFactoriesParallelismFactor = 0;
+
+		/** @deprecated */
 		this.additionalIntegration = 0;
 	}
 
@@ -70,10 +95,12 @@ class ModuleProfile {
 	 * @returns {void}
 	 */
 	mergeInto(realProfile) {
-		if (this.factory > realProfile.additionalFactories)
-			realProfile.additionalFactories = this.factory;
-		if (this.integration > realProfile.additionalIntegration)
-			realProfile.additionalIntegration = this.integration;
+		realProfile.additionalFactories = this.factory;
+		(realProfile.additionalFactoryTimes =
+			realProfile.additionalFactoryTimes || []).push({
+			start: this.factoryStartTime,
+			end: this.factoryEndTime
+		});
 	}
 }
 

package/lib/NormalModule.js

@@ -259,7 +259,8 @@ class NormalModule extends Module {
 		this._lastSuccessfulBuildMeta = {};
 		this._forceBuild = true;
 		this._isEvaluatingSideEffects = false;
-		this._addedSideEffectsBailout = new WeakSet();
+		/** @type {WeakSet<ModuleGraph> | undefined} */
+		this._addedSideEffectsBailout = undefined;
 	}
 
 	/**
@@ -934,7 +935,11 @@ class NormalModule extends Module {
 			for (const dep of this.dependencies) {
 				const state = dep.getModuleEvaluationSideEffectsState(moduleGraph);
 				if (state === true) {
-					if (!this._addedSideEffectsBailout.has(moduleGraph)) {
+					if (
+						this._addedSideEffectsBailout === undefined
+							? ((this._addedSideEffectsBailout = new WeakSet()), true)
+							: !this._addedSideEffectsBailout.has(moduleGraph)
+					) {
 						this._addedSideEffectsBailout.add(moduleGraph);
 						moduleGraph
 							.getOptimizationBailout(this)
@@ -988,6 +993,13 @@ class NormalModule extends Module {
 			runtimeRequirements.add(RuntimeGlobals.thisAsExports);
 		}
 
+		/** @type {Map<string, any>} */
+		let data;
+		const getData = () => {
+			if (data === undefined) data = new Map();
+			return data;
+		};
+
 		const sources = new Map();
 		for (const type of this.generator.getTypes(this)) {
 			const source = this.error
@@ -1002,6 +1014,7 @@ class NormalModule extends Module {
 						runtimeRequirements,
 						runtime,
 						concatenationScope,
+						getData,
 						type
 				  });
 
@@ -1013,7 +1026,8 @@ class NormalModule extends Module {
 		/** @type {CodeGenerationResult} */
 		const resultEntry = {
 			sources,
-			runtimeRequirements
+			runtimeRequirements,
+			data
 		};
 		return resultEntry;
 	}

package/lib/ProgressPlugin.js

@@ -108,14 +108,13 @@ class ProgressPlugin {
 	/**
 	 * @param {ProgressPluginArgument} options options
 	 */
-	constructor(options) {
+	constructor(options = {}) {
 		if (typeof options === "function") {
 			options = {
 				handler: options
 			};
 		}
 
-		options = options || {};
 		validate(schema, options, {
 			name: "Progress Plugin",
 			baseDataPath: "options"
@@ -203,12 +202,13 @@ class ProgressPlugin {
 			const items = [];
 			const percentByModules =
 				doneModules /
-				Math.max(lastModulesCount || this.modulesCount, modulesCount);
+				Math.max(lastModulesCount || this.modulesCount || 1, modulesCount);
 			const percentByEntries =
 				doneEntries /
-				Math.max(lastEntriesCount || this.dependenciesCount, entriesCount);
+				Math.max(lastEntriesCount || this.dependenciesCount || 1, entriesCount);
 			const percentByDependencies =
-				doneDependencies / Math.max(lastDependenciesCount, dependenciesCount);
+				doneDependencies /
+				Math.max(lastDependenciesCount || 1, dependenciesCount);
 			let percentageFactor;
 
 			switch (this.percentBy) {
@@ -268,17 +268,19 @@ class ProgressPlugin {
 
 		const factorizeAdd = () => {
 			dependenciesCount++;
-			if (dependenciesCount % 100 === 0) updateThrottled();
+			if (dependenciesCount < 50 || dependenciesCount % 100 === 0)
+				updateThrottled();
 		};
 
 		const factorizeDone = () => {
 			doneDependencies++;
-			if (doneDependencies % 100 === 0) updateThrottled();
+			if (doneDependencies < 50 || doneDependencies % 100 === 0)
+				updateThrottled();
 		};
 
 		const moduleAdd = () => {
 			modulesCount++;
-			if (modulesCount % 100 === 0) updateThrottled();
+			if (modulesCount < 50 || modulesCount % 100 === 0) updateThrottled();
 		};
 
 		// only used when showActiveModules is set
@@ -293,7 +295,7 @@ class ProgressPlugin {
 
 		const entryAdd = (entry, options) => {
 			entriesCount++;
-			if (entriesCount % 10 === 0) updateThrottled();
+			if (entriesCount < 5 || entriesCount % 10 === 0) updateThrottled();
 		};
 
 		const moduleDone = module => {
@@ -312,7 +314,7 @@ class ProgressPlugin {
 					}
 				}
 			}
-			if (doneModules % 100 === 0) updateThrottled();
+			if (doneModules < 50 || doneModules % 100 === 0) updateThrottled();
 		};
 
 		const entryDone = (entry, options) => {

package/lib/RuntimeGlobals.js

@@ -303,3 +303,17 @@ exports.systemContext = "__webpack_require__.y";
  * the baseURI of current document
  */
 exports.baseURI = "__webpack_require__.b";
+
+/**
+ * Creates an async module. The body function must be a async function.
+ * "module.exports" will be decorated with an AsyncModulePromise.
+ * The body function will be called.
+ * To handle async dependencies correctly do this: "([a, b, c] = await handleDependencies([a, b, c]));".
+ * If "hasAwaitAfterDependencies" is truthy, "handleDependencies()" must be called at the end of the body function.
+ * Signature: function(
+ * module: Module,
+ * body: (handleDependencies: (deps: AsyncModulePromise[]) => Promise<any[]> & () => void,
+ * hasAwaitAfterDependencies?: boolean
+ * ) => void
+ */
+exports.asyncModule = "__webpack_require__.a";

package/lib/RuntimePlugin.js

@@ -8,6 +8,7 @@
 const RuntimeGlobals = require("./RuntimeGlobals");
 const RuntimeRequirementsDependency = require("./dependencies/RuntimeRequirementsDependency");
 const JavascriptModulesPlugin = require("./javascript/JavascriptModulesPlugin");
+const AsyncModuleRuntimeModule = require("./runtime/AsyncModuleRuntimeModule");
 const AutoPublicPathRuntimeModule = require("./runtime/AutoPublicPathRuntimeModule");
 const CompatGetDefaultExportRuntimeModule = require("./runtime/CompatGetDefaultExportRuntimeModule");
 const CompatRuntimeModule = require("./runtime/CompatRuntimeModule");
@@ -48,6 +49,7 @@ const GLOBALS_ON_REQUIRE = [
 	RuntimeGlobals.publicPath,
 	RuntimeGlobals.scriptNonce,
 	RuntimeGlobals.uncaughtErrorHandler,
+	RuntimeGlobals.asyncModule,
 	RuntimeGlobals.wasmInstances,
 	RuntimeGlobals.instantiateWasm,
 	RuntimeGlobals.shareScopeMap,
@@ -194,6 +196,12 @@ class RuntimePlugin {
 					compilation.addRuntimeModule(chunk, new GlobalRuntimeModule());
 					return true;
 				});
+			compilation.hooks.runtimeRequirementInTree
+				.for(RuntimeGlobals.asyncModule)
+				.tap("RuntimePlugin", chunk => {
+					compilation.addRuntimeModule(chunk, new AsyncModuleRuntimeModule());
+					return true;
+				});
 			compilation.hooks.runtimeRequirementInTree
 				.for(RuntimeGlobals.systemContext)
 				.tap("RuntimePlugin", chunk => {

package/lib/RuntimeTemplate.js

@@ -103,7 +103,7 @@ class RuntimeTemplate {
 
 	returningFunction(returnValue, args = "") {
 		return this.supportsArrowFunction()
-			? `(${args}) => ${returnValue}`
+			? `(${args}) => (${returnValue})`
 			: `function(${args}) { return ${returnValue}; }`;
 	}
 

package/lib/WebpackOptionsApply.js

@@ -177,6 +177,13 @@ class WebpackOptionsApply extends OptionsApply {
 			);
 		}
 
+		if (options.output.clean) {
+			const CleanPlugin = require("./CleanPlugin");
+			new CleanPlugin(
+				options.output.clean === true ? {} : options.output.clean
+			).apply(compiler);
+		}
+
 		if (options.devtool) {
 			if (options.devtool.includes("source-map")) {
 				const hidden = options.devtool.includes("hidden");
@@ -246,22 +253,24 @@ class WebpackOptionsApply extends OptionsApply {
 
 		if (options.experiments.lazyCompilation) {
 			const LazyCompilationPlugin = require("./hmr/LazyCompilationPlugin");
+			const lazyOptions =
+				typeof options.experiments.lazyCompilation === "object"
+					? options.experiments.lazyCompilation
+					: null;
 			new LazyCompilationPlugin({
 				backend:
-					(typeof options.experiments.lazyCompilation === "object" &&
-						options.experiments.lazyCompilation.backend) ||
+					(lazyOptions && lazyOptions.backend) ||
 					require("./hmr/lazyCompilationBackend"),
 				client:
-					(typeof options.experiments.lazyCompilation === "object" &&
-						options.experiments.lazyCompilation.client) ||
+					(lazyOptions && lazyOptions.client) ||
 					require.resolve(
 						`../hot/lazy-compilation-${
 							options.externalsPresets.node ? "node" : "web"
 						}.js`
 					),
-				entries:
-					typeof options.experiments.lazyCompilation !== "object" ||
-					options.experiments.lazyCompilation.entries !== false
+				entries: !lazyOptions || lazyOptions.entries !== false,
+				imports: !lazyOptions || lazyOptions.imports !== false,
+				test: lazyOptions && lazyOptions.test
 			}).apply(compiler);
 		}
 

package/lib/asset/AssetGenerator.js

@@ -47,7 +47,7 @@ class AssetGenerator extends Generator {
 	 */
 	generate(
 		module,
-		{ runtime, chunkGraph, runtimeTemplate, runtimeRequirements, type }
+		{ runtime, chunkGraph, runtimeTemplate, runtimeRequirements, type, getData }
 	) {
 		switch (type) {
 			case "asset":
@@ -146,6 +146,15 @@ class AssetGenerator extends Generator {
 						sourceFilename,
 						...info
 					};
+					if (getData) {
+						// Due to code generation caching module.buildInfo.XXX can't used to store such information
+						// It need to be stored in the code generation results instead, where it's cached too
+						// TODO webpack 6 For back-compat reasons we also store in on module.buildInfo
+						const data = getData();
+						data.set("fullContentHash", fullHash);
+						data.set("filename", filename);
+						data.set("assetInfo", info);
+					}
 
 					runtimeRequirements.add(RuntimeGlobals.publicPath); // add __webpack_require__.p
 

package/lib/asset/AssetModulesPlugin.js

@@ -145,14 +145,23 @@ class AssetModulesPlugin {
 					);
 					if (modules) {
 						for (const module of modules) {
+							const codeGenResult = codeGenerationResults.get(
+								module,
+								chunk.runtime
+							);
 							result.push({
-								render: () =>
-									codeGenerationResults.getSource(module, chunk.runtime, type),
-								filename: module.buildInfo.filename,
-								info: module.buildInfo.assetInfo,
+								render: () => codeGenResult.sources.get(type),
+								filename:
+									module.buildInfo.filename ||
+									codeGenResult.data.get("filename"),
+								info:
+									module.buildInfo.assetInfo ||
+									codeGenResult.data.get("assetInfo"),
 								auxiliary: true,
 								identifier: `assetModule${chunkGraph.getModuleId(module)}`,
-								hash: module.buildInfo.fullContentHash
+								hash:
+									module.buildInfo.fullContentHash ||
+									codeGenResult.data.get("fullContentHash")
 							});
 						}
 					}