stylelint-webpack-plugin 2.1.1 → 2.3.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', compiler.options.output.path]`
+
+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)

package/declarations/StylelintError.d.ts

@@ -1,30 +1,2 @@
-/** @typedef {import('stylelint').LintResult} LintResult */
-/** @typedef {import('./getOptions').Options} Options */
-export default class StylelintError extends Error {
-  /**
-   * @param {Options} options
-   * @param {Array<LintResult>} messages
-   * @returns {StylelintError}
-   */
-  static format(
-    { formatter }: Options,
-    messages: Array<LintResult>
-  ): StylelintError;
-  /**
-   * @param {Partial<string>} messages
-   */
-  constructor(messages: Partial<string>);
-}
-export type LintResult = import('stylelint').LintResult;
-export type Options = {
-  context?: string | undefined;
-  emitError?: boolean | undefined;
-  emitWarning?: boolean | undefined;
-  failOnError?: boolean | undefined;
-  failOnWarning?: boolean | undefined;
-  files: string | string[];
-  formatter: TimerHandler;
-  lintDirtyModulesOnly?: boolean | undefined;
-  quiet?: boolean | undefined;
-  stylelintPath: string;
-};
+export default StylelintError;
+declare class StylelintError extends Error {}

package/declarations/cjs.d.ts

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

package/declarations/getStylelint.d.ts

@@ -0,0 +1,72 @@
+/// <reference types="stylelint" />
+/**
+ * @param {string|undefined} key
+ * @param {Options} options
+ * @returns {Linter}
+ */
+export default function getStylelint(
+  key: string | undefined,
+  { threads, ...options }: Options
+): Linter;
+export type Stylelint = import('stylelint/node_modules/postcss').PluginCreator<
+  import('stylelint').PostcssPluginOptions
+> & {
+  lint: (
+    options: import('stylelint').LinterOptions
+  ) => Promise<import('stylelint').LinterResult>;
+  rules: {
+    [k: string]: import('stylelint').Rule<any, any>;
+  };
+  formatters: {
+    [k: string]: import('stylelint').Formatter;
+  };
+  createPlugin: (
+    ruleName: string,
+    plugin: import('stylelint').Plugin<any, any>
+  ) => {
+    ruleName: string;
+    rule: import('stylelint').Rule<any, any>;
+  };
+  createLinter: (
+    options: import('stylelint').LinterOptions
+  ) => import('stylelint').InternalApi;
+  utils: {
+    report: (problem: import('stylelint').Problem) => void;
+    ruleMessages: <
+      T extends import('stylelint').RuleMessages,
+      R extends { [K in keyof T]: T[K] }
+    >(
+      ruleName: string,
+      messages: T
+    ) => R;
+    validateOptions: (
+      result: import('stylelint').PostcssResult,
+      ruleName: string,
+      ...optionDescriptions: import('stylelint').RuleOptions[]
+    ) => boolean;
+    checkAgainstRule: <T_1, O extends Object>(
+      options: {
+        ruleName: string;
+        ruleSettings: import('stylelint').ConfigRuleSettings<T_1, O>;
+        root: import('stylelint/node_modules/postcss').Root;
+      },
+      callback: (
+        warning: import('stylelint/node_modules/postcss').Warning
+      ) => void
+    ) => void;
+  };
+};
+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

@@ -1,9 +1,30 @@
 export default StylelintWebpackPlugin;
 export type Compiler = import('webpack').Compiler;
-/** @typedef {import('webpack').Compiler} Compiler */
+export type Module = import('webpack').Module;
+export type Options = import('./options').Options;
+export type FileSystemInfoEntry = Partial<
+  | {
+      timestamp: number;
+    }
+  | number
+>;
 declare class StylelintWebpackPlugin {
-  constructor(options?: {});
-  options: import('./getOptions').Options;
+  /**
+   * @param {Options} options
+   */
+  constructor(options?: Options);
+  key: string;
+  options: Partial<import('./options').PluginOptions>;
+  /**
+   * @param {Compiler} compiler
+   */
+  run(compiler: Compiler): Promise<void>;
+  startTime: number;
+  /** @type {ReadonlyMap<string, null | FileSystemInfoEntry | "ignore" | undefined>} */
+  prevTimestamps: ReadonlyMap<
+    string,
+    'ignore' | FileSystemInfoEntry | null | undefined
+  >;
   /**
    * @param {Compiler} compiler
    * @returns {void}
@@ -15,4 +36,21 @@ declare class StylelintWebpackPlugin {
    * @returns {string}
    */
   getContext(compiler: Compiler): string;
+  /**
+   * @param {Compiler} compiler
+   * @param {string[]} wanted
+   * @param {string[]} exclude
+   * @returns {string[]}
+   */
+  getFiles(compiler: Compiler, wanted: string[], exclude: string[]): string[];
+  /**
+   * @param {ReadonlyMap<string, null | FileSystemInfoEntry | "ignore" | undefined>} fileTimestamps
+   * @returns {string[]}
+   */
+  getChangedFiles(
+    fileTimestamps: ReadonlyMap<
+      string,
+      'ignore' | FileSystemInfoEntry | null | undefined
+    >
+  ): string[];
 }

package/declarations/linter.d.ts

@@ -1,47 +1,82 @@
-/** @typedef {import('stylelint').LinterResult} LinterResult */
-/** @typedef {import('stylelint').LintResult} LintResult */
-/** @typedef {import('webpack').Compiler} Compiler */
-/** @typedef {import('./getOptions').Options} Options */
+/// <reference types="stylelint" />
 /**
- * @callback Lint
+ * @param {string|undefined} key
  * @param {Options} options
- * @returns {Promise<LinterResult>}
- */
-/**
- * @callback LinterCallback
- * @param {StylelintError | null=} error
- * @returns {void}
- */
-/**
- * @param {Lint} lint
- * @param {Options} options
- * @param {Compiler} compiler
- * @param {LinterCallback} callback
- * @returns {void}
+ * @param {Compilation} compilation
+ * @returns {{lint: Linter, report: Reporter, threads: number}}
  */
 export default function linter(
-  lint: Lint,
+  key: string | undefined,
   options: Options,
-  compiler: Compiler,
-  callback: LinterCallback
-): void;
-export type LinterResult = import('stylelint').LinterResult;
+  compilation: Compilation
+): {
+  lint: Linter;
+  report: Reporter;
+  threads: number;
+};
+export type Stylelint = import('stylelint/node_modules/postcss').PluginCreator<
+  import('stylelint').PostcssPluginOptions
+> & {
+  lint: (
+    options: import('stylelint').LinterOptions
+  ) => Promise<import('stylelint').LinterResult>;
+  rules: {
+    [k: string]: import('stylelint').Rule<any, any>;
+  };
+  formatters: {
+    [k: string]: import('stylelint').Formatter;
+  };
+  createPlugin: (
+    ruleName: string,
+    plugin: import('stylelint').Plugin<any, any>
+  ) => {
+    ruleName: string;
+    rule: import('stylelint').Rule<any, any>;
+  };
+  createLinter: (
+    options: import('stylelint').LinterOptions
+  ) => import('stylelint').InternalApi;
+  utils: {
+    report: (problem: import('stylelint').Problem) => void;
+    ruleMessages: <
+      T extends import('stylelint').RuleMessages,
+      R extends { [K in keyof T]: T[K] }
+    >(
+      ruleName: string,
+      messages: T
+    ) => R;
+    validateOptions: (
+      result: import('stylelint').PostcssResult,
+      ruleName: string,
+      ...optionDescriptions: import('stylelint').RuleOptions[]
+    ) => boolean;
+    checkAgainstRule: <T_1, O extends Object>(
+      options: {
+        ruleName: string;
+        ruleSettings: import('stylelint').ConfigRuleSettings<T_1, O>;
+        root: import('stylelint/node_modules/postcss').Root;
+      },
+      callback: (
+        warning: import('stylelint/node_modules/postcss').Warning
+      ) => void
+    ) => void;
+  };
+};
 export type LintResult = import('stylelint').LintResult;
 export type Compiler = import('webpack').Compiler;
-export type Options = {
-  context?: string | undefined;
-  emitError?: boolean | undefined;
-  emitWarning?: boolean | undefined;
-  failOnError?: boolean | undefined;
-  failOnWarning?: boolean | undefined;
-  files: string | string[];
-  formatter: TimerHandler;
-  lintDirtyModulesOnly?: boolean | undefined;
-  quiet?: boolean | undefined;
-  stylelintPath: string;
+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;
 };
-export type Lint = (options: Options) => Promise<LinterResult>;
-export type LinterCallback = (
-  error?: (StylelintError | null) | undefined
-) => void;
 import StylelintError from './StylelintError';

package/declarations/options.d.ts

@@ -0,0 +1,110 @@
+/// <reference types="stylelint" />
+/** @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 = import('stylelint/node_modules/postcss').PluginCreator<
+  import('stylelint').PostcssPluginOptions
+> & {
+  lint: (
+    options: import('stylelint').LinterOptions
+  ) => Promise<import('stylelint').LinterResult>;
+  rules: {
+    [k: string]: import('stylelint').Rule<any, any>;
+  };
+  formatters: {
+    [k: string]: import('stylelint').Formatter;
+  };
+  createPlugin: (
+    ruleName: string,
+    plugin: import('stylelint').Plugin<any, any>
+  ) => {
+    ruleName: string;
+    rule: import('stylelint').Rule<any, any>;
+  };
+  createLinter: (
+    options: import('stylelint').LinterOptions
+  ) => import('stylelint').InternalApi;
+  utils: {
+    report: (problem: import('stylelint').Problem) => void;
+    ruleMessages: <
+      T extends import('stylelint').RuleMessages,
+      R extends { [K in keyof T]: T[K] }
+    >(
+      ruleName: string,
+      messages: T
+    ) => R;
+    validateOptions: (
+      result: import('stylelint').PostcssResult,
+      ruleName: string,
+      ...optionDescriptions: import('stylelint').RuleOptions[]
+    ) => boolean;
+    checkAgainstRule: <T_1, O extends Object>(
+      options: {
+        ruleName: string;
+        ruleSettings: import('stylelint').ConfigRuleSettings<T_1, O>;
+        root: import('stylelint/node_modules/postcss').Root;
+      },
+      callback: (
+        warning: import('stylelint/node_modules/postcss').Warning
+      ) => void
+    ) => void;
+  };
+};
+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

@@ -1,14 +1,19 @@
 /**
- * @param {Array<string> | string} files
+ * @param {string|(string|undefined)[]} files
  * @param {string} context
- * @returns {Array<string>}
+ * @returns {string[]}
  */
 export function parseFiles(
-  files: Array<string> | string,
+  files: string | (string | undefined)[],
   context: string
-): Array<string>;
+): string[];
 /**
- * @param {string} str
- * @returns {string}
+ * @param {string|string[]} patterns
+ * @param {string|string[]} extensions
+ * @returns {string[]}
  */
-export function replaceBackslashes(str: string): 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,51 @@
+/// <reference types="stylelint" />
+export type Stylelint = import('stylelint/node_modules/postcss').PluginCreator<
+  import('stylelint').PostcssPluginOptions
+> & {
+  lint: (
+    options: import('stylelint').LinterOptions
+  ) => Promise<import('stylelint').LinterResult>;
+  rules: {
+    [k: string]: import('stylelint').Rule<any, any>;
+  };
+  formatters: {
+    [k: string]: import('stylelint').Formatter;
+  };
+  createPlugin: (
+    ruleName: string,
+    plugin: import('stylelint').Plugin<any, any>
+  ) => {
+    ruleName: string;
+    rule: import('stylelint').Rule<any, any>;
+  };
+  createLinter: (
+    options: import('stylelint').LinterOptions
+  ) => import('stylelint').InternalApi;
+  utils: {
+    report: (problem: import('stylelint').Problem) => void;
+    ruleMessages: <
+      T extends import('stylelint').RuleMessages,
+      R extends { [K in keyof T]: T[K] }
+    >(
+      ruleName: string,
+      messages: T
+    ) => R;
+    validateOptions: (
+      result: import('stylelint').PostcssResult,
+      ruleName: string,
+      ...optionDescriptions: import('stylelint').RuleOptions[]
+    ) => boolean;
+    checkAgainstRule: <T_1, O extends Object>(
+      options: {
+        ruleName: string;
+        ruleSettings: import('stylelint').ConfigRuleSettings<T_1, O>;
+        root: import('stylelint/node_modules/postcss').Root;
+      },
+      callback: (
+        warning: import('stylelint/node_modules/postcss').Warning
+      ) => void
+    ) => void;
+  };
+};
+export type StylelintOptions = import('stylelint').LinterOptions;
+export type Options = import('./options').Options;

package/dist/StylelintError.js

@@ -5,32 +5,17 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 
-/** @typedef {import('stylelint').LintResult} LintResult */
-
-/** @typedef {import('./getOptions').Options} Options */
 class StylelintError extends Error {
   /**
-   * @param {Partial<string>} messages
+   * @param {string=} messages
    */
   constructor(messages) {
     super(messages);
     this.name = 'StylelintError';
     this.stack = '';
   }
-  /**
-   * @param {Options} options
-   * @param {Array<LintResult>} messages
-   * @returns {StylelintError}
-   */
-
-
-  static format({
-    formatter
-  }, messages) {
-    // @ts-ignore
-    return new StylelintError(formatter(messages));
-  }
 
 }
 
-exports.default = StylelintError;
+var _default = StylelintError;
+exports.default = _default;