webpack 5.110.3 → 5.111.0

package/lib/sharing/ConsumeSharedPlugin.js

@@ -15,6 +15,7 @@ const ConsumeSharedFallbackDependency = require("./ConsumeSharedFallbackDependen
 const ConsumeSharedModule = require("./ConsumeSharedModule");
 const ConsumeSharedRuntimeModule = require("./ConsumeSharedRuntimeModule");
 const ProvideForSharedDependency = require("./ProvideForSharedDependency");
+const { addDeclaredShared } = require("./declaredShared");
 const { resolveMatchedConfigs } = require("./resolveMatchedConfigs");
 const {
 	getDescriptionFile,
@@ -137,6 +138,17 @@ class ConsumeSharedPlugin {
 					normalModuleFactory
 				);
 
+				// A key ending in a slash shares everything under it, and the
+				// modules then carry the remainder appended to the share key.
+				addDeclaredShared(
+					compilation,
+					consumes.map(([key, config]) => ({
+						name: key,
+						shareKey: config.shareKey,
+						prefix: key.endsWith("/")
+					}))
+				);
+
 				/** @typedef {Map<string, ConsumeOptions>} Consumes */
 
 				/** @type {Consumes} */

package/lib/sharing/ConsumeSharedRuntimeModule.js

@@ -33,6 +33,17 @@ class ConsumeSharedRuntimeModule extends RuntimeModule {
 		this._runtimeRequirements = runtimeRequirements;
 	}
 
+	/**
+	 * The `[handlerMap, key]` pairs this module installs onto a chunk handler map
+	 * such as `__webpack_require__.f`, or `null` where it cannot name them.
+	 * @returns {[string, string][] | null} installed chunk handlers (do not mutate)
+	 */
+	getInstalledChunkHandlers() {
+		return this._runtimeRequirements.has(RuntimeGlobals.ensureChunkHandlers)
+			? [[RuntimeGlobals.ensureChunkHandlers, "consumes"]]
+			: [];
+	}
+
 	/**
 	 * Generates runtime code for this runtime module.
 	 * @returns {string | null} runtime code

package/lib/sharing/ShareRuntimeModule.js

@@ -23,6 +23,15 @@ class ShareRuntimeModule extends RuntimeModule {
 		super("sharing");
 	}
 
+	/**
+	 * The `[handlerMap, key]` pairs this module installs onto a chunk handler map
+	 * such as `__webpack_require__.f`, or `null` where it cannot name them.
+	 * @returns {[string, string][] | null} installed chunk handlers (do not mutate)
+	 */
+	getInstalledChunkHandlers() {
+		return RuntimeModule.NO_CHUNK_HANDLERS;
+	}
+
 	/**
 	 * Generates runtime code for this runtime module.
 	 * @returns {string | null} runtime code

package/lib/sharing/declaredShared.js

@@ -0,0 +1,47 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+/** @import Compilation from "../Compilation" */
+
+/**
+ * @typedef {object} SharedDeclaration
+ * @property {string} name the config key, as the config spells it
+ * @property {string} shareKey the key the modules created for it carry
+ * @property {boolean} prefix whether it shares everything under the key
+ */
+
+/** @type {WeakMap<Compilation, SharedDeclaration[]>} */
+const DECLARED_SHARED = new WeakMap();
+
+/**
+ * What this build declared as shared, one entry per config key, since several
+ * may name one share key. `performance.unusedConfig` matches modules on the
+ * share key and reports the config key.
+ * @param {Compilation} compilation the compilation
+ * @returns {SharedDeclaration[] | undefined} the declarations, when any were made
+ */
+const getDeclaredShared = (compilation) => DECLARED_SHARED.get(compilation);
+
+/**
+ * Records declarations, appending when a build applies the plugin more than
+ * once, as `ModuleFederationPlugin` and `SharePlugin` do.
+ * @param {Compilation} compilation the compilation
+ * @param {SharedDeclaration[]} declarations what this application declared
+ * @returns {void}
+ */
+const addDeclaredShared = (compilation, declarations) => {
+	const declared = DECLARED_SHARED.get(compilation);
+
+	if (declared === undefined) {
+		DECLARED_SHARED.set(compilation, [...declarations]);
+	} else {
+		for (const declaration of declarations) declared.push(declaration);
+	}
+};
+
+module.exports.addDeclaredShared = addDeclaredShared;
+module.exports.getDeclaredShared = getDeclaredShared;

package/lib/stats/DefaultStatsFactoryPlugin.js

@@ -1340,9 +1340,11 @@ const SIMPLE_EXTRACTORS = {
 			const warnings = module.getWarnings();
 			const warningsCount =
 				warnings !== undefined ? countIterable(warnings) : 0;
-			const { cacheable, notCacheableReasons } = /** @type {BuildInfo} */ (
+			const { cacheable, diagnostics } = /** @type {BuildInfo} */ (
 				module.buildInfo
 			);
+			const notCacheableReasons =
+				diagnostics === undefined ? undefined : diagnostics.notCacheableReasons;
 			const preOrderIndex = /** @type {number} */ (
 				moduleGraph.getPreOrderIndex(module)
 			);

package/lib/stats/DefaultStatsPrinterPlugin.js

@@ -460,6 +460,8 @@ const ASSET_SIMPLE_PRINTERS = {
 		javascriptModule ? formatFlag("javascript module") : undefined,
 	"asset.info.sourceFilename": (sourceFilename, { formatFlag }) =>
 		sourceFilename ? formatFlag(`from: ${sourceFilename}`) : undefined,
+	"asset.info.copied": (copied, { green, formatFlag }) =>
+		copied ? green(formatFlag("copied")) : undefined,
 	"asset.info.development": (development, { green, formatFlag }) =>
 		development ? green(formatFlag("dev")) : undefined,
 	"asset.info.hotModuleReplacement": (
@@ -1045,6 +1047,7 @@ const PREFERRED_ORDERS = {
 	"asset.info": [
 		"immutable",
 		"sourceFilename",
+		"copied",
 		"javascriptModule",
 		"development",
 		"hotModuleReplacement"

package/lib/util/SourceProcessor.js

@@ -261,14 +261,17 @@ class PrintContext {
 		/** @type {NodePrinter<TPath, TNode, TPrintOptions>} */
 		this._printer = printer;
 		// Printed text by node handle, in two columns rather than one `Map`: the
-		// handles are dense integers, and a stylesheet prints ~300k nodes through
-		// a store that never holds more than a few dozen of them at once.
+		// handles are dense integers, and `_moveEpoch` keeps the live set small.
 		/** @type {string[]} each finished node's printed text */
 		this._storeText = [];
 		/** @type {Int32Array} the epoch each slot was written in */
 		this._storeGen = new Int32Array(0);
 		/** @type {number} current epoch; a slot from an older one reads as absent */
 		this._gen = 1;
+		/** @type {number} lowest slot written since the epoch last moved */
+		this._storeLow = 0x7fffffff;
+		/** @type {number} highest slot written since the epoch last moved */
+		this._storeHigh = -1;
 		// Output accumulates into `_tail`, a plain string append, so printing that
 		// never takes anything back costs exactly what appending to one string
 		// costs. A piece is cut off into `_chunks` only for text that may still be
@@ -285,7 +288,7 @@ class PrintContext {
 		this._flattened = 0;
 		/** @type {[number, number, number, number][]} `[chunkIndex, offsetInChunk, srcLine, srcCol]`, output-ordered; a `srcLine` of -1 is one {@link retract} took back with its piece */
 		this._mappings = [];
-		/** @type {Map<number, number> | null} a retractable piece -> the mapping anchored to it, so taking the piece back takes its mapping too */
+		/** @type {number[] | null} by retractable piece index, the mapping anchored to it, so taking the piece back takes its mapping too */
 		this._retractableMappings = null;
 		// A map is built only for a caller that named the input, and that is known
 		// before printing — so a print nobody asks a map of collects none.
@@ -424,8 +427,25 @@ class PrintContext {
 	 * node's text.
 	 */
 	dropStore() {
-		// Bumping the epoch invalidates every slot at once, so this stays O(1) —
-		// it runs per node, and clearing a column by length would not.
+		this._moveEpoch();
+	}
+
+	/**
+	 * Move the epoch on and release the text every slot written under the old one
+	 * holds. Only the range actually written is walked, so the drop stays O(1)
+	 * per node.
+	 * @returns {void}
+	 */
+	_moveEpoch() {
+		const high = this._storeHigh;
+		if (high !== -1) {
+			// `""` rather than a hole: the column is packed, and a hole in it would
+			// cost every read after this one.
+			const text = this._storeText;
+			for (let i = this._storeLow; i <= high; i++) text[i] = "";
+			this._storeLow = 0x7fffffff;
+			this._storeHigh = -1;
+		}
 		this._gen++;
 	}
 
@@ -469,6 +489,8 @@ class PrintContext {
 		if (n >= this._storeText.length) this._growStore(n + 1);
 		this._storeText[n] = text;
 		this._storeGen[n] = this._gen;
+		if (n < this._storeLow) this._storeLow = n;
+		if (n > this._storeHigh) this._storeHigh = n;
 	}
 
 	/**
@@ -552,7 +574,7 @@ class PrintContext {
 	retract(index) {
 		this._chunks[index] = "";
 		if (this._retractableMappings === null) return;
-		const mapping = this._retractableMappings.get(index);
+		const mapping = this._retractableMappings[index];
 		if (mapping !== undefined) this._mappings[mapping][2] = -1;
 	}
 
@@ -598,12 +620,12 @@ class PrintContext {
 		this.anchor(srcOffset, srcLine, srcCol);
 		const mapping = this._mappings.length > before ? before : -1;
 		const at = this.emitRetractable(text === undefined ? this.get(node) : text);
-		this._gen++;
+		this._moveEpoch();
 		if (mapping !== -1) {
-			if (this._retractableMappings === null) {
-				this._retractableMappings = new Map();
-			}
-			this._retractableMappings.set(at, mapping);
+			// Indexed by piece rather than a `Map`: pieces are dense integers, and
+			// nearly every rule minifying goes out as one.
+			if (this._retractableMappings === null) this._retractableMappings = [];
+			this._retractableMappings[at] = mapping;
 		}
 		return at;
 	}
@@ -627,7 +649,7 @@ class PrintContext {
 		this._emit(
 			text === undefined ? this.get(/** @type {TNode} */ (node)) : text
 		);
-		this._gen++;
+		this._moveEpoch();
 	}
 
 	/**
@@ -739,68 +761,44 @@ class PrintContext {
 
 	/**
 	 * @param {SourceMapOptions} options the input's name / content
+	 * @param {string=} code the output {@link result} built, walked for its line breaks
 	 * @returns {SourceMap} the input->output source map
 	 */
-	sourceMap(options) {
+	sourceMap(options, code) {
 		let out = "";
 		let genLine = 0;
 		let genCol = 0;
 		let srcLine = 0;
 		let srcCol = 0;
 		let atLineStart = true;
-		// Where each anchor landed, walked once alongside the mappings — both are
-		// in output order, so this is one pass over the output, not a position
-		// recomputed per mapping. An anchor can sit inside a piece rather than at
-		// its start, since output accumulates into the piece it is appending to.
+		// Walked over the flat output rather than piece by piece: a piece is a rope
+		// until something reads it, and reading each one flattens each one.
+		const text = code === undefined ? this.result() : code;
 		const chunks = this._chunks;
-		const tail = this._tail;
-		/**
-		 * @param {number} i piece index, `chunks.length` being the tail
-		 * @returns {string} that piece
-		 */
-		const pieceAt = (i) => (i === chunks.length ? tail : chunks[i]);
 		let atChunk = 0;
+		let chunkStart = 0;
 		let atOffset = 0;
 		let atLine = 0;
 		let atCol = 0;
-		// Offset of the next newline at or after the cursor, `-1` for none left in
-		// this piece. Carried rather than searched for per mapping: `indexOf` has no
-		// end bound, so asking it again for each of a piece's mappings scans again to
-		// the end of the piece every time — and minified output, the case with no
-		// newlines at all, is the one where that is the whole piece.
-		let nextNewline = pieceAt(0).indexOf("\n");
-		/**
-		 * @param {string} text the piece to walk
-		 * @param {number} to offset to walk to
-		 */
-		const advanceOver = (text, to) => {
-			while (nextNewline !== -1 && nextNewline < to) {
-				atLine++;
-				atCol = 0;
-				atOffset = nextNewline + 1;
-				nextNewline = text.indexOf("\n", atOffset);
-			}
-			atCol += to - atOffset;
-			atOffset = to;
-		};
-		/**
-		 * @param {number} chunk piece index to advance to
-		 * @param {number} offset offset within it
-		 */
-		const advanceTo = (chunk, offset) => {
-			while (atChunk < chunk) {
-				const text = pieceAt(atChunk);
-				advanceOver(text, text.length);
-				atChunk++;
-				atOffset = 0;
-				nextNewline = pieceAt(atChunk).indexOf("\n");
-			}
-			if (offset > atOffset) advanceOver(pieceAt(atChunk), offset);
-		};
+		// Offset of the next newline at or after the cursor, `-1` for none left.
+		// Carried rather than searched for per mapping: `indexOf` has no end bound.
+		let nextNewline = text.indexOf("\n");
 		for (const [chunkIndex, chunkOffset, sl, sc] of this._mappings) {
 			// Its piece was taken back, so there is no output left to anchor.
 			if (sl === -1) continue;
-			advanceTo(chunkIndex, chunkOffset);
+			// A piece's length is stored, so summing them costs nothing per byte.
+			while (atChunk < chunkIndex) chunkStart += chunks[atChunk++].length;
+			const to = chunkStart + chunkOffset;
+			if (to > atOffset) {
+				while (nextNewline !== -1 && nextNewline < to) {
+					atLine++;
+					atCol = 0;
+					atOffset = nextNewline + 1;
+					nextNewline = text.indexOf("\n", atOffset);
+				}
+				atCol += to - atOffset;
+				atOffset = to;
+			}
 			const gl = atLine;
 			const gc = atCol;
 			while (genLine < gl) {
@@ -915,7 +913,11 @@ class PrintContext {
 		if (this._insertIdx < this._inserts.length) this._flushBefore(Infinity);
 		// Nothing was ever cut into its own piece, so there is nothing to join.
 		const chunks = this._chunks;
-		return chunks.length === 0 ? this._tail : chunks.join("") + this._tail;
+		if (chunks.length === 0) return this._tail;
+		// The tail joins as a piece of its own, so the output comes back flat
+		// rather than as a rope over the join that every reader flattens again.
+		this._cutTail();
+		return chunks.join("");
 	}
 }
 
@@ -1030,16 +1032,21 @@ class SourceProcessor {
 		);
 		this._grammar(input, this._visitors, ctx, opts);
 		const name = /** @type {{ source?: string, content?: string }} */ (opts);
-		const build = () => ({
-			code: ctx.result(),
-			// Built only for a caller that named the input: building one walks the
-			// whole output for its line breaks, and the minifier prints an inline
-			// `style=""` — which asks for no map — thousands of times a document.
-			map:
-				name.source === undefined
-					? undefined
-					: ctx.sourceMap({ source: name.source, content: name.content })
-		});
+		const build = () => {
+			const code = ctx.result();
+			return {
+				code,
+				// Built only for a caller that named the input: a map walks the whole
+				// output, and an inline `style=""` asks for none thousands of times a page.
+				map:
+					name.source === undefined
+						? undefined
+						: ctx.sourceMap(
+								{ source: name.source, content: name.content },
+								code
+							)
+			};
+		};
 		if (this._deferred !== null) {
 			const finish = this._deferred;
 

package/lib/util/async.js

@@ -0,0 +1,292 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+/**
+ * Wraps the shared completion callback for one item, so an iterator that
+ * reports twice fails loudly instead of settling the run early.
+ * @template E
+ * @param {(err?: E | null) => void} done shared completion callback
+ * @returns {(err?: E | null) => void} completion callback for a single item
+ */
+const once = (done) => {
+	/** @type {((err?: E | null) => void) | undefined} */
+	let pending = done;
+	return (err) => {
+		const fn = pending;
+		if (fn === undefined) throw new Error("Callback was already called");
+		pending = undefined;
+		fn(err);
+	};
+};
+
+/**
+ * Runs `iterator` over every item with unlimited concurrency.
+ * Every item is started from one flat loop, so a synchronous iterator never
+ * grows the stack.
+ * @template T
+ * @template E
+ * @param {Iterable<T>} collection items to iterate
+ * @param {(item: T, callback: (err?: E | null) => void) => void} iterator called once per item
+ * @param {(err?: E | null) => void} callback called when every item is done, or with the first error
+ * @returns {void}
+ */
+const each = (collection, iterator, callback) => {
+	let remaining = 1;
+	let finished = false;
+
+	/**
+	 * @param {(E | null)=} err error
+	 * @returns {void}
+	 */
+	const done = (err) => {
+		if (finished) return;
+		if (err) {
+			finished = true;
+			callback(err);
+			return;
+		}
+		if (--remaining === 0) {
+			finished = true;
+			callback(null);
+		}
+	};
+
+	if (Array.isArray(collection)) {
+		const array = /** @type {T[]} */ (collection);
+		const length = array.length;
+		if (length === 0) return callback(null);
+		remaining = length;
+		// Dispatching continues past an error on purpose: callers rely on every
+		// item being started, e.g. to close every watcher when one close fails.
+		for (let i = 0; i < length; i++) iterator(array[i], once(done));
+		return;
+	}
+
+	// `remaining` starts at 1 so that completion cannot fire while items of a
+	// collection of unknown length are still being dispatched.
+	for (const item of collection) {
+		remaining++;
+		iterator(item, once(done));
+	}
+	done(null);
+};
+
+/**
+ * Runs `iterator` over every item, keeping at most `limit` of them in flight.
+ * A synchronous iterator is drained by the dispatch loop instead of by
+ * recursion, so the stack stays flat however long the collection is.
+ * @template T
+ * @template E
+ * @param {Iterable<T>} collection items to iterate
+ * @param {number} limit maximum number of items in flight
+ * @param {(item: T, callback: (err?: E | null) => void) => void} iterator called once per item
+ * @param {(err?: E | null) => void} callback called when every item is done, or with the first error
+ * @returns {void}
+ */
+const eachLimit = (collection, limit, iterator, callback) => {
+	const array = Array.isArray(collection)
+		? /** @type {T[]} */ (collection)
+		: undefined;
+	const length = array === undefined ? 0 : array.length;
+	const values =
+		array === undefined ? collection[Symbol.iterator]() : undefined;
+	let index = 0;
+	let running = 0;
+	let exhausted = false;
+	let finished = false;
+	let dispatching = false;
+
+	const dispatch = () => {
+		// A re-entrant call returns at once; the loop already running sees the
+		// slot the completed item freed and takes the next one itself.
+		if (dispatching) return;
+		dispatching = true;
+		while (running < limit && !exhausted) {
+			// `finished` is set from `done`, which an iterator may call before it
+			// returns, so it has to be re-read on every turn of this loop.
+			if (finished) break;
+			/** @type {T} */
+			let item;
+			if (array === undefined) {
+				const next = /** @type {Iterator<T>} */ (values).next();
+				if (next.done) {
+					exhausted = true;
+					break;
+				}
+				item = next.value;
+			} else {
+				if (index === length) {
+					exhausted = true;
+					break;
+				}
+				item = array[index++];
+			}
+			running++;
+			iterator(item, once(done));
+		}
+		dispatching = false;
+		if (exhausted && running === 0 && !finished) {
+			finished = true;
+			callback(null);
+		}
+	};
+
+	/**
+	 * @param {(E | null)=} err error
+	 * @returns {void}
+	 */
+	const done = (err) => {
+		if (finished) return;
+		running--;
+		if (err) {
+			finished = true;
+			callback(err);
+			return;
+		}
+		dispatch();
+	};
+
+	if (limit < 1) return callback(null);
+
+	dispatch();
+};
+
+/**
+ * Runs `iterator` over every item with unlimited concurrency and collects the
+ * results in the order of the collection, not the order of completion.
+ * @template T
+ * @template R
+ * @template E
+ * @param {Iterable<T>} collection items to iterate
+ * @param {(item: T, callback: (err?: E | null, result?: R) => void) => void} iterator called once per item
+ * @param {(err?: E | null, results?: R[]) => void} callback called with every result, or with the first error
+ * @returns {void}
+ */
+const map = (collection, iterator, callback) => {
+	const array = Array.isArray(collection)
+		? /** @type {T[]} */ (collection)
+		: undefined;
+	// Pre-sized, because growing it or `Array.from` costs measurably more on
+	// the small collections this is called with.
+	/** @type {R[]} */
+	// eslint-disable-next-line unicorn/no-new-array
+	const results = array === undefined ? [] : new Array(array.length);
+	let remaining = 1;
+	let finished = false;
+
+	/**
+	 * @param {(E | null)=} err error
+	 * @returns {void}
+	 */
+	const settle = (err) => {
+		if (finished) return;
+		if (err) {
+			finished = true;
+			callback(err, results);
+			return;
+		}
+		if (--remaining === 0) {
+			finished = true;
+			callback(null, results);
+		}
+	};
+
+	/**
+	 * @param {number} index position the result of that item belongs at
+	 * @returns {(err?: E | null, result?: R) => void} completion callback for that item
+	 */
+	const createCallback = (index) => {
+		let position = index;
+		return (err, result) => {
+			const at = position;
+			if (at === -1) throw new Error("Callback was already called");
+			position = -1;
+			// A result arriving after the run settled must not reach `results`,
+			// which the callback already handed to the caller.
+			if (finished) return;
+			if (!err) results[at] = /** @type {R} */ (result);
+			settle(err);
+		};
+	};
+
+	if (array !== undefined) {
+		const length = array.length;
+		if (length === 0) return callback(null, results);
+		remaining = length;
+		for (let i = 0; i < length; i++) iterator(array[i], createCallback(i));
+		return;
+	}
+
+	let index = 0;
+	for (const item of collection) {
+		remaining++;
+		iterator(item, createCallback(index++));
+	}
+	results.length = index;
+	settle(null);
+};
+
+/**
+ * Runs `iterator` over every item, at most `limit` of them in flight, and
+ * collects the results in the order of the collection, not of completion.
+ * @template T
+ * @template R
+ * @template E
+ * @param {Iterable<T>} collection items to iterate
+ * @param {number} limit maximum number of items in flight
+ * @param {(item: T, callback: (err?: E | null, result?: R) => void) => void} iterator called once per item
+ * @param {(err?: E | null, results?: R[]) => void} callback called with every result, or with the first error
+ * @returns {void}
+ */
+const mapLimit = (collection, limit, iterator, callback) => {
+	/** @type {R[]} */
+	const results = [];
+	let index = 0;
+	eachLimit(
+		collection,
+		limit,
+		(item, done) => {
+			// the dispatch loop hands out one item at a time, so this counts the
+			// position of the item rather than of whichever finishes first
+			const position = index++;
+			iterator(item, (err, result) => {
+				if (err) return done(err);
+				results[position] = /** @type {R} */ (result);
+				done(null);
+			});
+		},
+		(err) => {
+			if (err) return callback(err);
+			callback(null, results);
+		}
+	);
+};
+
+/**
+ * @template R
+ * @template E
+ * @param {(callback: (err?: E | null, result?: R) => void) => void} task task to run
+ * @param {(err?: E | null, result?: R) => void} callback called when the task is done
+ * @returns {void}
+ */
+const runTask = (task, callback) => task(callback);
+
+/**
+ * Runs every task in parallel and collects the results in task order.
+ * @template R
+ * @template E
+ * @param {((callback: (err?: E | null, result?: R) => void) => void)[]} tasks tasks to run
+ * @param {(err?: E | null, results?: R[]) => void} callback called with every result, or with the first error
+ * @returns {void}
+ */
+const parallel = (tasks, callback) => map(tasks, runTask, callback);
+
+module.exports.each = each;
+module.exports.eachLimit = eachLimit;
+module.exports.map = map;
+module.exports.mapLimit = mapLimit;
+module.exports.parallel = parallel;