@alexlit/lint-kit 183.4.0 → 183.6.0

package/packages/config-stylelint/node_modules/stylelint/lib/rules/alpha-value-notation/index.mjs

@@ -0,0 +1,207 @@
+import valueParser from 'postcss-value-parser';
+
+import { assert, isRegExp, isString } from '../../utils/validateTypes.mjs';
+import { declarationValueIndex } from '../../utils/nodeFieldIndices.mjs';
+import getDeclarationValue from '../../utils/getDeclarationValue.mjs';
+import isStandardSyntaxValue from '../../utils/isStandardSyntaxValue.mjs';
+import { isValueWord } from '../../utils/typeGuards.mjs';
+import optionsMatches from '../../utils/optionsMatches.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 = 'alpha-value-notation';
+
+const messages = ruleMessages(ruleName, {
+	expected: (unfixed, fixed) => `Expected "${unfixed}" to be "${fixed}"`,
+});
+
+const meta = {
+	url: 'https://stylelint.io/user-guide/rules/alpha-value-notation',
+	fixable: true,
+};
+
+const ALPHA_PROPS =
+	/^(?:opacity|shape-image-threshold|fill-opacity|flood-opacity|stop-opacity|stroke-opacity)$/i;
+const ALPHA_FUNCTION = /(?:color|hsla?|rgba?|hwb|lab|lch|oklab|oklch)\(/i;
+const ALPHA_FUNCTION_NAME = /^(?:color|hsla?|rgba?|hwb|lab|lch|oklab|oklch)$/i;
+const DIGIT = /\d/;
+
+/** @type {import('stylelint').CoreRules[ruleName]} */
+const rule = (primary, secondaryOptions) => {
+	return (root, result) => {
+		const validOptions = validateOptions(
+			result,
+			ruleName,
+			{
+				actual: primary,
+				possible: ['number', 'percentage'],
+			},
+			{
+				actual: secondaryOptions,
+				possible: {
+					exceptProperties: [isString, isRegExp],
+				},
+				optional: true,
+			},
+		);
+
+		if (!validOptions) return;
+
+		const optionFuncs = Object.freeze({
+			number: {
+				expFunc: isNumber,
+				fixFunc: asNumber,
+			},
+			percentage: {
+				expFunc: isPercentage,
+				fixFunc: asPercentage,
+			},
+		});
+
+		root.walkDecls((decl) => {
+			const declarationValue = getDeclarationValue(decl);
+			const isAlphaProp = ALPHA_PROPS.test(decl.prop);
+			const isAlpha = isAlphaProp || ALPHA_FUNCTION.test(declarationValue);
+
+			if (!isAlpha || !DIGIT.test(declarationValue)) return;
+
+			const parsedValue = valueParser(declarationValue);
+
+			parsedValue.walk((node) => {
+				const inVal = isAlphaProp && DIGIT.test(node.value);
+				const inFn = node.type === 'function' && ALPHA_FUNCTION_NAME.test(node.value);
+				const alpha = inVal ? findAlphaInValue(node) : inFn ? findAlphaInFunction(node) : undefined;
+
+				if (!alpha) return;
+
+				const { value } = alpha;
+
+				if (!isStandardSyntaxValue(value)) return;
+
+				if (!isNumber(value) && !isPercentage(value)) return;
+
+				/** @type {'number' | 'percentage'} */
+				let expectation = primary;
+
+				if (optionsMatches(secondaryOptions, 'exceptProperties', decl.prop)) {
+					if (expectation === 'number') {
+						expectation = 'percentage';
+					} else if (expectation === 'percentage') {
+						expectation = 'number';
+					}
+				}
+
+				if (optionFuncs[expectation].expFunc(value)) return;
+
+				const fixed = optionFuncs[expectation].fixFunc(value);
+				const unfixed = value;
+				const index = declarationValueIndex(decl) + alpha.sourceIndex;
+				const endIndex = index + alpha.value.length;
+				const fix = () => {
+					alpha.value = fixed;
+					setDeclarationValue(decl, parsedValue.toString());
+				};
+
+				report({
+					message: messages.expected,
+					messageArgs: [unfixed, fixed],
+					node: decl,
+					index,
+					endIndex,
+					result,
+					ruleName,
+					fix: {
+						apply: fix,
+						node: decl,
+					},
+				});
+			});
+		});
+	};
+};
+
+/**
+ * @param {string} value
+ * @returns {string}
+ */
+function asPercentage(value) {
+	const number = Number(value);
+
+	return `${Number((number * 100).toPrecision(3))}%`;
+}
+
+/**
+ * @param {string} value
+ * @returns {string}
+ */
+function asNumber(value) {
+	const dimension = valueParser.unit(value);
+
+	assert(dimension);
+
+	const number = Number(dimension.number);
+
+	return Number((number / 100).toPrecision(3)).toString();
+}
+
+/**
+ * @template {import('postcss-value-parser').Node} T
+ * @param {T} node
+ * @returns {T | undefined}
+ */
+function findAlphaInValue(node) {
+	return node.type === 'word' || node.type === 'function' ? node : undefined;
+}
+
+/**
+ * @param {import('postcss-value-parser').FunctionNode} node
+ * @returns {import('postcss-value-parser').Node | undefined}
+ */
+function findAlphaInFunction(node) {
+	const legacySyntax = node.nodes.some(({ type, value }) => type === 'div' && value === ',');
+
+	if (legacySyntax) {
+		const args = node.nodes.filter(({ type }) => type === 'word' || type === 'function');
+
+		if (args.length === 4) return args[3];
+
+		return undefined;
+	}
+
+	const slashNodeIndex = node.nodes.findIndex(({ type, value }) => type === 'div' && value === '/');
+
+	if (slashNodeIndex !== -1) {
+		const nodesAfterSlash = node.nodes.slice(slashNodeIndex + 1, node.nodes.length);
+
+		return nodesAfterSlash.find(isValueWord);
+	}
+
+	return undefined;
+}
+
+/**
+ * @param {string} value
+ * @returns {boolean}
+ */
+function isPercentage(value) {
+	const dimension = valueParser.unit(value);
+
+	return dimension && dimension.unit === '%';
+}
+
+/**
+ * @param {string} value
+ * @returns {boolean}
+ */
+function isNumber(value) {
+	const dimension = valueParser.unit(value);
+
+	return dimension && dimension.unit === '';
+}
+
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;
+export default rule;

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

@@ -0,0 +1,88 @@
+import valueParser from 'postcss-value-parser';
+
+import { isRegExp, isString } from '../../utils/validateTypes.mjs';
+import getDeclarationValue from '../../utils/getDeclarationValue.mjs';
+import isStandardSyntaxValue from '../../utils/isStandardSyntaxValue.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 = 'annotation-no-unknown';
+
+const messages = ruleMessages(ruleName, {
+	rejected: (annotation) => `Unexpected unknown annotation "${annotation}"`,
+});
+
+const meta = {
+	url: 'https://stylelint.io/user-guide/rules/annotation-no-unknown',
+};
+
+/** @type {import('stylelint').CoreRules[ruleName]} */
+const rule = (primary, secondaryOptions) => {
+	return (root, result) => {
+		const validOptions = validateOptions(
+			result,
+			ruleName,
+			{ actual: primary },
+			{
+				actual: secondaryOptions,
+				possible: {
+					ignoreAnnotations: [isString, isRegExp],
+				},
+				optional: true,
+			},
+		);
+
+		if (!validOptions) {
+			return;
+		}
+
+		root.walkDecls(checkStatement);
+
+		/**
+		 * @param {import('postcss').Declaration} decl
+		 */
+		function checkStatement(decl) {
+			if (!isStandardSyntaxValue(decl.value)) return;
+
+			if (decl.important) return;
+
+			if (!decl.value.includes('!')) return;
+
+			const parsedValue = valueParser(getDeclarationValue(decl));
+
+			parsedValue.walk((node) => {
+				if (!isAnnotation(node)) return;
+
+				const value = node.value;
+				const tokenValue = value.slice(1);
+
+				if (optionsMatches(secondaryOptions, 'ignoreAnnotations', tokenValue)) {
+					return;
+				}
+
+				report({
+					message: messages.rejected,
+					messageArgs: [value],
+					node: decl,
+					result,
+					ruleName,
+					word: value,
+				});
+			});
+		}
+
+		/**
+		 * @param {valueParser.Node} node
+		 */
+		function isAnnotation(node) {
+			return node.type === 'word' && node.value.startsWith('!');
+		}
+	};
+};
+
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;
+export default rule;

package/packages/config-stylelint/node_modules/stylelint/lib/rules/at-rule-allowed-list/index.mjs

@@ -0,0 +1,62 @@
+import { isRegExp, isString } from '../../utils/validateTypes.mjs';
+import isStandardSyntaxAtRule from '../../utils/isStandardSyntaxAtRule.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 = 'at-rule-allowed-list';
+
+const messages = ruleMessages(ruleName, {
+	rejected: (atRule) => `Unexpected at-rule "${atRule}"`,
+});
+
+const meta = {
+	url: 'https://stylelint.io/user-guide/rules/at-rule-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;
+		}
+
+		const primaryValues = [primary].flat();
+
+		root.walkAtRules((atRule) => {
+			const name = atRule.name;
+
+			if (!isStandardSyntaxAtRule(atRule)) {
+				return;
+			}
+
+			if (matchesStringOrRegExp(name, primaryValues)) {
+				return;
+			}
+
+			const atName = `@${name}`;
+
+			report({
+				message: messages.rejected,
+				messageArgs: [atName],
+				node: atRule,
+				result,
+				ruleName,
+				word: atName,
+			});
+		});
+	};
+};
+
+rule.primaryOptionArray = true;
+
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;
+export default rule;

package/packages/config-stylelint/node_modules/stylelint/lib/rules/at-rule-descriptor-no-unknown/index.mjs

@@ -0,0 +1,108 @@
+import { fontFeatureValueTypes, pageMarginAtKeywords } from '../../reference/atKeywords.mjs';
+import { marginContextProperties, pageContextProperties } from '../../reference/properties.mjs';
+import { atRuleRegexes } from '../../utils/regexes.mjs';
+import { isAtRule } from '../../utils/typeGuards.mjs';
+import isStandardSyntaxAtRule from '../../utils/isStandardSyntaxAtRule.mjs';
+import isStandardSyntaxDeclaration from '../../utils/isStandardSyntaxDeclaration.mjs';
+import report from '../../utils/report.mjs';
+import ruleMessages from '../../utils/ruleMessages.mjs';
+import validateOptions from '../../utils/validateOptions.mjs';
+
+const ruleName = 'at-rule-descriptor-no-unknown';
+
+const messages = ruleMessages(ruleName, {
+	rejected: (atRule, descriptor) =>
+		`Unexpected unknown descriptor "${descriptor}" for at-rule "${atRule}"`,
+});
+
+const meta = {
+	url: 'https://stylelint.io/user-guide/rules/at-rule-descriptor-no-unknown',
+};
+
+/** @type {import('stylelint').CoreRules[ruleName]} */
+const rule = (primary) => {
+	return (root, result) => {
+		const validOptions = validateOptions(result, ruleName, { actual: primary });
+
+		if (!validOptions) {
+			return;
+		}
+
+		const lexer = /** @type {import('css-tree').Lexer} */ (result.stylelint.lexer);
+
+		root.walkAtRules(atRuleRegexes.unsupportedNestingNames, (atRule) => {
+			if (!isStandardSyntaxAtRule(atRule)) return;
+
+			atRule.walkDecls((decl) => {
+				if (!isStandardSyntaxDeclaration(decl)) return;
+
+				const { prop, value, parent } = decl;
+
+				if (isPageContextPropertyInPageAtRule(atRule, prop)) return;
+
+				if (parent && isAtRule(parent)) {
+					if (isMarginContextPropertyInMarginAtRule(atRule, prop, parent)) return;
+
+					if (isFontFeatureValueType(atRule, parent)) return;
+				}
+
+				const { error } = lexer.matchAtruleDescriptor(atRule.name, prop, value);
+
+				if (!error) return;
+
+				if (error.name !== 'SyntaxReferenceError') return;
+
+				if (!error.message.startsWith('Unknown at-rule descriptor')) return;
+
+				const atName = `@${atRule.name}`;
+
+				report({
+					message: messages.rejected,
+					messageArgs: [atName, prop],
+					node: decl,
+					index: 0,
+					endIndex: prop.length,
+					ruleName,
+					result,
+				});
+			});
+		});
+	};
+};
+
+/**
+ * @param {import('postcss').AtRule} atRule
+ * @param {import('postcss').AtRule} parent
+ * @returns {boolean}
+ */
+function isFontFeatureValueType(atRule, parent) {
+	if (atRule.name.toLowerCase() !== 'font-feature-values') return false;
+
+	return fontFeatureValueTypes.has(parent.name.toLowerCase());
+}
+
+/**
+ * @param {import('postcss').AtRule} atRule
+ * @param {string} prop
+ * @param {import('postcss').AtRule} parent
+ */
+function isMarginContextPropertyInMarginAtRule(atRule, prop, parent) {
+	return (
+		atRule.name.toLowerCase() === 'page' &&
+		pageMarginAtKeywords.has(parent.name.toLowerCase()) &&
+		marginContextProperties.has(prop)
+	);
+}
+
+/**
+ * @param {import('postcss').AtRule} atRule
+ * @param {string} prop
+ */
+function isPageContextPropertyInPageAtRule(atRule, prop) {
+	return atRule.name.toLowerCase() === 'page' && pageContextProperties.has(prop);
+}
+
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;
+export default rule;

package/packages/config-stylelint/node_modules/stylelint/lib/rules/at-rule-descriptor-value-no-unknown/index.mjs

@@ -0,0 +1,64 @@
+import { atRuleRegexes } from '../../utils/regexes.mjs';
+import { declarationValueIndex } from '../../utils/nodeFieldIndices.mjs';
+import isStandardSyntaxAtRule from '../../utils/isStandardSyntaxAtRule.mjs';
+import isStandardSyntaxDeclaration from '../../utils/isStandardSyntaxDeclaration.mjs';
+import report from '../../utils/report.mjs';
+import ruleMessages from '../../utils/ruleMessages.mjs';
+import validateOptions from '../../utils/validateOptions.mjs';
+
+const ruleName = 'at-rule-descriptor-value-no-unknown';
+
+const messages = ruleMessages(ruleName, {
+	rejected: (descriptor, value) =>
+		`Unexpected unknown value "${value}" for descriptor "${descriptor}"`,
+});
+
+const meta = {
+	url: 'https://stylelint.io/user-guide/rules/at-rule-descriptor-value-no-unknown',
+};
+
+/** @type {import('stylelint').CoreRules[ruleName]} */
+const rule = (primary) => {
+	return (root, result) => {
+		const validOptions = validateOptions(result, ruleName, { actual: primary });
+
+		if (!validOptions) {
+			return;
+		}
+
+		const lexer = /** @type {import('css-tree').Lexer} */ (result.stylelint.lexer);
+
+		root.walkAtRules(atRuleRegexes.unsupportedNestingNames, (atRule) => {
+			if (!isStandardSyntaxAtRule(atRule)) return;
+
+			atRule.walkDecls((decl) => {
+				if (!isStandardSyntaxDeclaration(decl)) return;
+
+				const { prop, value } = decl;
+				const { error } = lexer.matchAtruleDescriptor(atRule.name, prop, value);
+
+				if (!error) return;
+
+				if (error.name !== 'SyntaxMatchError') return;
+
+				const index = declarationValueIndex(decl);
+				const endIndex = index + value.length;
+
+				report({
+					message: messages.rejected,
+					messageArgs: [prop, value],
+					node: decl,
+					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/at-rule-disallowed-list/index.mjs

@@ -0,0 +1,62 @@
+import { isRegExp, isString } from '../../utils/validateTypes.mjs';
+import isStandardSyntaxAtRule from '../../utils/isStandardSyntaxAtRule.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 = 'at-rule-disallowed-list';
+
+const messages = ruleMessages(ruleName, {
+	rejected: (atRule) => `Unexpected at-rule "${atRule}"`,
+});
+
+const meta = {
+	url: 'https://stylelint.io/user-guide/rules/at-rule-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;
+		}
+
+		const primaryValues = [primary].flat();
+
+		root.walkAtRules((atRule) => {
+			const name = atRule.name;
+
+			if (!isStandardSyntaxAtRule(atRule)) {
+				return;
+			}
+
+			if (!matchesStringOrRegExp(name, primaryValues)) {
+				return;
+			}
+
+			const atName = `@${atRule.name}`;
+
+			report({
+				message: messages.rejected,
+				messageArgs: [atName],
+				node: atRule,
+				result,
+				ruleName,
+				word: atName,
+			});
+		});
+	};
+};
+
+rule.primaryOptionArray = true;
+
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;
+export default rule;