webpack 5.54.0 → 5.56.1

package/lib/util/WeakTupleMap.js

@@ -7,87 +7,20 @@
 
 const isWeakKey = thing => typeof thing === "object" && thing !== null;
 
-class WeakTupleNode {
-	constructor() {
-		this.f = 0;
-		/** @type {any} */
-		this.v = undefined;
-		/** @type {Map<object, WeakTupleNode> | undefined} */
-		this.m = undefined;
-		/** @type {WeakMap<object, WeakTupleNode> | undefined} */
-		this.w = undefined;
-	}
-
-	getValue() {
-		return this.v;
-	}
-
-	hasValue() {
-		return (this.f & 1) === 1;
-	}
-
-	setValue(v) {
-		this.f |= 1;
-		this.v = v;
-	}
-
-	deleteValue() {
-		this.f &= 6;
-		this.v = undefined;
-	}
-
-	peek(thing) {
-		if (isWeakKey(thing)) {
-			if ((this.f & 4) !== 4) return undefined;
-			return this.w.get(thing);
-		} else {
-			if ((this.f & 2) !== 2) return undefined;
-			return this.m.get(thing);
-		}
-	}
-
-	get(thing) {
-		if (isWeakKey(thing)) {
-			if ((this.f & 4) !== 4) {
-				const newMap = new WeakMap();
-				this.f |= 4;
-				const newNode = new WeakTupleNode();
-				(this.w = newMap).set(thing, newNode);
-				return newNode;
-			}
-			const entry = this.w.get(thing);
-			if (entry !== undefined) {
-				return entry;
-			}
-			const newNode = new WeakTupleNode();
-			this.w.set(thing, newNode);
-			return newNode;
-		} else {
-			if ((this.f & 2) !== 2) {
-				const newMap = new Map();
-				this.f |= 2;
-				const newNode = new WeakTupleNode();
-				(this.m = newMap).set(thing, newNode);
-				return newNode;
-			}
-			const entry = this.m.get(thing);
-			if (entry !== undefined) {
-				return entry;
-			}
-			const newNode = new WeakTupleNode();
-			this.m.set(thing, newNode);
-			return newNode;
-		}
-	}
-}
-
 /**
  * @template {any[]} T
  * @template V
  */
 class WeakTupleMap {
 	constructor() {
-		this._node = new WeakTupleNode();
+		/** @private */
+		this.f = 0;
+		/** @private @type {any} */
+		this.v = undefined;
+		/** @private @type {Map<object, WeakTupleMap<T, V>> | undefined} */
+		this.m = undefined;
+		/** @private @type {WeakMap<object, WeakTupleMap<T, V>> | undefined} */
+		this.w = undefined;
 	}
 
 	/**
@@ -95,11 +28,12 @@ class WeakTupleMap {
 	 * @returns {void}
 	 */
 	set(...args) {
-		let node = this._node;
+		/** @type {WeakTupleMap<T, V>} */
+		let node = this;
 		for (let i = 0; i < args.length - 1; i++) {
-			node = node.get(args[i]);
+			node = node._get(args[i]);
 		}
-		node.setValue(args[args.length - 1]);
+		node._setValue(args[args.length - 1]);
 	}
 
 	/**
@@ -107,12 +41,13 @@ class WeakTupleMap {
 	 * @returns {boolean} true, if the tuple is in the Set
 	 */
 	has(...args) {
-		let node = this._node;
+		/** @type {WeakTupleMap<T, V>} */
+		let node = this;
 		for (let i = 0; i < args.length; i++) {
-			node = node.peek(args[i]);
+			node = node._peek(args[i]);
 			if (node === undefined) return false;
 		}
-		return node.hasValue();
+		return node._hasValue();
 	}
 
 	/**
@@ -120,12 +55,13 @@ class WeakTupleMap {
 	 * @returns {V} the value
 	 */
 	get(...args) {
-		let node = this._node;
+		/** @type {WeakTupleMap<T, V>} */
+		let node = this;
 		for (let i = 0; i < args.length; i++) {
-			node = node.peek(args[i]);
+			node = node._peek(args[i]);
 			if (node === undefined) return undefined;
 		}
-		return node.getValue();
+		return node._getValue();
 	}
 
 	/**
@@ -133,14 +69,15 @@ class WeakTupleMap {
 	 * @returns {V} the value
 	 */
 	provide(...args) {
-		let node = this._node;
+		/** @type {WeakTupleMap<T, V>} */
+		let node = this;
 		for (let i = 0; i < args.length - 1; i++) {
-			node = node.get(args[i]);
+			node = node._get(args[i]);
 		}
-		if (node.hasValue()) return node.getValue();
+		if (node._hasValue()) return node._getValue();
 		const fn = args[args.length - 1];
 		const newValue = fn(...args.slice(0, -1));
-		node.setValue(newValue);
+		node._setValue(newValue);
 		return newValue;
 	}
 
@@ -149,19 +86,85 @@ class WeakTupleMap {
 	 * @returns {void}
 	 */
 	delete(...args) {
-		let node = this._node;
+		/** @type {WeakTupleMap<T, V>} */
+		let node = this;
 		for (let i = 0; i < args.length; i++) {
-			node = node.peek(args[i]);
+			node = node._peek(args[i]);
 			if (node === undefined) return;
 		}
-		node.deleteValue();
+		node._deleteValue();
 	}
 
 	/**
 	 * @returns {void}
 	 */
 	clear() {
-		this._node = new WeakTupleNode();
+		this.f = 0;
+		this.v = undefined;
+		this.w = undefined;
+		this.m = undefined;
+	}
+
+	_getValue() {
+		return this.v;
+	}
+
+	_hasValue() {
+		return (this.f & 1) === 1;
+	}
+
+	_setValue(v) {
+		this.f |= 1;
+		this.v = v;
+	}
+
+	_deleteValue() {
+		this.f &= 6;
+		this.v = undefined;
+	}
+
+	_peek(thing) {
+		if (isWeakKey(thing)) {
+			if ((this.f & 4) !== 4) return undefined;
+			return this.w.get(thing);
+		} else {
+			if ((this.f & 2) !== 2) return undefined;
+			return this.m.get(thing);
+		}
+	}
+
+	_get(thing) {
+		if (isWeakKey(thing)) {
+			if ((this.f & 4) !== 4) {
+				const newMap = new WeakMap();
+				this.f |= 4;
+				const newNode = new WeakTupleMap();
+				(this.w = newMap).set(thing, newNode);
+				return newNode;
+			}
+			const entry = this.w.get(thing);
+			if (entry !== undefined) {
+				return entry;
+			}
+			const newNode = new WeakTupleMap();
+			this.w.set(thing, newNode);
+			return newNode;
+		} else {
+			if ((this.f & 2) !== 2) {
+				const newMap = new Map();
+				this.f |= 2;
+				const newNode = new WeakTupleMap();
+				(this.m = newMap).set(thing, newNode);
+				return newNode;
+			}
+			const entry = this.m.get(thing);
+			if (entry !== undefined) {
+				return entry;
+			}
+			const newNode = new WeakTupleMap();
+			this.m.set(thing, newNode);
+			return newNode;
+		}
 	}
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "webpack",
-  "version": "5.54.0",
+  "version": "5.56.1",
   "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/types.d.ts

@@ -1299,7 +1299,7 @@ declare class Compilation {
 	/**
 	 * Creates an instance of Compilation.
 	 */
-	constructor(compiler: Compiler);
+	constructor(compiler: Compiler, params: CompilationParams);
 	hooks: Readonly<{
 		buildModule: SyncHook<[Module]>;
 		rebuildModule: SyncHook<[Module]>;
@@ -1455,18 +1455,22 @@ declare class Compilation {
 	outputOptions: OutputNormalized;
 	bail: boolean;
 	profile: boolean;
+	params: CompilationParams;
 	mainTemplate: MainTemplate;
 	chunkTemplate: ChunkTemplate;
 	runtimeTemplate: RuntimeTemplate;
 	moduleTemplates: { javascript: ModuleTemplate };
-	memCache?: MemCache;
-	moduleMemCaches?: WeakMap<Module, MemCache>;
+	moduleMemCaches?: WeakMap<Module, WeakTupleMap<any, any>>;
 	moduleGraph: ModuleGraph;
 	chunkGraph: ChunkGraph;
 	codeGenerationResults: CodeGenerationResults;
 	processDependenciesQueue: AsyncQueue<Module, Module, Module>;
 	addModuleQueue: AsyncQueue<Module, string, Module>;
-	factorizeQueue: AsyncQueue<FactorizeModuleOptions, string, Module>;
+	factorizeQueue: AsyncQueue<
+		FactorizeModuleOptions,
+		string,
+		Module | ModuleFactoryResult
+	>;
 	buildQueue: AsyncQueue<Module, Module, Module>;
 	rebuildQueue: AsyncQueue<Module, Module, Module>;
 
@@ -1549,10 +1553,6 @@ declare class Compilation {
 		__0: HandleModuleCreationOptions,
 		callback: (err?: WebpackError, result?: Module) => void
 	): void;
-	factorizeModule(
-		options: FactorizeModuleOptions,
-		callback: (err?: WebpackError, result?: Module) => void
-	): void;
 	addModuleChain(
 		context: string,
 		dependency: Dependency,
@@ -1719,6 +1719,16 @@ declare class Compilation {
 		callback: (err?: WebpackError, result?: ExecuteModuleResult) => void
 	): void;
 	checkConstraints(): void;
+	factorizeModule: {
+		(
+			options: FactorizeModuleOptions & { factoryResult?: false },
+			callback: (err?: WebpackError, result?: Module) => void
+		): void;
+		(
+			options: FactorizeModuleOptions & { factoryResult: true },
+			callback: (err?: WebpackError, result?: ModuleFactoryResult) => void
+		): void;
+	};
 
 	/**
 	 * Add additional assets to the compilation.
@@ -1897,7 +1907,14 @@ declare class Compiler {
 	context: string;
 	requestShortener: RequestShortener;
 	cache: Cache;
-	moduleMemCaches?: WeakMap<Module, { hash: string; memCache: MemCache }>;
+	moduleMemCaches?: WeakMap<
+		Module,
+		{
+			hash: string;
+			references: WeakMap<Dependency, Module>;
+			memCache: WeakTupleMap<any, any>;
+		}
+	>;
 	compilerPath: string;
 	running: boolean;
 	idle: boolean;
@@ -1921,7 +1938,7 @@ declare class Compiler {
 		plugins?: WebpackPluginInstance[]
 	): Compiler;
 	isChild(): boolean;
-	createCompilation(): Compilation;
+	createCompilation(params?: any): Compilation;
 	newCompilation(params: CompilationParams): Compilation;
 	createNormalModuleFactory(): NormalModuleFactory;
 	createContextModuleFactory(): ContextModuleFactory;
@@ -2241,6 +2258,7 @@ declare class ConstDependency extends NullDependency {
 	static Template: typeof ConstDependencyTemplate;
 	static NO_EXPORTS_REFERENCED: string[][];
 	static EXPORTS_OBJECT_REFERENCED: string[][];
+	static TRANSITIVE: typeof TRANSITIVE;
 }
 declare class ConstDependencyTemplate extends NullDependencyTemplate {
 	constructor();
@@ -2554,6 +2572,7 @@ declare class Dependency {
 	readonly category: string;
 	loc: DependencyLocation;
 	getResourceIdentifier(): null | string;
+	couldAffectReferencingModule(): boolean | typeof TRANSITIVE;
 
 	/**
 	 * Returns the referenced module and export
@@ -2608,6 +2627,7 @@ declare class Dependency {
 	readonly disconnect: any;
 	static NO_EXPORTS_REFERENCED: string[][];
 	static EXPORTS_OBJECT_REFERENCED: string[][];
+	static TRANSITIVE: typeof TRANSITIVE;
 }
 declare interface DependencyConstructor {
 	new (...args: any[]): Dependency;
@@ -3819,6 +3839,11 @@ declare interface FactorizeModuleOptions {
 	currentProfile: ModuleProfile;
 	factory: ModuleFactory;
 	dependencies: Dependency[];
+
+	/**
+	 * return full ModuleFactoryResult instead of only module
+	 */
+	factoryResult?: boolean;
 	originModule: null | Module;
 	contextInfo?: Partial<ModuleFactoryCreateDataContextInfo>;
 	context?: string;
@@ -6313,11 +6338,6 @@ declare interface MapOptions {
 	columns?: boolean;
 	module?: boolean;
 }
-declare abstract class MemCache {
-	get<T extends any[], V>(...args: T): undefined | V;
-	set<T extends [any, ...any[]]>(...args: T): void;
-	provide<T extends [any, ...((...args: any[]) => V)[]], V>(...args: T): V;
-}
 
 /**
  * Options object for in-memory caching.
@@ -6524,6 +6544,7 @@ declare class ModuleDependency extends Dependency {
 	static Template: typeof DependencyTemplate;
 	static NO_EXPORTS_REFERENCED: string[][];
 	static EXPORTS_OBJECT_REFERENCED: string[][];
+	static TRANSITIVE: typeof TRANSITIVE;
 }
 declare abstract class ModuleFactory {
 	create(
@@ -6550,6 +6571,11 @@ declare interface ModuleFactoryResult {
 	fileDependencies?: Set<string>;
 	contextDependencies?: Set<string>;
 	missingDependencies?: Set<string>;
+
+	/**
+	 * allow to use the unsafe cache
+	 */
+	cacheable?: boolean;
 }
 declare class ModuleFederationPlugin {
 	constructor(options: ModuleFederationPluginOptions);
@@ -6707,12 +6733,16 @@ declare class ModuleGraph {
 	setAsync(module: Module): void;
 	getMeta(thing?: any): Object;
 	getMetaIfExisting(thing?: any): Object;
-	freeze(): void;
+	freeze(cacheStage?: string): void;
 	unfreeze(): void;
 	cached<T extends any[], V>(
 		fn: (moduleGraph: ModuleGraph, ...args: T) => V,
 		...args: T
 	): V;
+	setModuleMemCaches(
+		moduleMemCaches: WeakMap<Module, WeakTupleMap<any, any>>
+	): void;
+	dependencyCacheProvide(dependency: Dependency, ...args: any[]): any;
 	static getModuleGraphForModule(
 		module: Module,
 		deprecateMessage: string,
@@ -7366,8 +7396,6 @@ declare abstract class NormalModuleFactory extends ModuleFactory {
 	}>;
 	resolverFactory: ResolverFactory;
 	ruleSet: RuleSet;
-	unsafeCache: boolean;
-	cachePredicate: Function;
 	context: string;
 	fs: InputFileSystem;
 	parserCache: Map<string, WeakMap<Object, any>>;
@@ -7511,6 +7539,7 @@ declare class NullDependency extends Dependency {
 	static Template: typeof NullDependencyTemplate;
 	static NO_EXPORTS_REFERENCED: string[][];
 	static EXPORTS_OBJECT_REFERENCED: string[][];
+	static TRANSITIVE: typeof TRANSITIVE;
 }
 declare class NullDependencyTemplate extends DependencyTemplate {
 	constructor();
@@ -11283,6 +11312,7 @@ declare interface SyntheticDependencyLocation {
 	index?: number;
 }
 declare const TOMBSTONE: unique symbol;
+declare const TRANSITIVE: unique symbol;
 declare const TRANSITIVE_ONLY: unique symbol;
 declare interface TagInfo {
 	tag: any;
@@ -11647,6 +11677,14 @@ declare abstract class Watching {
 	resume(): void;
 	close(callback: CallbackFunction<void>): void;
 }
+declare abstract class WeakTupleMap<T extends any[], V> {
+	set(...args: [T, ...V[]]): void;
+	has(...args: T): boolean;
+	get(...args: T): V;
+	provide(...args: [T, ...(() => V)[]]): V;
+	delete(...args: T): void;
+	clear(): void;
+}
 declare interface WebAssemblyRenderContext {
 	/**
 	 * the chunk

package/lib/MemCache.js

@@ -1,45 +0,0 @@
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-"use strict";
-
-const WeakTupleMap = require("./util/WeakTupleMap");
-
-class MemCache {
-	constructor() {
-		this._cache = new WeakTupleMap();
-	}
-
-	/**
-	 * @template {any[]} T
-	 * @template V
-	 * @param {T} args arguments
-	 * @returns {V | undefined} cached value
-	 */
-	get(...args) {
-		return this._cache.get(...args);
-	}
-
-	/**
-	 * @template {[...any[], any]} T
-	 * @param {T} args arguments
-	 * @returns {void}
-	 */
-	set(...args) {
-		this._cache.set(...args);
-	}
-
-	/**
-	 * @template {[...any[], (...args: any[]) => V]} T
-	 * @template V
-	 * @param {T} args arguments
-	 * @returns {V} computed value or cached
-	 */
-	provide(...args) {
-		return this._cache.provide(...args);
-	}
-}
-
-module.exports = MemCache;