feat: add LoaderContext to types

declarations/LoaderContext.d.ts

@@ -0,0 +1,172 @@
+import type { AssetInfo, Configuration } from "../lib";
+import Compilation from "../lib/Compilation";
+import NormalModule, { InputFileSystem } from "../lib/NormalModule";
+import type { Mode } from "./WebpackOptions";
+
+export interface LoaderContext {
+	version: number;
+	getOptions(schema: any): any;
+	emitWarning(warning: Error | string): void;
+	emitError(error: Error | string): void;
+	getLogger(name: string): Compilation["logger"];
+	resolve(context: string, request: string, callback: any): any;
+	getResolve(
+		options: Configuration
+	): (context: string, request: string, callback: any) => Promise<any>;
+	emitFile(
+		name: string,
+		content: string,
+		sourceMap: string,
+		assetInfo: AssetInfo
+	): void;
+	addBuildDependency(dep: string): void;
+	utils: {
+		absolutify: (context: string, request: string) => string;
+		contextify: (context: string, request: string) => string;
+	};
+	rootContext: string;
+	webpack: boolean;
+	sourceMap: boolean;
+	mode: Mode;
+	_module: NormalModule;
+	_compilation: Compilation;
+	_compiler: Compilation.Compiler;
+	fs: InputFileSystem;
+}
+
+/** The types added to LoaderContextBase by https://github.com/webpack/loader-runner */
+export interface EmptyContextAdditions {
+	/**
+	 * Add a directory as dependency of the loader result.
+	 */
+	addContextDependency(context: string): void;
+
+	/**
+	 * Adds a file as dependency of the loader result in order to make them watchable.
+	 * For example, html-loader uses this technique as it finds src and src-set attributes.
+	 * Then, it sets the url's for those attributes as dependencies of the html file that is parsed.
+	 */
+	addDependency(file: string): void;
+
+	addMissingDependency(context: string): void;
+
+	/**
+	 * Make this loader async.
+	 */
+	async(): (
+		err: Error | undefined | null,
+		content?: string | Buffer,
+		sourceMap?: string | any
+	) => void | undefined;
+
+	/**
+	 * Make this loader result cacheable. By default it's not cacheable.
+	 * A cacheable loader must have a deterministic result, when inputs and dependencies haven't changed.
+	 * This means the loader shouldn't have other dependencies than specified with this.addDependency.
+	 * Most loaders are deterministic and cacheable.
+	 */
+	cacheable(flag?: boolean): void;
+
+	callback(): void;
+
+	/**
+	 * Remove all dependencies of the loader result. Even initial dependencies and these of other loaders.
+	 */
+	clearDependencies(): void;
+
+	/**
+	 * The directory of the module. Can be used as context for resolving other stuff.
+	 * eg '/workspaces/ts-loader/examples/vanilla/src'
+	 */
+	context: string;
+
+	readonly currentRequest: string;
+
+	readonly data: any;
+	/**
+	 * alias of addDependency
+	 * Adds a file as dependency of the loader result in order to make them watchable.
+	 * For example, html-loader uses this technique as it finds src and src-set attributes.
+	 * Then, it sets the url's for those attributes as dependencies of the html file that is parsed.
+	 */
+	dependency(file: string): void;
+
+	getContextDependencies(): string[];
+
+	getDependencies(): string[];
+
+	getMissingDependencies(): string[];
+
+	/**
+	 * The index in the loaders array of the current loader.
+	 * In the example: in loader1: 0, in loader2: 1
+	 */
+	loaderIndex: number;
+
+	/**
+	 * Resolves the given request to a module, applies all configured loaders and calls
+	 * back with the generated source, the sourceMap and the module instance (usually an
+	 * instance of NormalModule). Use this function if you need to know the source code
+	 * of another module to generate the result.
+	 */
+	loadModule(
+		request: string,
+		callback: (
+			err: Error | null,
+			source: string,
+			sourceMap: any,
+			module: NormalModule
+		) => void
+	): void;
+
+	readonly previousRequest: string;
+
+	readonly query: any;
+
+	readonly remainingRequest: string;
+
+	readonly request: string;
+
+	/**
+	 * An array of all the loaders. It is writeable in the pitch phase.
+	 * loaders = [{request: string, path: string, query: string, module: function}]
+	 *
+	 * In the example:
+	 * [
+	 *   { request: "/abc/loader1.js?xyz",
+	 *     path: "/abc/loader1.js",
+	 *     query: "?xyz",
+	 *     module: [Function]
+	 *   },
+	 *   { request: "/abc/node_modules/loader2/index.js",
+	 *     path: "/abc/node_modules/loader2/index.js",
+	 *     query: "",
+	 *     module: [Function]
+	 *   }
+	 * ]
+	 */
+	loaders: { 
+        request: string;
+        path: string;
+		query: string;
+		fragment: string;
+		options: any;
+		ident: string;
+		normal: any;
+		pitch: any;
+		raw: any;
+		data: any;
+		pitchExecuted: boolean;
+		normalExecuted: boolean;
+    }[];
+
+	/**
+	 * The resource file.
+	 * In the example: "/abc/resource.js"
+	 */
+	resourcePath: string;
+}
+
+export interface LoaderDefinition<ContextAdditions = EmptyContextAdditions> {
+    (this: LoaderContext & ContextAdditions, contents: string): string;
+}

lib/NormalModule.js

@@ -44,8 +44,11 @@ const memoize = require("./util/memoize");
 
 /** @typedef {import("source-map").RawSourceMap} SourceMap */
 /** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../declarations/LoaderContext").LoaderContext} LoaderContext */
+/** @typedef {import("../declarations/WebpackOptions").Mode} Mode */
 /** @typedef {import("../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptions */
 /** @typedef {import("./ChunkGraph")} ChunkGraph */
+/** @typedef {import("./Compiler")} Compiler */
 /** @typedef {import("./Dependency").UpdateHashContext} UpdateHashContext */
 /** @typedef {import("./DependencyTemplates")} DependencyTemplates */
 /** @typedef {import("./Generator")} Generator */
@@ -61,6 +64,7 @@ const memoize = require("./util/memoize");
 /** @typedef {import("./RequestShortener")} RequestShortener */
 /** @typedef {import("./ResolverFactory").ResolverWithOptions} ResolverWithOptions */
 /** @typedef {import("./RuntimeTemplate")} RuntimeTemplate */
+/** @typedef {import("./logging/Logger").Logger} WebpackLogger */
 /** @typedef {import("./util/Hash")} Hash */
 /** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
 /** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
@@ -421,7 +425,7 @@ class NormalModule extends Module {
 	 * @param {WebpackOptions} options webpack options
 	 * @param {Compilation} compilation the compilation
 	 * @param {InputFileSystem} fs file system from reading
-	 * @returns {any} loader context
+	 * @returns {LoaderContext} loader context
 	 */
 	createLoaderContext(resolver, options, compilation, fs) {
 		const { requestShortener } = compilation.runtimeTemplate;

lib/index.js

@@ -8,6 +8,9 @@
 const util = require("util");
 const memoize = require("./util/memoize");
 
+/** @typedef {import("../declarations/LoaderContext").EmptyContextAdditions} EmptyContextAdditions */
+/** @typedef {import("../declarations/LoaderContext").LoaderContext} LoaderContext */
+/** @typedef {import("../declarations/LoaderContext").LoaderDefinition} LoaderDefinition */
 /** @typedef {import("../declarations/WebpackOptions").Entry} Entry */
 /** @typedef {import("../declarations/WebpackOptions").EntryNormalized} EntryNormalized */
 /** @typedef {import("../declarations/WebpackOptions").EntryObject} EntryObject */

test/cases/errors/load-module-error/error-loader.js

@@ -1,3 +1,4 @@
+/** @type {import("../../../../types").LoaderDefinition} */
 module.exports = function(source) {
 	const callback = this.async();
 	callback(new Error("err: abc"));