@alexlit/lint-kit 182.2.0 → 182.3.0

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

@@ -1,95 +0,0 @@
-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

@@ -1,95 +0,0 @@
-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

@@ -1,323 +0,0 @@
-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

@@ -1,92 +0,0 @@
-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;