stylelint-webpack-plugin 2.3.2 → 2.5.0

package/dist/index.js

@@ -1,144 +1,149 @@
 "use strict";
 
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-
-var _path = require("path");
-
-var _arrify = _interopRequireDefault(require("arrify"));
-
-var _globby = _interopRequireDefault(require("globby"));
-
-var _micromatch = require("micromatch");
-
-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 {
+  isAbsolute,
+  join
+} = require('path');
+const arrify = require('arrify');
+const globby = require('globby');
+const {
+  isMatch
+} = require('micromatch');
+const {
+  getOptions
+} = require('./options');
+const linter = require('./linter');
+const {
+  parseFiles,
+  parseFoldersToGlobs
+} = require('./utils');
 
 /** @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
+  /**
+   * @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>} */
 
+    /** @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,
-    // execute the linter on the build
+    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;
     compiler.hooks.watchRun.tapPromise(this.key, c => {
       if (isFirstRun) {
         isFirstRun = false;
         return Promise.resolve();
       }
-
-      return this.run(c);
+      return this.run(c, options, wanted, exclude);
     });
   }
-  /**
-   * @param {Compiler} compiler
-   */
 
-
-  async run(compiler) {
+  /**
+   * @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;
     }
-
-    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('./getStylelint').Stylelint} */
+      let stylelint;
+
       /** @type {import('./linter').Linter} */
       let lint;
-      /** @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,
+          isPathIgnored,
           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} */file) => {
+          try {
+            return (await isPathIgnored(stylelint, 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
+      });
 
+      // 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);
@@ -146,7 +151,6 @@ class StylelintWebpackPlugin {
           // @ts-ignore
           compilation.errors.push(warnings);
         }
-
         if (errors && options.failOnError) {
           // @ts-ignore
           compilation.errors.push(errors);
@@ -154,115 +158,99 @@ class StylelintWebpackPlugin {
           // @ts-ignore
           compilation.warnings.push(errors);
         }
-
         if (generateReportAsset) {
           await generateReportAsset(compilation);
         }
       }
     });
   }
-  /**
-   *
-   * @param {Compiler} compiler
-   * @returns {string}
-   */
-
 
+  /**
+   *
+   * @param {Compiler} compiler
+   * @returns {string}
+   */
   getContext(compiler) {
     if (!this.options.context) {
       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
-
-
   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
+    }
 
+    // webpack 4
     /* istanbul ignore next */
-
-
     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
       if (fileSystemInfoEntry && fileSystemInfoEntry.timestamp) {
         // @ts-ignore
         return fileSystemInfoEntry.timestamp;
-      } // @ts-ignore
-
+      }
 
+      // @ts-ignore
       return fileSystemInfoEntry;
     };
-    /**
-     * @param {string} filename
-     * @param {null | FileSystemInfoEntry | "ignore" | undefined} fileSystemInfoEntry
-     * @returns {boolean}
-     */
-
 
+    /**
+     * @param {string} filename
+     * @param {null | FileSystemInfoEntry | "ignore" | undefined} fileSystemInfoEntry
+     * @returns {boolean}
+     */
     const hasFileChanged = (filename, fileSystemInfoEntry) => {
       const prevTimestamp = getTimestamps(this.prevTimestamps.get(filename));
       const timestamp = getTimestamps(fileSystemInfoEntry);
       return (prevTimestamp || this.startTime) < (timestamp || Infinity);
     };
-
     const changedFiles = [];
-
     for (const [filename, timestamp] of fileTimestamps.entries()) {
       if (hasFileChanged(filename, timestamp)) {
         changedFiles.push(filename);
       }
     }
-
     this.prevTimestamps = fileTimestamps;
     return changedFiles;
   }
-
 }
-
-var _default = StylelintWebpackPlugin;
-exports.default = _default;
+module.exports = StylelintWebpackPlugin;