@alexlit/lint-kit 173.2.2 → 173.3.0

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

@@ -1,167 +0,0 @@
-import valueParser from 'postcss-value-parser';
-
-import { declarationValueIndex } from '../../utils/nodeFieldIndices.mjs';
-import getDeclarationValue from '../../utils/getDeclarationValue.mjs';
-import isStandardSyntaxValue from '../../utils/isStandardSyntaxValue.mjs';
-import report from '../../utils/report.mjs';
-import ruleMessages from '../../utils/ruleMessages.mjs';
-import setDeclarationValue from '../../utils/setDeclarationValue.mjs';
-import validateOptions from '../../utils/validateOptions.mjs';
-
-const ruleName = 'lightness-notation';
-
-const messages = ruleMessages(ruleName, {
-	expected: (unfixed, fixed) => `Expected "${unfixed}" to be "${fixed}"`,
-});
-
-const meta = {
-	url: 'https://stylelint.io/user-guide/rules/lightness-notation',
-	fixable: true,
-};
-
-const LIGHTNESS_ZERO_TO_ONE_RANGE_FUNCS = new Set(['oklch', 'oklab']);
-const LIGHTNESS_ZERO_TO_HUNDRED_RANGE_FUNCS = new Set(['lch', 'lab']);
-const LIGHTNESS_FUNCS = new Set([
-	...LIGHTNESS_ZERO_TO_ONE_RANGE_FUNCS,
-	...LIGHTNESS_ZERO_TO_HUNDRED_RANGE_FUNCS,
-]);
-const HAS_LIGHTNESS_COLOR_FUNC = new RegExp(`\\b(?:${[...LIGHTNESS_FUNCS].join('|')})\\(`, 'i');
-
-/** @type {import('stylelint').CoreRules[ruleName]} */
-const rule = (primary) => {
-	return (root, result) => {
-		const validOptions = validateOptions(result, ruleName, {
-			actual: primary,
-			possible: ['percentage', 'number'],
-		});
-
-		if (!validOptions) return;
-
-		root.walkDecls((decl) => {
-			if (!HAS_LIGHTNESS_COLOR_FUNC.test(decl.value)) return;
-
-			const parsedValue = valueParser(getDeclarationValue(decl));
-
-			parsedValue.walk((node) => {
-				if (node.type !== 'function') return;
-
-				const functionName = node.value.toLowerCase();
-
-				if (!LIGHTNESS_FUNCS.has(functionName)) return;
-
-				const lightness = findLightness(node);
-
-				if (!lightness) return;
-
-				const { value: unfixedValue } = lightness;
-
-				if (!isStandardSyntaxValue(unfixedValue)) return;
-
-				const dimension = valueParser.unit(unfixedValue);
-
-				if (!dimension) return;
-
-				const isPercentage = dimension.unit === `%`;
-				const isNumber = dimension.unit === '';
-
-				if (!isPercentage && !isNumber) return;
-
-				if (primary === 'percentage' && isPercentage) return;
-
-				if (primary === 'number' && isNumber) return;
-
-				const fixedValue =
-					primary === 'percentage'
-						? asPercentage(unfixedValue, functionName)
-						: asNumber(unfixedValue, functionName);
-				const valueIndex = declarationValueIndex(decl);
-				const fix = () => {
-					lightness.value = fixedValue;
-					setDeclarationValue(decl, parsedValue.toString());
-				};
-
-				report({
-					message: messages.expected,
-					messageArgs: [unfixedValue, fixedValue],
-					node: decl,
-					index: valueIndex + lightness.sourceIndex,
-					endIndex: valueIndex + lightness.sourceEndIndex,
-					result,
-					ruleName,
-					fix: {
-						apply: fix,
-						node: decl,
-					},
-				});
-			});
-		});
-	};
-};
-
-/**
- * @param {string} value
- * @param {import('postcss-value-parser').FunctionNode['value']} func
- */
-function asPercentage(value, func) {
-	let num = Number.parseFloat(value);
-
-	if (LIGHTNESS_ZERO_TO_HUNDRED_RANGE_FUNCS.has(func)) {
-		return `${num}%`;
-	}
-
-	if (LIGHTNESS_ZERO_TO_ONE_RANGE_FUNCS.has(func)) {
-		num *= 100;
-	}
-
-	if (Number.isInteger(num)) {
-		return `${num}%`;
-	}
-
-	return `${roundToNumberOfDigits(num, value)}%`;
-}
-
-/**
- * @param {string} value
- * @param {import('postcss-value-parser').FunctionNode['value']} func
- */
-function asNumber(value, func) {
-	let num = Number.parseFloat(value);
-
-	if (LIGHTNESS_ZERO_TO_ONE_RANGE_FUNCS.has(func)) {
-		num /= 100;
-
-		return `${roundToNumberOfDigits(num, value)}`;
-	}
-
-	return `${num}`;
-}
-
-/**
- * @param {number} num
- * @param {string} value
- * @returns {string}
- */
-function roundToNumberOfDigits(num, value) {
-	if (num === 0) return '0';
-
-	const precision = value.replaceAll('%', '').replaceAll('.', '').length;
-
-	if (precision === 0) return `${num}`;
-
-	return num.toPrecision(precision).replace(/\.?0+$/, ''); // trim trailing zeros and decimal point
-}
-
-/**
- * @param {import('postcss-value-parser').FunctionNode} node
- */
-function findLightness({ nodes }) {
-	const args = nodes.filter(({ type }) => type === 'word' || type === 'function');
-	const isRelativeColor = args[0]?.value.toLowerCase() === 'from';
-
-	return isRelativeColor ? args[2] : args[0];
-}
-
-rule.ruleName = ruleName;
-rule.messages = messages;
-rule.meta = meta;
-export default rule;

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

@@ -1,195 +0,0 @@
-import parser from 'postcss-selector-parser';
-
-import { isAtRule, isDeclaration, isRoot, isRule } from '../../utils/typeGuards.mjs';
-import { isNumber, isRegExp, isString } from '../../utils/validateTypes.mjs';
-import hasBlock from '../../utils/hasBlock.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 = 'max-nesting-depth';
-
-const messages = ruleMessages(ruleName, {
-	expected: (depth) => `Expected nesting depth to be no more than ${depth}`,
-});
-
-const meta = {
-	url: 'https://stylelint.io/user-guide/rules/max-nesting-depth',
-};
-
-/** @type {import('stylelint').CoreRules[ruleName]} */
-const rule = (primary, secondaryOptions) => {
-	/**
-	 * @param {import('postcss').Node} node
-	 */
-	const isIgnoreAtRule = (node) =>
-		isAtRule(node) && optionsMatches(secondaryOptions, 'ignoreAtRules', node.name);
-
-	/**
-	 * @param {import('postcss').Node} node
-	 */
-	const isIgnoreRule = (node) => {
-		return isRule(node) && optionsMatches(secondaryOptions, 'ignoreRules', node.selector);
-	};
-
-	return (root, result) => {
-		const validOptions = validateOptions(
-			result,
-			ruleName,
-			{
-				actual: primary,
-				possible: [isNumber],
-			},
-			{
-				optional: true,
-				actual: secondaryOptions,
-				possible: {
-					ignore: ['blockless-at-rules', 'pseudo-classes'],
-					ignoreAtRules: [isString, isRegExp],
-					ignoreRules: [isString, isRegExp],
-					ignorePseudoClasses: [isString, isRegExp],
-				},
-			},
-		);
-
-		if (!validOptions) return;
-
-		root.walkRules(checkStatement);
-		root.walkAtRules(checkStatement);
-
-		/**
-		 * @param {import('postcss').Rule | import('postcss').AtRule} statement
-		 */
-		function checkStatement(statement) {
-			if (isIgnoreAtRule(statement)) {
-				return;
-			}
-
-			if (isIgnoreRule(statement)) {
-				return;
-			}
-
-			if (!hasBlock(statement)) {
-				return;
-			}
-
-			if (isRule(statement) && !isStandardSyntaxRule(statement)) {
-				return;
-			}
-
-			const depth = nestingDepth(statement, 0);
-
-			if (depth > primary) {
-				report({
-					ruleName,
-					result,
-					node: statement,
-					message: messages.expected,
-					messageArgs: [primary],
-				});
-			}
-		}
-	};
-
-	/**
-	 * @param {import('postcss').Node} node
-	 * @param {number} level
-	 * @returns {number}
-	 */
-	function nestingDepth(node, level) {
-		const parent = node.parent;
-
-		if (!parent) {
-			return 0;
-		}
-
-		if (isIgnoreAtRule(parent)) {
-			return 0;
-		}
-
-		// The nesting depth level's computation has finished
-		// when this function, recursively called, receives
-		// a node that is not nested -- a direct child of the
-		// root node
-		if (isRoot(parent) || (isAtRule(parent) && parent.parent && isRoot(parent.parent))) {
-			return level;
-		}
-
-		/**
-		 * @param {string} selector
-		 */
-		function containsPseudoClassesOnly(selector) {
-			const normalized = parser().processSync(selector, { lossless: false });
-			const selectors = normalized.split(',');
-
-			const filteredSelectors = selectors.filter(
-				(sel) => !optionsMatches(secondaryOptions, 'ignoreRules', sel),
-			);
-
-			return filteredSelectors.every((sel) => extractPseudoRule(sel));
-		}
-
-		/**
-		 * @param {string[]} selectors
-		 * @returns {boolean}
-		 */
-		function containsIgnoredPseudoClassesOrRulesOnly(selectors) {
-			if (
-				!(
-					secondaryOptions &&
-					(secondaryOptions.ignorePseudoClasses || secondaryOptions.ignoreRules)
-				)
-			)
-				return false;
-
-			return selectors.every((selector) => {
-				if (
-					secondaryOptions.ignoreRules &&
-					optionsMatches(secondaryOptions, 'ignoreRules', selector)
-				)
-					return true;
-
-				if (!secondaryOptions.ignorePseudoClasses) return false;
-
-				const pseudoRule = extractPseudoRule(selector);
-
-				if (!pseudoRule) return false;
-
-				return optionsMatches(secondaryOptions, 'ignorePseudoClasses', pseudoRule);
-			});
-		}
-
-		if (
-			(optionsMatches(secondaryOptions, 'ignore', 'blockless-at-rules') &&
-				isAtRule(node) &&
-				node.every((child) => !isDeclaration(child))) ||
-			(optionsMatches(secondaryOptions, 'ignore', 'pseudo-classes') &&
-				isRule(node) &&
-				containsPseudoClassesOnly(node.selector)) ||
-			(isRule(node) && containsIgnoredPseudoClassesOrRulesOnly(node.selectors))
-		) {
-			return nestingDepth(parent, level);
-		}
-
-		// Unless any of the conditions above apply, we want to
-		// add 1 to the nesting depth level and then check the parent,
-		// continuing to add and move up the hierarchy
-		// until we hit the root node
-		return nestingDepth(parent, level + 1);
-	}
-};
-
-/**
- * @param {string} selector
- * @returns {string | undefined}
- */
-function extractPseudoRule(selector) {
-	return selector.startsWith('&:') && selector[2] !== ':' ? selector.slice(2) : undefined;
-}
-
-rule.ruleName = ruleName;
-rule.messages = messages;
-rule.meta = meta;
-export default rule;

package/packages/config-stylelint/node_modules/stylelint/lib/rules/media-feature-name-allowed-list/index.mjs

@@ -1,67 +0,0 @@
-import { isRegExp, isString } from '../../utils/validateTypes.mjs';
-import { atRuleParamIndex } from '../../utils/nodeFieldIndices.mjs';
-import { atRuleRegexes } from '../../utils/regexes.mjs';
-import findMediaFeatureNames from '../../utils/findMediaFeatureNames.mjs';
-import getAtRuleParams from '../../utils/getAtRuleParams.mjs';
-import isCustomMediaQuery from '../../utils/isCustomMediaQuery.mjs';
-import matchesStringOrRegExp from '../../utils/matchesStringOrRegExp.mjs';
-import report from '../../utils/report.mjs';
-import ruleMessages from '../../utils/ruleMessages.mjs';
-import validateOptions from '../../utils/validateOptions.mjs';
-
-const ruleName = 'media-feature-name-allowed-list';
-
-const messages = ruleMessages(ruleName, {
-	rejected: (name) => `Unexpected media feature name "${name}"`,
-});
-
-const meta = {
-	url: 'https://stylelint.io/user-guide/rules/media-feature-name-allowed-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.walkAtRules(atRuleRegexes.mediaName, (atRule) => {
-			findMediaFeatureNames(getAtRuleParams(atRule), (mediaFeatureNameToken) => {
-				const [, , startIndex, endIndex, { value: featureName }] = mediaFeatureNameToken;
-
-				if (isCustomMediaQuery(featureName)) {
-					return;
-				}
-
-				if (matchesStringOrRegExp(featureName, primary)) {
-					return;
-				}
-
-				const atRuleIndex = atRuleParamIndex(atRule);
-
-				report({
-					message: messages.rejected,
-					messageArgs: [featureName],
-					node: atRule,
-					index: atRuleIndex + startIndex,
-					endIndex: atRuleIndex + endIndex + 1,
-					ruleName,
-					result,
-				});
-			});
-		});
-	};
-};
-
-rule.primaryOptionArray = true;
-
-rule.ruleName = ruleName;
-rule.messages = messages;
-rule.meta = meta;
-export default rule;

package/packages/config-stylelint/node_modules/stylelint/lib/rules/media-feature-name-disallowed-list/index.mjs

@@ -1,67 +0,0 @@
-import { isRegExp, isString } from '../../utils/validateTypes.mjs';
-import { atRuleParamIndex } from '../../utils/nodeFieldIndices.mjs';
-import { atRuleRegexes } from '../../utils/regexes.mjs';
-import findMediaFeatureNames from '../../utils/findMediaFeatureNames.mjs';
-import getAtRuleParams from '../../utils/getAtRuleParams.mjs';
-import isCustomMediaQuery from '../../utils/isCustomMediaQuery.mjs';
-import matchesStringOrRegExp from '../../utils/matchesStringOrRegExp.mjs';
-import report from '../../utils/report.mjs';
-import ruleMessages from '../../utils/ruleMessages.mjs';
-import validateOptions from '../../utils/validateOptions.mjs';
-
-const ruleName = 'media-feature-name-disallowed-list';
-
-const messages = ruleMessages(ruleName, {
-	rejected: (name) => `Unexpected media feature name "${name}"`,
-});
-
-const meta = {
-	url: 'https://stylelint.io/user-guide/rules/media-feature-name-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.walkAtRules(atRuleRegexes.mediaName, (atRule) => {
-			findMediaFeatureNames(getAtRuleParams(atRule), (mediaFeatureNameToken) => {
-				const [, , startIndex, endIndex, { value: featureName }] = mediaFeatureNameToken;
-
-				if (isCustomMediaQuery(featureName)) {
-					return;
-				}
-
-				if (!matchesStringOrRegExp(featureName, primary)) {
-					return;
-				}
-
-				const atRuleIndex = atRuleParamIndex(atRule);
-
-				report({
-					message: messages.rejected,
-					messageArgs: [featureName],
-					node: atRule,
-					index: atRuleIndex + startIndex,
-					endIndex: atRuleIndex + endIndex + 1,
-					ruleName,
-					result,
-				});
-			});
-		});
-	};
-};
-
-rule.primaryOptionArray = true;
-
-rule.ruleName = ruleName;
-rule.messages = messages;
-rule.meta = meta;
-export default rule;

package/packages/config-stylelint/node_modules/stylelint/lib/rules/media-feature-name-no-unknown/index.mjs

@@ -1,79 +0,0 @@
-import { isRegExp, isString } from '../../utils/validateTypes.mjs';
-import { atRuleParamIndex } from '../../utils/nodeFieldIndices.mjs';
-import { atRuleRegexes } from '../../utils/regexes.mjs';
-import findMediaFeatureNames from '../../utils/findMediaFeatureNames.mjs';
-import getAtRuleParams from '../../utils/getAtRuleParams.mjs';
-import isCustomMediaQuery from '../../utils/isCustomMediaQuery.mjs';
-import { mediaFeatureNames } from '../../reference/mediaFeatures.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';
-import vendor from '../../utils/vendor.mjs';
-
-const ruleName = 'media-feature-name-no-unknown';
-
-const messages = ruleMessages(ruleName, {
-	rejected: (mediaFeatureName) => `Unexpected unknown media feature name "${mediaFeatureName}"`,
-});
-
-const meta = {
-	url: 'https://stylelint.io/user-guide/rules/media-feature-name-no-unknown',
-};
-
-/** @type {import('stylelint').CoreRules[ruleName]} */
-const rule = (primary, secondaryOptions) => {
-	return (root, result) => {
-		const validOptions = validateOptions(
-			result,
-			ruleName,
-			{ actual: primary },
-			{
-				actual: secondaryOptions,
-				possible: {
-					ignoreMediaFeatureNames: [isString, isRegExp],
-				},
-				optional: true,
-			},
-		);
-
-		if (!validOptions) {
-			return;
-		}
-
-		root.walkAtRules(atRuleRegexes.mediaName, (atRule) => {
-			findMediaFeatureNames(getAtRuleParams(atRule), (mediaFeatureNameToken) => {
-				const [, , startIndex, endIndex, { value: featureName }] = mediaFeatureNameToken;
-
-				if (isCustomMediaQuery(featureName)) {
-					return;
-				}
-
-				if (optionsMatches(secondaryOptions, 'ignoreMediaFeatureNames', featureName)) {
-					return;
-				}
-
-				if (vendor.prefix(featureName) || mediaFeatureNames.has(featureName.toLowerCase())) {
-					return;
-				}
-
-				const atRuleIndex = atRuleParamIndex(atRule);
-
-				report({
-					message: messages.rejected,
-					messageArgs: [featureName],
-					node: atRule,
-					index: atRuleIndex + startIndex,
-					endIndex: atRuleIndex + endIndex + 1,
-					ruleName,
-					result,
-				});
-			});
-		});
-	};
-};
-
-rule.ruleName = ruleName;
-rule.messages = messages;
-rule.meta = meta;
-export default rule;

package/packages/config-stylelint/node_modules/stylelint/lib/rules/media-feature-name-no-vendor-prefix/index.mjs

@@ -1,77 +0,0 @@
-import { atRuleRegexes } from '../../utils/regexes.mjs';
-import isAutoprefixable from '../../utils/isAutoprefixable.mjs';
-import report from '../../utils/report.mjs';
-import ruleMessages from '../../utils/ruleMessages.mjs';
-import validateOptions from '../../utils/validateOptions.mjs';
-
-const ruleName = 'media-feature-name-no-vendor-prefix';
-
-const messages = ruleMessages(ruleName, {
-	rejected: 'Unexpected vendor-prefix',
-});
-
-const meta = {
-	url: 'https://stylelint.io/user-guide/rules/media-feature-name-no-vendor-prefix',
-	fixable: true,
-};
-
-const FEATURES = [
-	'-webkit-device-pixel-ratio',
-	'-webkit-min-device-pixel-ratio',
-	'-webkit-max-device-pixel-ratio',
-	'-o-device-pixel-ratio',
-	'-o-min-device-pixel-ratio',
-	'-o-max-device-pixel-ratio',
-	'-moz-device-pixel-ratio',
-	'min--moz-device-pixel-ratio',
-	'max--moz-device-pixel-ratio',
-];
-
-/** @type {import('stylelint').CoreRules[ruleName]} */
-const rule = (primary) => {
-	return (root, result) => {
-		const validOptions = validateOptions(result, ruleName, { actual: primary });
-
-		if (!validOptions) {
-			return;
-		}
-
-		root.walkAtRules(atRuleRegexes.mediaName, (atRule) => {
-			const params = atRule.params;
-
-			if (!isAutoprefixable.mediaFeatureName(params)) {
-				return;
-			}
-
-			const matches = atRule.toString().match(new RegExp(`${FEATURES.join('|')}`, 'gi'));
-
-			if (!matches) {
-				return;
-			}
-
-			for (const match of matches) {
-				const fix = () => {
-					atRule.params = atRule.params.replace(/-moz-|-o-|-webkit-/i, '');
-				};
-
-				report({
-					message: messages.rejected,
-					messageArgs: [],
-					node: atRule,
-					word: match,
-					result,
-					ruleName,
-					fix: {
-						apply: fix,
-						node: atRule,
-					},
-				});
-			}
-		});
-	};
-};
-
-rule.ruleName = ruleName;
-rule.messages = messages;
-rule.meta = meta;
-export default rule;