@alexlit/lint-kit 183.4.0 → 183.6.0

package/packages/config-stylelint/node_modules/stylelint/lib/rules/function-disallowed-list/index.mjs

@@ -0,0 +1,73 @@
+import valueParser from 'postcss-value-parser';
+
+import { isRegExp, isString } from '../../utils/validateTypes.mjs';
+import { declarationValueIndex } from '../../utils/nodeFieldIndices.mjs';
+import isStandardSyntaxFunction from '../../utils/isStandardSyntaxFunction.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 = 'function-disallowed-list';
+
+const messages = ruleMessages(ruleName, {
+	rejected: (name) => `Unexpected function "${name}"`,
+});
+
+const meta = {
+	url: 'https://stylelint.io/user-guide/rules/function-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;
+		}
+
+		root.walkDecls((decl) => {
+			if (!decl.value.includes('(')) return;
+
+			valueParser(decl.value).walk((node) => {
+				const { type, sourceIndex, value: funcName } = node;
+
+				if (type !== 'function') {
+					return;
+				}
+
+				if (!isStandardSyntaxFunction(node)) {
+					return;
+				}
+
+				if (!matchesStringOrRegExp(funcName, primary)) {
+					return;
+				}
+
+				const index = declarationValueIndex(decl) + sourceIndex;
+				const endIndex = index + funcName.length;
+
+				report({
+					message: messages.rejected,
+					messageArgs: [funcName],
+					node: decl,
+					index,
+					endIndex,
+					result,
+					ruleName,
+				});
+			});
+		});
+	};
+};
+
+rule.primaryOptionArray = true;
+
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;
+export default rule;

package/packages/config-stylelint/node_modules/stylelint/lib/rules/function-linear-gradient-no-nonstandard-direction/index.mjs

@@ -0,0 +1,145 @@
+import valueParser from 'postcss-value-parser';
+
+import { declarationValueIndex } from '../../utils/nodeFieldIndices.mjs';
+import functionArgumentsSearch from '../../utils/functionArgumentsSearch.mjs';
+import isStandardSyntaxValue from '../../utils/isStandardSyntaxValue.mjs';
+import report from '../../utils/report.mjs';
+import ruleMessages from '../../utils/ruleMessages.mjs';
+import validateOptions from '../../utils/validateOptions.mjs';
+import vendor from '../../utils/vendor.mjs';
+
+const ruleName = 'function-linear-gradient-no-nonstandard-direction';
+
+const messages = ruleMessages(ruleName, {
+	rejected: 'Unexpected nonstandard direction',
+});
+
+const meta = {
+	url: 'https://stylelint.io/user-guide/rules/function-linear-gradient-no-nonstandard-direction',
+};
+
+const LINEAR_GRADIENT_FUNCTION = '(?:-webkit-|-moz-|-o-|-ms-)?linear-gradient';
+const LINEAR_GRADIENT_FUNCTION_CALL = new RegExp(`${LINEAR_GRADIENT_FUNCTION}\\(`, 'i');
+const LINEAR_GRADIENT_FUNCTION_NAME = new RegExp(`^${LINEAR_GRADIENT_FUNCTION}$`, 'i');
+
+const DIRECTION = /top|left|bottom|right/i;
+const DIRECTION_WITH_TO = new RegExp(`^to (${DIRECTION.source})(?: (${DIRECTION.source}))?$`, 'i');
+const DIRECTION_WITHOUT_TO = new RegExp(`^(${DIRECTION.source})(?: (${DIRECTION.source}))?$`, 'i');
+
+const DIGIT = /[\d.]/;
+const ANGLE = /^[\d.]+(?:deg|grad|rad|turn)$/;
+const IN_KEYWORD = /\bin\b/i;
+
+/**
+ * @param {string} source
+ * @param {boolean} withToPrefix
+ */
+function isStandardDirection(source, withToPrefix) {
+	const regexp = withToPrefix ? DIRECTION_WITH_TO : DIRECTION_WITHOUT_TO;
+
+	const matches = source.match(regexp);
+
+	if (!matches) {
+		return false;
+	}
+
+	if (matches.length === 2) {
+		return true;
+	}
+
+	// Cannot repeat side-or-corner, e.g. "to top top"
+	if (matches.length === 3 && matches[1] !== matches[2]) {
+		return true;
+	}
+
+	return false;
+}
+
+/** @type {import('stylelint').CoreRules[ruleName]} */
+const rule = (primary) => {
+	return (root, result) => {
+		const validOptions = validateOptions(result, ruleName, { actual: primary });
+
+		if (!validOptions) {
+			return;
+		}
+
+		root.walkDecls((decl) => {
+			if (!LINEAR_GRADIENT_FUNCTION_CALL.test(decl.value)) return;
+
+			valueParser(decl.value).walk((valueNode) => {
+				if (valueNode.type !== 'function') {
+					return;
+				}
+
+				functionArgumentsSearch(
+					valueParser.stringify(valueNode).toLowerCase(),
+					LINEAR_GRADIENT_FUNCTION_NAME,
+					(expression, expressionIndex) => {
+						const args = expression.split(',');
+						const firstArg = (args[0] || '').trim();
+
+						// If the first arg is not standard, return early
+						if (!isStandardSyntaxValue(firstArg)) {
+							return;
+						}
+
+						// Skip direction validation for CSS variables
+						if (firstArg.startsWith('var(')) {
+							return;
+						}
+
+						// Ignore gradients with modern syntax that have color space interpolation arguments
+						if (IN_KEYWORD.test(firstArg)) {
+							return;
+						}
+
+						// If the first character is a number, we can assume the user intends an angle
+						if (DIGIT.test(firstArg.charAt(0))) {
+							if (ANGLE.test(firstArg)) {
+								return;
+							}
+
+							complain();
+
+							return;
+						}
+
+						// The first argument may not be a direction: it may be an angle,
+						// or a color stop (in which case user gets default direction, "to bottom")
+						// cf. https://drafts.csswg.org/css-images-3/#linear-gradient-syntax
+						if (!DIRECTION.test(firstArg)) {
+							return;
+						}
+
+						const withToPrefix = !vendor.prefix(valueNode.value);
+
+						if (!isStandardDirection(firstArg, withToPrefix)) {
+							complain();
+						}
+
+						function complain() {
+							const index = declarationValueIndex(decl) + valueNode.sourceIndex + expressionIndex;
+							const endIndex = index + (args[0] || '').trimEnd().length;
+
+							report({
+								message: messages.rejected,
+								messageArgs: [],
+								node: decl,
+								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/function-name-case/index.mjs

@@ -0,0 +1,120 @@
+import valueParser from 'postcss-value-parser';
+
+import { isRegExp, isString } from '../../utils/validateTypes.mjs';
+import { camelCaseFunctions } from '../../reference/functions.mjs';
+import { declarationValueIndex } from '../../utils/nodeFieldIndices.mjs';
+import getDeclarationValue from '../../utils/getDeclarationValue.mjs';
+import isStandardSyntaxFunction from '../../utils/isStandardSyntaxFunction.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 setDeclarationValue from '../../utils/setDeclarationValue.mjs';
+import validateOptions from '../../utils/validateOptions.mjs';
+
+const ruleName = 'function-name-case';
+
+const messages = ruleMessages(ruleName, {
+	expected: (actual, expected) => `Expected "${actual}" to be "${expected}"`,
+});
+
+const meta = {
+	url: 'https://stylelint.io/user-guide/rules/function-name-case',
+	fixable: true,
+};
+
+const mapLowercaseFunctionNamesToCamelCase = new Map();
+
+for (const func of camelCaseFunctions) {
+	mapLowercaseFunctionNamesToCamelCase.set(func.toLowerCase(), func);
+}
+
+/** @type {import('stylelint').CoreRules[ruleName]} */
+const rule = (primary, secondaryOptions) => {
+	return (root, result) => {
+		const validOptions = validateOptions(
+			result,
+			ruleName,
+			{
+				actual: primary,
+				possible: ['lower', 'upper'],
+			},
+			{
+				actual: secondaryOptions,
+				possible: {
+					ignoreFunctions: [isString, isRegExp],
+				},
+				optional: true,
+			},
+		);
+
+		if (!validOptions) {
+			return;
+		}
+
+		root.walkDecls((decl) => {
+			if (!decl.value.includes('(')) return;
+
+			if (!isStandardSyntaxValue(decl.value)) return;
+
+			const parsed = valueParser(getDeclarationValue(decl));
+
+			parsed.walk((node) => {
+				if (node.type !== 'function' || !isStandardSyntaxFunction(node)) {
+					return;
+				}
+
+				const functionName = node.value;
+				const functionNameLowerCase = functionName.toLowerCase();
+
+				if (optionsMatches(secondaryOptions, 'ignoreFunctions', functionName)) {
+					return;
+				}
+
+				/** @type {string} */
+				let expectedFunctionName;
+
+				if (
+					primary === 'lower' &&
+					mapLowercaseFunctionNamesToCamelCase.has(functionNameLowerCase)
+				) {
+					expectedFunctionName = mapLowercaseFunctionNamesToCamelCase.get(functionNameLowerCase);
+				} else if (primary === 'lower') {
+					expectedFunctionName = functionNameLowerCase;
+				} else {
+					expectedFunctionName = functionName.toUpperCase();
+				}
+
+				if (functionName === expectedFunctionName) {
+					return;
+				}
+
+				const index = declarationValueIndex(decl) + node.sourceIndex;
+				const endIndex = index + functionName.length;
+				const fix = () => {
+					node.value = expectedFunctionName;
+					setDeclarationValue(decl, parsed.toString());
+				};
+
+				report({
+					message: messages.expected,
+					messageArgs: [functionName, expectedFunctionName],
+					node: decl,
+					index,
+					endIndex,
+					result,
+					ruleName,
+					fix: {
+						apply: fix,
+						node: decl,
+					},
+				});
+			});
+		});
+	};
+};
+
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;
+export default rule;

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

@@ -0,0 +1,83 @@
+import { isFunctionNode, parseListOfComponentValues, walk } from '@csstools/css-parser-algorithms';
+import functions from 'css-functions-list/index.json' with { type: 'json' };
+import { tokenize } from '@csstools/css-tokenizer';
+
+import { isRegExp, isString } from '../../utils/validateTypes.mjs';
+import { declarationValueIndex } from '../../utils/nodeFieldIndices.mjs';
+import isCustomFunction from '../../utils/isCustomFunction.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 = 'function-no-unknown';
+
+const messages = ruleMessages(ruleName, {
+	rejected: (name) => `Unexpected unknown function "${name}"`,
+});
+
+const meta = {
+	url: 'https://stylelint.io/user-guide/rules/function-no-unknown',
+};
+
+/** @type {import('stylelint').CoreRules[ruleName]} */
+const rule = (primary, secondaryOptions) => {
+	return (root, result) => {
+		const validOptions = validateOptions(
+			result,
+			ruleName,
+			{ actual: primary },
+			{
+				actual: secondaryOptions,
+				possible: {
+					ignoreFunctions: [isString, isRegExp],
+				},
+				optional: true,
+			},
+		);
+
+		if (!validOptions) {
+			return;
+		}
+
+		root.walkDecls((decl) => {
+			const { value } = decl;
+
+			if (!value.includes('(')) return;
+
+			if (!isStandardSyntaxValue(value)) return;
+
+			walk(parseListOfComponentValues(tokenize({ css: value })), ({ node }) => {
+				if (!isFunctionNode(node)) return;
+
+				const name = node.getName();
+
+				if (isCustomFunction(name)) return;
+
+				if (optionsMatches(secondaryOptions, 'ignoreFunctions', name)) return;
+
+				if (functions.includes(name.toLowerCase())) return;
+
+				const declIndex = declarationValueIndex(decl);
+				const index = declIndex + node.name[2];
+				const endIndex = declIndex + node.name[3];
+
+				report({
+					message: messages.rejected,
+					messageArgs: [name],
+					node: decl,
+					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/function-url-no-scheme-relative/index.mjs

@@ -0,0 +1,67 @@
+import { atRuleRegexes } from '../../utils/regexes.mjs';
+import functionArgumentsSearch from '../../utils/functionArgumentsSearch.mjs';
+import isStandardSyntaxUrl from '../../utils/isStandardSyntaxUrl.mjs';
+import report from '../../utils/report.mjs';
+import ruleMessages from '../../utils/ruleMessages.mjs';
+import validateOptions from '../../utils/validateOptions.mjs';
+
+const ruleName = 'function-url-no-scheme-relative';
+
+const messages = ruleMessages(ruleName, {
+	rejected: 'Unexpected scheme-relative url',
+});
+
+const meta = {
+	url: 'https://stylelint.io/user-guide/rules/function-url-no-scheme-relative',
+};
+
+/**
+ * Reports scheme-relative URLs.
+ *
+ * @param {import('postcss').Node} node - The PostCSS node containing the URL.
+ * @param {string} rawInput - The raw string to search (e.g., decl or params).
+ * @param {import('stylelint').PostcssResult} result - The Stylelint result object.
+ */
+const reportSchemeRelativeUrl = (node, rawInput, result) => {
+	functionArgumentsSearch(rawInput.toLowerCase(), 'url', (args, index) => {
+		const url = args.trim().replace(/^['"]+|['"]+$/g, '');
+
+		if (!isStandardSyntaxUrl(url) || !url.startsWith('//')) {
+			return;
+		}
+
+		report({
+			message: messages.rejected,
+			messageArgs: [],
+			node,
+			index,
+			endIndex: index + args.length,
+			result,
+			ruleName,
+		});
+	});
+};
+
+/** @type {import('stylelint').CoreRules[ruleName]} */
+const rule = (primary) => {
+	return (root, result) => {
+		const validOptions = validateOptions(result, ruleName, { actual: primary });
+
+		if (!validOptions) {
+			return;
+		}
+
+		root.walkDecls((decl) => {
+			reportSchemeRelativeUrl(decl, decl.toString(), result);
+		});
+
+		root.walkAtRules(atRuleRegexes.importName, (atRule) => {
+			reportSchemeRelativeUrl(atRule, atRule.toString(), result);
+		});
+	};
+};
+
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;
+export default rule;