stylelint-webpack-plugin 3.0.1 → 3.2.0

package/dist/options.js

@@ -1,19 +1,10 @@
 "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
+const {
+  validate
+} = require('schema-utils');
 
+const schema = require('./options.json');
 /** @typedef {import("stylelint")} stylelint */
 
 /** @typedef {import("stylelint").LinterOptions} StylelintOptions */
@@ -50,6 +41,8 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de
  * @param {Options} pluginOptions
  * @returns {Partial<PluginOptions>}
  */
+
+
 function getOptions(pluginOptions) {
   const options = {
     extensions: ['css', 'scss', 'sass'],
@@ -63,7 +56,7 @@ function getOptions(pluginOptions) {
     } : {})
   }; // @ts-ignore
 
-  (0, _schemaUtils.validate)(_options.default, options, {
+  validate(schema, options, {
     name: 'Stylelint Webpack Plugin',
     baseDataPath: 'options'
   });
@@ -83,7 +76,7 @@ function getStylelintOptions(pluginOptions) {
     files,
     formatter,
     ...stylelintOnlyOptions
-  } = _options.default.properties; // No need to guard the for-in because schema.properties has hardcoded keys.
+  } = 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) {
@@ -92,4 +85,9 @@ function getStylelintOptions(pluginOptions) {
   }
 
   return stylelintOptions;
-}
+}
+
+module.exports = {
+  getOptions,
+  getStylelintOptions
+};

package/dist/utils.js

@@ -1,23 +1,14 @@
 "use strict";
 
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.arrify = arrify;
-exports.parseFiles = parseFiles;
-exports.parseFoldersToGlobs = parseFoldersToGlobs;
-exports.jsonStringifyReplacerSortKeys = void 0;
+const {
+  resolve
+} = require('path');
 
-var _path = require("path");
-
-var _fs = require("fs");
-
-var _normalizePath = _interopRequireDefault(require("normalize-path"));
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-// @ts-ignore
+const {
+  statSync
+} = require('fs');
 
+const normalizePath = require('normalize-path');
 /**
  * @template T
  * @param {T} value
@@ -33,6 +24,10 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de
            : [T]
  }
  */
+
+/* istanbul ignore next */
+
+
 function arrify(value) {
   // eslint-disable-next-line no-undefined
   if (value === null || value === undefined) {
@@ -69,7 +64,7 @@ function arrify(value) {
 function parseFiles(files, context) {
   return arrify(files).map((
   /** @type {string} */
-  file) => (0, _normalizePath.default)((0, _path.resolve)(context, file)));
+  file) => normalizePath(resolve(context, file)));
 }
 /**
  * @param {string|string[]} patterns
@@ -89,7 +84,7 @@ function parseFoldersToGlobs(patterns, extensions = []) {
   pattern) => {
     try {
       // The patterns are absolute because they are prepended with the context.
-      const stats = (0, _fs.statSync)(pattern);
+      const stats = statSync(pattern);
       /* istanbul ignore else */
 
       if (stats.isDirectory()) {
@@ -122,4 +117,9 @@ const jsonStringifyReplacerSortKeys = (_, value) => {
   return value instanceof Object && !(value instanceof Array) ? Object.keys(value).sort().reduce(insert, {}) : value;
 };
 
-exports.jsonStringifyReplacerSortKeys = jsonStringifyReplacerSortKeys;
+module.exports = {
+  arrify,
+  parseFiles,
+  parseFoldersToGlobs,
+  jsonStringifyReplacerSortKeys
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "stylelint-webpack-plugin",
-  "version": "3.0.1",
+  "version": "3.2.0",
   "description": "A Stylelint plugin for webpack",
   "license": "MIT",
   "repository": "webpack-contrib/stylelint-webpack-plugin",
@@ -11,16 +11,16 @@
     "type": "opencollective",
     "url": "https://opencollective.com/webpack"
   },
-  "main": "dist/cjs.js",
-  "types": "declarations/index.d.ts",
+  "main": "dist/index.js",
+  "types": "types/index.d.ts",
   "engines": {
     "node": ">= 12.13.0"
   },
   "scripts": {
     "start": "npm run build -- -w",
-    "clean": "del-cli dist declarations",
+    "clean": "del-cli dist types",
     "prebuild": "npm run clean",
-    "build:types": "tsc --declaration --emitDeclarationOnly --outDir declarations && prettier \"declarations/**/*.ts\" --write",
+    "build:types": "tsc --declaration --emitDeclarationOnly --outDir types && prettier \"types/**/*.ts\" --write",
     "build:code": "cross-env NODE_ENV=production babel src -d dist --copy-files",
     "build": "npm-run-all -p \"build:**\"",
     "commitlint": "commitlint --from=master",
@@ -39,51 +39,51 @@
   },
   "files": [
     "dist",
-    "declarations"
+    "types"
   ],
   "peerDependencies": {
-    "stylelint": "^13.0.0",
+    "stylelint": "^13.0.0 || ^14.0.0",
     "webpack": "^5.0.0"
   },
   "dependencies": {
-    "@types/stylelint": "^13.13.1",
-    "jest-worker": "^27.0.6",
-    "globby": "^11.0.4",
+    "jest-worker": "^27.5.1",
+    "globby": "^11.1.0",
     "micromatch": "^4.0.4",
     "normalize-path": "^3.0.0",
-    "schema-utils": "^3.1.0"
+    "schema-utils": "^4.0.0"
   },
   "devDependencies": {
-    "@babel/cli": "^7.14.5",
-    "@babel/core": "^7.14.6",
-    "@babel/preset-env": "^7.14.7",
-    "@commitlint/cli": "^12.1.4",
-    "@commitlint/config-conventional": "^12.1.4",
-    "@types/fs-extra": "^9.0.12",
+    "@babel/cli": "^7.17.6",
+    "@babel/core": "^7.17.7",
+    "@babel/preset-env": "^7.16.11",
+    "@commitlint/cli": "^16.2.3",
+    "@commitlint/config-conventional": "^16.2.1",
+    "@types/fs-extra": "^9.0.13",
     "@types/micromatch": "^4.0.2",
     "@types/normalize-path": "^3.0.0",
     "@types/webpack": "^5.28.0",
     "@webpack-contrib/eslint-config-webpack": "^3.0.0",
     "babel-eslint": "^10.1.0",
-    "babel-jest": "^27.0.6",
+    "babel-jest": "^27.5.1",
     "chokidar": "^3.5.2",
     "cross-env": "^7.0.3",
     "del": "^6.0.0",
-    "del-cli": "^4.0.0",
-    "eslint": "^7.30.0",
-    "eslint-config-prettier": "^8.3.0",
-    "eslint-plugin-import": "^2.23.4",
+    "del-cli": "^4.0.1",
+    "eslint": "^8.11.0",
+    "eslint-config-prettier": "^8.5.0",
+    "eslint-plugin-import": "^2.25.4",
     "file-loader": "^6.2.0",
-    "fs-extra": "^10.0.0",
-    "husky": "^7.0.1",
-    "jest": "^27.0.6",
-    "lint-staged": "^11.0.0",
+    "fs-extra": "^10.0.1",
+    "husky": "^7.0.4",
+    "jest": "^27.5.1",
+    "lint-staged": "^12.3.6",
     "npm-run-all": "^4.1.5",
-    "prettier": "^2.3.2",
-    "standard-version": "^9.3.0",
-    "stylelint": "^13.13.1",
-    "typescript": "^4.3.5",
-    "webpack": "^5.44.0"
+    "postcss-scss": "^4.0.3",
+    "prettier": "^2.6.0",
+    "standard-version": "^9.3.2",
+    "stylelint": "^14.6.0",
+    "typescript": "^4.6.2",
+    "webpack": "^5.70.0"
   },
   "keywords": [
     "stylelint",

package/types/StylelintError.d.ts

@@ -0,0 +1,8 @@
+export = StylelintError;
+declare class StylelintError extends Error {
+  /**
+   * @param {string=} messages
+   */
+  constructor(messages?: string | undefined);
+  stack: string;
+}

package/types/getStylelint.d.ts

@@ -0,0 +1,91 @@
+/// <reference types="stylelint" />
+export = getStylelint;
+/**
+ * @param {string|undefined} key
+ * @param {Options} options
+ * @returns {Linter}
+ */
+declare function getStylelint(
+  key: string | undefined,
+  { threads, ...options }: Options
+): Linter;
+declare namespace getStylelint {
+  export {
+    Stylelint,
+    LintResult,
+    Options,
+    AsyncTask,
+    LintTask,
+    Linter,
+    Worker,
+  };
+}
+type Options = import('./options').Options;
+type Linter = {
+  api: import('stylelint').InternalApi;
+  stylelint: Stylelint;
+  lintFiles: LintTask;
+  cleanup: AsyncTask;
+  threads: number;
+};
+type Stylelint = import('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;
+  resolveConfig: (
+    filePath: string,
+    options?:
+      | Pick<
+          import('stylelint').LinterOptions,
+          'cwd' | 'config' | 'configFile' | 'configBasedir'
+        >
+      | undefined
+  ) => Promise<import('stylelint').Config | undefined>;
+  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('postcss').Root;
+      },
+      callback: (warning: import('postcss').Warning) => void
+    ) => void;
+  };
+};
+type LintResult = import('stylelint').LintResult;
+type AsyncTask = () => Promise<void>;
+type LintTask = (files: string | string[]) => Promise<LintResult[]>;
+type Worker = import('jest-worker').Worker & {
+  lintFiles: LintTask;
+};

package/{declarations → types}/index.d.ts

@@ -1,13 +1,4 @@
-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
->;
+export = StylelintWebpackPlugin;
 declare class StylelintWebpackPlugin {
   /**
    * @param {Options} options
@@ -33,3 +24,15 @@ declare class StylelintWebpackPlugin {
    */
   getContext(compiler: Compiler): string;
 }
+declare namespace StylelintWebpackPlugin {
+  export { Compiler, Module, Options, FileSystemInfoEntry };
+}
+type Compiler = import('webpack').Compiler;
+type Options = import('./options').Options;
+type Module = import('webpack').Module;
+type FileSystemInfoEntry = Partial<
+  | {
+      timestamp: number;
+    }
+  | number
+>;

package/types/linter.d.ts

@@ -0,0 +1,109 @@
+/// <reference types="stylelint" />
+export = linter;
+/**
+ * @param {string|undefined} key
+ * @param {Options} options
+ * @param {Compilation} compilation
+ * @returns {{api: InternalApi, lint: Linter, report: Reporter, threads: number}}
+ */
+declare function linter(
+  key: string | undefined,
+  options: Options,
+  compilation: Compilation
+): {
+  api: InternalApi;
+  lint: Linter;
+  report: Reporter;
+  threads: number;
+};
+declare namespace linter {
+  export {
+    Stylelint,
+    LintResult,
+    InternalApi,
+    Compiler,
+    Compilation,
+    Options,
+    FormatterType,
+    FormatterFunction,
+    GenerateReport,
+    Report,
+    Reporter,
+    Linter,
+    LintResultMap,
+  };
+}
+type Options = import('./options').Options;
+type Compilation = import('webpack').Compilation;
+type InternalApi = import('stylelint').InternalApi;
+type Linter = (files: string | string[]) => void;
+type Reporter = () => Promise<Report>;
+type Stylelint = import('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;
+  resolveConfig: (
+    filePath: string,
+    options?:
+      | Pick<
+          import('stylelint').LinterOptions,
+          'cwd' | 'config' | 'configFile' | 'configBasedir'
+        >
+      | undefined
+  ) => Promise<import('stylelint').Config | undefined>;
+  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('postcss').Root;
+      },
+      callback: (warning: import('postcss').Warning) => void
+    ) => void;
+  };
+};
+type LintResult = import('stylelint').LintResult;
+type Compiler = import('webpack').Compiler;
+type FormatterType = import('./options').FormatterType;
+type FormatterFunction = (results: LintResult[]) => string;
+type GenerateReport = (compilation: Compilation) => Promise<void>;
+type Report = {
+  errors?: StylelintError;
+  warnings?: StylelintError;
+  generateReportAsset?: GenerateReport;
+};
+type LintResultMap = {
+  [files: string]: import('stylelint').LintResult;
+};
+import StylelintError = require('./StylelintError');

package/{declarations → types}/options.d.ts

@@ -1,3 +1,82 @@
+/// <reference types="stylelint" />
+export type stylelint = import('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;
+  resolveConfig: (
+    filePath: string,
+    options?:
+      | Pick<
+          import('stylelint').LinterOptions,
+          'cwd' | 'config' | 'configFile' | 'configBasedir'
+        >
+      | undefined
+  ) => Promise<import('stylelint').Config | undefined>;
+  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('postcss').Root;
+      },
+      callback: (warning: import('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>;
 /** @typedef {import("stylelint")} stylelint */
 /** @typedef {import("stylelint").LinterOptions} StylelintOptions */
 /** @typedef {import("stylelint").FormatterType} FormatterType */
@@ -36,27 +115,3 @@ export function getOptions(pluginOptions: Options): Partial<PluginOptions>;
 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 → types}/utils.d.ts

@@ -39,4 +39,9 @@ export function parseFoldersToGlobs(
   patterns: string | string[],
   extensions?: string | string[]
 ): string[];
+/**
+ *
+ * @param {string} _ key, but unused
+ * @param {any} value
+ */
 export function jsonStringifyReplacerSortKeys(_: string, value: any): any;

package/types/worker.d.ts

@@ -0,0 +1,58 @@
+/// <reference types="stylelint" />
+export type Stylelint = import('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;
+  resolveConfig: (
+    filePath: string,
+    options?:
+      | Pick<
+          import('stylelint').LinterOptions,
+          'cwd' | 'config' | 'configFile' | 'configBasedir'
+        >
+      | undefined
+  ) => Promise<import('stylelint').Config | undefined>;
+  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('postcss').Root;
+      },
+      callback: (warning: import('postcss').Warning) => void
+    ) => void;
+  };
+};
+export type StylelintOptions = import('stylelint').LinterOptions;
+export type Options = import('./options').Options;

package/declarations/StylelintError.d.ts

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

package/declarations/cjs.d.ts

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