stylelint-webpack-plugin 2.4.0 → 2.5.0

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,94 @@
 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 {{lint: (options: LinterOptions) => Promise<LinterResult>, formatters: { [k: string]: Formatter }}} Stylelint */
 /** @typedef {import('stylelint').LintResult} LintResult */
-
+/** @typedef {import('stylelint').LinterOptions} LinterOptions */
+/** @typedef {import('stylelint').LinterResult} LinterResult */
+/** @typedef {import('stylelint').Formatter} Formatter */
+/** @typedef {import('stylelint').FormatterType} FormatterType */
 /** @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 +99,12 @@ function loadStylelintThreaded(key, poolSize, options) {
   };
   return context;
 }
+
 /**
  * @param {string|undefined} key
  * @param {Options} options
  * @returns {Linter}
  */
-
-
 function getStylelint(key, {
   threads,
   ...options
@@ -115,25 +114,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,37 +4,27 @@ 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').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
@@ -44,82 +34,82 @@ class StylelintWebpackPlugin {
     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}
    */
-
-
   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('./getStylelint').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));
@@ -127,20 +117,16 @@ class StylelintWebpackPlugin {
         compilation.errors.push(e);
         return;
       }
-
       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) => {
+        const files = (await Promise.all(this.getFiles(compiler, wanted, exclude).map(async ( /** @type {string} */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 || ''));
@@ -148,17 +134,16 @@ class StylelintWebpackPlugin {
         } else if (files.length > 0) {
           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);
@@ -166,7 +151,6 @@ class StylelintWebpackPlugin {
           // @ts-ignore
           compilation.errors.push(warnings);
         }
-
         if (errors && options.failOnError) {
           // @ts-ignore
           compilation.errors.push(errors);
@@ -174,31 +158,28 @@ 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;
   }
+
   /**
    * @param {Compiler} compiler
    * @param {string[]} wanted
@@ -206,8 +187,6 @@ class StylelintWebpackPlugin {
    * @returns {string[]}
    */
   // eslint-disable-next-line no-unused-vars
-
-
   getFiles(compiler, wanted, exclude) {
     // webpack 5
     if (compiler.modifiedFiles) {
@@ -216,11 +195,10 @@ class StylelintWebpackPlugin {
       }) && !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 => isMatch(file, wanted, {
         dot: true
@@ -228,20 +206,17 @@ class StylelintWebpackPlugin {
         dot: true
       }));
     }
-
     return globby.sync(wanted, {
       dot: true,
       ignore: exclude
     });
   }
+
   /**
    * @param {ReadonlyMap<string, null | FileSystemInfoEntry | "ignore" | undefined>} fileTimestamps
    * @returns {string[]}
    */
-
   /* istanbul ignore next */
-
-
   getChangedFiles(fileTimestamps) {
     /**
      * @param {null | FileSystemInfoEntry | "ignore" | undefined} fileSystemInfoEntry
@@ -252,36 +227,30 @@ class StylelintWebpackPlugin {
       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}
      */
-
-
     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;
   }
-
 }
-
 module.exports = StylelintWebpackPlugin;