test: fix

Author: alexander-akait

package-lock.json

@@ -70,7 +70,6 @@
     "@types/micromatch": "^4.0.9",
     "@types/node": "^22.15.30",
     "@types/normalize-path": "^3.0.2",
-    "@types/webpack": "^5.28.5",
     "babel-jest": "^30.0.0",
     "chokidar": "^4.0.3",
     "cross-env": "^7.0.3",

package.json

@@ -1 +1 @@
-require('./good');
+require("./good");

test/fixtures/good-entry.js

@@ -1,3 +1,6 @@
+/**
+ * @returns {string} value
+ */
 function test() {
   return "value"
 }

test/fixtures/good.js

@@ -14,7 +14,6 @@ export default (entry, pluginConf = {}, webpackConf = {}) => {
     },
     plugins: [
       new ESLintPlugin({
-        configType: "eslintrc",
         // this disables the use of .eslintignore, since it contains the fixtures
         // folder to skip it on the global linting, but here we want the opposite
         // (we only use .eslintignore on the test that checks this)

test/utils/conf.js

@@ -1,7 +1,7 @@
 export = ESLintError;
 declare class ESLintError extends Error {
   /**
-   * @param {string=} messages
+   * @param {string=} messages messages
    */
   constructor(messages?: string | undefined);
   stack: string;

types/ESLintError.d.ts

@@ -12,6 +12,15 @@ export type Linter = {
 export type Worker = JestWorker & {
   lintFiles: LintTask;
 };
+/**
+ * @param {string | undefined} key a cache key
+ * @param {Options} options options
+ * @returns {Promise<Linter>} linter
+ */
+export function getESLint(
+  key: string | undefined,
+  { threads, ...options }: Options,
+): Promise<Linter>;
 /** @typedef {import('eslint').ESLint} ESLint */
 /** @typedef {import('eslint').ESLint.LintResult} LintResult */
 /** @typedef {import('./options').Options} Options */
@@ -20,28 +29,19 @@ export type Worker = JestWorker & {
 /** @typedef {{threads: number, eslint: ESLint, lintFiles: LintTask, cleanup: AsyncTask}} Linter */
 /** @typedef {JestWorker & {lintFiles: LintTask}} Worker */
 /**
- * @param {Options} options
- * @returns {Promise<Linter>}
+ * @param {Options} options options
+ * @returns {Promise<Linter>} linter
  */
 export function loadESLint(options: Options): Promise<Linter>;
 /**
- * @param {string|undefined} key
- * @param {number} poolSize
- * @param {Options} options
- * @returns {Promise<Linter>}
+ * @param {string | undefined} key a cache key
+ * @param {number} poolSize number of workers
+ * @param {Options} options options
+ * @returns {Promise<Linter>} linter
  */
 export function loadESLintThreaded(
   key: string | undefined,
   poolSize: number,
   options: Options,
 ): Promise<Linter>;
-/**
- * @param {string|undefined} key
- * @param {Options} options
- * @returns {Promise<Linter>}
- */
-export function getESLint(
-  key: string | undefined,
-  { threads, ...options }: Options,
-): Promise<Linter>;
 import { Worker as JestWorker } from "jest-worker";

types/getESLint.d.ts

@@ -1,16 +1,16 @@
 export = ESLintWebpackPlugin;
 declare class ESLintWebpackPlugin {
   /**
-   * @param {Options} options
+   * @param {Options=} options options
    */
-  constructor(options?: Options);
+  constructor(options?: Options | undefined);
   key: string;
   options: import("./options").PluginOptions;
   /**
-   * @param {Compiler} compiler
-   * @param {Omit<Options, 'resourceQueryExclude'> & {resourceQueryExclude: RegExp[]}} options
-   * @param {string[]} wanted
-   * @param {string[]} exclude
+   * @param {Compiler} compiler compiler
+   * @param {Omit<Options, 'resourceQueryExclude'> & { resourceQueryExclude: RegExp[] }} options options
+   * @param {string[]} wanted wanted files
+   * @param {string[]} exclude excluded files
    */
   run(
     compiler: Compiler,
@@ -21,14 +21,13 @@ declare class ESLintWebpackPlugin {
     exclude: string[],
   ): Promise<void>;
   /**
-   * @param {Compiler} compiler
+   * @param {Compiler} compiler compiler
    * @returns {void}
    */
   apply(compiler: Compiler): void;
   /**
-   *
-   * @param {Compiler} compiler
-   * @returns {string}
+   * @param {Compiler} compiler compiler
+   * @returns {string} context
    */
   getContext(compiler: Compiler): string;
 }

types/index.d.ts

@@ -1,9 +1,9 @@
 export = linter;
 /**
- * @param {string|undefined} key
- * @param {Options} options
- * @param {Compilation} compilation
- * @returns {Promise<{lint: Linter, report: Reporter, threads: number}>}
+ * @param {string | undefined} key a cache key
+ * @param {Options} options options
+ * @param {Compilation} compilation compilation
+ * @returns {Promise<{lint: Linter, report: Reporter, threads: number}>} linter with additional functions
  */
 declare function linter(
   key: string | undefined,

types/linter.d.ts

@@ -2,69 +2,126 @@ export type ESLintOptions = import("eslint").ESLint.Options;
 export type LintResult = import("eslint").ESLint.LintResult;
 export type FormatterFunction = (results: LintResult[]) => string;
 export type OutputReport = {
+  /**
+   * a file path
+   */
   filePath?: string | undefined;
+  /**
+   * a formatter
+   */
   formatter?: (string | FormatterFunction) | undefined;
 };
 export type PluginOptions = {
+  /**
+   * a string indicating the root of your files
+   */
   context?: string | undefined;
+  /**
+   * the errors found will always be emitted
+   */
   emitError?: boolean | undefined;
+  /**
+   * the warnings found will always be emitted
+   */
   emitWarning?: boolean | undefined;
-  eslintPath?: string | undefined;
+  /**
+   * specify the files and/or directories to exclude
+   */
   exclude?: (string | string[]) | undefined;
+  /**
+   * specify the extensions that should be checked
+   */
   extensions?: (string | string[]) | undefined;
+  /**
+   * will cause the module build to fail if there are any errors
+   */
   failOnError?: boolean | undefined;
+  /**
+   * will cause the module build to fail if there are any warning
+   */
   failOnWarning?: boolean | undefined;
+  /**
+   * specify directories, files, or globs
+   */
   files?: (string | string[]) | undefined;
+  /**
+   * apply fixes
+   */
   fix?: boolean | undefined;
+  /**
+   * specify the formatter you would like to use to format your results
+   */
   formatter?: (string | FormatterFunction) | undefined;
+  /**
+   * lint only changed files, skip linting on start
+   */
   lintDirtyModulesOnly?: boolean | undefined;
+  /**
+   * will process and report errors only and ignore warnings
+   */
   quiet?: boolean | undefined;
+  /**
+   * path to `eslint` instance that will be used for linting
+   */
+  eslintPath?: string | undefined;
+  /**
+   * writes the output of the errors to a file - for example, a `json` file for use for reporting
+   */
   outputReport?: OutputReport | undefined;
+  /**
+   * number of worker threads
+   */
   threads?: (number | boolean) | undefined;
+  /**
+   * Specify the resource query to exclude
+   */
   resourceQueryExclude?: (RegExp | RegExp[]) | undefined;
+  /**
+   * config type
+   */
   configType?: string | undefined;
 };
 export type Options = PluginOptions & ESLintOptions;
+/**
+ * @param {Options} loaderOptions loader options
+ * @returns {ESLintOptions} eslint options
+ */
+export function getESLintOptions(loaderOptions: Options): ESLintOptions;
 /** @typedef {import("eslint").ESLint.Options} ESLintOptions */
 /** @typedef {import('eslint').ESLint.LintResult} LintResult */
 /**
  * @callback FormatterFunction
- * @param {LintResult[]} results
- * @returns {string}
+ * @param {LintResult[]} results results
+ * @returns {string} formatted result
  */
 /**
- * @typedef {Object} OutputReport
- * @property {string=} filePath
- * @property {string|FormatterFunction=} formatter
+ * @typedef {object} OutputReport
+ * @property {string=} filePath a file path
+ * @property {string | FormatterFunction=} formatter a formatter
  */
 /**
- * @typedef {Object} PluginOptions
- * @property {string=} context
- * @property {boolean=} emitError
- * @property {boolean=} emitWarning
- * @property {string=} eslintPath
- * @property {string|string[]=} exclude
- * @property {string|string[]=} extensions
- * @property {boolean=} failOnError
- * @property {boolean=} failOnWarning
- * @property {string|string[]=} files
- * @property {boolean=} fix
- * @property {string|FormatterFunction=} formatter
- * @property {boolean=} lintDirtyModulesOnly
- * @property {boolean=} quiet
- * @property {OutputReport=} outputReport
- * @property {number|boolean=} threads
- * @property {RegExp|RegExp[]=} resourceQueryExclude
- * @property {string=} configType
+ * @typedef {object} PluginOptions
+ * @property {string=} context a string indicating the root of your files
+ * @property {boolean=} emitError the errors found will always be emitted
+ * @property {boolean=} emitWarning the warnings found will always be emitted
+ * @property {string | string[]=} exclude specify the files and/or directories to exclude
+ * @property {string | string[]=} extensions specify the extensions that should be checked
+ * @property {boolean=} failOnError will cause the module build to fail if there are any errors
+ * @property {boolean=} failOnWarning will cause the module build to fail if there are any warning
+ * @property {string | string[]=} files specify directories, files, or globs
+ * @property {boolean=} fix apply fixes
+ * @property {string | FormatterFunction=} formatter specify the formatter you would like to use to format your results
+ * @property {boolean=} lintDirtyModulesOnly lint only changed files, skip linting on start
+ * @property {boolean=} quiet will process and report errors only and ignore warnings
+ * @property {string=} eslintPath path to `eslint` instance that will be used for linting
+ * @property {OutputReport=} outputReport writes the output of the errors to a file - for example, a `json` file for use for reporting
+ * @property {number | boolean=} threads number of worker threads
+ * @property {RegExp | RegExp[]=} resourceQueryExclude Specify the resource query to exclude
+ * @property {string=} configType config type
  */
 /** @typedef {PluginOptions & ESLintOptions} Options */
 /**
- * @param {Options} pluginOptions
- * @returns {PluginOptions}
+ * @param {Options} pluginOptions plugin options
+ * @returns {PluginOptions} normalized plugin options
  */
 export function getOptions(pluginOptions: Options): PluginOptions;
-/**
- * @param {Options} loaderOptions
- * @returns {ESLintOptions}
- */
-export function getESLintOptions(loaderOptions: Options): ESLintOptions;