webpack 5.31.2 → 5.33.2

package/lib/util/WeakTupleMap.js

@@ -0,0 +1,168 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+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();
+	}
+
+	/**
+	 * @param {[...T, V]} args tuple
+	 * @returns {void}
+	 */
+	set(...args) {
+		let node = this._node;
+		for (let i = 0; i < args.length - 1; i++) {
+			node = node.get(args[i]);
+		}
+		node.setValue(args[args.length - 1]);
+	}
+
+	/**
+	 * @param {T} args tuple
+	 * @returns {boolean} true, if the tuple is in the Set
+	 */
+	has(...args) {
+		let node = this._node;
+		for (let i = 0; i < args.length; i++) {
+			node = node.peek(args[i]);
+			if (node === undefined) return false;
+		}
+		return node.hasValue();
+	}
+
+	/**
+	 * @param {T} args tuple
+	 * @returns {V} the value
+	 */
+	get(...args) {
+		let node = this._node;
+		for (let i = 0; i < args.length; i++) {
+			node = node.peek(args[i]);
+			if (node === undefined) return undefined;
+		}
+		return node.getValue();
+	}
+
+	/**
+	 * @param {[...T, function(): V]} args tuple
+	 * @returns {V} the value
+	 */
+	provide(...args) {
+		let node = this._node;
+		for (let i = 0; i < args.length - 1; i++) {
+			node = node.get(args[i]);
+		}
+		if (node.hasValue()) return node.getValue();
+		const fn = args[args.length - 1];
+		const newValue = fn(...args.slice(0, -1));
+		node.setValue(newValue);
+		return newValue;
+	}
+
+	/**
+	 * @param {T} args tuple
+	 * @returns {void}
+	 */
+	delete(...args) {
+		let node = this._node;
+		for (let i = 0; i < args.length; i++) {
+			node = node.peek(args[i]);
+			if (node === undefined) return;
+		}
+		node.deleteValue();
+	}
+
+	/**
+	 * @returns {void}
+	 */
+	clear() {
+		this._node = new WeakTupleNode();
+	}
+}
+
+module.exports = WeakTupleMap;

package/lib/util/processAsyncTree.js

@@ -7,10 +7,11 @@
 
 /**
  * @template T
+ * @template {Error} E
  * @param {Iterable<T>} items initial items
  * @param {number} concurrency number of items running in parallel
- * @param {function(T, function(T): void, function(Error=): void): void} processor worker which pushes more items
- * @param {function(Error=): void} callback all items processed
+ * @param {function(T, function(T): void, function(E=): void): void} processor worker which pushes more items
+ * @param {function(E=): void} callback all items processed
  * @returns {void}
  */
 const processAsyncTree = (items, concurrency, processor, callback) => {

package/lib/wasm-sync/WasmChunkLoadingRuntimeModule.js

@@ -200,8 +200,8 @@ class WasmChunkLoadingRuntimeModule extends RuntimeModule {
 	 * @returns {string} runtime code
 	 */
 	generate() {
-		const { compilation, chunk, mangleImports } = this;
-		const { chunkGraph, moduleGraph, outputOptions } = compilation;
+		const { chunkGraph, compilation, chunk, mangleImports } = this;
+		const { moduleGraph, outputOptions } = compilation;
 		const fn = RuntimeGlobals.ensureChunkHandlers;
 		const wasmModules = getAllWasmModules(moduleGraph, chunkGraph, chunk);
 		const declarations = [];

package/lib/web/FetchCompileAsyncWasmPlugin.js

@@ -24,7 +24,9 @@ class FetchCompileAsyncWasmPlugin {
 				const isEnabledForChunk = chunk => {
 					const options = chunk.getEntryOptions();
 					const wasmLoading =
-						(options && options.wasmLoading) || globalWasmLoading;
+						options && options.wasmLoading !== undefined
+							? options.wasmLoading
+							: globalWasmLoading;
 					return wasmLoading === "fetch";
 				};
 				const generateLoadBinaryCode = path =>

package/lib/web/FetchCompileWasmPlugin.js

@@ -30,7 +30,9 @@ class FetchCompileWasmPlugin {
 				const isEnabledForChunk = chunk => {
 					const options = chunk.getEntryOptions();
 					const wasmLoading =
-						(options && options.wasmLoading) || globalWasmLoading;
+						options && options.wasmLoading !== undefined
+							? options.wasmLoading
+							: globalWasmLoading;
 					return wasmLoading === "fetch";
 				};
 				const generateLoadBinaryCode = path =>

package/lib/web/JsonpChunkLoadingPlugin.js

@@ -24,7 +24,9 @@ class JsonpChunkLoadingPlugin {
 				const isEnabledForChunk = chunk => {
 					const options = chunk.getEntryOptions();
 					const chunkLoading =
-						(options && options.chunkLoading) || globalChunkLoading;
+						options && options.chunkLoading !== undefined
+							? options.chunkLoading
+							: globalChunkLoading;
 					return chunkLoading === "jsonp";
 				};
 				const onceForChunkSet = new WeakSet();

package/lib/web/JsonpChunkLoadingRuntimeModule.js

@@ -55,10 +55,9 @@ class JsonpChunkLoadingRuntimeModule extends RuntimeModule {
 	 * @returns {string} runtime code
 	 */
 	generate() {
-		const { compilation, chunk } = this;
+		const { chunkGraph, compilation, chunk } = this;
 		const {
 			runtimeTemplate,
-			chunkGraph,
 			outputOptions: {
 				globalObject,
 				chunkLoadingGlobal,

package/lib/webworker/ImportScriptsChunkLoadingPlugin.js

@@ -29,7 +29,9 @@ class ImportScriptsChunkLoadingPlugin {
 				const isEnabledForChunk = chunk => {
 					const options = chunk.getEntryOptions();
 					const chunkLoading =
-						(options && options.chunkLoading) || globalChunkLoading;
+						options && options.chunkLoading !== undefined
+							? options.chunkLoading
+							: globalChunkLoading;
 					return chunkLoading === "import-scripts";
 				};
 				const onceForChunkSet = new WeakSet();

package/lib/webworker/ImportScriptsChunkLoadingRuntimeModule.js

@@ -27,8 +27,8 @@ class ImportScriptsChunkLoadingRuntimeModule extends RuntimeModule {
 	generate() {
 		const {
 			chunk,
+			chunkGraph,
 			compilation: {
-				chunkGraph,
 				runtimeTemplate,
 				outputOptions: { globalObject, chunkLoadingGlobal, hotUpdateGlobal }
 			}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "webpack",
-  "version": "5.31.2",
+  "version": "5.33.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",
@@ -60,7 +60,7 @@
     "eslint-plugin-prettier": "^3.1.4",
     "file-loader": "^6.0.0",
     "fork-ts-checker-webpack-plugin": "^6.0.5",
-    "husky": "^5.1.2",
+    "husky": "^6.0.0",
     "is-ci": "^3.0.0",
     "istanbul": "^0.4.5",
     "jest": "^26.6.3",
@@ -92,7 +92,7 @@
     "style-loader": "^2.0.0",
     "terser": "^5.5.0",
     "toml": "^3.0.0",
-    "tooling": "webpack/tooling#v1.14.1",
+    "tooling": "webpack/tooling#v1.15.0",
     "ts-loader": "^8.0.2",
     "typescript": "^4.2.0-beta",
     "url-loader": "^4.1.0",

package/schemas/WebpackOptions.json

@@ -470,6 +470,9 @@
         "library": {
           "$ref": "#/definitions/LibraryOptions"
         },
+        "publicPath": {
+          "$ref": "#/definitions/PublicPath"
+        },
         "runtime": {
           "$ref": "#/definitions/EntryRuntime"
         },
@@ -518,6 +521,9 @@
         "library": {
           "$ref": "#/definitions/LibraryOptions"
         },
+        "publicPath": {
+          "$ref": "#/definitions/PublicPath"
+        },
         "runtime": {
           "$ref": "#/definitions/EntryRuntime"
         },
@@ -675,6 +681,10 @@
           "description": "Support WebAssembly as asynchronous EcmaScript Module.",
           "type": "boolean"
         },
+        "executeModule": {
+          "description": "Enable build-time execution of modules from the module graph for plugins and loaders.",
+          "type": "boolean"
+        },
         "layers": {
           "description": "Enable module and chunk layers.",
           "type": "boolean"

package/types.d.ts

@@ -343,8 +343,13 @@ declare abstract class AsyncQueue<T, K, R> {
 		started: SyncHook<[T]>;
 		result: SyncHook<[T, Error, R]>;
 	};
-	add(item: T, callback: CallbackFunction<R>): void;
+	add(item: T, callback: CallbackAsyncQueue<R>): void;
 	invalidate(item: T): void;
+
+	/**
+	 * Waits for an already started item
+	 */
+	waitFor(item: T, callback: CallbackAsyncQueue<R>): void;
 	stop(): void;
 	increaseParallelism(): void;
 	decreaseParallelism(): void;
@@ -657,6 +662,9 @@ declare interface CallExpressionInfo {
 	name: string;
 	getMembers: () => string[];
 }
+declare interface CallbackAsyncQueue<T> {
+	(err?: WebpackError, result?: T): any;
+}
 declare interface CallbackCache<T> {
 	(err?: WebpackError, result?: T): void;
 }
@@ -1242,6 +1250,10 @@ declare class Compilation {
 		dependencyReferencedExports: SyncWaterfallHook<
 			[(string[] | ReferencedExport)[], Dependency, RuntimeSpec]
 		>;
+		executeModule: SyncHook<[ExecuteModuleArgument, ExecuteModuleContext]>;
+		prepareModuleExecution: AsyncParallelHook<
+			[ExecuteModuleArgument, ExecuteModuleContext]
+		>;
 		finishModules: AsyncSeriesHook<[Iterable<Module>]>;
 		finishRebuildingModule: AsyncSeriesHook<[Module]>;
 		unseal: SyncHook<[]>;
@@ -1263,14 +1275,24 @@ declare class Compilation {
 		>;
 		afterOptimizeChunkModules: SyncHook<[Iterable<Chunk>, Iterable<Module>]>;
 		shouldRecord: SyncBailHook<[], boolean>;
-		additionalChunkRuntimeRequirements: SyncHook<[Chunk, Set<string>]>;
-		runtimeRequirementInChunk: HookMap<SyncBailHook<[Chunk, Set<string>], any>>;
-		additionalModuleRuntimeRequirements: SyncHook<[Module, Set<string>]>;
+		additionalChunkRuntimeRequirements: SyncHook<
+			[Chunk, Set<string>, RuntimeRequirementsContext]
+		>;
+		runtimeRequirementInChunk: HookMap<
+			SyncBailHook<[Chunk, Set<string>, RuntimeRequirementsContext], any>
+		>;
+		additionalModuleRuntimeRequirements: SyncHook<
+			[Module, Set<string>, RuntimeRequirementsContext]
+		>;
 		runtimeRequirementInModule: HookMap<
-			SyncBailHook<[Module, Set<string>], any>
+			SyncBailHook<[Module, Set<string>, RuntimeRequirementsContext], any>
+		>;
+		additionalTreeRuntimeRequirements: SyncHook<
+			[Chunk, Set<string>, RuntimeRequirementsContext]
+		>;
+		runtimeRequirementInTree: HookMap<
+			SyncBailHook<[Chunk, Set<string>, RuntimeRequirementsContext], any>
 		>;
-		additionalTreeRuntimeRequirements: SyncHook<[Chunk, Set<string>]>;
-		runtimeRequirementInTree: HookMap<SyncBailHook<[Chunk, Set<string>], any>>;
 		runtimeModule: SyncHook<[RuntimeModule, Chunk]>;
 		reviveModules: SyncHook<[Iterable<Module>, any]>;
 		beforeModuleIds: SyncHook<[Iterable<Module>]>;
@@ -1363,7 +1385,7 @@ declare class Compilation {
 	resolverFactory: ResolverFactory;
 	inputFileSystem: InputFileSystem;
 	fileSystemInfo: FileSystemInfo;
-	valueCacheVersions: Map<string, string>;
+	valueCacheVersions: Map<string, string | Set<string>>;
 	requestShortener: RequestShortener;
 	compilerPath: string;
 	logger: WebpackLogger;
@@ -1376,7 +1398,7 @@ declare class Compilation {
 	runtimeTemplate: RuntimeTemplate;
 	moduleTemplates: { javascript: ModuleTemplate };
 	moduleGraph: ModuleGraph;
-	chunkGraph?: ChunkGraph;
+	chunkGraph: ChunkGraph;
 	codeGenerationResults: CodeGenerationResults;
 	processDependenciesQueue: AsyncQueue<Module, Module, Module>;
 	addModuleQueue: AsyncQueue<Module, string, Module>;
@@ -1415,6 +1437,7 @@ declare class Compilation {
 	needAdditionalPass: boolean;
 	builtModules: WeakSet<Module>;
 	codeGeneratedModules: WeakSet<Module>;
+	buildTimeExecutedModules: WeakSet<Module>;
 	emittedAssets: Set<string>;
 	comparedForEmitAssets: Set<string>;
 	fileDependencies: LazySet<string>;
@@ -1512,8 +1535,33 @@ declare class Compilation {
 		blocks: DependenciesBlock[]
 	): void;
 	codeGeneration(callback?: any): void;
-	processRuntimeRequirements(): void;
-	addRuntimeModule(chunk: Chunk, module: RuntimeModule): void;
+	processRuntimeRequirements(__0?: {
+		/**
+		 * the chunk graph
+		 */
+		chunkGraph?: ChunkGraph;
+		/**
+		 * modules
+		 */
+		modules?: Iterable<Module>;
+		/**
+		 * chunks
+		 */
+		chunks?: Iterable<Chunk>;
+		/**
+		 * codeGenerationResults
+		 */
+		codeGenerationResults?: CodeGenerationResults;
+		/**
+		 * chunkGraphEntries
+		 */
+		chunkGraphEntries?: Iterable<Chunk>;
+	}): void;
+	addRuntimeModule(
+		chunk: Chunk,
+		module: RuntimeModule,
+		chunkGraph?: ChunkGraph
+	): void;
 	addChunkInGroup(
 		groupOptions: string | ChunkGroupOptions,
 		module: Module,
@@ -1601,6 +1649,11 @@ declare class Compilation {
 			| WebpackPluginInstance
 		)[]
 	): Compiler;
+	executeModule(
+		module: Module,
+		options: ExecuteModuleOptions,
+		callback: (err?: WebpackError, result?: ExecuteModuleResult) => void
+	): void;
 	checkConstraints(): void;
 
 	/**
@@ -2876,6 +2929,11 @@ declare interface EntryDescription {
 	 */
 	library?: LibraryOptions;
 
+	/**
+	 * The 'publicPath' specifies the public URL address of the output files when referenced in a browser.
+	 */
+	publicPath?: string | ((pathData: PathData, assetInfo?: AssetInfo) => string);
+
 	/**
 	 * The name of the runtime chunk. If set a runtime chunk with this name is created or an existing entrypoint is used as runtime.
 	 */
@@ -2921,6 +2979,11 @@ declare interface EntryDescriptionNormalized {
 	 */
 	library?: LibraryOptions;
 
+	/**
+	 * The 'publicPath' specifies the public URL address of the output files when referenced in a browser.
+	 */
+	publicPath?: string | ((pathData: PathData, assetInfo?: AssetInfo) => string);
+
 	/**
 	 * The name of the runtime chunk. If set a runtime chunk with this name is created or an existing entrypoint is used as runtime.
 	 */
@@ -3085,6 +3148,30 @@ declare class EvalSourceMapDevToolPlugin {
 	 */
 	apply(compiler: Compiler): void;
 }
+declare interface ExecuteModuleArgument {
+	module: Module;
+	moduleObject?: { id: string; exports: any; loaded: boolean };
+	preparedInfo: any;
+	codeGenerationResult: CodeGenerationResult;
+}
+declare interface ExecuteModuleContext {
+	assets: Map<string, { source: Source; info: AssetInfo }>;
+	chunk: Chunk;
+	chunkGraph: ChunkGraph;
+	__webpack_require__?: (arg0: string) => any;
+}
+declare interface ExecuteModuleOptions {
+	entryOptions?: EntryOptions;
+}
+declare interface ExecuteModuleResult {
+	exports: any;
+	cacheable: boolean;
+	assets: Map<string, { source: Source; info: AssetInfo }>;
+	fileDependencies: LazySet<string>;
+	contextDependencies: LazySet<string>;
+	missingDependencies: LazySet<string>;
+	buildDependencies: LazySet<string>;
+}
 
 /**
  * Enables/Disables experiments (experimental features with relax SemVer compatibility).
@@ -3100,6 +3187,11 @@ declare interface Experiments {
 	 */
 	asyncWebAssembly?: boolean;
 
+	/**
+	 * Enable build-time execution of modules from the module graph for plugins and loaders.
+	 */
+	executeModule?: boolean;
+
 	/**
 	 * Enable module and chunk layers.
 	 */
@@ -4048,6 +4140,11 @@ declare interface HandleModuleCreationOptions {
 	 * recurse into dependencies of the created module
 	 */
 	recursive?: boolean;
+
+	/**
+	 * connect the resolved module with the origin module
+	 */
+	connectOrigin?: boolean;
 }
 declare class Hash {
 	constructor();
@@ -5348,6 +5445,7 @@ declare interface KnownStatsModule {
 	cacheable?: boolean;
 	built?: boolean;
 	codeGenerated?: boolean;
+	buildTimeExecuted?: boolean;
 	cached?: boolean;
 	optional?: boolean;
 	orphan?: boolean;
@@ -5484,6 +5582,7 @@ declare class LibManifestPlugin {
 }
 declare interface LibraryContext<T> {
 	compilation: Compilation;
+	chunkGraph: ChunkGraph;
 	options: T;
 }
 
@@ -6154,6 +6253,12 @@ declare class ModuleGraph {
 	setAsync(module: Module): void;
 	getMeta(thing?: any): Object;
 	getMetaIfExisting(thing?: any): Object;
+	freeze(): void;
+	unfreeze(): void;
+	cached<T extends any[], V>(
+		fn: (moduleGraph: ModuleGraph, ...args: T) => V,
+		...args: T
+	): V;
 	static getModuleGraphForModule(
 		module: Module,
 		deprecateMessage: string,
@@ -6514,7 +6619,7 @@ declare class NaturalModuleIdsPlugin {
 }
 declare interface NeedBuildContext {
 	fileSystemInfo: FileSystemInfo;
-	valueCacheVersions: Map<string, string>;
+	valueCacheVersions: Map<string, string | Set<string>>;
 }
 declare class NoEmitOnErrorsPlugin {
 	constructor();
@@ -9268,8 +9373,9 @@ declare class RuntimeModule extends Module {
 	stage: number;
 	compilation: Compilation;
 	chunk: Chunk;
+	chunkGraph: ChunkGraph;
 	fullHash: boolean;
-	attach(compilation: Compilation, chunk: Chunk): void;
+	attach(compilation: Compilation, chunk: Chunk, chunkGraph?: ChunkGraph): void;
 	generate(): string;
 	getGeneratedCode(): string;
 	shouldIsolate(): boolean;
@@ -9294,6 +9400,17 @@ declare class RuntimeModule extends Module {
 	 */
 	static STAGE_TRIGGER: number;
 }
+declare interface RuntimeRequirementsContext {
+	/**
+	 * the chunk graph
+	 */
+	chunkGraph: ChunkGraph;
+
+	/**
+	 * the code generation results
+	 */
+	codeGenerationResults: CodeGenerationResults;
+}
 type RuntimeSpec = undefined | string | SortableSet<string>;
 declare abstract class RuntimeSpecMap<T> {
 	get(runtime: RuntimeSpec): T;
@@ -9714,7 +9831,7 @@ declare abstract class RuntimeValue {
 	readonly fileDependencies?: true | string[];
 	exec(
 		parser: JavascriptParser,
-		valueCacheVersions: Map<string, string>,
+		valueCacheVersions: Map<string, string | Set<string>>,
 		key: string
 	): CodeValuePrimitive;
 	getCacheVersion(): undefined | string;