@alexlit/lint-kit 183.6.0 → 183.7.0

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

@@ -1,180 +0,0 @@
-/** @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

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

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

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

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

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