@alexlit/lint-kit 173.2.2 → 173.3.0

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

@@ -1,328 +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 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 HAS_ID_CLASS_ATTRIBUTE_PREFIXES = /[#.[]/;
-
-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((ruleNode) => {
-			if (!isStandardSyntaxRule(ruleNode)) {
-				return;
-			}
-
-			if (isKeyframeRule(ruleNode)) {
-				return;
-			}
-
-			if (!HAS_ID_CLASS_ATTRIBUTE_PREFIXES.test(ruleNode.selector)) {
-				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,94 +0,0 @@
-import { isRegExp, isString } from '../../utils/validateTypes.mjs';
-import getRuleSelector from '../../utils/getRuleSelector.mjs';
-import hasPrefix from '../../utils/hasPrefix.mjs';
-import isAutoprefixable from '../../utils/isAutoprefixable.mjs';
-import isStandardSyntaxRule from '../../utils/isStandardSyntaxRule.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((ruleNode) => {
-			if (!hasPrefix(ruleNode.selector)) return;
-
-			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;

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

@@ -1,220 +0,0 @@
-import selectorParser from 'postcss-selector-parser';
-const { isAttribute, isClassName, isIdentifier, isPseudoClass, isTag, isUniversal } =
-	selectorParser;
-
-import { assert } from '../../utils/validateTypes.mjs';
-import getRuleSelector from '../../utils/getRuleSelector.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';
-
-const ruleName = 'selector-not-notation';
-const messages = ruleMessages(ruleName, {
-	expected: (type) => `Expected ${type} :not() pseudo-class notation`,
-});
-const meta = {
-	url: 'https://stylelint.io/user-guide/rules/selector-not-notation',
-	fixable: true,
-};
-
-/** @typedef {import('postcss-selector-parser').Node} Node */
-/** @typedef {import('postcss-selector-parser').Selector} Selector */
-/** @typedef {import('postcss-selector-parser').Pseudo} Pseudo */
-/** @typedef {import('postcss-selector-parser').Root} Root */
-/** @typedef {import('postcss').Rule} Rule */
-/** @typedef {import('stylelint').Range} Range */
-
-/**
- * @param {Node} node
- * @returns {boolean}
- */
-const isSimpleSelector = (node) =>
-	isPseudoClass(node) ||
-	isAttribute(node) ||
-	isClassName(node) ||
-	isUniversal(node) ||
-	isIdentifier(node) ||
-	isTag(node);
-
-/**
- * @param {Node | undefined} node
- * @returns {node is Pseudo}
- */
-const isNot = (node) =>
-	isPseudoClass(node) && node.value !== undefined && node.value.toLowerCase() === ':not';
-
-/**
- * @param {Selector[]} list
- * @returns {boolean}
- */
-const isSimple = (list) => {
-	if (list.length > 1) return false;
-
-	assert(list[0], 'list is never empty');
-	const [first, second] = list[0].nodes;
-
-	if (!first) return true;
-
-	if (second) return false;
-
-	return isSimpleSelector(first) && !isNot(first);
-};
-
-/** @type {import('stylelint').CoreRules[ruleName]} */
-const rule = (primary) => {
-	return (root, result) => {
-		const validOptions = validateOptions(result, ruleName, {
-			actual: primary,
-			possible: ['simple', 'complex'],
-		});
-
-		if (!validOptions) return;
-
-		root.walkRules((ruleNode) => {
-			if (!isStandardSyntaxRule(ruleNode)) return;
-
-			const selector = ruleNode.selector;
-
-			if (!selector.includes(':not(')) return;
-
-			const selectorRoot = parseSelector(getRuleSelector(ruleNode), result, ruleNode);
-
-			if (!selectorRoot) return;
-
-			selectorRoot.walkPseudos((pseudo) => {
-				if (!isNot(pseudo)) return;
-
-				const index = pseudo.sourceIndex;
-				const endIndex = index + pseudo.toString().trim().length;
-
-				let fix;
-
-				if (primary === 'complex') {
-					const prev = pseudo.prev();
-					const hasConsecutiveNot = prev && isNot(prev);
-
-					if (!hasConsecutiveNot) return;
-
-					fix = () => fixComplex(prev, ruleNode, selectorRoot);
-				} else {
-					const selectors = pseudo.nodes;
-
-					if (isSimple(selectors)) return;
-
-					const second = selectors.length > 1 && selectors[1];
-					const isFixable =
-						second && (!second.nodes.length || selectors.every(({ nodes }) => nodes.length === 1));
-
-					if (isFixable) fix = () => fixSimple(pseudo, ruleNode, selectorRoot);
-				}
-
-				report({
-					message: messages.expected,
-					messageArgs: [primary],
-					node: ruleNode,
-					result,
-					ruleName,
-					index,
-					endIndex,
-					fix: {
-						apply: fix,
-						node: ruleNode,
-					},
-				});
-			});
-		});
-	};
-};
-
-/**
- * @param {Pseudo} not
- * @returns {Node}
- */
-const getLastConsecutiveNot = ({ parent, sourceIndex }) => {
-	assert(parent);
-
-	const nodes = parent.nodes;
-	const index = nodes.findIndex((node) => node.sourceIndex >= sourceIndex && !isNot(node));
-	const node = index === -1 ? nodes[nodes.length - 1] : nodes[index - 1];
-
-	assert(node);
-
-	return node;
-};
-
-/**
- * @param {Pseudo} not
- * @param {Rule} ruleNode
- * @param {Root} selectorRoot
- */
-function fixSimple(not, ruleNode, selectorRoot) {
-	const simpleSelectors = not.nodes
-		.filter(({ nodes }) => nodes[0] && isSimpleSelector(nodes[0]))
-		.map((s) => {
-			assert(s.nodes[0]);
-			s.nodes[0].rawSpaceBefore = '';
-			s.nodes[0].rawSpaceAfter = '';
-
-			return s;
-		});
-	const firstSelector = simpleSelectors.shift();
-
-	assert(firstSelector);
-	assert(not.parent);
-
-	not.empty();
-	not.nodes.push(firstSelector);
-
-	for (const s of simpleSelectors) {
-		const last = getLastConsecutiveNot(not);
-		const clone = last.clone({ nodes: [s] });
-
-		clone.rawSpaceBefore = '';
-		not.parent.insertAfter(last, clone);
-	}
-
-	ruleNode.selector = selectorRoot.toString();
-}
-
-/**
- * @param {Pseudo} previousNot
- * @param {Rule} ruleNode
- * @param {Root} selectorRoot
- */
-function fixComplex(previousNot, ruleNode, selectorRoot) {
-	const indentAndTrimRight = (/** @type {Selector[]} */ selectors) => {
-		for (const s of selectors) {
-			assert(s.nodes[0]);
-			s.nodes[0].rawSpaceBefore = ' ';
-			s.nodes[0].rawSpaceAfter = '';
-		}
-	};
-	const [head, ...tail] = previousNot.nodes;
-	let node = previousNot.next();
-
-	if (head == null || head.nodes.length === 0) return;
-
-	assert(head.nodes[0]);
-	head.nodes[0].rawSpaceBefore = '';
-	head.nodes[0].rawSpaceAfter = '';
-	indentAndTrimRight(tail);
-
-	while (isNot(node)) {
-		const selectors = node.nodes;
-		const prev = node;
-
-		indentAndTrimRight(selectors);
-		previousNot.nodes = previousNot.nodes.concat(selectors);
-		node = node.next();
-		prev.remove();
-	}
-
-	ruleNode.selector = selectorRoot.toString();
-}
-
-rule.ruleName = ruleName;
-rule.messages = messages;
-rule.meta = meta;
-export default rule;