webpack 5.59.0 → 5.71.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

@@ -5,6 +5,7 @@
 
 "use strict";
 
+const EventEmitter = require("events");
 const { extname, basename } = require("path");
 const { URL } = require("url");
 const { createGunzip, createBrotliDecompress, createInflate } = require("zlib");
@@ -19,6 +20,44 @@ const memoize = require("../util/memoize");
 
 const getHttp = memoize(() => require("http"));
 const getHttps = memoize(() => require("https"));
+const proxyFetch = (request, proxy) => (url, options, callback) => {
+	const eventEmitter = new EventEmitter();
+	const doRequest = socket =>
+		request
+			.get(url, { ...options, ...(socket && { socket }) }, callback)
+			.on("error", eventEmitter.emit.bind(eventEmitter, "error"));
+
+	if (proxy) {
+		const { hostname: host, port } = new URL(proxy);
+
+		getHttp()
+			.request({
+				host, // IP address of proxy server
+				port, // port of proxy server
+				method: "CONNECT",
+				path: url.host
+			})
+			.on("connect", (res, socket) => {
+				if (res.statusCode === 200) {
+					// connected to proxy server
+					doRequest(socket);
+				}
+			})
+			.on("error", err => {
+				eventEmitter.emit(
+					"error",
+					new Error(
+						`Failed to connect to proxy server "${proxy}": ${err.message}`
+					)
+				);
+			})
+			.end();
+	} else {
+		doRequest();
+	}
+
+	return eventEmitter;
+};
 
 /** @type {(() => void)[] | undefined} */
 let inProgressWrite = undefined;
@@ -166,7 +205,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 +240,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) => {
@@ -274,6 +313,7 @@ class HttpUriPlugin {
 		this._upgrade = options.upgrade;
 		this._frozen = options.frozen;
 		this._allowedUris = options.allowedUris;
+		this._proxy = options.proxy;
 	}
 
 	/**
@@ -282,15 +322,16 @@ class HttpUriPlugin {
 	 * @returns {void}
 	 */
 	apply(compiler) {
+		const proxy =
+			this._proxy || process.env["http_proxy"] || process.env["HTTP_PROXY"];
 		const schemes = [
 			{
 				scheme: "http",
-				fetch: (url, options, callback) => getHttp().get(url, options, callback)
+				fetch: proxyFetch(getHttp(), proxy)
 			},
 			{
 				scheme: "https",
-				fetch: (url, options, callback) =>
-					getHttps().get(url, options, callback)
+				fetch: proxyFetch(getHttps(), proxy)
 			}
 		];
 		let lockfileCache;
@@ -358,7 +399,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 +506,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 +550,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 +644,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 +724,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 +755,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) => {
@@ -1044,6 +1106,7 @@ Run build with un-frozen lockfile to automatically fix lockfile.`
 							inProgressWrite.push(runWrite);
 						} else {
 							inProgressWrite = [];
+							runWrite();
 						}
 					}
 				);

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) {
@@ -210,6 +212,10 @@ class ConsumeSharedModule extends Module {
 			}
 			args.push(stringifyHoley(requiredVersion));
 			fn += "VersionCheck";
+		} else {
+			if (singleton) {
+				fn += "Singleton";
+			}
 		}
 		if (fallbackCode) {
 			fn += "Fallback";

package/lib/sharing/ConsumeSharedRuntimeModule.js

@@ -103,9 +103,16 @@ class ConsumeSharedRuntimeModule extends RuntimeModule {
 				]
 			)};`,
 			`var getInvalidSingletonVersionMessage = ${runtimeTemplate.basicFunction(
-				"key, version, requiredVersion",
+				"scope, key, version, requiredVersion",
 				[
-					`return "Unsatisfied version " + version + " of shared singleton module " + key + " (required " + rangeToString(requiredVersion) + ")"`
+					`return "Unsatisfied version " + version + " from " + (version && scope[key][version].from) + " of shared singleton module " + key + " (required " + rangeToString(requiredVersion) + ")"`
+				]
+			)};`,
+			`var getSingleton = ${runtimeTemplate.basicFunction(
+				"scope, scopeName, key, requiredVersion",
+				[
+					"var version = findSingletonVersionKey(scope, key);",
+					"return get(scope[key][version]);"
 				]
 			)};`,
 			`var getSingletonVersion = ${runtimeTemplate.basicFunction(
@@ -113,7 +120,7 @@ class ConsumeSharedRuntimeModule extends RuntimeModule {
 				[
 					"var version = findSingletonVersionKey(scope, key);",
 					"if (!satisfy(requiredVersion, version)) " +
-						'typeof console !== "undefined" && console.warn && console.warn(getInvalidSingletonVersionMessage(key, version, requiredVersion));',
+						'typeof console !== "undefined" && console.warn && console.warn(getInvalidSingletonVersionMessage(scope, key, version, requiredVersion));',
 					"return get(scope[key][version]);"
 				]
 			)};`,
@@ -122,7 +129,7 @@ class ConsumeSharedRuntimeModule extends RuntimeModule {
 				[
 					"var version = findSingletonVersionKey(scope, key);",
 					"if (!satisfy(requiredVersion, version)) " +
-						"throw new Error(getInvalidSingletonVersionMessage(key, version, requiredVersion));",
+						"throw new Error(getInvalidSingletonVersionMessage(scope, key, version, requiredVersion));",
 					"return get(scope[key][version]);"
 				]
 			)};`,
@@ -202,6 +209,13 @@ class ConsumeSharedRuntimeModule extends RuntimeModule {
 					"return get(findValidVersion(scope, key, version) || warnInvalidVersion(scope, scopeName, key, version) || findVersion(scope, key));"
 				]
 			)});`,
+			`var loadSingleton = /*#__PURE__*/ init(${runtimeTemplate.basicFunction(
+				"scopeName, scope, key",
+				[
+					"ensureExistence(scopeName, key);",
+					"return getSingleton(scope, scopeName, key);"
+				]
+			)});`,
 			`var loadSingletonVersionCheck = /*#__PURE__*/ init(${runtimeTemplate.basicFunction(
 				"scopeName, scope, key, version",
 				[
@@ -230,6 +244,13 @@ class ConsumeSharedRuntimeModule extends RuntimeModule {
 					"return get(findValidVersion(scope, key, version) || warnInvalidVersion(scope, scopeName, key, version) || findVersion(scope, key));"
 				]
 			)});`,
+			`var loadSingletonFallback = /*#__PURE__*/ init(${runtimeTemplate.basicFunction(
+				"scopeName, scope, key, fallback",
+				[
+					`if(!scope || !${RuntimeGlobals.hasOwnProperty}(scope, key)) return fallback();`,
+					"return getSingleton(scope, scopeName, key);"
+				]
+			)});`,
 			`var loadSingletonVersionCheckFallback = /*#__PURE__*/ init(${runtimeTemplate.basicFunction(
 				"scopeName, scope, key, version, fallback",
 				[
@@ -320,7 +341,7 @@ class ConsumeSharedRuntimeModule extends RuntimeModule {
 											"var promise = moduleToHandlerMapping[id]();",
 											"if(promise.then) {",
 											Template.indent(
-												`promises.push(installedModules[id] = promise.then(onFactory).catch(onError));`
+												"promises.push(installedModules[id] = promise.then(onFactory)['catch'](onError));"
 											),
 											"} else onFactory(promise);"
 										]),

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/ShareRuntimeModule.js

@@ -105,7 +105,7 @@ class ShareRuntimeModule extends RuntimeModule {
 							)}`,
 							"if(module.then) return promises.push(module.then(initFn, handleError));",
 							"var initResult = initFn(module);",
-							"if(initResult && initResult.then) return promises.push(initResult.catch(handleError));"
+							"if(initResult && initResult.then) return promises.push(initResult['catch'](handleError));"
 						]),
 						"} catch(err) { handleError(err); }"
 					])}`,

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;