@depup/webpack 5.111.1-depup.2 → 5.112.0-depup.1

package/lib/{LoaderOptionsPlugin.js → loaders/LoaderOptionsPlugin.js}

@@ -5,21 +5,39 @@
 
 "use strict";
 
-const ModuleFilenameHelpers = require("./ModuleFilenameHelpers");
-const NormalModule = require("./NormalModule");
+const ModuleFilenameHelpers = require("../devtool/ModuleFilenameHelpers");
+const NormalModule = require("../module/NormalModule");
+
+/** @import Compiler from "../Compiler" */
+/** @import { MatchObject } from "../devtool/ModuleFilenameHelpers" */
+
+/**
+ * @inline
+ * @absolutePath true
+ * @typedef {string} AbsolutePath
+ */
+
+/**
+ * A configuration object that can be used to configure older loaders.
+ * @additionalProperties
+ * @inline
+ * @typedef {object} LoaderOptionsPluginLoaderOptions
+ * @property {AbsolutePath=} context The context that can be used to configure older loaders.
+ */
 
 /**
- * @import {
- * 	LoaderOptionsPluginOptions
- * } from "../declarations/plugins/LoaderOptionsPlugin"
+ * @additionalProperties
+ * @schema plugins/LoaderOptionsPlugin
+ * @typedef {object} LoaderOptionsPluginOptions
+ * @property {boolean=} debug Whether loaders should be in debug mode or not. debug will be removed as of webpack 3.
+ * @property {boolean=} minimize Where loaders can be switched to minimize mode.
+ * @property {LoaderOptionsPluginLoaderOptions & Record<string, EXPECTED_ANY>=} options
  */
-/** @import Compiler from "./Compiler" */
-/** @import { MatchObject } from "./ModuleFilenameHelpers" */
 
 /**
  * Defines the loader context type used by this module.
  * @template T
- * @typedef {import("./NormalModule").LoaderContext<T>} LoaderContext
+ * @typedef {import("../module/NormalModule").LoaderContext<T>} LoaderContext
  */
 
 const PLUGIN_NAME = "LoaderOptionsPlugin";
@@ -27,7 +45,7 @@ const PLUGIN_NAME = "LoaderOptionsPlugin";
 class LoaderOptionsPlugin {
 	/**
 	 * Creates an instance of LoaderOptionsPlugin.
-	 * @param {LoaderOptionsPluginOptions & MatchObject} options options object
+	 * @param {LoaderOptionsPluginOptions & MatchObject & Record<string, EXPECTED_ANY>} options options object
 	 */
 	constructor(options = {}) {
 		// If no options are set then generate empty options object
@@ -35,7 +53,7 @@ class LoaderOptionsPlugin {
 		if (!options.test) {
 			options.test = () => true;
 		}
-		/** @type {LoaderOptionsPluginOptions & MatchObject} */
+		/** @type {LoaderOptionsPluginOptions & MatchObject & Record<string, EXPECTED_ANY>} */
 		this.options = options;
 	}
 
@@ -47,14 +65,14 @@ class LoaderOptionsPlugin {
 	apply(compiler) {
 		compiler.hooks.validate.tap(PLUGIN_NAME, () => {
 			compiler.validate(
-				() => require("../schemas/plugins/LoaderOptionsPlugin.json"),
+				() => require("../../schemas/plugins/LoaderOptionsPlugin.json"),
 				this.options,
 				{
 					name: "Loader Options Plugin",
 					baseDataPath: "options"
 				},
 				(options) =>
-					require("../schemas/plugins/LoaderOptionsPlugin.check")(options)
+					require("../../schemas/plugins/LoaderOptionsPlugin.check")(options)
 			);
 		});
 

package/lib/{dependencies → loaders}/LoaderPlugin.js

@@ -5,8 +5,8 @@
 
 "use strict";
 
-const NormalModule = require("../NormalModule");
 const { markNotCacheable } = require("../loaders/LoaderRunner");
+const NormalModule = require("../module/NormalModule");
 const LazySet = require("../util/LazySet");
 const LoaderDependency = require("./LoaderDependency");
 const LoaderImportDependency = require("./LoaderImportDependency");
@@ -21,7 +21,7 @@ const LoaderImportDependency = require("./LoaderImportDependency");
  * } from "../Compilation"
  */
 /** @import Compiler from "../Compiler" */
-/** @import Module, { BuildInfo } from "../Module" */
+/** @import Module, { BuildInfo } from "../module/Module" */
 
 /**
  * Defines the import module callback callback.

package/lib/loaders/LoaderRunner.js

@@ -12,12 +12,14 @@ const loadLoader = require("./loadLoader");
 
 /** @import { RawSourceMap } from "webpack-sources" */
 /** @import { Environment } from "../../declarations/WebpackOptions" */
+/** @import { PreparsedAst } from "../module/Parser" */
+/** @import { LoaderItem } from "../module/NormalModule" */
 
 // Set on a loader context to have each loader's own run measured. Absent
 // unless something asked for the measurement, and read once per loader.
 const LOADER_TIMING = Symbol("loader timing");
 
-/** @typedef {string | ({ loader: string } & Record<string, EXPECTED_ANY>)} LoaderItemInput */
+/** @typedef {string | { loader: string, options?: LoaderItem["options"], ident?: string | null, type?: string | null, fragment?: string }} LoaderItemInput */
 
 /**
  * @typedef {object} ProcessOptions
@@ -49,7 +51,7 @@ const LOADER_TIMING = Symbol("loader timing");
 
 /**
  * @typedef {object} AdditionalDataKnown
- * @property {EXPECTED_OBJECT} webpackAST the AST webpack should parse instead of the source
+ * @property {PreparsedAst} webpackAST the AST webpack should parse instead of the source
  */
 
 /** @typedef {AdditionalDataKnown & Record<string, EXPECTED_ANY>} AdditionalData */
@@ -69,12 +71,12 @@ const LOADER_TIMING = Symbol("loader timing");
  * @property {string} path
  * @property {string} query
  * @property {string} fragment
- * @property {EXPECTED_OBJECT | string | undefined} options
+ * @property {Record<string, EXPECTED_ANY> | string | undefined} options
  * @property {string} ident
- * @property {EXPECTED_FUNCTION | undefined} normal
- * @property {EXPECTED_FUNCTION | undefined} pitch
+ * @property {LoaderDefinitionFunction<EXPECTED_ANY> | RawLoaderDefinitionFunction<EXPECTED_ANY> | undefined} normal
+ * @property {PitchLoaderDefinitionFunction<EXPECTED_ANY> | undefined} pitch
  * @property {boolean | undefined} raw
- * @property {EXPECTED_OBJECT | undefined} data
+ * @property {Record<string, EXPECTED_ANY> | undefined} data
  * @property {boolean} pitchExecuted
  * @property {boolean} normalExecuted
  * @property {("commonjs" | "module")=} type
@@ -138,19 +140,19 @@ const LOADER_TIMING = Symbol("loader timing");
 /**
  * @template [OptionsType={}]
  * @template [ContextAdditions={}]
- * @typedef {(this: import("../NormalModule").LoaderContext<OptionsType> & ContextAdditions, remainingRequest: string, previousRequest: string, data: EXPECTED_OBJECT) => string | Buffer | Promise<string | Buffer> | void} PitchLoaderDefinitionFunction
+ * @typedef {(this: import("../module/NormalModule").LoaderContext<OptionsType> & ContextAdditions, remainingRequest: string, previousRequest: string, data: Record<string, EXPECTED_ANY>) => string | Buffer | Promise<string | Buffer> | void} PitchLoaderDefinitionFunction
  */
 
 /**
  * @template [OptionsType={}]
  * @template [ContextAdditions={}]
- * @typedef {(this: import("../NormalModule").LoaderContext<OptionsType> & ContextAdditions, content: string, sourceMap?: string | RawSourceMap, additionalData?: AdditionalData) => string | Buffer | Promise<string | Buffer> | void} LoaderDefinitionFunction
+ * @typedef {(this: import("../module/NormalModule").LoaderContext<OptionsType> & ContextAdditions, content: string, sourceMap?: string | RawSourceMap, additionalData?: AdditionalData) => string | Buffer | Promise<string | Buffer> | void} LoaderDefinitionFunction
  */
 
 /**
  * @template [OptionsType={}]
  * @template [ContextAdditions={}]
- * @typedef {(this: import("../NormalModule").LoaderContext<OptionsType> & ContextAdditions, content: Buffer, sourceMap?: string | RawSourceMap, additionalData?: AdditionalData) => string | Buffer | Promise<string | Buffer> | void} RawLoaderDefinitionFunction
+ * @typedef {(this: import("../module/NormalModule").LoaderContext<OptionsType> & ContextAdditions, content: Buffer, sourceMap?: string | RawSourceMap, additionalData?: AdditionalData) => string | Buffer | Promise<string | Buffer> | void} RawLoaderDefinitionFunction
  */
 
 /**
@@ -260,15 +262,15 @@ class LoaderObject {
 		this.options = null;
 		/** @type {string | null=} */
 		this.ident = null;
-		/** @type {string=} */
+		/** @type {(string | null)=} */
 		this.type = undefined;
-		/** @type {EXPECTED_FUNCTION | null=} */
+		/** @type {LoaderDefinitionFunction<EXPECTED_ANY> | RawLoaderDefinitionFunction<EXPECTED_ANY> | null=} */
 		this.normal = null;
-		/** @type {EXPECTED_FUNCTION | null=} */
+		/** @type {PitchLoaderDefinitionFunction<EXPECTED_ANY> | null=} */
 		this.pitch = null;
 		/** @type {boolean | null=} */
 		this.raw = null;
-		/** @type {EXPECTED_OBJECT | null=} */
+		/** @type {Record<string, EXPECTED_ANY> | null=} */
 		this.data = null;
 		this.pitchExecuted = false;
 		this.normalExecuted = false;
@@ -338,7 +340,7 @@ const REQUEST_DESCRIPTOR = {
 };
 
 /**
- * @param {EXPECTED_FUNCTION} fn the loader function
+ * @param {LoaderDefinitionFunction<EXPECTED_ANY> | RawLoaderDefinitionFunction<EXPECTED_ANY> | PitchLoaderDefinitionFunction<EXPECTED_ANY>} fn the loader function
  * @param {LoaderContext} context the loader context
  * @param {EXPECTED_ANY[]} args arguments
  * @param {LoaderCallback} callback callback
@@ -383,17 +385,22 @@ function runSyncOrAsync(fn, context, args, callback) {
 		return innerCallback;
 	};
 
+	// The runner types its context more loosely than a loader's `this`.
+	const loader =
+		/** @type {(this: LoaderContext, ...args: EXPECTED_ANY[]) => EXPECTED_ANY} */ (
+			fn
+		);
 	const timing =
-		/** @type {{ [LOADER_TIMING]?: (loader: EXPECTED_ANY, run: () => EXPECTED_ANY) => EXPECTED_ANY }} */
+		/** @type {{ [LOADER_TIMING]?: <T>(loader: LoaderObject, run: () => T) => T }} */
 		(context)[LOADER_TIMING];
 
 	try {
 		const result = (function LOADER_EXECUTION() {
 			return timing
 				? timing(context.loaders[context.loaderIndex], () =>
-						fn.apply(context, args)
+						loader.apply(context, args)
 					)
-				: fn.apply(context, args);
+				: loader.apply(context, args);
 		})();
 		if (isSync) {
 			isDone = true;
@@ -626,7 +633,9 @@ const LOADER_STATE = Symbol("loader context state");
  * @returns {LoaderState} the hidden mutable state carried under `LOADER_STATE`
  */
 function getState(loaderContext) {
-	return /** @type {EXPECTED_ANY} */ (loaderContext)[LOADER_STATE];
+	return /** @type {LoaderContext & { [LOADER_STATE]: LoaderState }} */ (
+		loaderContext
+	)[LOADER_STATE];
 }
 
 /**
@@ -636,7 +645,8 @@ function getState(loaderContext) {
  * and the `request` accessors once host hooks have populated the context, then
  * freezes it — the accessors are added last so V8 keeps the context in
  * fast-properties mode. Returned unfrozen.
- * @param {EXPECTED_ANY=} base object to augment (the caller's context), if any
+ * @template T
+ * @param {T=} base object to augment (the caller's context), if any
  * @returns {LoaderContext} the loader context
  */
 function createLoaderContext(base) {
@@ -816,7 +826,7 @@ module.exports.runLoaders = function runLoaders(options, callback) {
 	// host hook such as `beforeLoaders` can pre-add dependencies or mark the
 	// request non-cacheable before the run; a caller re-running on the same context
 	// should `clearDependencies()` first, to avoid accumulating stale ones.
-	const provided = /** @type {EXPECTED_ANY} */ (options.context);
+	const provided = options.context;
 	const loaderContext =
 		provided && provided[LOADER_STATE]
 			? /** @type {LoaderContext} */ (provided)
@@ -842,7 +852,7 @@ module.exports.runLoaders = function runLoaders(options, callback) {
 
 	const processResourceFn =
 		options.processResource ||
-		/** @type {(readResource: EXPECTED_FUNCTION, context: EXPECTED_ANY, res: string, cb: (err: Error | null, ...args: EXPECTED_ANY[]) => void) => void} */
+		/** @type {(readResource: NonNullable<RunLoaderOptions["readResource"]>, context: LoaderContext, res: string, cb: (err: Error | null, result?: Buffer) => void) => void} */
 		(
 			(readResource, context, res, cb) => {
 				context.addDependency(res);

package/lib/{LoaderTargetPlugin.js → loaders/LoaderTargetPlugin.js}

@@ -5,9 +5,9 @@
 
 "use strict";
 
-const NormalModule = require("./NormalModule");
+const NormalModule = require("../module/NormalModule");
 
-/** @import Compiler from "./Compiler" */
+/** @import Compiler from "../Compiler" */
 
 const PLUGIN_NAME = "LoaderTargetPlugin";
 

package/lib/logging/Logger.js

@@ -38,11 +38,11 @@ const TIMERS_AGGREGATES_SYMBOL = Symbol("webpack logger aggregated times");
 
 /** @typedef {EXPECTED_ANY[]} Args */
 /** @typedef {(type: LogTypeEnum, args?: Args) => void} LogFn */
-/** @typedef {(name: string | (() => string)) => WebpackLogger} GetChildLogger */
+/** @typedef {(name: string | (() => string)) => Logger} GetChildLogger */
 
-class WebpackLogger {
+class Logger {
 	/**
-	 * Creates an instance of WebpackLogger.
+	 * Creates an instance of Logger.
 	 * @param {LogFn} log log function
 	 * @param {GetChildLogger} getChildLogger function to create child logger
 	 */
@@ -173,7 +173,7 @@ class WebpackLogger {
 	timeLog(label) {
 		const prev = this[TIMERS_SYMBOL] && this[TIMERS_SYMBOL].get(label);
 		if (!prev) {
-			throw new Error(`No such label '${label}' for WebpackLogger.timeLog()`);
+			throw new Error(`No such label '${label}' for Logger.timeLog()`);
 		}
 		const time = process.hrtime(prev);
 		this[LOG_SYMBOL](LogType.time, [label, ...time]);
@@ -186,7 +186,7 @@ class WebpackLogger {
 	timeEnd(label) {
 		const prev = this[TIMERS_SYMBOL] && this[TIMERS_SYMBOL].get(label);
 		if (!prev) {
-			throw new Error(`No such label '${label}' for WebpackLogger.timeEnd()`);
+			throw new Error(`No such label '${label}' for Logger.timeEnd()`);
 		}
 		const time = process.hrtime(prev);
 		/** @type {TimersMap} */
@@ -201,9 +201,7 @@ class WebpackLogger {
 	timeAggregate(label) {
 		const prev = this[TIMERS_SYMBOL] && this[TIMERS_SYMBOL].get(label);
 		if (!prev) {
-			throw new Error(
-				`No such label '${label}' for WebpackLogger.timeAggregate()`
-			);
+			throw new Error(`No such label '${label}' for Logger.timeAggregate()`);
 		}
 		const time = process.hrtime(prev);
 		/** @type {TimersMap} */
@@ -237,4 +235,4 @@ class WebpackLogger {
 	}
 }
 
-module.exports.Logger = WebpackLogger;
+module.exports.Logger = Logger;