@alexlit/lint-kit 182.1.0 → 182.2.0

package/packages/config-stylelint/node_modules/stylelint/lib/rules/length-zero-no-unit/index.mjs

@@ -0,0 +1,221 @@
+import valueParser from 'postcss-value-parser';
+
+import { atRuleParamIndex, declarationValueIndex } from '../../utils/nodeFieldIndices.mjs';
+import { isValueFunction as isFunction, isValueWord as isWord } from '../../utils/typeGuards.mjs';
+import { isRegExp, isString } from '../../utils/validateTypes.mjs';
+import getAtRuleParams from '../../utils/getAtRuleParams.mjs';
+import getDeclarationValue from '../../utils/getDeclarationValue.mjs';
+import isCustomProperty from '../../utils/isCustomProperty.mjs';
+import isMathFunction from '../../utils/isMathFunction.mjs';
+import isStandardSyntaxAtRule from '../../utils/isStandardSyntaxAtRule.mjs';
+import isStandardSyntaxDeclaration from '../../utils/isStandardSyntaxDeclaration.mjs';
+import { lengthUnits } from '../../reference/units.mjs';
+import { mayIncludeRegexes } from '../../utils/regexes.mjs';
+import optionsMatches from '../../utils/optionsMatches.mjs';
+import report from '../../utils/report.mjs';
+import ruleMessages from '../../utils/ruleMessages.mjs';
+import setAtRuleParams from '../../utils/setAtRuleParams.mjs';
+import setDeclarationValue from '../../utils/setDeclarationValue.mjs';
+import validateOptions from '../../utils/validateOptions.mjs';
+
+const ruleName = 'length-zero-no-unit';
+
+const messages = ruleMessages(ruleName, {
+	rejected: 'Unexpected unit',
+});
+
+const meta = {
+	url: 'https://stylelint.io/user-guide/rules/length-zero-no-unit',
+	fixable: true,
+};
+
+/** @import { AtRule, Declaration } from 'postcss' */
+/** @import { ParsedValue, Node } from 'postcss-value-parser' */
+
+/** @type {import('stylelint').CoreRules[ruleName]} */
+const rule = (primary, secondaryOptions) => {
+	return (root, result) => {
+		const validOptions = validateOptions(
+			result,
+			ruleName,
+			{
+				actual: primary,
+			},
+			{
+				actual: secondaryOptions,
+				possible: {
+					ignore: ['custom-properties'],
+					ignoreFunctions: [isString, isRegExp],
+					ignorePreludeOfAtRules: [isString, isRegExp],
+				},
+				optional: true,
+			},
+		);
+
+		if (!validOptions) return;
+
+		/**
+		 * @param {AtRule | Declaration} node
+		 * @param {number} nodeIndex
+		 * @param {Node} valueNode
+		 * @param {ParsedValue} parsedValue
+		 */
+		function check(node, nodeIndex, valueNode, parsedValue) {
+			const { value, sourceIndex } = valueNode;
+
+			if (isMathFunction(valueNode)) return false;
+
+			if (isFunction(valueNode) && optionsMatches(secondaryOptions, 'ignoreFunctions', value))
+				return false;
+
+			if (!isWord(valueNode)) return;
+
+			const dimension = valueParser.unit(value);
+			const decompositionFailed = dimension === false;
+
+			if (decompositionFailed) return;
+
+			const { number, unit } = dimension;
+
+			if (!isZero(number)) return;
+
+			if (isNumber(unit)) return;
+
+			if (!isLength(unit)) return;
+
+			if (isFraction(unit)) return;
+
+			const fix = () => {
+				valueNode.value = number.startsWith('.') ? number.slice(1) : number;
+
+				switch (node.type) {
+					case 'atrule':
+						setAtRuleParams(node, parsedValue.toString());
+						break;
+					case 'decl':
+						setDeclarationValue(node, parsedValue.toString());
+						break;
+				}
+			};
+
+			const index = nodeIndex + sourceIndex + number.length;
+			const endIndex = index + unit.length;
+
+			report({
+				index,
+				endIndex,
+				message: messages.rejected,
+				messageArgs: [],
+				node,
+				result,
+				ruleName,
+				fix: {
+					apply: fix,
+					node,
+				},
+			});
+		}
+
+		/** @param {AtRule} node */
+		function checkAtRule(node) {
+			if (!mayIncludeRegexes.zeroLength.test(node.params)) return;
+
+			if (!isStandardSyntaxAtRule(node)) return;
+
+			if (optionsMatches(secondaryOptions, 'ignorePreludeOfAtRules', node.name)) return;
+
+			const index = atRuleParamIndex(node);
+			const parsedValue = valueParser(getAtRuleParams(node));
+
+			parsedValue.walk((valueNode) => check(node, index, valueNode, parsedValue));
+		}
+
+		/** @param {Declaration} node */
+		function checkDecl(node) {
+			const { prop, value } = node;
+
+			if (!mayIncludeRegexes.zeroLength.test(value)) return;
+
+			if (!isStandardSyntaxDeclaration(node)) return;
+
+			if (isLineHeight(prop)) return;
+
+			if (isFlex(prop)) return;
+
+			if (optionsMatches(secondaryOptions, 'ignore', 'custom-properties') && isCustomProperty(prop))
+				return;
+
+			const index = declarationValueIndex(node);
+			const parsedValue = valueParser(getDeclarationValue(node));
+
+			parsedValue.walk((valueNode, valueNodeIndex, valueNodes) => {
+				if (isLineHeightValue(node, valueNodes, valueNodeIndex)) return;
+
+				return check(node, index, valueNode, parsedValue);
+			});
+		}
+
+		root.walkAtRules(checkAtRule);
+		root.walkDecls(checkDecl);
+	};
+};
+
+/**
+ * @param {Declaration} decl
+ * @param {Node[]} nodes
+ * @param {number} index
+ */
+function isLineHeightValue({ prop }, nodes, index) {
+	const lastNode = nodes[index - 1];
+
+	return (
+		prop.toLowerCase() === 'font' && lastNode && lastNode.type === 'div' && lastNode.value === '/'
+	);
+}
+
+/**
+ * @param {string} prop
+ */
+function isLineHeight(prop) {
+	return prop.toLowerCase() === 'line-height';
+}
+
+/**
+ * @param {string} prop
+ */
+function isFlex(prop) {
+	return prop.toLowerCase() === 'flex';
+}
+
+/**
+ * @param {string} unit
+ */
+function isLength(unit) {
+	return lengthUnits.has(unit.toLowerCase());
+}
+
+/**
+ * @param {string} unit
+ */
+function isFraction(unit) {
+	return unit.toLowerCase() === 'fr';
+}
+
+/**
+ * @param {string} number
+ */
+function isZero(number) {
+	return Number.parseFloat(number) === 0;
+}
+
+/**
+ * @param {string} unit
+ */
+function isNumber(unit) {
+	return unit === '';
+}
+
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;
+export default rule;

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

@@ -0,0 +1,165 @@
+import valueParser from 'postcss-value-parser';
+
+import {
+	lightnessColorFunctions,
+	lightnessZeroToHundredColorFunctions,
+	lightnessZeroToOneColorFunctions,
+} from '../../reference/functions.mjs';
+import { declarationValueIndex } from '../../utils/nodeFieldIndices.mjs';
+import getDeclarationValue from '../../utils/getDeclarationValue.mjs';
+import isStandardSyntaxValue from '../../utils/isStandardSyntaxValue.mjs';
+import { mayIncludeRegexes } from '../../utils/regexes.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,
+};
+
+/** @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 (!mayIncludeRegexes.lightnessColorFunction.test(decl.value)) return;
+
+			const parsedValue = valueParser(getDeclarationValue(decl));
+
+			parsedValue.walk((node) => {
+				if (node.type !== 'function') return;
+
+				const functionName = node.value.toLowerCase();
+
+				if (!lightnessColorFunctions.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 (lightnessZeroToHundredColorFunctions.has(func)) {
+		return `${num}%`;
+	}
+
+	if (lightnessZeroToOneColorFunctions.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 (lightnessZeroToOneColorFunctions.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

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

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

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