webpack 5.65.0 → 5.69.0

package/lib/runtime/GetTrustedTypesPolicyRuntimeModule.js

@@ -0,0 +1,76 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
+
+"use strict";
+
+const RuntimeGlobals = require("../RuntimeGlobals");
+const Template = require("../Template");
+const HelperRuntimeModule = require("./HelperRuntimeModule");
+
+class GetTrustedTypesPolicyRuntimeModule extends HelperRuntimeModule {
+	/**
+	 * @param {Set<string>} runtimeRequirements runtime requirements
+	 */
+	constructor(runtimeRequirements) {
+		super("trusted types policy");
+		this.runtimeRequirements = runtimeRequirements;
+	}
+
+	/**
+	 * @returns {string} runtime code
+	 */
+	generate() {
+		const { compilation } = this;
+		const { runtimeTemplate, outputOptions } = compilation;
+		const { trustedTypes } = outputOptions;
+		const fn = RuntimeGlobals.getTrustedTypesPolicy;
+
+		return Template.asString([
+			"var policy;",
+			`${fn} = ${runtimeTemplate.basicFunction("", [
+				"// Create Trusted Type policy if Trusted Types are available and the policy doesn't exist yet.",
+				"if (policy === undefined) {",
+				Template.indent([
+					"policy = {",
+					Template.indent(
+						[
+							...(this.runtimeRequirements.has(RuntimeGlobals.createScript)
+								? [
+										`createScript: ${runtimeTemplate.returningFunction(
+											"script",
+											"script"
+										)}`
+								  ]
+								: []),
+							...(this.runtimeRequirements.has(RuntimeGlobals.createScriptUrl)
+								? [
+										`createScriptURL: ${runtimeTemplate.returningFunction(
+											"url",
+											"url"
+										)}`
+								  ]
+								: [])
+						].join(",\n")
+					),
+					"};",
+					...(trustedTypes
+						? [
+								'if (typeof trustedTypes !== "undefined" && trustedTypes.createPolicy) {',
+								Template.indent([
+									`policy = trustedTypes.createPolicy(${JSON.stringify(
+										trustedTypes.policyName
+									)}, policy);`
+								]),
+								"}"
+						  ]
+						: [])
+				]),
+				"}",
+				"return policy;"
+			])};`
+		]);
+	}
+}
+
+module.exports = GetTrustedTypesPolicyRuntimeModule;

package/lib/schemes/HttpUriPlugin.js

@@ -166,7 +166,7 @@ class Lockfile {
 /**
  * @template R
  * @param {function(function(Error=, R=): void): void} fn function
- * @returns {function(function(Error=, R=): void): void} cached function
+ * @returns {function(function((Error | null)=, R=): void): void} cached function
  */
 const cachedWithoutKey = fn => {
 	let inFlight = false;
@@ -201,10 +201,10 @@ const cachedWithoutKey = fn => {
  * @template R
  * @param {function(T, function(Error=, R=): void): void} fn function
  * @param {function(T, function(Error=, R=): void): void=} forceFn function for the second try
- * @returns {(function(T, function(Error=, R=): void): void) & { force: function(T, function(Error=, R=): void): void }} cached function
+ * @returns {(function(T, function((Error | null)=, R=): void): void) & { force: function(T, function((Error | null)=, R=): void): void }} cached function
  */
 const cachedWithKey = (fn, forceFn = fn) => {
-	/** @typedef {{ result?: R, error?: Error, callbacks?: (function(Error=, R=): void)[], force?: true }} CacheEntry */
+	/** @typedef {{ result?: R, error?: Error, callbacks?: (function((Error | null)=, R=): void)[], force?: true }} CacheEntry */
 	/** @type {Map<T, CacheEntry>} */
 	const cache = new Map();
 	const resultFn = (arg, callback) => {
@@ -358,7 +358,7 @@ class HttpUriPlugin {
 
 				const getLockfile = cachedWithoutKey(
 					/**
-					 * @param {function(Error=, Lockfile=): void} callback callback
+					 * @param {function((Error | null)=, Lockfile=): void} callback callback
 					 * @returns {void}
 					 */
 					callback => {
@@ -465,7 +465,7 @@ class HttpUriPlugin {
 					 *
 					 * @param {string} url URL
 					 * @param {string} integrity integrity
-					 * @param {function(Error=, { entry: LockfileEntry, content: Buffer, storeLock: boolean }=): void} callback callback
+					 * @param {function((Error | null)=, { entry: LockfileEntry, content: Buffer, storeLock: boolean }=): void} callback callback
 					 */
 					const resolveContent = (url, integrity, callback) => {
 						const handleResult = (err, result) => {
@@ -509,8 +509,8 @@ class HttpUriPlugin {
 
 					/**
 					 * @param {string} url URL
-					 * @param {FetchResult} cachedResult result from cache
-					 * @param {function(Error=, FetchResult=): void} callback callback
+					 * @param {FetchResult | RedirectFetchResult} cachedResult result from cache
+					 * @param {function((Error | null)=, FetchResult=): void} callback callback
 					 * @returns {void}
 					 */
 					const fetchContentRaw = (url, cachedResult, callback) => {
@@ -603,9 +603,30 @@ class HttpUriPlugin {
 									res.statusCode >= 301 &&
 									res.statusCode <= 308
 								) {
-									return finishWith({
+									const result = {
 										location: new URL(location, url).href
-									});
+									};
+									if (
+										!cachedResult ||
+										!("location" in cachedResult) ||
+										cachedResult.location !== result.location ||
+										cachedResult.validUntil < validUntil ||
+										cachedResult.storeLock !== storeLock ||
+										cachedResult.storeCache !== storeCache ||
+										cachedResult.etag !== etag
+									) {
+										return finishWith(result);
+									} else {
+										logger.debug(`GET ${url} [${res.statusCode}] (unchanged)`);
+										return callback(null, {
+											...result,
+											fresh: true,
+											storeLock,
+											storeCache,
+											validUntil,
+											etag
+										});
+									}
 								}
 								const contentType = res.headers["content-type"] || "";
 								const bufferArr = [];
@@ -662,7 +683,7 @@ class HttpUriPlugin {
 					const fetchContent = cachedWithKey(
 						/**
 						 * @param {string} url URL
-						 * @param {function(Error=, { validUntil: number, etag?: string, entry: LockfileEntry, content: Buffer, fresh: boolean } | { validUntil: number, etag?: string, location: string, fresh: boolean }=): void} callback callback
+						 * @param {function((Error | null)=, { validUntil: number, etag?: string, entry: LockfileEntry, content: Buffer, fresh: boolean } | { validUntil: number, etag?: string, location: string, fresh: boolean }=): void} callback callback
 						 * @returns {void}
 						 */ (url, callback) => {
 							cache.get(url, null, (err, cachedResult) => {
@@ -693,7 +714,7 @@ class HttpUriPlugin {
 					const getInfo = cachedWithKey(
 						/**
 						 * @param {string} url the url
-						 * @param {function(Error=, { entry: LockfileEntry, content: Buffer }=): void} callback callback
+						 * @param {function((Error | null)=, { entry: LockfileEntry, content: Buffer }=): void} callback callback
 						 * @returns {void}
 						 */
 						(url, callback) => {

package/lib/serialization/FileMiddleware.js

@@ -40,6 +40,8 @@ Section -> Buffer
 
 // "wpc" + 1 in little-endian
 const VERSION = 0x01637077;
+const WRITE_LIMIT_TOTAL = 0x7fff0000;
+const WRITE_LIMIT_CHUNK = 511 * 1024 * 1024;
 
 /**
  * @param {Buffer[]} buffers buffers
@@ -87,7 +89,7 @@ const readUInt64LE = Buffer.prototype.readBigUInt64LE
  * @param {FileMiddleware} middleware this
  * @param {BufferSerializableType[] | Promise<BufferSerializableType[]>} data data to be serialized
  * @param {string | boolean} name file base name
- * @param {function(string | false, Buffer[]): Promise<void>} writeFile writes a file
+ * @param {function(string | false, Buffer[], number): Promise<void>} writeFile writes a file
  * @param {string | Hash} hashFunction hash function to use
  * @returns {Promise<SerializeResult>} resulting file pointer and promise
  */
@@ -212,9 +214,9 @@ const serialize = async (
 	if (name === true) {
 		name = hashForName(buf, hashFunction);
 	}
-	backgroundJobs.push(writeFile(name, buf));
 	let size = 0;
 	for (const b of buf) size += b.length;
+	backgroundJobs.push(writeFile(name, buf, size));
 	return {
 		size,
 		name,
@@ -422,7 +424,7 @@ class FileMiddleware extends SerializerMiddleware {
 				// It's important that we don't touch existing files during serialization
 				// because serialize may read existing files (when deserializing)
 				const allWrittenFiles = new Set();
-				const writeFile = async (name, content) => {
+				const writeFile = async (name, content, size) => {
 					const file = name
 						? join(this.fs, filename, `../${name}${extension}`)
 						: filename;
@@ -441,10 +443,7 @@ class FileMiddleware extends SerializerMiddleware {
 									[zConstants.BROTLI_PARAM_MODE]: zConstants.BROTLI_MODE_TEXT,
 									[zConstants.BROTLI_PARAM_QUALITY]: 2,
 									[zConstants.BROTLI_PARAM_DISABLE_LITERAL_CONTEXT_MODELING]: true,
-									[zConstants.BROTLI_PARAM_SIZE_HINT]: content.reduce(
-										(size, b) => size + b.length,
-										0
-									)
+									[zConstants.BROTLI_PARAM_SIZE_HINT]: size
 								}
 							});
 						}
@@ -456,8 +455,44 @@ class FileMiddleware extends SerializerMiddleware {
 							stream.on("error", err => reject(err));
 							stream.on("finish", () => resolve());
 						}
-						for (const b of content) stream.write(b);
-						stream.end();
+						// split into chunks for WRITE_LIMIT_CHUNK size
+						const chunks = [];
+						for (const b of content) {
+							if (b.length < WRITE_LIMIT_CHUNK) {
+								chunks.push(b);
+							} else {
+								for (let i = 0; i < b.length; i += WRITE_LIMIT_CHUNK) {
+									chunks.push(b.slice(i, i + WRITE_LIMIT_CHUNK));
+								}
+							}
+						}
+
+						const len = chunks.length;
+						let i = 0;
+						const batchWrite = err => {
+							// will be handled in "on" error handler
+							if (err) return;
+
+							if (i === len) {
+								stream.end();
+								return;
+							}
+
+							// queue up a batch of chunks up to the write limit
+							// end is exclusive
+							let end = i;
+							let sum = chunks[end++].length;
+							while (end < len) {
+								sum += chunks[end].length;
+								if (sum > WRITE_LIMIT_TOTAL) break;
+								end++;
+							}
+							while (i < end - 1) {
+								stream.write(chunks[i++]);
+							}
+							stream.write(chunks[i++], batchWrite);
+						};
+						batchWrite();
 					});
 					if (name) allWrittenFiles.add(file);
 				};

package/lib/sharing/ConsumeSharedModule.js

@@ -101,14 +101,16 @@ class ConsumeSharedModule extends Module {
 	 */
 	libIdent(options) {
 		const { shareKey, shareScope, import: request } = this.options;
-		return `webpack/sharing/consume/${shareScope}/${shareKey}${
+		return `${
+			this.layer ? `(${this.layer})/` : ""
+		}webpack/sharing/consume/${shareScope}/${shareKey}${
 			request ? `/${request}` : ""
 		}`;
 	}
 
 	/**
 	 * @param {NeedBuildContext} context context info
-	 * @param {function(WebpackError=, boolean=): void} callback callback function, returns true, if the module needs a rebuild
+	 * @param {function((WebpackError | null)=, boolean=): void} callback callback function, returns true, if the module needs a rebuild
 	 * @returns {void}
 	 */
 	needBuild(context, callback) {

package/lib/sharing/ProvideSharedModule.js

@@ -67,12 +67,14 @@ class ProvideSharedModule extends Module {
 	 * @returns {string | null} an identifier for library inclusion
 	 */
 	libIdent(options) {
-		return `webpack/sharing/provide/${this._shareScope}/${this._name}`;
+		return `${this.layer ? `(${this.layer})/` : ""}webpack/sharing/provide/${
+			this._shareScope
+		}/${this._name}`;
 	}
 
 	/**
 	 * @param {NeedBuildContext} context context info
-	 * @param {function(WebpackError=, boolean=): void} callback callback function, returns true, if the module needs a rebuild
+	 * @param {function((WebpackError | null)=, boolean=): void} callback callback function, returns true, if the module needs a rebuild
 	 * @returns {void}
 	 */
 	needBuild(context, callback) {

package/lib/sharing/utils.js

@@ -22,7 +22,7 @@ exports.isRequiredVersion = str => {
  * @param {InputFileSystem} fs file system
  * @param {string} directory directory to start looking into
  * @param {string[]} descriptionFiles possible description filenames
- * @param {function(Error=, {data: object, path: string}=): void} callback callback
+ * @param {function((Error | null)=, {data: object, path: string}=): void} callback callback
  */
 const getDescriptionFile = (fs, directory, descriptionFiles, callback) => {
 	let i = 0;

package/lib/stats/DefaultStatsFactoryPlugin.js

@@ -1658,84 +1658,121 @@ const collapse = children => {
 	return newChildren;
 };
 
-const spaceLimited = (itemsAndGroups, max) => {
+const spaceLimited = (
+	itemsAndGroups,
+	max,
+	filteredChildrenLineReserved = false
+) => {
+	if (max < 1) {
+		return {
+			children: undefined,
+			filteredChildren: getTotalItems(itemsAndGroups)
+		};
+	}
 	/** @type {any[] | undefined} */
 	let children = undefined;
 	/** @type {number | undefined} */
 	let filteredChildren = undefined;
 	// This are the groups, which take 1+ lines each
-	const groups = itemsAndGroups.filter(c => c.children || c.filteredChildren);
+	const groups = [];
 	// The sizes of the groups are stored in groupSizes
-	const groupSizes = groups.map(g => getItemSize(g));
+	const groupSizes = [];
 	// This are the items, which take 1 line each
-	const items = itemsAndGroups.filter(c => !c.children && !c.filteredChildren);
+	const items = [];
 	// The total of group sizes
-	let groupsSize = groupSizes.reduce((a, b) => a + b, 0);
+	let groupsSize = 0;
+
+	for (const itemOrGroup of itemsAndGroups) {
+		// is item
+		if (!itemOrGroup.children && !itemOrGroup.filteredChildren) {
+			items.push(itemOrGroup);
+		} else {
+			groups.push(itemOrGroup);
+			const size = getItemSize(itemOrGroup);
+			groupSizes.push(size);
+			groupsSize += size;
+		}
+	}
+
 	if (groupsSize + items.length <= max) {
 		// The total size in the current state fits into the max
 		// keep all
-		children = groups.concat(items);
-	} else if (
-		groups.length > 0 &&
-		groups.length + Math.min(1, items.length) < max
-	) {
-		// If each group would take 1 line the total would be below the maximum
-		// collapse some groups, keep items
-		while (groupsSize + items.length + (filteredChildren ? 1 : 0) > max) {
+		children = groups.length > 0 ? groups.concat(items) : items;
+	} else if (groups.length === 0) {
+		// slice items to max
+		// inner space marks that lines for filteredChildren already reserved
+		const limit = max - (filteredChildrenLineReserved ? 0 : 1);
+		filteredChildren = items.length - limit;
+		items.length = limit;
+		children = items;
+	} else {
+		// limit is the size when all groups are collapsed
+		const limit =
+			groups.length +
+			(filteredChildrenLineReserved || items.length === 0 ? 0 : 1);
+		if (limit < max) {
 			// calculate how much we are over the size limit
 			// this allows to approach the limit faster
-			// it's always > 1
-			const oversize =
-				items.length + groupsSize + (filteredChildren ? 1 : 0) - max;
-			// Find the maximum group and process only this one
-			const maxGroupSize = Math.max(...groupSizes);
-			if (maxGroupSize < items.length) {
-				filteredChildren = items.length;
-				items.length = 0;
-				continue;
-			}
-			for (let i = 0; i < groups.length; i++) {
-				if (groupSizes[i] === maxGroupSize) {
-					const group = groups[i];
-					// run this algorithm recursively and limit the size of the children to
-					// current size - oversize / number of groups
-					// So it should always end up being smaller
-					const headerSize = !group.children
-						? 0
-						: group.filteredChildren
-						? 2
-						: 1;
-					const limited = spaceLimited(
-						group.children,
-						groupSizes[i] - headerSize - oversize / groups.length
-					);
-					groups[i] = {
-						...group,
-						children: limited.children,
-						filteredChildren:
-							(group.filteredChildren || 0) + limited.filteredChildren
-					};
-					const newSize = getItemSize(groups[i]);
-					groupsSize -= groupSizes[i] - newSize;
-					groupSizes[i] = newSize;
-					break;
+			let oversize;
+			// If each group would take 1 line the total would be below the maximum
+			// collapse some groups, keep items
+			while (
+				(oversize =
+					groupsSize +
+					items.length +
+					(filteredChildren && !filteredChildrenLineReserved ? 1 : 0) -
+					max) > 0
+			) {
+				// Find the maximum group and process only this one
+				const maxGroupSize = Math.max(...groupSizes);
+				if (maxGroupSize < items.length) {
+					filteredChildren = items.length;
+					items.length = 0;
+					continue;
+				}
+				for (let i = 0; i < groups.length; i++) {
+					if (groupSizes[i] === maxGroupSize) {
+						const group = groups[i];
+						// run this algorithm recursively and limit the size of the children to
+						// current size - oversize / number of groups
+						// So it should always end up being smaller
+						const headerSize = group.filteredChildren ? 2 : 1;
+						const limited = spaceLimited(
+							group.children,
+							maxGroupSize -
+								// we should use ceil to always feet in max
+								Math.ceil(oversize / groups.length) -
+								// we substitute size of group head
+								headerSize,
+							headerSize === 2
+						);
+						groups[i] = {
+							...group,
+							children: limited.children,
+							filteredChildren: limited.filteredChildren
+								? (group.filteredChildren || 0) + limited.filteredChildren
+								: group.filteredChildren
+						};
+						const newSize = getItemSize(groups[i]);
+						groupsSize -= maxGroupSize - newSize;
+						groupSizes[i] = newSize;
+						break;
+					}
 				}
 			}
+			children = groups.concat(items);
+		} else if (limit === max) {
+			// If we have only enough space to show one line per group and one line for the filtered items
+			// collapse all groups and items
+			children = collapse(groups);
+			filteredChildren = items.length;
+		} else {
+			// If we have no space
+			// collapse complete group
+			filteredChildren = getTotalItems(itemsAndGroups);
 		}
-		children = groups.concat(items);
-	} else if (
-		groups.length > 0 &&
-		groups.length + Math.min(1, items.length) <= max
-	) {
-		// If we have only enough space to show one line per group and one line for the filtered items
-		// collapse all groups and items
-		children = groups.length ? collapse(groups) : undefined;
-		filteredChildren = items.length;
-	} else {
-		// If we have no space
-		// collapse complete group
-		filteredChildren = getTotalItems(itemsAndGroups);
 	}
+
 	return {
 		children,
 		filteredChildren
@@ -1777,6 +1814,9 @@ const reasonGroup = (children, reasons) => {
 	};
 };
 
+const GROUP_EXTENSION_REGEXP = /(\.[^.]+?)(?:\?|(?: \+ \d+ modules?)?$)/;
+const GROUP_PATH_REGEXP = /(.+)[/\\][^/\\]+?(?:\?|(?: \+ \d+ modules?)?$)/;
+
 /** @type {Record<string, (groupConfigs: GroupConfig[], context: StatsFactoryContext, options: NormalizedStatsOptions) => void>} */
 const ASSETS_GROUPERS = {
 	_: (groupConfigs, context, options) => {
@@ -1825,10 +1865,10 @@ const ASSETS_GROUPERS = {
 			groupConfigs.push({
 				getKeys: asset => {
 					const extensionMatch =
-						groupAssetsByExtension && /(\.[^.]+)(?:\?.*|$)/.exec(asset.name);
+						groupAssetsByExtension && GROUP_EXTENSION_REGEXP.exec(asset.name);
 					const extension = extensionMatch ? extensionMatch[1] : "";
 					const pathMatch =
-						groupAssetsByPath && /(.+)[/\\][^/\\]+(?:\?.*|$)/.exec(asset.name);
+						groupAssetsByPath && GROUP_PATH_REGEXP.exec(asset.name);
 					const path = pathMatch ? pathMatch[1].split(/[/\\]/) : [];
 					const keys = [];
 					if (groupAssetsByPath) {
@@ -2022,11 +2062,13 @@ const MODULES_GROUPERS = type => ({
 				getKeys: module => {
 					if (!module.name) return;
 					const resource = parseResource(module.name.split("!").pop()).path;
+					const dataUrl = /^data:[^,;]+/.exec(resource);
+					if (dataUrl) return [dataUrl[0]];
 					const extensionMatch =
-						groupModulesByExtension && /(\.[^.]+)(?:\?.*|$)/.exec(resource);
+						groupModulesByExtension && GROUP_EXTENSION_REGEXP.exec(resource);
 					const extension = extensionMatch ? extensionMatch[1] : "";
 					const pathMatch =
-						groupModulesByPath && /(.+)[/\\][^/\\]+(?:\?.*|$)/.exec(resource);
+						groupModulesByPath && GROUP_PATH_REGEXP.exec(resource);
 					const path = pathMatch ? pathMatch[1].split(/[/\\]/) : [];
 					const keys = [];
 					if (groupModulesByPath) {
@@ -2046,11 +2088,14 @@ const MODULES_GROUPERS = type => ({
 					return keys;
 				},
 				createGroup: (key, children, modules) => {
+					const isDataUrl = key.startsWith("data:");
 					return {
-						type: groupModulesByPath
+						type: isDataUrl
+							? "modules by mime type"
+							: groupModulesByPath
 							? "modules by path"
 							: "modules by extension",
-						name: key,
+						name: isDataUrl ? key.slice(/* 'data:'.length */ 5) : key,
 						children,
 						...moduleGroup(children, modules)
 					};