stylelint-webpack-plugin 2.1.0 → 2.2.2

package/dist/index.js

@@ -7,9 +7,13 @@ exports.default = void 0;
 
 var _path = require("path");
 
-var _getOptions = _interopRequireDefault(require("./getOptions"));
+var _arrify = _interopRequireDefault(require("arrify"));
 
-var _LintDirtyModulesPlugin = _interopRequireDefault(require("./LintDirtyModulesPlugin"));
+var _globby = _interopRequireDefault(require("globby"));
+
+var _micromatch = require("micromatch");
+
+var _options = require("./options");
 
 var _linter = _interopRequireDefault(require("./linter"));
 
@@ -17,10 +21,29 @@ var _utils = require("./utils");
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
+// @ts-ignore
+// @ts-ignore
+
 /** @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
+   */
   constructor(options = {}) {
-    this.options = (0, _getOptions.default)(options);
+    this.key = STYLELINT_PLUGIN;
+    this.options = (0, _options.getOptions)(options);
+    this.run = this.run.bind(this);
+    this.startTime = Date.now();
+    this.prevTimestamps = new Map();
   }
   /**
    * @param {Compiler} compiler
@@ -29,35 +52,112 @@ class StylelintWebpackPlugin {
 
 
   apply(compiler) {
-    const options = { ...this.options,
-      files: (0, _utils.parseFiles)(this.options.files, this.getContext(compiler))
-    }; // eslint-disable-next-line
-
-    const {
-      lint
-    } = require(options.stylelintPath);
-
-    const {
-      name: plugin
-    } = this.constructor;
-
-    if (options.lintDirtyModulesOnly) {
-      const lintDirty = new _LintDirtyModulesPlugin.default(lint, compiler, options);
-      /* istanbul ignore next */
-
-      compiler.hooks.watchRun.tapAsync(plugin, (compilation, callback) => {
-        lintDirty.apply(compilation, callback);
-      });
-    } else {
-      compiler.hooks.run.tapAsync(plugin, (compilation, callback) => {
-        (0, _linter.default)(lint, options, compilation, callback);
-      });
-      /* istanbul ignore next */
-
-      compiler.hooks.watchRun.tapAsync(plugin, (compilation, callback) => {
-        (0, _linter.default)(lint, options, compilation, callback);
-      });
+    // 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
+
+    if (!this.options.lintDirtyModulesOnly) {
+      compiler.hooks.run.tapPromise(this.key, this.run);
     }
+
+    let isFirstRun = this.options.lintDirtyModulesOnly;
+    compiler.hooks.watchRun.tapPromise(this.key, c => {
+      if (isFirstRun) {
+        isFirstRun = false;
+        return Promise.resolve();
+      }
+
+      return this.run(c);
+    });
+  }
+  /**
+   * @param {Compiler} compiler
+   */
+
+
+  async run(compiler) {
+    // Do not re-hook
+
+    /* istanbul ignore if */
+    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('./linter').Linter} */
+      let lint;
+      /** @type {import('./linter').Reporter} */
+
+      let report;
+      /** @type number */
+
+      let threads;
+
+      try {
+        ({
+          lint,
+          report,
+          threads
+        } = (0, _linter.default)(this.key, options, compilation));
+      } catch (e) {
+        compilation.errors.push(e);
+        return;
+      }
+
+      compilation.hooks.finishModules.tap(this.key, () => {
+        const files = this.getFiles(compiler, wanted, exclude);
+
+        if (threads > 1) {
+          for (const file of files) {
+            lint((0, _utils.parseFiles)(file, context));
+          }
+        } else if (files.length > 0) {
+          lint((0, _utils.parseFiles)(files, context));
+        }
+      }); // 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);
+        } else if (warnings && options.failOnWarning) {
+          // @ts-ignore
+          compilation.errors.push(warnings);
+        }
+
+        if (errors && options.failOnError) {
+          // @ts-ignore
+          compilation.errors.push(errors);
+        } else if (errors && !options.failOnError) {
+          // @ts-ignore
+          compilation.warnings.push(errors);
+        }
+
+        if (generateReportAsset) {
+          await generateReportAsset(compilation);
+        }
+      }
+    });
   }
   /**
    *
@@ -77,6 +177,88 @@ class StylelintWebpackPlugin {
 
     return this.options.context;
   }
+  /**
+   * @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, {
+        dot: true
+      }) && !(0, _micromatch.isMatch)(file, exclude, {
+        dot: true
+      }));
+    } // webpack 4
+
+    /* istanbul ignore next */
+
+
+    if (compiler.fileTimestamps && compiler.fileTimestamps.size > 0) {
+      return this.getChangedFiles(compiler.fileTimestamps).filter(file => (0, _micromatch.isMatch)(file, wanted, {
+        dot: true
+      }) && !(0, _micromatch.isMatch)(file, exclude, {
+        dot: true
+      }));
+    }
+
+    return _globby.default.sync(wanted, {
+      dot: true,
+      ignore: exclude
+    });
+  }
+  /**
+   * @param {Map<string, null | FileSystemInfoEntry | "ignore">} fileTimestamps
+   * @returns {string[]}
+   */
+
+  /* istanbul ignore next */
+
+
+  getChangedFiles(fileTimestamps) {
+    /**
+     * @param {null | FileSystemInfoEntry | "ignore"} fileSystemInfoEntry
+     * @returns {Partial<number>}
+     */
+    const getTimestamps = fileSystemInfoEntry => {
+      // @ts-ignore
+      if (fileSystemInfoEntry && fileSystemInfoEntry.timestamp) {
+        // @ts-ignore
+        return fileSystemInfoEntry.timestamp;
+      } // @ts-ignore
+
+
+      return fileSystemInfoEntry;
+    };
+    /**
+     * @param {string} filename
+     * @param {null | FileSystemInfoEntry | "ignore"} 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;
+  }
 
 }
 

package/dist/linter.js

@@ -5,105 +5,195 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = linter;
 
+var _path = require("path");
+
+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 }; }
 
-/** @typedef {import('stylelint').LinterResult} LinterResult */
+// @ts-ignore
+
+/** @typedef {import('stylelint')} Stylelint */
 
 /** @typedef {import('stylelint').LintResult} LintResult */
 
 /** @typedef {import('webpack').Compiler} Compiler */
 
-/** @typedef {import('./getOptions').Options} Options */
+/** @typedef {import('webpack').Compilation} Compilation */
 
-/**
- * @callback Lint
- * @param {Options} options
- * @returns {Promise<LinterResult>}
- */
+/** @typedef {import('./options').Options} Options */
 
-/**
- * @callback LinterCallback
- * @param {StylelintError | null=} error
- * @returns {void}
- */
+/** @typedef {import('./options').FormatterType} FormatterType */
+
+/** @typedef {((results: LintResult[]) => string)} FormatterFunction */
+
+/** @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 {Lint} lint
+ * @param {string|undefined} key
  * @param {Options} options
- * @param {Compiler} compiler
- * @param {LinterCallback} callback
- * @returns {void}
+ * @param {Compilation} compilation
+ * @returns {{lint: Linter, report: Reporter, threads: number}}
  */
-function linter(lint, options, compiler, callback) {
-  /** @type {Array<LintResult>} */
-  let errors = [];
-  /** @type {Array<LintResult>} */
-
-  let warnings = [];
-  lint(options).then(({
-    results
-  }) => {
+
+function linter(key, options, compilation) {
+  /** @type {Stylelint} */
+  let stylelint;
+  /** @type {(files: string|string[]) => Promise<LintResult[]>} */
+
+  let lintFiles;
+  /** @type {() => Promise<void>} */
+
+  let cleanup;
+  /** @type number */
+
+  let threads;
+  /** @type {Promise<LintResult[]>[]} */
+
+  const rawResults = [];
+  const crossRunResultStorage = getResultStorage(compilation);
+
+  try {
     ({
+      stylelint,
+      lintFiles,
+      cleanup,
+      threads
+    } = (0, _getStylelint.default)(key, options));
+  } catch (e) {
+    throw new _StylelintError.default(e.message);
+  }
+
+  return {
+    lint,
+    report,
+    threads
+  };
+  /**
+   * @param {string | string[]} files
+   */
+
+  function lint(files) {
+    for (const file of (0, _arrify.default)(files)) {
+      delete crossRunResultStorage[file];
+    }
+
+    rawResults.push(lintFiles(files).catch(e => {
+      compilation.errors.push(e);
+      return [];
+    }));
+  }
+
+  async function report() {
+    // Filter out ignored files.
+    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[result.source] = result;
+    }
+
+    results = Object.values(crossRunResultStorage); // do not analyze if there are no results or stylelint config
+
+    if (!results || results.length < 1) {
+      return {};
+    }
+
+    const formatter = loadFormatter(stylelint, options.formatter);
+    const {
       errors,
       warnings
-    } = parseResults(options, results));
-    compiler.hooks.afterEmit.tapAsync('StylelintWebpackPlugin', (compilation, next) => {
-      if (warnings.length) {
-        compilation.warnings.push(_StylelintError.default.format(options, warnings));
-        warnings = [];
-      }
+    } = formatResults(formatter, parseResults(options, results));
+    return {
+      errors,
+      warnings,
+      generateReportAsset
+    };
+    /**
+     * @param {Compilation} compilation
+     * @returns {Promise<void>}
+     */
 
-      if (errors.length) {
-        compilation.errors.push(_StylelintError.default.format(options, errors));
-        errors = [];
+    async function generateReportAsset({
+      compiler
+    }) {
+      const {
+        outputReport
+      } = options;
+      /**
+       * @param {string} name
+       * @param {string | Buffer} content
+       */
+
+      const save = (name, content) =>
+      /** @type {Promise<void>} */
+      new Promise((finish, bail) => {
+        const {
+          mkdir,
+          writeFile
+        } = compiler.outputFileSystem; // ensure directory exists
+        // @ts-ignore - the types for `outputFileSystem` are missing the 3 arg overload
+
+        mkdir((0, _path.dirname)(name), {
+          recursive: true
+        }, err => {
+          /* istanbul ignore if */
+          if (err) bail(err);else writeFile(name, content, err2 => {
+            /* istanbul ignore if */
+            if (err2) bail(err2);else finish();
+          });
+        });
+      });
+
+      if (!outputReport || !outputReport.filePath) {
+        return;
       }
 
-      next();
-    });
+      const content = outputReport.formatter ? loadFormatter(stylelint, outputReport.formatter)(results) : formatter(results);
+      let {
+        filePath
+      } = outputReport;
+
+      if (!(0, _path.isAbsolute)(filePath)) {
+        filePath = (0, _path.join)(compiler.outputPath, filePath);
+      }
 
-    if (options.failOnError && errors.length) {
-      callback(_StylelintError.default.format(options, errors));
-    } else if (options.failOnWarning && warnings.length) {
-      callback(_StylelintError.default.format(options, warnings));
-    } else {
-      callback();
+      await save(filePath, content);
     }
-  }).catch(e => {
-    compiler.hooks.afterEmit.tapAsync('StylelintWebpackPlugin', (compilation, next) => {
-      compilation.errors.push(new _StylelintError.default(e.message));
-      next();
-    });
-    callback();
-  });
+  }
 }
 /**
- *
- * @param {Options} options
- * @param {Array<LintResult>} results
- * @returns {{errors: Array<LintResult>, warnings: Array<LintResult>}}
+ * @param {FormatterFunction} formatter
+ * @param {{ errors: LintResult[]; warnings: LintResult[]; }} results
+ * @returns {{errors?: StylelintError, warnings?: StylelintError}}
  */
 
 
-function parseResults(options, results) {
-  /** @type {Array<LintResult>} */
-  let errors = [];
-  /** @type {Array<LintResult>} */
-
-  let warnings = [];
-
-  if (options.emitError) {
-    errors = results.filter(file => fileHasErrors(file) || fileHasWarnings(file));
-  } else if (options.emitWarning) {
-    warnings = results.filter(file => fileHasErrors(file) || fileHasWarnings(file));
-  } else {
-    warnings = results.filter(file => !fileHasErrors(file) && fileHasWarnings(file));
-    errors = results.filter(fileHasErrors);
+function formatResults(formatter, results) {
+  let errors;
+  let warnings;
+
+  if (results.warnings.length > 0) {
+    warnings = new _StylelintError.default(formatter(results.warnings));
   }
 
-  if (options.quiet && warnings.length) {
-    warnings = [];
+  if (results.errors.length > 0) {
+    errors = new _StylelintError.default(formatter(results.errors));
   }
 
   return {
@@ -112,20 +202,99 @@ function parseResults(options, results) {
   };
 }
 /**
- * @param {LintResult} file
- * @returns {boolean}
+ * @param {Options} options
+ * @param {LintResult[]} results
+ * @returns {{errors: LintResult[], warnings: LintResult[]}}
+ */
+
+
+function parseResults(options, results) {
+  /** @type {LintResult[]} */
+  const errors = [];
+  /** @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,
+        warnings: fileErrors
+      });
+    }
+
+    const fileWarnings = file.warnings.filter(message => options.emitWarning && message.severity === 'warning');
+
+    if (fileWarnings.length > 0) {
+      warnings.push({ ...file,
+        warnings: fileWarnings
+      });
+    }
+  });
+  return {
+    errors,
+    warnings
+  };
+}
+/**
+ * @param {Stylelint} stylelint
+ * @param {FormatterType=} formatter
+ * @returns {FormatterFunction}
  */
 
 
-function fileHasErrors(file) {
-  return !!file.errored;
+function loadFormatter(stylelint, formatter) {
+  if (typeof formatter === 'function') {
+    return formatter;
+  }
+
+  if (typeof formatter === 'string') {
+    try {
+      return stylelint.formatters[formatter];
+    } catch (_) {// Load the default formatter.
+    }
+  }
+
+  return stylelint.formatters.string;
 }
 /**
- * @param {LintResult} file
- * @returns {boolean}
+ * @param {LintResult[]} results
+ * @returns {LintResult[]}
  */
 
 
-function fileHasWarnings(file) {
-  return file.warnings && file.warnings.length > 0;
+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;
 }