@alexlit/lint-kit 183.6.0 → 183.7.0

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

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

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

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

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

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