@alexlit/lint-kit 173.2.2 → 173.3.0

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

@@ -1,191 +0,0 @@
-import { assertString } from '../../utils/validateTypes.mjs';
-import { keyframeSelectorKeywords } from '../../reference/keywords.mjs';
-
-import { atRuleRegexes } from '../../utils/regexes.mjs';
-import getRuleSelector from '../../utils/getRuleSelector.mjs';
-import parseSelector from '../../utils/parseSelector.mjs';
-import parser from 'postcss-selector-parser';
-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_SELECTORS = new Set(['0%', '100%']);
-
-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) => PERCENTAGE_SELECTORS.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 PERCENTAGE_SELECTORS.has(selector);
-				},
-				fixFunc: (selector) => getFromMap(KEYWORD_TO_PERCENTAGE, selector),
-			},
-		};
-
-		const { expFunc, fixFunc } = optionFuncs[primary];
-
-		root.walkAtRules(atRuleRegexes.keyframesName, (atRuleKeyframes) => {
-			const selectorsInBlock =
-				primary === 'percentage-unless-within-keyword-only-block'
-					? getSelectorsInBlock(atRuleKeyframes)
-					: [];
-
-			atRuleKeyframes.walkRules((keyframeRule) => {
-				const selectors = parseSelector(getRuleSelector(keyframeRule), 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) &&
-		!PERCENTAGE_SELECTORS.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, functionRegexes } 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 (!functionRegexes.layer.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;

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

@@ -1,216 +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 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 (!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 } = node;
-
-			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;