stylelint-webpack-plugin 2.1.1 → 2.3.0

package/dist/linter.js

@@ -5,108 +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[String(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) {
-        // @ts-ignore
-        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) {
-        // @ts-ignore
-        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) => {
-      // @ts-ignore
-      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 {
@@ -115,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;
 }

package/dist/options.js

@@ -0,0 +1,95 @@
+"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 }; }
+
+// @ts-ignore
+
+/** @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} 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>}
+ */
+function getOptions(pluginOptions) {
+  const options = {
+    extensions: ['css', 'scss', 'sass'],
+    emitError: true,
+    emitWarning: true,
+    failOnError: true,
+    ...pluginOptions,
+    ...(pluginOptions.quiet ? {
+      emitError: true,
+      emitWarning: false
+    } : {})
+  }; // @ts-ignore
+
+  (0, _schemaUtils.validate)(_options.default, options, {
+    name: 'Stylelint Webpack Plugin',
+    baseDataPath: 'options'
+  });
+  return options;
+}
+/**
+ * @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 {
+    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
+
+  for (const option in stylelintOnlyOptions) {
+    // @ts-ignore
+    delete stylelintOptions[option];
+  }
+
+  return stylelintOptions;
+}

package/dist/options.json

@@ -7,15 +7,23 @@
       "type": "string"
     },
     "emitError": {
-      "description": "Will always return errors, if set to `true`.",
+      "description": "The errors found will always be emitted, to disable set to `false`.",
       "type": "boolean"
     },
     "emitWarning": {
-      "description": "Will always return warnings, if set to `true`.",
+      "description": "The warnings found will always be emitted, to disable set to `false`.",
       "type": "boolean"
     },
+    "exclude": {
+      "description": "Specify the files and/or directories to exclude. Must be relative to `options.context`.",
+      "anyOf": [{ "type": "string" }, { "type": "array" }]
+    },
+    "extensions": {
+      "description": "Specify extensions that should be checked.",
+      "anyOf": [{ "type": "string" }, { "type": "array" }]
+    },
     "failOnError": {
-      "description": "Will cause the module build to fail if there are any errors, if set to `true`.",
+      "description": "Will cause the module build to fail if there are any errors, to disable set to `false`.",
       "type": "boolean"
     },
     "failOnWarning": {
@@ -23,7 +31,7 @@
       "type": "boolean"
     },
     "files": {
-      "description": "Specify the glob pattern for finding files. Must be relative to `options.context`.",
+      "description": "Specify directories, files, or globs. Must be relative to `options.context`. Directories are traveresed recursively looking for files matching `options.extensions`. File and glob patterns ignore `options.extensions`.",
       "anyOf": [{ "type": "string" }, { "type": "array" }]
     },
     "formatter": {
@@ -41,6 +49,32 @@
     "stylelintPath": {
       "description": "Path to `stylelint` instance that will be used for linting.",
       "type": "string"
+    },
+    "outputReport": {
+      "description": "Write the output of the errors to a file, for example a `json` file for use for reporting.",
+      "anyOf": [
+        {
+          "type": "boolean"
+        },
+        {
+          "type": "object",
+          "additionalProperties": false,
+          "properties": {
+            "filePath": {
+              "description": "The `filePath` is relative to the webpack config: `output.path`.",
+              "anyOf": [{ "type": "string" }]
+            },
+            "formatter": {
+              "description": "You can pass in a different formatter for the output file, if none is passed in the default/configured formatter will be used.",
+              "anyOf": [{ "type": "string" }, { "instanceof": "Function" }]
+            }
+          }
+        }
+      ]
+    },
+    "threads": {
+      "description": "Set to true for an auto-selected pool size based on number of cpus. Set to a number greater than 1 to set an explicit pool size. Set to false, 1, or less to disable and only run in main process.",
+      "anyOf": [{ "type": "number" }, { "type": "boolean" }]
     }
   }
 }

package/dist/utils.js

@@ -3,29 +3,84 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+exports.jsonStringifyReplacerSortKeys = void 0;
 exports.parseFiles = parseFiles;
-exports.replaceBackslashes = replaceBackslashes;
+exports.parseFoldersToGlobs = parseFoldersToGlobs;
+
+var _path = require("path");
+
+var _fs = require("fs");
+
+var _normalizePath = _interopRequireDefault(require("normalize-path"));
 
 var _arrify = _interopRequireDefault(require("arrify"));
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-const UNESCAPED_GLOB_SYMBOLS_RE = /(\\?)([()*?[\]{|}]|^!|[!+@](?=\())/g;
+// @ts-ignore
+// @ts-ignore
+
 /**
- * @param {Array<string> | string} files
+ * @param {string|(string|undefined)[]} files
  * @param {string} context
- * @returns {Array<string>}
+ * @returns {string[]}
  */
-
 function parseFiles(files, context) {
-  return (0, _arrify.default)(files).map(file => `${replaceBackslashes(context).replace(UNESCAPED_GLOB_SYMBOLS_RE, '\\$2')}/${replaceBackslashes(file)}`);
+  return (0, _arrify.default)(files).filter((
+  /** @type {string} */
+  file) => typeof file === 'string').map((
+  /** @type {string} */
+  file) => (0, _normalizePath.default)((0, _path.resolve)(context, file)));
+}
+/**
+ * @param {string|string[]} patterns
+ * @param {string|string[]} extensions
+ * @returns {string[]}
+ */
+
+
+function parseFoldersToGlobs(patterns, extensions = []) {
+  const extensionsList = (0, _arrify.default)(extensions);
+  const [prefix, postfix] = extensionsList.length > 1 ? ['{', '}'] : ['', ''];
+  const extensionsGlob = extensionsList.map((
+  /** @type {string} */
+  extension) => extension.replace(/^\./u, '')).join(',');
+  return (0, _arrify.default)(patterns).map((
+  /** @type {string} */
+  pattern) => {
+    try {
+      // The patterns are absolute because they are prepended with the context.
+      const stats = (0, _fs.statSync)(pattern);
+      /* istanbul ignore else */
+
+      if (stats.isDirectory()) {
+        return pattern.replace(/[/\\]*?$/u, `/**${extensionsGlob ? `/*.${prefix + extensionsGlob + postfix}` : ''}`);
+      }
+    } catch (_) {// Return the pattern as is on error.
+    }
+
+    return pattern;
+  });
 }
 /**
- * @param {string} str
- * @returns {string}
+ *
+ * @param {string} _ key, but unused
+ * @param {any} value
  */
 
 
-function replaceBackslashes(str) {
-  return str.replace(/\\/g, '/');
-}
+const jsonStringifyReplacerSortKeys = (_, value) => {
+  /**
+   * @param {{ [x: string]: any; }} sorted
+   * @param {string | number} key
+   */
+  const insert = (sorted, key) => {
+    // eslint-disable-next-line no-param-reassign
+    sorted[key] = value[key];
+    return sorted;
+  };
+
+  return value instanceof Object && !(value instanceof Array) ? Object.keys(value).sort().reduce(insert, {}) : value;
+};
+
+exports.jsonStringifyReplacerSortKeys = jsonStringifyReplacerSortKeys;

package/dist/worker.js

@@ -0,0 +1,50 @@
+"use strict";
+
+/** @typedef {import('stylelint')} Stylelint */
+
+/** @typedef {import("stylelint").LinterOptions} StylelintOptions */
+
+/** @typedef {import('./options').Options} Options */
+Object.assign(module.exports, {
+  lintFiles,
+  setup
+});
+/** @type {Stylelint} */
+
+let stylelint;
+/** @type {Partial<StylelintOptions>} */
+
+let linterOptions;
+/**
+ * @param {Options} options
+ * @param {Partial<StylelintOptions>} stylelintOptions
+ */
+
+function setup(options, stylelintOptions) {
+  stylelint = require(options.stylelintPath || 'stylelint');
+  linterOptions = stylelintOptions;
+  return stylelint;
+}
+/**
+ * @param {string | string[]} files
+ */
+
+
+async function lintFiles(files) {
+  const {
+    results
+  } = await stylelint.lint({ ...linterOptions,
+    files
+  }); // Reset result to work with worker
+
+  return results.map(result => {
+    return {
+      source: result.source,
+      errored: result.errored,
+      ignored: result.ignored,
+      warnings: result.warnings,
+      deprecations: result.deprecations,
+      invalidOptionWarnings: result.invalidOptionWarnings
+    };
+  });
+}