stylelint-webpack-plugin 3.3.0 → 4.0.0

package/README.md

@@ -5,7 +5,6 @@
 
 [![npm][npm]][npm-url]
 [![node][node]][node-url]
-[![deps][deps]][deps-url]
 [![tests][tests]][tests-url]
 [![coverage][cover]][cover-url]
 [![chat][chat]][chat-url]
@@ -37,7 +36,9 @@ or
 pnpm add -D stylelint-webpack-plugin
 ```
 
-**Note**: You also need to install `stylelint >= 13` from npm, if you haven't already:
+> **Note**:
+>
+> You also need to install `stylelint >= 13` from npm, if you haven't already:
 
 ```console
 npm install stylelint --save-dev
@@ -55,7 +56,9 @@ or
 pnpm add -D stylelint
 ```
 
-**Note**: If you are using Stylelint 13 rather than 14+, you might also need to install `@types/stylelint` as a dev dependency if getting stylelint related type errors.
+> **Note**:
+>
+> If you are using Stylelint 13 rather than 14+, you might also need to install `@types/stylelint` as a dev dependency if getting stylelint related type errors.
 
 Then add the plugin to your webpack config. For example:
 
@@ -85,7 +88,9 @@ type context = string;
 
 Specify the config file location to be used by `stylelint`.
 
-**Note:** By default this is [handled by `stylelint`](https://stylelint.io/user-guide/configure).
+> **Note:**
+>
+> By default this is [handled by `stylelint`](https://stylelint.io/user-guide/configure).
 
 ### `context`
 
@@ -305,8 +310,6 @@ You can pass in a different formatter for the output file, if none is passed in
 [npm-url]: https://npmjs.com/package/stylelint-webpack-plugin
 [node]: https://img.shields.io/node/v/stylelint-webpack-plugin.svg
 [node-url]: https://nodejs.org
-[deps]: https://david-dm.org/webpack-contrib/stylelint-webpack-plugin.svg
-[deps-url]: https://david-dm.org/webpack-contrib/stylelint-webpack-plugin
 [tests]: https://github.com/webpack-contrib/stylelint-webpack-plugin/workflows/stylelint-webpack-plugin/badge.svg
 [tests-url]: https://github.com/webpack-contrib/stylelint-webpack-plugin/actions
 [cover]: https://codecov.io/gh/webpack-contrib/stylelint-webpack-plugin/branch/master/graph/badge.svg

package/dist/StylelintError.js

@@ -9,7 +9,5 @@ class StylelintError extends Error {
     this.name = 'StylelintError';
     this.stack = '';
   }
-
 }
-
 module.exports = StylelintError;

package/dist/getStylelint.js

@@ -3,94 +3,90 @@
 const {
   cpus
 } = require('os');
-
 const {
   Worker: JestWorker
-} = require('jest-worker'); // @ts-ignore
-
+} = require('jest-worker');
 
+// @ts-ignore
 const {
   setup,
   lintFiles
 } = require('./worker');
-
 const {
   jsonStringifyReplacerSortKeys
 } = require('./utils');
-
 const {
   getStylelintOptions
 } = require('./options');
-/** @type {{[key: string]: any}} */
-
 
+/** @type {{[key: string]: any}} */
 const cache = {};
-/** @typedef {import('stylelint')} Stylelint */
 
+/** @typedef {import('stylelint')} Stylelint */
 /** @typedef {import('stylelint').LintResult} LintResult */
-
 /** @typedef {import('./options').Options} Options */
-
+/** @typedef {(stylelint: Stylelint, filePath: string) => Promise<boolean>} isPathIgnored */
 /** @typedef {() => Promise<void>} AsyncTask */
-
 /** @typedef {(files: string|string[]) => Promise<LintResult[]>} LintTask */
-
-/** @typedef {{api: import('stylelint').InternalApi, stylelint: Stylelint, lintFiles: LintTask, cleanup: AsyncTask, threads: number, }} Linter */
-
+/** @typedef {{stylelint: Stylelint, isPathIgnored: isPathIgnored, lintFiles: LintTask, cleanup: AsyncTask, threads: number }} Linter */
 /** @typedef {JestWorker & {lintFiles: LintTask}} Worker */
 
 /**
  * @param {Options} options
  * @returns {Linter}
  */
-
 function loadStylelint(options) {
   const stylelintOptions = getStylelintOptions(options);
   const stylelint = setup(options, stylelintOptions);
+
+  /** @type {isPathIgnored} */
+  let isPathIgnored;
+  try {
+    isPathIgnored = require(`${options.stylelintPath}/lib/isPathIgnored`);
+  } catch (e) {
+    try {
+      // @ts-ignore
+      isPathIgnored = require('stylelint/lib/isPathIgnored');
+    } catch (_) {
+      isPathIgnored = () => Promise.resolve(false);
+    }
+  }
   return {
     stylelint,
-    api: stylelint.createLinter(stylelintOptions),
+    isPathIgnored,
     lintFiles,
     cleanup: async () => {},
     threads: 1
   };
 }
+
 /**
  * @param {string|undefined} key
  * @param {number} poolSize
  * @param {Options} options
  * @returns {Linter}
  */
-
-
 function loadStylelintThreaded(key, poolSize, options) {
   const cacheKey = getCacheKey(key, options);
-
   const source = require.resolve('./worker');
-
   const workerOptions = {
     enableWorkerThreads: true,
     numWorkers: poolSize,
     setupArgs: [options, getStylelintOptions(options)]
   };
   const local = loadStylelint(options);
-  let worker =
-  /** @type {Worker?} */
-  new JestWorker(source, workerOptions);
-  /** @type {Linter} */
+  let worker = /** @type {Worker?} */new JestWorker(source, workerOptions);
 
-  const context = { ...local,
+  /** @type {Linter} */
+  const context = {
+    ...local,
     threads: poolSize,
-    lintFiles: async files =>
-    /* istanbul ignore next */
+    lintFiles: async files => /* istanbul ignore next */
     worker ? worker.lintFiles(files) : local.lintFiles(files),
     cleanup: async () => {
       cache[cacheKey] = local;
-
       context.lintFiles = files => local.lintFiles(files);
       /* istanbul ignore next */
-
-
       if (worker) {
         worker.end();
         worker = null;
@@ -99,13 +95,12 @@ function loadStylelintThreaded(key, poolSize, options) {
   };
   return context;
 }
+
 /**
  * @param {string|undefined} key
  * @param {Options} options
  * @returns {Linter}
  */
-
-
 function getStylelint(key, {
   threads,
   ...options
@@ -115,25 +110,21 @@ function getStylelint(key, {
     threads,
     ...options
   });
-
   if (!cache[cacheKey]) {
     cache[cacheKey] = max > 1 ? loadStylelintThreaded(key, max, options) : loadStylelint(options);
   }
-
   return cache[cacheKey];
 }
+
 /**
  * @param {string|undefined} key
  * @param {Options} options
  * @returns {string}
  */
-
-
 function getCacheKey(key, options) {
   return JSON.stringify({
     key,
     options
   }, jsonStringifyReplacerSortKeys);
 }
-
 module.exports = getStylelint;

package/dist/index.js

@@ -4,36 +4,27 @@ const {
   isAbsolute,
   join
 } = require('path');
-
 const globby = require('globby');
-
 const {
   isMatch
 } = require('micromatch');
-
 const {
   getOptions
 } = require('./options');
-
 const linter = require('./linter');
-
 const {
   arrify,
   parseFiles,
   parseFoldersToGlobs
 } = require('./utils');
-/** @typedef {import('webpack').Compiler} Compiler */
 
+/** @typedef {import('webpack').Compiler} Compiler */
 /** @typedef {import('webpack').Module} Module */
-
 /** @typedef {import('./options').Options} Options */
-
 /** @typedef {Partial<{timestamp:number} | number>} FileSystemInfoEntry */
 
-
 const STYLELINT_PLUGIN = 'StylelintWebpackPlugin';
 let counter = 0;
-
 class StylelintWebpackPlugin {
   /**
    * @param {Options} options
@@ -45,78 +36,78 @@ class StylelintWebpackPlugin {
     this.startTime = Date.now();
     this.prevTimestamps = new Map();
   }
+
   /**
    * @param {Compiler} compiler
    * @returns {void}
    */
-
-
   apply(compiler) {
     // Generate key for each compilation,
     // this differentiates one from the other when being cached.
     this.key = compiler.name || `${this.key}_${counter += 1}`;
     const context = this.getContext(compiler);
     const excludeDefault = ['**/node_modules/**', String(compiler.options.output.path)];
-    const options = { ...this.options,
+    const options = {
+      ...this.options,
       context,
       exclude: parseFiles(this.options.exclude || excludeDefault, context),
       extensions: arrify(this.options.extensions),
       files: parseFiles(this.options.files || '', context)
     };
     const wanted = parseFoldersToGlobs(options.files, options.extensions);
-    const exclude = parseFoldersToGlobs(options.exclude); // If `lintDirtyModulesOnly` is disabled,
-    // execute the linter on the build
+    const exclude = parseFoldersToGlobs(options.exclude);
 
+    // If `lintDirtyModulesOnly` is disabled,
+    // execute the linter on the build
     if (!this.options.lintDirtyModulesOnly) {
       compiler.hooks.run.tapPromise(this.key, c => this.run(c, options, wanted, exclude));
     }
-
     let isFirstRun = this.options.lintDirtyModulesOnly;
     compiler.hooks.watchRun.tapPromise(this.key, c => {
       if (isFirstRun) {
         isFirstRun = false;
         return Promise.resolve();
       }
-
       return this.run(c, options, wanted, exclude);
     });
   }
+
   /**
    * @param {Compiler} compiler
    * @param {Options} options
    * @param {string[]} wanted
    * @param {string[]} exclude
    */
-
-
   async run(compiler, options, wanted, exclude) {
     // Do not re-hook
-
     /* istanbul ignore if */
-    if ( // @ts-ignore
+    if (
+    // @ts-ignore
     compiler.hooks.thisCompilation.taps.find(({
       name
     }) => name === this.key)) {
       return;
     }
-
     compiler.hooks.thisCompilation.tap(this.key, compilation => {
+      /** @type {import('stylelint')} */
+      let stylelint;
+
       /** @type {import('./linter').Linter} */
       let lint;
-      /** @type {import('stylelint').InternalApi} */
 
-      let api;
-      /** @type {import('./linter').Reporter} */
+      /** @type {import('./linter').isPathIgnored} */
+      let isPathIgnored;
 
+      /** @type {import('./linter').Reporter} */
       let report;
-      /** @type number */
 
+      /** @type number */
       let threads;
-
       try {
         ({
+          stylelint,
           lint,
-          api,
+          isPathIgnored,
           report,
           threads
         } = linter(this.key, options, compilation));
@@ -124,7 +115,6 @@ class StylelintWebpackPlugin {
         compilation.errors.push(e);
         return;
       }
-
       compilation.hooks.finishModules.tapPromise(this.key, async () => {
         /** @type {string[]} */
         // @ts-ignore
@@ -137,30 +127,28 @@ class StylelintWebpackPlugin {
           ignore: exclude
         })).map(async file => {
           try {
-            return (await api.isPathIgnored(file)) ? false : file;
+            return (await isPathIgnored(stylelint, file)) ? false : file;
           } catch (e) {
             return file;
           }
         }))).filter(file => file !== false);
-
         if (threads > 1) {
           for (const file of files) {
-            lint(parseFiles(file, options.context || ''));
+            lint(parseFiles(file, String(options.context)));
           }
         } else if (files.length > 0) {
-          lint(parseFiles(files, options.context || ''));
+          lint(parseFiles(files, String(options.context)));
         }
-      }); // await and interpret results
+      });
 
+      // await and interpret results
       compilation.hooks.additionalAssets.tapPromise(this.key, processResults);
-
       async function processResults() {
         const {
           errors,
           warnings,
           generateReportAsset
         } = await report();
-
         if (warnings && !options.failOnWarning) {
           // @ts-ignore
           compilation.warnings.push(warnings);
@@ -168,7 +156,6 @@ class StylelintWebpackPlugin {
           // @ts-ignore
           compilation.errors.push(warnings);
         }
-
         if (errors && options.failOnError) {
           // @ts-ignore
           compilation.errors.push(errors);
@@ -176,32 +163,26 @@ class StylelintWebpackPlugin {
           // @ts-ignore
           compilation.warnings.push(errors);
         }
-
         if (generateReportAsset) {
           await generateReportAsset(compilation);
         }
       }
     });
   }
+
   /**
    *
    * @param {Compiler} compiler
    * @returns {string}
    */
-
-
   getContext(compiler) {
     if (!this.options.context) {
       return String(compiler.options.context);
     }
-
     if (!isAbsolute(this.options.context)) {
       return join(String(compiler.options.context), this.options.context);
     }
-
     return this.options.context;
   }
-
 }
-
 module.exports = StylelintWebpackPlugin;

package/dist/linter.js

@@ -5,75 +5,59 @@ const {
   isAbsolute,
   join
 } = require('path');
-
 const StylelintError = require('./StylelintError');
-
 const getStylelint = require('./getStylelint');
-
 const {
   arrify
 } = require('./utils');
-/** @typedef {import('stylelint')} Stylelint */
 
+/** @typedef {import('stylelint')} Stylelint */
 /** @typedef {import('stylelint').LintResult} LintResult */
-
-/** @typedef {import('stylelint').InternalApi} InternalApi */
-
+/** @typedef {import('stylelint').LinterResult} LinterResult */
+/** @typedef {import('stylelint').Formatter} Formatter */
+/** @typedef {import('stylelint').FormatterType} FormatterType */
 /** @typedef {import('webpack').Compiler} Compiler */
-
 /** @typedef {import('webpack').Compilation} Compilation */
-
 /** @typedef {import('./options').Options} Options */
-
-/** @typedef {import('./options').FormatterType} FormatterType */
-
-/** @typedef {((results: LintResult[]) => string)} FormatterFunction */
-
+/** @typedef {import('./getStylelint').isPathIgnored} isPathIgnored */
 /** @typedef {(compilation: Compilation) => Promise<void>} GenerateReport */
-
 /** @typedef {{errors?: StylelintError, warnings?: StylelintError, generateReportAsset?: GenerateReport}} Report */
-
 /** @typedef {() => Promise<Report>} Reporter */
-
 /** @typedef {(files: string|string[]) => void} Linter */
-
 /** @typedef {{[files: string]: LintResult}} LintResultMap */
 
 /** @type {WeakMap<Compiler, LintResultMap>} */
-
-
 const resultStorage = new WeakMap();
+
 /**
  * @param {string|undefined} key
  * @param {Options} options
  * @param {Compilation} compilation
- * @returns {{api: InternalApi, lint: Linter, report: Reporter, threads: number}}
+ * @returns {{stylelint: Stylelint, isPathIgnored: isPathIgnored, lint: Linter, report: Reporter, threads: number}}
  */
-
 function linter(key, options, compilation) {
   /** @type {Stylelint} */
   let stylelint;
-  /** @type {InternalApi} */
 
-  let api;
-  /** @type {(files: string|string[]) => Promise<LintResult[]>} */
+  /** @type {isPathIgnored} */
+  let isPathIgnored;
 
+  /** @type {(files: string|string[]) => Promise<LintResult[]>} */
   let lintFiles;
-  /** @type {() => Promise<void>} */
 
+  /** @type {() => Promise<void>} */
   let cleanup;
-  /** @type number */
 
+  /** @type number */
   let threads;
-  /** @type {Promise<LintResult[]>[]} */
 
+  /** @type {Promise<LintResult[]>[]} */
   const rawResults = [];
   const crossRunResultStorage = getResultStorage(compilation);
-
   try {
     ({
       stylelint,
-      api,
+      isPathIgnored,
       lintFiles,
       cleanup,
       threads
@@ -81,60 +65,68 @@ function linter(key, options, compilation) {
   } catch (e) {
     throw new StylelintError(e.message);
   }
-
   return {
+    stylelint,
     lint,
-    api,
+    isPathIgnored,
     report,
     threads
   };
+
   /**
    * @param {string | string[]} files
    */
-
   function lint(files) {
     for (const file of arrify(files)) {
       delete crossRunResultStorage[file];
     }
-
     rawResults.push(lintFiles(files).catch(e => {
       // @ts-ignore
       compilation.errors.push(new StylelintError(e.message));
       return [];
     }));
   }
-
   async function report() {
     // Filter out ignored files.
-    let results = removeIgnoredWarnings( // Get the current results, resetting the rawResults to empty
+    let results = removeIgnoredWarnings(
+    // Get the current results, resetting the rawResults to empty
     await flatten(rawResults.splice(0, rawResults.length)));
     await cleanup();
-
     for (const result of results) {
       crossRunResultStorage[String(result.source)] = result;
     }
+    results = Object.values(crossRunResultStorage);
 
-    results = Object.values(crossRunResultStorage); // do not analyze if there are no results or stylelint config
-
+    // do not analyze if there are no results or stylelint config
     if (!results || results.length < 1) {
       return {};
     }
-
     const formatter = loadFormatter(stylelint, options.formatter);
+
+    /** @type {LinterResult} */
+    const returnValue = {
+      // @ts-ignore
+      cwd: options.cwd,
+      errored: false,
+      results: [],
+      output: '',
+      reportedDisables: [],
+      ruleMetadata: getRuleMetadata(results)
+    };
     const {
       errors,
       warnings
-    } = formatResults(formatter, parseResults(options, results));
+    } = formatResults(formatter, parseResults(options, results), returnValue);
     return {
       errors,
       warnings,
       generateReportAsset
     };
+
     /**
      * @param {Compilation} compilation
      * @returns {Promise<void>}
      */
-
     async function generateReportAsset({
       compiler
     }) {
@@ -145,16 +137,14 @@ function linter(key, options, compilation) {
        * @param {string} name
        * @param {string | Buffer} content
        */
-
-      const save = (name, content) =>
-      /** @type {Promise<void>} */
+      const save = (name, content) => /** @type {Promise<void>} */
       new Promise((finish, bail) => {
         const {
           mkdir,
           writeFile
-        } = compiler.outputFileSystem; // ensure directory exists
+        } = compiler.outputFileSystem;
+        // ensure directory exists
         // @ts-ignore - the types for `outputFileSystem` are missing the 3 arg overload
-
         mkdir(dirname(name), {
           recursive: true
         }, err => {
@@ -165,74 +155,67 @@ function linter(key, options, compilation) {
           });
         });
       });
-
       if (!outputReport || !outputReport.filePath) {
         return;
       }
-
-      const content = outputReport.formatter ? loadFormatter(stylelint, outputReport.formatter)(results) : formatter(results);
+      const content = outputReport.formatter;
+      loadFormatter(stylelint, outputReport.formatter)(results, returnValue);
+      formatter(results, returnValue);
       let {
         filePath
       } = outputReport;
-
       if (!isAbsolute(filePath)) {
         filePath = join(compiler.outputPath, filePath);
       }
-
-      await save(filePath, content);
+      await save(filePath, String(content));
     }
   }
 }
+
 /**
- * @param {FormatterFunction} formatter
+ * @param {Formatter} formatter
  * @param {{ errors: LintResult[]; warnings: LintResult[]; }} results
+ * @param {LinterResult} returnValue
  * @returns {{errors?: StylelintError, warnings?: StylelintError}}
  */
-
-
-function formatResults(formatter, results) {
+function formatResults(formatter, results, returnValue) {
   let errors;
   let warnings;
-
   if (results.warnings.length > 0) {
-    warnings = new StylelintError(formatter(results.warnings));
+    warnings = new StylelintError(formatter(results.warnings, returnValue));
   }
-
   if (results.errors.length > 0) {
-    errors = new StylelintError(formatter(results.errors));
+    errors = new StylelintError(formatter(results.errors, returnValue));
   }
-
   return {
     errors,
     warnings
   };
 }
+
 /**
  * @param {Options} options
  * @param {LintResult[]} results
  * @returns {{errors: LintResult[], warnings: LintResult[]}}
  */
-
-
 function parseResults(options, results) {
   /** @type {LintResult[]} */
   const errors = [];
-  /** @type {LintResult[]} */
 
+  /** @type {LintResult[]} */
   const warnings = [];
   results.forEach(file => {
     const fileErrors = file.warnings.filter(message => options.emitError && message.severity === 'error');
-
     if (fileErrors.length > 0) {
-      errors.push({ ...file,
+      errors.push({
+        ...file,
         warnings: fileErrors
       });
     }
-
     const fileWarnings = file.warnings.filter(message => options.emitWarning && message.severity === 'warning');
-
     if (fileWarnings.length > 0) {
-      warnings.push({ ...file,
+      warnings.push({
+        ...file,
         warnings: fileWarnings
       });
     }
@@ -242,67 +225,75 @@ function parseResults(options, results) {
     warnings
   };
 }
+
 /**
  * @param {Stylelint} stylelint
  * @param {FormatterType=} formatter
- * @returns {FormatterFunction}
+ * @returns {Formatter}
  */
-
-
 function loadFormatter(stylelint, formatter) {
   if (typeof formatter === 'function') {
     return formatter;
   }
-
   if (typeof formatter === 'string') {
     try {
       return stylelint.formatters[formatter];
-    } catch (_) {// Load the default formatter.
+    } catch (_) {
+      // Load the default formatter.
     }
   }
-
   return stylelint.formatters.string;
 }
+
 /**
  * @param {LintResult[]} results
  * @returns {LintResult[]}
  */
-
-
 function removeIgnoredWarnings(results) {
   return results.filter(result => !result.ignored);
 }
+
 /**
  * @param {Promise<LintResult[]>[]} results
  * @returns {Promise<LintResult[]>}
  */
-
-
 async function flatten(results) {
   /**
    * @param {LintResult[]} acc
    * @param {LintResult[]} list
    */
   const flat = (acc, list) => [...acc, ...list];
-
   return (await Promise.all(results)).reduce(flat, []);
 }
+
 /**
  * @param {Compilation} compilation
  * @returns {LintResultMap}
  */
-
-
 function getResultStorage({
   compiler
 }) {
   let storage = resultStorage.get(compiler);
-
   if (!storage) {
     resultStorage.set(compiler, storage = {});
   }
-
   return storage;
 }
 
+/**
+ * @param {LintResult[]} lintResults
+ */
+/* istanbul ignore next */
+function getRuleMetadata(lintResults) {
+  const [lintResult] = lintResults;
+
+  // eslint-disable-next-line no-undefined
+  if (lintResult === undefined) return {};
+
+  // eslint-disable-next-line no-underscore-dangle, no-undefined
+  if (lintResult._postcssResult === undefined) return {};
+
+  // eslint-disable-next-line no-underscore-dangle
+  return lintResult._postcssResult.stylelint.ruleMetadata;
+}
 module.exports = linter;

package/dist/options.js

@@ -3,12 +3,10 @@
 const {
   validate
 } = require('schema-utils');
-
 const schema = require('./options.json');
-/** @typedef {import("stylelint")} stylelint */
 
+/** @typedef {import("stylelint")} stylelint */
 /** @typedef {import("stylelint").LinterOptions} StylelintOptions */
-
 /** @typedef {import("stylelint").FormatterType} FormatterType */
 
 /**
@@ -41,8 +39,6 @@ const schema = require('./options.json');
  * @param {Options} pluginOptions
  * @returns {Partial<PluginOptions>}
  */
-
-
 function getOptions(pluginOptions) {
   const options = {
     extensions: ['css', 'scss', 'sass'],
@@ -54,39 +50,40 @@ function getOptions(pluginOptions) {
       emitError: true,
       emitWarning: false
     } : {})
-  }; // @ts-ignore
+  };
 
+  // @ts-ignore
   validate(schema, options, {
     name: 'Stylelint Webpack Plugin',
     baseDataPath: 'options'
   });
   return options;
 }
+
 /**
  * @param {Options} pluginOptions
  * @returns {Partial<StylelintOptions>}
  */
-
-
 function getStylelintOptions(pluginOptions) {
-  const stylelintOptions = { ...pluginOptions
-  }; // Keep the files and formatter option because it is common to both the plugin and Stylelint.
+  const stylelintOptions = {
+    ...pluginOptions
+  };
 
+  // Keep the files and formatter option because it is common to both the plugin and Stylelint.
   const {
     files,
     formatter,
     ...stylelintOnlyOptions
-  } = schema.properties; // No need to guard the for-in because schema.properties has hardcoded keys.
-  // eslint-disable-next-line guard-for-in
+  } = schema.properties;
 
+  // No need to guard the for-in because schema.properties has hardcoded keys.
+  // eslint-disable-next-line guard-for-in
   for (const option in stylelintOnlyOptions) {
     // @ts-ignore
     delete stylelintOptions[option];
   }
-
   return stylelintOptions;
 }
-
 module.exports = {
   getOptions,
   getStylelintOptions

package/dist/options.json

@@ -31,7 +31,7 @@
       "type": "boolean"
     },
     "files": {
-      "description": "Specify directories, files, or globs. Must be relative to `options.context`. Directories are traveresed recursively looking for files matching `options.extensions`. File and glob patterns ignore `options.extensions`.",
+      "description": "Specify directories, files, or globs. Must be relative to `options.context`. Directories are traversed recursively looking for files matching `options.extensions`. File and glob patterns ignore `options.extensions`.",
       "anyOf": [{ "type": "string" }, { "type": "array" }]
     },
     "formatter": {

package/dist/utils.js

@@ -3,12 +3,11 @@
 const {
   resolve
 } = require('path');
-
 const {
   statSync
 } = require('fs');
-
 const normalizePath = require('normalize-path');
+
 /**
  * @template T
  * @param {T} value
@@ -24,85 +23,70 @@ const normalizePath = require('normalize-path');
            : [T]
  }
  */
-
 /* istanbul ignore next */
-
-
 function arrify(value) {
   // eslint-disable-next-line no-undefined
   if (value === null || value === undefined) {
     // @ts-ignore
     return [];
   }
-
   if (Array.isArray(value)) {
     // @ts-ignore
     return value;
   }
-
   if (typeof value === 'string') {
     // @ts-ignore
     return [value];
-  } // @ts-ignore
-
+  }
 
+  // @ts-ignore
   if (typeof value[Symbol.iterator] === 'function') {
     // @ts-ignore
     return [...value];
-  } // @ts-ignore
-
+  }
 
+  // @ts-ignore
   return [value];
 }
+
 /**
  * @param {string|string[]} files
  * @param {string} context
  * @returns {string[]}
  */
-
-
 function parseFiles(files, context) {
-  return arrify(files).map((
-  /** @type {string} */
-  file) => normalizePath(resolve(context, file)));
+  return arrify(files).map(( /** @type {string} */file) => normalizePath(resolve(context, file)));
 }
+
 /**
  * @param {string|string[]} patterns
  * @param {string|string[]} extensions
  * @returns {string[]}
  */
-
-
 function parseFoldersToGlobs(patterns, extensions = []) {
   const extensionsList = arrify(extensions);
   const [prefix, postfix] = extensionsList.length > 1 ? ['{', '}'] : ['', ''];
-  const extensionsGlob = extensionsList.map((
-  /** @type {string} */
-  extension) => extension.replace(/^\./u, '')).join(',');
-  return arrify(patterns).map((
-  /** @type {string} */
-  pattern) => {
+  const extensionsGlob = extensionsList.map(( /** @type {string} */extension) => extension.replace(/^\./u, '')).join(',');
+  return arrify(patterns).map(( /** @type {string} */pattern) => {
     try {
       // The patterns are absolute because they are prepended with the context.
       const stats = statSync(pattern);
       /* istanbul ignore else */
-
       if (stats.isDirectory()) {
         return pattern.replace(/[/\\]*?$/u, `/**${extensionsGlob ? `/*.${prefix + extensionsGlob + postfix}` : ''}`);
       }
-    } catch (_) {// Return the pattern as is on error.
+    } catch (_) {
+      // Return the pattern as is on error.
     }
-
     return pattern;
   });
 }
+
 /**
  *
  * @param {string} _ key, but unused
  * @param {any} value
  */
-
-
 const jsonStringifyReplacerSortKeys = (_, value) => {
   /**
    * @param {{ [x: string]: any; }} sorted
@@ -113,10 +97,8 @@ const jsonStringifyReplacerSortKeys = (_, value) => {
     sorted[key] = value[key];
     return sorted;
   };
-
   return value instanceof Object && !(value instanceof Array) ? Object.keys(value).sort().reduce(insert, {}) : value;
 };
-
 module.exports = {
   arrify,
   parseFiles,

package/dist/worker.js

@@ -1,42 +1,42 @@
 "use strict";
 
 /** @typedef {import('stylelint')} Stylelint */
-
 /** @typedef {import("stylelint").LinterOptions} StylelintOptions */
-
 /** @typedef {import('./options').Options} Options */
+
 Object.assign(module.exports, {
   lintFiles,
   setup
 });
-/** @type {Stylelint} */
 
+/** @type {Stylelint} */
 let stylelint;
-/** @type {Partial<StylelintOptions>} */
 
+/** @type {Partial<StylelintOptions>} */
 let linterOptions;
+
 /**
  * @param {Options} options
  * @param {Partial<StylelintOptions>} stylelintOptions
  */
-
 function setup(options, stylelintOptions) {
   stylelint = require(options.stylelintPath || 'stylelint');
   linterOptions = stylelintOptions;
   return stylelint;
 }
+
 /**
  * @param {string | string[]} files
  */
-
-
 async function lintFiles(files) {
   const {
     results
-  } = await stylelint.lint({ ...linterOptions,
+  } = await stylelint.lint({
+    ...linterOptions,
     files
-  }); // Reset result to work with worker
+  });
 
+  // Reset result to work with worker
   return results.map(result => {
     return {
       source: result.source,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "stylelint-webpack-plugin",
-  "version": "3.3.0",
+  "version": "4.0.0",
   "description": "A Stylelint plugin for webpack",
   "license": "MIT",
   "repository": "webpack-contrib/stylelint-webpack-plugin",
@@ -14,7 +14,7 @@
   "main": "dist/index.js",
   "types": "types/index.d.ts",
   "engines": {
-    "node": ">= 12.13.0"
+    "node": ">= 14.15.0"
   },
   "scripts": {
     "start": "npm run build -- -w",
@@ -27,6 +27,7 @@
     "security": "npm audit",
     "lint:prettier": "prettier -w --list-different .",
     "lint:js": "eslint --cache .",
+    "lint:spelling": "cspell \"**/*.*\"",
     "lint:types": "tsc --pretty --noEmit",
     "lint": "npm-run-all -l -p \"lint:**\"",
     "test:only": "cross-env NODE_ENV=test jest --testTimeout=60000",
@@ -46,44 +47,47 @@
     "webpack": "^5.0.0"
   },
   "dependencies": {
-    "jest-worker": "^28.1.0",
     "globby": "^11.1.0",
+    "jest-worker": "^29.4.1",
     "micromatch": "^4.0.5",
     "normalize-path": "^3.0.0",
     "schema-utils": "^4.0.0"
   },
   "devDependencies": {
-    "@babel/cli": "^7.17.10",
-    "@babel/core": "^7.18.0",
-    "@babel/preset-env": "^7.18.0",
-    "@commitlint/cli": "^16.2.3",
-    "@commitlint/config-conventional": "^16.2.1",
+    "@babel/cli": "^7.20.7",
+    "@babel/core": "^7.20.12",
+    "@babel/preset-env": "^7.20.2",
+    "@commitlint/cli": "^17.4.2",
+    "@commitlint/config-conventional": "^17.4.2",
+    "@types/file-entry-cache": "^5.0.2",
     "@types/fs-extra": "^9.0.13",
     "@types/micromatch": "^4.0.2",
+    "@types/node": "^18.11.18",
     "@types/normalize-path": "^3.0.0",
     "@types/webpack": "^5.28.0",
     "@webpack-contrib/eslint-config-webpack": "^3.0.0",
     "babel-eslint": "^10.1.0",
-    "babel-jest": "^28.1.0",
+    "babel-jest": "^29.4.1",
     "chokidar": "^3.5.3",
     "cross-env": "^7.0.3",
-    "del": "^6.1.0",
+    "cspell": "^6.20.1",
+    "del": "^6.1.1",
     "del-cli": "^4.0.1",
-    "eslint": "^8.15.0",
-    "eslint-config-prettier": "^8.5.0",
-    "eslint-plugin-import": "^2.26.0",
+    "eslint": "^8.33.0",
+    "eslint-config-prettier": "^8.6.0",
+    "eslint-plugin-import": "^2.27.5",
     "file-loader": "^6.2.0",
     "fs-extra": "^10.1.0",
-    "husky": "^7.0.4",
-    "jest": "^28.1.0",
-    "lint-staged": "^12.4.1",
+    "husky": "^8.0.3",
+    "jest": "^29.4.1",
+    "lint-staged": "^13.1.0",
     "npm-run-all": "^4.1.5",
-    "postcss-scss": "^4.0.4",
-    "prettier": "^2.6.2",
+    "postcss-scss": "^4.0.6",
+    "prettier": "^2.8.3",
     "standard-version": "^9.5.0",
-    "stylelint": "^14.8.2",
-    "typescript": "^4.6.2",
-    "webpack": "^5.72.1"
+    "stylelint": "^14.16.1",
+    "typescript": "^4.9.5",
+    "webpack": "^5.75.0"
   },
   "keywords": [
     "stylelint",

package/types/getStylelint.d.ts

@@ -14,6 +14,7 @@ declare namespace getStylelint {
     Stylelint,
     LintResult,
     Options,
+    isPathIgnored,
     AsyncTask,
     LintTask,
     Linter,
@@ -22,8 +23,8 @@ declare namespace getStylelint {
 }
 type Options = import('./options').Options;
 type Linter = {
-  api: import('stylelint').InternalApi;
   stylelint: Stylelint;
+  isPathIgnored: isPathIgnored;
   lintFiles: LintTask;
   cleanup: AsyncTask;
   threads: number;
@@ -42,7 +43,7 @@ type Stylelint = import('postcss').PluginCreator<
   };
   createPlugin: (
     ruleName: string,
-    plugin: import('stylelint').Plugin<any, any>
+    rule: import('stylelint').Rule<any, any>
   ) => {
     ruleName: string;
     rule: import('stylelint').Rule<any, any>;
@@ -78,12 +79,21 @@ type Stylelint = import('postcss').PluginCreator<
         ruleName: string;
         ruleSettings: import('stylelint').ConfigRuleSettings<T_1, O>;
         root: import('postcss').Root;
+        result?: import('stylelint').PostcssResult | undefined;
+        context?: import('stylelint').RuleContext | undefined;
       },
       callback: (warning: import('postcss').Warning) => void
     ) => void;
   };
+  reference: {
+    longhandSubPropertiesOfShorthandProperties: import('stylelint').LonghandSubPropertiesOfShorthandProperties;
+  };
 };
 type LintResult = import('stylelint').LintResult;
+type isPathIgnored = (
+  stylelint: Stylelint,
+  filePath: string
+) => Promise<boolean>;
 type AsyncTask = () => Promise<void>;
 type LintTask = (files: string | string[]) => Promise<LintResult[]>;
 type Worker = JestWorker & {

package/types/linter.d.ts

@@ -4,14 +4,15 @@ export = linter;
  * @param {string|undefined} key
  * @param {Options} options
  * @param {Compilation} compilation
- * @returns {{api: InternalApi, lint: Linter, report: Reporter, threads: number}}
+ * @returns {{stylelint: Stylelint, isPathIgnored: isPathIgnored, lint: Linter, report: Reporter, threads: number}}
  */
 declare function linter(
   key: string | undefined,
   options: Options,
   compilation: Compilation
 ): {
-  api: InternalApi;
+  stylelint: Stylelint;
+  isPathIgnored: getStylelint.isPathIgnored;
   lint: Linter;
   report: Reporter;
   threads: number;
@@ -20,12 +21,13 @@ declare namespace linter {
   export {
     Stylelint,
     LintResult,
-    InternalApi,
+    LinterResult,
+    Formatter,
+    FormatterType,
     Compiler,
     Compilation,
     Options,
-    FormatterType,
-    FormatterFunction,
+    isPathIgnored,
     GenerateReport,
     Report,
     Reporter,
@@ -35,9 +37,6 @@ declare namespace linter {
 }
 type Options = import('./options').Options;
 type Compilation = import('webpack').Compilation;
-type InternalApi = import('stylelint').InternalApi;
-type Linter = (files: string | string[]) => void;
-type Reporter = () => Promise<Report>;
 type Stylelint = import('postcss').PluginCreator<
   import('stylelint').PostcssPluginOptions
 > & {
@@ -52,7 +51,7 @@ type Stylelint = import('postcss').PluginCreator<
   };
   createPlugin: (
     ruleName: string,
-    plugin: import('stylelint').Plugin<any, any>
+    rule: import('stylelint').Rule<any, any>
   ) => {
     ruleName: string;
     rule: import('stylelint').Rule<any, any>;
@@ -88,15 +87,25 @@ type Stylelint = import('postcss').PluginCreator<
         ruleName: string;
         ruleSettings: import('stylelint').ConfigRuleSettings<T_1, O>;
         root: import('postcss').Root;
+        result?: import('stylelint').PostcssResult | undefined;
+        context?: import('stylelint').RuleContext | undefined;
       },
       callback: (warning: import('postcss').Warning) => void
     ) => void;
   };
+  reference: {
+    longhandSubPropertiesOfShorthandProperties: import('stylelint').LonghandSubPropertiesOfShorthandProperties;
+  };
 };
+type Linter = (files: string | string[]) => void;
+type Reporter = () => Promise<Report>;
+import getStylelint = require('./getStylelint');
 type LintResult = import('stylelint').LintResult;
+type LinterResult = import('stylelint').LinterResult;
+type Formatter = import('stylelint').Formatter;
+type FormatterType = import('stylelint').FormatterType;
 type Compiler = import('webpack').Compiler;
-type FormatterType = import('./options').FormatterType;
-type FormatterFunction = (results: LintResult[]) => string;
+type isPathIgnored = import('./getStylelint').isPathIgnored;
 type GenerateReport = (compilation: Compilation) => Promise<void>;
 type Report = {
   errors?: StylelintError;

package/types/options.d.ts

@@ -13,7 +13,7 @@ export type stylelint = import('postcss').PluginCreator<
   };
   createPlugin: (
     ruleName: string,
-    plugin: import('stylelint').Plugin<any, any>
+    rule: import('stylelint').Rule<any, any>
   ) => {
     ruleName: string;
     rule: import('stylelint').Rule<any, any>;
@@ -49,10 +49,15 @@ export type stylelint = import('postcss').PluginCreator<
         ruleName: string;
         ruleSettings: import('stylelint').ConfigRuleSettings<T_1, O>;
         root: import('postcss').Root;
+        result?: import('stylelint').PostcssResult | undefined;
+        context?: import('stylelint').RuleContext | undefined;
       },
       callback: (warning: import('postcss').Warning) => void
     ) => void;
   };
+  reference: {
+    longhandSubPropertiesOfShorthandProperties: import('stylelint').LonghandSubPropertiesOfShorthandProperties;
+  };
 };
 export type StylelintOptions = import('stylelint').LinterOptions;
 export type FormatterType = import('stylelint').FormatterType;

package/types/worker.d.ts

@@ -13,7 +13,7 @@ export type Stylelint = import('postcss').PluginCreator<
   };
   createPlugin: (
     ruleName: string,
-    plugin: import('stylelint').Plugin<any, any>
+    rule: import('stylelint').Rule<any, any>
   ) => {
     ruleName: string;
     rule: import('stylelint').Rule<any, any>;
@@ -49,10 +49,15 @@ export type Stylelint = import('postcss').PluginCreator<
         ruleName: string;
         ruleSettings: import('stylelint').ConfigRuleSettings<T_1, O>;
         root: import('postcss').Root;
+        result?: import('stylelint').PostcssResult | undefined;
+        context?: import('stylelint').RuleContext | undefined;
       },
       callback: (warning: import('postcss').Warning) => void
     ) => void;
   };
+  reference: {
+    longhandSubPropertiesOfShorthandProperties: import('stylelint').LonghandSubPropertiesOfShorthandProperties;
+  };
 };
 export type StylelintOptions = import('stylelint').LinterOptions;
 export type Options = import('./options').Options;