stylelint-webpack-plugin 5.0.0 → 5.1.0

package/dist/utils.js

@@ -1,81 +1,81 @@
 "use strict";
 
-const {
-  resolve
-} = require('path');
+// eslint-disable-next-line jsdoc/no-restricted-syntax
+/** @typedef {any} EXPECTED_ANY */
+
 const {
   statSync
-} = require('fs');
-const normalizePath = require('normalize-path');
+} = require("node:fs");
+const {
+  resolve
+} = require("node:path");
+const normalizePath = require("normalize-path");
 
 /**
  * @template T
- * @param {T} value
- * @return {
-   T extends (null | undefined)
-     ? []
-     : T extends string
-       ? [string]
-       : T extends readonly unknown[]
-         ? T
-         : T extends Iterable<infer T>
-           ? T[]
-           : [T]
- }
+ * @typedef {T extends (null | undefined)
+ * ? []
+ * : T extends string
+ * ? [string]
+ * : T extends readonly unknown[]
+ * ? T
+ * : T extends Iterable<infer T>
+ * ? T[]
+ * : [T]} ArrifyResult
  */
+
 /* istanbul ignore next */
+/**
+ * @template T
+ * @param {T} value value
+ * @returns {ArrifyResult<T>} array of values
+ */
 function arrify(value) {
-  // eslint-disable-next-line no-undefined
   if (value === null || value === undefined) {
-    // @ts-ignore
-    return [];
+    return /** @type {ArrifyResult<T>} */[];
   }
   if (Array.isArray(value)) {
-    // @ts-ignore
-    return value;
+    return /** @type {ArrifyResult<T>} */value;
   }
-  if (typeof value === 'string') {
-    // @ts-ignore
-    return [value];
+  if (typeof value === "string") {
+    return /** @type {ArrifyResult<T>} */[value];
   }
 
-  // @ts-ignore
-  if (typeof value[Symbol.iterator] === 'function') {
-    // @ts-ignore
+  // @ts-expect-error need better types
+  if (typeof value[Symbol.iterator] === "function") {
+    // @ts-expect-error need better types
     return [...value];
   }
-
-  // @ts-ignore
-  return [value];
+  return /** @type {ArrifyResult<T>} */[value];
 }
 
 /**
- * @param {string|string[]} files
- * @param {string} context
- * @returns {string[]}
+ * @param {string | string[]} files files
+ * @param {string} context context
+ * @returns {string[]} normalized paths
  */
 function parseFiles(files, context) {
-  return arrify(files).map(( /** @type {string} */file) => normalizePath(resolve(context, file)));
+  return arrify(files).map((/** @type {string} */file) => normalizePath(resolve(context, file)));
 }
 
 /**
- * @param {string|string[]} patterns
- * @param {string|string[]} extensions
- * @returns {string[]}
+ * @param {string | string[]} patterns patterns
+ * @param {string | string[]} extensions extensions
+ * @returns {string[]} globs
  */
 function parseFoldersToGlobs(patterns, extensions = []) {
   const extensionsList = arrify(extensions);
-  const [prefix, postfix] = extensionsList.length > 1 ? ['{', '}'] : ['', ''];
-  const extensionsGlob = extensionsList.map(( /** @type {string} */extension) => extension.replace(/^\./u, '')).join(',');
-  return arrify(patterns).map(( /** @type {string} */pattern) => {
+  const [prefix, postfix] = extensionsList.length > 1 ? ["{", "}"] : ["", ""];
+  const extensionsGlob = extensionsList.map((/** @type {string} */extension) => extension.replace(/^\./u, "")).join(",");
+  return arrify(patterns).map((/** @type {string} */pattern) => {
     try {
       // The patterns are absolute because they are prepended with the context.
       const stats = statSync(pattern);
       /* istanbul ignore else */
       if (stats.isDirectory()) {
-        return pattern.replace(/[/\\]*?$/u, `/**${extensionsGlob ? `/*.${prefix + extensionsGlob + postfix}` : ''}`);
+        return pattern.replace(/[/\\]*?$/u, `/**${extensionsGlob ? `/*.${prefix + extensionsGlob + postfix}` : ""}`);
       }
-    } catch (_) {
+    } catch {
       // Return the pattern as is on error.
     }
     return pattern;
@@ -83,25 +83,25 @@ function parseFoldersToGlobs(patterns, extensions = []) {
 }
 
 /**
- *
  * @param {string} _ key, but unused
- * @param {any} value
+ * @param {EXPECTED_ANY} value value
+ * @returns {{ [x: string]: EXPECTED_ANY }} result
  */
 const jsonStringifyReplacerSortKeys = (_, value) => {
   /**
-   * @param {{ [x: string]: any; }} sorted
-   * @param {string | number} key
+   * @param {{ [x: string]: EXPECTED_ANY }} sorted sorted
+   * @param {string | number} key key
+   * @returns {{ [x: string]: EXPECTED_ANY }} result
    */
   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;
+  return value instanceof Object && !Array.isArray(value) ? Object.keys(value).sort().reduce(insert, {}) : value;
 };
 module.exports = {
   arrify,
+  jsonStringifyReplacerSortKeys,
   parseFiles,
-  parseFoldersToGlobs,
-  jsonStringifyReplacerSortKeys
+  parseFoldersToGlobs
 };

package/dist/worker.js

@@ -1,34 +1,52 @@
 "use strict";
 
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
 /** @typedef {import('./getStylelint').Stylelint} Stylelint */
 /** @typedef {import('./getStylelint').LinterOptions} StylelintOptions */
+/** @typedef {import('./getStylelint').LintResult} LintResult */
 /** @typedef {import('./options').Options} Options */
 
-Object.assign(module.exports, {
-  lintFiles,
-  setup
-});
-
-/** @type {Stylelint} */
-let stylelint;
+/** @type {string} */
+let stylelintPath = "stylelint";
 
 /** @type {Partial<StylelintOptions>} */
 let linterOptions;
 
+/** @type {Promise<Stylelint> | null} */
+let stylelintPromise = null;
+
+/**
+ * Lazily load stylelint on first use
+ * @returns {Promise<Stylelint>} stylelint instance
+ */
+async function getStylelint() {
+  if (!stylelintPromise) {
+    stylelintPromise = (async () => {
+      const mod = await (specifier => new Promise(r => r(`${specifier}`)).then(s => _interopRequireWildcard(require(s))))(stylelintPath);
+      // Handle both CJS (v13-v16) and ESM (v17) exports
+      return mod.default || mod;
+    })();
+  }
+  return stylelintPromise;
+}
+
 /**
- * @param {Options} options
- * @param {Partial<StylelintOptions>} stylelintOptions
+ * @param {Options} options the worker options
+ * @param {Partial<StylelintOptions>} stylelintOptions the stylelint options
  */
 function setup(options, stylelintOptions) {
-  stylelint = require(options.stylelintPath || 'stylelint');
+  stylelintPath = options.stylelintPath || "stylelint";
   linterOptions = stylelintOptions;
-  return stylelint;
+  // Reset cached stylelint in case path changed
+  stylelintPromise = null;
 }
 
 /**
- * @param {string | string[]} files
+ * @param {string | string[]} files files
+ * @returns {Promise<LintResult[]>} results
  */
 async function lintFiles(files) {
+  const stylelint = await getStylelint();
   const {
     results
   } = await stylelint.lint({
@@ -38,14 +56,16 @@ async function lintFiles(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
-    };
-  });
-}
+  return results.map(result => ({
+    source: result.source,
+    errored: result.errored,
+    ignored: result.ignored,
+    warnings: result.warnings,
+    deprecations: result.deprecations,
+    invalidOptionWarnings: result.invalidOptionWarnings,
+    parseErrors: result.parseErrors
+  }));
+}
+module.exports.getStylelint = getStylelint;
+module.exports.lintFiles = lintFiles;
+module.exports.setup = setup;

package/package.json

@@ -1,21 +1,29 @@
 {
   "name": "stylelint-webpack-plugin",
-  "version": "5.0.0",
+  "version": "5.1.0",
   "description": "A Stylelint plugin for webpack",
-  "license": "MIT",
-  "repository": "webpack-contrib/stylelint-webpack-plugin",
-  "author": "Ricardo Gobbo de Souza <ricardogobbosouza@yahoo.com.br>",
-  "homepage": "https://github.com/webpack-contrib/stylelint-webpack-plugin",
-  "bugs": "https://github.com/webpack-contrib/stylelint-webpack-plugin/issues",
+  "keywords": [
+    "stylelint",
+    "lint",
+    "linter",
+    "plugin",
+    "webpack"
+  ],
+  "homepage": "https://github.com/webpack/stylelint-webpack-plugin",
+  "bugs": "https://github.com/webpack/stylelint-webpack-plugin/issues",
+  "repository": "webpack/stylelint-webpack-plugin",
   "funding": {
     "type": "opencollective",
     "url": "https://opencollective.com/webpack"
   },
+  "license": "MIT",
+  "author": "Ricardo Gobbo de Souza <ricardogobbosouza@yahoo.com.br>",
   "main": "dist/index.js",
   "types": "types/index.d.ts",
-  "engines": {
-    "node": ">= 18.12.0"
-  },
+  "files": [
+    "dist",
+    "types"
+  ],
   "scripts": {
     "start": "npm run build -- -w",
     "clean": "del-cli dist types",
@@ -23,32 +31,24 @@
     "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",
+    "commitlint": "commitlint --from=main",
     "security": "npm audit",
     "lint:prettier": "prettier -w --list-different .",
-    "lint:js": "eslint --cache .",
+    "lint:code": "eslint --cache .",
     "lint:spelling": "cspell \"**/*.*\"",
     "lint:types": "tsc --pretty --noEmit",
     "lint": "npm-run-all -l -p \"lint:**\"",
-    "fix:js": "npm run lint:js -- --fix",
+    "fix:code": "npm run lint:code -- --fix",
     "fix:prettier": "npm run lint:prettier -- --write",
-    "fix": "npm-run-all -l fix:js fix:prettier",
+    "fix": "npm-run-all -l fix:code fix:prettier",
     "test:only": "cross-env NODE_OPTIONS=--experimental-vm-modules NODE_ENV=test jest --testTimeout=60000",
     "test:watch": "npm run test:only -- --watch",
     "test:coverage": "npm run test:only -- --collectCoverageFrom=\"src/**/*.js\" --coverage",
     "pretest": "npm run lint",
     "test": "npm run test:coverage",
-    "prepare": "husky install && npm run build",
+    "prepare": "husky && npm run build",
     "release": "standard-version"
   },
-  "files": [
-    "dist",
-    "types"
-  ],
-  "peerDependencies": {
-    "stylelint": "^13.0.0 || ^14.0.0 || ^15.0.0 || ^16.0.0",
-    "webpack": "^5.0.0"
-  },
   "dependencies": {
     "globby": "^11.1.0",
     "jest-worker": "^29.7.0",
@@ -57,46 +57,53 @@
     "schema-utils": "^4.2.0"
   },
   "devDependencies": {
-    "@babel/cli": "^7.23.4",
-    "@babel/core": "^7.23.7",
-    "@babel/preset-env": "^7.23.8",
-    "@commitlint/cli": "^18.6.0",
-    "@commitlint/config-conventional": "^18.6.0",
+    "@babel/cli": "^7.24.7",
+    "@babel/core": "^7.24.7",
+    "@babel/preset-env": "^7.24.7",
+    "@commitlint/cli": "^19.3.0",
+    "@commitlint/config-conventional": "^19.2.2",
+    "@eslint/js": "^9.32.0",
+    "@eslint/markdown": "^7.0.0",
+    "@stylistic/eslint-plugin": "^5.2.2",
     "@types/file-entry-cache": "^5.0.4",
     "@types/fs-extra": "^11.0.4",
-    "@types/micromatch": "^4.0.6",
-    "@types/node": "^20.11.6",
+    "@types/micromatch": "^4.0.9",
+    "@types/node": "^20.14.9",
     "@types/normalize-path": "^3.0.2",
-    "@types/webpack": "^5.28.5",
-    "@webpack-contrib/eslint-config-webpack": "^3.0.0",
-    "babel-eslint": "^10.1.0",
-    "babel-jest": "^29.7.0",
-    "chokidar": "^3.5.3",
+    "babel-jest": "^30.0.0",
+    "chokidar": "^3.6.0",
     "cross-env": "^7.0.3",
-    "cspell": "^8.3.2",
+    "cspell": "^8.10.0",
     "del": "^7.1.0",
     "del-cli": "^5.1.0",
-    "eslint": "^8.56.0",
-    "eslint-config-prettier": "^9.1.0",
-    "eslint-plugin-import": "^2.29.1",
+    "eslint": "^9.32.0",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-config-webpack": "^4.4.2",
+    "eslint-plugin-import": "^2.32.0",
+    "eslint-plugin-jest": "^29.0.1",
+    "eslint-plugin-jsdoc": "^52.0.0",
+    "eslint-plugin-n": "^17.21.0",
+    "eslint-plugin-prettier": "^5.5.3",
+    "eslint-plugin-unicorn": "^60.0.0",
     "file-loader": "^6.2.0",
     "fs-extra": "^11.2.0",
-    "husky": "^8.0.3",
-    "jest": "^29.7.0",
-    "lint-staged": "^15.2.0",
+    "husky": "^9.1.3",
+    "jest": "^30.0.0",
+    "lint-staged": "^15.2.7",
     "npm-run-all": "^4.1.5",
     "postcss-scss": "^4.0.9",
-    "prettier": "^3.2.4",
+    "prettier": "^3.3.2",
     "standard-version": "^9.5.0",
-    "stylelint": "^16.2.0",
-    "typescript": "^5.3.3",
-    "webpack": "^5.90.0"
+    "stylelint": "^17.1.0",
+    "typescript": "^5.5.3",
+    "typescript-eslint": "^8.38.0",
+    "webpack": "^5.92.1"
   },
-  "keywords": [
-    "stylelint",
-    "lint",
-    "linter",
-    "plugin",
-    "webpack"
-  ]
+  "peerDependencies": {
+    "stylelint": "^13.0.0 || ^14.0.0 || ^15.0.0 || ^16.0.0 || ^17.0.0",
+    "webpack": "^5.0.0"
+  },
+  "engines": {
+    "node": ">= 18.12.0"
+  }
 }

package/types/StylelintError.d.ts

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

package/types/getStylelint.d.ts

@@ -1,8 +1,8 @@
 export = getStylelint;
 /**
- * @param {string|undefined} key
- * @param {Options} options
- * @returns {Linter}
+ * @param {string|undefined} key a cache key
+ * @param {Options} options options
+ * @returns {Linter} linter
  */
 declare function getStylelint(
   key: string | undefined,
@@ -16,6 +16,7 @@ declare namespace getStylelint {
     LinterResult,
     Formatter,
     FormatterType,
+    RuleMeta,
     Options,
     AsyncTask,
     LintTask,
@@ -23,27 +24,28 @@ declare namespace getStylelint {
     Worker,
   };
 }
-type Options = import('./options').Options;
-type Linter = {
-  stylelint: Stylelint;
-  lintFiles: LintTask;
-  cleanup: AsyncTask;
-  threads: number;
-};
 type Stylelint = {
   lint: (options: LinterOptions) => Promise<LinterResult>;
   formatters: {
-    [k: string]: import('stylelint').Formatter;
+    [k: string]: Formatter;
   };
 };
-type LintResult = import('stylelint').LintResult;
-type LinterOptions = import('stylelint').LinterOptions;
-type LinterResult = import('stylelint').LinterResult;
-type Formatter = import('stylelint').Formatter;
-type FormatterType = import('stylelint').FormatterType;
+type LintResult = import("stylelint").LintResult;
+type LinterOptions = import("stylelint").LinterOptions;
+type LinterResult = import("stylelint").LinterResult;
+type Formatter = import("stylelint").Formatter;
+type FormatterType = import("stylelint").FormatterType;
+type RuleMeta = import("stylelint").RuleMeta;
+type Options = import("./options").Options;
 type AsyncTask = () => Promise<void>;
 type LintTask = (files: string | string[]) => Promise<LintResult[]>;
+type Linter = {
+  getStylelint: () => Promise<Stylelint>;
+  lintFiles: LintTask;
+  cleanup: AsyncTask;
+  threads: number;
+};
 type Worker = JestWorker & {
   lintFiles: LintTask;
 };
-import { Worker as JestWorker } from 'jest-worker';
+import { Worker as JestWorker } from "jest-worker";

package/types/index.d.ts

@@ -1,16 +1,16 @@
 export = StylelintWebpackPlugin;
 declare class StylelintWebpackPlugin {
   /**
-   * @param {Options} options
+   * @param {Options=} options options
    */
-  constructor(options?: Options);
+  constructor(options?: Options | undefined);
   key: string;
-  options: Partial<import('./options').PluginOptions>;
+  options: Partial<import("./options").PluginOptions>;
   /**
-   * @param {Compiler} compiler
-   * @param {Options} options
-   * @param {string[]} wanted
-   * @param {string[]} exclude
+   * @param {Compiler} compiler compiler
+   * @param {Options} options options
+   * @param {string[]} wanted wanted files
+   * @param {string[]} exclude exclude files
    */
   run(
     compiler: Compiler,
@@ -21,23 +21,22 @@ declare class StylelintWebpackPlugin {
   startTime: number;
   prevTimestamps: Map<any, any>;
   /**
-   * @param {Compiler} compiler
+   * @param {Compiler} compiler compiler
    * @returns {void}
    */
   apply(compiler: Compiler): void;
   /**
-   *
-   * @param {Compiler} compiler
-   * @returns {string}
+   * @param {Compiler} compiler compiler
+   * @returns {string} context
    */
   getContext(compiler: Compiler): string;
 }
 declare namespace StylelintWebpackPlugin {
   export { Compiler, Module, Options, FileSystemInfoEntry };
 }
-type Compiler = import('webpack').Compiler;
-type Module = import('webpack').Module;
-type Options = import('./options').Options;
+type Compiler = import("webpack").Compiler;
+type Module = import("webpack").Module;
+type Options = import("./options").Options;
 type FileSystemInfoEntry = Partial<
   | {
       timestamp: number;

package/types/linter.d.ts

@@ -1,9 +1,9 @@
 export = linter;
 /**
- * @param {string|undefined} key
- * @param {Options} options
- * @param {Compilation} compilation
- * @returns {{lint: Linter, report: Reporter, threads: number}}
+ * @param {string | undefined} key a cache key
+ * @param {Options} options options
+ * @param {Compilation} compilation compilation
+ * @returns {{ lint: Linter, report: Reporter, threads: number }} the linter with additional functions
  */
 declare function linter(
   key: string | undefined,
@@ -23,6 +23,7 @@ declare namespace linter {
     LinterResult,
     Formatter,
     FormatterType,
+    RuleMeta,
     Options,
     GenerateReport,
     Report,
@@ -31,23 +32,24 @@ declare namespace linter {
     LintResultMap,
   };
 }
-type Options = import('./options').Options;
-type Compilation = import('webpack').Compilation;
-type Linter = (files: string | string[]) => void;
-type Reporter = () => Promise<Report>;
-type Compiler = import('webpack').Compiler;
-type Stylelint = import('./getStylelint').Stylelint;
-type LintResult = import('./getStylelint').LintResult;
-type LinterResult = import('./getStylelint').LinterResult;
-type Formatter = import('./getStylelint').Formatter;
-type FormatterType = import('./getStylelint').FormatterType;
+type Compiler = import("webpack").Compiler;
+type Compilation = import("webpack").Compilation;
+type Stylelint = import("./getStylelint").Stylelint;
+type LintResult = import("./getStylelint").LintResult;
+type LinterResult = import("./getStylelint").LinterResult;
+type Formatter = import("./getStylelint").Formatter;
+type FormatterType = import("./getStylelint").FormatterType;
+type RuleMeta = import("./getStylelint").RuleMeta;
+type Options = import("./options").Options;
 type GenerateReport = (compilation: Compilation) => Promise<void>;
 type Report = {
   errors?: StylelintError;
   warnings?: StylelintError;
   generateReportAsset?: GenerateReport;
 };
+type Reporter = () => Promise<Report>;
+type Linter = (files: string | string[]) => void;
 type LintResultMap = {
-  [files: string]: import('stylelint').LintResult;
+  [files: string]: LintResult;
 };
-import StylelintError = require('./StylelintError');
+import StylelintError = require("./StylelintError");