@alexlit/lint-kit 182.1.0 → 182.2.0

package/packages/config-stylelint/node_modules/stylelint/lib/rules/selector-max-universal/index.mjs

@@ -0,0 +1,95 @@
+import getRuleSelector from '../../utils/getRuleSelector.mjs';
+import getStrippedSelectorSource from '../../utils/getStrippedSelectorSource.mjs';
+import isNonNegativeInteger from '../../utils/isNonNegativeInteger.mjs';
+import isStandardSyntaxRule from '../../utils/isStandardSyntaxRule.mjs';
+import { isString } from '../../utils/validateTypes.mjs';
+import { mayIncludeRegexes } from '../../utils/regexes.mjs';
+import optionsMatches from '../../utils/optionsMatches.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-max-universal';
+
+const messages = ruleMessages(ruleName, {
+	expected: (selector, max) =>
+		`Expected "${selector}" to have no more than ${max} universal ${
+			max === 1 ? 'selector' : 'selectors'
+		}`,
+});
+
+const meta = {
+	url: 'https://stylelint.io/user-guide/rules/selector-max-universal',
+};
+
+/** @type {import('stylelint').CoreRules[ruleName]} */
+const rule = (primary, secondaryOptions) => {
+	return (root, result) => {
+		const validOptions = validateOptions(
+			result,
+			ruleName,
+			{
+				actual: primary,
+				possible: isNonNegativeInteger,
+			},
+			{
+				actual: secondaryOptions,
+				possible: {
+					ignoreAfterCombinators: [isString],
+				},
+				optional: true,
+			},
+		);
+
+		if (!validOptions) {
+			return;
+		}
+
+		/**
+		 * @param {import('postcss-selector-parser').Selector} selectorNode
+		 * @param {import('postcss').Rule} ruleNode
+		 */
+		function checkSelector(selectorNode, ruleNode) {
+			let count = 0;
+
+			selectorNode.walkUniversals((childNode) => {
+				const prevChildNode = childNode.prev();
+				const prevChildNodeValue = prevChildNode && prevChildNode.value;
+
+				if (optionsMatches(secondaryOptions, 'ignoreAfterCombinators', prevChildNodeValue)) return;
+
+				count += 1;
+			});
+
+			if (count > primary) {
+				const { index, endIndex, selector: selectorStr } = getStrippedSelectorSource(selectorNode);
+
+				report({
+					ruleName,
+					result,
+					node: ruleNode,
+					message: messages.expected,
+					messageArgs: [selectorStr, primary],
+					index,
+					endIndex,
+				});
+			}
+		}
+
+		root.walkRules(mayIncludeRegexes.universalSelector, (ruleNode) => {
+			if (!isStandardSyntaxRule(ruleNode)) return;
+
+			const selectors = parseSelector(getRuleSelector(ruleNode), result, ruleNode);
+
+			selectors?.each((selector) => {
+				checkSelector(selector, ruleNode);
+			});
+		});
+	};
+};
+
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;
+export default rule;

package/packages/config-stylelint/node_modules/stylelint/lib/rules/selector-nested-pattern/index.mjs

@@ -0,0 +1,95 @@
+import { isBoolean, isRegExp, isString } from '../../utils/validateTypes.mjs';
+import getRuleSelector from '../../utils/getRuleSelector.mjs';
+import getStrippedSelectorSource from '../../utils/getStrippedSelectorSource.mjs';
+import isStandardSyntaxRule from '../../utils/isStandardSyntaxRule.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';
+
+/** @import { Rule } from 'postcss' */
+
+const ruleName = 'selector-nested-pattern';
+
+const messages = ruleMessages(ruleName, {
+	expected: (selector, pattern) => `Expected "${selector}" to match pattern "${pattern}"`,
+});
+
+const meta = {
+	url: 'https://stylelint.io/user-guide/rules/selector-nested-pattern',
+};
+
+/** @type {import('stylelint').CoreRules[ruleName]} */
+const rule = (primary, secondaryOptions) => {
+	return (root, result) => {
+		const validOptions = validateOptions(
+			result,
+			ruleName,
+			{
+				actual: primary,
+				possible: [isRegExp, isString],
+			},
+			{
+				actual: secondaryOptions,
+				possible: {
+					splitList: [isBoolean],
+				},
+				optional: true,
+			},
+		);
+
+		if (!validOptions) {
+			return;
+		}
+
+		const normalizedPattern = isString(primary) ? new RegExp(primary) : primary;
+		const splitList = secondaryOptions && secondaryOptions.splitList;
+
+		root.walkRules((ruleNode) => {
+			if (ruleNode.parent && ruleNode.parent.type !== 'rule') {
+				return;
+			}
+
+			if (!isStandardSyntaxRule(ruleNode)) {
+				return;
+			}
+
+			const selectors = getRuleSelector(ruleNode);
+
+			if (splitList) {
+				parseSelector(selectors, result, ruleNode)?.each((selector) => {
+					const { index, endIndex, selector: selectorStr } = getStrippedSelectorSource(selector);
+
+					check(ruleNode, selectorStr, index, endIndex);
+				});
+			} else {
+				check(ruleNode, selectors, 0, selectors.length);
+			}
+		});
+
+		/**
+		 * @param {Rule} ruleNode
+		 * @param {string} selectorStr
+		 * @param {number} index
+		 * @param {number} endIndex
+		 */
+		function check(ruleNode, selectorStr, index, endIndex) {
+			if (normalizedPattern.test(selectorStr)) return;
+
+			report({
+				result,
+				ruleName,
+				message: messages.expected,
+				messageArgs: [selectorStr, primary],
+				node: ruleNode,
+				index,
+				endIndex,
+			});
+		}
+	};
+};
+
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;
+export default rule;

package/packages/config-stylelint/node_modules/stylelint/lib/rules/selector-no-qualifying-type/index.mjs

@@ -0,0 +1,323 @@
+import selectorParser from 'postcss-selector-parser';
+
+import getStrippedSelectorSource from '../../utils/getStrippedSelectorSource.mjs';
+import isKeyframeRule from '../../utils/isKeyframeRule.mjs';
+import isStandardSyntaxRule from '../../utils/isStandardSyntaxRule.mjs';
+import isStandardSyntaxTypeSelector from '../../utils/isStandardSyntaxTypeSelector.mjs';
+import { logicalCombinationsPseudoClasses } from '../../reference/selectors.mjs';
+import { mayIncludeRegexes } from '../../utils/regexes.mjs';
+import optionsMatches from '../../utils/optionsMatches.mjs';
+import report from '../../utils/report.mjs';
+import resolveNestedSelectorsForRule from '../../utils/resolveNestedSelectorsForRule.mjs';
+import ruleMessages from '../../utils/ruleMessages.mjs';
+import validateOptions from '../../utils/validateOptions.mjs';
+
+const ruleName = 'selector-no-qualifying-type';
+
+const messages = ruleMessages(ruleName, {
+	rejected: (selector, type) => {
+		return `Unexpected qualifying type selector "${type}" in "${selector}"`;
+	},
+});
+
+const meta = {
+	url: 'https://stylelint.io/user-guide/rules/selector-no-qualifying-type',
+};
+
+const SELECTOR_CONTAINING_PSEUDO_CLASSES = new Set(
+	[...logicalCombinationsPseudoClasses, 'host'].map((s) => `:${s}`),
+);
+
+/** @import { Tag, Node, Selector, Root } from 'postcss-selector-parser' */
+
+/**
+ * @typedef {Exclude<Node, Selector>} NonSelector
+ */
+
+/**
+ * @param {unknown} node
+ * @returns {node is selectorParser.Pseudo}
+ */
+function isSelectorContainingPseudoClass(node) {
+	return (
+		selectorParser.isPseudoClass(node) &&
+		SELECTOR_CONTAINING_PSEUDO_CLASSES.has(node.value) &&
+		Boolean(node.nodes.length)
+	);
+}
+
+/**
+ * @param {Root} root
+ * @returns {{compoundSelectors: Root, lookupMap: Map<Tag, Tag>}}
+ */
+function getCompoundSelectors(root) {
+	const compoundSelectors = selectorParser.root({
+		source: root.source,
+		sourceIndex: root.sourceIndex,
+		value: '',
+		nodes: [],
+	});
+
+	/** @type {Map<Tag, Tag>} */
+	const lookupMap = new Map();
+
+	root.each((selector) => {
+		groupByCompoundSelectors(selector).forEach((compoundSelector) => {
+			const selectorClone = selector.clone({
+				nodes: [],
+			});
+
+			compoundSelector.forEach((node) => {
+				const clone = node.clone();
+
+				if (selectorParser.isTag(node)) {
+					lookupMap.set(/** @type {typeof node} */ (clone), node);
+				}
+
+				selectorClone.append(clone);
+			});
+
+			compoundSelectors.append(selectorClone);
+		});
+	});
+
+	return {
+		compoundSelectors,
+		lookupMap,
+	};
+}
+
+/**
+ * @param {Selector} selector
+ * @returns {Array<Array<NonSelector>>}
+ */
+function groupByCompoundSelectors(selector) {
+	/** @type {Array<Array<NonSelector>>} */
+	const compoundSelectors = [];
+	/** @type {Array<Array<NonSelector>>} */
+	let currentCompoundSelectors = [[]];
+
+	selector.each((node) => {
+		if (selectorParser.isCombinator(node)) {
+			compoundSelectors.push(...currentCompoundSelectors);
+			currentCompoundSelectors = [[]];
+
+			return;
+		}
+
+		if (selectorParser.isPseudoElement(node)) {
+			compoundSelectors.push(...currentCompoundSelectors);
+			currentCompoundSelectors = [[]];
+		}
+
+		if (isSelectorContainingPseudoClass(node)) {
+			/** @type {Array<Array<NonSelector>>} */
+			const compoundSelectorsCombinations = [];
+
+			node.each((childSelector) => {
+				const childCompounds = groupByCompoundSelectors(childSelector);
+
+				const rightMost = childCompounds.at(-1);
+
+				if (!rightMost) return;
+
+				const remainder = childCompounds.slice(0, -1);
+
+				compoundSelectors.push(...remainder);
+
+				currentCompoundSelectors.forEach((compoundSelector) => {
+					compoundSelectorsCombinations.push([...compoundSelector, ...rightMost]);
+				});
+			});
+
+			currentCompoundSelectors = compoundSelectorsCombinations;
+
+			return;
+		}
+
+		currentCompoundSelectors.forEach((compoundSelector) => {
+			compoundSelector.push(node);
+		});
+	});
+
+	if (currentCompoundSelectors.length) {
+		compoundSelectors.push(...currentCompoundSelectors);
+	}
+
+	return compoundSelectors;
+}
+
+/**
+ * @param {Node} node
+ * @returns {Array<Node>}
+ */
+function getOriginalCompound(node) {
+	const container = node.parent?.parent;
+
+	if (isSelectorContainingPseudoClass(container)) {
+		return getOriginalCompound(container);
+	}
+
+	/** @type {Array<Node>} */
+	const result = [node];
+
+	/** @type {Node | undefined} */
+	let leftNode = node;
+
+	while ((leftNode = leftNode.prev())) {
+		if (selectorParser.isCombinator(leftNode) || selectorParser.isPseudoElement(leftNode)) {
+			break;
+		}
+
+		if (selectorParser.isComment(leftNode)) {
+			continue;
+		}
+
+		result.push(leftNode);
+	}
+
+	result.reverse();
+
+	/** @type {Node | undefined} */
+	let rightNode = node;
+
+	while ((rightNode = rightNode.next())) {
+		if (selectorParser.isCombinator(rightNode) || selectorParser.isPseudoElement(rightNode)) {
+			break;
+		}
+
+		if (selectorParser.isComment(rightNode)) {
+			continue;
+		}
+
+		result.push(rightNode);
+	}
+
+	while ((rightNode = result.at(-1))) {
+		if (
+			selectorParser.isIdentifier(rightNode) ||
+			selectorParser.isClassName(rightNode) ||
+			selectorParser.isAttribute(rightNode) ||
+			selectorParser.isTag(rightNode)
+		) {
+			break;
+		}
+
+		if (isSelectorContainingPseudoClass(rightNode)) {
+			break;
+		}
+
+		result.splice(-1, 1);
+	}
+
+	return result;
+}
+
+/** @type {import('stylelint').CoreRules[ruleName]} */
+const rule = (primary, secondaryOptions) => {
+	return (root, result) => {
+		const validOptions = validateOptions(
+			result,
+			ruleName,
+			{
+				actual: primary,
+				possible: [true],
+			},
+			{
+				actual: secondaryOptions,
+				possible: {
+					ignore: ['attribute', 'class', 'id'],
+				},
+				optional: true,
+			},
+		);
+
+		if (!validOptions) {
+			return;
+		}
+
+		const ignoreId = optionsMatches(secondaryOptions, 'ignore', 'id');
+		const ignoreClass = optionsMatches(secondaryOptions, 'ignore', 'class');
+		const ignoreAttribute = optionsMatches(secondaryOptions, 'ignore', 'attribute');
+
+		root.walkRules(mayIncludeRegexes.idClassAttributeSelector, (ruleNode) => {
+			if (!isStandardSyntaxRule(ruleNode)) {
+				return;
+			}
+
+			if (isKeyframeRule(ruleNode)) {
+				return;
+			}
+
+			/**
+			 * @param {Root} resolvedSelectorNode
+			 * @param {Selector} selectorNode
+			 * @param {boolean} nested
+			 */
+			function checkSelector(resolvedSelectorNode, selectorNode, nested) {
+				const { compoundSelectors, lookupMap } = getCompoundSelectors(resolvedSelectorNode);
+
+				compoundSelectors.walkTags((tagNode) => {
+					const originalTag = lookupMap.get(tagNode);
+
+					if (!originalTag) return;
+
+					if (!isStandardSyntaxTypeSelector(originalTag)) return;
+
+					const selectorParent = tagNode.parent;
+
+					if (!selectorParent || selectorParent.nodes.length === 1) {
+						return;
+					}
+
+					const siblingNodes = selectorParent.nodes;
+
+					const originalCompound = getOriginalCompound(originalTag);
+
+					for (const siblingNode of siblingNodes) {
+						if (
+							(selectorParser.isIdentifier(siblingNode) && !ignoreId) ||
+							(selectorParser.isClassName(siblingNode) && !ignoreClass) ||
+							(selectorParser.isAttribute(siblingNode) && !ignoreAttribute)
+						) {
+							const selector = originalCompound.join('').trim();
+
+							let index = 0;
+							let endIndex = 0;
+
+							if (nested) {
+								({ index, endIndex } = getStrippedSelectorSource(selectorNode));
+							} else {
+								index = tagNode.sourceIndex ?? 0;
+								endIndex = index + tagNode.value.length;
+							}
+
+							report({
+								ruleName,
+								result,
+								node: ruleNode,
+								message: messages.rejected,
+								messageArgs: [selector, tagNode.value],
+								index,
+								endIndex,
+							});
+
+							break;
+						}
+					}
+				});
+			}
+
+			resolveNestedSelectorsForRule(ruleNode, result).forEach(
+				({ selector, resolvedSelectors, nested }) => {
+					checkSelector(resolvedSelectors, selector, nested);
+				},
+			);
+		});
+	};
+};
+
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;
+export default rule;

package/packages/config-stylelint/node_modules/stylelint/lib/rules/selector-no-vendor-prefix/index.mjs

@@ -0,0 +1,92 @@
+import { isRegExp, isString } from '../../utils/validateTypes.mjs';
+import getRuleSelector from '../../utils/getRuleSelector.mjs';
+import isAutoprefixable from '../../utils/isAutoprefixable.mjs';
+import isStandardSyntaxRule from '../../utils/isStandardSyntaxRule.mjs';
+import { mayIncludeRegexes } from '../../utils/regexes.mjs';
+import optionsMatches from '../../utils/optionsMatches.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-no-vendor-prefix';
+
+const messages = ruleMessages(ruleName, {
+	rejected: (selector) => `Unexpected vendor-prefixed selector "${selector}"`,
+});
+
+const meta = {
+	url: 'https://stylelint.io/user-guide/rules/selector-no-vendor-prefix',
+	fixable: true,
+};
+
+/** @type {import('stylelint').CoreRules[ruleName]} */
+const rule = (primary, secondaryOptions) => {
+	return (root, result) => {
+		const validOptions = validateOptions(
+			result,
+			ruleName,
+			{ actual: primary },
+			{
+				actual: secondaryOptions,
+				possible: {
+					ignoreSelectors: [isString, isRegExp],
+				},
+				optional: true,
+			},
+		);
+
+		if (!validOptions) {
+			return;
+		}
+
+		root.walkRules(mayIncludeRegexes.prefix, (ruleNode) => {
+			if (!isStandardSyntaxRule(ruleNode)) {
+				return;
+			}
+
+			const resolvedRoot = parseSelector(getRuleSelector(ruleNode), result, ruleNode);
+
+			if (!resolvedRoot) return;
+
+			resolvedRoot.walkPseudos((pseudoNode) => {
+				const { value } = pseudoNode;
+
+				if (!isAutoprefixable.selector(value)) {
+					return;
+				}
+
+				if (optionsMatches(secondaryOptions, 'ignoreSelectors', value)) {
+					return;
+				}
+
+				const fix = () => {
+					pseudoNode.value = isAutoprefixable.unprefix(value);
+					ruleNode.selector = resolvedRoot.toString();
+				};
+
+				const index = pseudoNode.sourceIndex;
+				const endIndex = index + value.length;
+
+				report({
+					result,
+					ruleName,
+					message: messages.rejected,
+					messageArgs: [value],
+					node: ruleNode,
+					index,
+					endIndex,
+					fix: {
+						apply: fix,
+						node: ruleNode,
+					},
+				});
+			});
+		});
+	};
+};
+
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;
+export default rule;