@alexlit/lint-kit 183.4.0 → 183.6.0

package/packages/config-stylelint/node_modules/stylelint/lib/rules/function-url-quotes/index.mjs

@@ -0,0 +1,230 @@
+import { isTokenURL, tokenize } from '@csstools/css-tokenizer';
+
+import { atRuleParamIndex, declarationValueIndex } from '../../utils/nodeFieldIndices.mjs';
+import functionArgumentsSearch from '../../utils/functionArgumentsSearch.mjs';
+import getAtRuleParams from '../../utils/getAtRuleParams.mjs';
+import getDeclarationValue from '../../utils/getDeclarationValue.mjs';
+import isStandardSyntaxDeclaration from '../../utils/isStandardSyntaxDeclaration.mjs';
+import isStandardSyntaxUrl from '../../utils/isStandardSyntaxUrl.mjs';
+import { mayIncludeRegexes } from '../../utils/regexes.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-url-quotes';
+
+const messages = ruleMessages(ruleName, {
+	expected: (functionName) => `Expected quotes around "${functionName}" function argument`,
+	rejected: (functionName) => `Unexpected quotes around "${functionName}" function argument`,
+});
+
+const meta = {
+	url: 'https://stylelint.io/user-guide/rules/function-url-quotes',
+	fixable: true,
+};
+
+/** @import { Problem, CoreRules } from 'stylelint' */
+/** @import { FunctionNode, ParsedValue } from 'postcss-value-parser' */
+/** @import { AtRule, Declaration } from 'postcss' */
+
+/** @type {CoreRules[ruleName]} */
+const rule = (primary, secondaryOptions) => {
+	return (root, result) => {
+		const validOptions = validateOptions(
+			result,
+			ruleName,
+			{
+				actual: primary,
+				possible: ['always', 'never'],
+			},
+			{
+				actual: secondaryOptions,
+				possible: {
+					except: ['empty'],
+				},
+				optional: true,
+			},
+		);
+
+		if (!validOptions) {
+			return;
+		}
+
+		const exceptEmpty = optionsMatches(secondaryOptions, 'except', 'empty');
+		const emptyArgumentPatterns = new Set(['', "''", '""']);
+
+		root.walkAtRules(checkAtRuleParams);
+		root.walkDecls(checkDeclParams);
+
+		/**
+		 * @param {Declaration|AtRule} node
+		 * @param {FunctionNode} fn
+		 * @param {keyof messages} messageType
+		 * @param {ParsedValue} parsedValue
+		 */
+		function getFix(node, fn, messageType, parsedValue) {
+			return () => {
+				switch (messageType) {
+					case 'expected':
+						addQuotes(fn);
+						break;
+					case 'rejected':
+						removeQuotes(fn);
+						break;
+				}
+
+				switch (node.type) {
+					case 'decl':
+						node.value = parsedValue.toString();
+						break;
+					case 'atrule':
+						node.params = parsedValue.toString();
+						break;
+				}
+			};
+		}
+
+		/**
+		 * @param {AtRule|Declaration} node
+		 * @param {string} source
+		 * @param {number} startIndex
+		 */
+		function complain(node, source, startIndex) {
+			functionArgumentsSearch(source, /^url$/i, (args, index, funcNode, parsedValue) => {
+				const object = checkArgs(args, startIndex + index);
+
+				if (object) {
+					const { messageType, ...rest } = object;
+					const message = messages[messageType];
+					const messageArgs = [funcNode.value.toLowerCase()];
+					const fix = getFix(node, funcNode, messageType, parsedValue);
+
+					report({
+						...rest,
+						node,
+						fix: { apply: fix, node },
+						message,
+						messageArgs,
+						result,
+						ruleName,
+					});
+				}
+			});
+		}
+
+		/** @param {Declaration} decl */
+		function checkDeclParams(decl) {
+			if (!mayIncludeRegexes.urlFunction.test(decl.value)) return;
+
+			if (!isStandardSyntaxDeclaration(decl)) return;
+
+			const value = getDeclarationValue(decl);
+			const startIndex = declarationValueIndex(decl);
+
+			complain(decl, value, startIndex);
+		}
+
+		/** @param {AtRule} atRule */
+		function checkAtRuleParams(atRule) {
+			const params = getAtRuleParams(atRule);
+			const startIndex = atRuleParamIndex(atRule);
+
+			complain(atRule, params, startIndex);
+		}
+
+		/** @param {FunctionNode} funcNode */
+		function addQuotes(funcNode) {
+			for (const argNode of funcNode.nodes) {
+				if (argNode.type === 'word') {
+					argNode.value = `"${argNode.value}"`;
+				}
+			}
+		}
+
+		/** @param {FunctionNode} funcNode */
+		function removeQuotes(funcNode) {
+			for (const argNode of funcNode.nodes) {
+				if (argNode.type === 'string') {
+					// NOTE: We can ignore this error because the test passes.
+					// @ts-expect-error -- TS2322: Type '"word"' is not assignable to type '"string"'.
+					argNode.type = 'word';
+				}
+			}
+		}
+
+		/**
+		 * Check if a URL requires quotes for valid CSS
+		 *
+		 * This function determines if a URL needs to be quoted when used in a CSS url() function.
+		 * It tokenizes the URL and checks if it would be parsed as a bad-url token, which indicates
+		 * that quotes are necessary for valid CSS.
+		 *
+		 * @param {string} url - The URL value, either quoted or unquoted
+		 * @returns {boolean} True if the URL requires quotes to be valid CSS, false otherwise
+		 */
+		function requiresQuotes(url) {
+			// Extract the URL content (remove quotes if present)
+			let urlContent = url;
+
+			const quote = url[0] ?? '';
+			const endQuoteIndex = url.lastIndexOf(quote);
+
+			if (endQuoteIndex > 0) {
+				urlContent = url.slice(1, endQuoteIndex);
+			}
+
+			const tokens = tokenize({ css: `url(${urlContent})` });
+
+			// there is always an EOF token, so we expect 2 tokens for a valid URL
+			if (tokens.length !== 2) return true;
+
+			const urlToken = tokens[0];
+
+			if (!isTokenURL(urlToken)) return true;
+
+			return false;
+		}
+
+		/**
+		 * @param {string} args
+		 * @param {number} index
+		 * @returns {Pick<Problem, 'index' | 'endIndex'> & { messageType: keyof messages } | undefined}
+		 */
+		function checkArgs(args, index) {
+			const leftTrimmedArgs = args.trimStart();
+
+			if (!isStandardSyntaxUrl(leftTrimmedArgs)) return;
+
+			let expectQuotes = primary === 'always';
+
+			if (exceptEmpty && emptyArgumentPatterns.has(args.trim())) {
+				expectQuotes = !expectQuotes;
+			}
+
+			const hasQuotes = leftTrimmedArgs.startsWith("'") || leftTrimmedArgs.startsWith('"');
+
+			// If quotes are required, don't complain about them being present
+			if (hasQuotes && requiresQuotes(leftTrimmedArgs)) return;
+
+			if (expectQuotes && hasQuotes) return;
+
+			if (!expectQuotes && !hasQuotes) return;
+
+			const messageType = expectQuotes ? 'expected' : 'rejected';
+			const reportIndex = index + args.length - leftTrimmedArgs.length;
+			const reportEndIndex = index + args.length;
+
+			return {
+				messageType,
+				index: reportIndex,
+				endIndex: reportEndIndex,
+			};
+		}
+	};
+};
+
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;
+export default rule;

package/packages/config-stylelint/node_modules/stylelint/lib/rules/function-url-scheme-allowed-list/index.mjs

@@ -0,0 +1,70 @@
+import { isRegExp, isString } from '../../utils/validateTypes.mjs';
+import functionArgumentsSearch from '../../utils/functionArgumentsSearch.mjs';
+import getSchemeFromUrl from '../../utils/getSchemeFromUrl.mjs';
+import isStandardSyntaxUrl from '../../utils/isStandardSyntaxUrl.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-url-scheme-allowed-list';
+
+const messages = ruleMessages(ruleName, {
+	rejected: (scheme) => `Unexpected URL scheme "${scheme}:"`,
+});
+
+const meta = {
+	url: 'https://stylelint.io/user-guide/rules/function-url-scheme-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;
+		}
+
+		root.walkDecls((decl) => {
+			functionArgumentsSearch(decl.toString().toLowerCase(), 'url', (args, index) => {
+				const unspacedUrlString = args.trim();
+
+				if (!isStandardSyntaxUrl(unspacedUrlString)) {
+					return;
+				}
+
+				const urlString = unspacedUrlString.replace(/^['"]+|['"]+$/g, '');
+				const scheme = getSchemeFromUrl(urlString);
+
+				if (scheme === null) {
+					return;
+				}
+
+				if (matchesStringOrRegExp(scheme, primary)) {
+					return;
+				}
+
+				report({
+					message: messages.rejected,
+					messageArgs: [scheme],
+					node: decl,
+					index,
+					endIndex: index + args.length,
+					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-url-scheme-disallowed-list/index.mjs

@@ -0,0 +1,70 @@
+import { isRegExp, isString } from '../../utils/validateTypes.mjs';
+import functionArgumentsSearch from '../../utils/functionArgumentsSearch.mjs';
+import getSchemeFromUrl from '../../utils/getSchemeFromUrl.mjs';
+import isStandardSyntaxUrl from '../../utils/isStandardSyntaxUrl.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-url-scheme-disallowed-list';
+
+const messages = ruleMessages(ruleName, {
+	rejected: (scheme) => `Unexpected URL scheme "${scheme}:"`,
+});
+
+const meta = {
+	url: 'https://stylelint.io/user-guide/rules/function-url-scheme-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) => {
+			functionArgumentsSearch(decl.toString().toLowerCase(), 'url', (args, index) => {
+				const unspacedUrlString = args.trim();
+
+				if (!isStandardSyntaxUrl(unspacedUrlString)) {
+					return;
+				}
+
+				const urlString = unspacedUrlString.replace(/^['"]+|['"]+$/g, '');
+				const scheme = getSchemeFromUrl(urlString);
+
+				if (scheme === null) {
+					return;
+				}
+
+				if (!matchesStringOrRegExp(scheme, primary)) {
+					return;
+				}
+
+				report({
+					message: messages.rejected,
+					messageArgs: [scheme],
+					node: decl,
+					index,
+					endIndex: index + args.length,
+					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/hue-degree-notation/index.mjs

@@ -0,0 +1,123 @@
+import valueParser from 'postcss-value-parser';
+
+import {
+	hueAsFirstComponentColorFunctions,
+	hueAsThirdComponentColorFunctions,
+	hueColorFunctions,
+} from '../../reference/functions.mjs';
+import { declarationValueIndex } from '../../utils/nodeFieldIndices.mjs';
+import getDeclarationValue from '../../utils/getDeclarationValue.mjs';
+import isStandardSyntaxValue from '../../utils/isStandardSyntaxValue.mjs';
+import { mayIncludeRegexes } from '../../utils/regexes.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 = 'hue-degree-notation';
+
+const messages = ruleMessages(ruleName, {
+	expected: (unfixed, fixed) => `Expected "${unfixed}" to be "${fixed}"`,
+});
+
+const meta = {
+	url: 'https://stylelint.io/user-guide/rules/hue-degree-notation',
+	fixable: true,
+};
+
+/** @type {import('stylelint').CoreRules[ruleName]} */
+const rule = (primary) => {
+	return (root, result) => {
+		const validOptions = validateOptions(result, ruleName, {
+			actual: primary,
+			possible: ['angle', 'number'],
+		});
+
+		if (!validOptions) return;
+
+		root.walkDecls((decl) => {
+			if (!mayIncludeRegexes.hueColorFunction.test(decl.value)) return;
+
+			const parsedValue = valueParser(getDeclarationValue(decl));
+
+			parsedValue.walk((node) => {
+				if (node.type !== 'function') return;
+
+				const functionName = node.value.toLowerCase();
+
+				if (!hueColorFunctions.has(functionName)) return;
+
+				const hue = findHue(node);
+
+				if (!hue) return;
+
+				const { value } = hue;
+
+				if (!isStandardSyntaxValue(value)) return;
+
+				const dimension = valueParser.unit(value);
+
+				if (!dimension) return;
+
+				const isDegree = dimension.unit.toLowerCase() === 'deg';
+				const isNumber = dimension.unit === '';
+
+				if (!isDegree && !isNumber) return;
+
+				if (primary === 'angle' && isDegree) return;
+
+				if (primary === 'number' && isNumber) return;
+
+				const fixed = primary === 'angle' ? `${dimension.number}deg` : dimension.number;
+				const unfixed = value;
+				const valueIndex = declarationValueIndex(decl);
+				const fix = () => {
+					hue.value = fixed;
+					setDeclarationValue(decl, parsedValue.toString());
+				};
+
+				report({
+					message: messages.expected,
+					messageArgs: [unfixed, fixed],
+					node: decl,
+					index: valueIndex + hue.sourceIndex,
+					endIndex: valueIndex + hue.sourceEndIndex,
+					result,
+					ruleName,
+					fix: {
+						apply: fix,
+						node: decl,
+					},
+				});
+			});
+		});
+	};
+};
+
+/**
+ * @param {import('postcss-value-parser').FunctionNode} node
+ */
+function findHue(node) {
+	const args = node.nodes.filter(({ type }) => type === 'word' || type === 'function');
+	const value = node.value.toLowerCase();
+
+	// If using relative color syntax, for instance `oklch(from red l c h)`, the
+	// channels start from the 2nd value.
+	const isRelativeColor = args[0]?.value.toLowerCase() === 'from';
+	const offset = isRelativeColor ? 2 : 0;
+
+	if (hueAsFirstComponentColorFunctions.has(value)) {
+		return args[0 + offset];
+	}
+
+	if (hueAsThirdComponentColorFunctions.has(value)) {
+		return args[2 + offset];
+	}
+
+	return undefined;
+}
+
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;
+export default rule;

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

@@ -0,0 +1,104 @@
+import valueParser from 'postcss-value-parser';
+
+import { atRuleParamIndex } from '../../utils/nodeFieldIndices.mjs';
+import { atRuleRegexes } from '../../utils/regexes.mjs';
+import getAtRuleParams from '../../utils/getAtRuleParams.mjs';
+import report from '../../utils/report.mjs';
+import ruleMessages from '../../utils/ruleMessages.mjs';
+import setAtRuleParams from '../../utils/setAtRuleParams.mjs';
+import validateOptions from '../../utils/validateOptions.mjs';
+
+const ruleName = 'import-notation';
+
+const messages = ruleMessages(ruleName, {
+	expected: (unfixed, fixed) => `Expected "${unfixed}" to be "${fixed}"`,
+});
+
+const meta = {
+	url: 'https://stylelint.io/user-guide/rules/import-notation',
+	fixable: true,
+};
+
+/** @typedef {import('postcss').AtRule} AtRule */
+
+/**
+ * @param {AtRule} node
+ * @param {string} fixed
+ * @param {number} index
+ */
+const fixer = (node, fixed, index) => () => {
+	const restAtRuleParams = node.params.slice(index);
+
+	setAtRuleParams(node, `${fixed}${restAtRuleParams}`);
+};
+
+/** @type {import('stylelint').CoreRules[ruleName]} */
+const rule = (primary) => {
+	return (root, result) => {
+		const validOptions = validateOptions(result, ruleName, {
+			actual: primary,
+			possible: ['string', 'url'],
+		});
+
+		if (!validOptions) return;
+
+		root.walkAtRules(atRuleRegexes.importName, checkAtRuleImportParams);
+
+		/** @param {AtRule} atRule */
+		function checkAtRuleImportParams(atRule) {
+			const params = getAtRuleParams(atRule);
+
+			if (primary === 'string' && !/url\(/i.test(params)) return;
+
+			if (primary === 'url' && /url\(/i.test(params)) return;
+
+			const index = atRuleParamIndex(atRule);
+			const parsed = valueParser(params);
+
+			for (const node of parsed.nodes) {
+				const { sourceEndIndex, type, value } = node;
+				const endIndex = index + sourceEndIndex;
+				const problem = { node: atRule, index, endIndex, result, ruleName };
+
+				if (primary === 'string') {
+					if (type !== 'function' || value.toLowerCase() !== 'url') continue;
+
+					const urlFunctionFull = valueParser.stringify(node);
+					const urlFunctionArguments = valueParser.stringify(node.nodes);
+					const quotedUrlFunctionFirstArgument =
+						node.nodes[0]?.type === 'word' ? `"${urlFunctionArguments}"` : urlFunctionArguments;
+					const fix = fixer(atRule, quotedUrlFunctionFirstArgument, sourceEndIndex);
+					const message = messages.expected;
+					const messageArgs = [urlFunctionFull, quotedUrlFunctionFirstArgument];
+
+					report({ ...problem, message, messageArgs, fix: { apply: fix, node: problem.node } });
+
+					return;
+				}
+
+				if (primary === 'url') {
+					if (type === 'space') return;
+
+					if (type !== 'word' && type !== 'string') continue;
+
+					const path = valueParser.stringify(node);
+					const urlFunctionFull = `url(${path})`;
+					const quotedNodeValue =
+						type === 'word' ? `"${value}"` : `${node.quote}${value}${node.quote}`;
+					const fix = fixer(atRule, urlFunctionFull, sourceEndIndex);
+					const message = messages.expected;
+					const messageArgs = [quotedNodeValue, urlFunctionFull];
+
+					report({ ...problem, message, messageArgs, fix: { apply: fix, node: problem.node } });
+
+					return;
+				}
+			}
+		}
+	};
+};
+
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;
+export default rule;