stylelint - npm Package Compare versions

Comparing version 14.14.1 to 14.15.0

lib/cli.js

@@ -7,2 +7,3 @@ 'use strict';
 const { red, dim } = require('picocolors');
+const { isPlainObject } = require('./utils/validateTypes');
 
@@ -51,2 +52,3 @@ const checkInvalidCLIOptions = require('./utils/checkInvalidCLIOptions');
  * @property {boolean} [allowEmptyInput]
+ * @property {string} [globbyOptions]
  */
@@ -77,2 +79,3 @@
  * @property {boolean} [fix]
+ * @property {Record<string, unknown>} [globbyOptions]
  * @property {boolean} [ignoreDisables]
@@ -242,2 +245,6 @@ * @property {any} [ignorePath]
         When glob pattern matches no files, the process will exit without throwing an error.
+
+      --globby-options, --go
+
+        Options in JSON format passed to globby.
 	`,
@@ -344,2 +351,6 @@ flags: {
 		},
+		globbyOptions: {
+			alias: 'go',
+			type: 'string',
+		},
 	},
@@ -405,2 +416,17 @@ };
 
+	if (cli.flags.globbyOptions) {
+		try {
+			optionsBase.globbyOptions = await parseGlobbyOptions(cli.flags.globbyOptions);
+		} catch (error) {
+			if (typeof error === 'string') {
+				process.stderr.write(`${error}${EOL}`);
+				process.exitCode = EXIT_CODE_ERROR;
+
+				return;
+			}
+
+			throw error;
+		}
+	}
+
 	if (cli.flags.stdinFilename) {
@@ -552,2 +578,26 @@ optionsBase.codeFilename = cli.flags.stdinFilename;
 /**
+ * @param {string} value
+ * @returns {Promise<Record<string, unknown>>}
+ */
+function parseGlobbyOptions(value) {
+	const errorMessage = () =>
+		`Invalid option ${red('"--globby-options"')}.` +
+		` The value ${red(`"${value}"`)} is not valid JSON object.`;
+
+	let options;
+
+	try {
+		options = JSON.parse(value);
+	} catch (_) {
+		return Promise.reject(errorMessage());
+	}
+
+	if (isPlainObject(options)) {
+		return Promise.resolve(options);
+	}
+
+	return Promise.reject(errorMessage());
+}
+
+/**
  * @param {string[]} argv
@@ -554,0 +604,0 @@ * @returns {CLIOptions}

lib/formatters/index.js

 'use strict';
 
-const _importLazy = require('import-lazy');
+const importLazy = require('import-lazy');
 
-const importLazy = _importLazy(require);
-
 /** @type {typeof import('stylelint').formatters} */
 const formatters = {
-	compact: importLazy('./compactFormatter'),
-	github: importLazy('./githubFormatter'),
-	json: importLazy('./jsonFormatter'),
-	string: importLazy('./stringFormatter'),
-	tap: importLazy('./tapFormatter'),
-	unix: importLazy('./unixFormatter'),
-	verbose: importLazy('./verboseFormatter'),
+	compact: importLazy(() => require('./compactFormatter'))(),
+	github: importLazy(() => require('./githubFormatter'))(),
+	json: importLazy(() => require('./jsonFormatter'))(),
+	string: importLazy(() => require('./stringFormatter'))(),
+	tap: importLazy(() => require('./tapFormatter'))(),
+	unix: importLazy(() => require('./unixFormatter'))(),
+	verbose: importLazy(() => require('./verboseFormatter'))(),
 };
 
 module.exports = formatters;

lib/formatters/stringFormatter.js

@@ -304,6 +304,5 @@ 'use strict';
 		if (total > 0) {
-			const tally =
-				`${total} ${pluralize('problem', total)}` +
-				` (${errorCount} ${pluralize('error', errorCount)}` +
-				`, ${warningCount} ${pluralize('warning', warningCount)})`;
+			const error = red(`${errorCount} ${pluralize('error', errorCount)}`);
+			const warning = yellow(`${warningCount} ${pluralize('warning', warningCount)}`);
+			const tally = `${total} ${pluralize('problem', total)} (${error}, ${warning})`;
 
@@ -310,0 +309,0 @@ output += `${tally}\n\n`;

lib/lintPostcssResult.js

@@ -7,2 +7,3 @@ 'use strict';
 const rules = require('./rules');
+const getStylelintRule = require('./utils/getStylelintRule');
 
@@ -66,4 +67,3 @@ /** @typedef {import('stylelint').LinterOptions} LinterOptions */
 	for (const ruleName of ruleNames) {
-		const ruleFunction =
-			rules[ruleName] || (config.pluginFunctions && config.pluginFunctions[ruleName]);
+		const ruleFunction = getStylelintRule(ruleName, config);
 
@@ -70,0 +70,0 @@ if (ruleFunction === undefined) {

lib/normalizeAllRuleSettings.js

 'use strict';
 
 const normalizeRuleSettings = require('./normalizeRuleSettings');
-const rules = require('./rules');
+const getStylelintRule = require('./utils/getStylelintRule');
 
@@ -20,10 +20,6 @@ /** @typedef {import('stylelint').ConfigRules} StylelintConfigRules */
 	for (const [ruleName, rawRuleSettings] of Object.entries(config.rules)) {
-		const rule = rules[ruleName] || (config.pluginFunctions && config.pluginFunctions[ruleName]);
+		const rule = getStylelintRule(ruleName, config);
 
 		if (rule) {
-			normalizedRules[ruleName] = normalizeRuleSettings(
-				rawRuleSettings,
-				ruleName,
-				rule.primaryOptionArray,
-			);
+			normalizedRules[ruleName] = normalizeRuleSettings(rawRuleSettings, rule);
 		} else {
@@ -30,0 +26,0 @@ normalizedRules[ruleName] = [];

lib/normalizeRuleSettings.js

 'use strict';
 
-const rules = require('./rules');
 const { isPlainObject } = require('./utils/validateTypes');
@@ -22,13 +21,6 @@
  * @param {import('stylelint').ConfigRuleSettings<T, O>} rawSettings
- * @param {string} ruleName
- * @param {boolean} [primaryOptionArray] If primaryOptionArray is not provided, we try to get it from the rules themselves, which will not work for plugins
+ * @param {import('stylelint').Rule<T, O>} [rule]
  * @return {[T] | [T, O] | null}
  */
-module.exports = function normalizeRuleSettings(
-	rawSettings,
-	ruleName,
-	// If primaryOptionArray is not provided, we try to get it from the
-	// rules themselves, which will not work for plugins
-	primaryOptionArray,
-) {
+module.exports = function normalizeRuleSettings(rawSettings, rule) {
 	if (rawSettings === null || rawSettings === undefined) {
@@ -43,15 +35,9 @@ return null;
 
-	if (rawSettings.length > 0 && (rawSettings[0] === null || rawSettings[0] === undefined)) {
+	const [primary, secondary] = rawSettings;
+
+	if (rawSettings.length > 0 && (primary === null || primary === undefined)) {
 		return null;
 	}
 
-	if (primaryOptionArray === undefined) {
-		const rule = rules[ruleName];
-
-		if (rule && 'primaryOptionArray' in rule) {
-			primaryOptionArray = rule.primaryOptionArray;
-		}
-	}
-
-	if (!primaryOptionArray) {
+	if (rule && !rule.primaryOptionArray) {
 		return rawSettings;
@@ -63,7 +49,7 @@ }
 
-	if (rawSettings.length === 1 && Array.isArray(rawSettings[0])) {
+	if (rawSettings.length === 1 && Array.isArray(primary)) {
 		return rawSettings;
 	}
 
-	if (rawSettings.length === 2 && !isPlainObject(rawSettings[0]) && isPlainObject(rawSettings[1])) {
+	if (rawSettings.length === 2 && !isPlainObject(primary) && isPlainObject(secondary)) {
 		return rawSettings;
@@ -70,0 +56,0 @@ }

lib/rules/at-rule-disallowed-list/index.js

@@ -46,3 +46,4 @@ 'use strict';
 			report({
-				message: messages.rejected(name),
+				message: messages.rejected,
+				messageArgs: [name],
 				node: atRule,
@@ -49,0 +50,0 @@ result,

lib/rules/declaration-property-unit-disallowed-list/index.js

@@ -78,3 +78,4 @@ 'use strict';
 				report({
-					message: messages.rejected(prop, unit),
+					message: messages.rejected,
+					messageArgs: [prop, unit],
 					node: decl,
@@ -81,0 +82,0 @@ index,

lib/rules/declaration-property-value-disallowed-list/index.js

@@ -55,3 +55,4 @@ 'use strict';
 			report({
-				message: messages.rejected(prop, value),
+				message: messages.rejected,
+				messageArgs: [prop, value],
 				node: decl,
@@ -58,0 +59,0 @@ index,

lib/rules/function-disallowed-list/index.js

@@ -53,3 +53,4 @@ 'use strict';
 				report({
-					message: messages.rejected(node.value),
+					message: messages.rejected,
+					messageArgs: [node.value],
 					node: decl,
@@ -56,0 +57,0 @@ index,

lib/rules/index.js

 'use strict';
 
-const _importLazy = require('import-lazy');
+const importLazy = require('import-lazy');
 
-const importLazy = _importLazy(require);
-
 /** @type {typeof import('stylelint').rules} */
 const rules = {
-	'alpha-value-notation': importLazy('./alpha-value-notation'),
-	'annotation-no-unknown': importLazy('./annotation-no-unknown'),
-	'at-rule-allowed-list': importLazy('./at-rule-allowed-list'),
-	'at-rule-disallowed-list': importLazy('./at-rule-disallowed-list'),
-	'at-rule-empty-line-before': importLazy('./at-rule-empty-line-before'),
-	'at-rule-name-case': importLazy('./at-rule-name-case'),
-	'at-rule-name-newline-after': importLazy('./at-rule-name-newline-after'),
-	'at-rule-semicolon-space-before': importLazy('./at-rule-semicolon-space-before'),
-	'at-rule-name-space-after': importLazy('./at-rule-name-space-after'),
-	'at-rule-no-unknown': importLazy('./at-rule-no-unknown'),
-	'at-rule-no-vendor-prefix': importLazy('./at-rule-no-vendor-prefix'),
-	'at-rule-property-required-list': importLazy('./at-rule-property-required-list'),
-	'at-rule-semicolon-newline-after': importLazy('./at-rule-semicolon-newline-after'),
-	'block-closing-brace-empty-line-before': importLazy('./block-closing-brace-empty-line-before'),
-	'block-closing-brace-newline-after': importLazy('./block-closing-brace-newline-after'),
-	'block-closing-brace-newline-before': importLazy('./block-closing-brace-newline-before'),
-	'block-closing-brace-space-after': importLazy('./block-closing-brace-space-after'),
-	'block-closing-brace-space-before': importLazy('./block-closing-brace-space-before'),
-	'block-no-empty': importLazy('./block-no-empty'),
-	'block-opening-brace-newline-after': importLazy('./block-opening-brace-newline-after'),
-	'block-opening-brace-newline-before': importLazy('./block-opening-brace-newline-before'),
-	'block-opening-brace-space-after': importLazy('./block-opening-brace-space-after'),
-	'block-opening-brace-space-before': importLazy('./block-opening-brace-space-before'),
-	'color-function-notation': importLazy('./color-function-notation'),
-	'color-hex-alpha': importLazy('./color-hex-alpha'),
-	'color-hex-case': importLazy('./color-hex-case'),
-	'color-hex-length': importLazy('./color-hex-length'),
-	'color-named': importLazy('./color-named'),
-	'color-no-hex': importLazy('./color-no-hex'),
-	'color-no-invalid-hex': importLazy('./color-no-invalid-hex'),
-	'comment-empty-line-before': importLazy('./comment-empty-line-before'),
-	'comment-no-empty': importLazy('./comment-no-empty'),
-	'comment-pattern': importLazy('./comment-pattern'),
-	'comment-whitespace-inside': importLazy('./comment-whitespace-inside'),
-	'comment-word-disallowed-list': importLazy('./comment-word-disallowed-list'),
-	'custom-media-pattern': importLazy('./custom-media-pattern'),
-	'custom-property-empty-line-before': importLazy('./custom-property-empty-line-before'),
-	'custom-property-no-missing-var-function': importLazy(
-		'./custom-property-no-missing-var-function',
-	),
-	'custom-property-pattern': importLazy('./custom-property-pattern'),
-	'declaration-bang-space-after': importLazy('./declaration-bang-space-after'),
-	'declaration-bang-space-before': importLazy('./declaration-bang-space-before'),
-	'declaration-block-no-duplicate-custom-properties': importLazy(
-		'./declaration-block-no-duplicate-custom-properties',
-	),
-	'declaration-block-no-duplicate-properties': importLazy(
-		'./declaration-block-no-duplicate-properties',
-	),
-	'declaration-block-no-redundant-longhand-properties': importLazy(
-		'./declaration-block-no-redundant-longhand-properties',
-	),
-	'declaration-block-no-shorthand-property-overrides': importLazy(
-		'./declaration-block-no-shorthand-property-overrides',
-	),
-	'declaration-block-semicolon-newline-after': importLazy(
-		'./declaration-block-semicolon-newline-after',
-	),
-	'declaration-block-semicolon-newline-before': importLazy(
-		'./declaration-block-semicolon-newline-before',
-	),
-	'declaration-block-semicolon-space-after': importLazy(
-		'./declaration-block-semicolon-space-after',
-	),
-	'declaration-block-semicolon-space-before': importLazy(
-		'./declaration-block-semicolon-space-before',
-	),
-	'declaration-block-single-line-max-declarations': importLazy(
-		'./declaration-block-single-line-max-declarations',
-	),
-	'declaration-block-trailing-semicolon': importLazy('./declaration-block-trailing-semicolon'),
-	'declaration-colon-newline-after': importLazy('./declaration-colon-newline-after'),
-	'declaration-colon-space-after': importLazy('./declaration-colon-space-after'),
-	'declaration-colon-space-before': importLazy('./declaration-colon-space-before'),
-	'declaration-empty-line-before': importLazy('./declaration-empty-line-before'),
-	'declaration-no-important': importLazy('./declaration-no-important'),
-	'declaration-property-max-values': importLazy('./declaration-property-max-values'),
-	'declaration-property-unit-allowed-list': importLazy('./declaration-property-unit-allowed-list'),
-	'declaration-property-unit-disallowed-list': importLazy(
-		'./declaration-property-unit-disallowed-list',
-	),
-	'declaration-property-value-allowed-list': importLazy(
-		'./declaration-property-value-allowed-list',
-	),
-	'declaration-property-value-disallowed-list': importLazy(
-		'./declaration-property-value-disallowed-list',
-	),
-	'font-family-no-missing-generic-family-keyword': importLazy(
-		'./font-family-no-missing-generic-family-keyword',
-	),
-	'font-family-name-quotes': importLazy('./font-family-name-quotes'),
-	'font-family-no-duplicate-names': importLazy('./font-family-no-duplicate-names'),
-	'font-weight-notation': importLazy('./font-weight-notation'),
-	'function-allowed-list': importLazy('./function-allowed-list'),
-	'function-calc-no-unspaced-operator': importLazy('./function-calc-no-unspaced-operator'),
-	'function-comma-newline-after': importLazy('./function-comma-newline-after'),
-	'function-comma-newline-before': importLazy('./function-comma-newline-before'),
-	'function-comma-space-after': importLazy('./function-comma-space-after'),
-	'function-comma-space-before': importLazy('./function-comma-space-before'),
-	'function-disallowed-list': importLazy('./function-disallowed-list'),
-	'function-linear-gradient-no-nonstandard-direction': importLazy(
-		'./function-linear-gradient-no-nonstandard-direction',
-	),
-	'function-max-empty-lines': importLazy('./function-max-empty-lines'),
-	'function-name-case': importLazy('./function-name-case'),
-	'function-no-unknown': importLazy('./function-no-unknown'),
-	'function-parentheses-newline-inside': importLazy('./function-parentheses-newline-inside'),
-	'function-parentheses-space-inside': importLazy('./function-parentheses-space-inside'),
-	'function-url-no-scheme-relative': importLazy('./function-url-no-scheme-relative'),
-	'function-url-quotes': importLazy('./function-url-quotes'),
-	'function-url-scheme-allowed-list': importLazy('./function-url-scheme-allowed-list'),
-	'function-url-scheme-disallowed-list': importLazy('./function-url-scheme-disallowed-list'),
-	'function-whitespace-after': importLazy('./function-whitespace-after'),
-	'hue-degree-notation': importLazy('./hue-degree-notation'),
-	'import-notation': importLazy('./import-notation'),
-	'keyframe-block-no-duplicate-selectors': importLazy('./keyframe-block-no-duplicate-selectors'),
-	'keyframe-declaration-no-important': importLazy('./keyframe-declaration-no-important'),
-	'keyframe-selector-notation': importLazy('./keyframe-selector-notation'),
-	'keyframes-name-pattern': importLazy('./keyframes-name-pattern'),
-	'length-zero-no-unit': importLazy('./length-zero-no-unit'),
-	linebreaks: importLazy('./linebreaks'),
-	'max-empty-lines': importLazy('./max-empty-lines'),
-	'max-line-length': importLazy('./max-line-length'),
-	'max-nesting-depth': importLazy('./max-nesting-depth'),
-	'media-feature-colon-space-after': importLazy('./media-feature-colon-space-after'),
-	'media-feature-colon-space-before': importLazy('./media-feature-colon-space-before'),
-	'media-feature-name-allowed-list': importLazy('./media-feature-name-allowed-list'),
-	'media-feature-name-case': importLazy('./media-feature-name-case'),
-	'media-feature-name-disallowed-list': importLazy('./media-feature-name-disallowed-list'),
-	'media-feature-name-no-unknown': importLazy('./media-feature-name-no-unknown'),
-	'media-feature-name-no-vendor-prefix': importLazy('./media-feature-name-no-vendor-prefix'),
-	'media-feature-name-value-allowed-list': importLazy('./media-feature-name-value-allowed-list'),
-	'media-feature-parentheses-space-inside': importLazy('./media-feature-parentheses-space-inside'),
-	'media-feature-range-operator-space-after': importLazy(
-		'./media-feature-range-operator-space-after',
-	),
-	'media-feature-range-operator-space-before': importLazy(
-		'./media-feature-range-operator-space-before',
-	),
-	'media-query-list-comma-newline-after': importLazy('./media-query-list-comma-newline-after'),
-	'media-query-list-comma-newline-before': importLazy('./media-query-list-comma-newline-before'),
-	'media-query-list-comma-space-after': importLazy('./media-query-list-comma-space-after'),
-	'media-query-list-comma-space-before': importLazy('./media-query-list-comma-space-before'),
-	'named-grid-areas-no-invalid': importLazy('./named-grid-areas-no-invalid'),
-	'no-descending-specificity': importLazy('./no-descending-specificity'),
-	'no-duplicate-at-import-rules': importLazy('./no-duplicate-at-import-rules'),
-	'no-duplicate-selectors': importLazy('./no-duplicate-selectors'),
-	'no-empty-source': importLazy('./no-empty-source'),
-	'no-empty-first-line': importLazy('./no-empty-first-line'),
-	'no-eol-whitespace': importLazy('./no-eol-whitespace'),
-	'no-extra-semicolons': importLazy('./no-extra-semicolons'),
-	'no-invalid-double-slash-comments': importLazy('./no-invalid-double-slash-comments'),
-	'no-invalid-position-at-import-rule': importLazy('./no-invalid-position-at-import-rule'),
-	'no-irregular-whitespace': importLazy('./no-irregular-whitespace'),
-	'no-missing-end-of-source-newline': importLazy('./no-missing-end-of-source-newline'),
-	'no-unknown-animations': importLazy('./no-unknown-animations'),
-	'number-leading-zero': importLazy('./number-leading-zero'),
-	'number-max-precision': importLazy('./number-max-precision'),
-	'number-no-trailing-zeros': importLazy('./number-no-trailing-zeros'),
-	'property-allowed-list': importLazy('./property-allowed-list'),
-	'property-case': importLazy('./property-case'),
-	'property-disallowed-list': importLazy('./property-disallowed-list'),
-	'property-no-unknown': importLazy('./property-no-unknown'),
-	'property-no-vendor-prefix': importLazy('./property-no-vendor-prefix'),
-	'rule-empty-line-before': importLazy('./rule-empty-line-before'),
-	'rule-selector-property-disallowed-list': importLazy('./rule-selector-property-disallowed-list'),
-	'selector-attribute-brackets-space-inside': importLazy(
-		'./selector-attribute-brackets-space-inside',
-	),
-	'selector-attribute-name-disallowed-list': importLazy(
-		'./selector-attribute-name-disallowed-list',
-	),
-	'selector-attribute-operator-allowed-list': importLazy(
-		'./selector-attribute-operator-allowed-list',
-	),
-	'selector-attribute-operator-disallowed-list': importLazy(
-		'./selector-attribute-operator-disallowed-list',
-	),
-	'selector-attribute-operator-space-after': importLazy(
-		'./selector-attribute-operator-space-after',
-	),
-	'selector-attribute-operator-space-before': importLazy(
-		'./selector-attribute-operator-space-before',
-	),
-	'selector-attribute-quotes': importLazy('./selector-attribute-quotes'),
-	'selector-class-pattern': importLazy('./selector-class-pattern'),
-	'selector-combinator-allowed-list': importLazy('./selector-combinator-allowed-list'),
-	'selector-combinator-disallowed-list': importLazy('./selector-combinator-disallowed-list'),
-	'selector-combinator-space-after': importLazy('./selector-combinator-space-after'),
-	'selector-combinator-space-before': importLazy('./selector-combinator-space-before'),
-	'selector-descendant-combinator-no-non-space': importLazy(
-		'./selector-descendant-combinator-no-non-space',
-	),
-	'selector-disallowed-list': importLazy('./selector-disallowed-list'),
-	'selector-id-pattern': importLazy('./selector-id-pattern'),
-	'selector-list-comma-newline-after': importLazy('./selector-list-comma-newline-after'),
-	'selector-list-comma-newline-before': importLazy('./selector-list-comma-newline-before'),
-	'selector-list-comma-space-after': importLazy('./selector-list-comma-space-after'),
-	'selector-list-comma-space-before': importLazy('./selector-list-comma-space-before'),
-	'selector-max-attribute': importLazy('./selector-max-attribute'),
-	'selector-max-class': importLazy('./selector-max-class'),
-	'selector-max-combinators': importLazy('./selector-max-combinators'),
-	'selector-max-compound-selectors': importLazy('./selector-max-compound-selectors'),
-	'selector-max-empty-lines': importLazy('./selector-max-empty-lines'),
-	'selector-max-id': importLazy('./selector-max-id'),
-	'selector-max-pseudo-class': importLazy('./selector-max-pseudo-class'),
-	'selector-max-specificity': importLazy('./selector-max-specificity'),
-	'selector-max-type': importLazy('./selector-max-type'),
-	'selector-max-universal': importLazy('./selector-max-universal'),
-	'selector-nested-pattern': importLazy('./selector-nested-pattern'),
-	'selector-no-qualifying-type': importLazy('./selector-no-qualifying-type'),
-	'selector-no-vendor-prefix': importLazy('./selector-no-vendor-prefix'),
-	'selector-not-notation': importLazy('./selector-not-notation'),
-	'selector-pseudo-class-allowed-list': importLazy('./selector-pseudo-class-allowed-list'),
-	'selector-pseudo-class-case': importLazy('./selector-pseudo-class-case'),
-	'selector-pseudo-class-disallowed-list': importLazy('./selector-pseudo-class-disallowed-list'),
-	'selector-pseudo-class-no-unknown': importLazy('./selector-pseudo-class-no-unknown'),
-	'selector-pseudo-class-parentheses-space-inside': importLazy(
-		'./selector-pseudo-class-parentheses-space-inside',
-	),
-	'selector-pseudo-element-allowed-list': importLazy('./selector-pseudo-element-allowed-list'),
-	'selector-pseudo-element-case': importLazy('./selector-pseudo-element-case'),
-	'selector-pseudo-element-colon-notation': importLazy('./selector-pseudo-element-colon-notation'),
-	'selector-pseudo-element-disallowed-list': importLazy(
-		'./selector-pseudo-element-disallowed-list',
-	),
-	'selector-pseudo-element-no-unknown': importLazy('./selector-pseudo-element-no-unknown'),
-	'selector-type-case': importLazy('./selector-type-case'),
-	'selector-type-no-unknown': importLazy('./selector-type-no-unknown'),
-	'shorthand-property-no-redundant-values': importLazy('./shorthand-property-no-redundant-values'),
-	'string-no-newline': importLazy('./string-no-newline'),
-	'string-quotes': importLazy('./string-quotes'),
-	'time-min-milliseconds': importLazy('./time-min-milliseconds'),
-	'unicode-bom': importLazy('./unicode-bom'),
-	'unit-allowed-list': importLazy('./unit-allowed-list'),
-	'unit-case': importLazy('./unit-case'),
-	'unit-disallowed-list': importLazy('./unit-disallowed-list'),
-	'unit-no-unknown': importLazy('./unit-no-unknown'),
-	'value-keyword-case': importLazy('./value-keyword-case'),
-	'value-list-comma-newline-after': importLazy('./value-list-comma-newline-after'),
-	'value-list-comma-newline-before': importLazy('./value-list-comma-newline-before'),
-	'value-list-comma-space-after': importLazy('./value-list-comma-space-after'),
-	'value-list-comma-space-before': importLazy('./value-list-comma-space-before'),
-	'value-list-max-empty-lines': importLazy('./value-list-max-empty-lines'),
-	'value-no-vendor-prefix': importLazy('./value-no-vendor-prefix'),
-	indentation: importLazy('./indentation'),
+	'alpha-value-notation': importLazy(() => require('./alpha-value-notation'))(),
+	'annotation-no-unknown': importLazy(() => require('./annotation-no-unknown'))(),
+	'at-rule-allowed-list': importLazy(() => require('./at-rule-allowed-list'))(),
+	'at-rule-disallowed-list': importLazy(() => require('./at-rule-disallowed-list'))(),
+	'at-rule-empty-line-before': importLazy(() => require('./at-rule-empty-line-before'))(),
+	'at-rule-name-case': importLazy(() => require('./at-rule-name-case'))(),
+	'at-rule-name-newline-after': importLazy(() => require('./at-rule-name-newline-after'))(),
+	'at-rule-semicolon-space-before': importLazy(() => require('./at-rule-semicolon-space-before'))(),
+	'at-rule-name-space-after': importLazy(() => require('./at-rule-name-space-after'))(),
+	'at-rule-no-unknown': importLazy(() => require('./at-rule-no-unknown'))(),
+	'at-rule-no-vendor-prefix': importLazy(() => require('./at-rule-no-vendor-prefix'))(),
+	'at-rule-property-required-list': importLazy(() => require('./at-rule-property-required-list'))(),
+	'at-rule-semicolon-newline-after': importLazy(() =>
+		require('./at-rule-semicolon-newline-after'),
+	)(),
+	'block-closing-brace-empty-line-before': importLazy(() =>
+		require('./block-closing-brace-empty-line-before'),
+	)(),
+	'block-closing-brace-newline-after': importLazy(() =>
+		require('./block-closing-brace-newline-after'),
+	)(),
+	'block-closing-brace-newline-before': importLazy(() =>
+		require('./block-closing-brace-newline-before'),
+	)(),
+	'block-closing-brace-space-after': importLazy(() =>
+		require('./block-closing-brace-space-after'),
+	)(),
+	'block-closing-brace-space-before': importLazy(() =>
+		require('./block-closing-brace-space-before'),
+	)(),
+	'block-no-empty': importLazy(() => require('./block-no-empty'))(),
+	'block-opening-brace-newline-after': importLazy(() =>
+		require('./block-opening-brace-newline-after'),
+	)(),
+	'block-opening-brace-newline-before': importLazy(() =>
+		require('./block-opening-brace-newline-before'),
+	)(),
+	'block-opening-brace-space-after': importLazy(() =>
+		require('./block-opening-brace-space-after'),
+	)(),
+	'block-opening-brace-space-before': importLazy(() =>
+		require('./block-opening-brace-space-before'),
+	)(),
+	'color-function-notation': importLazy(() => require('./color-function-notation'))(),
+	'color-hex-alpha': importLazy(() => require('./color-hex-alpha'))(),
+	'color-hex-case': importLazy(() => require('./color-hex-case'))(),
+	'color-hex-length': importLazy(() => require('./color-hex-length'))(),
+	'color-named': importLazy(() => require('./color-named'))(),
+	'color-no-hex': importLazy(() => require('./color-no-hex'))(),
+	'color-no-invalid-hex': importLazy(() => require('./color-no-invalid-hex'))(),
+	'comment-empty-line-before': importLazy(() => require('./comment-empty-line-before'))(),
+	'comment-no-empty': importLazy(() => require('./comment-no-empty'))(),
+	'comment-pattern': importLazy(() => require('./comment-pattern'))(),
+	'comment-whitespace-inside': importLazy(() => require('./comment-whitespace-inside'))(),
+	'comment-word-disallowed-list': importLazy(() => require('./comment-word-disallowed-list'))(),
+	'custom-media-pattern': importLazy(() => require('./custom-media-pattern'))(),
+	'custom-property-empty-line-before': importLazy(() =>
+		require('./custom-property-empty-line-before'),
+	)(),
+	'custom-property-no-missing-var-function': importLazy(() =>
+		require('./custom-property-no-missing-var-function'),
+	)(),
+	'custom-property-pattern': importLazy(() => require('./custom-property-pattern'))(),
+	'declaration-bang-space-after': importLazy(() => require('./declaration-bang-space-after'))(),
+	'declaration-bang-space-before': importLazy(() => require('./declaration-bang-space-before'))(),
+	'declaration-block-no-duplicate-custom-properties': importLazy(() =>
+		require('./declaration-block-no-duplicate-custom-properties'),
+	)(),
+	'declaration-block-no-duplicate-properties': importLazy(() =>
+		require('./declaration-block-no-duplicate-properties'),
+	)(),
+	'declaration-block-no-redundant-longhand-properties': importLazy(() =>
+		require('./declaration-block-no-redundant-longhand-properties'),
+	)(),
+	'declaration-block-no-shorthand-property-overrides': importLazy(() =>
+		require('./declaration-block-no-shorthand-property-overrides'),
+	)(),
+	'declaration-block-semicolon-newline-after': importLazy(() =>
+		require('./declaration-block-semicolon-newline-after'),
+	)(),
+	'declaration-block-semicolon-newline-before': importLazy(() =>
+		require('./declaration-block-semicolon-newline-before'),
+	)(),
+	'declaration-block-semicolon-space-after': importLazy(() =>
+		require('./declaration-block-semicolon-space-after'),
+	)(),
+	'declaration-block-semicolon-space-before': importLazy(() =>
+		require('./declaration-block-semicolon-space-before'),
+	)(),
+	'declaration-block-single-line-max-declarations': importLazy(() =>
+		require('./declaration-block-single-line-max-declarations'),
+	)(),
+	'declaration-block-trailing-semicolon': importLazy(() =>
+		require('./declaration-block-trailing-semicolon'),
+	)(),
+	'declaration-colon-newline-after': importLazy(() =>
+		require('./declaration-colon-newline-after'),
+	)(),
+	'declaration-colon-space-after': importLazy(() => require('./declaration-colon-space-after'))(),
+	'declaration-colon-space-before': importLazy(() => require('./declaration-colon-space-before'))(),
+	'declaration-empty-line-before': importLazy(() => require('./declaration-empty-line-before'))(),
+	'declaration-no-important': importLazy(() => require('./declaration-no-important'))(),
+	'declaration-property-max-values': importLazy(() =>
+		require('./declaration-property-max-values'),
+	)(),
+	'declaration-property-unit-allowed-list': importLazy(() =>
+		require('./declaration-property-unit-allowed-list'),
+	)(),
+	'declaration-property-unit-disallowed-list': importLazy(() =>
+		require('./declaration-property-unit-disallowed-list'),
+	)(),
+	'declaration-property-value-allowed-list': importLazy(() =>
+		require('./declaration-property-value-allowed-list'),
+	)(),
+	'declaration-property-value-disallowed-list': importLazy(() =>
+		require('./declaration-property-value-disallowed-list'),
+	)(),
+	'font-family-no-missing-generic-family-keyword': importLazy(() =>
+		require('./font-family-no-missing-generic-family-keyword'),
+	)(),
+	'font-family-name-quotes': importLazy(() => require('./font-family-name-quotes'))(),
+	'font-family-no-duplicate-names': importLazy(() => require('./font-family-no-duplicate-names'))(),
+	'font-weight-notation': importLazy(() => require('./font-weight-notation'))(),
+	'function-allowed-list': importLazy(() => require('./function-allowed-list'))(),
+	'function-calc-no-unspaced-operator': importLazy(() =>
+		require('./function-calc-no-unspaced-operator'),
+	)(),
+	'function-comma-newline-after': importLazy(() => require('./function-comma-newline-after'))(),
+	'function-comma-newline-before': importLazy(() => require('./function-comma-newline-before'))(),
+	'function-comma-space-after': importLazy(() => require('./function-comma-space-after'))(),
+	'function-comma-space-before': importLazy(() => require('./function-comma-space-before'))(),
+	'function-disallowed-list': importLazy(() => require('./function-disallowed-list'))(),
+	'function-linear-gradient-no-nonstandard-direction': importLazy(() =>
+		require('./function-linear-gradient-no-nonstandard-direction'),
+	)(),
+	'function-max-empty-lines': importLazy(() => require('./function-max-empty-lines'))(),
+	'function-name-case': importLazy(() => require('./function-name-case'))(),
+	'function-no-unknown': importLazy(() => require('./function-no-unknown'))(),
+	'function-parentheses-newline-inside': importLazy(() =>
+		require('./function-parentheses-newline-inside'),
+	)(),
+	'function-parentheses-space-inside': importLazy(() =>
+		require('./function-parentheses-space-inside'),
+	)(),
+	'function-url-no-scheme-relative': importLazy(() =>
+		require('./function-url-no-scheme-relative'),
+	)(),
+	'function-url-quotes': importLazy(() => require('./function-url-quotes'))(),
+	'function-url-scheme-allowed-list': importLazy(() =>
+		require('./function-url-scheme-allowed-list'),
+	)(),
+	'function-url-scheme-disallowed-list': importLazy(() =>
+		require('./function-url-scheme-disallowed-list'),
+	)(),
+	'function-whitespace-after': importLazy(() => require('./function-whitespace-after'))(),
+	'hue-degree-notation': importLazy(() => require('./hue-degree-notation'))(),
+	'import-notation': importLazy(() => require('./import-notation'))(),
+	'keyframe-block-no-duplicate-selectors': importLazy(() =>
+		require('./keyframe-block-no-duplicate-selectors'),
+	)(),
+	'keyframe-declaration-no-important': importLazy(() =>
+		require('./keyframe-declaration-no-important'),
+	)(),
+	'keyframe-selector-notation': importLazy(() => require('./keyframe-selector-notation'))(),
+	'keyframes-name-pattern': importLazy(() => require('./keyframes-name-pattern'))(),
+	'length-zero-no-unit': importLazy(() => require('./length-zero-no-unit'))(),
+	linebreaks: importLazy(() => require('./linebreaks'))(),
+	'max-empty-lines': importLazy(() => require('./max-empty-lines'))(),
+	'max-line-length': importLazy(() => require('./max-line-length'))(),
+	'max-nesting-depth': importLazy(() => require('./max-nesting-depth'))(),
+	'media-feature-colon-space-after': importLazy(() =>
+		require('./media-feature-colon-space-after'),
+	)(),
+	'media-feature-colon-space-before': importLazy(() =>
+		require('./media-feature-colon-space-before'),
+	)(),
+	'media-feature-name-allowed-list': importLazy(() =>
+		require('./media-feature-name-allowed-list'),
+	)(),
+	'media-feature-name-case': importLazy(() => require('./media-feature-name-case'))(),
+	'media-feature-name-disallowed-list': importLazy(() =>
+		require('./media-feature-name-disallowed-list'),
+	)(),
+	'media-feature-name-no-unknown': importLazy(() => require('./media-feature-name-no-unknown'))(),
+	'media-feature-name-no-vendor-prefix': importLazy(() =>
+		require('./media-feature-name-no-vendor-prefix'),
+	)(),
+	'media-feature-name-value-allowed-list': importLazy(() =>
+		require('./media-feature-name-value-allowed-list'),
+	)(),
+	'media-feature-parentheses-space-inside': importLazy(() =>
+		require('./media-feature-parentheses-space-inside'),
+	)(),
+	'media-feature-range-operator-space-after': importLazy(() =>
+		require('./media-feature-range-operator-space-after'),
+	)(),
+	'media-feature-range-operator-space-before': importLazy(() =>
+		require('./media-feature-range-operator-space-before'),
+	)(),
+	'media-query-list-comma-newline-after': importLazy(() =>
+		require('./media-query-list-comma-newline-after'),
+	)(),
+	'media-query-list-comma-newline-before': importLazy(() =>
+		require('./media-query-list-comma-newline-before'),
+	)(),
+	'media-query-list-comma-space-after': importLazy(() =>
+		require('./media-query-list-comma-space-after'),
+	)(),
+	'media-query-list-comma-space-before': importLazy(() =>
+		require('./media-query-list-comma-space-before'),
+	)(),
+	'named-grid-areas-no-invalid': importLazy(() => require('./named-grid-areas-no-invalid'))(),
+	'no-descending-specificity': importLazy(() => require('./no-descending-specificity'))(),
+	'no-duplicate-at-import-rules': importLazy(() => require('./no-duplicate-at-import-rules'))(),
+	'no-duplicate-selectors': importLazy(() => require('./no-duplicate-selectors'))(),
+	'no-empty-source': importLazy(() => require('./no-empty-source'))(),
+	'no-empty-first-line': importLazy(() => require('./no-empty-first-line'))(),
+	'no-eol-whitespace': importLazy(() => require('./no-eol-whitespace'))(),
+	'no-extra-semicolons': importLazy(() => require('./no-extra-semicolons'))(),
+	'no-invalid-double-slash-comments': importLazy(() =>
+		require('./no-invalid-double-slash-comments'),
+	)(),
+	'no-invalid-position-at-import-rule': importLazy(() =>
+		require('./no-invalid-position-at-import-rule'),
+	)(),
+	'no-irregular-whitespace': importLazy(() => require('./no-irregular-whitespace'))(),
+	'no-missing-end-of-source-newline': importLazy(() =>
+		require('./no-missing-end-of-source-newline'),
+	)(),
+	'no-unknown-animations': importLazy(() => require('./no-unknown-animations'))(),
+	'number-leading-zero': importLazy(() => require('./number-leading-zero'))(),
+	'number-max-precision': importLazy(() => require('./number-max-precision'))(),
+	'number-no-trailing-zeros': importLazy(() => require('./number-no-trailing-zeros'))(),
+	'property-allowed-list': importLazy(() => require('./property-allowed-list'))(),
+	'property-case': importLazy(() => require('./property-case'))(),
+	'property-disallowed-list': importLazy(() => require('./property-disallowed-list'))(),
+	'property-no-unknown': importLazy(() => require('./property-no-unknown'))(),
+	'property-no-vendor-prefix': importLazy(() => require('./property-no-vendor-prefix'))(),
+	'rule-empty-line-before': importLazy(() => require('./rule-empty-line-before'))(),
+	'rule-selector-property-disallowed-list': importLazy(() =>
+		require('./rule-selector-property-disallowed-list'),
+	)(),
+	'selector-attribute-brackets-space-inside': importLazy(() =>
+		require('./selector-attribute-brackets-space-inside'),
+	)(),
+	'selector-attribute-name-disallowed-list': importLazy(() =>
+		require('./selector-attribute-name-disallowed-list'),
+	)(),
+	'selector-attribute-operator-allowed-list': importLazy(() =>
+		require('./selector-attribute-operator-allowed-list'),
+	)(),
+	'selector-attribute-operator-disallowed-list': importLazy(() =>
+		require('./selector-attribute-operator-disallowed-list'),
+	)(),
+	'selector-attribute-operator-space-after': importLazy(() =>
+		require('./selector-attribute-operator-space-after'),
+	)(),
+	'selector-attribute-operator-space-before': importLazy(() =>
+		require('./selector-attribute-operator-space-before'),
+	)(),
+	'selector-attribute-quotes': importLazy(() => require('./selector-attribute-quotes'))(),
+	'selector-class-pattern': importLazy(() => require('./selector-class-pattern'))(),
+	'selector-combinator-allowed-list': importLazy(() =>
+		require('./selector-combinator-allowed-list'),
+	)(),
+	'selector-combinator-disallowed-list': importLazy(() =>
+		require('./selector-combinator-disallowed-list'),
+	)(),
+	'selector-combinator-space-after': importLazy(() =>
+		require('./selector-combinator-space-after'),
+	)(),
+	'selector-combinator-space-before': importLazy(() =>
+		require('./selector-combinator-space-before'),
+	)(),
+	'selector-descendant-combinator-no-non-space': importLazy(() =>
+		require('./selector-descendant-combinator-no-non-space'),
+	)(),
+	'selector-disallowed-list': importLazy(() => require('./selector-disallowed-list'))(),
+	'selector-id-pattern': importLazy(() => require('./selector-id-pattern'))(),
+	'selector-list-comma-newline-after': importLazy(() =>
+		require('./selector-list-comma-newline-after'),
+	)(),
+	'selector-list-comma-newline-before': importLazy(() =>
+		require('./selector-list-comma-newline-before'),
+	)(),
+	'selector-list-comma-space-after': importLazy(() =>
+		require('./selector-list-comma-space-after'),
+	)(),
+	'selector-list-comma-space-before': importLazy(() =>
+		require('./selector-list-comma-space-before'),
+	)(),
+	'selector-max-attribute': importLazy(() => require('./selector-max-attribute'))(),
+	'selector-max-class': importLazy(() => require('./selector-max-class'))(),
+	'selector-max-combinators': importLazy(() => require('./selector-max-combinators'))(),
+	'selector-max-compound-selectors': importLazy(() =>
+		require('./selector-max-compound-selectors'),
+	)(),
+	'selector-max-empty-lines': importLazy(() => require('./selector-max-empty-lines'))(),
+	'selector-max-id': importLazy(() => require('./selector-max-id'))(),
+	'selector-max-pseudo-class': importLazy(() => require('./selector-max-pseudo-class'))(),
+	'selector-max-specificity': importLazy(() => require('./selector-max-specificity'))(),
+	'selector-max-type': importLazy(() => require('./selector-max-type'))(),
+	'selector-max-universal': importLazy(() => require('./selector-max-universal'))(),
+	'selector-nested-pattern': importLazy(() => require('./selector-nested-pattern'))(),
+	'selector-no-qualifying-type': importLazy(() => require('./selector-no-qualifying-type'))(),
+	'selector-no-vendor-prefix': importLazy(() => require('./selector-no-vendor-prefix'))(),
+	'selector-not-notation': importLazy(() => require('./selector-not-notation'))(),
+	'selector-pseudo-class-allowed-list': importLazy(() =>
+		require('./selector-pseudo-class-allowed-list'),
+	)(),
+	'selector-pseudo-class-case': importLazy(() => require('./selector-pseudo-class-case'))(),
+	'selector-pseudo-class-disallowed-list': importLazy(() =>
+		require('./selector-pseudo-class-disallowed-list'),
+	)(),
+	'selector-pseudo-class-no-unknown': importLazy(() =>
+		require('./selector-pseudo-class-no-unknown'),
+	)(),
+	'selector-pseudo-class-parentheses-space-inside': importLazy(() =>
+		require('./selector-pseudo-class-parentheses-space-inside'),
+	)(),
+	'selector-pseudo-element-allowed-list': importLazy(() =>
+		require('./selector-pseudo-element-allowed-list'),
+	)(),
+	'selector-pseudo-element-case': importLazy(() => require('./selector-pseudo-element-case'))(),
+	'selector-pseudo-element-colon-notation': importLazy(() =>
+		require('./selector-pseudo-element-colon-notation'),
+	)(),
+	'selector-pseudo-element-disallowed-list': importLazy(() =>
+		require('./selector-pseudo-element-disallowed-list'),
+	)(),
+	'selector-pseudo-element-no-unknown': importLazy(() =>
+		require('./selector-pseudo-element-no-unknown'),
+	)(),
+	'selector-type-case': importLazy(() => require('./selector-type-case'))(),
+	'selector-type-no-unknown': importLazy(() => require('./selector-type-no-unknown'))(),
+	'shorthand-property-no-redundant-values': importLazy(() =>
+		require('./shorthand-property-no-redundant-values'),
+	)(),
+	'string-no-newline': importLazy(() => require('./string-no-newline'))(),
+	'string-quotes': importLazy(() => require('./string-quotes'))(),
+	'time-min-milliseconds': importLazy(() => require('./time-min-milliseconds'))(),
+	'unicode-bom': importLazy(() => require('./unicode-bom'))(),
+	'unit-allowed-list': importLazy(() => require('./unit-allowed-list'))(),
+	'unit-case': importLazy(() => require('./unit-case'))(),
+	'unit-disallowed-list': importLazy(() => require('./unit-disallowed-list'))(),
+	'unit-no-unknown': importLazy(() => require('./unit-no-unknown'))(),
+	'value-keyword-case': importLazy(() => require('./value-keyword-case'))(),
+	'value-list-comma-newline-after': importLazy(() => require('./value-list-comma-newline-after'))(),
+	'value-list-comma-newline-before': importLazy(() =>
+		require('./value-list-comma-newline-before'),
+	)(),
+	'value-list-comma-space-after': importLazy(() => require('./value-list-comma-space-after'))(),
+	'value-list-comma-space-before': importLazy(() => require('./value-list-comma-space-before'))(),
+	'value-list-max-empty-lines': importLazy(() => require('./value-list-max-empty-lines'))(),
+	'value-no-vendor-prefix': importLazy(() => require('./value-no-vendor-prefix'))(),
+	indentation: importLazy(() => require('./indentation'))(),
 };
 
 module.exports = rules;

lib/rules/property-disallowed-list/index.js

@@ -51,3 +51,4 @@ 'use strict';
 			report({
-				message: messages.rejected(prop),
+				message: messages.rejected,
+				messageArgs: [prop],
 				word: prop,
@@ -54,0 +55,0 @@ node: decl,

lib/utils/checkAgainstRule.js

@@ -5,3 +5,4 @@ 'use strict';
 const Result = require('postcss/lib/result');
-const rules = require('../rules');
+const { isPlainObject } = require('./validateTypes');
+const getStylelintRule = require('./getStylelintRule');
 
@@ -11,32 +12,24 @@ /**
  * against a specific rule and do something with the warnings
- * @template T
- * @template {Object} O
- * @param {{
-		ruleName: string,
-		ruleSettings: import('stylelint').ConfigRuleSettings<T, O>,
-		root: import('postcss').Root,
-	}} options
- * @param {(warning: import('postcss').Warning) => void} callback
- * @returns {void}
+ *
+ * @type {typeof import('stylelint').utils.checkAgainstRule}
  */
 function checkAgainstRule(options, callback) {
-	if (!options)
-		throw new Error(
-			"checkAgainstRule requires an options object with 'ruleName', 'ruleSettings', and 'root' properties",
-		);
+	if (!isPlainObject(options)) throw new Error('Expected an options object');
 
-	if (!callback) throw new Error('checkAgainstRule requires a callback');
+	if (!callback) throw new Error('Expected a callback function');
 
-	if (!options.ruleName) throw new Error("checkAgainstRule requires a 'ruleName' option");
+	const { ruleName, ruleSettings, root, result, context = {} } = options;
 
-	const rule = rules[options.ruleName];
+	if (!ruleName) throw new Error('Expected a "ruleName" option');
 
-	if (!rule) throw new Error(`Rule '${options.ruleName}' does not exist`);
+	const rule = getStylelintRule(ruleName, result && result.stylelint.config);
 
-	if (!options.ruleSettings) throw new Error("checkAgainstRule requires a 'ruleSettings' option");
+	if (!rule) throw new Error(`Rule "${ruleName}" does not exist`);
 
-	if (!options.root) throw new Error("checkAgainstRule requires a 'root' option");
+	if (!ruleSettings) throw new Error('Expected a "ruleSettings" option');
 
-	const settings = normalizeRuleSettings(options.ruleSettings, options.ruleName);
+	if (!root) throw new Error('Expected a "root" option');
 
+	const settings = normalizeRuleSettings(ruleSettings, rule);
+
 	if (!settings) {
@@ -49,3 +42,3 @@ return;
 
-	rule(settings[0], /** @type {O} */ (settings[1]), {})(options.root, tmpPostcssResult);
+	rule(settings[0], /** @type {Object} */ (settings[1]), context)(root, tmpPostcssResult);
 
@@ -55,4 +48,2 @@ for (const warning of tmpPostcssResult.warnings()) callback(warning);
 
-module.exports = /** @type {typeof import('stylelint').utils.checkAgainstRule} */ (
-	checkAgainstRule
-);
+module.exports = checkAgainstRule;

lib/utils/report.js

@@ -18,3 +18,4 @@ 'use strict';
 module.exports = function report(problem) {
-	const { ruleName, result, message, messageArgs, line, node, index, endIndex, word } = problem;
+	const { ruleName, result, message, messageArgs, line, node, index, endIndex, word, severity } =
+		problem;
 
@@ -27,4 +28,7 @@ result.stylelint = result.stylelint || {
 
+	const ruleSeverity =
+		severity || (result.stylelint.ruleSeverities && result.stylelint.ruleSeverities[ruleName]);
+
 	// In quiet mode, mere warnings are ignored
-	if (result.stylelint.quiet && result.stylelint.ruleSeverities[ruleName] !== 'error') {
+	if (result.stylelint.quiet && ruleSeverity !== 'error') {
 		return;
@@ -77,9 +81,7 @@ }
 
-	const severity = result.stylelint.ruleSeverities && result.stylelint.ruleSeverities[ruleName];
-
-	if (!result.stylelint.stylelintError && severity === 'error') {
+	if (!result.stylelint.stylelintError && ruleSeverity === 'error') {
 		result.stylelint.stylelintError = true;
 	}
 
-	if (!result.stylelint.stylelintWarning && severity === 'warning') {
+	if (!result.stylelint.stylelintWarning && ruleSeverity === 'warning') {
 		result.stylelint.stylelintWarning = true;
@@ -90,3 +92,3 @@ }
 	const warningProperties = {
-		severity,
+		severity: ruleSeverity,
 		rule: ruleName,
@@ -93,0 +95,0 @@ };

package.json

 {
   "name": "stylelint",
-  "version": "14.14.1",
+  "version": "14.15.0",
   "description": "A mighty, modern CSS linter.",
@@ -117,3 +117,3 @@ "keywords": [
     "colord": "^2.9.3",
-    "cosmiconfig": "^7.0.1",
+    "cosmiconfig": "^7.1.0",
     "css-functions-list": "^3.1.0",
@@ -138,3 +138,3 @@ "debug": "^4.3.4",
     "picocolors": "^1.0.0",
-    "postcss": "^8.4.18",
+    "postcss": "^8.4.19",
     "postcss-media-query-parser": "^0.2.3",
@@ -176,5 +176,5 @@ "postcss-resolve-nested-selector": "^0.1.1",
     "deepmerge": "^4.2.2",
-    "eslint": "^8.26.0",
+    "eslint": "^8.27.0",
     "eslint-config-stylelint": "^17.0.0",
-    "husky": "^8.0.1",
+    "husky": "^8.0.2",
     "jest": "^28.1.3",
@@ -184,3 +184,3 @@ "jest-preset-stylelint": "^5.0.4",
     "lint-staged": "^13.0.3",
-    "node-fetch": "^3.2.10",
+    "node-fetch": "^3.3.0",
     "np": "^7.6.2",
@@ -187,0 +187,0 @@ "npm-run-all": "^4.1.5",

types/stylelint/index.d.ts

@@ -151,7 +151,2 @@ declare module 'stylelint' {
 
-		export type PluginContext = {
-			fix?: boolean | undefined;
-			newline?: string | undefined;
-		};
-
 		// Note: With strict function types enabled, function signatures are checked contravariantly.
@@ -184,6 +179,16 @@ // This means that it would not be possible for rule authors to narrow the message function
 
+		export type RuleContext = {
+			fix?: boolean | undefined;
+			newline?: string | undefined;
+		};
+
+		/**
+		 * @deprecated Use `RuleContext` instead.
+		 */
+		export type PluginContext = RuleContext;
+
 		export type RuleBase<P = any, S = any> = (
 			primaryOption: P,
 			secondaryOptions: Record<string, S>,
-			context: PluginContext,
+			context: RuleContext,
 		) => (root: PostCSS.Root, result: PostcssResult) => Promise<void> | void;
@@ -401,2 +406,6 @@
 			line?: number;
+			/**
+			 * Optional severity override for the problem.
+			 */
+			severity?: Severity;
 		};
@@ -515,3 +524,9 @@
 				checkAgainstRule: <T, O extends Object>(
-					options: { ruleName: string; ruleSettings: ConfigRuleSettings<T, O>; root: PostCSS.Root },
+					options: {
+						ruleName: string;
+						ruleSettings: ConfigRuleSettings<T, O>;
+						root: PostCSS.Root;
+						result?: PostcssResult;
+						context?: RuleContext;
+					},
 					callback: (warning: PostCSS.Warning) => void,
@@ -518,0 +533,0 @@ ) => void;

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

889677

increased by0.53%

Number of package files

381

increased by0.26%

Lines of code

28056

increased by0.54%

Dependency changes

• + Addedcss-functions-list@3.2.2(transitive)

• - Removedcss-functions-list@3.2.3(transitive)

• Updatedcosmiconfig@^7.1.0

• Updatedpostcss@^8.4.19