webpack 5.20.1 → 5.21.2

package/lib/stats/DefaultStatsPrinterPlugin.js

@@ -111,6 +111,24 @@ const SIMPLE_PRINTERS = {
 		)
 			return `${builtAtMessage}${subjectMessage} ${statusMessage}${timeMessage}${hashMessage}`;
 	},
+	"compilation.filteredWarningDetailsCount": count =>
+		count
+			? `${count} ${plural(
+					count,
+					"warning has",
+					"warnings have"
+			  )} detailed information that is not shown.\nUse 'stats.errorDetails: true' resp. '--stats-error-details' to show it.`
+			: undefined,
+	"compilation.filteredErrorDetailsCount": (count, { yellow }) =>
+		count
+			? yellow(
+					`${count} ${plural(
+						count,
+						"error has",
+						"errors have"
+					)} detailed information that is not shown.\nUse 'stats.errorDetails: true' resp. '--stats-error-details' to show it.`
+			  )
+			: undefined,
 	"compilation.env": (env, { bold }) =>
 		env
 			? `Environment (--env): ${bold(JSON.stringify(env, null, 2))}`
@@ -321,7 +339,7 @@ const SIMPLE_PRINTERS = {
 					: null;
 				if (
 					providedExportsCount !== null &&
-					providedExportsCount === module.usedExports.length
+					providedExportsCount === usedExports.length
 				) {
 					return cyan(formatFlag("all exports used"));
 				} else {
@@ -484,8 +502,9 @@ const SIMPLE_PRINTERS = {
 			: `${bold(moduleName)}`;
 	},
 	"error.loc": (loc, { green }) => green(loc),
-	"error.message": (message, { bold }) => bold(message),
-	"error.details": details => details,
+	"error.message": (message, { bold, formatError }) =>
+		message.includes("\u001b[") ? message : bold(formatError(message)),
+	"error.details": (details, { formatError }) => formatError(details),
 	"error.stack": stack => stack,
 	"error.moduleTrace": moduleTrace => undefined,
 	"error.separator!": () => "\n",
@@ -613,8 +632,10 @@ const PREFERRED_ORDERS = {
 		"logging",
 		"warnings",
 		"warningsInChildren!",
+		"filteredWarningDetailsCount",
 		"errors",
 		"errorsInChildren!",
+		"filteredErrorDetailsCount",
 		"summary!",
 		"needAdditionalPass"
 	],
@@ -895,7 +916,9 @@ const SIMPLE_ELEMENT_JOINERS = {
 			if (!item.content) continue;
 			const needMoreSpace =
 				item.element === "warnings" ||
+				item.element === "filteredWarningDetailsCount" ||
 				item.element === "errors" ||
+				item.element === "filteredErrorDetailsCount" ||
 				item.element === "logging";
 			if (result.length !== 0) {
 				result.push(needMoreSpace || lastNeedMore ? "\n\n" : "\n");
@@ -1072,6 +1095,40 @@ const AVAILABLE_FORMATS = {
 		} else {
 			return `${boldQuantity ? bold(time) : time}${unit}`;
 		}
+	},
+	formatError: (message, { green, yellow, red }) => {
+		if (message.includes("\u001b[")) return message;
+		const highlights = [
+			{ regExp: /(Did you mean .+)/g, format: green },
+			{
+				regExp: /(Set 'mode' option to 'development' or 'production')/g,
+				format: green
+			},
+			{ regExp: /(\(module has no exports\))/g, format: red },
+			{ regExp: /\(possible exports: (.+)\)/g, format: green },
+			{ regExp: /\s*(.+ doesn't exist)/g, format: red },
+			{ regExp: /('\w+' option has not been set)/g, format: red },
+			{
+				regExp: /(Emitted value instead of an instance of Error)/g,
+				format: yellow
+			},
+			{ regExp: /(Used? .+ instead)/gi, format: yellow },
+			{ regExp: /\b(deprecated|must|required)\b/g, format: yellow },
+			{
+				regExp: /\b(BREAKING CHANGE)\b/gi,
+				format: red
+			},
+			{
+				regExp: /\b(error|failed|unexpected|invalid|not found|not supported|not available|not possible|not implemented|doesn't support|conflict|conflicting|not existing|duplicate)\b/gi,
+				format: red
+			}
+		];
+		for (const { regExp, format } of highlights) {
+			message = message.replace(regExp, (match, content) => {
+				return match.replace(content, format(content));
+			});
+		}
+		return message;
 	}
 };
 
@@ -1128,7 +1185,15 @@ class DefaultStatsPrinterPlugin {
 									}
 								}
 								if (start) {
-									context[color] = str => `${start}${str}\u001b[39m\u001b[22m`;
+									context[color] = str =>
+										`${start}${
+											typeof str === "string"
+												? str.replace(
+														/((\u001b\[39m|\u001b\[22m|\u001b\[0m)+)/g,
+														`$1${start}`
+												  )
+												: str
+										}\u001b[39m\u001b[22m`;
 								} else {
 									context[color] = str => str;
 								}

package/lib/stats/StatsPrinter.js

@@ -9,6 +9,12 @@ const { HookMap, SyncWaterfallHook, SyncBailHook } = require("tapable");
 
 /** @template T @typedef {import("tapable").AsArray<T>} AsArray<T> */
 /** @typedef {import("tapable").Hook} Hook */
+/** @typedef {import("./DefaultStatsFactoryPlugin").StatsAsset} StatsAsset */
+/** @typedef {import("./DefaultStatsFactoryPlugin").StatsChunk} StatsChunk */
+/** @typedef {import("./DefaultStatsFactoryPlugin").StatsChunkGroup} StatsChunkGroup */
+/** @typedef {import("./DefaultStatsFactoryPlugin").StatsCompilation} StatsCompilation */
+/** @typedef {import("./DefaultStatsFactoryPlugin").StatsModule} StatsModule */
+/** @typedef {import("./DefaultStatsFactoryPlugin").StatsModuleReason} StatsModuleReason */
 
 /**
  * @typedef {Object} PrintedElement
@@ -19,12 +25,12 @@ const { HookMap, SyncWaterfallHook, SyncBailHook } = require("tapable");
 /**
  * @typedef {Object} KnownStatsPrinterContext
  * @property {string=} type
- * @property {Object=} compilation
- * @property {Object=} chunkGroup
- * @property {Object=} asset
- * @property {Object=} module
- * @property {Object=} chunk
- * @property {Object=} moduleReason
+ * @property {StatsCompilation=} compilation
+ * @property {StatsChunkGroup=} chunkGroup
+ * @property {StatsAsset=} asset
+ * @property {StatsModule=} module
+ * @property {StatsChunk=} chunk
+ * @property {StatsModuleReason=} moduleReason
  * @property {(str: string) => string=} bold
  * @property {(str: string) => string=} yellow
  * @property {(str: string) => string=} red

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "webpack",
-  "version": "5.20.1",
+  "version": "5.21.2",
   "author": "Tobias Koppers @sokra",
   "description": "Packs CommonJs/AMD modules for the browser. Allows to split your codebase into multiple bundles, which can be loaded on demand. Support loaders to preprocess files, i.e. json, jsx, es7, css, less, ... and your custom stuff.",
   "license": "MIT",

package/schemas/WebpackOptions.json

@@ -3882,7 +3882,14 @@
         },
         "errorDetails": {
           "description": "Add details to errors (like resolving log).",
-          "type": "boolean"
+          "anyOf": [
+            {
+              "enum": ["auto"]
+            },
+            {
+              "type": "boolean"
+            }
+          ]
         },
         "errorStack": {
           "description": "Add internal stack trace to errors.",

package/types.d.ts

@@ -3796,6 +3796,11 @@ declare interface GenerateContext {
 	 * which kind of code should be generated
 	 */
 	type: string;
+
+	/**
+	 * get access to the code generation data
+	 */
+	getData?: () => Map<string, any>;
 }
 declare class Generator {
 	constructor();
@@ -5053,6 +5058,108 @@ declare interface KnownNormalizedStatsOptions {
 	loggingDebug: Function[];
 	loggingTrace: boolean;
 }
+declare interface KnownStatsAsset {
+	type: string;
+	name: string;
+	info: AssetInfo;
+	size: number;
+	emitted: boolean;
+	comparedForEmit: boolean;
+	cached: boolean;
+	related?: StatsAsset[];
+	chunkNames?: (string | number)[];
+	chunkIdHints?: (string | number)[];
+	chunks?: (string | number)[];
+	auxiliaryChunkNames?: (string | number)[];
+	auxiliaryChunks?: (string | number)[];
+	auxiliaryChunkIdHints?: (string | number)[];
+	filteredRelated?: number;
+	isOverSizeLimit?: boolean;
+}
+declare interface KnownStatsChunk {
+	rendered: boolean;
+	initial: boolean;
+	entry: boolean;
+	recorded: boolean;
+	reason?: string;
+	size: number;
+	sizes?: Record<string, number>;
+	names?: string[];
+	idHints?: string[];
+	runtime?: string[];
+	files?: string[];
+	auxiliaryFiles?: string[];
+	hash: string;
+	childrenByOrder?: Record<string, (string | number)[]>;
+	id?: string | number;
+	siblings?: (string | number)[];
+	parents?: (string | number)[];
+	children?: (string | number)[];
+	modules?: StatsModule[];
+	filteredModules?: number;
+	origins?: StatsChunkOrigin[];
+}
+declare interface KnownStatsChunkGroup {
+	name?: string;
+	chunks?: (string | number)[];
+	assets?: { name: string; size?: number }[];
+	filteredAssets?: number;
+	assetsSize?: number;
+	auxiliaryAssets?: { name: string; size?: number }[];
+	filteredAuxiliaryAssets?: number;
+	auxiliaryAssetsSize?: number;
+	children?: { [index: string]: StatsChunkGroup[] };
+	childAssets?: { [index: string]: string[] };
+	isOverSizeLimit?: boolean;
+}
+declare interface KnownStatsChunkOrigin {
+	module?: string;
+	moduleIdentifier?: string;
+	moduleName?: string;
+	loc?: string;
+	request?: string;
+	moduleId?: string | number;
+}
+declare interface KnownStatsCompilation {
+	env?: any;
+	name?: string;
+	hash?: string;
+	version?: string;
+	time?: number;
+	builtAt?: number;
+	needAdditionalPass?: boolean;
+	publicPath?: string;
+	outputPath?: string;
+	assetsByChunkName?: Record<string, string[]>;
+	assets?: StatsAsset[];
+	filteredAssets?: number;
+	chunks?: StatsChunk[];
+	modules?: StatsModule[];
+	filteredModules?: number;
+	entrypoints?: Record<string, StatsChunkGroup>;
+	namedChunkGroups?: Record<string, StatsChunkGroup>;
+	errors?: StatsError[];
+	errorsCount?: number;
+	warnings?: StatsError[];
+	warningsCount?: number;
+	children?: StatsCompilation[];
+	logging?: Record<string, StatsLogging>;
+}
+declare interface KnownStatsError {
+	message: string;
+	chunkName?: string;
+	chunkEntry?: boolean;
+	chunkInitial?: boolean;
+	file?: string;
+	moduleIdentifier?: string;
+	moduleName?: string;
+	loc?: string;
+	chunkId?: string | number;
+	moduleId?: string | number;
+	moduleTrace?: any;
+	details?: any;
+	stack?: any;
+}
 declare interface KnownStatsFactoryContext {
 	type: string;
 	makePathsRelative?: (arg0: string) => string;
@@ -5064,14 +5171,87 @@ declare interface KnownStatsFactoryContext {
 	cachedGetErrors?: (arg0: Compilation) => WebpackError[];
 	cachedGetWarnings?: (arg0: Compilation) => WebpackError[];
 }
+declare interface KnownStatsLogging {
+	entries: StatsLoggingEntry[];
+	filteredEntries: number;
+	debug: boolean;
+}
+declare interface KnownStatsLoggingEntry {
+	type: string;
+	message: string;
+	trace?: string[];
+	children?: StatsLoggingEntry[];
+	args?: any[];
+	time?: number;
+}
+declare interface KnownStatsModule {
+	type?: string;
+	moduleType?: string;
+	layer?: string;
+	identifier?: string;
+	name?: string;
+	nameForCondition?: string;
+	index?: number;
+	preOrderIndex?: number;
+	index2?: number;
+	postOrderIndex?: number;
+	size?: number;
+	sizes?: { [index: string]: number };
+	cacheable?: boolean;
+	built?: boolean;
+	codeGenerated?: boolean;
+	cached?: boolean;
+	optional?: boolean;
+	orphan?: boolean;
+	id?: string | number;
+	issuerId?: string | number;
+	chunks?: (string | number)[];
+	assets?: (string | number)[];
+	dependent?: boolean;
+	issuer?: string;
+	issuerName?: string;
+	issuerPath?: StatsModuleIssuer[];
+	failed?: boolean;
+	errors?: number;
+	warnings?: number;
+	profile?: StatsProfile;
+	reasons?: StatsModuleReason[];
+	usedExports?: boolean | string[];
+	providedExports?: string[];
+	optimizationBailout?: string[];
+	depth?: number;
+	modules?: StatsModule[];
+	filteredModules?: number;
+	source?: string | Buffer;
+}
+declare interface KnownStatsModuleIssuer {
+	identifier?: string;
+	name?: string;
+	id?: string | number;
+	profile?: StatsProfile;
+}
+declare interface KnownStatsModuleReason {
+	moduleIdentifier?: string;
+	module?: string;
+	moduleName?: string;
+	resolvedModuleIdentifier?: string;
+	resolvedModule?: string;
+	type?: string;
+	active: boolean;
+	explanation?: string;
+	userRequest?: string;
+	loc?: string;
+	moduleId?: string | number;
+	resolvedModuleId?: string | number;
+}
 declare interface KnownStatsPrinterContext {
 	type?: string;
-	compilation?: Object;
-	chunkGroup?: Object;
-	asset?: Object;
-	module?: Object;
-	chunk?: Object;
-	moduleReason?: Object;
+	compilation?: StatsCompilation;
+	chunkGroup?: StatsChunkGroup;
+	asset?: StatsAsset;
+	module?: StatsModule;
+	chunk?: StatsChunk;
+	moduleReason?: StatsModuleReason;
 	bold?: (str: string) => string;
 	yellow?: (str: string) => string;
 	red?: (str: string) => string;
@@ -5090,6 +5270,18 @@ declare interface KnownStatsPrinterContext {
 	formatTime?: (time: number, boldQuantity?: boolean) => string;
 	chunkGroupKind?: string;
 }
+declare interface KnownStatsProfile {
+	total: number;
+	resolving: number;
+	restoring: number;
+	building: number;
+	integration: number;
+	storing: number;
+	additionalResolving: number;
+	additionalIntegration: number;
+	factory: number;
+	dependencies: number;
+}
 declare class LazySet<T> {
 	constructor(iterable?: Iterable<T>);
 	readonly size: number;
@@ -6081,17 +6273,7 @@ declare abstract class MultiStats {
 	readonly hash: string;
 	hasErrors(): boolean;
 	hasWarnings(): boolean;
-	toJson(
-		options?: any
-	): {
-		children: any[];
-		version: any;
-		hash: string;
-		errors: any[];
-		warnings: any[];
-		errorsCount: number;
-		warningsCount: number;
-	};
+	toJson(options?: any): StatsCompilation;
 	toString(options?: any): string;
 }
 declare abstract class MultiWatching {
@@ -9708,9 +9890,15 @@ declare class Stats {
 	readonly endTime: any;
 	hasWarnings(): boolean;
 	hasErrors(): boolean;
-	toJson(options?: any): any;
+	toJson(options?: string | StatsOptions): StatsCompilation;
 	toString(options?: any): string;
 }
+type StatsAsset = KnownStatsAsset & Record<string, any>;
+type StatsChunk = KnownStatsChunk & Record<string, any>;
+type StatsChunkGroup = KnownStatsChunkGroup & Record<string, any>;
+type StatsChunkOrigin = KnownStatsChunkOrigin & Record<string, any>;
+type StatsCompilation = KnownStatsCompilation & Record<string, any>;
+type StatsError = KnownStatsError & Record<string, any>;
 declare abstract class StatsFactory {
 	hooks: Readonly<{
 		extract: HookMap<SyncBailHook<[Object, any, StatsFactoryContext], any>>;
@@ -9750,6 +9938,11 @@ declare abstract class StatsFactory {
 	): any;
 }
 type StatsFactoryContext = KnownStatsFactoryContext & Record<string, any>;
+type StatsLogging = KnownStatsLogging & Record<string, any>;
+type StatsLoggingEntry = KnownStatsLoggingEntry & Record<string, any>;
+type StatsModule = KnownStatsModule & Record<string, any>;
+type StatsModuleIssuer = KnownStatsModuleIssuer & Record<string, any>;
+type StatsModuleReason = KnownStatsModuleReason & Record<string, any>;
 
 /**
  * Stats options object.
@@ -9910,7 +10103,7 @@ declare interface StatsOptions {
 	/**
 	 * Add details to errors (like resolving log).
 	 */
-	errorDetails?: boolean;
+	errorDetails?: boolean | "auto";
 
 	/**
 	 * Add internal stack trace to errors.
@@ -10180,6 +10373,7 @@ declare abstract class StatsPrinter {
 	print(type: string, object: Object, baseContext?: Object): string;
 }
 type StatsPrinterContext = KnownStatsPrinterContext & Record<string, any>;
+type StatsProfile = KnownStatsProfile & Record<string, any>;
 type StatsValue =
 	| boolean
 	| "none"
@@ -11259,7 +11453,8 @@ declare namespace exports {
 		WebpackPluginInstance,
 		Asset,
 		AssetInfo,
-		ParserState
+		ParserState,
+		StatsCompilation
 	};
 }