@alexlit/lint-kit 182.1.0 → 182.2.0

package/packages/config-stylelint/node_modules/stylelint/lib/rules/selector-class-pattern/index.mjs

@@ -0,0 +1,71 @@
+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 { 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-class-pattern';
+
+const messages = ruleMessages(ruleName, {
+	expected: (selector, pattern) => `Expected "${selector}" to match pattern "${pattern}"`,
+});
+
+const meta = {
+	url: 'https://stylelint.io/user-guide/rules/selector-class-pattern',
+};
+
+/** @type {import('stylelint').CoreRules[ruleName]} */
+const rule = (primary) => {
+	return (root, result) => {
+		const validOptions = validateOptions(result, ruleName, {
+			actual: primary,
+			possible: [isRegExp, isString],
+		});
+
+		if (!validOptions) {
+			return;
+		}
+
+		const normalizedPattern = isString(primary) ? new RegExp(primary) : primary;
+
+		root.walkRules(mayIncludeRegexes.classSelector, (ruleNode) => {
+			if (!isStandardSyntaxRule(ruleNode)) {
+				return;
+			}
+
+			if (ruleNode.selectors.some(isKeyframeSelector)) {
+				return;
+			}
+
+			parseSelector(getRuleSelector(ruleNode), result, ruleNode)?.walkClasses((classNode) => {
+				const { value, sourceIndex: index } = classNode;
+
+				if (normalizedPattern.test(value)) {
+					return;
+				}
+
+				const selector = classNode.toString().trim();
+				const endIndex = index + selector.length;
+
+				report({
+					result,
+					ruleName,
+					message: messages.expected,
+					messageArgs: [selector, 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-combinator-allowed-list/index.mjs

@@ -0,0 +1,81 @@
+import getRuleSelector from '../../utils/getRuleSelector.mjs';
+import isStandardSyntaxCombinator from '../../utils/isStandardSyntaxCombinator.mjs';
+import isStandardSyntaxRule from '../../utils/isStandardSyntaxRule.mjs';
+import { isString } from '../../utils/validateTypes.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-combinator-allowed-list';
+
+const messages = ruleMessages(ruleName, {
+	rejected: (combinator) => `Unexpected combinator "${combinator}"`,
+});
+
+const meta = {
+	url: 'https://stylelint.io/user-guide/rules/selector-combinator-allowed-list',
+};
+
+/** @type {import('stylelint').CoreRules[ruleName]} */
+const rule = (primary) => {
+	return (root, result) => {
+		const validOptions = validateOptions(result, ruleName, {
+			actual: primary,
+			possible: [isString],
+		});
+
+		if (!validOptions) {
+			return;
+		}
+
+		root.walkRules((ruleNode) => {
+			if (!isStandardSyntaxRule(ruleNode)) {
+				return;
+			}
+
+			parseSelector(getRuleSelector(ruleNode), result, ruleNode)?.walkCombinators(
+				(combinatorNode) => {
+					if (!isStandardSyntaxCombinator(combinatorNode)) {
+						return;
+					}
+
+					const { value } = combinatorNode;
+					const normalizedValue = normalizeCombinator(value);
+
+					if (primary.includes(normalizedValue)) {
+						return;
+					}
+
+					const { sourceIndex: index, raws } = combinatorNode;
+					const endIndex = index + ((raws && raws.value) || value).length;
+
+					report({
+						result,
+						ruleName,
+						message: messages.rejected,
+						messageArgs: [normalizedValue],
+						node: ruleNode,
+						index,
+						endIndex,
+					});
+				},
+			);
+		});
+	};
+};
+
+/**
+ * @param {string} value
+ * @returns {string}
+ */
+function normalizeCombinator(value) {
+	return value.replace(/\s+/g, ' ');
+}
+
+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-combinator-disallowed-list/index.mjs

@@ -0,0 +1,81 @@
+import getRuleSelector from '../../utils/getRuleSelector.mjs';
+import isStandardSyntaxCombinator from '../../utils/isStandardSyntaxCombinator.mjs';
+import isStandardSyntaxRule from '../../utils/isStandardSyntaxRule.mjs';
+import { isString } from '../../utils/validateTypes.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-combinator-disallowed-list';
+
+const messages = ruleMessages(ruleName, {
+	rejected: (combinator) => `Unexpected combinator "${combinator}"`,
+});
+
+const meta = {
+	url: 'https://stylelint.io/user-guide/rules/selector-combinator-disallowed-list',
+};
+
+/** @type {import('stylelint').CoreRules[ruleName]} */
+const rule = (primary) => {
+	return (root, result) => {
+		const validOptions = validateOptions(result, ruleName, {
+			actual: primary,
+			possible: [isString],
+		});
+
+		if (!validOptions) {
+			return;
+		}
+
+		root.walkRules((ruleNode) => {
+			if (!isStandardSyntaxRule(ruleNode)) {
+				return;
+			}
+
+			parseSelector(getRuleSelector(ruleNode), result, ruleNode)?.walkCombinators(
+				(combinatorNode) => {
+					if (!isStandardSyntaxCombinator(combinatorNode)) {
+						return;
+					}
+
+					const { value } = combinatorNode;
+					const normalizedValue = normalizeCombinator(value);
+
+					if (!primary.includes(normalizedValue)) {
+						return;
+					}
+
+					const { sourceIndex: index, raws } = combinatorNode;
+					const endIndex = index + ((raws && raws.value) || value).length;
+
+					report({
+						result,
+						ruleName,
+						message: messages.rejected,
+						messageArgs: [normalizedValue],
+						node: ruleNode,
+						index,
+						endIndex,
+					});
+				},
+			);
+		});
+	};
+};
+
+/**
+ * @param {string} value
+ * @returns {string}
+ */
+function normalizeCombinator(value) {
+	return value.replace(/\s+/g, ' ');
+}
+
+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-disallowed-list/index.mjs

@@ -0,0 +1,115 @@
+import { isBoolean, isRegExp, isString } from '../../utils/validateTypes.mjs';
+import getRuleSelector from '../../utils/getRuleSelector.mjs';
+import getStrippedSelectorSource from '../../utils/getStrippedSelectorSource.mjs';
+import isKeyframeRule from '../../utils/isKeyframeRule.mjs';
+import isStandardSyntaxRule from '../../utils/isStandardSyntaxRule.mjs';
+import matchesStringOrRegExp from '../../utils/matchesStringOrRegExp.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-disallowed-list';
+
+const messages = ruleMessages(ruleName, {
+	rejected: (selector) => `Unexpected selector "${selector}"`,
+});
+
+const meta = {
+	url: 'https://stylelint.io/user-guide/rules/selector-disallowed-list',
+};
+
+/** @type {import('stylelint').CoreRules[ruleName]} */
+const rule = (primary, secondaryOptions) => {
+	return (root, result) => {
+		const validOptions = validateOptions(
+			result,
+			ruleName,
+			{
+				actual: primary,
+				possible: [isString, isRegExp],
+			},
+			{
+				actual: secondaryOptions,
+				possible: {
+					ignore: ['inside-block', 'keyframe-selectors'],
+					splitList: [isBoolean],
+				},
+				optional: true,
+			},
+		);
+
+		if (!validOptions) {
+			return;
+		}
+
+		const ignoreInsideBlock = optionsMatches(secondaryOptions, 'ignore', 'inside-block');
+		const ignoreKeyframeSelectors = optionsMatches(
+			secondaryOptions,
+			'ignore',
+			'keyframe-selectors',
+		);
+
+		const splitList = secondaryOptions && secondaryOptions.splitList;
+
+		root.walkRules((ruleNode) => {
+			if (!isStandardSyntaxRule(ruleNode)) {
+				return;
+			}
+
+			if (ignoreKeyframeSelectors && isKeyframeRule(ruleNode)) {
+				return;
+			}
+
+			if (ignoreInsideBlock) {
+				const { parent } = ruleNode;
+				const isInsideBlock = parent && parent.type !== 'root';
+
+				if (isInsideBlock) {
+					return;
+				}
+			}
+
+			/**
+			 * @param {string} selectorStr
+			 * @param {number} index
+			 * @param {number} endIndex
+			 */
+			function check(selectorStr, index, endIndex) {
+				if (matchesStringOrRegExp(selectorStr, primary)) {
+					report({
+						result,
+						ruleName,
+						message: messages.rejected,
+						messageArgs: [selectorStr],
+						node: ruleNode,
+						index,
+						endIndex,
+					});
+				}
+			}
+
+			const selectors = getRuleSelector(ruleNode);
+
+			if (!splitList) {
+				check(selectors, 0, selectors.length);
+
+				return;
+			}
+
+			parseSelector(selectors, result, ruleNode)?.each((selector) => {
+				const { selector: selectorStr, index, endIndex } = getStrippedSelectorSource(selector);
+
+				check(selectorStr, index, endIndex);
+			});
+		});
+	};
+};
+
+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-id-pattern/index.mjs

@@ -0,0 +1,66 @@
+import { isRegExp, isString } 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-id-pattern';
+
+const messages = ruleMessages(ruleName, {
+	expected: (selector, pattern) => `Expected "${selector}" to match pattern "${pattern}"`,
+});
+
+const meta = {
+	url: 'https://stylelint.io/user-guide/rules/selector-id-pattern',
+};
+
+/** @type {import('stylelint').CoreRules[ruleName]} */
+const rule = (primary) => {
+	return (root, result) => {
+		const validOptions = validateOptions(result, ruleName, {
+			actual: primary,
+			possible: [isRegExp, isString],
+		});
+
+		if (!validOptions) {
+			return;
+		}
+
+		const normalizedPattern = isString(primary) ? new RegExp(primary) : primary;
+
+		root.walkRules(mayIncludeRegexes.idSelector, (ruleNode) => {
+			if (!isStandardSyntaxRule(ruleNode)) {
+				return;
+			}
+
+			parseSelector(getRuleSelector(ruleNode), result, ruleNode)?.walkIds((selectorNode) => {
+				const { value, sourceIndex: index } = selectorNode;
+
+				if (normalizedPattern.test(value)) {
+					return;
+				}
+
+				const selector = selectorNode.toString().trim();
+				const endIndex = index + selector.length;
+
+				report({
+					result,
+					ruleName,
+					message: messages.expected,
+					messageArgs: [selector, 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-max-attribute/index.mjs

@@ -0,0 +1,92 @@
+import { isRegExp, isString } from '../../utils/validateTypes.mjs';
+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 { 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-attribute';
+
+const messages = ruleMessages(ruleName, {
+	expected: (selector, max) =>
+		`Expected "${selector}" to have no more than ${max} attribute ${
+			max === 1 ? 'selector' : 'selectors'
+		}`,
+});
+
+const meta = {
+	url: 'https://stylelint.io/user-guide/rules/selector-max-attribute',
+};
+
+/** @type {import('stylelint').CoreRules[ruleName]} */
+const rule = (primary, secondaryOptions) => {
+	return (root, result) => {
+		const validOptions = validateOptions(
+			result,
+			ruleName,
+			{
+				actual: primary,
+				possible: isNonNegativeInteger,
+			},
+			{
+				actual: secondaryOptions,
+				possible: {
+					ignoreAttributes: [isString, isRegExp],
+				},
+				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.walkAttributes((node) => {
+				if (optionsMatches(secondaryOptions, 'ignoreAttributes', node.attribute)) 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.attributeSelector, (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-max-class/index.mjs

@@ -0,0 +1,75 @@
+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 { 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-max-class';
+
+const messages = ruleMessages(ruleName, {
+	expected: (selector, max) =>
+		`Expected "${selector}" to have no more than ${max} ${max === 1 ? 'class' : 'classes'}`,
+});
+
+const meta = {
+	url: 'https://stylelint.io/user-guide/rules/selector-max-class',
+};
+
+/** @type {import('stylelint').CoreRules[ruleName]} */
+const rule = (primary) => {
+	return (root, result) => {
+		const validOptions = validateOptions(result, ruleName, {
+			actual: primary,
+			possible: isNonNegativeInteger,
+		});
+
+		if (!validOptions) {
+			return;
+		}
+
+		/**
+		 * @param {import('postcss-selector-parser').Selector} selectorNode
+		 * @param {import('postcss').Rule} ruleNode
+		 */
+		function checkSelector(selectorNode, ruleNode) {
+			let count = 0;
+
+			selectorNode.walkClasses(() => {
+				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.classSelector, (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-max-combinators/index.mjs

@@ -0,0 +1,77 @@
+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 { 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-max-combinators';
+
+const messages = ruleMessages(ruleName, {
+	expected: (selector, max) =>
+		`Expected "${selector}" to have no more than ${max} ${
+			max === 1 ? 'combinator' : 'combinators'
+		}`,
+});
+
+const meta = {
+	url: 'https://stylelint.io/user-guide/rules/selector-max-combinators',
+};
+
+/** @type {import('stylelint').CoreRules[ruleName]} */
+const rule = (primary) => {
+	return (root, result) => {
+		const validOptions = validateOptions(result, ruleName, {
+			actual: primary,
+			possible: isNonNegativeInteger,
+		});
+
+		if (!validOptions) {
+			return;
+		}
+
+		/**
+		 * @param {import('postcss-selector-parser').Selector} selectorNode
+		 * @param {import('postcss').Rule} ruleNode
+		 */
+		function checkSelector(selectorNode, ruleNode) {
+			let count = 0;
+
+			selectorNode.walkCombinators((/* node */) => {
+				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.combinator, (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;