@alexlit/lint-kit 183.4.0 → 183.6.0

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

@@ -0,0 +1,180 @@
+/** @type {Map<string, Promise<import('stylelint').Rule>>} */
+const ruleCache = new Map();
+
+/**
+ * Returns a cached Promise for the rule, avoiding async overhead for rules that
+ * have already been loaded.
+ *
+ * @param {string} ruleName
+ * @returns {Promise<import('stylelint').Rule>}
+ */
+function getCachedRule(ruleName) {
+	let rule = ruleCache.get(ruleName);
+
+	if (!rule) {
+		rule = import(`./${ruleName}/index.mjs`).then((m) => m.default);
+		ruleCache.set(ruleName, rule);
+	}
+
+	return rule;
+}
+
+const ruleNames = [
+	'alpha-value-notation',
+	'annotation-no-unknown',
+	'at-rule-allowed-list',
+	'at-rule-descriptor-no-unknown',
+	'at-rule-descriptor-value-no-unknown',
+	'at-rule-disallowed-list',
+	'at-rule-empty-line-before',
+	'at-rule-no-deprecated',
+	'at-rule-no-unknown',
+	'at-rule-no-vendor-prefix',
+	'at-rule-prelude-no-invalid',
+	'at-rule-property-required-list',
+	'block-no-empty',
+	'block-no-redundant-nested-style-rules',
+	'color-function-alias-notation',
+	'color-function-notation',
+	'color-hex-alpha',
+	'color-hex-length',
+	'color-named',
+	'color-no-hex',
+	'color-no-invalid-hex',
+	'comment-empty-line-before',
+	'comment-no-empty',
+	'comment-pattern',
+	'comment-whitespace-inside',
+	'comment-word-disallowed-list',
+	'container-name-pattern',
+	'custom-media-pattern',
+	'custom-property-empty-line-before',
+	'custom-property-no-missing-var-function',
+	'custom-property-pattern',
+	'declaration-block-no-duplicate-custom-properties',
+	'declaration-block-no-duplicate-properties',
+	'declaration-block-no-redundant-longhand-properties',
+	'declaration-block-no-shorthand-property-overrides',
+	'declaration-block-single-line-max-declarations',
+	'declaration-empty-line-before',
+	'declaration-no-important',
+	'declaration-property-max-values',
+	'declaration-property-unit-allowed-list',
+	'declaration-property-unit-disallowed-list',
+	'declaration-property-value-allowed-list',
+	'declaration-property-value-disallowed-list',
+	'declaration-property-value-keyword-no-deprecated',
+	'declaration-property-value-no-unknown',
+	'display-notation',
+	'font-family-name-quotes',
+	'font-family-no-duplicate-names',
+	'font-family-no-missing-generic-family-keyword',
+	'font-weight-notation',
+	'function-allowed-list',
+	'function-calc-no-unspaced-operator',
+	'function-disallowed-list',
+	'function-linear-gradient-no-nonstandard-direction',
+	'function-name-case',
+	'function-no-unknown',
+	'function-url-no-scheme-relative',
+	'function-url-quotes',
+	'function-url-scheme-allowed-list',
+	'function-url-scheme-disallowed-list',
+	'hue-degree-notation',
+	'import-notation',
+	'keyframe-block-no-duplicate-selectors',
+	'keyframe-declaration-no-important',
+	'keyframe-selector-notation',
+	'keyframes-name-pattern',
+	'layer-name-pattern',
+	'length-zero-no-unit',
+	'lightness-notation',
+	'max-nesting-depth',
+	'media-feature-name-allowed-list',
+	'media-feature-name-disallowed-list',
+	'media-feature-name-no-unknown',
+	'media-feature-name-no-vendor-prefix',
+	'media-feature-name-unit-allowed-list',
+	'media-feature-name-value-allowed-list',
+	'media-feature-name-value-no-unknown',
+	'media-feature-range-notation',
+	'media-query-no-invalid',
+	'media-type-no-deprecated',
+	'named-grid-areas-no-invalid',
+	'nesting-selector-no-missing-scoping-root',
+	'no-descending-specificity',
+	'no-duplicate-at-import-rules',
+	'no-duplicate-selectors',
+	'no-empty-source',
+	'no-invalid-double-slash-comments',
+	'no-invalid-position-at-import-rule',
+	'no-invalid-position-declaration',
+	'no-irregular-whitespace',
+	'no-unknown-animations',
+	'no-unknown-custom-media',
+	'no-unknown-custom-properties',
+	'number-max-precision',
+	'property-allowed-list',
+	'property-disallowed-list',
+	'property-no-deprecated',
+	'property-no-unknown',
+	'property-no-vendor-prefix',
+	'rule-empty-line-before',
+	'rule-nesting-at-rule-required-list',
+	'rule-selector-property-disallowed-list',
+	'selector-anb-no-unmatchable',
+	'selector-attribute-name-disallowed-list',
+	'selector-attribute-operator-allowed-list',
+	'selector-attribute-operator-disallowed-list',
+	'selector-attribute-quotes',
+	'selector-class-pattern',
+	'selector-combinator-allowed-list',
+	'selector-combinator-disallowed-list',
+	'selector-disallowed-list',
+	'selector-id-pattern',
+	'selector-max-attribute',
+	'selector-max-class',
+	'selector-max-combinators',
+	'selector-max-compound-selectors',
+	'selector-max-id',
+	'selector-max-pseudo-class',
+	'selector-max-specificity',
+	'selector-max-type',
+	'selector-max-universal',
+	'selector-nested-pattern',
+	'selector-no-qualifying-type',
+	'selector-no-vendor-prefix',
+	'selector-not-notation',
+	'selector-pseudo-class-allowed-list',
+	'selector-pseudo-class-disallowed-list',
+	'selector-pseudo-class-no-unknown',
+	'selector-pseudo-element-allowed-list',
+	'selector-pseudo-element-colon-notation',
+	'selector-pseudo-element-disallowed-list',
+	'selector-pseudo-element-no-unknown',
+	'selector-type-case',
+	'selector-type-no-unknown',
+	'shorthand-property-no-redundant-values',
+	'string-no-newline',
+	'syntax-string-no-invalid',
+	'time-min-milliseconds',
+	'unit-allowed-list',
+	'unit-disallowed-list',
+	'unit-no-unknown',
+	'value-keyword-case',
+	'value-no-vendor-prefix',
+];
+
+const rules = /** @type {import('stylelint').PublicApi['rules']} */ ({});
+
+for (const name of ruleNames) {
+	Object.defineProperty(rules, name, {
+		get() {
+			return getCachedRule(name);
+		},
+		enumerable: true,
+		configurable: true,
+	});
+}
+
+export default rules;

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

@@ -0,0 +1,68 @@
+import { atRuleRegexes } from '../../utils/regexes.mjs';
+import getRuleSelector from '../../utils/getRuleSelector.mjs';
+import getStrippedSelectorSource from '../../utils/getStrippedSelectorSource.mjs';
+import isStandardSyntaxRule from '../../utils/isStandardSyntaxRule.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 = 'keyframe-block-no-duplicate-selectors';
+
+const messages = ruleMessages(ruleName, {
+	rejected: (selector) => `Unexpected duplicate "${selector}"`,
+});
+
+const meta = {
+	url: 'https://stylelint.io/user-guide/rules/keyframe-block-no-duplicate-selectors',
+};
+
+/** @type {import('stylelint').CoreRules[ruleName]} */
+const rule = (primary) => {
+	return (root, result) => {
+		const validOptions = validateOptions(result, ruleName, { actual: primary });
+
+		if (!validOptions) {
+			return;
+		}
+
+		root.walkAtRules(atRuleRegexes.keyframesName, (atRuleKeyframes) => {
+			const selectors = new Set();
+
+			atRuleKeyframes.walkRules((keyframeRule) => {
+				if (!isStandardSyntaxRule(keyframeRule)) {
+					return;
+				}
+
+				parseSelector(getRuleSelector(keyframeRule), result, keyframeRule)?.each((selector) => {
+					const { selector: selectorStr, index, endIndex } = getStrippedSelectorSource(selector);
+
+					const normalizedSelector = selectorStr.toLowerCase();
+
+					const isDuplicate = selectors.has(normalizedSelector);
+
+					if (isDuplicate) {
+						report({
+							message: messages.rejected,
+							messageArgs: [selectorStr],
+							node: keyframeRule,
+							result,
+							ruleName,
+							index,
+							endIndex,
+						});
+
+						return;
+					}
+
+					selectors.add(normalizedSelector);
+				});
+			});
+		});
+	};
+};
+
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;
+export default rule;

package/packages/config-stylelint/node_modules/stylelint/lib/rules/keyframe-declaration-no-important/index.mjs

@@ -0,0 +1,54 @@
+import { assert } from '../../utils/validateTypes.mjs';
+import { atRuleRegexes } from '../../utils/regexes.mjs';
+import getImportantPosition from '../../utils/getImportantPosition.mjs';
+import report from '../../utils/report.mjs';
+import ruleMessages from '../../utils/ruleMessages.mjs';
+import validateOptions from '../../utils/validateOptions.mjs';
+
+const ruleName = 'keyframe-declaration-no-important';
+
+const messages = ruleMessages(ruleName, {
+	rejected: 'Unexpected !important',
+});
+
+const meta = {
+	url: 'https://stylelint.io/user-guide/rules/keyframe-declaration-no-important',
+};
+
+/** @type {import('stylelint').CoreRules[ruleName]} */
+const rule = (primary) => {
+	return (root, result) => {
+		const validOptions = validateOptions(result, ruleName, { actual: primary });
+
+		if (!validOptions) {
+			return;
+		}
+
+		root.walkAtRules(atRuleRegexes.keyframesName, (atRuleKeyframes) => {
+			atRuleKeyframes.walkDecls((decl) => {
+				if (!decl.important) {
+					return;
+				}
+
+				const pos = getImportantPosition(decl.toString());
+
+				assert(pos);
+
+				report({
+					message: messages.rejected,
+					messageArgs: [],
+					node: decl,
+					index: pos.index,
+					endIndex: pos.endIndex,
+					result,
+					ruleName,
+				});
+			});
+		});
+	};
+};
+
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;
+export default rule;

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

@@ -0,0 +1,202 @@
+import { assertString } from '../../utils/validateTypes.mjs';
+import { keyframeSelectorKeywords } from '../../reference/keywords.mjs';
+
+import { atRuleRegexes, mayIncludeRegexes } from '../../utils/regexes.mjs';
+import getRuleSelector from '../../utils/getRuleSelector.mjs';
+import parseSelector from '../../utils/parseSelector.mjs';
+import parser from 'postcss-selector-parser';
+import { percentageKeyframeWithNamedEquivalent } from '../../reference/selectors.mjs';
+import report from '../../utils/report.mjs';
+import ruleMessages from '../../utils/ruleMessages.mjs';
+import validateOptions from '../../utils/validateOptions.mjs';
+
+const ruleName = 'keyframe-selector-notation';
+
+const messages = ruleMessages(ruleName, {
+	expected: (selector, fixedSelector) => `Expected "${selector}" to be "${fixedSelector}"`,
+});
+
+const meta = {
+	url: 'https://stylelint.io/user-guide/rules/keyframe-selector-notation',
+	fixable: true,
+};
+
+const PERCENTAGE_TO_KEYWORD = new Map([
+	['0%', 'from'],
+	['100%', 'to'],
+]);
+
+const KEYWORD_TO_PERCENTAGE = new Map([
+	['from', '0%'],
+	['to', '100%'],
+]);
+
+/** @type {import('stylelint').CoreRules[ruleName]} */
+const rule = (primary) => {
+	return (root, result) => {
+		const validOptions = validateOptions(result, ruleName, {
+			actual: primary,
+			possible: ['keyword', 'percentage', 'percentage-unless-within-keyword-only-block'],
+		});
+
+		if (!validOptions) return;
+
+		/**
+		 * @typedef {{
+		 *   expFunc: (selector: string, selectorsInBlock: string[]) => boolean,
+		 *   fixFunc: (selector: string) => string,
+		 * }} OptionFuncs
+		 *
+		 * @type {Record<typeof primary, OptionFuncs>}
+		 */
+		const optionFuncs = {
+			keyword: {
+				expFunc: (selector) => keyframeSelectorKeywords.has(selector),
+				fixFunc: (selector) => getFromMap(PERCENTAGE_TO_KEYWORD, selector),
+			},
+			percentage: {
+				expFunc: (selector) => percentageKeyframeWithNamedEquivalent.has(selector),
+				fixFunc: (selector) => getFromMap(KEYWORD_TO_PERCENTAGE, selector),
+			},
+			'percentage-unless-within-keyword-only-block': {
+				expFunc: (selector, selectorsInBlock) => {
+					if (selectorsInBlock.every((s) => keyframeSelectorKeywords.has(s))) return true;
+
+					return percentageKeyframeWithNamedEquivalent.has(selector);
+				},
+				fixFunc: (selector) => getFromMap(KEYWORD_TO_PERCENTAGE, selector),
+			},
+		};
+
+		const { expFunc, fixFunc } = optionFuncs[primary];
+
+		let selectorRegex;
+
+		if (primary === 'keyword') {
+			selectorRegex = mayIncludeRegexes.percentageKeyframeSelectorWithNamedEquivalent;
+		} else if (primary === 'percentage') {
+			selectorRegex = mayIncludeRegexes.namedKeyframeSelectorWithPercentageEquivalent;
+		} else {
+			selectorRegex = /./;
+		}
+
+		root.walkAtRules(atRuleRegexes.keyframesName, (atRuleKeyframes) => {
+			const selectorsInBlock =
+				primary === 'percentage-unless-within-keyword-only-block'
+					? getSelectorsInBlock(atRuleKeyframes)
+					: [];
+
+			atRuleKeyframes.walkRules(selectorRegex, (keyframeRule) => {
+				const ruleSelector = getRuleSelector(keyframeRule);
+
+				const selectors = parseSelector(ruleSelector, result, keyframeRule);
+
+				if (!selectors) return;
+
+				selectors.each((selector) => {
+					const parsed = parseKeyframeSelector(selector);
+
+					if (!parsed) return;
+
+					const [keyframeSelector, normalizedSelector] = parsed;
+
+					if (expFunc(normalizedSelector, selectorsInBlock)) return;
+
+					const fixedSelector = fixFunc(normalizedSelector);
+
+					const fix = () => {
+						keyframeSelector.value = fixedSelector;
+						keyframeRule.selector = selectors.toString();
+					};
+
+					report({
+						message: messages.expected,
+						messageArgs: [keyframeSelector.value, fixedSelector],
+						node: keyframeRule,
+						result,
+						ruleName,
+						index: keyframeSelector.sourceIndex,
+						endIndex: keyframeSelector.sourceIndex + normalizedSelector.length,
+						fix: {
+							apply: fix,
+							node: keyframeRule,
+						},
+					});
+				});
+			});
+		});
+	};
+};
+
+/** @import { Selector, Tag } from 'postcss-selector-parser' */
+
+/**
+ * Full syntax is:
+ * `<keyframe-selector> = from | to | <percentage [0,100]> | <timeline-range-name> <percentage>`
+ *
+ * Only parses `from | to | <percentage [0,100]>` and returns `undefined` in any other case.
+ *
+ * @param {Selector} selector
+ * @returns {[Tag,string]|undefined}
+ */
+function parseKeyframeSelector(selector) {
+	const relevantNodes = selector.nodes.filter((node) => {
+		if (parser.isComment(node)) return false;
+
+		if (parser.isCombinator(node) && node.value.trim() === '') return false;
+
+		return true;
+	});
+
+	if (relevantNodes.length !== 1) return;
+
+	if (!relevantNodes.every(parser.isTag)) return;
+
+	const keyframeSelector = relevantNodes[0];
+
+	if (!keyframeSelector) return;
+
+	const normalizedSelector = keyframeSelector.value.toLowerCase();
+
+	if (
+		!keyframeSelectorKeywords.has(normalizedSelector) &&
+		!percentageKeyframeWithNamedEquivalent.has(normalizedSelector)
+	) {
+		return;
+	}
+
+	return [keyframeSelector, normalizedSelector];
+}
+
+/**
+ * @param {Map<string, string>} map
+ * @param {string} key
+ * @returns {string}
+ */
+function getFromMap(map, key) {
+	const value = map.get(key);
+
+	assertString(value);
+
+	return value;
+}
+
+/**
+ * @param {import('postcss').AtRule} atRule
+ * @returns {string[]}
+ */
+function getSelectorsInBlock(atRule) {
+	/** @type {string[]} */
+	const selectors = [];
+
+	atRule.walkRules((r) => {
+		selectors.push(...r.selectors.map((selector) => selector.toLowerCase()));
+	});
+
+	return selectors;
+}
+
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;
+export default rule;

package/packages/config-stylelint/node_modules/stylelint/lib/rules/keyframes-name-pattern/index.mjs

@@ -0,0 +1,63 @@
+import { isRegExp, isString } from '../../utils/validateTypes.mjs';
+import { atRuleParamIndex } from '../../utils/nodeFieldIndices.mjs';
+import { atRuleRegexes } from '../../utils/regexes.mjs';
+import isStandardSyntaxKeyframesName from '../../utils/isStandardSyntaxKeyframesName.mjs';
+import report from '../../utils/report.mjs';
+import ruleMessages from '../../utils/ruleMessages.mjs';
+import validateOptions from '../../utils/validateOptions.mjs';
+
+const ruleName = 'keyframes-name-pattern';
+
+const messages = ruleMessages(ruleName, {
+	expected: (keyframeName, pattern) => `Expected "${keyframeName}" to match pattern "${pattern}"`,
+});
+
+const meta = {
+	url: 'https://stylelint.io/user-guide/rules/keyframes-name-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 regex = isString(primary) ? new RegExp(primary) : primary;
+
+		root.walkAtRules(atRuleRegexes.keyframesName, (keyframesNode) => {
+			const value = keyframesNode.params;
+
+			if (!isStandardSyntaxKeyframesName(value)) {
+				return;
+			}
+
+			if (regex.test(value)) {
+				return;
+			}
+
+			const index = atRuleParamIndex(keyframesNode);
+			const endIndex = index + value.length;
+
+			report({
+				index,
+				endIndex,
+				message: messages.expected,
+				messageArgs: [value, primary],
+				node: keyframesNode,
+				ruleName,
+				result,
+			});
+		});
+	};
+};
+
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;
+export default rule;

package/packages/config-stylelint/node_modules/stylelint/lib/rules/layer-name-pattern/index.mjs

@@ -0,0 +1,91 @@
+import valueParser from 'postcss-value-parser';
+
+import { atRuleRegexes, mayIncludeRegexes } from '../../utils/regexes.mjs';
+import { isRegExp, isString } from '../../utils/validateTypes.mjs';
+import { atRuleParamIndex } from '../../utils/nodeFieldIndices.mjs';
+import report from '../../utils/report.mjs';
+import ruleMessages from '../../utils/ruleMessages.mjs';
+import validateOptions from '../../utils/validateOptions.mjs';
+
+const ruleName = 'layer-name-pattern';
+
+const messages = ruleMessages(ruleName, {
+	expected: (name, pattern) => `Expected "${name}" to match pattern "${pattern}"`,
+});
+
+const meta = {
+	url: 'https://stylelint.io/user-guide/rules/layer-name-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 pattern = isString(primary) ? new RegExp(primary) : primary;
+
+		root.walkAtRules(atRuleRegexes.layerName, (atRule) => {
+			const { params } = atRule;
+
+			if (!params) return;
+
+			const parsedParams = valueParser(params);
+
+			parsedParams.walk((node) => {
+				check(node.type, node.value, node.sourceIndex, atRule);
+			});
+		});
+
+		root.walkAtRules(atRuleRegexes.importName, (atRule) => {
+			const { params } = atRule;
+
+			if (!mayIncludeRegexes.layerFunction.test(params)) return;
+
+			const parsedParams = valueParser(atRule.params);
+
+			parsedParams.walk((node) => {
+				if (node.type !== 'function' || node.value.toLowerCase() !== 'layer') return;
+
+				for (const child of node.nodes) {
+					check(child.type, child.value, child.sourceIndex, atRule);
+				}
+			});
+		});
+
+		/**
+		 * @param {string} type
+		 * @param {string} value
+		 * @param {number} sourceIndex
+		 * @param {import('postcss').AtRule} atRule
+		 */
+		function check(type, value, sourceIndex, atRule) {
+			if (type !== 'word') return;
+
+			if (pattern.test(value)) return;
+
+			const index = atRuleParamIndex(atRule) + sourceIndex;
+			const endIndex = index + value.length;
+
+			report({
+				message: messages.expected,
+				messageArgs: [value, primary],
+				node: atRule,
+				index,
+				endIndex,
+				ruleName,
+				result,
+			});
+		}
+	};
+};
+
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;
+
+export default rule;