@alexlit/lint-kit 183.6.0 → 183.7.0

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

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

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

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

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

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