stylelint-webpack-plugin 2.3.2 → 2.5.0

package/dist/linter.js

@@ -1,155 +1,149 @@
 "use strict";
 
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-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 }; }
-
-// @ts-ignore
-
-/** @typedef {import('stylelint')} Stylelint */
-
-/** @typedef {import('stylelint').LintResult} LintResult */
+const {
+  dirname,
+  isAbsolute,
+  join
+} = require('path');
+const arrify = require('arrify');
+const StylelintError = require('./StylelintError');
+const getStylelint = require('./getStylelint');
 
 /** @typedef {import('webpack').Compiler} Compiler */
-
 /** @typedef {import('webpack').Compilation} Compilation */
-
+/** @typedef {import('./getStylelint').Stylelint} Stylelint */
+/** @typedef {import('./getStylelint').LintResult} LintResult */
+/** @typedef {import('./getStylelint').LinterResult} LinterResult */
+/** @typedef {import('./getStylelint').Formatter} Formatter */
+/** @typedef {import('./getStylelint').FormatterType} FormatterType */
+/** @typedef {import('./getStylelint').isPathIgnored} isPathIgnored */
 /** @typedef {import('./options').Options} Options */
-
-/** @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 {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 {{stylelint: Stylelint, isPathIgnored: isPathIgnored, lint: Linter, report: Reporter, threads: number}}
+ */
 function linter(key, options, compilation) {
   /** @type {Stylelint} */
   let stylelint;
-  /** @type {(files: string|string[]) => Promise<LintResult[]>} */
 
+  /** @type {isPathIgnored} */
+  let isPathIgnored;
+
+  /** @type {(files: string|string[]) => Promise<LintResult[]>} */
   let lintFiles;
-  /** @type {() => Promise<void>} */
 
+  /** @type {() => Promise<void>} */
   let cleanup;
-  /** @type number */
 
+  /** @type number */
   let threads;
-  /** @type {Promise<LintResult[]>[]} */
 
+  /** @type {Promise<LintResult[]>[]} */
   const rawResults = [];
   const crossRunResultStorage = getResultStorage(compilation);
-
   try {
     ({
       stylelint,
+      isPathIgnored,
       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 {
+    stylelint,
     lint,
+    isPathIgnored,
     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 [];
     }));
   }
-
   async function report() {
     // Filter out ignored files.
-    let results = removeIgnoredWarnings( // Get the current results, resetting the rawResults to empty
+    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[String(result.source)] = result;
     }
+    results = Object.values(crossRunResultStorage);
 
-    results = Object.values(crossRunResultStorage); // do not analyze if there are no results or stylelint config
-
+    // do not analyze if there are no results or stylelint config
     if (!results || results.length < 1) {
       return {};
     }
-
     const formatter = loadFormatter(stylelint, options.formatter);
+
+    /** @type {LinterResult} */
+    const returnValue = {
+      // @ts-ignore
+      cwd: options.cwd,
+      errored: false,
+      results: [],
+      output: '',
+      reportedDisables: [],
+      ruleMetadata: getRuleMetadata(results)
+    };
     const {
       errors,
       warnings
-    } = formatResults(formatter, parseResults(options, results));
+    } = formatResults(formatter, parseResults(options, results), returnValue);
     return {
       errors,
       warnings,
       generateReportAsset
     };
-    /**
-     * @param {Compilation} compilation
-     * @returns {Promise<void>}
-     */
 
+    /**
+     * @param {Compilation} compilation
+     * @returns {Promise<void>}
+     */
     async function generateReportAsset({
       compiler
     }) {
       const {
         outputReport
       } = options;
-      /**
-       * @param {string} name
-       * @param {string | Buffer} content
+      /**
+       * @param {string} name
+       * @param {string | Buffer} content
        */
-
-      const save = (name, content) =>
-      /** @type {Promise<void>} */
+      const save = (name, content) => /** @type {Promise<void>} */
       new Promise((finish, bail) => {
         const {
           mkdir,
           writeFile
-        } = compiler.outputFileSystem; // ensure directory exists
+        } = 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 */
@@ -159,74 +153,66 @@ function linter(key, options, compilation) {
           });
         });
       });
-
       if (!outputReport || !outputReport.filePath) {
         return;
       }
-
-      const content = outputReport.formatter ? loadFormatter(stylelint, outputReport.formatter)(results) : formatter(results);
+      const content = outputReport.formatter;
+      loadFormatter(stylelint, outputReport.formatter)(results, returnValue);
+      formatter(results, returnValue);
       let {
         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);
+      await save(filePath, String(content));
     }
   }
 }
-/**
- * @param {FormatterFunction} formatter
- * @param {{ errors: LintResult[]; warnings: LintResult[]; }} results
- * @returns {{errors?: StylelintError, warnings?: StylelintError}}
- */
 
-
-function formatResults(formatter, results) {
+/**
+ * @param {Formatter} formatter
+ * @param {{ errors: LintResult[]; warnings: LintResult[]; }} results
+ * @param {LinterResult} returnValue
+ * @returns {{errors?: StylelintError, warnings?: StylelintError}}
+ */
+function formatResults(formatter, results, returnValue) {
   let errors;
   let warnings;
-
   if (results.warnings.length > 0) {
-    warnings = new _StylelintError.default(formatter(results.warnings));
+    warnings = new StylelintError(formatter(results.warnings, returnValue));
   }
-
   if (results.errors.length > 0) {
-    errors = new _StylelintError.default(formatter(results.errors));
+    errors = new StylelintError(formatter(results.errors, returnValue));
   }
-
   return {
     errors,
     warnings
   };
 }
-/**
- * @param {Options} options
- * @param {LintResult[]} results
- * @returns {{errors: LintResult[], warnings: LintResult[]}}
+/**
+ * @param {Options} options
+ * @param {LintResult[]} results
+ * @returns {{errors: LintResult[], warnings: LintResult[]}}
  */
-
-
 function parseResults(options, results) {
   /** @type {LintResult[]} */
   const errors = [];
-  /** @type {LintResult[]} */
 
+  /** @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,
+      errors.push({
+        ...file,
         warnings: fileErrors
       });
     }
-
     const fileWarnings = file.warnings.filter(message => options.emitWarning && message.severity === 'warning');
-
     if (fileWarnings.length > 0) {
-      warnings.push({ ...file,
+      warnings.push({
+        ...file,
         warnings: fileWarnings
       });
     }
@@ -236,65 +222,75 @@ function parseResults(options, results) {
     warnings
   };
 }
-/**
- * @param {Stylelint} stylelint
- * @param {FormatterType=} formatter
- * @returns {FormatterFunction}
- */
-
 
+/**
+ * @param {Stylelint} stylelint
+ * @param {FormatterType=} formatter
+ * @returns {Formatter}
+ */
 function loadFormatter(stylelint, formatter) {
   if (typeof formatter === 'function') {
     return formatter;
   }
-
   if (typeof formatter === 'string') {
     try {
       return stylelint.formatters[formatter];
-    } catch (_) {// Load the default formatter.
+    } catch (_) {
+      // Load the default 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}
+ */
 function getResultStorage({
   compiler
 }) {
   let storage = resultStorage.get(compiler);
-
   if (!storage) {
     resultStorage.set(compiler, storage = {});
   }
-
   return storage;
-}
+}
+
+/**
+ * @param {LintResult[]} lintResults
+ */
+/* istanbul ignore next */
+function getRuleMetadata(lintResults) {
+  const [lintResult] = lintResults;
+
+  // eslint-disable-next-line no-undefined
+  if (lintResult === undefined) return {};
+
+  // eslint-disable-next-line no-underscore-dangle, no-undefined
+  if (lintResult._postcssResult === undefined) return {};
+
+  // eslint-disable-next-line no-underscore-dangle
+  return lintResult._postcssResult.stylelint.ruleMetadata;
+}
+module.exports = linter;

package/dist/options.js

@@ -1,54 +1,44 @@
 "use strict";
 
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.getOptions = getOptions;
-exports.getStylelintOptions = getStylelintOptions;
-
-var _schemaUtils = require("schema-utils");
-
-var _options = _interopRequireDefault(require("./options.json"));
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const {
+  validate
+} = require('schema-utils');
 
 // @ts-ignore
+const schema = require('./options.json');
 
-/** @typedef {import("stylelint")} stylelint */
+/** @typedef {import('./getStylelint').LinterOptions} StylelintOptions */
+/** @typedef {import('./getStylelint').FormatterType} FormatterType */
 
-/** @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 = {
@@ -61,35 +51,41 @@ function getOptions(pluginOptions) {
       emitError: true,
       emitWarning: false
     } : {})
-  }; // @ts-ignore
+  };
 
-  (0, _schemaUtils.validate)(_options.default, options, {
+  // @ts-ignore
+  validate(schema, options, {
     name: 'Stylelint Webpack Plugin',
     baseDataPath: 'options'
   });
   return options;
 }
-/**
- * @param {Options} pluginOptions
- * @returns {Partial<StylelintOptions>}
- */
-
 
+/**
+ * @param {Options} pluginOptions
+ * @returns {Partial<StylelintOptions>}
+ */
 function getStylelintOptions(pluginOptions) {
-  const stylelintOptions = { ...pluginOptions
-  }; // Keep the files and formatter option because it is common to both the plugin and Stylelint.
+  const stylelintOptions = {
+    ...pluginOptions
+  };
 
+  // Keep the files and formatter option because it is common to both the plugin and Stylelint.
   const {
     files,
     formatter,
     ...stylelintOnlyOptions
-  } = _options.default.properties; // No need to guard the for-in because schema.properties has hardcoded keys.
-  // eslint-disable-next-line guard-for-in
+  } = 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) {
     // @ts-ignore
     delete stylelintOptions[option];
   }
-
   return stylelintOptions;
-}
+}
+module.exports = {
+  getOptions,
+  getStylelintOptions
+};