webpack 5.99.9 → 5.100.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 */
+/** @typedef {import("../Module").BuildInfo} BuildInfo */
+/** @typedef {import("../Module").ValueCacheVersions} ValueCacheVersions */
+/** @typedef {string | Set<string>} ValueCacheVersion */
+
+/**
+ * @template T
+ * @typedef {import("../../declarations/LoaderContext").LoaderContext<T>} LoaderContext
+ */
+
+const PLUGIN_NAME = "VirtualUrlPlugin";
+const DEFAULT_SCHEME = "virtual";
+
+/**
+ * @typedef {object} VirtualModuleConfig
+ * @property {string=} type - The module type
+ * @property {(loaderContext: LoaderContext<EXPECTED_ANY>) => Promise<string> | string} source - The source function
+ * @property {(() => string) | true | string=} version - Optional version function or value
+ */
+
+/**
+ * @typedef {string | ((loaderContext: LoaderContext<EXPECTED_ANY>) => Promise<string> | string) | 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 {(() => string) | 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

@@ -28,7 +28,7 @@ class AggregateErrorSerializer {
 	deserialize(context) {
 		const errors = context.read();
 		// @ts-expect-error ES2018 doesn't `AggregateError`, but it can be used by developers
-		// eslint-disable-next-line n/no-unsupported-features/es-builtins, n/no-unsupported-features/es-syntax
+		// 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();

package/lib/serialization/BinaryMiddleware.js

@@ -215,7 +215,7 @@ class BinaryMiddleware extends SerializerMiddleware {
 						(allocationScope.increaseCounter + 1) % 4) &&
 					allocationScope.allocationSize < 16777216
 				) {
-					allocationScope.allocationSize = allocationScope.allocationSize << 1;
+					allocationScope.allocationSize <<= 1;
 				}
 			}
 		};
@@ -281,8 +281,9 @@ 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 | LazyFunction<SerializedType, DeserializedType> | undefined} */
 					let serializedData =
 						SerializerMiddleware.getLazySerializedValue(thing);
@@ -801,7 +802,7 @@ class BinaryMiddleware extends SerializerMiddleware {
 			let mask = 1;
 			while (n !== 0) {
 				result.push((data & mask) !== 0);
-				mask = mask << 1;
+				mask <<= 1;
 				n--;
 			}
 		};
@@ -1155,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/FileMiddleware.js

@@ -7,11 +7,13 @@
 const { constants } = require("buffer");
 const { pipeline } = require("stream");
 const {
+	constants: zConstants,
+	// eslint-disable-next-line n/no-unsupported-features/node-builtins
 	createBrotliCompress,
+	// eslint-disable-next-line n/no-unsupported-features/node-builtins
 	createBrotliDecompress,
-	createGzip,
 	createGunzip,
-	constants: zConstants
+	createGzip
 } = require("zlib");
 const { DEFAULTS } = require("../config/defaults");
 const createHash = require("../util/createHash");
@@ -117,8 +119,9 @@ const serialize = async (
 	let lastBuffers;
 	for (const item of await data) {
 		if (typeof item === "function") {
-			if (!SerializerMiddleware.isLazy(item))
+			if (!SerializerMiddleware.isLazy(item)) {
 				throw new Error("Unexpected function");
+			}
 			if (!SerializerMiddleware.isLazy(item, middleware)) {
 				throw new Error(
 					"Unexpected lazy value with non-this target (can't pass through lazy values)"
@@ -551,7 +554,7 @@ class FileMiddleware extends SerializerMiddleware {
 								 * @param {(value?: undefined) => void} resolve resolve
 								 */
 								resolve => {
-									this.fs.rename(filename, `${filename}.old`, err => {
+									this.fs.rename(filename, `${filename}.old`, _err => {
 										resolve();
 									});
 								}

package/lib/serialization/ObjectMiddleware.js

@@ -175,7 +175,7 @@ if (exports.constructor !== Object) {
 	// eslint-disable-next-line n/exports-style
 	const Obj = /** @type {ObjectConstructor} */ (exports.constructor);
 	const Fn = /** @type {FunctionConstructor} */ (Obj.constructor);
-	for (const [type, config] of Array.from(jsTypes)) {
+	for (const [type, config] of jsTypes) {
 		if (type) {
 			const Type = new Fn(`return ${type.name};`)();
 			jsTypes.set(Type, config);
@@ -416,7 +416,7 @@ class ObjectMiddleware extends SerializerMiddleware {
 		 * @returns {string} stack
 		 */
 		const stackToString = item => {
-			const arr = Array.from(cycleStack);
+			const arr = [...cycleStack];
 			arr.push(item);
 			return arr
 				.map(item => {
@@ -439,11 +439,13 @@ class ObjectMiddleware extends SerializerMiddleware {
 					}
 					if (typeof item === "object" && item !== null) {
 						if (item.constructor) {
-							if (item.constructor === Object)
+							if (item.constructor === Object) {
 								return `Object { ${Object.keys(item).join(", ")} }`;
+							}
 							if (item.constructor === Map) return `Map { ${item.size} items }`;
-							if (item.constructor === Array)
+							if (item.constructor === Array) {
 								return `Array { ${item.length} items }`;
+							}
 							if (item.constructor === Set) return `Set { ${item.size} items }`;
 							if (item.constructor === RegExp) return item.toString();
 							return `${item.constructor.name}`;
@@ -472,8 +474,9 @@ class ObjectMiddleware extends SerializerMiddleware {
 					process(value);
 				} catch (err) {
 					if (err !== NOT_SERIALIZABLE) {
-						if (hasDebugInfoAttached === undefined)
+						if (hasDebugInfoAttached === undefined) {
 							hasDebugInfoAttached = new WeakSet();
+						}
 						if (!hasDebugInfoAttached.has(/** @type {Error} */ (err))) {
 							/** @type {Error} */
 							(err).message += `\nwhile serializing ${stackToString(value)}`;
@@ -596,8 +599,9 @@ class ObjectMiddleware extends SerializerMiddleware {
 
 				result.push(item);
 			} else if (typeof item === "function") {
-				if (!SerializerMiddleware.isLazy(item))
+				if (!SerializerMiddleware.isLazy(item)) {
 					throw new Error(`Unexpected function ${item}`);
+				}
 
 				/** @type {SerializedType | undefined} */
 				const serializedData =
@@ -658,14 +662,16 @@ class ObjectMiddleware extends SerializerMiddleware {
 	deserialize(data, context) {
 		let currentDataPos = 0;
 		const read = () => {
-			if (currentDataPos >= data.length)
+			if (currentDataPos >= data.length) {
 				throw new Error("Unexpected end of stream");
+			}
 
 			return data[currentDataPos++];
 		};
 
-		if (read() !== CURRENT_VERSION)
+		if (read() !== CURRENT_VERSION) {
 			throw new Error("Version mismatch, serializer changed");
+		}
 
 		let currentPos = 0;
 		/** @type {ReferenceableItem[]} */

package/lib/serialization/Serializer.js

@@ -20,8 +20,8 @@ class Serializer {
 	 * @param {Context=} context context
 	 */
 	constructor(middlewares, context) {
-		this.serializeMiddlewares = middlewares.slice();
-		this.deserializeMiddlewares = middlewares.slice().reverse();
+		this.serializeMiddlewares = [...middlewares];
+		this.deserializeMiddlewares = [...middlewares].reverse();
 		this.context = context;
 	}
 
@@ -49,7 +49,9 @@ class Serializer {
 				} catch (err) {
 					current = Promise.reject(err);
 				}
-			} else break;
+			} else {
+				break;
+			}
 		}
 		return /** @type {Promise<SerializedValue>} */ (current);
 	}

package/lib/serialization/SerializerMiddleware.js

@@ -35,6 +35,7 @@ class SerializerMiddleware {
 	 */
 	serialize(data, context) {
 		const AbstractMethodError = require("../AbstractMethodError");
+
 		throw new AbstractMethodError();
 	}
 
@@ -47,6 +48,7 @@ class SerializerMiddleware {
 	 */
 	deserialize(data, context) {
 		const AbstractMethodError = require("../AbstractMethodError");
+
 		throw new AbstractMethodError();
 	}
 

package/lib/sharing/ConsumeSharedModule.js

@@ -177,7 +177,7 @@ class ConsumeSharedModule extends Module {
 	 * @param {CodeGenerationContext} context context for code generation
 	 * @returns {CodeGenerationResult} result
 	 */
-	codeGeneration({ chunkGraph, moduleGraph, runtimeTemplate }) {
+	codeGeneration({ chunkGraph, runtimeTemplate }) {
 		const runtimeRequirements = new Set([RuntimeGlobals.shareScopeMap]);
 		const {
 			shareScope,

package/lib/sharing/ConsumeSharedPlugin.js

@@ -18,9 +18,9 @@ const ConsumeSharedRuntimeModule = require("./ConsumeSharedRuntimeModule");
 const ProvideForSharedDependency = require("./ProvideForSharedDependency");
 const { resolveMatchedConfigs } = require("./resolveMatchedConfigs");
 const {
-	isRequiredVersion,
 	getDescriptionFile,
-	getRequiredVersionFromDescriptionFile
+	getRequiredVersionFromDescriptionFile,
+	isRequiredVersion
 } = require("./utils");
 
 /** @typedef {import("../../declarations/plugins/sharing/ConsumeSharedPlugin").ConsumeSharedPluginOptions} ConsumeSharedPluginOptions */
@@ -32,7 +32,7 @@ const {
 /** @typedef {import("./utils").DescriptionFile} DescriptionFile */
 
 const validate = createSchemaValidation(
-	require("../../schemas/plugins/sharing/ConsumeSharedPlugin.check.js"),
+	require("../../schemas/plugins/sharing/ConsumeSharedPlugin.check"),
 	() => require("../../schemas/plugins/sharing/ConsumeSharedPlugin.json"),
 	{
 		name: "Consume Shared Plugin",

package/lib/sharing/ConsumeSharedRuntimeModule.js

@@ -10,9 +10,9 @@ const RuntimeModule = require("../RuntimeModule");
 const Template = require("../Template");
 const {
 	parseVersionRuntimeCode,
-	versionLtRuntimeCode,
 	rangeToStringRuntimeCode,
-	satisfyRuntimeCode
+	satisfyRuntimeCode,
+	versionLtRuntimeCode
 } = require("../util/semver");
 
 /** @typedef {import("webpack-sources").Source} Source */

package/lib/sharing/ProvideSharedModule.js

@@ -132,7 +132,7 @@ class ProvideSharedModule extends Module {
 	 * @param {CodeGenerationContext} context context for code generation
 	 * @returns {CodeGenerationResult} result
 	 */
-	codeGeneration({ runtimeTemplate, moduleGraph, chunkGraph }) {
+	codeGeneration({ runtimeTemplate, chunkGraph }) {
 		const runtimeRequirements = new Set([RuntimeGlobals.initializeSharing]);
 		const code = `register(${JSON.stringify(this._name)}, ${JSON.stringify(
 			this._version || "0"

package/lib/sharing/ProvideSharedPlugin.js

@@ -18,7 +18,7 @@ const ProvideSharedModuleFactory = require("./ProvideSharedModuleFactory");
 /** @typedef {import("../NormalModuleFactory").NormalModuleCreateData} NormalModuleCreateData */
 
 const validate = createSchemaValidation(
-	require("../../schemas/plugins/sharing/ProvideSharedPlugin.check.js"),
+	require("../../schemas/plugins/sharing/ProvideSharedPlugin.check"),
 	() => require("../../schemas/plugins/sharing/ProvideSharedPlugin.json"),
 	{
 		name: "Provide Shared Plugin",
@@ -49,8 +49,9 @@ class ProvideSharedPlugin {
 			parseOptions(
 				options.provides,
 				item => {
-					if (Array.isArray(item))
+					if (Array.isArray(item)) {
 						throw new Error("Unexpected array of provides");
+					}
 					/** @type {ProvideOptions} */
 					const result = {
 						shareKey: item,

package/lib/sharing/SharePlugin.js

@@ -27,8 +27,9 @@ class SharePlugin {
 		const sharedOptions = parseOptions(
 			options.shared,
 			(item, key) => {
-				if (typeof item !== "string")
+				if (typeof item !== "string") {
 					throw new Error("Unexpected array in shared");
+				}
 				/** @type {SharedConfig} */
 				const config =
 					item === key || !isRequiredVersion(item)

package/lib/sharing/ShareRuntimeModule.js

@@ -121,17 +121,15 @@ class ShareRuntimeModule extends RuntimeModule {
 					])}`,
 					"var promises = [];",
 					"switch(name) {",
-					...Array.from(initCodePerScope)
+					...[...initCodePerScope]
 						.sort(([a], [b]) => compareStrings(a, b))
 						.map(([name, stages]) =>
 							Template.indent([
 								`case ${JSON.stringify(name)}: {`,
 								Template.indent(
-									Array.from(stages)
+									[...stages]
 										.sort(([a], [b]) => a - b)
-										.map(([, initCode]) =>
-											Template.asString(Array.from(initCode))
-										)
+										.map(([, initCode]) => Template.asString([...initCode]))
 								),
 								"}",
 								"break;"

package/lib/sharing/utils.js

@@ -5,7 +5,7 @@
 
 "use strict";
 
-const { join, dirname, readJson } = require("../util/fs");
+const { dirname, join, readJson } = require("../util/fs");
 
 /** @typedef {import("../util/fs").InputFileSystem} InputFileSystem */
 /** @typedef {import("../util/fs").JsonObject} JsonObject */
@@ -292,34 +292,6 @@ function getGitUrlVersion(gitUrl) {
 	return getVersionFromHash(gitUrl);
 }
 
-/**
- * @param {string} str maybe required version
- * @returns {boolean} true, if it looks like a version
- */
-function isRequiredVersion(str) {
-	return VERSION_PATTERN_REGEXP.test(str);
-}
-
-module.exports.isRequiredVersion = isRequiredVersion;
-
-/**
- * @see https://docs.npmjs.com/cli/v7/configuring-npm/package-json#urls-as-dependencies
- * @param {string} versionDesc version to be normalized
- * @returns {string} normalized version
- */
-function normalizeVersion(versionDesc) {
-	versionDesc = (versionDesc && versionDesc.trim()) || "";
-
-	if (isRequiredVersion(versionDesc)) {
-		return versionDesc;
-	}
-
-	// add handle for URL Dependencies
-	return getGitUrlVersion(versionDesc.toLowerCase());
-}
-
-module.exports.normalizeVersion = normalizeVersion;
-
 /** @typedef {{ data: JsonObject, path: string }} DescriptionFile */
 
 /**
@@ -349,11 +321,9 @@ const getDescriptionFile = (
 		if (i >= descriptionFiles.length) {
 			const parentDirectory = dirname(fs, directory);
 			if (!parentDirectory || parentDirectory === directory) {
-				return callback(
-					null,
-					undefined,
-					Array.from(satisfiesDescriptionFileDataInternal.checkedFilePaths)
-				);
+				return callback(null, undefined, [
+					...satisfiesDescriptionFileDataInternal.checkedFilePaths
+				]);
 			}
 			return getDescriptionFile(
 				fs,
@@ -391,6 +361,7 @@ const getDescriptionFile = (
 	};
 	tryLoadCurrent();
 };
+
 module.exports.getDescriptionFile = getDescriptionFile;
 
 /**
@@ -421,5 +392,34 @@ const getRequiredVersionFromDescriptionFile = (data, packageName) => {
 		}
 	}
 };
+
 module.exports.getRequiredVersionFromDescriptionFile =
 	getRequiredVersionFromDescriptionFile;
+
+/**
+ * @param {string} str maybe required version
+ * @returns {boolean} true, if it looks like a version
+ */
+function isRequiredVersion(str) {
+	return VERSION_PATTERN_REGEXP.test(str);
+}
+
+module.exports.isRequiredVersion = isRequiredVersion;
+
+/**
+ * @see https://docs.npmjs.com/cli/v7/configuring-npm/package-json#urls-as-dependencies
+ * @param {string} versionDesc version to be normalized
+ * @returns {string} normalized version
+ */
+function normalizeVersion(versionDesc) {
+	versionDesc = (versionDesc && versionDesc.trim()) || "";
+
+	if (isRequiredVersion(versionDesc)) {
+		return versionDesc;
+	}
+
+	// add handle for URL Dependencies
+	return getGitUrlVersion(versionDesc.toLowerCase());
+}
+
+module.exports.normalizeVersion = normalizeVersion;