webpack 5.18.0 → 5.20.2

package/types.d.ts

@@ -1025,6 +1025,48 @@ declare abstract class ChunkTemplate {
 	}>;
 	readonly outputOptions: Output;
 }
+
+/**
+ * Advanced options for cleaning assets.
+ */
+declare interface CleanOptions {
+	/**
+	 * Log the assets that should be removed instead of deleting them.
+	 */
+	dry?: boolean;
+
+	/**
+	 * Keep these assets.
+	 */
+	keep?: string | RegExp | ((filename: string) => boolean);
+}
+declare class CleanPlugin {
+	constructor(options?: CleanOptions);
+	options: {
+		/**
+		 * Log the assets that should be removed instead of deleting them.
+		 */
+		dry: boolean;
+		/**
+		 * Keep these assets.
+		 */
+		keep?: string | RegExp | ((filename: string) => boolean);
+	};
+
+	/**
+	 * Apply the plugin
+	 */
+	apply(compiler: Compiler): void;
+	static getCompilationHooks(
+		compilation: Compilation
+	): CleanPluginCompilationHooks;
+}
+declare interface CleanPluginCompilationHooks {
+	/**
+	 * when returning true the file/directory will be kept during cleaning, returning false will clean it and ignore the following plugins and config
+	 */
+	keep: SyncBailHook<[string], boolean>;
+}
 declare interface CodeGenerationContext {
 	/**
 	 * the dependency templates
@@ -1079,7 +1121,6 @@ declare interface CodeGenerationResult {
 }
 declare abstract class CodeGenerationResults {
 	map: Map<Module, RuntimeSpecMap<CodeGenerationResult>>;
-	hashes: Map<Module, RuntimeSpecMap<string>>;
 	get(module: Module, runtime: RuntimeSpec): CodeGenerationResult;
 	has(module: Module, runtime: RuntimeSpec): boolean;
 	getSource(module: Module, runtime: RuntimeSpec, sourceType: string): Source;
@@ -1284,11 +1325,11 @@ declare class Compilation {
 	moduleGraph: ModuleGraph;
 	chunkGraph?: ChunkGraph;
 	codeGenerationResults: CodeGenerationResults;
-	factorizeQueue: AsyncQueue<FactorizeModuleOptions, string, Module>;
+	processDependenciesQueue: AsyncQueue<Module, Module, Module>;
 	addModuleQueue: AsyncQueue<Module, string, Module>;
+	factorizeQueue: AsyncQueue<FactorizeModuleOptions, string, Module>;
 	buildQueue: AsyncQueue<Module, Module, Module>;
 	rebuildQueue: AsyncQueue<Module, Module, Module>;
-	processDependenciesQueue: AsyncQueue<Module, Module, Module>;
 
 	/**
 	 * Modules in value are building during the build of Module in key.
@@ -2298,7 +2339,10 @@ declare class Dependency {
 	): (string[] | ReferencedExport)[];
 	getCondition(
 		moduleGraph: ModuleGraph
-	): (arg0: ModuleGraphConnection, arg1: RuntimeSpec) => ConnectionState;
+	):
+		| null
+		| false
+		| ((arg0: ModuleGraphConnection, arg1: RuntimeSpec) => ConnectionState);
 
 	/**
 	 * Returns the exported names
@@ -3000,6 +3044,14 @@ declare interface Experiments {
 				 * Enable/disable lazy compilation for entries.
 				 */
 				entries?: boolean;
+				/**
+				 * Enable/disable lazy compilation for import() modules.
+				 */
+				imports?: boolean;
+				/**
+				 * Specify which entrypoints or import()ed modules should be lazily compiled. This is matched with the imported module and not the entrypoint name.
+				 */
+				test?: string | RegExp | ((module: Module) => boolean);
 		  };
 
 	/**
@@ -3249,6 +3301,11 @@ declare interface ExposesConfig {
 	 * Request to a module that should be exposed by this container.
 	 */
 	import: string | string[];
+
+	/**
+	 * Custom chunk name for the exposed module.
+	 */
+	name?: string;
 }
 
 /**
@@ -3739,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();
@@ -5713,6 +5775,7 @@ declare class ModuleGraph {
 	isAsync(module: Module): boolean;
 	setAsync(module: Module): void;
 	getMeta(thing?: any): Object;
+	getMetaIfExisting(thing?: any): Object;
 	static getModuleGraphForModule(
 		module: Module,
 		deprecateMessage: string,
@@ -5731,10 +5794,9 @@ declare class ModuleGraphConnection {
 		module: Module,
 		explanation?: string,
 		weak?: boolean,
-		condition?: (
-			arg0: ModuleGraphConnection,
-			arg1: RuntimeSpec
-		) => ConnectionState
+		condition?:
+			| false
+			| ((arg0: ModuleGraphConnection, arg1: RuntimeSpec) => ConnectionState)
 	);
 	originModule?: Module;
 	resolvedOriginModule?: Module;
@@ -5912,33 +5974,40 @@ declare interface ModulePathData {
 }
 declare abstract class ModuleProfile {
 	startTime: number;
+	factoryStartTime: number;
+	factoryEndTime: number;
 	factory: number;
+	factoryParallelismFactor: number;
+	restoringStartTime: number;
+	restoringEndTime: number;
 	restoring: number;
+	restoringParallelismFactor: number;
+	integrationStartTime: number;
+	integrationEndTime: number;
 	integration: number;
+	integrationParallelismFactor: number;
+	buildingStartTime: number;
+	buildingEndTime: number;
 	building: number;
+	buildingParallelismFactor: number;
+	storingStartTime: number;
+	storingEndTime: number;
 	storing: number;
+	storingParallelismFactor: number;
+	additionalFactoryTimes: any;
 	additionalFactories: number;
+	additionalFactoriesParallelismFactor: number;
 	additionalIntegration: number;
 	markFactoryStart(): void;
-	factoryStartTime?: number;
 	markFactoryEnd(): void;
-	factoryEndTime?: number;
 	markRestoringStart(): void;
-	restoringStartTime?: number;
 	markRestoringEnd(): void;
-	restoringEndTime?: number;
 	markIntegrationStart(): void;
-	integrationStartTime?: number;
 	markIntegrationEnd(): void;
-	integrationEndTime?: number;
 	markBuildingStart(): void;
-	buildingStartTime?: number;
 	markBuildingEnd(): void;
-	buildingEndTime?: number;
 	markStoringStart(): void;
-	storingStartTime?: number;
 	markStoringEnd(): void;
-	storingEndTime?: number;
 
 	/**
 	 * Merge this profile into another one
@@ -6838,6 +6907,11 @@ declare interface Output {
 	 */
 	chunkLoadingGlobal?: string;
 
+	/**
+	 * Clean the output directory before emit.
+	 */
+	clean?: boolean | CleanOptions;
+
 	/**
 	 * Check if to be emitted file already exists and have the same content before writing to output filesystem.
 	 */
@@ -7035,6 +7109,15 @@ declare interface OutputFileSystem {
 		arg2: (arg0?: NodeJS.ErrnoException) => void
 	) => void;
 	mkdir: (arg0: string, arg1: (arg0?: NodeJS.ErrnoException) => void) => void;
+	readdir?: (
+		arg0: string,
+		arg1: (
+			arg0?: NodeJS.ErrnoException,
+			arg1?: (string | Buffer)[] | IDirent[]
+		) => void
+	) => void;
+	rmdir?: (arg0: string, arg1: (arg0?: NodeJS.ErrnoException) => void) => void;
+	unlink?: (arg0: string, arg1: (arg0?: NodeJS.ErrnoException) => void) => void;
 	stat: (
 		arg0: string,
 		arg1: (arg0?: NodeJS.ErrnoException, arg1?: IStats) => void
@@ -7091,6 +7174,11 @@ declare interface OutputNormalized {
 	 */
 	chunkLoadingGlobal?: string;
 
+	/**
+	 * Clean the output directory before emit.
+	 */
+	clean?: boolean | CleanOptions;
+
 	/**
 	 * Check if to be emitted file already exists and have the same content before writing to output filesystem.
 	 */
@@ -7461,7 +7549,7 @@ declare interface ProfilingPluginOptions {
 	outputPath?: string;
 }
 declare class ProgressPlugin {
-	constructor(options: ProgressPluginArgument);
+	constructor(options?: ProgressPluginArgument);
 	profile?: null | boolean;
 	handler?: (percentage: number, msg: string, ...args: string[]) => void;
 	modulesCount?: number;
@@ -8754,6 +8842,7 @@ declare abstract class RuntimeSpecMap<T> {
 	update(runtime?: any, fn?: any): void;
 	keys(): RuntimeSpec[];
 	values(): IterableIterator<T>;
+	readonly size?: number;
 }
 declare abstract class RuntimeSpecSet {
 	add(runtime?: any): void;
@@ -10894,6 +10983,7 @@ declare namespace exports {
 		export let hasOwnProperty: string;
 		export let systemContext: string;
 		export let baseURI: string;
+		export let asyncModule: string;
 	}
 	export const UsageState: Readonly<{
 		Unused: 0;
@@ -11110,6 +11200,7 @@ declare namespace exports {
 		Cache,
 		Chunk,
 		ChunkGraph,
+		CleanPlugin,
 		Compilation,
 		Compiler,
 		ConcatenationScope,
@@ -11159,6 +11250,7 @@ declare namespace exports {
 		WebpackOptionsDefaulter,
 		Entry,
 		EntryNormalized,
+		EntryObject,
 		LibraryOptions,
 		ModuleOptions,
 		ResolveOptionsWebpackOptions as ResolveOptions,