webpack 5.97.1 → 5.104.1

package/lib/schemes/VirtualUrlPlugin.js

@@ -0,0 +1,222 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Natsu @xiaoxiaojx
+*/
+
+"use strict";
+
+const { NormalModule } = require("..");
+const ModuleNotFoundError = require("../ModuleNotFoundError");
+const { parseResourceWithoutFragment } = require("../util/identifier");
+
+/** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../NormalModule")} NormalModule */
+
+/**
+ * @template T
+ * @typedef {import("../../declarations/LoaderContext").LoaderContext<T>} LoaderContext
+ */
+
+const PLUGIN_NAME = "VirtualUrlPlugin";
+const DEFAULT_SCHEME = "virtual";
+
+/** @typedef {(loaderContext: LoaderContext<EXPECTED_ANY>) => Promise<string | Buffer> | string | Buffer} SourceFn */
+/** @typedef {() => string} VersionFn */
+
+/**
+ * @typedef {object} VirtualModuleConfig
+ * @property {string=} type the module type
+ * @property {SourceFn} source the source function
+ * @property {VersionFn | true | string=} version optional version function or value
+ */
+
+/**
+ * @typedef {string | SourceFn | VirtualModuleConfig} VirtualModuleInput
+ */
+
+/** @typedef {{ [key: string]: VirtualModuleInput }} VirtualModules */
+
+/**
+ * Normalizes a virtual module definition into a standard format
+ * @param {VirtualModuleInput} virtualConfig The virtual module to normalize
+ * @returns {VirtualModuleConfig} The normalized virtual module
+ */
+function normalizeModule(virtualConfig) {
+	if (typeof virtualConfig === "string") {
+		return {
+			type: "",
+			source() {
+				return virtualConfig;
+			}
+		};
+	} else if (typeof virtualConfig === "function") {
+		return {
+			type: "",
+			source: virtualConfig
+		};
+	}
+	return virtualConfig;
+}
+
+/**
+ * Normalizes all virtual modules with the given scheme
+ * @param {VirtualModules} virtualConfigs The virtual modules to normalize
+ * @param {string} scheme The URL scheme to use
+ * @returns {{ [key: string]: VirtualModuleConfig }} The normalized virtual modules
+ */
+function normalizeModules(virtualConfigs, scheme) {
+	return Object.keys(virtualConfigs).reduce((pre, id) => {
+		pre[toVid(id, scheme)] = normalizeModule(virtualConfigs[id]);
+		return pre;
+	}, /** @type {{ [key: string]: VirtualModuleConfig }} */ ({}));
+}
+
+/**
+ * Converts a module id and scheme to a virtual module id
+ * @param {string} id The module id
+ * @param {string} scheme The URL scheme
+ * @returns {string} The virtual module id
+ */
+function toVid(id, scheme) {
+	return `${scheme}:${id}`;
+}
+
+const VALUE_DEP_VERSION = `webpack/${PLUGIN_NAME}/version`;
+
+/**
+ * Converts a module id and scheme to a cache key
+ * @param {string} id The module id
+ * @param {string} scheme The URL scheme
+ * @returns {string} The cache key
+ */
+function toCacheKey(id, scheme) {
+	return `${VALUE_DEP_VERSION}/${toVid(id, scheme)}`;
+}
+
+/**
+ * @typedef {object} VirtualUrlPluginOptions
+ * @property {VirtualModules} modules - The virtual modules
+ * @property {string=} scheme - The URL scheme to use
+ */
+
+class VirtualUrlPlugin {
+	/**
+	 * @param {VirtualModules} modules The virtual modules
+	 * @param {string=} scheme The URL scheme to use
+	 */
+	constructor(modules, scheme) {
+		this.scheme = scheme || DEFAULT_SCHEME;
+		this.modules = normalizeModules(modules, this.scheme);
+	}
+
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		const scheme = this.scheme;
+		const cachedParseResourceWithoutFragment =
+			parseResourceWithoutFragment.bindCache(compiler.root);
+
+		compiler.hooks.compilation.tap(
+			PLUGIN_NAME,
+			(compilation, { normalModuleFactory }) => {
+				normalModuleFactory.hooks.resolveForScheme
+					.for(scheme)
+					.tap(PLUGIN_NAME, (resourceData) => {
+						const virtualConfig = this.findVirtualModuleConfigById(
+							resourceData.resource
+						);
+						const url = cachedParseResourceWithoutFragment(
+							resourceData.resource
+						);
+						const path = url.path;
+						const type = virtualConfig.type;
+						resourceData.path = path + type;
+						resourceData.resource = path;
+
+						if (virtualConfig.version) {
+							const cacheKey = toCacheKey(resourceData.resource, scheme);
+							const cacheVersion = this.getCacheVersion(virtualConfig.version);
+							compilation.valueCacheVersions.set(
+								cacheKey,
+								/** @type {string} */ (cacheVersion)
+							);
+						}
+
+						return true;
+					});
+
+				const hooks = NormalModule.getCompilationHooks(compilation);
+				hooks.readResource
+					.for(scheme)
+					.tapAsync(PLUGIN_NAME, async (loaderContext, callback) => {
+						const { resourcePath } = loaderContext;
+						const module = /** @type {NormalModule} */ (loaderContext._module);
+						const cacheKey = toCacheKey(resourcePath, scheme);
+
+						const addVersionValueDependency = () => {
+							if (!module || !module.buildInfo) return;
+
+							const buildInfo = module.buildInfo;
+							if (!buildInfo.valueDependencies) {
+								buildInfo.valueDependencies = new Map();
+							}
+
+							const cacheVersion = compilation.valueCacheVersions.get(cacheKey);
+							if (compilation.valueCacheVersions.has(cacheKey)) {
+								buildInfo.valueDependencies.set(
+									cacheKey,
+									/** @type {string} */ (cacheVersion)
+								);
+							}
+						};
+
+						try {
+							const virtualConfig =
+								this.findVirtualModuleConfigById(resourcePath);
+							const content = await virtualConfig.source(loaderContext);
+							addVersionValueDependency();
+							callback(null, content);
+						} catch (err) {
+							callback(/** @type {Error} */ (err));
+						}
+					});
+			}
+		);
+	}
+
+	/**
+	 * @param {string} id The module id
+	 * @returns {VirtualModuleConfig} The virtual module config
+	 */
+	findVirtualModuleConfigById(id) {
+		const config = this.modules[id];
+		if (!config) {
+			throw new ModuleNotFoundError(
+				null,
+				new Error(`Can't resolve virtual module ${id}`),
+				{
+					name: `virtual module ${id}`
+				}
+			);
+		}
+		return config;
+	}
+
+	/**
+	 * Get the cache version for a given version value
+	 * @param {VersionFn | true | string} version The version value or function
+	 * @returns {string | undefined} The cache version
+	 */
+	getCacheVersion(version) {
+		return version === true
+			? undefined
+			: (typeof version === "function" ? version() : version) || "unset";
+	}
+}
+
+VirtualUrlPlugin.DEFAULT_SCHEME = DEFAULT_SCHEME;
+
+module.exports = VirtualUrlPlugin;

package/lib/serialization/AggregateErrorSerializer.js

@@ -0,0 +1,41 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
+
+"use strict";
+
+/** @typedef {import("./ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
+/** @typedef {import("./ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+
+/** @typedef {Error & { cause?: unknown, errors: EXPECTED_ANY[] }} AggregateError */
+
+class AggregateErrorSerializer {
+	/**
+	 * @param {AggregateError} obj error
+	 * @param {ObjectSerializerContext} context context
+	 */
+	serialize(obj, context) {
+		context.write(obj.errors);
+		context.write(obj.message);
+		context.write(obj.stack);
+		context.write(obj.cause);
+	}
+
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 * @returns {AggregateError} error
+	 */
+	deserialize(context) {
+		const errors = context.read();
+		// eslint-disable-next-line n/no-unsupported-features/es-builtins, n/no-unsupported-features/es-syntax, unicorn/error-message
+		const err = new AggregateError(errors);
+
+		err.message = context.read();
+		err.stack = context.read();
+		err.cause = context.read();
+
+		return err;
+	}
+}
+
+module.exports = AggregateErrorSerializer;

package/lib/serialization/BinaryMiddleware.js

@@ -117,7 +117,7 @@ const MEASURE_END_OPERATION = Symbol("MEASURE_END_OPERATION");
  * @param {number} n number
  * @returns {0 | 1 | 2} type of number for serialization
  */
-const identifyNumber = n => {
+const identifyNumber = (n) => {
 	if (n === (n | 0)) {
 		if (n <= 127 && n >= -128) return 0;
 		if (n <= 2147483647 && n >= -2147483648) return 1;
@@ -129,43 +129,49 @@ const identifyNumber = n => {
  * @param {bigint} n bigint
  * @returns {0 | 1 | 2} type of bigint for serialization
  */
-const identifyBigInt = n => {
+const identifyBigInt = (n) => {
 	if (n <= BigInt(127) && n >= BigInt(-128)) return 0;
 	if (n <= BigInt(2147483647) && n >= BigInt(-2147483648)) return 1;
 	return 2;
 };
 
-/** @typedef {TODO} Context */
+/** @typedef {PrimitiveSerializableType[]} DeserializedType */
+/** @typedef {BufferSerializableType[]} SerializedType} */
+/** @typedef {{ retainedBuffer?: (x: Buffer) => Buffer }} Context} */
 
 /**
- * @typedef {PrimitiveSerializableType[]} DeserializedType
- * @typedef {BufferSerializableType[]} SerializedType
- * @extends {SerializerMiddleware<DeserializedType, SerializedType>}
+ * @template LazyInputValue
+ * @template LazyOutputValue
+ * @typedef {import("./SerializerMiddleware").LazyFunction<LazyInputValue, LazyOutputValue, BinaryMiddleware, undefined>} LazyFunction
+ */
+
+/**
+ * @extends {SerializerMiddleware<DeserializedType, SerializedType, Context>}
  */
 class BinaryMiddleware extends SerializerMiddleware {
 	/**
 	 * @param {DeserializedType} data data
-	 * @param {object} context context object
-	 * @returns {SerializedType|Promise<SerializedType>} serialized data
+	 * @param {Context} context context object
+	 * @returns {SerializedType | Promise<SerializedType> | null} serialized data
 	 */
 	serialize(data, context) {
 		return this._serialize(data, context);
 	}
 
 	/**
-	 * @param {function(): Promise<any> | any} fn lazy function
-	 * @param {TODO} context serialize function
-	 * @returns {function(): Promise<any> | any} new lazy
+	 * @param {LazyFunction<DeserializedType, SerializedType>} fn lazy function
+	 * @param {Context} context serialize function
+	 * @returns {LazyFunction<SerializedType, DeserializedType>} new lazy
 	 */
 	_serializeLazy(fn, context) {
-		return SerializerMiddleware.serializeLazy(fn, data =>
+		return SerializerMiddleware.serializeLazy(fn, (data) =>
 			this._serialize(data, context)
 		);
 	}
 
 	/**
 	 * @param {DeserializedType} data data
-	 * @param {TODO} context context object
+	 * @param {Context} context context object
 	 * @param {{ leftOverBuffer: Buffer | null, allocationSize: number, increaseCounter: number }} allocationScope allocation scope
 	 * @returns {SerializedType} serialized data
 	 */
@@ -192,7 +198,7 @@ class BinaryMiddleware extends SerializerMiddleware {
 		/**
 		 * @param {number} bytesNeeded bytes needed
 		 */
-		const allocate = bytesNeeded => {
+		const allocate = (bytesNeeded) => {
 			if (currentBuffer !== null) {
 				if (currentBuffer.length - currentPosition >= bytesNeeded) return;
 				flush();
@@ -209,7 +215,7 @@ class BinaryMiddleware extends SerializerMiddleware {
 						(allocationScope.increaseCounter + 1) % 4) &&
 					allocationScope.allocationSize < 16777216
 				) {
-					allocationScope.allocationSize = allocationScope.allocationSize << 1;
+					allocationScope.allocationSize <<= 1;
 				}
 			}
 		};
@@ -242,14 +248,14 @@ class BinaryMiddleware extends SerializerMiddleware {
 		/**
 		 * @param {number} byte byte
 		 */
-		const writeU8 = byte => {
+		const writeU8 = (byte) => {
 			/** @type {Buffer} */
 			(currentBuffer).writeUInt8(byte, currentPosition++);
 		};
 		/**
 		 * @param {number} ui32 ui32
 		 */
-		const writeU32 = ui32 => {
+		const writeU32 = (ui32) => {
 			/** @type {Buffer} */
 			(currentBuffer).writeUInt32LE(ui32, currentPosition);
 			currentPosition += 4;
@@ -275,9 +281,10 @@ class BinaryMiddleware extends SerializerMiddleware {
 			const thing = data[i];
 			switch (typeof thing) {
 				case "function": {
-					if (!SerializerMiddleware.isLazy(thing))
+					if (!SerializerMiddleware.isLazy(thing)) {
 						throw new Error(`Unexpected function ${thing}`);
-					/** @type {SerializedType | (() => SerializedType)} */
+					}
+					/** @type {SerializedType | LazyFunction<SerializedType, DeserializedType> | undefined} */
 					let serializedData =
 						SerializerMiddleware.getLazySerializedValue(thing);
 					if (serializedData === undefined) {
@@ -285,9 +292,8 @@ class BinaryMiddleware extends SerializerMiddleware {
 							flush();
 							allocationScope.leftOverBuffer = leftOverBuffer;
 							const result =
-								/** @type {(Exclude<PrimitiveSerializableType, Promise<PrimitiveSerializableType>>)[]} */ (
-									thing()
-								);
+								/** @type {PrimitiveSerializableType[]} */
+								(thing());
 							const data = this._serialize(result, context, allocationScope);
 							leftOverBuffer = allocationScope.leftOverBuffer;
 							allocationScope.leftOverBuffer = null;
@@ -644,13 +650,19 @@ class BinaryMiddleware extends SerializerMiddleware {
 
 	/**
 	 * @param {SerializedType} data data
-	 * @param {object} context context object
-	 * @returns {DeserializedType|Promise<DeserializedType>} deserialized data
+	 * @param {Context} context context object
+	 * @returns {DeserializedType | Promise<DeserializedType>} deserialized data
 	 */
 	deserialize(data, context) {
 		return this._deserialize(data, context);
 	}
 
+	/**
+	 * @private
+	 * @param {SerializedType} content content
+	 * @param {Context} context context object
+	 * @returns {LazyFunction<DeserializedType, SerializedType>} lazy function
+	 */
 	_createLazyDeserialized(content, context) {
 		return SerializerMiddleware.createLazy(
 			memoize(() => this._deserialize(content, context)),
@@ -660,15 +672,21 @@ class BinaryMiddleware extends SerializerMiddleware {
 		);
 	}
 
+	/**
+	 * @private
+	 * @param {LazyFunction<SerializedType, DeserializedType>} fn lazy function
+	 * @param {Context} context context object
+	 * @returns {LazyFunction<DeserializedType, SerializedType>} new lazy
+	 */
 	_deserializeLazy(fn, context) {
-		return SerializerMiddleware.deserializeLazy(fn, data =>
+		return SerializerMiddleware.deserializeLazy(fn, (data) =>
 			this._deserialize(data, context)
 		);
 	}
 
 	/**
 	 * @param {SerializedType} data data
-	 * @param {TODO} context context object
+	 * @param {Context} context context object
 	 * @returns {DeserializedType} deserialized data
 	 */
 	_deserialize(data, context) {
@@ -678,8 +696,7 @@ class BinaryMiddleware extends SerializerMiddleware {
 		let currentIsBuffer = Buffer.isBuffer(currentBuffer);
 		let currentPosition = 0;
 
-		/** @type {(x: Buffer) => Buffer} */
-		const retainedBuffer = context.retainedBuffer || (x => x);
+		const retainedBuffer = context.retainedBuffer || ((x) => x);
 
 		const checkOverflow = () => {
 			if (currentPosition >= /** @type {Buffer} */ (currentBuffer).length) {
@@ -694,7 +711,7 @@ class BinaryMiddleware extends SerializerMiddleware {
 		 * @param {number} n n
 		 * @returns {boolean} true when in current buffer, otherwise false
 		 */
-		const isInCurrentBuffer = n =>
+		const isInCurrentBuffer = (n) =>
 			currentIsBuffer &&
 			n + currentPosition <= /** @type {Buffer} */ (currentBuffer).length;
 		const ensureBuffer = () => {
@@ -711,7 +728,7 @@ class BinaryMiddleware extends SerializerMiddleware {
 		 * @param {number} n amount of bytes to read
 		 * @returns {Buffer} buffer with bytes
 		 */
-		const read = n => {
+		const read = (n) => {
 			ensureBuffer();
 			const rem =
 				/** @type {Buffer} */ (currentBuffer).length - currentPosition;
@@ -743,7 +760,7 @@ class BinaryMiddleware extends SerializerMiddleware {
 		 * @param {number} n amount of bytes to read
 		 * @returns {Buffer} buffer with bytes
 		 */
-		const readUpTo = n => {
+		const readUpTo = (n) => {
 			ensureBuffer();
 			const rem =
 				/** @type {Buffer} */
@@ -785,7 +802,7 @@ class BinaryMiddleware extends SerializerMiddleware {
 			let mask = 1;
 			while (n !== 0) {
 				result.push((data & mask) !== 0);
-				mask = mask << 1;
+				mask <<= 1;
 				n--;
 			}
 		};
@@ -795,6 +812,7 @@ class BinaryMiddleware extends SerializerMiddleware {
 					return () => {
 						const count = readU32();
 						const lengths = Array.from({ length: count }).map(() => readU32());
+						/** @type {(Buffer | LazyFunction<SerializedType, DeserializedType>)[]} */
 						const content = [];
 						for (let l of lengths) {
 							if (l === 0) {
@@ -1138,5 +1156,5 @@ class BinaryMiddleware extends SerializerMiddleware {
 
 module.exports = BinaryMiddleware;
 
-module.exports.MEASURE_START_OPERATION = MEASURE_START_OPERATION;
 module.exports.MEASURE_END_OPERATION = MEASURE_END_OPERATION;
+module.exports.MEASURE_START_OPERATION = MEASURE_START_OPERATION;

package/lib/serialization/ErrorObjectSerializer.js

@@ -7,6 +7,8 @@
 /** @typedef {import("./ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
 /** @typedef {import("./ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
 
+/** @typedef {Error & { cause?: unknown }} ErrorWithCause */
+
 class ErrorObjectSerializer {
 	/**
 	 * @param {ErrorConstructor | EvalErrorConstructor | RangeErrorConstructor | ReferenceErrorConstructor | SyntaxErrorConstructor | TypeErrorConstructor} Type error type
@@ -22,7 +24,10 @@ class ErrorObjectSerializer {
 	serialize(obj, context) {
 		context.write(obj.message);
 		context.write(obj.stack);
-		context.write(/** @type {Error & { cause: "unknown" }} */ (obj).cause);
+		context.write(
+			/** @type {ErrorWithCause} */
+			(obj).cause
+		);
 	}
 
 	/**
@@ -34,7 +39,7 @@ class ErrorObjectSerializer {
 
 		err.message = context.read();
 		err.stack = context.read();
-		/** @type {Error & { cause: "unknown" }} */
+		/** @type {ErrorWithCause} */
 		(err).cause = context.read();
 
 		return err;