@alexlit/lint-kit 183.4.0 → 183.6.0

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

@@ -0,0 +1,236 @@
+import selectorParser from 'postcss-selector-parser';
+import valueParser from 'postcss-value-parser';
+
+const { isAttribute, isComment } = selectorParser;
+
+import {
+	atRuleAfterIndex,
+	atRuleAfterNameIndex,
+	atRuleBetweenIndex,
+	atRuleParamIndex,
+	declarationBetweenIndex,
+	declarationValueIndex,
+	ruleAfterIndex,
+	ruleBetweenIndex,
+} from '../../utils/nodeFieldIndices.mjs';
+
+import getAtRuleParams from '../../utils/getAtRuleParams.mjs';
+import getDeclarationValue from '../../utils/getDeclarationValue.mjs';
+import getRuleSelector from '../../utils/getRuleSelector.mjs';
+import report from '../../utils/report.mjs';
+import ruleMessages from '../../utils/ruleMessages.mjs';
+import validateOptions from '../../utils/validateOptions.mjs';
+
+const ruleName = 'no-irregular-whitespace';
+
+const messages = ruleMessages(ruleName, {
+	rejected: 'Unexpected irregular whitespace',
+});
+
+const meta = {
+	url: 'https://stylelint.io/user-guide/rules/no-irregular-whitespace',
+};
+
+const IRREGULAR_WHITESPACES = [
+	'\u000B', // Line Tabulation (\v) - <VT>
+	'\u000C', // Form Feed (\f) - <FF>
+	'\u00A0', // No-Break Space - <NBSP>
+	'\u0085', // Next Line
+	'\u1680', // Ogham Space Mark
+	'\u180E', // Mongolian Vowel Separator - <MVS>
+	'\uFEFF', // Zero Width No-Break Space - <BOM>
+	'\u2000', // En Quad
+	'\u2001', // Em Quad
+	'\u2002', // En Space - <ENSP>
+	'\u2003', // Em Space - <EMSP>
+	'\u2004', // Tree-Per-Em
+	'\u2005', // Four-Per-Em
+	'\u2006', // Six-Per-Em
+	'\u2007', // Figure Space
+	'\u2008', // Punctuation Space - <PUNCSP>
+	'\u2009', // Thin Space
+	'\u200A', // Hair Space
+	'\u200B', // Zero Width Space - <ZWSP>
+	'\u2028', // Line Separator
+	'\u2029', // Paragraph Separator
+	'\u202F', // Narrow No-Break Space
+	'\u205F', // Medium Mathematical Space
+	'\u3000', // Ideographic Space
+];
+
+const irregularWhitespacesChars = IRREGULAR_WHITESPACES.join('');
+
+const IRREGULAR_WHITESPACE_PATTERN = new RegExp(`[${irregularWhitespacesChars}]`);
+const IRREGULAR_WHITESPACES_PATTERN = new RegExp(`[${irregularWhitespacesChars}]+`, 'g');
+
+// Properties whose string values are intentionally ignored by validation logic
+const IGNORED_STRING_PROPS = ['grid', 'grid-template', 'grid-template-areas'];
+
+const IGNORED_STRING_PROPS_PATTERN = new RegExp(`^(?:${IGNORED_STRING_PROPS.join('|')})$`, 'i');
+
+/**
+ * @param {string} str
+ * @returns {Array<{index: number, length: number}>}
+ */
+const findIrregularWhitespace = (str) => {
+	return Array.from(str.matchAll(IRREGULAR_WHITESPACES_PATTERN)).map((match) => {
+		return {
+			index: match.index,
+			length: match[0].length,
+		};
+	});
+};
+
+/** @type {import('stylelint').CoreRules[ruleName]} */
+const rule = (primary) => {
+	return (root, result) => {
+		const validOptions = validateOptions(result, ruleName, { actual: primary });
+
+		if (!validOptions) {
+			return;
+		}
+
+		const rootString = root.source?.input.css;
+
+		if (!rootString || !IRREGULAR_WHITESPACE_PATTERN.test(rootString)) return;
+
+		/**
+		 * @template {import('postcss').Node} T
+		 * @param {T} node
+		 * @param {string | undefined} value
+		 * @param {(node: T) => number} getIndex
+		 */
+		const validate = (node, value, getIndex) => {
+			if (!value) return;
+
+			const issues = findIrregularWhitespace(value);
+
+			if (!issues.length) return;
+
+			const startIndex = getIndex(node);
+
+			issues.forEach(({ index, length }) => {
+				report({
+					ruleName,
+					result,
+					message: messages.rejected,
+					messageArgs: [],
+					node,
+					index: startIndex + index,
+					endIndex: startIndex + index + length,
+				});
+			});
+		};
+
+		root.walkAtRules((atRule) => {
+			validate(atRule, atRule.raws.before, zeroIndex);
+			validate(atRule, atRule.name, oneIndex);
+			validate(atRule, atRule.raws.afterName, atRuleAfterNameIndex);
+			validate(atRule, normalizeAtRule(getAtRuleParams(atRule)), atRuleParamIndex);
+			validate(atRule, atRule.raws.between, atRuleBetweenIndex);
+			validate(atRule, atRule.raws.after, atRuleAfterIndex);
+		});
+
+		root.walkRules((ruleNode) => {
+			validate(ruleNode, ruleNode.raws.before, zeroIndex);
+			validate(ruleNode, normalizeSelector(getRuleSelector(ruleNode)), zeroIndex);
+			validate(ruleNode, ruleNode.raws.between, ruleBetweenIndex);
+			validate(ruleNode, ruleNode.raws.after, ruleAfterIndex);
+		});
+
+		root.walkDecls((decl) => {
+			validate(decl, decl.raws.before, zeroIndex);
+			validate(decl, normalizeDecl(decl.prop), zeroIndex);
+			validate(decl, normalizeDecl(decl.raws.between), declarationBetweenIndex);
+			validate(decl, normalizeDecl(getDeclarationValue(decl), decl.prop), declarationValueIndex);
+		});
+	};
+};
+
+function zeroIndex() {
+	return 0;
+}
+
+function oneIndex() {
+	return 1;
+}
+
+/**
+ * @param {string} str
+ * @returns {string}
+ */
+function replaceIrregularWhitespaces(str) {
+	return str.replace(IRREGULAR_WHITESPACES_PATTERN, ' ');
+}
+
+/**
+ * @param {string} value
+ * @param {(node: import('postcss-value-parser').Node) => boolean} shouldNormalizeNode
+ * @returns {string}
+ */
+function normalizeValue(value, shouldNormalizeNode) {
+	if (!IRREGULAR_WHITESPACE_PATTERN.test(value)) {
+		return value;
+	}
+
+	const parsed = valueParser(value);
+
+	parsed.walk((node) => {
+		if (shouldNormalizeNode(node)) {
+			node.value = replaceIrregularWhitespaces(node.value);
+		}
+	});
+
+	return parsed.toString();
+}
+
+/**.
+ * @param {string} value
+ * @returns {string}
+ */
+function normalizeAtRule(value) {
+	return normalizeValue(value, (node) => node.type === 'string');
+}
+
+/**.
+ * @param {string|undefined} value
+ * @param {string=} prop
+ * @returns {string|undefined}
+ */
+function normalizeDecl(value, prop) {
+	if (!value) return;
+
+	const shouldIgnore = prop ? IGNORED_STRING_PROPS_PATTERN.test(prop.toLowerCase()) : false;
+
+	return normalizeValue(
+		value,
+		(node) => (node.type === 'string' && !shouldIgnore) || node.type === 'comment',
+	);
+}
+
+/**
+ * @param {string} selector
+ * @returns {string}
+ */
+function normalizeSelector(selector) {
+	if (!IRREGULAR_WHITESPACE_PATTERN.test(selector)) {
+		return selector;
+	}
+
+	const processor = selectorParser((selectors) => {
+		selectors.walk((node) => {
+			if (!node.value) return;
+
+			if (isAttribute(node) || isComment(node)) {
+				node.value = replaceIrregularWhitespaces(node.value);
+			}
+		});
+	});
+
+	return processor.processSync(selector);
+}
+
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;
+export default rule;

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

@@ -0,0 +1,71 @@
+import { animationNameKeywords } from '../../reference/keywords.mjs';
+import { atRuleRegexes } from '../../utils/regexes.mjs';
+import { declarationValueIndex } from '../../utils/nodeFieldIndices.mjs';
+import findAnimationName from '../../utils/findAnimationName.mjs';
+import report from '../../utils/report.mjs';
+import ruleMessages from '../../utils/ruleMessages.mjs';
+import validateOptions from '../../utils/validateOptions.mjs';
+
+const ruleName = 'no-unknown-animations';
+
+const messages = ruleMessages(ruleName, {
+	rejected: (animationName) => `Unexpected unknown animation name "${animationName}"`,
+});
+
+const meta = {
+	url: 'https://stylelint.io/user-guide/rules/no-unknown-animations',
+};
+
+/** @type {import('stylelint').CoreRules[ruleName]} */
+const rule = (primary) => {
+	return (root, result) => {
+		const validOptions = validateOptions(result, ruleName, { actual: primary });
+
+		if (!validOptions) {
+			return;
+		}
+
+		const declaredAnimations = new Set();
+
+		root.walkAtRules(atRuleRegexes.keyframesName, (atRule) => {
+			declaredAnimations.add(atRule.params);
+		});
+
+		root.walkDecls((decl) => {
+			if (decl.prop.toLowerCase() === 'animation' || decl.prop.toLowerCase() === 'animation-name') {
+				const animationNames = findAnimationName(decl.value);
+
+				if (animationNames.length === 0) {
+					return;
+				}
+
+				for (const animationNameNode of animationNames) {
+					if (animationNameKeywords.has(animationNameNode.value.toLowerCase())) {
+						continue;
+					}
+
+					if (declaredAnimations.has(animationNameNode.value)) {
+						continue;
+					}
+
+					const begin = declarationValueIndex(decl);
+
+					report({
+						result,
+						ruleName,
+						message: messages.rejected,
+						messageArgs: [animationNameNode.value],
+						node: decl,
+						index: begin + animationNameNode.sourceIndex,
+						endIndex: begin + animationNameNode.sourceEndIndex,
+					});
+				}
+			}
+		});
+	};
+};
+
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;
+export default rule;

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

@@ -0,0 +1,77 @@
+import { atRuleRegexes, mayIncludeRegexes } from '../../utils/regexes.mjs';
+import { isMediaFeature, isMediaQueryInvalid } from '@csstools/media-query-list-parser';
+import { atRuleParamIndex } from '../../utils/nodeFieldIndices.mjs';
+import isCustomMediaQuery from '../../utils/isCustomMediaQuery.mjs';
+import parseCustomMediaQuery from '../../utils/parseCustomMediaQuery.mjs';
+import parseMediaQuery from '../../utils/parseMediaQuery.mjs';
+import report from '../../utils/report.mjs';
+import ruleMessages from '../../utils/ruleMessages.mjs';
+import validateOptions from '../../utils/validateOptions.mjs';
+
+const ruleName = 'no-unknown-custom-media';
+
+const messages = ruleMessages(ruleName, {
+	rejected: (mediaName) => `Unexpected unknown custom media "${mediaName}"`,
+});
+
+const meta = {
+	url: 'https://stylelint.io/user-guide/rules/no-unknown-custom-media',
+};
+
+/** @type {import('stylelint').CoreRules[ruleName]} */
+const rule = (primary) => {
+	return (root, result) => {
+		const validOptions = validateOptions(result, ruleName, { actual: primary });
+
+		if (!validOptions) return;
+
+		const declaredCustomMediaQueries = new Set();
+
+		root.walkAtRules(atRuleRegexes.customMediaName, (atRule) => {
+			const customMediaQuery = parseCustomMediaQuery(atRule);
+
+			if (!customMediaQuery) return;
+
+			declaredCustomMediaQueries.add(customMediaQuery.getName());
+		});
+
+		root.walkAtRules(atRuleRegexes.mediaName, (atRule) => {
+			if (!mayIncludeRegexes.customProperty.test(atRule.params)) return;
+
+			const mediaQueryList = parseMediaQuery(atRule);
+
+			mediaQueryList.forEach((mediaQuery) => {
+				if (isMediaQueryInvalid(mediaQuery)) return;
+
+				mediaQuery.walk(({ node }) => {
+					if (!isMediaFeature(node)) return;
+
+					const [, name, start, end] = node.getNameToken();
+
+					if (!isCustomMediaQuery(name)) return;
+
+					if (declaredCustomMediaQueries.has(name)) return;
+
+					const baseIndex = atRuleParamIndex(atRule);
+					const index = baseIndex + start;
+					const endIndex = baseIndex + end + 1;
+
+					report({
+						message: messages.rejected,
+						messageArgs: [name],
+						node: atRule,
+						index,
+						endIndex,
+						result,
+						ruleName,
+					});
+				});
+			});
+		});
+	};
+};
+
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;
+export default rule;

package/packages/config-stylelint/node_modules/stylelint/lib/rules/no-unknown-custom-properties/index.mjs

@@ -0,0 +1,72 @@
+import valueParser from 'postcss-value-parser';
+
+import { atRuleRegexes, propertyRegexes } from '../../utils/regexes.mjs';
+import { declarationValueIndex } from '../../utils/nodeFieldIndices.mjs';
+import isVarFunction from '../../utils/isVarFunction.mjs';
+import report from '../../utils/report.mjs';
+import ruleMessages from '../../utils/ruleMessages.mjs';
+import validateOptions from '../../utils/validateOptions.mjs';
+
+const ruleName = 'no-unknown-custom-properties';
+
+const messages = ruleMessages(ruleName, {
+	rejected: (property) => `Unexpected unknown custom property "${property}"`,
+});
+
+const meta = {
+	url: 'https://stylelint.io/user-guide/rules/no-unknown-custom-properties',
+};
+
+/** @type {import('stylelint').CoreRules[ruleName]} */
+const rule = (primary) => {
+	return (root, result) => {
+		const validOptions = validateOptions(result, ruleName, { actual: primary });
+
+		if (!validOptions) return;
+
+		/** @type {Set<string>} */
+		const declaredCustomProps = new Set();
+
+		root.walkAtRules(atRuleRegexes.propertyName, ({ params }) => {
+			declaredCustomProps.add(params);
+		});
+
+		root.walkDecls(propertyRegexes.custom, ({ prop }) => {
+			declaredCustomProps.add(prop);
+		});
+
+		root.walkDecls((decl) => {
+			const { value } = decl;
+
+			const parsedValue = valueParser(value);
+
+			parsedValue.walk((node) => {
+				if (!isVarFunction(node)) return;
+
+				const [firstNode, secondNode] = node.nodes;
+
+				if (!firstNode || declaredCustomProps.has(firstNode.value)) return;
+
+				// Second node (div) indicates fallback exists in all cases
+				if (secondNode && secondNode.type === 'div') return;
+
+				const startIndex = declarationValueIndex(decl);
+
+				report({
+					result,
+					ruleName,
+					message: messages.rejected,
+					messageArgs: [firstNode.value],
+					node: decl,
+					index: startIndex + firstNode.sourceIndex,
+					endIndex: startIndex + firstNode.sourceEndIndex,
+				});
+			});
+		});
+	};
+};
+
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;
+export default rule;

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

@@ -0,0 +1,209 @@
+import { TokenType, tokenize } from '@csstools/css-tokenizer';
+import {
+	isFunctionNode,
+	isTokenNode,
+	parseListOfComponentValues,
+	walk,
+} from '@csstools/css-parser-algorithms';
+
+import { atRuleParamIndex, declarationValueIndex } from '../../utils/nodeFieldIndices.mjs';
+import { isRegExp, isString } from '../../utils/validateTypes.mjs';
+import getAtRuleParams from '../../utils/getAtRuleParams.mjs';
+import getDeclarationValue from '../../utils/getDeclarationValue.mjs';
+import isNonNegativeInteger from '../../utils/isNonNegativeInteger.mjs';
+import matchesStringOrRegExp from '../../utils/matchesStringOrRegExp.mjs';
+import optionsMatches from '../../utils/optionsMatches.mjs';
+import report from '../../utils/report.mjs';
+import ruleMessages from '../../utils/ruleMessages.mjs';
+import validateObjectWithProps from '../../utils/validateObjectWithProps.mjs';
+import validateOptions from '../../utils/validateOptions.mjs';
+
+const ruleName = 'number-max-precision';
+
+const messages = ruleMessages(ruleName, {
+	expected: (actual, expected) => `Expected "${actual}" to be "${expected}"`,
+});
+
+const meta = {
+	url: 'https://stylelint.io/user-guide/rules/number-max-precision',
+};
+
+/** @type {import('stylelint').CoreRules[ruleName]} */
+const rule = (primary, secondaryOptions) => {
+	return (root, result) => {
+		const validOptions = validateOptions(
+			result,
+			ruleName,
+			{
+				actual: primary,
+				possible: [isNonNegativeInteger],
+			},
+			{
+				optional: true,
+				actual: secondaryOptions,
+				possible: {
+					ignoreProperties: [isString, isRegExp],
+					ignoreUnits: [isString, isRegExp],
+					insideFunctions: [validateObjectWithProps(isNonNegativeInteger)],
+				},
+			},
+		);
+
+		if (!validOptions) {
+			return;
+		}
+
+		/** @type {Map<string, number>} */
+		const insideFunctions = new Map(Object.entries(secondaryOptions?.insideFunctions ?? {}));
+
+		root.walkAtRules((atRule) => {
+			if (atRule.name.toLowerCase() === 'import') {
+				return;
+			}
+
+			check(atRule, atRuleParamIndex, getAtRuleParams(atRule));
+		});
+
+		root.walkDecls((decl) => {
+			check(decl, declarationValueIndex, getDeclarationValue(decl));
+		});
+
+		/**
+		 * @template {import('postcss').AtRule | import('postcss').Declaration} T
+		 * @param {T} node
+		 * @param {(node: T) => number} getIndex
+		 * @param {string} value
+		 */
+		function check(node, getIndex, value) {
+			// Get out quickly if there are no periods
+			if (!value.includes('.')) return;
+
+			const prop = 'prop' in node ? node.prop : undefined;
+
+			if (optionsMatches(secondaryOptions, 'ignoreProperties', prop)) {
+				return;
+			}
+
+			const initialState = {
+				ignored: false,
+				precision: primary,
+			};
+
+			walk(
+				parseListOfComponentValues(tokenize({ css: value })),
+				({ node: mediaNode, state }) => {
+					if (!state) return;
+
+					if (state.ignored) return;
+
+					walker(node, getIndex, mediaNode, state);
+				},
+				initialState,
+			);
+		}
+
+		/**
+		 * @template {import('postcss').AtRule | import('postcss').Declaration} T
+		 * @param {T} node
+		 * @param {(node: T) => number} getIndex
+		 * @param {import('@csstools/css-parser-algorithms').ComponentValue} componentValue
+		 * @param {{ ignored: boolean, precision: number }} state
+		 */
+		function walker(node, getIndex, componentValue, state) {
+			if (isFunctionNode(componentValue)) {
+				const name = componentValue.getName().toLowerCase();
+
+				if (name === 'url') {
+					// postcss-value-parser exposed url token contents as "word" tokens, these were indistinguishable from numeric values in any other function.
+					// With @csstools/css-tokenizer this is no longer relevant, but we preserve the old condition to avoid breaking changes.
+					state.ignored = true;
+
+					return;
+				}
+
+				state.precision = precisionInsideFunction(name, state.precision);
+
+				return;
+			}
+
+			if (!isTokenNode(componentValue)) {
+				return;
+			}
+
+			const [tokenType, raw, startIndex, endIndex, parsedValue] = componentValue.value;
+
+			if (
+				tokenType !== TokenType.Number &&
+				tokenType !== TokenType.Dimension &&
+				tokenType !== TokenType.Percentage
+			) {
+				return;
+			}
+
+			let unitStringLength = 0;
+
+			if (tokenType === TokenType.Dimension) {
+				const unit = parsedValue.unit;
+
+				unitStringLength = unit.length;
+
+				if (optionsMatches(secondaryOptions, 'ignoreUnits', unit)) {
+					return;
+				}
+			} else if (tokenType === TokenType.Percentage) {
+				unitStringLength = 1;
+
+				if (optionsMatches(secondaryOptions, 'ignoreUnits', '%')) {
+					return;
+				}
+			}
+
+			const match = /\d*\.(\d+)/.exec(raw);
+
+			if (match == null || match[0] == null || match[1] == null) {
+				return;
+			}
+
+			if (match[1].length <= state.precision) {
+				return;
+			}
+
+			const nodeIndex = getIndex(node);
+
+			report({
+				result,
+				ruleName,
+				node,
+				index: nodeIndex + startIndex,
+				endIndex: nodeIndex + (endIndex + 1) - unitStringLength,
+				message: messages.expected,
+				messageArgs: [parsedValue.value, parsedValue.value.toFixed(state.precision)],
+			});
+		}
+
+		/**
+		 * @param {string} functionName
+		 * @param {number} currentPrecision
+		 * @returns {number}
+		 */
+		function precisionInsideFunction(functionName, currentPrecision) {
+			const precisionForFunction = insideFunctions.get(functionName);
+			const hasPrecision = typeof precisionForFunction !== 'undefined';
+
+			if (hasPrecision) return precisionForFunction;
+
+			for (const [name, precision] of insideFunctions) {
+				if (matchesStringOrRegExp(functionName, name)) {
+					return precision;
+				}
+			}
+
+			return currentPrecision;
+		}
+	};
+};
+
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;
+export default rule;