webpack 5.18.0 → 5.20.2

package/lib/util/AsyncQueue.js

@@ -6,6 +6,7 @@
 "use strict";
 
 const { SyncHook, AsyncSeriesHook } = require("tapable");
+const ArrayQueue = require("./ArrayQueue");
 
 const QUEUED_STATE = 0;
 const PROCESSING_STATE = 1;
@@ -51,23 +52,35 @@ class AsyncQueue {
 	/**
 	 * @param {Object} options options object
 	 * @param {string=} options.name name of the queue
-	 * @param {number} options.parallelism how many items should be processed at once
+	 * @param {number=} options.parallelism how many items should be processed at once
+	 * @param {AsyncQueue<any, any, any>=} options.parent parent queue, which will have priority over this queue and with shared parallelism
 	 * @param {function(T): K=} options.getKey extract key from item
 	 * @param {function(T, Callback<R>): void} options.processor async function to process items
 	 */
-	constructor({ name, parallelism, processor, getKey }) {
+	constructor({ name, parallelism, parent, processor, getKey }) {
 		this._name = name;
-		this._parallelism = parallelism;
+		this._parallelism = parallelism || 1;
 		this._processor = processor;
 		this._getKey =
 			getKey || /** @type {(T) => K} */ (item => /** @type {any} */ (item));
 		/** @type {Map<K, AsyncQueueEntry<T, K, R>>} */
 		this._entries = new Map();
-		/** @type {AsyncQueueEntry<T, K, R>[]} */
-		this._queued = [];
+		/** @type {ArrayQueue<AsyncQueueEntry<T, K, R>>} */
+		this._queued = new ArrayQueue();
+		/** @type {AsyncQueue<any, any, any>[]} */
+		this._children = undefined;
 		this._activeTasks = 0;
 		this._willEnsureProcessing = false;
+		this._needProcessing = false;
 		this._stopped = false;
+		this._root = parent ? parent._root : this;
+		if (parent) {
+			if (this._root._children === undefined) {
+				this._root._children = [this];
+			} else {
+				this._root._children.push(this);
+			}
+		}
 
 		this.hooks = {
 			/** @type {AsyncSeriesHook<[T]>} */
@@ -112,16 +125,18 @@ class AsyncQueue {
 			const newEntry = new AsyncQueueEntry(item, callback);
 			if (this._stopped) {
 				this.hooks.added.call(item);
-				this._activeTasks++;
+				this._root._activeTasks++;
 				process.nextTick(() =>
 					this._handleResult(newEntry, new Error("Queue was stopped"))
 				);
 			} else {
 				this._entries.set(key, newEntry);
-				this._queued.push(newEntry);
-				if (this._willEnsureProcessing === false) {
-					this._willEnsureProcessing = true;
-					setImmediate(this._ensureProcessing);
+				this._queued.enqueue(newEntry);
+				const root = this._root;
+				root._needProcessing = true;
+				if (root._willEnsureProcessing === false) {
+					root._willEnsureProcessing = true;
+					setImmediate(root._ensureProcessing);
 				}
 				this.hooks.added.call(item);
 			}
@@ -137,10 +152,7 @@ class AsyncQueue {
 		const entry = this._entries.get(key);
 		this._entries.delete(key);
 		if (entry.state === QUEUED_STATE) {
-			const idx = this._queued.indexOf(entry);
-			if (idx >= 0) {
-				this._queued.splice(idx, 1);
-			}
+			this._queued.delete(entry);
 		}
 	}
 
@@ -150,10 +162,11 @@ class AsyncQueue {
 	stop() {
 		this._stopped = true;
 		const queue = this._queued;
-		this._queued = [];
+		this._queued = new ArrayQueue();
+		const root = this._root;
 		for (const entry of queue) {
 			this._entries.delete(this._getKey(entry.item));
-			this._activeTasks++;
+			root._activeTasks++;
 			this._handleResult(entry, new Error("Queue was stopped"));
 		}
 	}
@@ -162,11 +175,12 @@ class AsyncQueue {
 	 * @returns {void}
 	 */
 	increaseParallelism() {
-		this._parallelism++;
+		const root = this._root;
+		root._parallelism++;
 		/* istanbul ignore next */
-		if (this._willEnsureProcessing === false && this._queued.length > 0) {
-			this._willEnsureProcessing = true;
-			setImmediate(this._ensureProcessing);
+		if (root._willEnsureProcessing === false && root._needProcessing) {
+			root._willEnsureProcessing = true;
+			setImmediate(root._ensureProcessing);
 		}
 	}
 
@@ -174,7 +188,8 @@ class AsyncQueue {
 	 * @returns {void}
 	 */
 	decreaseParallelism() {
-		this._parallelism--;
+		const root = this._root;
+		root._parallelism--;
 	}
 
 	/**
@@ -211,13 +226,28 @@ class AsyncQueue {
 	 * @returns {void}
 	 */
 	_ensureProcessing() {
-		while (this._activeTasks < this._parallelism && this._queued.length > 0) {
-			const entry = this._queued.pop();
+		while (this._activeTasks < this._parallelism) {
+			const entry = this._queued.dequeue();
+			if (entry === undefined) break;
 			this._activeTasks++;
 			entry.state = PROCESSING_STATE;
 			this._startProcessing(entry);
 		}
 		this._willEnsureProcessing = false;
+		if (this._queued.length > 0) return;
+		if (this._children !== undefined) {
+			for (const child of this._children) {
+				while (this._activeTasks < this._parallelism) {
+					const entry = child._queued.dequeue();
+					if (entry === undefined) break;
+					this._activeTasks++;
+					entry.state = PROCESSING_STATE;
+					child._startProcessing(entry);
+				}
+				if (child._queued.length > 0) return;
+			}
+		}
+		if (!this._willEnsureProcessing) this._needProcessing = false;
 	}
 
 	/**
@@ -261,11 +291,12 @@ class AsyncQueue {
 			entry.callbacks = undefined;
 			entry.result = result;
 			entry.error = error;
-			this._activeTasks--;
 
-			if (this._willEnsureProcessing === false && this._queued.length > 0) {
-				this._willEnsureProcessing = true;
-				setImmediate(this._ensureProcessing);
+			const root = this._root;
+			root._activeTasks--;
+			if (root._willEnsureProcessing === false && root._needProcessing) {
+				root._willEnsureProcessing = true;
+				setImmediate(root._ensureProcessing);
 			}
 
 			if (inHandleResult++ > 3) {

package/lib/util/ParallelismFactorCalculator.js

@@ -0,0 +1,59 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const binarySearchBounds = require("../util/binarySearchBounds");
+
+class ParallelismFactorCalculator {
+	constructor() {
+		this._rangePoints = [];
+		this._rangeCallbacks = [];
+	}
+
+	range(start, end, callback) {
+		if (start === end) return callback(1);
+		this._rangePoints.push(start);
+		this._rangePoints.push(end);
+		this._rangeCallbacks.push(callback);
+	}
+
+	calculate() {
+		const segments = Array.from(new Set(this._rangePoints)).sort((a, b) =>
+			a < b ? -1 : 1
+		);
+		const parallelism = segments.map(() => 0);
+		const rangeStartIndices = [];
+		for (let i = 0; i < this._rangePoints.length; i += 2) {
+			const start = this._rangePoints[i];
+			const end = this._rangePoints[i + 1];
+			let idx = binarySearchBounds.eq(segments, start);
+			rangeStartIndices.push(idx);
+			do {
+				parallelism[idx]++;
+				idx++;
+			} while (segments[idx] < end);
+		}
+		for (let i = 0; i < this._rangeCallbacks.length; i++) {
+			const start = this._rangePoints[i * 2];
+			const end = this._rangePoints[i * 2 + 1];
+			let idx = rangeStartIndices[i];
+			let sum = 0;
+			let totalDuration = 0;
+			let current = start;
+			do {
+				const p = parallelism[idx];
+				idx++;
+				const duration = segments[idx] - current;
+				totalDuration += duration;
+				current = segments[idx];
+				sum += p * duration;
+			} while (current < end);
+			this._rangeCallbacks[i](sum / totalDuration);
+		}
+	}
+}
+
+module.exports = ParallelismFactorCalculator;

package/lib/util/fs.js

@@ -84,6 +84,9 @@ const path = require("path");
  * @typedef {Object} OutputFileSystem
  * @property {function(string, Buffer|string, Callback): void} writeFile
  * @property {function(string, Callback): void} mkdir
+ * @property {function(string, DirentArrayCallback): void=} readdir
+ * @property {function(string, Callback): void=} rmdir
+ * @property {function(string, Callback): void=} unlink
  * @property {function(string, StatsCallback): void} stat
  * @property {function(string, BufferOrStringCallback): void} readFile
  * @property {(function(string, string): string)=} join

package/lib/util/runtime.js

@@ -129,7 +129,7 @@ exports.runtimeConditionToString = runtimeCondition => {
  * @param {RuntimeSpec} b second
  * @returns {boolean} true, when they are equal
  */
-exports.runtimeEqual = (a, b) => {
+const runtimeEqual = (a, b) => {
 	if (a === b) {
 		return true;
 	} else if (
@@ -154,6 +154,7 @@ exports.runtimeEqual = (a, b) => {
 		}
 	}
 };
+exports.runtimeEqual = runtimeEqual;
 
 /**
  * @param {RuntimeSpec} a first
@@ -269,9 +270,7 @@ const mergeRuntimeOwned = (a, b) => {
 		return a;
 	} else if (a === undefined) {
 		if (typeof b === "string") {
-			const set = new SortableSet();
-			set.add(b);
-			return set;
+			return b;
 		} else {
 			return new SortableSet(b);
 		}
@@ -424,8 +423,13 @@ class RuntimeSpecMap {
 	 * @param {RuntimeSpecMap<T>=} clone copy form this
 	 */
 	constructor(clone) {
-		/** @type {Map<string, T>} */
-		this._map = new Map(clone ? clone._map : undefined);
+		this._mode = clone ? clone._mode : 0; // 0 = empty, 1 = single entry, 2 = map
+		/** @type {RuntimeSpec} */
+		this._singleRuntime = clone ? clone._singleRuntime : undefined;
+		/** @type {T} */
+		this._singleValue = clone ? clone._singleValue : undefined;
+		/** @type {Map<string, T> | undefined} */
+		this._map = clone && clone._map ? new Map(clone._map) : undefined;
 	}
 
 	/**
@@ -433,8 +437,16 @@ class RuntimeSpecMap {
 	 * @returns {T} value
 	 */
 	get(runtime) {
-		const key = getRuntimeKey(runtime);
-		return this._map.get(key);
+		switch (this._mode) {
+			case 0:
+				return undefined;
+			case 1:
+				return runtimeEqual(this._singleRuntime, runtime)
+					? this._singleValue
+					: undefined;
+			default:
+				return this._map.get(getRuntimeKey(runtime));
+		}
 	}
 
 	/**
@@ -442,40 +454,139 @@ class RuntimeSpecMap {
 	 * @returns {boolean} true, when the runtime is stored
 	 */
 	has(runtime) {
-		const key = getRuntimeKey(runtime);
-		return this._map.has(key);
+		switch (this._mode) {
+			case 0:
+				return false;
+			case 1:
+				return runtimeEqual(this._singleRuntime, runtime);
+			default:
+				return this._map.has(getRuntimeKey(runtime));
+		}
 	}
 
 	set(runtime, value) {
-		this._map.set(getRuntimeKey(runtime), value);
+		switch (this._mode) {
+			case 0:
+				this._mode = 1;
+				this._singleRuntime = runtime;
+				this._singleValue = value;
+				break;
+			case 1:
+				if (runtimeEqual(this._singleRuntime, runtime)) {
+					this._singleValue = value;
+					break;
+				}
+				this._mode = 2;
+				this._map = new Map();
+				this._map.set(getRuntimeKey(this._singleRuntime), this._singleValue);
+				this._singleRuntime = undefined;
+				this._singleValue = undefined;
+			/* falls through */
+			default:
+				this._map.set(getRuntimeKey(runtime), value);
+		}
 	}
 
 	provide(runtime, computer) {
-		const key = getRuntimeKey(runtime);
-		const value = this._map.get(key);
-		if (value !== undefined) return value;
-		const newValue = computer();
-		this._map.set(key, newValue);
-		return newValue;
+		switch (this._mode) {
+			case 0:
+				this._mode = 1;
+				this._singleRuntime = runtime;
+				return (this._singleValue = computer());
+			case 1: {
+				if (runtimeEqual(this._singleRuntime, runtime)) {
+					return this._singleValue;
+				}
+				this._mode = 2;
+				this._map = new Map();
+				this._map.set(getRuntimeKey(this._singleRuntime), this._singleValue);
+				this._singleRuntime = undefined;
+				this._singleValue = undefined;
+				const newValue = computer();
+				this._map.set(getRuntimeKey(runtime), newValue);
+				return newValue;
+			}
+			default: {
+				const key = getRuntimeKey(runtime);
+				const value = this._map.get(key);
+				if (value !== undefined) return value;
+				const newValue = computer();
+				this._map.set(key, newValue);
+				return newValue;
+			}
+		}
 	}
 
 	delete(runtime) {
-		this._map.delete(getRuntimeKey(runtime));
+		switch (this._mode) {
+			case 0:
+				return;
+			case 1:
+				if (runtimeEqual(this._singleRuntime, runtime)) {
+					this._mode = 0;
+					this._singleRuntime = undefined;
+					this._singleValue = undefined;
+				}
+				return;
+			default:
+				this._map.delete(getRuntimeKey(runtime));
+		}
 	}
 
 	update(runtime, fn) {
-		const key = getRuntimeKey(runtime);
-		const oldValue = this._map.get(key);
-		const newValue = fn(oldValue);
-		if (newValue !== oldValue) this._map.set(key, newValue);
+		switch (this._mode) {
+			case 0:
+				throw new Error("runtime passed to update must exist");
+			case 1: {
+				if (runtimeEqual(this._singleRuntime, runtime)) {
+					this._singleValue = fn(this._singleValue);
+					break;
+				}
+				const newValue = fn(undefined);
+				if (newValue !== undefined) {
+					this._mode = 2;
+					this._map = new Map();
+					this._map.set(getRuntimeKey(this._singleRuntime), this._singleValue);
+					this._singleRuntime = undefined;
+					this._singleValue = undefined;
+					this._map.set(getRuntimeKey(runtime), newValue);
+				}
+				break;
+			}
+			default: {
+				const key = getRuntimeKey(runtime);
+				const oldValue = this._map.get(key);
+				const newValue = fn(oldValue);
+				if (newValue !== oldValue) this._map.set(key, newValue);
+			}
+		}
 	}
 
 	keys() {
-		return Array.from(this._map.keys(), keyToRuntime);
+		switch (this._mode) {
+			case 0:
+				return [];
+			case 1:
+				return [this._singleRuntime];
+			default:
+				return Array.from(this._map.keys(), keyToRuntime);
+		}
 	}
 
 	values() {
-		return this._map.values();
+		switch (this._mode) {
+			case 0:
+				return [][Symbol.iterator]();
+			case 1:
+				return [this._singleValue][Symbol.iterator]();
+			default:
+				return this._map.values();
+		}
+	}
+
+	get size() {
+		if (this._mode <= 1) return this._mode;
+		return this._map.size;
 	}
 }
 

package/lib/validateSchema.js

@@ -63,9 +63,9 @@ const DID_YOU_MEAN = {
 
 const REMOVED = {
 	concord:
-		"BREAKING CHANGE: resolve.concord has been removed and is no longer avaiable.",
+		"BREAKING CHANGE: resolve.concord has been removed and is no longer available.",
 	devtoolLineToLine:
-		"BREAKING CHANGE: output.devtoolLineToLine has been removed and is no longer avaiable."
+		"BREAKING CHANGE: output.devtoolLineToLine has been removed and is no longer available."
 };
 /* cSpell:enable */
 

package/lib/wasm-async/AsyncWebAssemblyJavascriptGenerator.js

@@ -155,30 +155,32 @@ class AsyncWebAssemblyJavascriptGenerator extends Generator {
 				chunkGraph.getRenderedModuleHash(module, runtime)
 			)}` + (importsObj ? `, ${importsObj})` : `)`);
 
+		if (promises.length > 0)
+			runtimeRequirements.add(RuntimeGlobals.asyncModule);
+
 		const source = new RawSource(
-			`${importsCode}${
-				promises.length > 1
-					? Template.asString([
-							`${module.moduleArgument}.exports = Promise.all([${promises.join(
-								", "
-							)}]).then(${runtimeTemplate.basicFunction(
-								`[${promises.join(", ")}]`,
-								`${importsCompatCode}return ${instantiateCall};`
-							)})`
-					  ])
-					: promises.length === 1
-					? Template.asString([
-							`${module.moduleArgument}.exports = Promise.resolve(${
-								promises[0]
-							}).then(${runtimeTemplate.basicFunction(
-								promises[0],
-
-								`${importsCompatCode}return ${instantiateCall};`
-							)})`
-					  ])
-					: `${importsCompatCode}${module.moduleArgument}.exports = ${instantiateCall}`
-			}`
+			promises.length > 0
+				? Template.asString([
+						`var __webpack_instantiate__ = ${runtimeTemplate.basicFunction(
+							`[${promises.join(", ")}]`,
+							`${importsCompatCode}return ${instantiateCall};`
+						)}`,
+						`${RuntimeGlobals.asyncModule}(${
+							module.moduleArgument
+						}, ${runtimeTemplate.basicFunction(
+							"__webpack_handle_async_dependencies__",
+							[
+								importsCode,
+								`var __webpack_async_dependencies__ = __webpack_handle_async_dependencies__([${promises.join(
+									", "
+								)}]);`,
+								"return __webpack_async_dependencies__.then ? __webpack_async_dependencies__.then(__webpack_instantiate__) : __webpack_instantiate__(__webpack_async_dependencies__);"
+							]
+						)}, 1);`
+				  ])
+				: `${importsCode}${importsCompatCode}module.exports = ${instantiateCall};`
 		);
+
 		return InitFragment.addToSource(source, initFragments, generateContext);
 	}
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "webpack",
-  "version": "5.18.0",
+  "version": "5.20.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",
@@ -23,7 +23,6 @@
     "loader-runner": "^4.2.0",
     "mime-types": "^2.1.27",
     "neo-async": "^2.6.2",
-    "pkg-dir": "^5.0.0",
     "schema-utils": "^3.0.0",
     "tapable": "^2.1.1",
     "terser-webpack-plugin": "^5.1.1",
@@ -70,7 +69,7 @@
     "json-loader": "^0.5.7",
     "json5": "^2.1.3",
     "less": "^4.0.0",
-    "less-loader": "^7.1.0",
+    "less-loader": "^8.0.0",
     "lint-staged": "^10.2.11",
     "loader-utils": "^2.0.0",
     "lodash": "^4.17.19",

package/schemas/WebpackOptions.json

@@ -224,6 +224,45 @@
         }
       ]
     },
+    "Clean": {
+      "description": "Clean the output directory before emit.",
+      "anyOf": [
+        {
+          "type": "boolean"
+        },
+        {
+          "$ref": "#/definitions/CleanOptions"
+        }
+      ]
+    },
+    "CleanOptions": {
+      "description": "Advanced options for cleaning assets.",
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "dry": {
+          "description": "Log the assets that should be removed instead of deleting them.",
+          "type": "boolean"
+        },
+        "keep": {
+          "description": "Keep these assets.",
+          "anyOf": [
+            {
+              "instanceof": "RegExp",
+              "tsType": "RegExp"
+            },
+            {
+              "type": "string",
+              "absolutePath": false
+            },
+            {
+              "instanceof": "Function",
+              "tsType": "((filename: string) => boolean)"
+            }
+          ]
+        }
+      }
+    },
     "CompareBeforeEmit": {
       "description": "Check if to be emitted file already exists and have the same content before writing to output filesystem.",
       "type": "boolean"
@@ -603,6 +642,26 @@
                 "entries": {
                   "description": "Enable/disable lazy compilation for entries.",
                   "type": "boolean"
+                },
+                "imports": {
+                  "description": "Enable/disable lazy compilation for import() modules.",
+                  "type": "boolean"
+                },
+                "test": {
+                  "description": "Specify which entrypoints or import()ed modules should be lazily compiled. This is matched with the imported module and not the entrypoint name.",
+                  "anyOf": [
+                    {
+                      "instanceof": "RegExp",
+                      "tsType": "RegExp"
+                    },
+                    {
+                      "type": "string"
+                    },
+                    {
+                      "instanceof": "Function",
+                      "tsType": "((module: import('../lib/Module')) => boolean)"
+                    }
+                  ]
                 }
               }
             }
@@ -2350,6 +2409,9 @@
         "chunkLoadingGlobal": {
           "$ref": "#/definitions/ChunkLoadingGlobal"
         },
+        "clean": {
+          "$ref": "#/definitions/Clean"
+        },
         "compareBeforeEmit": {
           "$ref": "#/definitions/CompareBeforeEmit"
         },
@@ -2517,6 +2579,9 @@
         "chunkLoadingGlobal": {
           "$ref": "#/definitions/ChunkLoadingGlobal"
         },
+        "clean": {
+          "$ref": "#/definitions/Clean"
+        },
         "compareBeforeEmit": {
           "$ref": "#/definitions/CompareBeforeEmit"
         },

package/schemas/_container.json

@@ -37,6 +37,10 @@
               "$ref": "#/definitions/ExposesItems"
             }
           ]
+        },
+        "name": {
+          "description": "Custom chunk name for the exposed module.",
+          "type": "string"
         }
       },
       "required": ["import"]

package/schemas/plugins/container/ContainerPlugin.json

@@ -49,6 +49,10 @@
               "$ref": "#/definitions/ExposesItems"
             }
           ]
+        },
+        "name": {
+          "description": "Custom chunk name for the exposed module.",
+          "type": "string"
         }
       },
       "required": ["import"]

package/schemas/plugins/container/ModuleFederationPlugin.json

@@ -49,6 +49,10 @@
               "$ref": "#/definitions/ExposesItems"
             }
           ]
+        },
+        "name": {
+          "description": "Custom chunk name for the exposed module.",
+          "type": "string"
         }
       },
       "required": ["import"]