@alexlit/lint-kit 182.2.0 → 182.3.0

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

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

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

@@ -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;