@alexlit/lint-kit 182.1.0 → 182.2.0

package/packages/config-stylelint/node_modules/stylelint/lib/rules/selector-pseudo-element-colon-notation/index.mjs

@@ -0,0 +1,93 @@
+import getRuleSelector from '../../utils/getRuleSelector.mjs';
+import isStandardSyntaxRule from '../../utils/isStandardSyntaxRule.mjs';
+import { levelOneAndTwoPseudoElements } from '../../reference/selectors.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-colon-notation';
+
+const messages = ruleMessages(ruleName, {
+	expected: (type) => `Expected ${type} colon pseudo-element notation`,
+});
+
+const meta = {
+	url: 'https://stylelint.io/user-guide/rules/selector-pseudo-element-colon-notation',
+	fixable: true,
+};
+
+/** @type {import('stylelint').CoreRules[ruleName]} */
+const rule = (primary) => {
+	return (root, result) => {
+		const validOptions = validateOptions(result, ruleName, {
+			actual: primary,
+			possible: ['single', 'double'],
+		});
+
+		if (!validOptions) {
+			return;
+		}
+
+		let fixedColon = '';
+
+		if (primary === 'single') {
+			fixedColon = ':';
+		} else if (primary === 'double') {
+			fixedColon = '::';
+		}
+
+		root.walkRules(mayIncludeRegexes.pseudo, (ruleNode) => {
+			if (!isStandardSyntaxRule(ruleNode)) {
+				return;
+			}
+
+			const selectorRoot = parseSelector(getRuleSelector(ruleNode), result, ruleNode);
+
+			if (!selectorRoot) return;
+
+			selectorRoot.walkPseudos((pseudo) => {
+				const pseudoElement = pseudo.value.replaceAll(':', '');
+
+				if (!levelOneAndTwoPseudoElements.has(pseudoElement.toLowerCase())) {
+					return;
+				}
+
+				const isDouble = pseudo.value.startsWith('::');
+
+				if (primary === 'single' && !isDouble) {
+					return;
+				}
+
+				if (primary === 'double' && isDouble) {
+					return;
+				}
+
+				const fix = () => {
+					pseudo.replaceWith(pseudo.clone({ value: fixedColon + pseudoElement }));
+					ruleNode.selector = selectorRoot.toString();
+				};
+
+				report({
+					message: messages.expected,
+					messageArgs: [primary],
+					node: ruleNode,
+					index: pseudo.sourceIndex,
+					endIndex: pseudo.sourceIndex + (isDouble ? 2 : 1),
+					result,
+					ruleName,
+					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-pseudo-element-disallowed-list/index.mjs

@@ -0,0 +1,74 @@
+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-disallowed-list';
+
+const messages = ruleMessages(ruleName, {
+	rejected: (selector) => `Unexpected pseudo-element "${selector}"`,
+});
+
+const meta = {
+	url: 'https://stylelint.io/user-guide/rules/selector-pseudo-element-disallowed-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);
+
+				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;

package/packages/config-stylelint/node_modules/stylelint/lib/rules/selector-pseudo-element-no-unknown/index.mjs

@@ -0,0 +1,91 @@
+import { isRegExp, isString } from '../../utils/validateTypes.mjs';
+import getRuleSelector from '../../utils/getRuleSelector.mjs';
+import isStandardSyntaxRule from '../../utils/isStandardSyntaxRule.mjs';
+import isStandardSyntaxSelector from '../../utils/isStandardSyntaxSelector.mjs';
+import { mayIncludeRegexes } from '../../utils/regexes.mjs';
+import optionsMatches from '../../utils/optionsMatches.mjs';
+import parseSelector from '../../utils/parseSelector.mjs';
+import { pseudoElements } from '../../reference/selectors.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-element-no-unknown';
+
+const messages = ruleMessages(ruleName, {
+	rejected: (selector) => `Unexpected unknown pseudo-element selector "${selector}"`,
+});
+
+const meta = {
+	url: 'https://stylelint.io/user-guide/rules/selector-pseudo-element-no-unknown',
+};
+
+/** @type {import('stylelint').CoreRules[ruleName]} */
+const rule = (primary, secondaryOptions) => {
+	return (root, result) => {
+		const validOptions = validateOptions(
+			result,
+			ruleName,
+			{ actual: primary },
+			{
+				actual: secondaryOptions,
+				possible: {
+					ignorePseudoElements: [isString, isRegExp],
+				},
+				optional: true,
+			},
+		);
+
+		if (!validOptions) {
+			return;
+		}
+
+		root.walkRules(mayIncludeRegexes.pseudo, (ruleNode) => {
+			if (!isStandardSyntaxRule(ruleNode)) {
+				return;
+			}
+
+			parseSelector(getRuleSelector(ruleNode), result, ruleNode)?.walkPseudos((pseudoNode) => {
+				const value = pseudoNode.value;
+
+				if (!isStandardSyntaxSelector(value)) {
+					return;
+				}
+
+				// Ignore pseudo-classes
+				if (value.slice(0, 2) !== '::') {
+					return;
+				}
+
+				if (optionsMatches(secondaryOptions, 'ignorePseudoElements', pseudoNode.value.slice(2))) {
+					return;
+				}
+
+				const name = value.slice(2);
+
+				if (vendor.prefix(name) || pseudoElements.has(name.toLowerCase())) {
+					return;
+				}
+
+				const index = pseudoNode.sourceIndex;
+				const endIndex = index + value.length;
+
+				report({
+					message: messages.rejected,
+					messageArgs: [value],
+					node: ruleNode,
+					index,
+					endIndex,
+					ruleName,
+					result,
+				});
+			});
+		});
+	};
+};
+
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;
+export default rule;

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

@@ -0,0 +1,118 @@
+import { isRegExp, isString } from '../../utils/validateTypes.mjs';
+import getRuleSelector from '../../utils/getRuleSelector.mjs';
+import isKeyframeSelector from '../../utils/isKeyframeSelector.mjs';
+import isStandardSyntaxRule from '../../utils/isStandardSyntaxRule.mjs';
+import isStandardSyntaxTypeSelector from '../../utils/isStandardSyntaxTypeSelector.mjs';
+import { mixedCaseSvgTypeSelectors } from '../../reference/selectors.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-type-case';
+
+const messages = ruleMessages(ruleName, {
+	expected: (actual, expected) => `Expected "${actual}" to be "${expected}"`,
+});
+
+const meta = {
+	url: 'https://stylelint.io/user-guide/rules/selector-type-case',
+	fixable: true,
+};
+
+const STARTS_A_TAG_NAME_REGEX = /(?:[^.#[:a-z-]|^)[a-z]/i;
+const ANY_UPPER_CASE_REGEX = /[A-Z]/;
+const ANY_LOWER_CASE_REGEX = /[a-z]/;
+
+/** @type {import('stylelint').CoreRules[ruleName]} */
+const rule = (primary, secondaryOptions) => {
+	return (root, result) => {
+		const validOptions = validateOptions(
+			result,
+			ruleName,
+			{
+				actual: primary,
+				possible: ['lower', 'upper'],
+			},
+			{
+				actual: secondaryOptions,
+				possible: {
+					ignoreTypes: [isString, isRegExp],
+				},
+				optional: true,
+			},
+		);
+
+		if (!validOptions) {
+			return;
+		}
+
+		root.walkRules((ruleNode) => {
+			const selector = ruleNode.selector;
+
+			if (!STARTS_A_TAG_NAME_REGEX.test(selector)) return;
+
+			if (primary === 'lower' && !ANY_UPPER_CASE_REGEX.test(selector)) return;
+
+			if (primary === 'upper' && !ANY_LOWER_CASE_REGEX.test(selector)) return;
+
+			if (!isStandardSyntaxRule(ruleNode)) return;
+
+			if (ruleNode.selectors.some(isKeyframeSelector)) return;
+
+			const selectorRoot = parseSelector(getRuleSelector(ruleNode), result, ruleNode);
+
+			if (!selectorRoot) return;
+
+			selectorRoot.walkTags((tag) => {
+				if (!isStandardSyntaxTypeSelector(tag)) {
+					return;
+				}
+
+				if (mixedCaseSvgTypeSelectors.has(tag.value)) {
+					return;
+				}
+
+				if (optionsMatches(secondaryOptions, 'ignoreTypes', tag.value)) {
+					return;
+				}
+
+				const sourceIndex = tag.sourceIndex;
+				const value = tag.value;
+
+				const expectedValue = primary === 'lower' ? value.toLowerCase() : value.toUpperCase();
+
+				if (value === expectedValue) {
+					return;
+				}
+
+				const index = sourceIndex;
+				const endIndex = sourceIndex + value.length;
+				const fix = () => {
+					tag.value = expectedValue;
+					ruleNode.selector = selectorRoot.toString();
+				};
+
+				report({
+					message: messages.expected,
+					messageArgs: [value, expectedValue],
+					node: ruleNode,
+					index,
+					endIndex,
+					ruleName,
+					result,
+					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-type-no-unknown/index.mjs

@@ -0,0 +1,148 @@
+import { mathmlTagNames } from 'mathml-tag-names';
+import parser from 'postcss-selector-parser';
+import svgTags from 'svg-tags';
+
+import { isRegExp, isString } from '../../utils/validateTypes.mjs';
+import getRuleSelector from '../../utils/getRuleSelector.mjs';
+import { htmlTypeSelectors } from '../../reference/selectors.mjs';
+import isCustomElement from '../../utils/isCustomElement.mjs';
+import isKeyframeSelector from '../../utils/isKeyframeSelector.mjs';
+import isStandardSyntaxRule from '../../utils/isStandardSyntaxRule.mjs';
+import isStandardSyntaxTypeSelector from '../../utils/isStandardSyntaxTypeSelector.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-type-no-unknown';
+
+const messages = ruleMessages(ruleName, {
+	rejected: (selector) => `Unexpected unknown type selector "${selector}"`,
+});
+
+const meta = {
+	url: 'https://stylelint.io/user-guide/rules/selector-type-no-unknown',
+};
+
+const STARTS_A_TAG_NAME_REGEX = /(?:[^.#[:a-z-]|^)[a-z]/i;
+const IGNORED_PSEUDO_ELEMENTS = new Set([
+	'::highlight',
+	'::view-transition-group',
+	'::view-transition-image-pair',
+	'::view-transition-new',
+	'::view-transition-old',
+]);
+
+const IGNORED_PSEUDO_CLASSES = new Set([
+	':active-view-transition-type',
+	':dir',
+	':-moz-locale-dir',
+	':state',
+	':lang',
+]);
+
+/** @type {import('stylelint').CoreRules[ruleName]} */
+const rule = (primary, secondaryOptions) => {
+	return (root, result) => {
+		const validOptions = validateOptions(
+			result,
+			ruleName,
+			{ actual: primary },
+			{
+				actual: secondaryOptions,
+				possible: {
+					ignore: ['custom-elements', 'default-namespace'],
+					ignoreNamespaces: [isString, isRegExp],
+					ignoreTypes: [isString, isRegExp],
+				},
+				optional: true,
+			},
+		);
+
+		if (!validOptions) {
+			return;
+		}
+
+		root.walkRules((ruleNode) => {
+			if (!STARTS_A_TAG_NAME_REGEX.test(ruleNode.selector)) return;
+
+			if (!isStandardSyntaxRule(ruleNode)) return;
+
+			if (ruleNode.selectors.some(isKeyframeSelector)) {
+				return;
+			}
+
+			parseSelector(getRuleSelector(ruleNode), result, ruleNode)?.walkTags((tagNode) => {
+				if (!isStandardSyntaxTypeSelector(tagNode)) return;
+
+				if (
+					optionsMatches(secondaryOptions, 'ignore', 'custom-elements') &&
+					isCustomElement(tagNode.value)
+				) {
+					return;
+				}
+
+				if (
+					optionsMatches(secondaryOptions, 'ignore', 'default-namespace') &&
+					!(typeof tagNode.namespace === 'string')
+				) {
+					return;
+				}
+
+				if (optionsMatches(secondaryOptions, 'ignoreNamespaces', tagNode.namespace)) return;
+
+				if (optionsMatches(secondaryOptions, 'ignoreTypes', tagNode.value)) return;
+
+				if (isArgumentOfIgnoredPseudoElement(tagNode) || isArgumentOfIgnoredPseudoClass(tagNode)) {
+					return;
+				}
+
+				const tagName = tagNode.value;
+				const tagNameLowerCase = tagName.toLowerCase();
+				// SVG tags are case-sensitive
+				const svgTypeSelectors = [...svgTags, 'hatch', 'hatchpath', 'hatchPath'];
+
+				if (
+					htmlTypeSelectors.has(tagNameLowerCase) ||
+					svgTypeSelectors.includes(tagName) ||
+					mathmlTagNames.includes(tagNameLowerCase)
+				) {
+					return;
+				}
+
+				const index = tagNode.sourceIndex;
+				const endIndex = index + tagName.length;
+
+				report({
+					message: messages.rejected,
+					messageArgs: [tagName],
+					node: ruleNode,
+					index,
+					endIndex,
+					ruleName,
+					result,
+				});
+			});
+		});
+	};
+};
+
+/** @param {import('postcss-selector-parser').Tag} tag */
+function isArgumentOfIgnoredPseudoElement(tag) {
+	const node = tag.parent?.parent;
+
+	return parser.isPseudoElement(node) && IGNORED_PSEUDO_ELEMENTS.has(node.value);
+}
+
+/** @param {import('postcss-selector-parser').Tag} tag */
+function isArgumentOfIgnoredPseudoClass(tag) {
+	const node = tag.parent?.parent;
+
+	return parser.isPseudoClass(node) && IGNORED_PSEUDO_CLASSES.has(node.value);
+}
+
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;
+export default rule;