@alexlit/lint-kit 183.4.0 → 183.6.0

package/packages/config-stylelint/node_modules/stylelint/lib/rules/declaration-no-important/index.mjs

@@ -0,0 +1,51 @@
+import { assert } from '../../utils/validateTypes.mjs';
+import getImportantPosition from '../../utils/getImportantPosition.mjs';
+import report from '../../utils/report.mjs';
+import ruleMessages from '../../utils/ruleMessages.mjs';
+import validateOptions from '../../utils/validateOptions.mjs';
+
+const ruleName = 'declaration-no-important';
+
+const messages = ruleMessages(ruleName, {
+	rejected: 'Unexpected !important',
+});
+
+const meta = {
+	url: 'https://stylelint.io/user-guide/rules/declaration-no-important',
+};
+
+/** @type {import('stylelint').CoreRules[ruleName]} */
+const rule = (primary) => {
+	return (root, result) => {
+		const validOptions = validateOptions(result, ruleName, { actual: primary });
+
+		if (!validOptions) {
+			return;
+		}
+
+		root.walkDecls((decl) => {
+			if (!decl.important) {
+				return;
+			}
+
+			const pos = getImportantPosition(decl.toString());
+
+			assert(pos);
+
+			report({
+				message: messages.rejected,
+				messageArgs: [],
+				node: decl,
+				index: pos.index,
+				endIndex: pos.endIndex,
+				result,
+				ruleName,
+			});
+		});
+	};
+};
+
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;
+export default rule;

package/packages/config-stylelint/node_modules/stylelint/lib/rules/declaration-property-max-values/index.mjs

@@ -0,0 +1,79 @@
+import valueParser from 'postcss-value-parser';
+
+import { assertNumber } from '../../utils/validateTypes.mjs';
+import isNonNegativeInteger from '../../utils/isNonNegativeInteger.mjs';
+import matchesStringOrRegExp from '../../utils/matchesStringOrRegExp.mjs';
+import { mayIncludeRegexes } from '../../utils/regexes.mjs';
+import report from '../../utils/report.mjs';
+import ruleMessages from '../../utils/ruleMessages.mjs';
+import validateObjectWithProps from '../../utils/validateObjectWithProps.mjs';
+import validateOptions from '../../utils/validateOptions.mjs';
+
+const ruleName = 'declaration-property-max-values';
+
+const messages = ruleMessages(ruleName, {
+	expected: (property, max) =>
+		`Expected "${property}" to have no more than ${max} ${max === 1 ? 'value' : 'values'}`,
+});
+
+const meta = {
+	url: 'https://stylelint.io/user-guide/rules/declaration-property-max-values',
+};
+
+/**
+ * @param {valueParser.Node} node
+ */
+const isValueNode = (node) => {
+	return node.type === 'word' || node.type === 'function' || node.type === 'string';
+};
+
+/** @type {import('stylelint').CoreRules[ruleName]} */
+const rule = (primary) => {
+	return (root, result) => {
+		const validOptions = validateOptions(result, ruleName, {
+			actual: primary,
+			possible: [validateObjectWithProps(isNonNegativeInteger)],
+		});
+
+		if (!validOptions) {
+			return;
+		}
+
+		root.walkDecls((decl) => {
+			const { prop, value } = decl;
+
+			if (!mayIncludeRegexes.multipleValues.test(value)) return;
+
+			const propLength = valueParser(value).nodes.filter(isValueNode).length;
+
+			const propKey = Object.keys(primary).find((propIdentifier) =>
+				matchesStringOrRegExp(prop, propIdentifier),
+			);
+
+			if (!propKey) {
+				return;
+			}
+
+			const max = primary[propKey];
+
+			assertNumber(max);
+
+			if (propLength <= max) {
+				return;
+			}
+
+			report({
+				message: messages.expected,
+				messageArgs: [prop, max],
+				node: decl,
+				result,
+				ruleName,
+			});
+		});
+	};
+};
+
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;
+export default rule;

package/packages/config-stylelint/node_modules/stylelint/lib/rules/declaration-property-unit-allowed-list/index.mjs

@@ -0,0 +1,108 @@
+import valueParser from 'postcss-value-parser';
+
+import { declarationValueIndex } from '../../utils/nodeFieldIndices.mjs';
+import getDimension from '../../utils/getDimension.mjs';
+import { isString } from '../../utils/validateTypes.mjs';
+import matchesStringOrRegExp from '../../utils/matchesStringOrRegExp.mjs';
+import optionsMatches from '../../utils/optionsMatches.mjs';
+import report from '../../utils/report.mjs';
+import ruleMessages from '../../utils/ruleMessages.mjs';
+import validateObjectWithArrayProps from '../../utils/validateObjectWithArrayProps.mjs';
+import validateOptions from '../../utils/validateOptions.mjs';
+
+const ruleName = 'declaration-property-unit-allowed-list';
+
+const messages = ruleMessages(ruleName, {
+	rejected: (property, unit) => `Unexpected unit "${unit}" for property "${property}"`,
+});
+
+const meta = {
+	url: 'https://stylelint.io/user-guide/rules/declaration-property-unit-allowed-list',
+};
+
+/** @type {import('stylelint').CoreRules[ruleName]} */
+const rule = (primary, secondaryOptions) => {
+	return (root, result) => {
+		const validOptions = validateOptions(
+			result,
+			ruleName,
+			{
+				actual: primary,
+				possible: [validateObjectWithArrayProps(isString)],
+			},
+			{
+				actual: secondaryOptions,
+				possible: {
+					ignore: ['inside-function'],
+				},
+				optional: true,
+			},
+		);
+
+		if (!validOptions) {
+			return;
+		}
+
+		root.walkDecls((decl) => {
+			const prop = decl.prop;
+			const value = decl.value;
+
+			const propKey = Object.keys(primary).find((propIdentifier) =>
+				matchesStringOrRegExp(prop, propIdentifier),
+			);
+
+			if (!propKey) {
+				return;
+			}
+
+			const propValue = primary[propKey];
+
+			if (!propValue) {
+				return;
+			}
+
+			const propList = new Set([propValue].flat());
+
+			valueParser(value).walk((node) => {
+				// Ignore wrong units within `url` function
+				if (node.type === 'function') {
+					if (node.value.toLowerCase() === 'url') {
+						return false;
+					}
+
+					if (optionsMatches(secondaryOptions, 'ignore', 'inside-function')) {
+						return false;
+					}
+				}
+
+				if (node.type === 'string') {
+					return;
+				}
+
+				const { unit } = getDimension(node);
+
+				if (!unit || propList.has(unit.toLowerCase())) {
+					return;
+				}
+
+				const index = declarationValueIndex(decl) + node.sourceIndex;
+				const endIndex = index + node.value.length;
+
+				report({
+					message: messages.rejected,
+					messageArgs: [prop, unit],
+					node: decl,
+					index,
+					endIndex,
+					result,
+					ruleName,
+				});
+			});
+		});
+	};
+};
+
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;
+export default rule;

package/packages/config-stylelint/node_modules/stylelint/lib/rules/declaration-property-unit-disallowed-list/index.mjs

@@ -0,0 +1,94 @@
+import valueParser from 'postcss-value-parser';
+
+import { declarationValueIndex } from '../../utils/nodeFieldIndices.mjs';
+import getDimension from '../../utils/getDimension.mjs';
+import { isString } from '../../utils/validateTypes.mjs';
+import isUrlFunction from '../../utils/isUrlFunction.mjs';
+import matchesStringOrRegExp from '../../utils/matchesStringOrRegExp.mjs';
+import { mayIncludeRegexes } from '../../utils/regexes.mjs';
+import report from '../../utils/report.mjs';
+import ruleMessages from '../../utils/ruleMessages.mjs';
+import validateObjectWithArrayProps from '../../utils/validateObjectWithArrayProps.mjs';
+import validateOptions from '../../utils/validateOptions.mjs';
+
+const ruleName = 'declaration-property-unit-disallowed-list';
+
+const messages = ruleMessages(ruleName, {
+	rejected: (property, unit) => `Unexpected unit "${unit}" for property "${property}"`,
+});
+
+const meta = {
+	url: 'https://stylelint.io/user-guide/rules/declaration-property-unit-disallowed-list',
+};
+
+/** @type {import('stylelint').CoreRules[ruleName]} */
+const rule = (primary) => {
+	return (root, result) => {
+		const validOptions = validateOptions(result, ruleName, {
+			actual: primary,
+			possible: [validateObjectWithArrayProps(isString)],
+		});
+
+		if (!validOptions) {
+			return;
+		}
+
+		root.walkDecls((decl) => {
+			const prop = decl.prop;
+			const value = decl.value;
+
+			if (!mayIncludeRegexes.dimension.test(value)) return;
+
+			const propKey = Object.keys(primary).find((propIdentifier) =>
+				matchesStringOrRegExp(prop, propIdentifier),
+			);
+
+			if (!propKey) {
+				return;
+			}
+
+			const propValue = primary[propKey];
+
+			if (!propValue) {
+				return;
+			}
+
+			const propList = new Set([propValue].flat());
+
+			valueParser(value).walk((node) => {
+				// Ignore wrong units within `url` function
+				if (isUrlFunction(node)) {
+					return false;
+				}
+
+				if (node.type === 'string') {
+					return;
+				}
+
+				const { unit } = getDimension(node);
+
+				if (!unit || !propList.has(unit.toLowerCase())) {
+					return;
+				}
+
+				const index = declarationValueIndex(decl) + node.sourceIndex;
+				const endIndex = index + node.value.length;
+
+				report({
+					message: messages.rejected,
+					messageArgs: [prop, unit],
+					node: decl,
+					index,
+					endIndex,
+					result,
+					ruleName,
+				});
+			});
+		});
+	};
+};
+
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;
+export default rule;

package/packages/config-stylelint/node_modules/stylelint/lib/rules/declaration-property-value-allowed-list/index.mjs

@@ -0,0 +1,66 @@
+import { isRegExp, isString } from '../../utils/validateTypes.mjs';
+import { declarationValueIndex } from '../../utils/nodeFieldIndices.mjs';
+import matchesStringOrRegExp from '../../utils/matchesStringOrRegExp.mjs';
+import optionsMatches from '../../utils/optionsMatches.mjs';
+import report from '../../utils/report.mjs';
+import ruleMessages from '../../utils/ruleMessages.mjs';
+import validateObjectWithArrayProps from '../../utils/validateObjectWithArrayProps.mjs';
+import validateOptions from '../../utils/validateOptions.mjs';
+
+const ruleName = 'declaration-property-value-allowed-list';
+
+const messages = ruleMessages(ruleName, {
+	rejected: (property, value) => `Unexpected value "${value}" for property "${property}"`,
+});
+
+const meta = {
+	url: 'https://stylelint.io/user-guide/rules/declaration-property-value-allowed-list',
+};
+
+/** @type {import('stylelint').CoreRules[ruleName]} */
+const rule = (primary) => {
+	return (root, result) => {
+		const validOptions = validateOptions(result, ruleName, {
+			actual: primary,
+			possible: [validateObjectWithArrayProps(isString, isRegExp)],
+		});
+
+		if (!validOptions) {
+			return;
+		}
+
+		const propKeys = Object.keys(primary);
+
+		root.walkDecls((decl) => {
+			const { prop, value } = decl;
+
+			const propPatterns = propKeys.filter((key) => matchesStringOrRegExp(prop, key));
+
+			if (propPatterns.length === 0) {
+				return;
+			}
+
+			if (propPatterns.some((pattern) => optionsMatches(primary, pattern, value))) {
+				return;
+			}
+
+			const index = declarationValueIndex(decl);
+			const endIndex = index + decl.value.length;
+
+			report({
+				message: messages.rejected,
+				messageArgs: [prop, value],
+				node: decl,
+				index,
+				endIndex,
+				result,
+				ruleName,
+			});
+		});
+	};
+};
+
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;
+export default rule;

package/packages/config-stylelint/node_modules/stylelint/lib/rules/declaration-property-value-disallowed-list/index.mjs

@@ -0,0 +1,66 @@
+import { isRegExp, isString } from '../../utils/validateTypes.mjs';
+import { declarationValueIndex } from '../../utils/nodeFieldIndices.mjs';
+import matchesStringOrRegExp from '../../utils/matchesStringOrRegExp.mjs';
+import optionsMatches from '../../utils/optionsMatches.mjs';
+import report from '../../utils/report.mjs';
+import ruleMessages from '../../utils/ruleMessages.mjs';
+import validateObjectWithArrayProps from '../../utils/validateObjectWithArrayProps.mjs';
+import validateOptions from '../../utils/validateOptions.mjs';
+
+const ruleName = 'declaration-property-value-disallowed-list';
+
+const messages = ruleMessages(ruleName, {
+	rejected: (property, value) => `Unexpected value "${value}" for property "${property}"`,
+});
+
+const meta = {
+	url: 'https://stylelint.io/user-guide/rules/declaration-property-value-disallowed-list',
+};
+
+/** @type {import('stylelint').CoreRules[ruleName]} */
+const rule = (primary) => {
+	return (root, result) => {
+		const validOptions = validateOptions(result, ruleName, {
+			actual: primary,
+			possible: [validateObjectWithArrayProps(isString, isRegExp)],
+		});
+
+		if (!validOptions) {
+			return;
+		}
+
+		const propKeys = Object.keys(primary);
+
+		root.walkDecls((decl) => {
+			const { prop, value } = decl;
+
+			const propPatterns = propKeys.filter((key) => matchesStringOrRegExp(prop, key));
+
+			if (propPatterns.length === 0) {
+				return;
+			}
+
+			if (propPatterns.every((pattern) => !optionsMatches(primary, pattern, value))) {
+				return;
+			}
+
+			const index = declarationValueIndex(decl);
+			const endIndex = index + decl.value.length;
+
+			report({
+				message: messages.rejected,
+				messageArgs: [prop, value],
+				node: decl,
+				index,
+				endIndex,
+				result,
+				ruleName,
+			});
+		});
+	};
+};
+
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;
+export default rule;

package/packages/config-stylelint/node_modules/stylelint/lib/rules/declaration-property-value-keyword-no-deprecated/index.mjs

@@ -0,0 +1,207 @@
+import valueParser from 'postcss-value-parser';
+
+import { isRegExp, isString } from '../../utils/validateTypes.mjs';
+import { colorFunctions } from '../../reference/functions.mjs';
+import { declarationValueIndex } from '../../utils/nodeFieldIndices.mjs';
+import getDeclarationValue from '../../utils/getDeclarationValue.mjs';
+import isStandardSyntaxDeclaration from '../../utils/isStandardSyntaxDeclaration.mjs';
+import isStandardSyntaxValue from '../../utils/isStandardSyntaxValue.mjs';
+import { mayIncludeRegexes } from '../../utils/regexes.mjs';
+import optionsMatches from '../../utils/optionsMatches.mjs';
+import report from '../../utils/report.mjs';
+import ruleMessages from '../../utils/ruleMessages.mjs';
+import setDeclarationValue from '../../utils/setDeclarationValue.mjs';
+import { singleValueColorProperties } from '../../reference/properties.mjs';
+import validateOptions from '../../utils/validateOptions.mjs';
+
+const ruleName = 'declaration-property-value-keyword-no-deprecated';
+
+const messages = ruleMessages(ruleName, {
+	expected: (actual, expected) => `Expected "${actual}" to be "${expected}"`,
+	rejected: (property, keyword) =>
+		`Unexpected deprecated keyword "${keyword}" for property "${property}"`,
+});
+
+const meta = {
+	url: 'https://stylelint.io/user-guide/rules/declaration-property-value-keyword-no-deprecated',
+	fixable: true,
+};
+
+const DEPRECATED_COLORS = {
+	activecaption: 'canvas',
+	appworkspace: 'canvas',
+	background: 'canvas',
+	inactivecaption: 'canvas',
+	infobackground: 'canvas',
+	menu: 'canvas',
+	scrollbar: 'canvas',
+	window: 'canvas',
+	activeborder: 'ButtonBorder',
+	inactiveborder: 'ButtonBorder',
+	threeddarkshadow: 'ButtonBorder',
+	threedhighlight: 'ButtonBorder',
+	threedlightshadow: 'ButtonBorder',
+	threedshadow: 'ButtonBorder',
+	windowframe: 'ButtonBorder',
+	captiontext: 'CanvasText',
+	infotext: 'CanvasText',
+	menutext: 'CanvasText',
+	windowtext: 'CanvasText',
+	buttonhighlight: 'ButtonFace',
+	buttonshadow: 'ButtonFace',
+	threedface: 'ButtonFace',
+	inactivecaptiontext: 'GrayText',
+};
+
+/** @type {ReadonlyArray<[string, Record<string, string>]>} */
+const COLOR_PROPERTIES = [...singleValueColorProperties.values()].map((value) => [
+	value,
+	DEPRECATED_COLORS,
+]);
+
+const PROPERTY_NAME_TO_KEYWORDS = new Map([
+	[
+		'appearance',
+		/** @type {string[] | Record<string, string>} */ ({
+			button: 'auto',
+			checkbox: 'auto',
+			listbox: 'auto',
+			menulist: 'auto',
+			meter: 'auto',
+			'progress-bar': 'auto',
+			'push-button': 'auto',
+			radio: 'auto',
+			searchfield: 'auto',
+			'slider-horizontal': 'auto',
+			'square-button': 'auto',
+			textarea: 'auto',
+		}),
+	],
+	[
+		'image-rendering',
+		{
+			optimizeQuality: 'smooth',
+			optimizeSpeed: 'pixelated',
+		},
+	],
+	['overflow', { overlay: 'auto' }],
+	['overflow-x', { overlay: 'auto' }],
+	['overflow-y', { overlay: 'auto' }],
+	['text-justify', { distribute: 'inter-character' }],
+	['text-orientation', { 'sideways-right': 'sideways' }],
+	['user-select', { element: 'contain' }],
+	['zoom', { reset: '1' }],
+	['border-color', DEPRECATED_COLORS],
+	['scrollbar-color', DEPRECATED_COLORS],
+	['text-decoration', ['blink']],
+	['text-decoration-line', ['blink']],
+	['box-sizing', ['padding-box']],
+	['image-orientation', ['flip']],
+	['min-height', ['intrinsic', 'min-intrinsic']],
+	['min-width', ['intrinsic', 'min-intrinsic']],
+	['max-height', ['intrinsic', 'min-intrinsic']],
+	['max-width', ['intrinsic', 'min-intrinsic']],
+	['height', ['intrinsic', 'min-intrinsic']],
+	['width', ['intrinsic', 'min-intrinsic']],
+	['word-break', ['break-word']],
+	...COLOR_PROPERTIES,
+]);
+
+/** @type {import('stylelint').CoreRules[ruleName]} */
+const rule = (primary, secondaryOptions) => {
+	return (root, result) => {
+		const validOptions = validateOptions(
+			result,
+			ruleName,
+			{ actual: primary },
+			{
+				optional: true,
+				actual: secondaryOptions,
+				possible: {
+					ignoreKeywords: [isString, isRegExp],
+				},
+			},
+		);
+
+		if (!validOptions) return;
+
+		root.walkDecls((decl) => {
+			const { prop, value } = decl;
+
+			if (!mayIncludeRegexes.keyword.test(value)) return;
+
+			if (!isStandardSyntaxDeclaration(decl)) return;
+
+			if (optionsMatches(secondaryOptions, 'ignoreKeywords', value)) return;
+
+			const keywords = PROPERTY_NAME_TO_KEYWORDS.get(prop.toLowerCase());
+
+			if (!keywords) return;
+
+			const parsedValue = valueParser(getDeclarationValue(decl));
+			let isStandardValue = true;
+
+			parsedValue.walk((node) => {
+				if (node.type === 'comment') return;
+
+				if (!isStandardSyntaxValue(node.value)) isStandardValue = false;
+			});
+
+			if (!isStandardValue) return;
+
+			parsedValue.walk((node) => {
+				const nodeValue = node.value;
+				const lowercasedValue = nodeValue.toLowerCase();
+
+				if (node.type === 'function' && !colorFunctions.has(lowercasedValue)) return false;
+
+				if (node.type !== 'word') return;
+
+				const offset = node.sourceIndex;
+				let fix;
+				let message;
+				let messageArgs;
+
+				if (Array.isArray(keywords)) {
+					if (!keywords.includes(lowercasedValue)) return;
+
+					message = messages.rejected;
+					messageArgs = [prop, nodeValue];
+				} else {
+					const expectedKeyword = keywords[lowercasedValue];
+
+					if (!expectedKeyword) return;
+
+					message = messages.expected;
+					messageArgs = [nodeValue, expectedKeyword];
+					fix = () => {
+						node.value = expectedKeyword;
+						setDeclarationValue(decl, parsedValue.toString());
+					};
+				}
+
+				const index = declarationValueIndex(decl) + offset;
+				const endIndex = index + nodeValue.length;
+
+				report({
+					message,
+					messageArgs,
+					node: decl,
+					result,
+					ruleName,
+					index,
+					endIndex,
+					fix: {
+						apply: fix,
+						node: decl,
+					},
+				});
+			});
+		});
+	};
+};
+
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;
+export default rule;