@alexlit/lint-kit 173.2.2 → 173.3.0

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

@@ -1,250 +0,0 @@
-import { find, fork, parse, string } from 'css-tree';
-import syntaxPatchesJson from '@csstools/css-syntax-patches-for-csstree' with { type: 'json' };
-
-import { isRegExp, isString } from '../../utils/validateTypes.mjs';
-import { atRuleRegexes } from '../../utils/regexes.mjs';
-import { declarationValueIndex } from '../../utils/nodeFieldIndices.mjs';
-import { isDeclaration } from '../../utils/typeGuards.mjs';
-
-import getDeclarationValue from '../../utils/getDeclarationValue.mjs';
-import isCustomProperty from '../../utils/isCustomProperty.mjs';
-import isDescriptorDeclaration from '../../utils/isDescriptorDeclaration.mjs';
-import isStandardSyntaxDeclaration from '../../utils/isStandardSyntaxDeclaration.mjs';
-import isStandardSyntaxProperty from '../../utils/isStandardSyntaxProperty.mjs';
-import isStandardSyntaxValue from '../../utils/isStandardSyntaxValue.mjs';
-import matchesStringOrRegExp from '../../utils/matchesStringOrRegExp.mjs';
-import mergeSyntaxDefinitions from '../../utils/mergeSyntaxDefinitions.mjs';
-import report from '../../utils/report.mjs';
-import ruleMessages from '../../utils/ruleMessages.mjs';
-import validateObjectWithArrayProps from '../../utils/validateObjectWithArrayProps.mjs';
-import validateObjectWithProps from '../../utils/validateObjectWithProps.mjs';
-import validateOptions from '../../utils/validateOptions.mjs';
-
-const { next: syntaxPatches } = syntaxPatchesJson;
-
-const ruleName = 'declaration-property-value-no-unknown';
-
-const messages = ruleMessages(ruleName, {
-	rejected: (property, value) => `Unexpected unknown value "${value}" for property "${property}"`,
-	rejectedParseError: (property, value) =>
-		`Cannot parse property value "${value}" for property "${property}"`,
-});
-
-const meta = {
-	url: 'https://stylelint.io/user-guide/rules/declaration-property-value-no-unknown',
-};
-
-const SYNTAX_DESCRIPTOR = /^syntax$/i;
-
-/** @typedef {import('stylelint').CoreRules[ruleName]} Rule */
-/** @typedef {Parameters<Rule>[1]} SecondaryOptions */
-
-/** @type {Rule} */
-const rule = (primary, secondaryOptions) => {
-	return (root, result) => {
-		const validOptions = validateOptions(
-			result,
-			ruleName,
-			{ actual: primary },
-			{
-				actual: secondaryOptions,
-				possible: {
-					ignoreProperties: [validateObjectWithArrayProps(isString, isRegExp)],
-					propertiesSyntax: [validateObjectWithProps(isString)],
-					typesSyntax: [validateObjectWithProps(isString)],
-				},
-				optional: true,
-			},
-		);
-
-		if (!validOptions) {
-			return;
-		}
-
-		const ignoreProperties = Array.from(Object.entries(secondaryOptions?.ignoreProperties ?? {}));
-
-		/** @type {(name: string, propValue: string) => boolean} */
-		const isPropIgnored = (name, value) => {
-			const [, valuePattern] =
-				ignoreProperties.find(([namePattern]) => matchesStringOrRegExp(name, namePattern)) || [];
-
-			return Boolean(valuePattern && matchesStringOrRegExp(value, valuePattern));
-		};
-
-		const propertiesSyntax = { ...secondaryOptions?.propertiesSyntax };
-		const typesSyntax = { ...secondaryOptions?.typesSyntax };
-
-		/** @type {Map<string, string>} */
-		const typedCustomPropertyNames = new Map();
-
-		root.walkAtRules(atRuleRegexes.propertyName, (atRule) => {
-			const propName = atRule.params.trim();
-
-			if (!propName || !atRule.nodes || !isCustomProperty(propName)) return;
-
-			for (const node of atRule.nodes) {
-				if (isDeclaration(node) && SYNTAX_DESCRIPTOR.test(node.prop)) {
-					const value = node.value.trim();
-					const unquoted = string.decode(value);
-
-					// Only string values are valid.
-					// We can not check the syntax of this property.
-					if (unquoted === value) continue;
-
-					// Any value is allowed in this custom property.
-					// We don't need to check this property.
-					if (unquoted === '*') continue;
-
-					// https://github.com/csstree/csstree/pull/256
-					// We can circumvent this issue by prefixing the property name,
-					// making it a vendor-prefixed property instead of a custom property.
-					// No one should be using `-stylelint--` as a property prefix.
-					//
-					// When this is resolved `typedCustomPropertyNames` can become a `Set<string>`
-					// and the prefix can be removed.
-					const prefixedPropName = `-stylelint${propName}`;
-
-					typedCustomPropertyNames.set(propName, prefixedPropName);
-					propertiesSyntax[prefixedPropName] = unquoted;
-				}
-			}
-		});
-
-		const languageOptions = result.stylelint.config?.languageOptions;
-		const forkedLexer = fork(
-			mergeSyntaxDefinitions(
-				syntaxPatches,
-				{ ...languageOptions?.syntax, atrules: languageOptions?.syntax?.atRules },
-				{ properties: propertiesSyntax, types: typesSyntax },
-			),
-		).lexer;
-
-		root.walkDecls((decl) => {
-			const { prop } = decl;
-			const value = getDeclarationValue(decl);
-
-			// csstree/csstree#243
-			// NOTE: CSSTree's `fork()` doesn't support `-moz-initial`, but it may be possible in the future.
-			if (/^-moz-initial$/i.test(value)) return;
-
-			if (!isStandardSyntaxDeclaration(decl)) return;
-
-			if (isDescriptorDeclaration(decl)) return;
-
-			if (!isStandardSyntaxProperty(prop)) return;
-
-			if (!isStandardSyntaxValue(value)) return;
-
-			if (isCustomProperty(prop) && !typedCustomPropertyNames.has(prop)) return;
-
-			if (isPropIgnored(prop, value)) return;
-
-			/** @type {import('css-tree').CssNode} */
-			let cssTreeValueNode;
-
-			try {
-				cssTreeValueNode = parse(value, { context: 'value', positions: true });
-
-				if (containsUnsupportedFunction(cssTreeValueNode)) return;
-			} catch {
-				// Ignore parse errors for `attr()`, `if()` and custom functions
-				// See: https://github.com/stylelint/stylelint/issues/8779
-				if (/(?:^|[^\w-])(?:attr|if|--[\w-]+)\(/i.test(value)) return;
-
-				const index = declarationValueIndex(decl);
-				const endIndex = index + value.length;
-
-				report({
-					message: messages.rejectedParseError,
-					messageArgs: [prop, value],
-					node: decl,
-					index,
-					endIndex,
-					result,
-					ruleName,
-				});
-
-				return;
-			}
-
-			const { error } = forkedLexer.matchProperty(
-				typedCustomPropertyNames.get(prop) ?? prop,
-				cssTreeValueNode,
-			);
-
-			if (!error) return;
-
-			if (!('mismatchLength' in error)) return;
-
-			const { name, rawMessage, loc } = error;
-
-			if (name !== 'SyntaxMatchError') return;
-
-			if (rawMessage !== 'Mismatch') return;
-
-			const valueIndex = declarationValueIndex(decl);
-			const mismatchValue = value.slice(loc.start.offset, loc.end.offset);
-
-			const functionNode = find(
-				cssTreeValueNode,
-				(node) =>
-					node.type === 'Function' &&
-					node.loc !== undefined &&
-					loc.start.offset >= node.loc.start.offset &&
-					loc.end.offset <= node.loc.end.offset,
-			);
-
-			if (functionNode?.loc) {
-				const valueFunction = value.slice(
-					functionNode.loc.start.offset,
-					functionNode.loc.end.offset,
-				);
-
-				const index = valueIndex + functionNode.loc.start.offset;
-				const endIndex = index + valueFunction.length;
-
-				report({
-					message: messages.rejected,
-					messageArgs: [prop, valueFunction],
-					node: decl,
-					index,
-					endIndex,
-					result,
-					ruleName,
-				});
-
-				return;
-			}
-
-			report({
-				message: messages.rejected,
-				messageArgs: [prop, mismatchValue],
-				node: decl,
-				index: valueIndex + loc.start.offset,
-				endIndex: valueIndex + loc.end.offset,
-				result,
-				ruleName,
-			});
-		});
-	};
-};
-
-/**
- * @see csstree/csstree#164 min, max, clamp
- * @see csstree/csstree#245 env
- * @param {import('css-tree').CssNode} cssTreeNode
- * @returns {boolean}
- */
-function containsUnsupportedFunction(cssTreeNode) {
-	return Boolean(
-		find(
-			cssTreeNode,
-			(node) => node.type === 'Function' && ['clamp', 'min', 'max', 'env'].includes(node.name),
-		),
-	);
-}
-
-rule.ruleName = ruleName;
-rule.messages = messages;
-rule.meta = meta;
-export default rule;

package/packages/config-stylelint/node_modules/stylelint/lib/rules/display-notation/index.mjs

@@ -1,226 +0,0 @@
-import {
-	TokenType,
-	isTokenComment,
-	isTokenEOF,
-	isTokenIdent,
-	isTokenWhiteSpaceOrComment,
-	stringify,
-	tokenize,
-} from '@csstools/css-tokenizer';
-
-import { declarationValueIndex } from '../../utils/nodeFieldIndices.mjs';
-import getDeclarationValue from '../../utils/getDeclarationValue.mjs';
-import isStandardSyntaxValue from '../../utils/isStandardSyntaxValue.mjs';
-import report from '../../utils/report.mjs';
-import ruleMessages from '../../utils/ruleMessages.mjs';
-import setDeclarationValue from '../../utils/setDeclarationValue.mjs';
-import validateOptions from '../../utils/validateOptions.mjs';
-
-/** @import {CSSToken,TokenIdent} from '@csstools/css-tokenizer' */
-
-const ruleName = 'display-notation';
-
-const messages = ruleMessages(ruleName, {
-	expected: (unexpected, expected) => `Expected "${unexpected}" to be "${expected}"`,
-});
-
-const meta = {
-	url: 'https://stylelint.io/user-guide/rules/display-notation',
-	fixable: true,
-};
-
-const DISPLAY_OUTSIDE_KEYWORDS = ['block', 'inline', 'run-in'];
-const DISPLAY_INSIDE_KEYWORDS = ['flow', 'flow-root', 'table', 'flex', 'grid', 'ruby'];
-const DISPLAY_LEGACY_KEYWORDS = ['inline-block', 'inline-table', 'inline-flex', 'inline-grid'];
-const DISPLAY_LIST_ITEM_KEYWORD = 'list-item';
-
-const SHORT_OR_LONG_KEYWORD = new RegExp(
-	`\\b(?:${[DISPLAY_LIST_ITEM_KEYWORD, ...DISPLAY_OUTSIDE_KEYWORDS, ...DISPLAY_INSIDE_KEYWORDS, ...DISPLAY_LEGACY_KEYWORDS].join('|')})\\b`,
-	'i',
-);
-
-const DISPLAY_OUTSIDE = new RegExp(`^(?:${DISPLAY_OUTSIDE_KEYWORDS.join('|')})$`, 'i');
-const DISPLAY_INSIDE = new RegExp(`^(?:${DISPLAY_INSIDE_KEYWORDS.join('|')})$`, 'i');
-const DISPLAY_LIST_ITEM = new RegExp(`^${DISPLAY_LIST_ITEM_KEYWORD}$`, 'i');
-
-const DISPLAY_PROPERTY = /^display$/i;
-
-/** @type {Record<string, Array<string>>} */
-const SHORT_TO_LONG = {
-	'block list-item': ['block', 'flow', 'list-item'],
-	block: ['block', 'flow'],
-	flex: ['block', 'flex'],
-	'flow list-item': ['block', 'flow', 'list-item'],
-	flow: ['block', 'flow'],
-	'flow-root': ['block', 'flow-root'],
-	grid: ['block', 'grid'],
-	'inline list-item': ['inline', 'flow', 'list-item'],
-	inline: ['inline', 'flow'],
-	'inline-block': ['inline', 'flow-root'],
-	'inline-flex': ['inline', 'flex'],
-	'inline-grid': ['inline', 'grid'],
-	'inline-table': ['inline', 'table'],
-	'list-item': ['block', 'flow', 'list-item'],
-	ruby: ['inline', 'ruby'],
-	'run-in': ['run-in', 'flow'],
-	table: ['block', 'table'],
-};
-
-/** @type {Record<string, Array<string>>} */
-const LONG_TO_SHORT = {
-	'block flex': ['flex'],
-	'block flow list-item': ['list-item'],
-	'block flow': ['block'],
-	'block flow-root': ['flow-root'],
-	'block grid': ['grid'],
-	'block list-item': ['list-item'],
-	'block table': ['table'],
-	'flow list-item': ['list-item'],
-	'inline flex': ['inline-flex'],
-	'inline flow list-item': ['inline', 'list-item'],
-	'inline flow': ['inline'],
-	'inline flow-root': ['inline-block'],
-	'inline grid': ['inline-grid'],
-	'inline ruby': ['ruby'],
-	'inline table': ['inline-table'],
-	'run-in flow': ['run-in'],
-};
-
-/** @type {import('stylelint').CoreRules[ruleName]} */
-const rule = (primary) => {
-	return (root, result) => {
-		const validOptions = validateOptions(result, ruleName, {
-			actual: primary,
-			possible: ['short', 'full'],
-		});
-
-		if (!validOptions) return;
-
-		root.walkDecls(DISPLAY_PROPERTY, (decl) => {
-			const value = getDeclarationValue(decl);
-
-			if (!SHORT_OR_LONG_KEYWORD.test(value)) return;
-
-			if (!isStandardSyntaxValue(value)) return;
-
-			const tokens = tokenize({ css: value });
-
-			// ignore values that contain functions or other non-keyword values
-			const hasNonKeywordTokens = tokens.some(
-				(token) => !(isTokenWhiteSpaceOrComment(token) || isTokenEOF(token) || isTokenIdent(token)),
-			);
-
-			if (hasNonKeywordTokens) return;
-
-			const keywords = tokens.filter(isTokenIdent);
-
-			if (!keywords.length) return;
-
-			const normalizedValue = normalizeValue(keywords);
-
-			const replacementValue =
-				primary === 'short' ? LONG_TO_SHORT[normalizedValue] : SHORT_TO_LONG[normalizedValue];
-
-			if (!replacementValue) return;
-
-			const firstKeyword = keywords.at(0);
-			const lastKeyword = keywords.at(-1);
-
-			if (!firstKeyword || !lastKeyword) return;
-
-			const index = declarationValueIndex(decl);
-
-			report({
-				message: messages.expected,
-				messageArgs: [normalizedValue, replacementValue.join(' ')],
-				node: decl,
-				index: index + firstKeyword[2],
-				endIndex: index + lastKeyword[3] + 1,
-				result,
-				ruleName,
-				fix: {
-					apply: () => {
-						setDeclarationValue(
-							decl,
-							fixValue(tokens, firstKeyword, lastKeyword, replacementValue),
-						);
-					},
-					node: decl,
-				},
-			});
-		});
-	};
-};
-
-/**
- * @param {string} a
- * @returns {number}
- */
-function keywordOrder(a) {
-	if (DISPLAY_OUTSIDE.test(a)) return 1;
-
-	if (DISPLAY_INSIDE.test(a)) return 2;
-
-	if (DISPLAY_LIST_ITEM.test(a)) return 3;
-
-	return 0;
-}
-
-/**
- * @param {string} a
- * @param {string} b
- * @returns {number}
- */
-function compareKeywords(a, b) {
-	return keywordOrder(a) - keywordOrder(b);
-}
-
-/**
- * @param {Array<TokenIdent>} tokens
- * @returns {string}
- */
-function normalizeValue(tokens) {
-	return tokens
-		.map((token) => token[4].value)
-		.sort(compareKeywords)
-		.join(' ')
-		.toLowerCase();
-}
-
-/**
- * @param {Array<CSSToken>} originalValue
- * @param {TokenIdent} firstKeyword
- * @param {TokenIdent} lastKeyword
- * @param {Array<string>} replacement
- * @returns {string}
- */
-function fixValue(originalValue, firstKeyword, lastKeyword, replacement) {
-	const before = originalValue.slice(0, originalValue.indexOf(firstKeyword));
-	const commentsBetweenKeywords = originalValue
-		.slice(originalValue.indexOf(firstKeyword), originalValue.indexOf(lastKeyword))
-		.filter(isTokenComment);
-	const after = originalValue.slice(originalValue.indexOf(lastKeyword) + 1);
-
-	return stringify(
-		...before,
-		...replacement.flatMap((keyword, index) => {
-			/** @type {Array<CSSToken>} */
-			const tokens = [];
-
-			if (index !== 0) {
-				tokens.push([TokenType.Whitespace, ' ', -1, -1, undefined]);
-			}
-
-			tokens.push([TokenType.Ident, keyword, -1, -1, { value: keyword }]);
-
-			return tokens;
-		}),
-		...commentsBetweenKeywords,
-		...after,
-	);
-}
-
-rule.ruleName = ruleName;
-rule.messages = messages;
-rule.meta = meta;
-export default rule;