@alexlit/lint-kit 173.2.2 → 173.3.0

package/packages/config-stylelint/node_modules/stylelint/lib/rules/no-invalid-position-at-import-rule/index.mjs

@@ -1,76 +0,0 @@
-import { isRegExp, isString } from '../../utils/validateTypes.mjs';
-import { isAtRule } from '../../utils/typeGuards.mjs';
-import isStandardSyntaxAtRule from '../../utils/isStandardSyntaxAtRule.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 = 'no-invalid-position-at-import-rule';
-
-const messages = ruleMessages(ruleName, {
-	rejected: 'Unexpected invalid position @import rule',
-});
-
-const meta = {
-	url: 'https://stylelint.io/user-guide/rules/no-invalid-position-at-import-rule',
-};
-
-/** @type {import('stylelint').CoreRules[ruleName]} */
-const rule = (primary, secondaryOptions) => {
-	return (root, result) => {
-		const validOptions = validateOptions(
-			result,
-			ruleName,
-			{ actual: primary },
-			{
-				actual: secondaryOptions,
-				possible: {
-					ignoreAtRules: [isString, isRegExp],
-				},
-				optional: true,
-			},
-		);
-
-		if (!validOptions) {
-			return;
-		}
-
-		let invalidPosition = false;
-
-		root.walk((node) => {
-			const nodeName = ('name' in node && node.name && node.name.toLowerCase()) || '';
-
-			if (
-				(isAtRule(node) &&
-					nodeName !== 'charset' &&
-					nodeName !== 'import' &&
-					nodeName !== 'layer' &&
-					!optionsMatches(secondaryOptions, 'ignoreAtRules', node.name) &&
-					isStandardSyntaxAtRule(node)) ||
-				(node.type === 'rule' && isStandardSyntaxRule(node))
-			) {
-				invalidPosition = true;
-
-				return;
-			}
-
-			if (isAtRule(node) && nodeName === 'import' && invalidPosition) {
-				report({
-					message: messages.rejected,
-					messageArgs: [],
-					node,
-					result,
-					ruleName,
-					word: node.toString(),
-				});
-			}
-		});
-	};
-};
-
-rule.ruleName = ruleName;
-rule.messages = messages;
-rule.meta = meta;
-export default rule;

package/packages/config-stylelint/node_modules/stylelint/lib/rules/no-invalid-position-declaration/index.mjs

@@ -1,86 +0,0 @@
-import { isAtRule, isRule } from '../../utils/typeGuards.mjs';
-import { isRegExp, isString } from '../../utils/validateTypes.mjs';
-import findNodeUpToRoot from '../../utils/findNodeUpToRoot.mjs';
-import isInDocument from '../../utils/isInDocument.mjs';
-import isStandardSyntaxDeclaration from '../../utils/isStandardSyntaxDeclaration.mjs';
-import { nestingSupportedAtKeywords } from '../../reference/atKeywords.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 = 'no-invalid-position-declaration';
-
-const messages = ruleMessages(ruleName, {
-	rejected: 'Unexpected invalid position declaration',
-});
-
-const meta = {
-	url: 'https://stylelint.io/user-guide/rules/no-invalid-position-declaration',
-};
-
-/** @type {import('stylelint').CoreRules[ruleName]} */
-const rule = (primary, secondaryOptions) => {
-	return (root, result) => {
-		const validOptions = validateOptions(
-			result,
-			ruleName,
-			{ actual: primary, possible: [true] },
-			{
-				actual: secondaryOptions,
-				possible: {
-					ignoreAtRules: [isString, isRegExp],
-				},
-				optional: true,
-			},
-		);
-
-		if (!validOptions) return;
-
-		/** @type {(node: import('postcss').Node) => boolean} */
-		const isIgnoredAtRule = (node) =>
-			isAtRule(node) && optionsMatches(secondaryOptions, 'ignoreAtRules', node.name);
-
-		root.walkDecls((decl) => {
-			if (isInDocument(decl, { inline: true })) return;
-
-			if (!isStandardSyntaxDeclaration(decl)) return;
-
-			const { parent } = decl;
-
-			if (!parent) return;
-
-			// Declarations are allowed in rules
-			if (isRule(parent)) return;
-
-			if (isAtRule(parent)) {
-				const atRuleName = parent.name.toLowerCase();
-
-				// Nesting-supported at-rules only allow declarations when nested inside a rule
-				if (nestingSupportedAtKeywords.has(atRuleName)) {
-					const parentRule = findNodeUpToRoot(
-						decl,
-						(node) => isRule(node) || isIgnoredAtRule(node),
-					);
-
-					if (parentRule) return;
-				} else {
-					return;
-				}
-			}
-
-			report({
-				message: messages.rejected,
-				messageArgs: [],
-				node: decl,
-				result,
-				ruleName,
-			});
-		});
-	};
-};
-
-rule.ruleName = ruleName;
-rule.messages = messages;
-rule.meta = meta;
-export default rule;

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

@@ -1,232 +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;
-		}
-
-		/**
-		 * @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,75 +0,0 @@
-import { isMediaFeature, isMediaQueryInvalid } from '@csstools/media-query-list-parser';
-import { atRuleParamIndex } from '../../utils/nodeFieldIndices.mjs';
-import { atRuleRegexes } from '../../utils/regexes.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(/^custom-media$/i, (atRule) => {
-			const customMediaQuery = parseCustomMediaQuery(atRule);
-
-			if (!customMediaQuery) return;
-
-			declaredCustomMediaQueries.add(customMediaQuery.getName());
-		});
-
-		root.walkAtRules(atRuleRegexes.mediaName, (atRule) => {
-			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 } 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(/^--/, ({ 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;