stylelint-webpack-plugin 2.3.2 → 2.4.0

package/dist/index.js

@@ -1,29 +1,28 @@
 "use strict";
 
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
+const {
+  isAbsolute,
+  join
+} = require('path');
 
-var _path = require("path");
+const arrify = require('arrify');
 
-var _arrify = _interopRequireDefault(require("arrify"));
+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
-// @ts-ignore
+const linter = require('./linter');
 
+const {
+  parseFiles,
+  parseFoldersToGlobs
+} = require('./utils');
 /** @typedef {import('webpack').Compiler} Compiler */
 
 /** @typedef {import('webpack').Module} Module */
@@ -31,36 +30,48 @@ 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;
 
 class StylelintWebpackPlugin {
-  /**
-   * @param {Options} options
+  /**
+   * @param {Options} options
    */
   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();
     /** @type {ReadonlyMap<string, null | FileSystemInfoEntry | "ignore" | undefined>} */
 
     this.prevTimestamps = new Map();
   }
-  /**
-   * @param {Compiler} compiler
-   * @returns {void}
+  /**
+   * @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}`; // If `lintDirtyModulesOnly` is disabled,
+    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,
+      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
 
     if (!this.options.lintDirtyModulesOnly) {
-      compiler.hooks.run.tapPromise(this.key, this.run);
+      compiler.hooks.run.tapPromise(this.key, c => this.run(c, options, wanted, exclude));
     }
 
     let isFirstRun = this.options.lintDirtyModulesOnly;
@@ -70,15 +81,18 @@ class StylelintWebpackPlugin {
         return Promise.resolve();
       }
 
-      return this.run(c);
+      return this.run(c, options, wanted, exclude);
     });
   }
-  /**
-   * @param {Compiler} compiler
+  /**
+   * @param {Compiler} compiler
+   * @param {Options} options
+   * @param {string[]} wanted
+   * @param {string[]} exclude
    */
 
 
-  async run(compiler) {
+  async run(compiler, options, wanted, exclude) {
     // Do not re-hook
 
     /* istanbul ignore if */
@@ -89,17 +103,12 @@ class StylelintWebpackPlugin {
       return;
     }
 
-    const context = this.getContext(compiler);
-    const options = { ...this.options,
-      exclude: (0, _utils.parseFiles)(this.options.exclude || ['**/node_modules/**', compiler.options.output.path], context),
-      extensions: (0, _arrify.default)(this.options.extensions),
-      files: (0, _utils.parseFiles)(this.options.files || '', context)
-    };
-    const wanted = (0, _utils.parseFoldersToGlobs)(options.files, options.extensions);
-    const exclude = (0, _utils.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;
@@ -110,23 +119,34 @@ 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 = this.getFiles(compiler, wanted, exclude);
+      compilation.hooks.finishModules.tapPromise(this.key, async () => {
+        /** @type {string[]} */
+        // @ts-ignore
+        const files = (await Promise.all(this.getFiles(compiler, wanted, exclude).map(async (
+        /** @type {string | undefined} */
+        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, options.context || ''));
           }
         } else if (files.length > 0) {
-          lint((0, _utils.parseFiles)(files, context));
+          lint(parseFiles(files, options.context || ''));
         }
       }); // await and interpret results
 
@@ -161,10 +181,10 @@ class StylelintWebpackPlugin {
       }
     });
   }
-  /**
-   *
-   * @param {Compiler} compiler
-   * @returns {string}
+  /**
+   *
+   * @param {Compiler} compiler
+   * @returns {string}
    */
 
 
@@ -173,17 +193,17 @@ 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;
   }
-  /**
-   * @param {Compiler} compiler
-   * @param {string[]} wanted
-   * @param {string[]} exclude
-   * @returns {string[]}
+  /**
+   * @param {Compiler} compiler
+   * @param {string[]} wanted
+   * @param {string[]} exclude
+   * @returns {string[]}
    */
   // eslint-disable-next-line no-unused-vars
 
@@ -191,9 +211,9 @@ class StylelintWebpackPlugin {
   getFiles(compiler, wanted, exclude) {
     // webpack 5
     if (compiler.modifiedFiles) {
-      return Array.from(compiler.modifiedFiles).filter(file => (0, _micromatch.isMatch)(file, wanted, {
+      return Array.from(compiler.modifiedFiles).filter(file => isMatch(file, wanted, {
         dot: true
-      }) && !(0, _micromatch.isMatch)(file, exclude, {
+      }) && !isMatch(file, exclude, {
         dot: true
       }));
     } // webpack 4
@@ -202,30 +222,30 @@ class StylelintWebpackPlugin {
 
 
     if (compiler.fileTimestamps && compiler.fileTimestamps.size > 0) {
-      return this.getChangedFiles(compiler.fileTimestamps).filter(file => (0, _micromatch.isMatch)(file, wanted, {
+      return this.getChangedFiles(compiler.fileTimestamps).filter(file => isMatch(file, wanted, {
         dot: true
-      }) && !(0, _micromatch.isMatch)(file, exclude, {
+      }) && !isMatch(file, exclude, {
         dot: true
       }));
     }
 
-    return _globby.default.sync(wanted, {
+    return globby.sync(wanted, {
       dot: true,
       ignore: exclude
     });
   }
-  /**
-   * @param {ReadonlyMap<string, null | FileSystemInfoEntry | "ignore" | undefined>} fileTimestamps
-   * @returns {string[]}
+  /**
+   * @param {ReadonlyMap<string, null | FileSystemInfoEntry | "ignore" | undefined>} fileTimestamps
+   * @returns {string[]}
    */
 
   /* istanbul ignore next */
 
 
   getChangedFiles(fileTimestamps) {
-    /**
-     * @param {null | FileSystemInfoEntry | "ignore" | undefined} fileSystemInfoEntry
-     * @returns {Partial<number>}
+    /**
+     * @param {null | FileSystemInfoEntry | "ignore" | undefined} fileSystemInfoEntry
+     * @returns {Partial<number>}
      */
     const getTimestamps = fileSystemInfoEntry => {
       // @ts-ignore
@@ -237,10 +257,10 @@ class StylelintWebpackPlugin {
 
       return fileSystemInfoEntry;
     };
-    /**
-     * @param {string} filename
-     * @param {null | FileSystemInfoEntry | "ignore" | undefined} fileSystemInfoEntry
-     * @returns {boolean}
+    /**
+     * @param {string} filename
+     * @param {null | FileSystemInfoEntry | "ignore" | undefined} fileSystemInfoEntry
+     * @returns {boolean}
      */
 
 
@@ -264,5 +284,4 @@ class StylelintWebpackPlugin {
 
 }
 
-var _default = StylelintWebpackPlugin;
-exports.default = _default;
+module.exports = StylelintWebpackPlugin;

package/dist/linter.js

@@ -1,26 +1,22 @@
 "use strict";
 
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = linter;
+const {
+  dirname,
+  isAbsolute,
+  join
+} = require('path');
 
-var _path = require("path");
+const arrify = require('arrify');
 
-var _arrify = _interopRequireDefault(require("arrify"));
-
-var _StylelintError = _interopRequireDefault(require("./StylelintError"));
-
-var _getStylelint = _interopRequireDefault(require("./getStylelint"));
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-// @ts-ignore
+const StylelintError = require('./StylelintError');
 
+const getStylelint = require('./getStylelint');
 /** @typedef {import('stylelint')} Stylelint */
 
 /** @typedef {import('stylelint').LintResult} LintResult */
 
+/** @typedef {import('stylelint').InternalApi} InternalApi */
+
 /** @typedef {import('webpack').Compiler} Compiler */
 
 /** @typedef {import('webpack').Compilation} Compilation */
@@ -42,17 +38,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}}
+/**
+ * @param {string|undefined} key
+ * @param {Options} options
+ * @param {Compilation} compilation
+ * @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;
@@ -70,30 +71,33 @@ 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
   };
-  /**
-   * @param {string | string[]} files
+  /**
+   * @param {string | string[]} files
    */
 
   function lint(files) {
-    for (const file of (0, _arrify.default)(files)) {
+    for (const file of arrify(files)) {
       delete crossRunResultStorage[file];
     }
 
     rawResults.push(lintFiles(files).catch(e => {
-      compilation.errors.push(e);
+      // @ts-ignore
+      compilation.errors.push(new StylelintError(e.message));
       return [];
     }));
   }
@@ -124,9 +128,9 @@ function linter(key, options, compilation) {
       warnings,
       generateReportAsset
     };
-    /**
-     * @param {Compilation} compilation
-     * @returns {Promise<void>}
+    /**
+     * @param {Compilation} compilation
+     * @returns {Promise<void>}
      */
 
     async function generateReportAsset({
@@ -135,9 +139,9 @@ function linter(key, options, compilation) {
       const {
         outputReport
       } = options;
-      /**
-       * @param {string} name
-       * @param {string | Buffer} content
+      /**
+       * @param {string} name
+       * @param {string | Buffer} content
        */
 
       const save = (name, content) =>
@@ -149,7 +153,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 */
@@ -169,18 +173,18 @@ 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);
     }
   }
 }
-/**
- * @param {FormatterFunction} formatter
- * @param {{ errors: LintResult[]; warnings: LintResult[]; }} results
- * @returns {{errors?: StylelintError, warnings?: StylelintError}}
+/**
+ * @param {FormatterFunction} formatter
+ * @param {{ errors: LintResult[]; warnings: LintResult[]; }} results
+ * @returns {{errors?: StylelintError, warnings?: StylelintError}}
  */
 
 
@@ -189,11 +193,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 {
@@ -201,10 +205,10 @@ function formatResults(formatter, results) {
     warnings
   };
 }
-/**
- * @param {Options} options
- * @param {LintResult[]} results
- * @returns {{errors: LintResult[], warnings: LintResult[]}}
+/**
+ * @param {Options} options
+ * @param {LintResult[]} results
+ * @returns {{errors: LintResult[], warnings: LintResult[]}}
  */
 
 
@@ -236,10 +240,10 @@ function parseResults(options, results) {
     warnings
   };
 }
-/**
- * @param {Stylelint} stylelint
- * @param {FormatterType=} formatter
- * @returns {FormatterFunction}
+/**
+ * @param {Stylelint} stylelint
+ * @param {FormatterType=} formatter
+ * @returns {FormatterFunction}
  */
 
 
@@ -257,33 +261,33 @@ function loadFormatter(stylelint, formatter) {
 
   return stylelint.formatters.string;
 }
-/**
- * @param {LintResult[]} results
- * @returns {LintResult[]}
+/**
+ * @param {LintResult[]} results
+ * @returns {LintResult[]}
  */
 
 
 function removeIgnoredWarnings(results) {
   return results.filter(result => !result.ignored);
 }
-/**
- * @param {Promise<LintResult[]>[]} results
- * @returns {Promise<LintResult[]>}
+/**
+ * @param {Promise<LintResult[]>[]} results
+ * @returns {Promise<LintResult[]>}
  */
 
 
 async function flatten(results) {
-  /**
-   * @param {LintResult[]} acc
-   * @param {LintResult[]} list
+  /**
+   * @param {LintResult[]} acc
+   * @param {LintResult[]} list
    */
   const flat = (acc, list) => [...acc, ...list];
 
   return (await Promise.all(results)).reduce(flat, []);
 }
-/**
- * @param {Compilation} compilation
- * @returns {LintResultMap}
+/**
+ * @param {Compilation} compilation
+ * @returns {LintResultMap}
  */
 
 
@@ -297,4 +301,6 @@ function getResultStorage({
   }
 
   return storage;
-}
+}
+
+module.exports = linter;

package/dist/options.js

@@ -1,55 +1,49 @@
 "use strict";
 
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.getOptions = getOptions;
-exports.getStylelintOptions = getStylelintOptions;
+const {
+  validate
+} = require('schema-utils'); // @ts-ignore
 
-var _schemaUtils = require("schema-utils");
-
-var _options = _interopRequireDefault(require("./options.json"));
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-// @ts-ignore
 
+const schema = require('./options.json');
 /** @typedef {import("stylelint")} stylelint */
 
 /** @typedef {import("stylelint").LinterOptions} StylelintOptions */
 
 /** @typedef {import("stylelint").FormatterType} FormatterType */
 
-/**
- * @typedef {Object} OutputReport
- * @property {string=} filePath
- * @property {FormatterType=} formatter
+/**
+ * @typedef {Object} OutputReport
+ * @property {string=} filePath
+ * @property {FormatterType=} formatter
  */
 
-/**
- * @typedef {Object} PluginOptions
- * @property {string} context
- * @property {boolean} emitError
- * @property {boolean} emitWarning
- * @property {string|string[]=} exclude
- * @property {string|string[]} extensions
- * @property {boolean} failOnError
- * @property {boolean} failOnWarning
- * @property {string|string[]} files
- * @property {FormatterType} formatter
- * @property {boolean} lintDirtyModulesOnly
- * @property {boolean} quiet
- * @property {string} stylelintPath
- * @property {OutputReport} outputReport
- * @property {number|boolean=} threads
+/**
+ * @typedef {Object} PluginOptions
+ * @property {string} context
+ * @property {boolean} emitError
+ * @property {boolean} emitWarning
+ * @property {string|string[]=} exclude
+ * @property {string|string[]} extensions
+ * @property {boolean} failOnError
+ * @property {boolean} failOnWarning
+ * @property {string|string[]} files
+ * @property {FormatterType} formatter
+ * @property {boolean} lintDirtyModulesOnly
+ * @property {boolean} quiet
+ * @property {string} stylelintPath
+ * @property {OutputReport} outputReport
+ * @property {number|boolean=} threads
  */
 
 /** @typedef {Partial<PluginOptions & StylelintOptions>} Options */
 
-/**
- * @param {Options} pluginOptions
- * @returns {Partial<PluginOptions>}
+/**
+ * @param {Options} pluginOptions
+ * @returns {Partial<PluginOptions>}
  */
+
+
 function getOptions(pluginOptions) {
   const options = {
     extensions: ['css', 'scss', 'sass'],
@@ -63,15 +57,15 @@ function getOptions(pluginOptions) {
     } : {})
   }; // @ts-ignore
 
-  (0, _schemaUtils.validate)(_options.default, options, {
+  validate(schema, options, {
     name: 'Stylelint Webpack Plugin',
     baseDataPath: 'options'
   });
   return options;
 }
-/**
- * @param {Options} pluginOptions
- * @returns {Partial<StylelintOptions>}
+/**
+ * @param {Options} pluginOptions
+ * @returns {Partial<StylelintOptions>}
  */
 
 
@@ -83,7 +77,7 @@ function getStylelintOptions(pluginOptions) {
     files,
     formatter,
     ...stylelintOnlyOptions
-  } = _options.default.properties; // No need to guard the for-in because schema.properties has hardcoded keys.
+  } = 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) {
@@ -92,4 +86,9 @@ function getStylelintOptions(pluginOptions) {
   }
 
   return stylelintOptions;
-}
+}
+
+module.exports = {
+  getOptions,
+  getStylelintOptions
+};