@depup/webpack 5.106.1-depup.0 → 5.109.2-depup.0

package/lib/stats/StatsFactory.js

@@ -6,7 +6,6 @@
 "use strict";
 
 const { HookMap, SyncBailHook, SyncWaterfallHook } = require("tapable");
-const { concatComparators, keepOriginalOrder } = require("../util/comparators");
 const smartGrouping = require("../util/smartGrouping");
 
 /** @typedef {import("../Chunk")} Chunk */
@@ -18,10 +17,11 @@ const smartGrouping = require("../util/smartGrouping");
 /** @typedef {import("../Module")} Module */
 /** @typedef {import("../ModuleGraph").ModuleProfile} ModuleProfile */
 /** @typedef {import("../ModuleGraphConnection")} ModuleGraphConnection */
-/** @typedef {import("../WebpackError")} WebpackError */
+/** @typedef {import("../errors/WebpackError")} WebpackError */
 /** @typedef {import("../util/comparators").Comparator<EXPECTED_ANY>} Comparator */
 /** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 /**
+ * Defines the group config type used by this module.
  * @template T, R
  * @typedef {import("../util/smartGrouping").GroupConfig<T, R>} GroupConfig
  */
@@ -42,6 +42,7 @@ const smartGrouping = require("../util/smartGrouping");
 /** @typedef {import("./DefaultStatsFactoryPlugin").StatsProfile} StatsProfile */
 
 /**
+ * Defines the known stats factory context type used by this module.
  * @typedef {object} KnownStatsFactoryContext
  * @property {string} type
  * @property {Compilation} compilation
@@ -59,12 +60,14 @@ const smartGrouping = require("../util/smartGrouping");
 // StatsLogging StatsLoggingEntry
 
 /**
+ * Defines the stats object type used by this module.
  * @template T
  * @template F
  * @typedef {T extends Compilation ? StatsCompilation : T extends ChunkGroupInfoWithName ? StatsChunkGroup : T extends Chunk ? StatsChunk : T extends OriginRecord ? StatsChunkOrigin : T extends Module ? StatsModule : T extends ModuleGraphConnection ? StatsModuleReason : T extends Asset ? StatsAsset : T extends ModuleTrace ? StatsModuleTraceItem : T extends Dependency ? StatsModuleTraceDependency : T extends Error ? StatsError : T extends ModuleProfile ? StatsProfile : F} StatsObject
  */
 
 /**
+ * Defines the created object type used by this module.
  * @template T
  * @template F
  * @typedef {T extends ChunkGroupInfoWithName[] ? Record<string, StatsObject<ChunkGroupInfoWithName, F>> : T extends (infer V)[] ? StatsObject<V, F>[] : StatsObject<T, F>} CreatedObject
@@ -76,6 +79,7 @@ const smartGrouping = require("../util/smartGrouping");
 /** @typedef {EXPECTED_ANY} Result */
 
 /**
+ * Defines the stats factory hooks type used by this module.
  * @typedef {object} StatsFactoryHooks
  * @property {HookMap<SyncBailHook<[ObjectForExtract, FactoryData, StatsFactoryContext], void>>} extract
  * @property {HookMap<SyncBailHook<[FactoryDataItem, StatsFactoryContext, number, number], boolean | void>>} filter
@@ -91,6 +95,7 @@ const smartGrouping = require("../util/smartGrouping");
  */
 
 /**
+ * Represents the stats factory runtime component.
  * @template T
  * @typedef {Map<string, T[]>} Caches
  */
@@ -125,14 +130,16 @@ class StatsFactory {
 		});
 		const hooks = this.hooks;
 		this._caches =
-			/** @type {{ [Key in keyof StatsFactoryHooks]: Map<string, SyncBailHook<EXPECTED_ANY, EXPECTED_ANY>[]> }} */ ({});
+			/** @type {{ [Key in keyof StatsFactoryHooks]: StatsFactoryHooks[Key] extends HookMap<infer H> ? Map<string, H[]> : never }} */ ({});
 		for (const key of Object.keys(hooks)) {
 			this._caches[/** @type {keyof StatsFactoryHooks} */ (key)] = new Map();
 		}
+		/** @type {boolean} */
 		this._inCreate = false;
 	}
 
 	/**
+	 * Get all level hooks.
 	 * @template {StatsFactoryHooks[keyof StatsFactoryHooks]} HM
 	 * @template {HM extends HookMap<infer H> ? H : never} H
 	 * @param {HM} hookMap hook map
@@ -159,9 +166,10 @@ class StatsFactory {
 	}
 
 	/**
+	 * Returns hook.
 	 * @template {StatsFactoryHooks[keyof StatsFactoryHooks]} HM
 	 * @template {HM extends HookMap<infer H> ? H : never} H
-	 * @template {H extends import("tapable").Hook<EXPECTED_ANY, infer R> ? R : never} R
+	 * @template {H extends import("tapable").Hook<infer A, infer R> ? R : never} R
 	 * @param {HM} hookMap hook map
 	 * @param {Caches<H>} cache cache
 	 * @param {string} type type
@@ -177,14 +185,16 @@ class StatsFactory {
 	}
 
 	/**
+	 * For each level waterfall.
 	 * @template {StatsFactoryHooks[keyof StatsFactoryHooks]} HM
 	 * @template {HM extends HookMap<infer H> ? H : never} H
+	 * @template [D=EXPECTED_ANY]
 	 * @param {HM} hookMap hook map
 	 * @param {Caches<H>} cache cache
 	 * @param {string} type type
-	 * @param {FactoryData} data data
-	 * @param {(hook: H, factoryData: FactoryData) => FactoryData} fn fn
-	 * @returns {FactoryData} data
+	 * @param {D} data data
+	 * @param {(hook: H, data: D) => D} fn fn
+	 * @returns {D} data
 	 * @private
 	 */
 	_forEachLevelWaterfall(hookMap, cache, type, data, fn) {
@@ -195,16 +205,17 @@ class StatsFactory {
 	}
 
 	/**
+	 * For each level filter.
 	 * @template {StatsFactoryHooks[keyof StatsFactoryHooks]} T
 	 * @template {T extends HookMap<infer H> ? H : never} H
-	 * @template {H extends import("tapable").Hook<EXPECTED_ANY, infer R> ? R : never} R
+	 * @template [D=EXPECTED_ANY]
 	 * @param {T} hookMap hook map
 	 * @param {Caches<H>} cache cache
 	 * @param {string} type type
-	 * @param {FactoryData[]} items items
-	 * @param {(hook: H, item: R, idx: number, i: number) => R | undefined} fn fn
+	 * @param {D[]} items items
+	 * @param {(hook: H, item: D, idx: number, i: number) => boolean | void} fn fn
 	 * @param {boolean} forceClone force clone
-	 * @returns {R[]} result for each level
+	 * @returns {D[]} result for each level
 	 * @private
 	 */
 	_forEachLevelFilter(hookMap, cache, type, items, fn, forceClone) {
@@ -225,6 +236,7 @@ class StatsFactory {
 	}
 
 	/**
+	 * Returns created object.
 	 * @template FactoryData
 	 * @template FallbackCreatedObject
 	 * @param {string} type type
@@ -248,6 +260,7 @@ class StatsFactory {
 	}
 
 	/**
+	 * Returns created object.
 	 * @private
 	 * @template FactoryData
 	 * @template FallbackCreatedObject
@@ -280,10 +293,7 @@ class StatsFactory {
 				h.call(comparators, context)
 			);
 			if (comparators.length > 0) {
-				items.sort(
-					// @ts-expect-error number of arguments is correct
-					concatComparators(...comparators, keepOriginalOrder(items))
-				);
+				sortWithOriginalOrder(items, comparators);
 			}
 
 			// run filter on sorted items
@@ -296,23 +306,30 @@ class StatsFactory {
 				false
 			);
 
-			// for each item
+			// reuse one item context; create() spreads it synchronously, so mutating
+			// `_index`/the name key between items is safe and skips a per-item spread
+			/** @type {StatsFactoryContext} */
+			const itemContext = { ...context };
+			const itemNameType = `${type}[]`;
+			/** @type {string | void} */
+			let prevItemName;
 			let resultItems = items2.map((item, i) => {
-				/** @type {StatsFactoryContext} */
-				const itemContext = {
-					...context,
-					_index: i
-				};
+				itemContext._index = i;
 
 				// run getItemName
 				const itemName = this._forEachLevel(
 					this.hooks.getItemName,
 					this._caches.getItemName,
-					`${type}[]`,
+					itemNameType,
 					(h) => h.call(item, itemContext)
 				);
+				// drop a previous item's name key before adding this one's
+				if (prevItemName !== undefined && prevItemName !== itemName) {
+					delete itemContext[prevItemName];
+				}
 				if (itemName) itemContext[itemName] = item;
-				const innerType = itemName ? `${type}[].${itemName}` : `${type}[]`;
+				prevItemName = itemName;
+				const innerType = itemName ? `${type}[].${itemName}` : itemNameType;
 
 				// run getItemFactory
 				const itemFactory =
@@ -337,10 +354,7 @@ class StatsFactory {
 				(h) => h.call(comparators2, context)
 			);
 			if (comparators2.length > 0) {
-				resultItems.sort(
-					// @ts-expect-error number of arguments is correct
-					concatComparators(...comparators2, keepOriginalOrder(resultItems))
-				);
+				sortWithOriginalOrder(resultItems, comparators2);
 			}
 
 			// group result items
@@ -403,4 +417,33 @@ class StatsFactory {
 	}
 }
 
+/**
+ * Stable in-place sort applying comparators in order, keeping the original order
+ * for equal items. Inlined instead of `concatComparators(...c, keepOriginalOrder())`
+ * because that combination is single-use per sort and only thrashes the comparator
+ * caches (a fresh tiebreaker closure every call allocates a new cache entry).
+ * @param {EXPECTED_ANY[]} items items to sort in place
+ * @param {Comparator[]} comparators comparators applied in order
+ * @returns {void}
+ */
+const sortWithOriginalOrder = (items, comparators) => {
+	// original-index tiebreaker keeps the sort stable on engines without a stable Array.sort
+	/** @type {Map<EXPECTED_ANY, number>} */
+	const originalOrder = new Map();
+	for (let i = 0; i < items.length; i++) {
+		originalOrder.set(items[i], i);
+	}
+	const count = comparators.length;
+	items.sort((a, b) => {
+		for (let i = 0; i < count; i++) {
+			const res = comparators[i](a, b);
+			if (res !== 0) return res;
+		}
+		return (
+			/** @type {number} */ (originalOrder.get(a)) -
+			/** @type {number} */ (originalOrder.get(b))
+		);
+	});
+};
+
 module.exports = StatsFactory;

package/lib/stats/StatsPrinter.js

@@ -21,12 +21,14 @@ const { HookMap, SyncBailHook, SyncWaterfallHook } = require("tapable");
 /** @typedef {import("./DefaultStatsFactoryPlugin").StatsProfile} StatsProfile */
 
 /**
+ * Defines the printed element type used by this module.
  * @typedef {object} PrintedElement
  * @property {string} element
  * @property {string | undefined} content
  */
 
 /**
+ * Defines the known stats printer context type used by this module.
  * @typedef {object} KnownStatsPrinterContext
  * @property {string=} type
  * @property {StatsCompilation=} compilation
@@ -47,6 +49,7 @@ const { HookMap, SyncBailHook, SyncWaterfallHook } = require("tapable");
 /** @typedef {(value: string | number) => string} ColorFunction */
 
 /**
+ * Defines the known stats printer color functions type used by this module.
  * @typedef {object} KnownStatsPrinterColorFunctions
  * @property {ColorFunction=} bold
  * @property {ColorFunction=} yellow
@@ -57,6 +60,7 @@ const { HookMap, SyncBailHook, SyncWaterfallHook } = require("tapable");
  */
 
 /**
+ * Defines the known stats printer formatters type used by this module.
  * @typedef {object} KnownStatsPrinterFormatters
  * @property {(file: string, oversize?: boolean) => string=} formatFilename
  * @property {(id: string | number) => string=} formatModuleId
@@ -69,11 +73,18 @@ const { HookMap, SyncBailHook, SyncWaterfallHook } = require("tapable");
  * @property {(message: string) => string=} formatError
  */
 
+/**
+ * Extracts the inner hook type held by a `HookMap`.
+ * @template T
+ * @typedef {T extends HookMap<infer H> ? H : never} HookMapHook
+ */
+
 /** @typedef {KnownStatsPrinterColorFunctions & KnownStatsPrinterFormatters & KnownStatsPrinterContext & Record<string, EXPECTED_ANY>} StatsPrinterContext */
 /** @typedef {StatsPrinterContext & Required<KnownStatsPrinterColorFunctions> & Required<KnownStatsPrinterFormatters> & { type: string }} StatsPrinterContextWithExtra */
 /** @typedef {EXPECTED_ANY} PrintObject */
 
 /**
+ * Represents the stats printer runtime component.
  * @typedef {object} StatsPrintHooks
  * @property {HookMap<SyncBailHook<[string[], StatsPrinterContext], void>>} sortElements
  * @property {HookMap<SyncBailHook<[PrintedElement[], StatsPrinterContext], string | undefined | void>>} printElements
@@ -102,8 +113,9 @@ class StatsPrinter {
 			print: new HookMap(() => new SyncBailHook(["object", "context"])),
 			result: new HookMap(() => new SyncWaterfallHook(["result", "context"]))
 		});
-		/** @type {Map<StatsPrintHooks[keyof StatsPrintHooks], Map<string, import("tapable").Hook<EXPECTED_ANY, EXPECTED_ANY>[]>>} */
+		/** @type {Map<StatsPrintHooks[keyof StatsPrintHooks], Map<string, HookMapHook<StatsPrintHooks[keyof StatsPrintHooks]>[]>>} */
 		this._levelHookCache = new Map();
+		/** @type {boolean} */
 		this._inPrint = false;
 	}
 
@@ -144,7 +156,7 @@ class StatsPrinter {
 	 * @private
 	 * @template {StatsPrintHooks[keyof StatsPrintHooks]} HM
 	 * @template {HM extends HookMap<infer H> ? H : never} H
-	 * @template {H extends import("tapable").Hook<EXPECTED_ANY, infer R> ? R : never} R
+	 * @template {H extends import("tapable").Hook<infer A, infer R> ? R : never} R
 	 * @param {HM} hookMap hook map
 	 * @param {string} type type
 	 * @param {(hooK: H) => R | undefined | void} fn fn
@@ -176,6 +188,7 @@ class StatsPrinter {
 	}
 
 	/**
+	 * Returns printed result.
 	 * @param {string} type The type
 	 * @param {PrintObject} object Object to print
 	 * @param {StatsPrinterContext=} baseContext The base context
@@ -195,6 +208,7 @@ class StatsPrinter {
 	}
 
 	/**
+	 * Returns printed result.
 	 * @private
 	 * @param {string} type type
 	 * @param {PrintObject} object object

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;