stylelint-webpack-plugin 3.0.1 → 3.2.0

package/README.md

@@ -13,22 +13,50 @@
 
 # stylelint-webpack-plugin
 
+> This is stylelint-webpack-plugin 3.0 which works only with webpack 5. For the webpack 4, see the [2.x branch](https://github.com/webpack-contrib/stylelint-webpack-plugin/tree/2.x).
+
 This plugin uses [`stylelint`](https://stylelint.io/) that helps you avoid errors and enforce conventions in your styles.
 
 ## Getting Started
 
 To begin, you'll need to install `stylelint-webpack-plugin`:
 
-```bash
+```console
 npm install stylelint-webpack-plugin --save-dev
 ```
 
+or
+
+```console
+yarn add -D install stylelint-webpack-plugin
+```
+
+or
+
+```console
+pnpm add -D stylelint-webpack-plugin
+```
+
 **Note**: You also need to install `stylelint >= 13` from npm, if you haven't already:
 
-```bash
+```console
 npm install stylelint --save-dev
 ```
 
+or
+
+```console
+yarn add -D stylelint
+```
+
+or
+
+```console
+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.
+
 Then add the plugin to your webpack config. For example:
 
 ```js
@@ -43,76 +71,128 @@ module.exports = {
 
 ## Options
 
-See [stylelint's options](http://stylelint.io/user-guide/node-api/#options) for the complete list of options available. These options are passed through to the `stylelint` directly.
+See [stylelint's options](https://stylelint.io/user-guide/usage/node-api#options) for the complete list of options available. These options are passed through to the `stylelint` directly.
 
 ### `configFile`
 
-- Type: `String`
+- Type:
+
+```ts
+type context = string;
+```
+
 - Default: `undefined`
 
 Specify the config file location to be used by `stylelint`.
 
-**Note:** By default this is [handled by `stylelint`](http://stylelint.io/user-guide/configuration/).
+**Note:** By default this is [handled by `stylelint`](https://stylelint.io/user-guide/configure).
 
 ### `context`
 
-- Type: `String`
+- Type:
+
+```ts
+type context = string;
+```
+
 - Default: `compiler.context`
 
 A string indicating the root of your files.
 
 ### `exclude`
 
-- Type: `String|Array[String]`
+- Type:
+
+```ts
+type exclude = string | Array<string>;
+```
+
 - Default: `['node_modules', compiler.options.output.path]`
 
 Specify the files and/or directories to exclude. Must be relative to `options.context`.
 
 ### `extensions`
 
-- Type: `String|Array[String]`
+- Type:
+
+```ts
+type extensions = string | Array<string>;
+```
+
 - Default: `['css', 'scss', 'sass']`
 
 Specify extensions that should be checked.
 
 ### `files`
 
-- Type: `String|Array[String]`
+- Type:
+
+```ts
+type files = string | Array<string>;
+```
+
 - Default: `null`
 
-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`.
+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`.
 
 ### `fix`
 
-- Type: `Boolean`
+- Type:
+
+```ts
+type fix = boolean;
+```
+
 - Default: `false`
 
-If `true`, `stylelint` will fix as many errors as possible. The fixes are made to the actual source files. All unfixed errors will be reported. See [Autofixing errors](https://stylelint.io/user-guide/cli#autofixing-errors) docs.
+If `true`, `stylelint` will fix as many errors as possible. The fixes are made to the actual source files. All unfixed errors will be reported. See [Autofixing errors](https://stylelint.io/user-guide/usage/options#fix) docs.
 
 ### `formatter`
 
-- Type: `String|Function`
+- Type:
+
+```ts
+type formatter = string | (
+  results: Array<import('stylelint').LintResult>
+) => string
+```
+
 - Default: `'string'`
 
-Specify the formatter that you would like to use to format your results. See [formatter option](https://stylelint.io/user-guide/node-api#formatter).
+Specify the formatter that you would like to use to format your results. See [formatter option](https://stylelint.io/user-guide/usage/options#formatter).
 
 ### `lintDirtyModulesOnly`
 
-- Type: `Boolean`
+- Type:
+
+```ts
+type lintDirtyModulesOnly = boolean;
+```
+
 - Default: `false`
 
 Lint only changed files, skip lint on start.
 
 ### `stylelintPath`
 
-- Type: `String`
+- Type:
+
+```ts
+type stylelintPath = string;
+```
+
 - Default: `stylelint`
 
 Path to `stylelint` instance that will be used for linting.
 
 ### `threads`
 
-- Type: `Boolean | Number`
+- Type:
+
+```ts
+type threads = boolean | number;
+```
+
 - Default: `false`
 
 Set to true for an auto-selected pool size based on number of cpus. Set to a number greater than 1 to set an explicit pool size. Set to false, 1, or less to disable and only run in main process.
@@ -124,42 +204,82 @@ You can still force this behavior by using `emitError` **or** `emitWarning` opti
 
 #### `emitError`
 
-- Type: `Boolean`
-- Default: `false`
+- Type:
+
+```ts
+type emitError = boolean;
+```
+
+- Default: `true`
 
 The errors found will always be emitted, to disable set to `false`.
 
 #### `emitWarning`
 
-- Type: `Boolean`
-- Default: `false`
+- Type:
+
+```ts
+type emitWarning = boolean;
+```
+
+- Default: `true`
 
 The warnings found will always be emitted, to disable set to `false`.
 
 #### `failOnError`
 
-- Type: `Boolean`
-- Default: `false`
+- Type:
+
+```ts
+type failOnError = boolean;
+```
+
+- Default: `true`
 
 Will cause the module build to fail if there are any errors, to disable set to `false`.
 
 #### `failOnWarning`
 
-- Type: `Boolean`
+- Type:
+
+```ts
+type failOnWarning = boolean;
+```
+
 - Default: `false`
 
 Will cause the module build to fail if there are any warnings, if set to `true`.
 
 #### `quiet`
 
-- Type: `Boolean`
+- Type:
+
+```ts
+type quiet = boolean;
+```
+
 - Default: `false`
 
 Will process and report errors only and ignore warnings, if set to `true`.
 
 #### `outputReport`
 
-- Type: `Boolean|Object`
+- Type:
+
+```ts
+type outputReport =
+  | boolean
+  | {
+      filePath?: string | undefined;
+      formatter?:
+        | (
+            | string
+            | ((results: Array<import('stylelint').LintResult>) => string)
+          )
+        | undefined;
+    };
+```
+
 - Default: `false`
 
 Write the output of the errors to a file, for example a `json` file for use for reporting.

package/dist/StylelintError.js

@@ -1,10 +1,5 @@
 "use strict";
 
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-
 class StylelintError extends Error {
   /**
    * @param {string=} messages
@@ -17,5 +12,4 @@ class StylelintError extends Error {
 
 }
 
-var _default = StylelintError;
-exports.default = _default;
+module.exports = StylelintError;

package/dist/getStylelint.js

@@ -1,23 +1,29 @@
 "use strict";
 
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = getStylelint;
+const {
+  cpus
+} = require('os');
 
-var _os = require("os");
+const {
+  Worker: JestWorker
+} = require('jest-worker'); // @ts-ignore
 
-var _jestWorker = require("jest-worker");
 
-var _worker = require("./worker");
+const {
+  setup,
+  lintFiles
+} = require('./worker');
 
-var _utils = require("./utils");
+const {
+  jsonStringifyReplacerSortKeys
+} = require('./utils');
 
-var _options = require("./options");
+const {
+  getStylelintOptions
+} = require('./options');
+/** @type {{[key: string]: any}} */
 
-// @ts-ignore
 
-/** @type {{[key: string]: any}} */
 const cache = {};
 /** @typedef {import('stylelint')} Stylelint */
 
@@ -29,9 +35,9 @@ const cache = {};
 
 /** @typedef {(files: string|string[]) => Promise<LintResult[]>} LintTask */
 
-/** @typedef {JestWorker & {lintFiles: LintTask}} Worker */
+/** @typedef {{api: import('stylelint').InternalApi, stylelint: Stylelint, lintFiles: LintTask, cleanup: AsyncTask, threads: number, }} Linter */
 
-/** @typedef {{stylelint: Stylelint, lintFiles: LintTask, cleanup: AsyncTask, threads: number, }} Linter */
+/** @typedef {import('jest-worker').Worker & {lintFiles: LintTask}} Worker */
 
 /**
  * @param {Options} options
@@ -39,10 +45,12 @@ const cache = {};
  */
 
 function loadStylelint(options) {
-  const stylelint = (0, _worker.setup)(options, (0, _options.getStylelintOptions)(options));
+  const stylelintOptions = getStylelintOptions(options);
+  const stylelint = setup(options, stylelintOptions);
   return {
     stylelint,
-    lintFiles: _worker.lintFiles,
+    api: stylelint.createLinter(stylelintOptions),
+    lintFiles,
     cleanup: async () => {},
     threads: 1
   };
@@ -63,15 +71,12 @@ function loadStylelintThreaded(key, poolSize, options) {
   const workerOptions = {
     enableWorkerThreads: true,
     numWorkers: poolSize,
-    setupArgs: [options, (0, _options.getStylelintOptions)(options)]
+    setupArgs: [options, getStylelintOptions(options)]
   };
   const local = loadStylelint(options);
-  /** @type {Worker?} */
-  // prettier-ignore
-
   let worker =
-  /** @type {Worker} */
-  new _jestWorker.Worker(source, workerOptions);
+  /** @type {Worker?} */
+  new JestWorker(source, workerOptions);
   /** @type {Linter} */
 
   const context = { ...local,
@@ -105,7 +110,7 @@ function getStylelint(key, {
   threads,
   ...options
 }) {
-  const max = typeof threads !== 'number' ? threads ? (0, _os.cpus)().length - 1 : 1 : threads;
+  const max = typeof threads !== 'number' ? threads ? cpus().length - 1 : 1 : threads;
   const cacheKey = getCacheKey(key, {
     threads,
     ...options
@@ -128,5 +133,7 @@ function getCacheKey(key, options) {
   return JSON.stringify({
     key,
     options
-  }, _utils.jsonStringifyReplacerSortKeys);
-}
+  }, jsonStringifyReplacerSortKeys);
+}
+
+module.exports = getStylelint;

package/dist/index.js

@@ -1,26 +1,27 @@
 "use strict";
 
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
+const {
+  isAbsolute,
+  join
+} = require('path');
 
-var _path = require("path");
+const globby = require('globby');
 
-var _globby = _interopRequireDefault(require("globby"));
+const {
+  isMatch
+} = require('micromatch');
 
-var _micromatch = require("micromatch");
+const {
+  getOptions
+} = require('./options');
 
-var _options = require("./options");
-
-var _linter = _interopRequireDefault(require("./linter"));
-
-var _utils = require("./utils");
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-// @ts-ignore
+const linter = require('./linter');
 
+const {
+  arrify,
+  parseFiles,
+  parseFoldersToGlobs
+} = require('./utils');
 /** @typedef {import('webpack').Compiler} Compiler */
 
 /** @typedef {import('webpack').Module} Module */
@@ -28,6 +29,8 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de
 /** @typedef {import('./options').Options} Options */
 
 /** @typedef {Partial<{timestamp:number} | number>} FileSystemInfoEntry */
+
+
 const STYLELINT_PLUGIN = 'StylelintWebpackPlugin';
 let counter = 0;
 
@@ -37,7 +40,7 @@ class StylelintWebpackPlugin {
    */
   constructor(options = {}) {
     this.key = STYLELINT_PLUGIN;
-    this.options = (0, _options.getOptions)(options);
+    this.options = getOptions(options);
     this.run = this.run.bind(this);
     this.startTime = Date.now();
     this.prevTimestamps = new Map();
@@ -87,15 +90,18 @@ class StylelintWebpackPlugin {
     const context = this.getContext(compiler);
     const excludeDefault = ['**/node_modules/**', String(compiler.options.output.path)];
     const options = { ...this.options,
-      exclude: (0, _utils.parseFiles)(this.options.exclude || excludeDefault, context),
-      extensions: (0, _utils.arrify)(this.options.extensions),
-      files: (0, _utils.parseFiles)(this.options.files || '', context)
+      exclude: parseFiles(this.options.exclude || excludeDefault, context),
+      extensions: arrify(this.options.extensions),
+      files: parseFiles(this.options.files || '', context)
     };
-    const wanted = (0, _utils.parseFoldersToGlobs)(options.files, options.extensions);
-    const exclude = (0, _utils.parseFoldersToGlobs)(options.exclude);
+    const wanted = parseFoldersToGlobs(options.files, options.extensions);
+    const exclude = parseFoldersToGlobs(options.exclude);
     compiler.hooks.thisCompilation.tap(this.key, compilation => {
       /** @type {import('./linter').Linter} */
       let lint;
+      /** @type {import('stylelint').InternalApi} */
+
+      let api;
       /** @type {import('./linter').Reporter} */
 
       let report;
@@ -106,30 +112,39 @@ class StylelintWebpackPlugin {
       try {
         ({
           lint,
+          api,
           report,
           threads
-        } = (0, _linter.default)(this.key, options, compilation));
+        } = linter(this.key, options, compilation));
       } catch (e) {
         compilation.errors.push(e);
         return;
       }
 
-      compilation.hooks.finishModules.tap(this.key, () => {
-        const files = compiler.modifiedFiles ? Array.from(compiler.modifiedFiles).filter(file => (0, _micromatch.isMatch)(file, wanted, {
+      compilation.hooks.finishModules.tapPromise(this.key, async () => {
+        /** @type {string[]} */
+        // @ts-ignore
+        const files = (await Promise.all((compiler.modifiedFiles ? Array.from(compiler.modifiedFiles).filter(file => isMatch(file, wanted, {
           dot: true
-        }) && !(0, _micromatch.isMatch)(file, exclude, {
+        }) && !isMatch(file, exclude, {
           dot: true
-        })) : _globby.default.sync(wanted, {
+        })) : globby.sync(wanted, {
           dot: true,
           ignore: exclude
-        });
+        })).map(async file => {
+          try {
+            return (await api.isPathIgnored(file)) ? false : file;
+          } catch (e) {
+            return file;
+          }
+        }))).filter(file => file !== false);
 
         if (threads > 1) {
           for (const file of files) {
-            lint((0, _utils.parseFiles)(file, context));
+            lint(parseFiles(file, context));
           }
         } else if (files.length > 0) {
-          lint((0, _utils.parseFiles)(files, context));
+          lint(parseFiles(files, context));
         }
       }); // await and interpret results
 
@@ -176,8 +191,8 @@ class StylelintWebpackPlugin {
       return String(compiler.options.context);
     }
 
-    if (!(0, _path.isAbsolute)(this.options.context)) {
-      return (0, _path.join)(String(compiler.options.context), this.options.context);
+    if (!isAbsolute(this.options.context)) {
+      return join(String(compiler.options.context), this.options.context);
     }
 
     return this.options.context;
@@ -185,5 +200,4 @@ class StylelintWebpackPlugin {
 
 }
 
-var _default = StylelintWebpackPlugin;
-exports.default = _default;
+module.exports = StylelintWebpackPlugin;

package/dist/linter.js

@@ -1,24 +1,24 @@
 "use strict";
 
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = linter;
+const {
+  dirname,
+  isAbsolute,
+  join
+} = require('path');
 
-var _path = require("path");
+const StylelintError = require('./StylelintError');
 
-var _StylelintError = _interopRequireDefault(require("./StylelintError"));
-
-var _getStylelint = _interopRequireDefault(require("./getStylelint"));
-
-var _utils = require("./utils");
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const getStylelint = require('./getStylelint');
 
+const {
+  arrify
+} = require('./utils');
 /** @typedef {import('stylelint')} Stylelint */
 
 /** @typedef {import('stylelint').LintResult} LintResult */
 
+/** @typedef {import('stylelint').InternalApi} InternalApi */
+
 /** @typedef {import('webpack').Compiler} Compiler */
 
 /** @typedef {import('webpack').Compilation} Compilation */
@@ -40,17 +40,22 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de
 /** @typedef {{[files: string]: LintResult}} LintResultMap */
 
 /** @type {WeakMap<Compiler, LintResultMap>} */
+
+
 const resultStorage = new WeakMap();
 /**
  * @param {string|undefined} key
  * @param {Options} options
  * @param {Compilation} compilation
- * @returns {{lint: Linter, report: Reporter, threads: number}}
+ * @returns {{api: InternalApi, 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[]>} */
 
   let lintFiles;
@@ -68,16 +73,18 @@ function linter(key, options, compilation) {
   try {
     ({
       stylelint,
+      api,
       lintFiles,
       cleanup,
       threads
-    } = (0, _getStylelint.default)(key, options));
+    } = getStylelint(key, options));
   } catch (e) {
-    throw new _StylelintError.default(e.message);
+    throw new StylelintError(e.message);
   }
 
   return {
     lint,
+    api,
     report,
     threads
   };
@@ -86,7 +93,7 @@ function linter(key, options, compilation) {
    */
 
   function lint(files) {
-    for (const file of (0, _utils.arrify)(files)) {
+    for (const file of arrify(files)) {
       delete crossRunResultStorage[file];
     }
 
@@ -103,7 +110,7 @@ function linter(key, options, compilation) {
     await cleanup();
 
     for (const result of results) {
-      crossRunResultStorage[result.source] = result;
+      crossRunResultStorage[String(result.source)] = result;
     }
 
     results = Object.values(crossRunResultStorage); // do not analyze if there are no results or stylelint config
@@ -147,7 +154,7 @@ function linter(key, options, compilation) {
         } = compiler.outputFileSystem; // ensure directory exists
         // @ts-ignore - the types for `outputFileSystem` are missing the 3 arg overload
 
-        mkdir((0, _path.dirname)(name), {
+        mkdir(dirname(name), {
           recursive: true
         }, err => {
           /* istanbul ignore if */
@@ -167,8 +174,8 @@ function linter(key, options, compilation) {
         filePath
       } = outputReport;
 
-      if (!(0, _path.isAbsolute)(filePath)) {
-        filePath = (0, _path.join)(compiler.outputPath, filePath);
+      if (!isAbsolute(filePath)) {
+        filePath = join(compiler.outputPath, filePath);
       }
 
       await save(filePath, content);
@@ -187,11 +194,11 @@ function formatResults(formatter, results) {
   let warnings;
 
   if (results.warnings.length > 0) {
-    warnings = new _StylelintError.default(formatter(results.warnings));
+    warnings = new StylelintError(formatter(results.warnings));
   }
 
   if (results.errors.length > 0) {
-    errors = new _StylelintError.default(formatter(results.errors));
+    errors = new StylelintError(formatter(results.errors));
   }
 
   return {
@@ -295,4 +302,6 @@ function getResultStorage({
   }
 
   return storage;
-}
+}
+
+module.exports = linter;