stylelint-webpack-plugin 1.2.3 → 2.2.0

package/README.md

@@ -61,12 +61,26 @@ Specify the config file location to be used by `stylelint`.
 
 A string indicating the root of your files.
 
+### `exclude`
+
+- Type: `String|Array[String]`
+- Default: `'node_modules'`
+
+Specify the files and/or directories to exclude. Must be relative to `options.context`.
+
+### `extensions`
+
+- Type: `String|Array[String]`
+- Default: `['css', 'scss', 'sass']`
+
+Specify extensions that should be checked.
+
 ### `files`
 
 - Type: `String|Array[String]`
-- Default: `'**/*.s?(a|c)ss'`
+- Default: `null`
 
-Specify the glob pattern for finding files. Must be relative to `options.context`.
+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`.
 
 ### `fix`
 
@@ -96,6 +110,13 @@ Lint only changed files, skip lint on start.
 
 Path to `stylelint` instance that will be used for linting.
 
+### `threads`
+
+- Type: `Boolean | Number`
+- Default: `false`
+
+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.
+
 ### Errors and Warning
 
 **By default the plugin will auto adjust error reporting depending on stylelint errors/warnings counts.**
@@ -106,21 +127,21 @@ You can still force this behavior by using `emitError` **or** `emitWarning` opti
 - Type: `Boolean`
 - Default: `false`
 
-Will always return errors, if set to `true`.
+The errors found will always be emitted, to disable set to `false`.
 
 #### `emitWarning`
 
 - Type: `Boolean`
 - Default: `false`
 
-Will always return warnings, if set to `true`.
+The warnings found will always be emitted, to disable set to `false`.
 
 #### `failOnError`
 
 - Type: `Boolean`
 - Default: `false`
 
-Will cause the module build to fail if there are any errors, if set to `true`.
+Will cause the module build to fail if there are any errors, to disable set to `false`.
 
 #### `failOnWarning`
 
@@ -136,6 +157,22 @@ Will cause the module build to fail if there are any warnings, if set to `true`.
 
 Will process and report errors only and ignore warnings, if set to `true`.
 
+#### `outputReport`
+
+- Type: `Boolean|Object`
+- Default: `false`
+
+Write the output of the errors to a file, for example a `json` file for use for reporting.
+The `filePath` is relative to the webpack config: `output.path`.
+You can pass in a different formatter for the output file, if none is passed in the default/configured formatter will be used.
+
+```js
+{
+  filePath: 'path/to/file';
+  formatter: 'json';
+}
+```
+
 ## Changelog
 
 [Changelog](CHANGELOG.md)
@@ -150,8 +187,8 @@ Will process and report errors only and ignore warnings, if set to `true`.
 [node-url]: https://nodejs.org
 [deps]: https://david-dm.org/webpack-contrib/stylelint-webpack-plugin.svg
 [deps-url]: https://david-dm.org/webpack-contrib/stylelint-webpack-plugin
-[tests]: https://dev.azure.com/webpack-contrib/stylelint-webpack-plugin/_apis/build/status/webpack-contrib.stylelint-webpack-plugin?branchName=master
-[tests-url]: https://dev.azure.com/webpack-contrib/stylelint-webpack-plugin/_build/latest?definitionId=4&branchName=master
+[tests]: https://github.com/webpack-contrib/stylelint-webpack-plugin/workflows/stylelint-webpack-plugin/badge.svg
+[tests-url]: https://github.com/webpack-contrib/stylelint-webpack-plugin/actions
 [cover]: https://codecov.io/gh/webpack-contrib/stylelint-webpack-plugin/branch/master/graph/badge.svg
 [cover-url]: https://codecov.io/gh/webpack-contrib/stylelint-webpack-plugin
 [chat]: https://badges.gitter.im/webpack/webpack.svg

package/declarations/StylelintError.d.ts

@@ -0,0 +1,2 @@
+export default StylelintError;
+declare class StylelintError extends Error {}

package/declarations/cjs.d.ts

@@ -0,0 +1,3 @@
+declare const _exports: typeof plugin.default;
+export = _exports;
+import plugin = require('./index');

package/declarations/getStylelint.d.ts

@@ -0,0 +1,24 @@
+/**
+ * @param {string|undefined} key
+ * @param {Options} options
+ * @returns {Linter}
+ */
+export default function getStylelint(
+  key: string | undefined,
+  { threads, ...options }: Options
+): Linter;
+export type Stylelint = typeof import('stylelint');
+export type LintResult = import('stylelint').LintResult;
+export type Options = import('./options').Options;
+export type AsyncTask = () => Promise<void>;
+export type LintTask = (files: string | string[]) => Promise<LintResult[]>;
+export type Worker = JestWorker & {
+  lintFiles: LintTask;
+};
+export type Linter = {
+  stylelint: Stylelint;
+  lintFiles: LintTask;
+  cleanup: AsyncTask;
+  threads: number;
+};
+import { Worker as JestWorker } from 'jest-worker';

package/declarations/index.d.ts

@@ -0,0 +1,49 @@
+export default StylelintWebpackPlugin;
+export type Compiler = import('webpack').Compiler;
+export type Module = import('webpack').Module;
+export type Options = import('./options').Options;
+export type FileSystemInfoEntry = Partial<
+  | {
+      timestamp: number;
+    }
+  | number
+>;
+declare class StylelintWebpackPlugin {
+  /**
+   * @param {Options} options
+   */
+  constructor(options?: Options);
+  key: string;
+  options: Partial<import('./options').PluginOptions>;
+  /**
+   * @param {Compiler} compiler
+   */
+  run(compiler: Compiler): Promise<void>;
+  startTime: number;
+  prevTimestamps: Map<any, any>;
+  /**
+   * @param {Compiler} compiler
+   * @returns {void}
+   */
+  apply(compiler: Compiler): void;
+  /**
+   *
+   * @param {Compiler} compiler
+   * @returns {string}
+   */
+  getContext(compiler: Compiler): string;
+  /**
+   * @param {string[]} glob
+   * @param {Compiler} compiler
+   * @param {Module} module
+   * @returns {string[]}
+   */
+  getFiles(glob: string[], compiler: Compiler, module: Module): string[];
+  /**
+   * @param {Map<string, null | FileSystemInfoEntry | "ignore">} fileTimestamps
+   * @returns {string[]}
+   */
+  getChangedFiles(
+    fileTimestamps: Map<string, 'ignore' | FileSystemInfoEntry | null>
+  ): string[];
+}

package/declarations/linter.d.ts

@@ -0,0 +1,34 @@
+/**
+ * @param {string|undefined} key
+ * @param {Options} options
+ * @param {Compilation} compilation
+ * @returns {{lint: Linter, report: Reporter, threads: number}}
+ */
+export default function linter(
+  key: string | undefined,
+  options: Options,
+  compilation: Compilation
+): {
+  lint: Linter;
+  report: Reporter;
+  threads: number;
+};
+export type Stylelint = typeof import('stylelint');
+export type LintResult = import('stylelint').LintResult;
+export type Compiler = import('webpack').Compiler;
+export type Compilation = import('webpack').Compilation;
+export type Options = import('./options').Options;
+export type FormatterType = import('./options').FormatterType;
+export type FormatterFunction = (results: LintResult[]) => string;
+export type GenerateReport = (compilation: Compilation) => Promise<void>;
+export type Report = {
+  errors?: StylelintError;
+  warnings?: StylelintError;
+  generateReportAsset?: GenerateReport;
+};
+export type Reporter = () => Promise<Report>;
+export type Linter = (files: string | string[]) => void;
+export type LintResultMap = {
+  [files: string]: import('stylelint').LintResult;
+};
+import StylelintError from './StylelintError';

package/declarations/options.d.ts

@@ -0,0 +1,62 @@
+/** @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>}
+ */
+export function getOptions(pluginOptions: Options): Partial<PluginOptions>;
+/**
+ * @param {Options} pluginOptions
+ * @returns {Partial<StylelintOptions>}
+ */
+export function getStylelintOptions(
+  pluginOptions: Options
+): Partial<StylelintOptions>;
+export type stylelint = typeof import('stylelint');
+export type StylelintOptions = import('stylelint').LinterOptions;
+export type FormatterType = import('stylelint').FormatterType;
+export type OutputReport = {
+  filePath?: string | undefined;
+  formatter?: FormatterType | undefined;
+};
+export type PluginOptions = {
+  context: string;
+  emitError: boolean;
+  emitWarning: boolean;
+  exclude?: (string | string[]) | undefined;
+  extensions: string | string[];
+  failOnError: boolean;
+  failOnWarning: boolean;
+  files: string | string[];
+  formatter: FormatterType;
+  lintDirtyModulesOnly: boolean;
+  quiet: boolean;
+  stylelintPath: string;
+  outputReport: OutputReport;
+  threads?: (number | boolean) | undefined;
+};
+export type Options = Partial<PluginOptions & StylelintOptions>;

package/declarations/utils.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @param {string|string[]} files
+ * @param {string} context
+ * @returns {string[]}
+ */
+export function parseFiles(files: string | string[], context: string): string[];
+/**
+ * @param {string|string[]} patterns
+ * @param {string|string[]} extensions
+ * @returns {string[]}
+ */
+export function parseFoldersToGlobs(
+  patterns: string | string[],
+  extensions?: string | string[]
+): string[];
+export function jsonStringifyReplacerSortKeys(_: string, value: any): any;

package/declarations/worker.d.ts

@@ -0,0 +1,3 @@
+export type Stylelint = typeof import('stylelint');
+export type StylelintOptions = import('stylelint').LinterOptions;
+export type Options = import('./options').Options;

package/dist/StylelintError.js

@@ -6,18 +6,16 @@ Object.defineProperty(exports, "__esModule", {
 exports.default = void 0;
 
 class StylelintError extends Error {
+  /**
+   * @param {string=} messages
+   */
   constructor(messages) {
     super(messages);
     this.name = 'StylelintError';
-    this.stack = false;
-  }
-
-  static format({
-    formatter
-  }, messages) {
-    return new StylelintError(formatter(messages));
+    this.stack = '';
   }
 
 }
 
-exports.default = StylelintError;
+var _default = StylelintError;
+exports.default = _default;

package/dist/getStylelint.js

@@ -0,0 +1,132 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = getStylelint;
+
+var _os = require("os");
+
+var _jestWorker = require("jest-worker");
+
+var _worker = require("./worker");
+
+var _utils = require("./utils");
+
+var _options = require("./options");
+
+// @ts-ignore
+
+/** @type {{[key: string]: any}} */
+const cache = {};
+/** @typedef {import('stylelint')} Stylelint */
+
+/** @typedef {import('stylelint').LintResult} LintResult */
+
+/** @typedef {import('./options').Options} Options */
+
+/** @typedef {() => Promise<void>} AsyncTask */
+
+/** @typedef {(files: string|string[]) => Promise<LintResult[]>} LintTask */
+
+/** @typedef {JestWorker & {lintFiles: LintTask}} Worker */
+
+/** @typedef {{stylelint: Stylelint, lintFiles: LintTask, cleanup: AsyncTask, threads: number, }} Linter */
+
+/**
+ * @param {Options} options
+ * @returns {Linter}
+ */
+
+function loadStylelint(options) {
+  const stylelint = (0, _worker.setup)(options, (0, _options.getStylelintOptions)(options));
+  return {
+    stylelint,
+    lintFiles: _worker.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, (0, _options.getStylelintOptions)(options)]
+  };
+  const local = loadStylelint(options);
+  /** @type {Worker?} */
+  // prettier-ignore
+
+  let worker =
+  /** @type {Worker} */
+  new _jestWorker.Worker(source, workerOptions);
+  /** @type {Linter} */
+
+  const context = { ...local,
+    threads: poolSize,
+    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;
+      }
+    }
+  };
+  return context;
+}
+/**
+ * @param {string|undefined} key
+ * @param {Options} options
+ * @returns {Linter}
+ */
+
+
+function getStylelint(key, {
+  threads,
+  ...options
+}) {
+  const max = typeof threads !== 'number' ? threads ? (0, _os.cpus)().length - 1 : 1 : threads;
+  const cacheKey = getCacheKey(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
+  }, _utils.jsonStringifyReplacerSortKeys);
+}