@alexlit/lint-kit 182.2.0 → 182.3.0

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

@@ -1,217 +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 { 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-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(mayIncludeRegexes.notPseudoClass, (ruleNode) => {
-			if (!isStandardSyntaxRule(ruleNode)) 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;

package/packages/config-stylelint/node_modules/stylelint/lib/rules/selector-pseudo-class-allowed-list/index.mjs

@@ -1,84 +0,0 @@
-import { atRuleRegexes, mayIncludeRegexes } from '../../utils/regexes.mjs';
-import { isRegExp, isString } from '../../utils/validateTypes.mjs';
-import { atRuleParamIndex } from '../../utils/nodeFieldIndices.mjs';
-import getAtRuleParams from '../../utils/getAtRuleParams.mjs';
-import getRuleSelector from '../../utils/getRuleSelector.mjs';
-import isStandardSyntaxAtRule from '../../utils/isStandardSyntaxAtRule.mjs';
-import isStandardSyntaxRule from '../../utils/isStandardSyntaxRule.mjs';
-import matchesStringOrRegExp from '../../utils/matchesStringOrRegExp.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-pseudo-class-allowed-list';
-
-const messages = ruleMessages(ruleName, {
-	rejected: (selector) => `Unexpected pseudo-class "${selector}"`,
-});
-
-const meta = {
-	url: 'https://stylelint.io/user-guide/rules/selector-pseudo-class-allowed-list',
-};
-
-/** @import {AtRule, Rule} from 'postcss' */
-
-/** @type {import('stylelint').CoreRules[ruleName]} */
-const rule = (primary) => {
-	return (root, result) => {
-		const validOptions = validateOptions(result, ruleName, {
-			actual: primary,
-			possible: [isString, isRegExp],
-		});
-
-		if (!validOptions) return;
-
-		/**
-		 * @param {string} selector
-		 * @param {AtRule | Rule} node
-		 * @param {number} [offset]
-		 */
-		function check(selector, node, offset = 0) {
-			parseSelector(selector, result, node)?.walkPseudos(({ value, sourceIndex }) => {
-				// Ignore pseudo-elements
-				if (value.slice(0, 2) === '::') return;
-
-				const name = value.slice(1);
-
-				if (matchesStringOrRegExp(name, primary)) return;
-
-				const index = offset + sourceIndex;
-
-				report({
-					message: messages.rejected,
-					messageArgs: [value],
-					node,
-					result,
-					ruleName,
-					index,
-					endIndex: index + value.length,
-				});
-			});
-		}
-
-		root.walkRules(mayIncludeRegexes.pseudo, (ruleNode) => {
-			if (!isStandardSyntaxRule(ruleNode)) return;
-
-			check(getRuleSelector(ruleNode), ruleNode);
-		});
-
-		root.walkAtRules(atRuleRegexes.pageName, (atRuleNode) => {
-			if (!mayIncludeRegexes.pseudo.test(atRuleNode.params)) return;
-
-			if (!isStandardSyntaxAtRule(atRuleNode)) return;
-
-			check(getAtRuleParams(atRuleNode), atRuleNode, atRuleParamIndex(atRuleNode));
-		});
-	};
-};
-
-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-pseudo-class-disallowed-list/index.mjs

@@ -1,84 +0,0 @@
-import { atRuleRegexes, mayIncludeRegexes } from '../../utils/regexes.mjs';
-import { isRegExp, isString } from '../../utils/validateTypes.mjs';
-import { atRuleParamIndex } from '../../utils/nodeFieldIndices.mjs';
-import getAtRuleParams from '../../utils/getAtRuleParams.mjs';
-import getRuleSelector from '../../utils/getRuleSelector.mjs';
-import isStandardSyntaxAtRule from '../../utils/isStandardSyntaxAtRule.mjs';
-import isStandardSyntaxRule from '../../utils/isStandardSyntaxRule.mjs';
-import matchesStringOrRegExp from '../../utils/matchesStringOrRegExp.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-pseudo-class-disallowed-list';
-
-const messages = ruleMessages(ruleName, {
-	rejected: (selector) => `Unexpected pseudo-class "${selector}"`,
-});
-
-const meta = {
-	url: 'https://stylelint.io/user-guide/rules/selector-pseudo-class-disallowed-list',
-};
-
-/** @import {AtRule, Rule} from 'postcss' */
-
-/** @type {import('stylelint').CoreRules[ruleName]} */
-const rule = (primary) => {
-	return (root, result) => {
-		const validOptions = validateOptions(result, ruleName, {
-			actual: primary,
-			possible: [isString, isRegExp],
-		});
-
-		if (!validOptions) return;
-
-		/**
-		 * @param {string} selector
-		 * @param {AtRule | Rule} node
-		 * @param {number} offset
-		 */
-		function check(selector, node, offset = 0) {
-			parseSelector(selector, result, node)?.walkPseudos(({ value, sourceIndex }) => {
-				// Ignore pseudo-elements
-				if (value.slice(0, 2) === '::') return;
-
-				const name = value.slice(1);
-
-				if (!matchesStringOrRegExp(name, primary)) return;
-
-				const index = offset + sourceIndex;
-
-				report({
-					message: messages.rejected,
-					messageArgs: [value],
-					node,
-					result,
-					ruleName,
-					index,
-					endIndex: index + value.length,
-				});
-			});
-		}
-
-		root.walkRules(mayIncludeRegexes.pseudo, (ruleNode) => {
-			if (!isStandardSyntaxRule(ruleNode)) return;
-
-			check(getRuleSelector(ruleNode), ruleNode);
-		});
-
-		root.walkAtRules(atRuleRegexes.pageName, (atRuleNode) => {
-			if (!mayIncludeRegexes.pseudo.test(atRuleNode.params)) return;
-
-			if (!isStandardSyntaxAtRule(atRuleNode)) return;
-
-			check(getAtRuleParams(atRuleNode), atRuleNode, atRuleParamIndex(atRuleNode));
-		});
-	};
-};
-
-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-pseudo-class-no-unknown/index.mjs

@@ -1,179 +0,0 @@
-import {
-	atRulePagePseudoClasses,
-	levelOneAndTwoPseudoElements,
-	pseudoClasses,
-	pseudoElements,
-	webkitScrollbarPseudoClasses,
-	webkitScrollbarPseudoElements,
-} from '../../reference/selectors.mjs';
-import { isRegExp, isString } from '../../utils/validateTypes.mjs';
-import { atRuleParamIndex } from '../../utils/nodeFieldIndices.mjs';
-import getAtRuleParams from '../../utils/getAtRuleParams.mjs';
-import getRuleSelector from '../../utils/getRuleSelector.mjs';
-import { isAtRule } from '../../utils/typeGuards.mjs';
-import isCustomSelector from '../../utils/isCustomSelector.mjs';
-import isStandardSyntaxAtRule from '../../utils/isStandardSyntaxAtRule.mjs';
-import isStandardSyntaxRule from '../../utils/isStandardSyntaxRule.mjs';
-import isStandardSyntaxSelector from '../../utils/isStandardSyntaxSelector.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';
-import vendor from '../../utils/vendor.mjs';
-
-const ruleName = 'selector-pseudo-class-no-unknown';
-
-const messages = ruleMessages(ruleName, {
-	rejected: (selector) => `Unexpected unknown pseudo-class selector "${selector}"`,
-});
-
-const meta = {
-	url: 'https://stylelint.io/user-guide/rules/selector-pseudo-class-no-unknown',
-};
-
-/** @type {import('stylelint').CoreRules[ruleName]} */
-const rule = (primary, secondaryOptions) => {
-	return (root, result) => {
-		const validOptions = validateOptions(
-			result,
-			ruleName,
-			{ actual: primary },
-			{
-				actual: secondaryOptions,
-				possible: {
-					ignorePseudoClasses: [isString, isRegExp],
-				},
-				optional: true,
-			},
-		);
-
-		if (!validOptions) {
-			return;
-		}
-
-		/**
-		 * @param {string} selector
-		 * @param {import('postcss').ChildNode} node
-		 */
-		function check(selector, node) {
-			parseSelector(selector, result, node)?.walkPseudos((pseudoNode) => {
-				const value = pseudoNode.value;
-
-				if (!isStandardSyntaxSelector(value)) {
-					return;
-				}
-
-				if (isCustomSelector(value)) {
-					return;
-				}
-
-				if (value.startsWith('::')) {
-					return;
-				}
-
-				const name = value.replace(/^:*/, '').toLowerCase();
-
-				if (levelOneAndTwoPseudoElements.has(name)) {
-					return;
-				}
-
-				if (optionsMatches(secondaryOptions, 'ignorePseudoClasses', pseudoNode.value.slice(1))) {
-					return;
-				}
-
-				const hasVendorPrefix = vendor.prefix(name);
-				let index = null;
-
-				if (isAtRule(node) && node.name === 'page') {
-					if (atRulePagePseudoClasses.has(name)) {
-						return;
-					}
-
-					index = atRuleParamIndex(node) + pseudoNode.sourceIndex;
-				} else if (pseudoElements.has(name) && !hasVendorPrefix) {
-					index = pseudoNode.sourceIndex;
-				} else {
-					if (hasVendorPrefix || pseudoClasses.has(name)) {
-						return;
-					}
-
-					/** @type {import('postcss-selector-parser').Base} */
-					let prevPseudoElement = pseudoNode;
-
-					do {
-						prevPseudoElement = /** @type {import('postcss-selector-parser').Base} */ (
-							prevPseudoElement.prev()
-						);
-
-						if (prevPseudoElement && prevPseudoElement.value.slice(0, 2) === '::') {
-							break;
-						}
-					} while (prevPseudoElement);
-
-					if (prevPseudoElement) {
-						const prevPseudoElementValue = prevPseudoElement.value.toLowerCase().slice(2);
-
-						if (
-							webkitScrollbarPseudoElements.has(prevPseudoElementValue) &&
-							webkitScrollbarPseudoClasses.has(name)
-						) {
-							return;
-						}
-					}
-
-					index = pseudoNode.sourceIndex;
-				}
-
-				const endIndex = index + pseudoNode.value.length;
-
-				report({
-					message: messages.rejected,
-					messageArgs: [value],
-					node,
-					index,
-					endIndex,
-					ruleName,
-					result,
-				});
-			});
-		}
-
-		root.walk((node) => {
-			let selector = null;
-
-			if (node.type === 'rule') {
-				if (!isStandardSyntaxRule(node)) {
-					return;
-				}
-
-				selector = getRuleSelector(node);
-			} else if (isAtRule(node) && node.name === 'page' && node.params) {
-				if (!isStandardSyntaxAtRule(node)) {
-					return;
-				}
-
-				selector = getAtRuleParams(node);
-			}
-
-			// Return if selector empty, it is meaning node type is not a rule or a at-rule
-
-			if (!selector) {
-				return;
-			}
-
-			// Return early before parse if no pseudos for performance
-
-			if (!selector.includes(':')) {
-				return;
-			}
-
-			check(selector, node);
-		});
-	};
-};
-
-rule.ruleName = ruleName;
-rule.messages = messages;
-rule.meta = meta;
-export default rule;

package/packages/config-stylelint/node_modules/stylelint/lib/rules/selector-pseudo-element-allowed-list/index.mjs

@@ -1,75 +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-pseudo-element-allowed-list';
-
-const messages = ruleMessages(ruleName, {
-	rejected: (selector) => `Unexpected pseudo-element "${selector}"`,
-});
-
-const meta = {
-	url: 'https://stylelint.io/user-guide/rules/selector-pseudo-element-allowed-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.pseudoElement, (ruleNode) => {
-			if (!isStandardSyntaxRule(ruleNode)) {
-				return;
-			}
-
-			parseSelector(getRuleSelector(ruleNode), result, ruleNode)?.walkPseudos((pseudoNode) => {
-				const value = pseudoNode.value;
-
-				// Ignore pseudo-classes
-				if (value.charAt(1) !== ':') {
-					return;
-				}
-
-				const name = value.slice(2);
-
-				// Pseudo is in allowlist
-				if (matchesStringOrRegExp(name, primary)) {
-					return;
-				}
-
-				const index = pseudoNode.sourceIndex;
-				const endIndex = index + value.length;
-
-				report({
-					index,
-					endIndex,
-					message: messages.rejected,
-					messageArgs: [value],
-					node: ruleNode,
-					result,
-					ruleName,
-				});
-			});
-		});
-	};
-};
-
-rule.primaryOptionArray = true;
-
-rule.ruleName = ruleName;
-rule.messages = messages;
-rule.meta = meta;
-export default rule;