@alexlit/lint-kit 182.2.0 → 182.3.0

package/packages/config-stylelint/node_modules/stylelint/lib/rules/rule-nesting-at-rule-required-list/index.mjs

@@ -1,85 +0,0 @@
-import { isAtRule, isRoot } from '../../utils/typeGuards.mjs';
-import { isRegExp, isString } from '../../utils/validateTypes.mjs';
-import isStandardSyntaxRule from '../../utils/isStandardSyntaxRule.mjs';
-import matchesStringOrRegExp from '../../utils/matchesStringOrRegExp.mjs';
-import report from '../../utils/report.mjs';
-import ruleMessages from '../../utils/ruleMessages.mjs';
-import validateOptions from '../../utils/validateOptions.mjs';
-
-const ruleName = 'rule-nesting-at-rule-required-list';
-
-const messages = ruleMessages(ruleName, {
-	expected: (...atRulePatterns) => {
-		const patterns = atRulePatterns.map((pattern) => `"${pattern}"`).join(', ');
-
-		return `Expected rule to be nested in an at-rule matching pattern(s): ${patterns}`;
-	},
-});
-
-const meta = {
-	url: 'https://stylelint.io/user-guide/rules/rule-nesting-at-rule-required-list',
-};
-
-/** @type {import('stylelint').CoreRules[ruleName]} */
-const rule = (primary) => {
-	return (root, result) => {
-		// Validate that the primary option is a string, regex, or array of strings/regexes
-		const validOptions = validateOptions(result, ruleName, {
-			actual: primary,
-			possible: [isString, isRegExp],
-		});
-
-		if (!validOptions) return;
-
-		const requiredAtRules = [primary].flat();
-
-		root.walkRules((ruleNode) => {
-			if (!isStandardSyntaxRule(ruleNode)) return;
-
-			// Skip if rule already has a required at-rule ancestor
-			if (hasRequiredAtRuleAncestor(ruleNode, requiredAtRules)) return;
-
-			report({
-				message: messages.expected,
-				messageArgs: requiredAtRules,
-				node: ruleNode,
-				result,
-				ruleName,
-			});
-		});
-	};
-};
-
-/**
- * Check if rule has a required at-rule ancestor
- * Traverses up the PostCSS AST tree from the rule to find
- * if any parent node is an at-rule that matches the required patterns
- * @param {import('postcss').Rule} ruleNode - The CSS rule to check
- * @param {Array<string | RegExp>} requiredAtRules - Patterns to match at-rule names against
- * @returns {boolean} True if rule has required at-rule ancestor, false otherwise
- */
-function hasRequiredAtRuleAncestor(ruleNode, requiredAtRules) {
-	let current = ruleNode.parent;
-
-	while (current) {
-		// Check if current node is an at-rule (e.g., @layer, @scope, @supports)
-		if (isAtRule(current)) {
-			const atRuleName = current.name;
-
-			// Check if at-rule name matches any of the required patterns
-			if (matchesStringOrRegExp(atRuleName, requiredAtRules)) return true;
-		}
-
-		if (isRoot(current)) break;
-
-		current = current.parent;
-	}
-
-	return false;
-}
-
-rule.primaryOptionArray = true;
-rule.ruleName = ruleName;
-rule.messages = messages;
-rule.meta = meta;
-export default rule;

package/packages/config-stylelint/node_modules/stylelint/lib/rules/rule-selector-property-disallowed-list/index.mjs

@@ -1,119 +0,0 @@
-import { isRegExp, isString } from '../../utils/validateTypes.mjs';
-import isKeyframeRule from '../../utils/isKeyframeRule.mjs';
-import isStandardSyntaxRule from '../../utils/isStandardSyntaxRule.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 = 'rule-selector-property-disallowed-list';
-
-const messages = ruleMessages(ruleName, {
-	rejected: (selector, property) => `Unexpected property "${property}" for selector "${selector}"`,
-});
-
-const meta = {
-	url: 'https://stylelint.io/user-guide/rules/rule-selector-property-disallowed-list',
-};
-
-/** @type {import('stylelint').CoreRules[ruleName]} */
-const rule = (primary, secondaryOptions) => {
-	return (root, result) => {
-		const validOptions = validateOptions(
-			result,
-			ruleName,
-			{
-				actual: primary,
-				possible: [validateObjectWithArrayProps(isString, isRegExp)],
-			},
-			{
-				actual: secondaryOptions,
-				possible: {
-					ignore: ['keyframe-selectors'],
-				},
-				optional: true,
-			},
-		);
-
-		if (!validOptions) {
-			return;
-		}
-
-		const ignoreKeyframeSelectors = optionsMatches(
-			secondaryOptions,
-			'ignore',
-			'keyframe-selectors',
-		);
-
-		const selectors = Object.keys(primary);
-
-		root.walkRules((ruleNode) => {
-			if (!isStandardSyntaxRule(ruleNode)) {
-				return;
-			}
-
-			if (ignoreKeyframeSelectors && isKeyframeRule(ruleNode)) {
-				return;
-			}
-
-			const selectorKey = selectors.find((selector) =>
-				matchesStringOrRegExp(ruleNode.selector, selector),
-			);
-
-			if (!selectorKey) {
-				return;
-			}
-
-			const disallowedProperties = primary[selectorKey];
-
-			if (!disallowedProperties) {
-				return;
-			}
-
-			ruleNode.walkDecls((decl) => {
-				if (!declarationIsAChildOfRule(decl, ruleNode)) return;
-
-				const { prop } = decl;
-
-				if (matchesStringOrRegExp(prop, disallowedProperties)) {
-					report({
-						message: messages.rejected,
-						messageArgs: [ruleNode.selector, prop],
-						node: decl,
-						result,
-						ruleName,
-						word: prop,
-					});
-				}
-			});
-		});
-	};
-};
-
-rule.ruleName = ruleName;
-rule.messages = messages;
-rule.meta = meta;
-export default rule;
-
-/**
- * Check that a given declaration is a child of this rule and not a nested rule
- *
- * @param {import('postcss').Declaration} decl
- * @param {import('postcss').Rule} ruleNode
- */
-function declarationIsAChildOfRule(decl, ruleNode) {
-	/** @type {import('postcss').Container['parent']} */
-	let parent = decl.parent;
-
-	while (parent) {
-		if (parent === ruleNode) return true;
-
-		if (parent.type === 'rule') return false;
-
-		parent = parent.parent;
-	}
-
-	return false;
-}

package/packages/config-stylelint/node_modules/stylelint/lib/rules/selector-anb-no-unmatchable/index.mjs

@@ -1,121 +0,0 @@
-import { parse } from 'css-tree';
-
-import {
-	aNPlusBNotationPseudoClasses,
-	aNPlusBOfSNotationPseudoClasses,
-} from '../../reference/selectors.mjs';
-import { assert } from '../../utils/validateTypes.mjs';
-import getRuleSelector from '../../utils/getRuleSelector.mjs';
-import isStandardSyntaxRule from '../../utils/isStandardSyntaxRule.mjs';
-import { mayIncludeRegexes } from '../../utils/regexes.mjs';
-import report from '../../utils/report.mjs';
-import ruleMessages from '../../utils/ruleMessages.mjs';
-import validateOptions from '../../utils/validateOptions.mjs';
-
-const ruleName = 'selector-anb-no-unmatchable';
-
-const messages = ruleMessages(ruleName, {
-	rejected: (pseudoClass) => `Unexpected unmatchable An+B selector "${pseudoClass}"`,
-});
-
-const meta = {
-	url: 'https://stylelint.io/user-guide/rules/selector-anb-no-unmatchable',
-};
-
-function isUnmatchableNth(/** @type {import('css-tree').AnPlusB} */ nth) {
-	const { a, b } = nth;
-
-	if (a !== null && a !== '0' && a !== '-0') {
-		return false;
-	}
-
-	if (b !== null && b !== '0' && b !== '-0') {
-		return false;
-	}
-
-	return true;
-}
-
-/** @type {import('stylelint').CoreRules[ruleName]} */
-const rule = (primary) => {
-	return (root, result) => {
-		const validOptions = validateOptions(result, ruleName, { actual: primary });
-
-		if (!validOptions) {
-			return;
-		}
-
-		root.walkRules(mayIncludeRegexes.aNPlusBNotationPseudoClass, (ruleNode) => {
-			if (!isStandardSyntaxRule(ruleNode)) return;
-
-			const ruleSelector = getRuleSelector(ruleNode);
-			let cssTreeSelectors;
-
-			try {
-				cssTreeSelectors = parse(ruleSelector, {
-					context: 'selectorList',
-					positions: true,
-				});
-			} catch {
-				return;
-			}
-
-			if (cssTreeSelectors.type !== 'SelectorList') return;
-
-			cssTreeSelectors.children.forEach((cssTreeSelector) => {
-				checkSelector(cssTreeSelector);
-			});
-
-			function checkSelector(/** @type {import('css-tree').CssNode} */ selector) {
-				if (selector.type !== 'Selector') {
-					return;
-				}
-
-				selector.children.forEach((selectorChild) => {
-					if (
-						selectorChild.type !== 'PseudoClassSelector' ||
-						(!aNPlusBNotationPseudoClasses.has(selectorChild.name) &&
-							!aNPlusBOfSNotationPseudoClasses.has(selectorChild.name))
-					) {
-						return;
-					}
-
-					const pseudoClassSelector = selectorChild;
-
-					if (pseudoClassSelector.children === null) {
-						return;
-					}
-
-					pseudoClassSelector.children.forEach((child) => {
-						if (child.type !== 'Nth' || child.nth.type !== 'AnPlusB') {
-							return;
-						}
-
-						// `loc` is expected to be present when calling `parse()` with `{ positions: true }`
-						assert(pseudoClassSelector.loc);
-
-						const index = pseudoClassSelector.loc.start.offset;
-						const endIndex = pseudoClassSelector.loc.end.offset;
-
-						if (isUnmatchableNth(child.nth)) {
-							report({
-								message: messages.rejected,
-								messageArgs: [ruleSelector.slice(index, endIndex)],
-								node: ruleNode,
-								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/selector-attribute-name-disallowed-list/index.mjs

@@ -1,69 +0,0 @@
-import { isRegExp, isString } from '../../utils/validateTypes.mjs';
-import getRuleSelector from '../../utils/getRuleSelector.mjs';
-import isStandardSyntaxRule from '../../utils/isStandardSyntaxRule.mjs';
-import matchesStringOrRegExp from '../../utils/matchesStringOrRegExp.mjs';
-import { mayIncludeRegexes } from '../../utils/regexes.mjs';
-import parseSelector from '../../utils/parseSelector.mjs';
-import report from '../../utils/report.mjs';
-import ruleMessages from '../../utils/ruleMessages.mjs';
-import validateOptions from '../../utils/validateOptions.mjs';
-
-const ruleName = 'selector-attribute-name-disallowed-list';
-
-const messages = ruleMessages(ruleName, {
-	rejected: (name) => `Unexpected name "${name}"`,
-});
-
-const meta = {
-	url: 'https://stylelint.io/user-guide/rules/selector-attribute-name-disallowed-list',
-};
-
-/** @type {import('stylelint').CoreRules[ruleName]} */
-const rule = (primary) => {
-	return (root, result) => {
-		const validOptions = validateOptions(result, ruleName, {
-			actual: primary,
-			possible: [isString, isRegExp],
-		});
-
-		if (!validOptions) {
-			return;
-		}
-
-		root.walkRules(mayIncludeRegexes.attributeSelector, (ruleNode) => {
-			if (!isStandardSyntaxRule(ruleNode)) {
-				return;
-			}
-
-			parseSelector(getRuleSelector(ruleNode), result, ruleNode)?.walkAttributes(
-				(attributeNode) => {
-					const attributeName = attributeNode.qualifiedAttribute;
-
-					if (!matchesStringOrRegExp(attributeName, primary)) {
-						return;
-					}
-
-					const index = attributeNode.sourceIndex + attributeNode.offsetOf('attribute');
-					const endIndex = index + attributeName.length;
-
-					report({
-						message: messages.rejected,
-						messageArgs: [attributeName],
-						node: ruleNode,
-						index,
-						endIndex,
-						result,
-						ruleName,
-					});
-				},
-			);
-		});
-	};
-};
-
-rule.primaryOptionArray = true;
-
-rule.ruleName = ruleName;
-rule.messages = messages;
-rule.meta = meta;
-export default rule;

package/packages/config-stylelint/node_modules/stylelint/lib/rules/selector-attribute-operator-allowed-list/index.mjs

@@ -1,70 +0,0 @@
-import getRuleSelector from '../../utils/getRuleSelector.mjs';
-import isStandardSyntaxRule from '../../utils/isStandardSyntaxRule.mjs';
-import { isString } from '../../utils/validateTypes.mjs';
-import { mayIncludeRegexes } from '../../utils/regexes.mjs';
-import parseSelector from '../../utils/parseSelector.mjs';
-import report from '../../utils/report.mjs';
-import ruleMessages from '../../utils/ruleMessages.mjs';
-import validateOptions from '../../utils/validateOptions.mjs';
-
-const ruleName = 'selector-attribute-operator-allowed-list';
-
-const messages = ruleMessages(ruleName, {
-	rejected: (operator) => `Unexpected operator "${operator}"`,
-});
-
-const meta = {
-	url: 'https://stylelint.io/user-guide/rules/selector-attribute-operator-allowed-list',
-};
-
-/** @type {import('stylelint').CoreRules[ruleName]} */
-const rule = (primary) => {
-	return (root, result) => {
-		const validOptions = validateOptions(result, ruleName, {
-			actual: primary,
-			possible: [isString],
-		});
-
-		if (!validOptions) {
-			return;
-		}
-
-		const primaryValues = new Set([primary].flat());
-
-		root.walkRules(mayIncludeRegexes.attributeSelectorWithOperator, (ruleNode) => {
-			if (!isStandardSyntaxRule(ruleNode)) {
-				return;
-			}
-
-			parseSelector(getRuleSelector(ruleNode), result, ruleNode)?.walkAttributes(
-				(attributeNode) => {
-					const { operator } = attributeNode;
-
-					if (!operator || primaryValues.has(operator)) {
-						return;
-					}
-
-					const index = attributeNode.sourceIndex + attributeNode.offsetOf('operator');
-					const endIndex = index + operator.length;
-
-					report({
-						message: messages.rejected,
-						messageArgs: [operator],
-						node: ruleNode,
-						index,
-						endIndex,
-						result,
-						ruleName,
-					});
-				},
-			);
-		});
-	};
-};
-
-rule.primaryOptionArray = true;
-
-rule.ruleName = ruleName;
-rule.messages = messages;
-rule.meta = meta;
-export default rule;

package/packages/config-stylelint/node_modules/stylelint/lib/rules/selector-attribute-operator-disallowed-list/index.mjs

@@ -1,70 +0,0 @@
-import getRuleSelector from '../../utils/getRuleSelector.mjs';
-import isStandardSyntaxRule from '../../utils/isStandardSyntaxRule.mjs';
-import { isString } from '../../utils/validateTypes.mjs';
-import { mayIncludeRegexes } from '../../utils/regexes.mjs';
-import parseSelector from '../../utils/parseSelector.mjs';
-import report from '../../utils/report.mjs';
-import ruleMessages from '../../utils/ruleMessages.mjs';
-import validateOptions from '../../utils/validateOptions.mjs';
-
-const ruleName = 'selector-attribute-operator-disallowed-list';
-
-const messages = ruleMessages(ruleName, {
-	rejected: (operator) => `Unexpected operator "${operator}"`,
-});
-
-const meta = {
-	url: 'https://stylelint.io/user-guide/rules/selector-attribute-operator-disallowed-list',
-};
-
-/** @type {import('stylelint').CoreRules[ruleName]} */
-const rule = (primary) => {
-	return (root, result) => {
-		const validOptions = validateOptions(result, ruleName, {
-			actual: primary,
-			possible: [isString],
-		});
-
-		if (!validOptions) {
-			return;
-		}
-
-		const primaryValues = new Set([primary].flat());
-
-		root.walkRules(mayIncludeRegexes.attributeSelectorWithOperator, (ruleNode) => {
-			if (!isStandardSyntaxRule(ruleNode)) {
-				return;
-			}
-
-			parseSelector(getRuleSelector(ruleNode), result, ruleNode)?.walkAttributes(
-				(attributeNode) => {
-					const { operator } = attributeNode;
-
-					if (!operator || !primaryValues.has(operator)) {
-						return;
-					}
-
-					const index = attributeNode.sourceIndex + attributeNode.offsetOf('operator');
-					const endIndex = index + operator.length;
-
-					report({
-						message: messages.rejected,
-						messageArgs: [operator],
-						node: ruleNode,
-						index,
-						endIndex,
-						result,
-						ruleName,
-					});
-				},
-			);
-		});
-	};
-};
-
-rule.primaryOptionArray = true;
-
-rule.ruleName = ruleName;
-rule.messages = messages;
-rule.meta = meta;
-export default rule;

package/packages/config-stylelint/node_modules/stylelint/lib/rules/selector-attribute-quotes/index.mjs

@@ -1,107 +0,0 @@
-import getRuleSelector from '../../utils/getRuleSelector.mjs';
-import isStandardSyntaxRule from '../../utils/isStandardSyntaxRule.mjs';
-import isValidIdentifier from '../../utils/isValidIdentifier.mjs';
-import { mayIncludeRegexes } from '../../utils/regexes.mjs';
-import parseSelector from '../../utils/parseSelector.mjs';
-import report from '../../utils/report.mjs';
-import ruleMessages from '../../utils/ruleMessages.mjs';
-import validateOptions from '../../utils/validateOptions.mjs';
-
-const ruleName = 'selector-attribute-quotes';
-
-const messages = ruleMessages(ruleName, {
-	expected: (value) => `Expected quotes around "${value}"`,
-	rejected: (value) => `Unexpected quotes around "${value}"`,
-});
-
-const meta = {
-	url: 'https://stylelint.io/user-guide/rules/selector-attribute-quotes',
-	fixable: true,
-};
-
-/** @type {import('stylelint').CoreRules[ruleName]} */
-const rule = (primary) => {
-	return (root, result) => {
-		const validOptions = validateOptions(result, ruleName, {
-			actual: primary,
-			possible: ['always', 'never'],
-		});
-
-		if (!validOptions) {
-			return;
-		}
-
-		root.walkRules(mayIncludeRegexes.attributeSelectorWithOperator, (ruleNode) => {
-			if (!isStandardSyntaxRule(ruleNode)) {
-				return;
-			}
-
-			const selectorTree = parseSelector(getRuleSelector(ruleNode), result, ruleNode);
-
-			if (!selectorTree) return;
-
-			/**
-			 * @param {keyof messages} messageType
-			 * @param {import('postcss-selector-parser').Attribute} attrNode
-			 */
-			const complain = (messageType, attrNode) => {
-				const index = attrNode.sourceIndex + attrNode.offsetOf('value');
-				const value = attrNode.value || '';
-				const endIndex = index + (attrNode.raws.value ?? value).length;
-
-				const fix = () => {
-					const quoteMark = messageType === 'expected' ? '"' : null;
-
-					attrNode.quoteMark = quoteMark;
-					ruleNode.selector = selectorTree.toString();
-				};
-
-				report({
-					message: messages[messageType],
-					messageArgs: [value],
-					index,
-					endIndex,
-					result,
-					ruleName,
-					node: ruleNode,
-					fix: {
-						apply: fix,
-						node: ruleNode,
-					},
-				});
-			};
-
-			selectorTree.walkAttributes((attributeNode) => {
-				const { operator, value, quoted } = attributeNode;
-
-				if (!operator || !value) {
-					return;
-				}
-
-				if (!quoted && primary === 'always') {
-					complain('expected', attributeNode);
-				}
-
-				if (quoted && primary === 'never') {
-					// some selectors require quotes to be valid;
-					// we pass in the raw string value, which contains the escape characters
-					// necessary to check if escaped characters are valid
-					// see: https://github.com/stylelint/stylelint/issues/4300
-					if (
-						!attributeNode.raws.value ||
-						!isValidIdentifier(attributeNode.raws.value.slice(1, -1))
-					) {
-						return;
-					}
-
-					complain('rejected', attributeNode);
-				}
-			});
-		});
-	};
-};
-
-rule.ruleName = ruleName;
-rule.messages = messages;
-rule.meta = meta;
-export default rule;