@alexlit/lint-kit 183.4.0 → 183.6.0

package/packages/config-stylelint/node_modules/stylelint/lib/rules/no-duplicate-selectors/index.mjs

@@ -0,0 +1,218 @@
+import selectorParser from 'postcss-selector-parser';
+
+import { isBoolean, isRegExp, isString } from '../../utils/validateTypes.mjs';
+import findAtRuleContext from '../../utils/findAtRuleContext.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 nodeContextLookup from '../../utils/nodeContextLookup.mjs';
+import normalizeSelector from '../../utils/normalizeSelector.mjs';
+import optionsMatches from '../../utils/optionsMatches.mjs';
+import parseSelector from '../../utils/parseSelector.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 = 'no-duplicate-selectors';
+
+const messages = ruleMessages(ruleName, {
+	rejected: (selector, firstDuplicateLine) =>
+		`Unexpected duplicate selector "${selector}", first used at line ${firstDuplicateLine}`,
+});
+
+const meta = {
+	url: 'https://stylelint.io/user-guide/rules/no-duplicate-selectors',
+};
+
+/** @import { Rule as PostcssRule } from 'postcss' */
+
+/** @type {import('stylelint').CoreRules[ruleName]} */
+const rule = (primary, secondaryOptions) => {
+	return (root, result) => {
+		const validOptions = validateOptions(
+			result,
+			ruleName,
+			{ actual: primary },
+			{
+				actual: secondaryOptions,
+				possible: {
+					disallowInList: [isBoolean],
+					ignoreSelectors: [isString, isRegExp],
+				},
+				optional: true,
+			},
+		);
+
+		if (!validOptions) {
+			return;
+		}
+
+		const shouldDisallowDuplicateInList = secondaryOptions && secondaryOptions.disallowInList;
+
+		// The top level of this map will be rule sources.
+		// Each source maps to another map, which maps rule parents to a set of selectors.
+		// This ensures that selectors are only checked against selectors
+		// from other rules that share the same parent and the same source.
+		const selectorContextLookup = nodeContextLookup();
+
+		/**
+		 * @param {PostcssRule} node
+		 * @param {string} selector
+		 * @param {number} index
+		 * @param {number} endIndex
+		 * @param {number} previousDuplicateLine
+		 */
+		function complain(node, selector, index, endIndex, previousDuplicateLine) {
+			report({
+				result,
+				ruleName,
+				node,
+				message: messages.rejected,
+				messageArgs: [selector, previousDuplicateLine],
+				index,
+				endIndex,
+			});
+		}
+
+		/**
+		 * Check selectors in the same rule:
+		 * `a, b, a {}` -> double "a"
+		 *
+		 * @param {PostcssRule} ruleNode
+		 */
+		function checkSelectorsInTheSameRule(ruleNode) {
+			const selectorsInList = new Map();
+			const selectors = parseSelector(getRuleSelector(ruleNode), result, ruleNode);
+
+			selectors?.each((selector) => {
+				const normalized = normalizeSelector(selector, result).string;
+
+				if (optionsMatches(secondaryOptions, 'ignoreSelectors', normalized)) {
+					return;
+				}
+
+				const previousDuplicatePosition = selectorsInList.get(normalized);
+
+				if (!previousDuplicatePosition) {
+					selectorsInList.set(normalized, {
+						// line numbers start at 1, adding two line numbers together requires subtracting 1
+						line: (selector.source?.start?.line ?? 1) + (ruleNode.source?.start?.line ?? 1) - 1,
+					});
+
+					return;
+				}
+
+				const { index, endIndex, selector: selectorStr } = getStrippedSelectorSource(selector);
+
+				complain(ruleNode, selectorStr, index, endIndex, previousDuplicatePosition.line);
+			});
+		}
+
+		/**
+		 * Check selectors in different rules, but evaluate each selector list as a single item:
+		 * `a, b {} b, a {}` -> double "a, b"
+		 *
+		 * @param {PostcssRule} ruleNode
+		 * @param {Map<string, { line: number }>} contextSelectorSet
+		 */
+		function checkSelectorListInDifferentRules(ruleNode, contextSelectorSet) {
+			const resolvedSelectorsNodes = resolveNestedSelectorsForRule(ruleNode, result).flatMap(
+				({ resolvedSelectors }) => resolvedSelectors.nodes,
+			);
+
+			if (!resolvedSelectorsNodes.length) return;
+
+			const hasIgnoredSelector = resolvedSelectorsNodes.some((selector) => {
+				const normalized = normalizeSelector(selector, result).string;
+
+				return optionsMatches(secondaryOptions, 'ignoreSelectors', normalized);
+			});
+
+			if (hasIgnoredSelector) return;
+
+			const combinedRoot = selectorParser.root({
+				nodes: resolvedSelectorsNodes,
+				value: '',
+			});
+
+			const normalized = normalizeSelector(combinedRoot, result).string;
+			const previousDuplicatePosition = contextSelectorSet.get(normalized);
+
+			if (!previousDuplicatePosition) {
+				contextSelectorSet.set(normalized, {
+					line: ruleNode.source?.start?.line ?? 1,
+				});
+
+				return;
+			}
+
+			const selector = getRuleSelector(ruleNode);
+			const selectorStr = selector.toString().trim();
+
+			complain(ruleNode, selectorStr, 0, selectorStr.length, previousDuplicatePosition.line);
+		}
+
+		/**
+		 * Check selectors in different rules, and evaluate each selector as an individual item:
+		 * `a, b {} a {}` -> double "a"
+		 *
+		 * @param {PostcssRule} ruleNode
+		 * @param {Map<string, { line: number }>} contextSelectorSet
+		 */
+		function checkSelectorsInDifferentRules(ruleNode, contextSelectorSet) {
+			resolveNestedSelectorsForRule(ruleNode, result).forEach((resolvedSelectorEntry) => {
+				const { selector, resolvedSelectors } = resolvedSelectorEntry;
+
+				resolvedSelectors.each((resolvedSelector) => {
+					const normalized = normalizeSelector(resolvedSelector, result).string;
+
+					if (optionsMatches(secondaryOptions, 'ignoreSelectors', normalized)) {
+						return;
+					}
+
+					const previousDuplicatePosition = contextSelectorSet.get(normalized);
+
+					if (!previousDuplicatePosition) {
+						contextSelectorSet.set(normalized, {
+							// line numbers start at 1, adding two line numbers together requires subtracting 1
+							line: (selector.source?.start?.line ?? 1) + (ruleNode.source?.start?.line ?? 1) - 1,
+						});
+
+						return;
+					}
+
+					const { index, endIndex, selector: selectorStr } = getStrippedSelectorSource(selector);
+
+					complain(ruleNode, selectorStr, index, endIndex, previousDuplicatePosition.line);
+				});
+			});
+		}
+
+		root.walkRules((ruleNode) => {
+			if (isKeyframeRule(ruleNode)) return;
+
+			if (!isStandardSyntaxRule(ruleNode)) return;
+
+			const contextSelectorSet = selectorContextLookup.getContext(
+				ruleNode,
+				findAtRuleContext(ruleNode),
+			);
+
+			if (shouldDisallowDuplicateInList) {
+				checkSelectorsInDifferentRules(ruleNode, contextSelectorSet);
+
+				return;
+			}
+
+			checkSelectorsInTheSameRule(ruleNode);
+			checkSelectorListInDifferentRules(ruleNode, contextSelectorSet);
+		});
+	};
+};
+
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;
+export default rule;

package/packages/config-stylelint/node_modules/stylelint/lib/rules/no-empty-source/index.mjs

@@ -0,0 +1,61 @@
+import { isConfigurationComment } from '../../utils/configurationComment.mjs';
+import report from '../../utils/report.mjs';
+import ruleMessages from '../../utils/ruleMessages.mjs';
+import validateOptions from '../../utils/validateOptions.mjs';
+
+const ruleName = 'no-empty-source';
+
+const messages = ruleMessages(ruleName, {
+	rejected: 'Unexpected empty source',
+});
+
+const meta = {
+	url: 'https://stylelint.io/user-guide/rules/no-empty-source',
+};
+
+/** @type {import('stylelint').CoreRules[ruleName]} */
+const rule = (primary, _secondaryOptions, context) => {
+	return (root, result) => {
+		const validOptions = validateOptions(result, ruleName, { actual: primary });
+
+		if (!validOptions) {
+			return;
+		}
+
+		// after a fix has been applied root.toString() may differ from root.source.input.css
+		// i.e. root.source.input.css remains unchanged after a fix
+		const rootString = context.fix ? root.toString() : (root.source && root.source.input.css) || '';
+
+		let hasNotableChild =
+			Boolean(rootString.trim()) &&
+			root.nodes.some((child) => {
+				if (isConfigurationComment(child, context.configurationComment)) return false;
+
+				return true;
+			});
+
+		if (!hasNotableChild) {
+			// Assume a case when a non-standard syntax is used, such as JSX. See #8547.
+			if (root.nodes.length === 0 && Boolean(root.raws.after?.trim())) {
+				hasNotableChild = true;
+			}
+		}
+
+		if (hasNotableChild) {
+			return;
+		}
+
+		report({
+			message: messages.rejected,
+			messageArgs: [],
+			node: root,
+			result,
+			ruleName,
+		});
+	};
+};
+
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;
+export default rule;

package/packages/config-stylelint/node_modules/stylelint/lib/rules/no-invalid-double-slash-comments/index.mjs

@@ -0,0 +1,77 @@
+import { assertString } from '../../utils/validateTypes.mjs';
+import getRuleSelector from '../../utils/getRuleSelector.mjs';
+import report from '../../utils/report.mjs';
+import ruleMessages from '../../utils/ruleMessages.mjs';
+import validateOptions from '../../utils/validateOptions.mjs';
+
+const ruleName = 'no-invalid-double-slash-comments';
+
+const messages = ruleMessages(ruleName, {
+	rejected: 'Unexpected double-slash CSS comment',
+});
+
+const meta = {
+	url: 'https://stylelint.io/user-guide/rules/no-invalid-double-slash-comments',
+};
+
+/** @type {import('stylelint').CoreRules[ruleName]} */
+const rule = (primary, _, context) => {
+	return (root, result) => {
+		const validOptions = validateOptions(result, ruleName, { actual: primary });
+
+		if (!validOptions) {
+			return;
+		}
+
+		root.walkDecls((decl) => {
+			if (decl.prop.startsWith('//')) {
+				report({
+					message: messages.rejected,
+					messageArgs: [],
+					node: decl,
+					result,
+					ruleName,
+				});
+			}
+		});
+
+		root.walkRules((ruleNode) => {
+			const selectors = getRuleSelector(ruleNode).split(',');
+
+			let ruleStringified;
+			let index = 0;
+
+			for (const value of selectors) {
+				const selector = value.trimStart();
+
+				if (selector.startsWith('//')) {
+					ruleStringified ??= ruleNode.toString();
+					assertString(context.newline);
+
+					const offset = value.length - selector.length;
+					const i = index + offset;
+					const lines = ruleStringified.slice(i).split(context.newline);
+					const comment = lines[0] ?? '';
+					const endIndex = i + comment.length;
+
+					report({
+						message: messages.rejected,
+						messageArgs: [],
+						node: ruleNode,
+						result,
+						ruleName,
+						index: i,
+						endIndex,
+					});
+				}
+
+				index += value.length + 1;
+			}
+		});
+	};
+};
+
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;
+export default rule;

package/packages/config-stylelint/node_modules/stylelint/lib/rules/no-invalid-position-at-import-rule/index.mjs

@@ -0,0 +1,76 @@
+import { isRegExp, isString } from '../../utils/validateTypes.mjs';
+import { isAtRule } from '../../utils/typeGuards.mjs';
+import isStandardSyntaxAtRule from '../../utils/isStandardSyntaxAtRule.mjs';
+import isStandardSyntaxRule from '../../utils/isStandardSyntaxRule.mjs';
+import optionsMatches from '../../utils/optionsMatches.mjs';
+import report from '../../utils/report.mjs';
+import ruleMessages from '../../utils/ruleMessages.mjs';
+import validateOptions from '../../utils/validateOptions.mjs';
+
+const ruleName = 'no-invalid-position-at-import-rule';
+
+const messages = ruleMessages(ruleName, {
+	rejected: 'Unexpected invalid position @import rule',
+});
+
+const meta = {
+	url: 'https://stylelint.io/user-guide/rules/no-invalid-position-at-import-rule',
+};
+
+/** @type {import('stylelint').CoreRules[ruleName]} */
+const rule = (primary, secondaryOptions) => {
+	return (root, result) => {
+		const validOptions = validateOptions(
+			result,
+			ruleName,
+			{ actual: primary },
+			{
+				actual: secondaryOptions,
+				possible: {
+					ignoreAtRules: [isString, isRegExp],
+				},
+				optional: true,
+			},
+		);
+
+		if (!validOptions) {
+			return;
+		}
+
+		let invalidPosition = false;
+
+		root.walk((node) => {
+			const nodeName = ('name' in node && node.name && node.name.toLowerCase()) || '';
+
+			if (
+				(isAtRule(node) &&
+					nodeName !== 'charset' &&
+					nodeName !== 'import' &&
+					!(nodeName === 'layer' && typeof node.nodes === 'undefined') &&
+					!optionsMatches(secondaryOptions, 'ignoreAtRules', node.name) &&
+					isStandardSyntaxAtRule(node)) ||
+				(node.type === 'rule' && isStandardSyntaxRule(node))
+			) {
+				invalidPosition = true;
+
+				return;
+			}
+
+			if (isAtRule(node) && nodeName === 'import' && invalidPosition) {
+				report({
+					message: messages.rejected,
+					messageArgs: [],
+					node,
+					result,
+					ruleName,
+					word: node.toString(),
+				});
+			}
+		});
+	};
+};
+
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;
+export default rule;

package/packages/config-stylelint/node_modules/stylelint/lib/rules/no-invalid-position-declaration/index.mjs

@@ -0,0 +1,92 @@
+import {
+	declarationContainingAtKeywords,
+	nestingSupportedAtKeywords,
+} from '../../reference/atKeywords.mjs';
+import { isAtRule, isRule } from '../../utils/typeGuards.mjs';
+import { isRegExp, isString } from '../../utils/validateTypes.mjs';
+import findNodeUpToRoot from '../../utils/findNodeUpToRoot.mjs';
+import isInDocument from '../../utils/isInDocument.mjs';
+import isStandardSyntaxDeclaration from '../../utils/isStandardSyntaxDeclaration.mjs';
+import optionsMatches from '../../utils/optionsMatches.mjs';
+import report from '../../utils/report.mjs';
+import ruleMessages from '../../utils/ruleMessages.mjs';
+import validateOptions from '../../utils/validateOptions.mjs';
+
+const ruleName = 'no-invalid-position-declaration';
+
+const messages = ruleMessages(ruleName, {
+	rejected: 'Unexpected invalid position declaration',
+});
+
+const meta = {
+	url: 'https://stylelint.io/user-guide/rules/no-invalid-position-declaration',
+};
+
+/** @type {import('stylelint').CoreRules[ruleName]} */
+const rule = (primary, secondaryOptions) => {
+	return (root, result) => {
+		const validOptions = validateOptions(
+			result,
+			ruleName,
+			{ actual: primary, possible: [true] },
+			{
+				actual: secondaryOptions,
+				possible: {
+					ignoreAtRules: [isString, isRegExp],
+				},
+				optional: true,
+			},
+		);
+
+		if (!validOptions) return;
+
+		/** @type {(node: import('postcss').Node) => boolean} */
+		const isIgnoredAtRule = (node) =>
+			isAtRule(node) && optionsMatches(secondaryOptions, 'ignoreAtRules', node.name);
+
+		/** @type {(node: import('postcss').Node) => boolean} */
+		const isDeclarationContainingAtRule = (node) =>
+			isAtRule(node) && declarationContainingAtKeywords.has(node.name.toLowerCase());
+
+		root.walkDecls((decl) => {
+			if (isInDocument(decl, { inline: true })) return;
+
+			if (!isStandardSyntaxDeclaration(decl)) return;
+
+			const { parent } = decl;
+
+			if (!parent) return;
+
+			if (isRule(parent) || isDeclarationContainingAtRule(parent)) return;
+
+			if (isAtRule(parent)) {
+				const atRuleName = parent.name.toLowerCase();
+
+				// Nesting-supported at-rules only allow declarations when nested inside a rule
+				if (nestingSupportedAtKeywords.has(atRuleName)) {
+					const parentRule = findNodeUpToRoot(
+						decl,
+						(node) => isRule(node) || isDeclarationContainingAtRule(node) || isIgnoredAtRule(node),
+					);
+
+					if (parentRule) return;
+				} else {
+					return;
+				}
+			}
+
+			report({
+				message: messages.rejected,
+				messageArgs: [],
+				node: decl,
+				result,
+				ruleName,
+			});
+		});
+	};
+};
+
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;
+export default rule;