@depup/webpack 5.106.0-depup.0 → 5.109.0-depup.0

package/lib/typescript/TypeScriptPlugin.js

@@ -0,0 +1,210 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+const mod = require("module");
+const {
+	JAVASCRIPT_MODULE_TYPE_AUTO,
+	JAVASCRIPT_MODULE_TYPE_DYNAMIC,
+	JAVASCRIPT_MODULE_TYPE_ESM
+} = require("../ModuleTypeConstants");
+const NormalModule = require("../NormalModule");
+const ModuleBuildError = require("../errors/ModuleBuildError");
+const memoize = require("../util/memoize");
+const removeBOM = require("../util/removeBOM");
+
+/** @typedef {import("webpack-sources").RawSourceMap} RawSourceMap */
+/** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../NormalModule")} NormalModuleType */
+/** @typedef {import("../NormalModule").Result} Result */
+/** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
+
+const getSourceMapSource = memoize(
+	() => require("webpack-sources").SourceMapSource
+);
+
+const PLUGIN_NAME = "TypeScriptPlugin";
+
+/** @type {Set<string>} */
+const JS_MODULE_TYPES = new Set([
+	JAVASCRIPT_MODULE_TYPE_AUTO,
+	JAVASCRIPT_MODULE_TYPE_DYNAMIC,
+	JAVASCRIPT_MODULE_TYPE_ESM
+]);
+
+const TS_RESOURCE_RE = /\.(?:[mc]?tsx?)$/i;
+const TSX_RESOURCE_RE = /\.[mc]?tsx$/i;
+const TS_DATA_URI_RE = /^data:(?:text|application)\/typescript/i;
+
+const TSX_NOT_SUPPORTED =
+	"experiments.typescript does not support .tsx/JSX. " +
+	"Use a TSX-capable loader (e.g. swc-loader, esbuild-loader, ts-loader) for .tsx files.";
+
+const NODE_API_MISSING =
+	"experiments.typescript requires Node.js >= 22.6. " +
+	"`module.stripTypeScriptTypes` is not available on this Node.js version.";
+
+/**
+ * Whether the resource (path or `data:` URI) should go through the TypeScript
+ * transform. Returns true for `.ts`, `.cts`, `.mts`, and the JSX-flavoured
+ * variants (so the `.tsx` branch can throw a friendly error), as well as the
+ * `text/typescript` / `application/typescript` data URIs.
+ * @param {string} resource module resource (without query string)
+ * @returns {boolean} true if the resource should be transformed
+ */
+const isTypeScriptResource = (resource) =>
+	TS_RESOURCE_RE.test(resource) || TS_DATA_URI_RE.test(resource);
+
+/**
+ * Build a line-granularity identity source map for a strip-types output.
+ * `mode: "strip"` replaces type annotations with whitespace, so the stripped
+ * output preserves the original line layout — an identity mapping is correct.
+ * Node's API does not emit a source map in strip mode (`sourceMap: true` is
+ * rejected on Node 22+ and Node 26+), so we construct one by hand.
+ * @param {string} resource module resource path
+ * @param {string} originalSource pre-strip source content
+ * @returns {RawSourceMap} identity source map
+ */
+const createIdentitySourceMap = (resource, originalSource) => {
+	const lineCount = (originalSource.match(/\n/g) || []).length + 1;
+	// Mappings: each line emits a single segment at column 0 mapping to
+	// column 0 of the same line in the source. `AAAA` for line 1, `;AACA`
+	// for each subsequent line (cumulative source-line delta of +1 per line).
+	const mappings = `AAAA${";AACA".repeat(lineCount - 1)}`;
+
+	return {
+		version: 3,
+		file: resource,
+		sources: [resource],
+		sourcesContent: [originalSource],
+		names: [],
+		mappings
+	};
+};
+
+/**
+ * Compose the strip-types source map with an upstream loader source map so the
+ * final map points back to the loader's original input (e.g. a `.vue` /
+ * `.svelte` / custom loader that emits TS code).
+ * @param {string} resource module resource
+ * @param {string} strippedSource post-strip JS
+ * @param {RawSourceMap} stripMap identity map for the strip step
+ * @param {string} preStripSource pre-strip TS (loader output)
+ * @param {string | RawSourceMap} loaderSourceMap upstream loader source map
+ * @returns {RawSourceMap} composed map
+ */
+const composeWithLoaderSourceMap = (
+	resource,
+	strippedSource,
+	stripMap,
+	preStripSource,
+	loaderSourceMap
+) => {
+	const SourceMapSource = getSourceMapSource();
+	const composed = new SourceMapSource(
+		strippedSource,
+		resource,
+		stripMap,
+		preStripSource,
+		loaderSourceMap,
+		true
+	);
+	return /** @type {RawSourceMap} */ (composed.sourceAndMap().map) || stripMap;
+};
+
+/**
+ * Run `module.stripTypeScriptTypes` on the input, wrapping any thrown
+ * `TypeScript ...` errors as `ModuleBuildError` so they surface as
+ * per-module build errors instead of uncaught exceptions.
+ * @param {string} input pre-strip TS source (BOM-free string)
+ * @returns {string} stripped JS
+ */
+const stripTypes = (input) => {
+	try {
+		// Pass only `mode`. `sourceUrl` would emit a `//# sourceURL=…` pragma
+		// into the output (V8 debugger hint), and `sourceMap: true` is
+		// rejected in strip mode — we build the source map by hand instead.
+		// eslint-disable-next-line n/no-unsupported-features/node-builtins
+		return mod.stripTypeScriptTypes(input, { mode: "strip" });
+	} catch (err) {
+		throw new ModuleBuildError(/** @type {Error} */ (err));
+	}
+};
+
+/**
+ * Coerce a Buffer-or-string source to a UTF-8 string, dropping any BOM.
+ * @param {string | Buffer} source raw source from the loader pipeline
+ * @returns {string} UTF-8 string without BOM
+ */
+const toBomFreeString = (source) => {
+	const text = Buffer.isBuffer(source) ? source.toString("utf8") : source;
+	const stripped = removeBOM(text);
+	return typeof stripped === "string" ? stripped : stripped.toString("utf8");
+};
+
+class TypeScriptPlugin {
+	/**
+	 * @param {Compiler} compiler webpack compiler
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation) => {
+			NormalModule.getCompilationHooks(compilation).processResult.tap(
+				PLUGIN_NAME,
+				(result, module) => this._processResult(result, module)
+			);
+		});
+	}
+
+	/**
+	 * processResult tap body. Returns the input untouched unless this is a
+	 * TypeScript module that needs to be transformed.
+	 * @param {Result} result loader result tuple
+	 * @param {NormalModuleType} module the normal module
+	 * @returns {Result} possibly transformed result
+	 */
+	_processResult(result, module) {
+		if (!JS_MODULE_TYPES.has(module.type)) return result;
+
+		const parser = /** @type {JavascriptParser} */ (module.parser);
+		if (!parser.options.typescript) return result;
+
+		const resource = module.nameForCondition();
+		if (!resource || !isTypeScriptResource(resource)) return result;
+
+		if (TSX_RESOURCE_RE.test(resource)) {
+			throw new ModuleBuildError(new Error(TSX_NOT_SUPPORTED));
+		}
+
+		if (!("stripTypeScriptTypes" in mod)) {
+			throw new ModuleBuildError(new Error(NODE_API_MISSING));
+		}
+
+		const [rawSource, loaderSourceMap, ...rest] = result;
+		const preStripSource = toBomFreeString(rawSource);
+		const strippedSource = stripTypes(preStripSource);
+
+		const needSourceMap = module.useSourceMap || module.useSimpleSourceMap;
+		const stripMap = needSourceMap
+			? createIdentitySourceMap(module.resource, preStripSource)
+			: undefined;
+
+		const outputSourceMap =
+			stripMap && loaderSourceMap
+				? composeWithLoaderSourceMap(
+						module.resource,
+						strippedSource,
+						stripMap,
+						preStripSource,
+						loaderSourceMap
+					)
+				: stripMap || loaderSourceMap;
+
+		return [strippedSource, outputSourceMap, ...rest];
+	}
+}
+
+module.exports = TypeScriptPlugin;

package/lib/url/URLParserPlugin.js

@@ -6,16 +6,20 @@
 "use strict";
 
 const { pathToFileURL } = require("url");
-const CommentCompilationWarning = require("../CommentCompilationWarning");
 const RuntimeGlobals = require("../RuntimeGlobals");
-const UnsupportedFeatureWarning = require("../UnsupportedFeatureWarning");
 const ConstDependency = require("../dependencies/ConstDependency");
 const ContextDependencyHelpers = require("../dependencies/ContextDependencyHelpers");
+const {
+	isImportMetaFieldEnabled
+} = require("../dependencies/ImportMetaPlugin");
 const URLContextDependency = require("../dependencies/URLContextDependency");
 const URLDependency = require("../dependencies/URLDependency");
+const CommentCompilationWarning = require("../errors/CommentCompilationWarning");
+const UnsupportedFeatureWarning = require("../errors/UnsupportedFeatureWarning");
 const BasicEvaluatedExpression = require("../javascript/BasicEvaluatedExpression");
 const { approve } = require("../javascript/JavascriptParserHelpers");
-const InnerGraph = require("../optimize/InnerGraph");
+const { getInnerGraphUtils } = require("../optimize/InnerGraph");
+const ResourceHintPlugin = require("../prefetch/ResourceHintPlugin");
 
 /** @typedef {import("estree").MemberExpression} MemberExpression */
 /** @typedef {import("estree").NewExpression} NewExpressionNode */
@@ -28,12 +32,14 @@ const InnerGraph = require("../optimize/InnerGraph");
 const PLUGIN_NAME = "URLParserPlugin";
 
 /**
+ * Returns file url.
  * @param {NormalModule} module module
  * @returns {URL} file url
  */
 const getUrl = (module) => pathToFileURL(module.resource);
 
 /**
+ * Checks whether this object is meta url.
  * @param {JavascriptParser} parser parser parser
  * @param {MemberExpression} arg arg
  * @returns {boolean} true when it is `meta.url`, otherwise false
@@ -54,19 +60,48 @@ const isMetaUrl = (parser, arg) => {
 	return true;
 };
 
+/**
+ * Whether the request points to a directory and thus can't be an asset.
+ * @param {string} request request
+ * @returns {boolean} true when the request is a directory reference
+ */
+const isDirectoryRequest = (request) =>
+	request === "." || request === ".." || request.endsWith("/");
+
+/**
+ * Replaces `import.meta.url` with the runtime base URI, leaving the
+ * `new URL(...)` construction untouched so it's evaluated at runtime.
+ * @param {JavascriptParser} parser parser
+ * @param {NewExpressionNode} expr expression
+ * @returns {void}
+ */
+const keepNewURL = (parser, expr) => {
+	const [, arg2] = expr.arguments;
+	const dep = new ConstDependency(
+		RuntimeGlobals.baseURI,
+		/** @type {Range} */ (arg2.range),
+		[RuntimeGlobals.baseURI]
+	);
+	dep.loc = parser.getLocation(expr);
+	parser.state.module.addPresentationalDependency(dep);
+};
+
 /** @type {WeakMap<NewExpressionNode, BasicEvaluatedExpression | undefined>} */
 const getEvaluatedExprCache = new WeakMap();
 
 /**
+ * Gets evaluated expr.
  * @param {NewExpressionNode} expr expression
  * @param {JavascriptParser} parser parser parser
+ * @param {boolean} importMetaUrlEnabled true when import.meta.url should be handled
  * @returns {BasicEvaluatedExpression | undefined} basic evaluated expression
  */
-const getEvaluatedExpr = (expr, parser) => {
+const getEvaluatedExpr = (expr, parser, importMetaUrlEnabled) => {
 	let result = getEvaluatedExprCache.get(expr);
 	if (result !== undefined) return result;
 
 	/**
+	 * Returns basic evaluated expression.
 	 * @returns {BasicEvaluatedExpression | undefined} basic evaluated expression
 	 */
 	const evaluate = () => {
@@ -77,7 +112,9 @@ const getEvaluatedExpr = (expr, parser) => {
 		if (arg2.type !== "MemberExpression" || arg1.type === "SpreadElement") {
 			return;
 		}
-		if (!isMetaUrl(parser, arg2)) return;
+		if (!importMetaUrlEnabled || !isMetaUrl(parser, arg2)) {
+			return;
+		}
 
 		return parser.evaluateExpression(arg1);
 	};
@@ -88,8 +125,16 @@ const getEvaluatedExpr = (expr, parser) => {
 	return result;
 };
 
+/**
+ * @typedef {object} ResolvedResourceHints
+ * @property {boolean=} prefetch project-wide prefetch default
+ * @property {boolean=} preload project-wide preload default
+ * @property {("low" | "high" | "auto" | false)=} fetchPriority project-wide fetchPriority default
+ */
+
 class URLParserPlugin {
 	/**
+	 * Creates an instance of URLParserPlugin.
 	 * @param {JavascriptParserOptions} options options
 	 */
 	constructor(options) {
@@ -98,15 +143,24 @@ class URLParserPlugin {
 	}
 
 	/**
+	 * Applies the plugin by registering its hooks on the compiler.
 	 * @param {JavascriptParser} parser the parser
 	 * @returns {void}
 	 */
 	apply(parser) {
 		const relative = this.options.url === "relative";
+		const importMetaUrlEnabled = isImportMetaFieldEnabled(
+			this.options.importMeta,
+			"url"
+		);
 
 		parser.hooks.canRename.for("URL").tap(PLUGIN_NAME, approve);
 		parser.hooks.evaluateNewExpression.for("URL").tap(PLUGIN_NAME, (expr) => {
-			const evaluatedExpr = getEvaluatedExpr(expr, parser);
+			const evaluatedExpr = getEvaluatedExpr(
+				expr,
+				parser,
+				importMetaUrlEnabled
+			);
 			const request = evaluatedExpr && evaluatedExpr.asString();
 
 			if (!request) return;
@@ -127,7 +181,7 @@ class URLParserPlugin {
 					parser.state.module.addWarning(
 						new CommentCompilationWarning(
 							`Compilation error while processing magic comment(-s): /*${comment.value}*/: ${e.message}`,
-							/** @type {DependencyLocation} */ (comment.loc)
+							parser.getLocation(comment)
 						)
 					);
 				}
@@ -138,7 +192,7 @@ class URLParserPlugin {
 					parser.state.module.addWarning(
 						new UnsupportedFeatureWarning(
 							`\`webpackIgnore\` expected a boolean, but received: ${importOptions.webpackIgnore}.`,
-							/** @type {DependencyLocation} */ (expr.loc)
+							parser.getLocation(expr)
 						)
 					);
 					return;
@@ -147,23 +201,25 @@ class URLParserPlugin {
 
 					const [, arg2] = expr.arguments;
 
-					if (arg2.type !== "MemberExpression" || !isMetaUrl(parser, arg2)) {
+					if (
+						arg2.type !== "MemberExpression" ||
+						!importMetaUrlEnabled ||
+						!isMetaUrl(parser, arg2)
+					) {
 						return;
 					}
 
-					const dep = new ConstDependency(
-						RuntimeGlobals.baseURI,
-						/** @type {Range} */ (arg2.range),
-						[RuntimeGlobals.baseURI]
-					);
-					dep.loc = /** @type {DependencyLocation} */ (expr.loc);
-					parser.state.module.addPresentationalDependency(dep);
+					keepNewURL(parser, expr);
 
 					return true;
 				}
 			}
 
-			const evaluatedExpr = getEvaluatedExpr(expr, parser);
+			const evaluatedExpr = getEvaluatedExpr(
+				expr,
+				parser,
+				importMetaUrlEnabled
+			);
 			if (!evaluatedExpr) return;
 
 			/** @type {string | undefined} */
@@ -171,6 +227,12 @@ class URLParserPlugin {
 
 			// static URL
 			if ((request = evaluatedExpr.asString())) {
+				// A directory is not an asset; keep `new URL(...)` as-is, matching Node/browsers.
+				if (isDirectoryRequest(request)) {
+					keepNewURL(parser, expr);
+					return true;
+				}
+
 				const [arg1, arg2] = expr.arguments;
 				const dep = new URLDependency(
 					request,
@@ -181,9 +243,31 @@ class URLParserPlugin {
 					/** @type {Range} */ (expr.range),
 					relative
 				);
-				dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+				dep.loc = parser.getLocation(expr);
+				// `parser.javascript.urlHints` provides project-wide defaults
+				// (resolved per-request, with `test` / `include` / `exclude`
+				// matching); a per-URL magic comment for the same hint wins
+				// when both are set.
+				ResourceHintPlugin.applyResourceHints(
+					dep,
+					this.options.urlHints,
+					request,
+					importOptions,
+					parser.state.module,
+					parser.getLocation(expr)
+				);
 				parser.state.current.addDependency(dep);
-				InnerGraph.onUsage(parser.state, (e) => (dep.usedByExports = e));
+				// For ESM module output the template embeds the asset's resolved
+				// filename, so the asset must be code-generated first. Only added in
+				// that mode — a code-gen dependency on an asset that a later watch
+				// rebuild leaves unaffected can otherwise deadlock the scheduler.
+				if (parser.state.compilation.options.output.module) {
+					parser.state.module.addCodeGenerationDependency(dep);
+				}
+				getInnerGraphUtils(parser.state.compilation).onUsage(
+					parser.state,
+					(e) => (dep.usedByExports = e)
+				);
 				return true;
 			}
 
@@ -204,7 +288,7 @@ class URLParserPlugin {
 						parser.state.module.addWarning(
 							new UnsupportedFeatureWarning(
 								`\`webpackInclude\` expected a regular expression, but received: ${importOptions.webpackInclude}.`,
-								/** @type {DependencyLocation} */ (expr.loc)
+								parser.getLocation(expr)
 							)
 						);
 					} else {
@@ -219,7 +303,7 @@ class URLParserPlugin {
 						parser.state.module.addWarning(
 							new UnsupportedFeatureWarning(
 								`\`webpackExclude\` expected a regular expression, but received: ${importOptions.webpackExclude}.`,
-								/** @type {DependencyLocation} */ (expr.loc)
+								parser.getLocation(expr)
 							)
 						);
 					} else {
@@ -243,7 +327,7 @@ class URLParserPlugin {
 				parser
 			);
 			if (!dep) return;
-			dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+			dep.loc = parser.getLocation(expr);
 			dep.optional = Boolean(parser.scope.inTry);
 			parser.state.current.addDependency(dep);
 			return true;
@@ -255,7 +339,11 @@ class URLParserPlugin {
 			const calleeInfo = parser.getFreeInfoFromVariable(callee.name);
 			if (!calleeInfo || calleeInfo.name !== "URL") return;
 
-			const evaluatedExpr = getEvaluatedExpr(expr, parser);
+			const evaluatedExpr = getEvaluatedExpr(
+				expr,
+				parser,
+				importMetaUrlEnabled
+			);
 			const request = evaluatedExpr && evaluatedExpr.asString();
 
 			if (request) return true;

package/lib/util/ArrayHelpers.js

@@ -34,6 +34,7 @@ module.exports.groupBy = (
 ) =>
 	arr.reduce(
 		/**
+		 * Handles the callback logic for this hook.
 		 * @param {[T[], T[]]} groups An accumulator storing already partitioned values returned from previous call.
 		 * @param {T} value The value of the current element
 		 * @returns {[T[], T[]]} returns an array of partitioned groups accumulator resulting from calling a predicate on the current value.

package/lib/util/ArrayQueue.js

@@ -6,10 +6,13 @@
 "use strict";
 
 /**
+ * FIFO queue backed by arrays with a reversed dequeue buffer to avoid the cost
+ * of repeated `Array#shift` operations.
  * @template T
  */
 class ArrayQueue {
 	/**
+	 * Seeds the queue with an optional iterable of items in dequeue order.
 	 * @param {Iterable<T>=} items The initial elements.
 	 */
 	constructor(items) {
@@ -26,7 +29,7 @@ class ArrayQueue {
 	}
 
 	/**
-	 * Returns the number of elements in this queue.
+	 * Returns the current number of items waiting in either internal buffer.
 	 * @returns {number} The number of elements in this queue.
 	 */
 	get length() {
@@ -34,7 +37,7 @@ class ArrayQueue {
 	}
 
 	/**
-	 * Empties the queue.
+	 * Removes all pending items from both internal buffers.
 	 */
 	clear() {
 		this._list.length = 0;
@@ -42,7 +45,7 @@ class ArrayQueue {
 	}
 
 	/**
-	 * Appends the specified element to this queue.
+	 * Appends an item to the tail of the queue.
 	 * @param {T} item The element to add.
 	 * @returns {void}
 	 */
@@ -51,7 +54,8 @@ class ArrayQueue {
 	}
 
 	/**
-	 * Retrieves and removes the head of this queue.
+	 * Removes and returns the next item in FIFO order, switching to a reversed
+	 * buffer when that is cheaper than shifting from the front of the array.
 	 * @returns {T | undefined} The head of the queue of `undefined` if this queue is empty.
 	 */
 	dequeue() {
@@ -68,7 +72,8 @@ class ArrayQueue {
 	}
 
 	/**
-	 * Finds and removes an item
+	 * Removes the first matching item from whichever internal buffer currently
+	 * contains it.
 	 * @param {T} item the item
 	 * @returns {void}
 	 */