@alexlit/lint-kit 182.1.0 → 182.2.0

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

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

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

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

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

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