@alexlit/lint-kit 183.4.0 → 183.6.0

package/packages/config-stylelint/node_modules/stylelint/lib/utils/emitWarning.mjs

@@ -0,0 +1,84 @@
+import process from 'node:process';
+
+// Each code must be unique across all warning types.
+const DEPRECATION_CODES = {
+	// COMMONJS_PLUGINS: '001', // Can be used in Node.js 20.19+
+	// COMMONJS_NODEJS_API: '002', // Can be used in Node.js 20.19+
+	// RESULT_OUTPUT_PROPERTY: '003', // Removed in 17.0.0
+	// GITHUB_FORMATTER: '004', // Removed in 17.0.0
+	CONTEXT_FIX: '005',
+	RULE: '006', // either removal or renaming
+	// REPORT_AMBIGUOUS_POSITION: '007', // Removed in 17.0.0
+	RULE_OPTION: '008',
+};
+
+const EXPERIMENTAL_CODES = {
+	SUPPRESSIONS: '101',
+};
+
+const emittedWarnings = new Set();
+
+/**
+ * @typedef {DEPRECATION_CODES[keyof DEPRECATION_CODES] |
+ *           EXPERIMENTAL_CODES[keyof EXPERIMENTAL_CODES]} WarningCode
+ */
+
+/**
+ * Emit a warning with the specified type.
+ *
+ * @param {string} message
+ * @param {'DeprecationWarning' | 'ExperimentalWarning'} type - See https://nodejs.org/api/process.html#nodejs-warning-names
+ * @param {WarningCode} code
+ * @param {string} detail
+ * @returns {void}
+ */
+function emitWarning(message, type, code, detail) {
+	const key = JSON.stringify({
+		message,
+		options: { type, code: `stylelint:${code}`, detail },
+	});
+
+	if (emittedWarnings.has(key)) return;
+
+	emittedWarnings.add(key);
+
+	process.emitWarning(message, { type, code: `stylelint:${code}`, detail });
+}
+
+/**
+ * Use this function for deprecation warnings, instead of `process.emitWarning()`.
+ *
+ * @param {string} message
+ * @param {keyof DEPRECATION_CODES} codeKey
+ * @param {string} detail
+ * @returns {void}
+ */
+export function emitDeprecationWarning(message, codeKey, detail) {
+	emitWarning(message, 'DeprecationWarning', DEPRECATION_CODES[codeKey], detail);
+}
+
+/**
+ * Use this function for experimental warnings, instead of `process.emitWarning()`.
+ *
+ * @param {string} message
+ * @param {keyof EXPERIMENTAL_CODES} codeKey
+ * @param {string} detail
+ * @returns {void}
+ */
+export function emitExperimentalWarning(message, codeKey, detail) {
+	emitWarning(message, 'ExperimentalWarning', EXPERIMENTAL_CODES[codeKey], detail);
+}
+
+/**
+ * Clear the already emitted warnings.
+ * Only useful in tests.
+ *
+ * @private
+ */
+export function clearEmittedWarnings() {
+	if (process.env.NODE_ENV !== 'test') {
+		throw new Error('This function can only be called in test environments!');
+	}
+
+	emittedWarnings.clear();
+}

package/packages/config-stylelint/node_modules/stylelint/lib/utils/errors.mjs

@@ -0,0 +1,55 @@
+import { EXIT_CODE_INVALID_CONFIG, EXIT_CODE_INVALID_USAGE } from '../constants.mjs';
+
+export class ConfigurationError extends Error {
+	name = 'ConfigurationError';
+
+	code = EXIT_CODE_INVALID_CONFIG;
+
+	/**
+	 * @param {string} message
+	 */
+	constructor(message) {
+		super(message);
+	}
+}
+
+export class AllFilesIgnoredError extends Error {
+	name = 'AllFilesIgnoredError';
+
+	constructor() {
+		super(
+			'All input files were ignored because of the ignore pattern. Either change your input, ignore pattern or use "--allow-empty-input" to allow no inputs',
+		);
+	}
+}
+
+export class NoFilesFoundError extends Error {
+	name = 'NoFilesFoundError';
+
+	/**
+	 * @param {string|string[]} fileList
+	 */
+	constructor(fileList) {
+		super();
+
+		if (typeof fileList === 'string') {
+			fileList = [fileList];
+		}
+
+		const pattern = fileList.filter((i) => !i.startsWith('!')).join(', ');
+
+		this.message = `No files matching the pattern "${pattern}" were found.`;
+	}
+}
+
+export class SuppressionFileNotFoundError extends Error {
+	name = 'SuppressionFileNotFoundError';
+
+	code = EXIT_CODE_INVALID_USAGE;
+
+	constructor() {
+		super(
+			'The suppressions file does not exist. Please run the command with "--suppress" or "--suppress=<rule>" to create it.',
+		);
+	}
+}

package/packages/config-stylelint/node_modules/stylelint/lib/utils/filterFilePaths.mjs

@@ -0,0 +1,17 @@
+import ignore from 'ignore';
+
+/**
+ * @param {import('ignore').Ignore} ignorer
+ * @param {string[]} filePaths
+ * @returns {string[]}
+ */
+export default function filterFilePaths(ignorer, filePaths) {
+	const validForIgnore = filePaths.filter(ignore.isPathValid);
+	// Paths which starts with `..` are not valid for `ignore`, e. g. `../style.css`
+	const notValidForIgnore = new Set(filePaths.filter((p) => !validForIgnore.includes(p)));
+
+	const filteredByIgnore = new Set(ignorer.filter(validForIgnore));
+
+	// Preserving files order, while removing paths which were filtered by `ignore`
+	return filePaths.filter((p) => notValidForIgnore.has(p) || filteredByIgnore.has(p));
+}

package/packages/config-stylelint/node_modules/stylelint/lib/utils/findAnimationName.mjs

@@ -0,0 +1,74 @@
+import postcssValueParser from 'postcss-value-parser';
+
+import { animationShorthandKeywords, basicKeywords } from '../reference/keywords.mjs';
+import getDimension from './getDimension.mjs';
+import isStandardSyntaxValue from './isStandardSyntaxValue.mjs';
+import isVariable from './isVariable.mjs';
+
+/** @typedef {import('postcss-value-parser').Node} Node */
+
+/**
+ * Get the animation name within an `animation` shorthand property value.
+ *
+ * @param {string} value
+ *
+ * @returns {Node[]}
+ */
+export default function findAnimationName(value) {
+	/** @type {Node[]} */
+	const animationNames = [];
+
+	const valueNodes = postcssValueParser(value);
+	const { nodes } = valueNodes;
+
+	// Handle `inherit`, `initial` and etc
+	if (nodes.length === 1 && nodes[0] && basicKeywords.has(nodes[0].value.toLowerCase())) {
+		return [nodes[0]];
+	}
+
+	let shouldBeIgnored = false;
+
+	valueNodes.walk((valueNode) => {
+		if (shouldBeIgnored) return;
+
+		if (valueNode.type === 'function') {
+			return false;
+		}
+
+		if (valueNode.type !== 'word') {
+			return;
+		}
+
+		const valueLowerCase = valueNode.value.toLowerCase();
+
+		// Ignore non-standard syntax
+		if (!isStandardSyntaxValue(valueLowerCase)) {
+			// Cannot find animation name if shorthand has non-standard syntax value (#5532)
+			shouldBeIgnored = true;
+			animationNames.length = 0; // clears animationNames
+
+			return;
+		}
+
+		// Ignore variables
+		if (isVariable(valueLowerCase)) {
+			return;
+		}
+
+		// Ignore keywords for other animation parts
+		if (animationShorthandKeywords.has(valueLowerCase)) {
+			return;
+		}
+
+		// Ignore numbers with units
+		const { unit } = getDimension(valueNode);
+
+		if (unit || unit === '') {
+			return;
+		}
+
+		animationNames.push(valueNode);
+	});
+
+	return animationNames;
+}

package/packages/config-stylelint/node_modules/stylelint/lib/utils/findAtRuleContext.mjs

@@ -0,0 +1,27 @@
+import { isAtRule, isRule } from './typeGuards.mjs';
+
+/**
+ * Find the at-rule in which a rule is nested.
+ *
+ * Returns `null` if the rule is not nested within an at-rule.
+ *
+ * @param {import('postcss').Rule} rule
+ * @returns {null | import('postcss').AtRule}
+ */
+export default function findAtRuleContext(rule) {
+	const parent = rule.parent;
+
+	if (!parent) {
+		return null;
+	}
+
+	if (isAtRule(parent)) {
+		return parent;
+	}
+
+	if (isRule(parent)) {
+		return findAtRuleContext(parent);
+	}
+
+	return null;
+}

package/packages/config-stylelint/node_modules/stylelint/lib/utils/findFontFamily.mjs

@@ -0,0 +1,148 @@
+import postcssValueParser from 'postcss-value-parser';
+
+import {
+	basicKeywords,
+	fontFamilyKeywords,
+	fontShorthandKeywords,
+	fontSizeKeywords,
+} from '../reference/keywords.mjs';
+import { assert } from './validateTypes.mjs';
+import isNumbery from './isNumbery.mjs';
+import isStandardSyntaxValue from './isStandardSyntaxValue.mjs';
+import isValidFontSize from './isValidFontSize.mjs';
+import isVariable from './isVariable.mjs';
+
+const nodeTypesToCheck = new Set(['word', 'string', 'space', 'div']);
+
+/** @typedef {import('postcss-value-parser').Node} Node */
+
+/**
+ * @param {Node} firstNode
+ * @param {Node} secondNode
+ * @param {string | null} charactersBetween
+ * @returns {Node}
+ */
+function joinValueNodes(firstNode, secondNode, charactersBetween) {
+	firstNode.value = firstNode.value + charactersBetween + secondNode.value;
+
+	return firstNode;
+}
+
+/**
+ * @param {Node} valueNode
+ * @returns {valueNode is postcssValueParser.DivNode & { value: ',' }}
+ */
+const isCommaDiv = (valueNode) => valueNode.type === 'div' && valueNode.value === ',';
+
+/**
+ * Get the font-families within a `font` shorthand property value.
+ *
+ * @param {string} value
+ * @returns {Node[]} Collection font-family nodes
+ */
+export default function findFontFamily(value) {
+	/** @type {Node[]} */
+	const fontFamilies = [];
+
+	const valueNodes = postcssValueParser(value);
+	const { nodes: children } = valueNodes;
+
+	// Handle `inherit`, `initial` and etc
+	if (children.length === 1 && children[0] && basicKeywords.has(children[0].value.toLowerCase())) {
+		return [children[0]];
+	}
+
+	let needMergeNodesByValue = false;
+	/** @type {string | null} */
+	let mergeCharacters = null;
+
+	valueNodes.walk((valueNode, index, nodes) => {
+		if (valueNode.type === 'function') {
+			return false;
+		}
+
+		if (!nodeTypesToCheck.has(valueNode.type)) {
+			return;
+		}
+
+		const valueLowerCase = valueNode.value.toLowerCase();
+
+		// Ignore non standard syntax
+		if (!isStandardSyntaxValue(valueLowerCase)) {
+			return;
+		}
+
+		// Ignore variables
+		if (isVariable(valueLowerCase)) {
+			return;
+		}
+
+		const isFontFamilyKeyword = fontFamilyKeywords.has(valueLowerCase);
+
+		// Ignore keywords for other font parts
+		if (!isFontFamilyKeyword && fontShorthandKeywords.has(valueLowerCase)) {
+			return;
+		}
+
+		// Ignore font-sizes
+		// NOTE: `math` is a keyword for both `font-family` and `font-size`.
+		if (!isFontFamilyKeyword && isValidFontSize(valueNode.value)) {
+			return;
+		}
+
+		const nextNode = nodes[index + 1];
+		const prevNode = nodes[index - 1];
+		const prevPrevNode = nodes[index - 2];
+		const allPrevNodes = nodes.slice(0, index);
+
+		// When the value is a keyword for both `font-family` and `font-size` (e.g. `math`),
+		// if its next node is a comma, or if it is already the last node, or if there is any comma before it,
+		// then treat it as a `font-family` keyword, otherwise treat it as a `font-size` keyword.
+		if (
+			isFontFamilyKeyword &&
+			fontSizeKeywords.has(valueLowerCase) &&
+			!(!nextNode || isCommaDiv(nextNode) || allPrevNodes.find(isCommaDiv))
+		)
+			return;
+
+		// Ignore anything come after a <font-size>/, because it's a line-height
+		if (prevNode && prevNode.value === '/' && prevPrevNode && isValidFontSize(prevPrevNode.value)) {
+			return;
+		}
+
+		// Ignore number values
+		if (isNumbery(valueLowerCase)) {
+			return;
+		}
+
+		// Detect when a space or comma is dividing a list of font-families, and save the joining character.
+		if (
+			(valueNode.type === 'space' || (valueNode.type === 'div' && valueNode.value !== ',')) &&
+			fontFamilies.length !== 0
+		) {
+			needMergeNodesByValue = true;
+			mergeCharacters = valueNode.value;
+
+			return;
+		}
+
+		if (valueNode.type === 'space' || valueNode.type === 'div') {
+			return;
+		}
+
+		const fontFamily = valueNode;
+
+		if (needMergeNodesByValue) {
+			const lastFontFamily = fontFamilies[fontFamilies.length - 1];
+
+			assert(lastFontFamily);
+			joinValueNodes(lastFontFamily, fontFamily, mergeCharacters);
+			needMergeNodesByValue = false;
+			mergeCharacters = null;
+		} else {
+			fontFamilies.push(fontFamily);
+		}
+	});
+
+	return fontFamilies;
+}

package/packages/config-stylelint/node_modules/stylelint/lib/utils/findMediaFeatureNames.mjs

@@ -0,0 +1,151 @@
+import { TokenType, isToken, stringify, tokenize } from '@csstools/css-tokenizer';
+import {
+	isGeneralEnclosed,
+	isMediaFeature,
+	isMediaQueryInvalid,
+	parseFromTokens,
+} from '@csstools/media-query-list-parser';
+import {
+	isSimpleBlockNode,
+	isTokenNode,
+	parseCommaSeparatedListOfComponentValues,
+} from '@csstools/css-parser-algorithms';
+
+/** @typedef {Array<import('@csstools/media-query-list-parser').MediaQuery>} MediaQueryList */
+/** @typedef {import('@csstools/css-tokenizer').TokenIdent} TokenIdent */
+/** @typedef {{ stringify: () => string }} MediaQuerySerializer */
+
+const rangeFeatureOperator = /[<>=]/;
+
+/**
+ * Search a CSS string for Media Feature names.
+ * For every found name, invoke the callback, passing the token
+ * as an argument.
+ *
+ * Found tokens are mutable and modifications made to them will be reflected in the output.
+ *
+ * This function supports some non-standard syntaxes like SCSS variables and interpolation.
+ *
+ * @param {string} mediaQueryParams
+ * @param {(mediaFeatureName: TokenIdent) => void} callback
+ *
+ * @returns {MediaQuerySerializer}
+ */
+export default function findMediaFeatureNames(mediaQueryParams, callback) {
+	const tokens = tokenize({ css: mediaQueryParams });
+	const list = parseCommaSeparatedListOfComponentValues(tokens);
+
+	const mediaQueryConditions = list.flatMap((listItem) => {
+		return listItem.flatMap((componentValue) => {
+			if (
+				!isSimpleBlockNode(componentValue) ||
+				componentValue.startToken[0] !== TokenType.OpenParen
+			) {
+				return [];
+			}
+
+			const blockTokens = componentValue.tokens();
+
+			const mediaQueryList = parseFromTokens(blockTokens, {
+				preserveInvalidMediaQueries: true,
+			});
+
+			return mediaQueryList.filter((mediaQuery) => {
+				return !isMediaQueryInvalid(mediaQuery);
+			});
+		});
+	});
+
+	mediaQueryConditions.forEach((mediaQuery) => {
+		mediaQuery.walk(({ node }) => {
+			if (isMediaFeature(node)) {
+				const token = node.getNameToken();
+
+				if (token[0] !== TokenType.Ident) return;
+
+				callback(token);
+			}
+
+			if (isGeneralEnclosed(node)) {
+				topLevelTokenNodes(node).forEach((token, i, topLevelTokens) => {
+					if (token[0] !== TokenType.Ident) {
+						return;
+					}
+
+					const nextToken = topLevelTokens[i + 1];
+					const prevToken = topLevelTokens[i - 1];
+
+					if (
+						// Media Feature
+						(!prevToken && nextToken && nextToken[0] === TokenType.Colon) ||
+						// Range Feature
+						(nextToken &&
+							nextToken[0] === TokenType.Delim &&
+							rangeFeatureOperator.test(nextToken[4].value)) ||
+						// Range Feature
+						(prevToken &&
+							prevToken[0] === TokenType.Delim &&
+							rangeFeatureOperator.test(prevToken[4].value))
+					) {
+						callback(token);
+					}
+				});
+			}
+		});
+	});
+
+	// Serializing takes time/resources and not all callers will use this.
+	// By returning an object with a stringify method, we can avoid doing
+	// this work when it's not needed.
+	return {
+		stringify() {
+			return stringify(...tokens);
+		},
+	};
+}
+
+/** @param {import('@csstools/media-query-list-parser').GeneralEnclosed} node */
+function topLevelTokenNodes(node) {
+	const components = node.value.value;
+
+	if (isToken(components) || components.length === 0 || isToken(components[0])) {
+		return [];
+	}
+
+	/** @type {Array<import('@csstools/css-tokenizer').CSSToken>} */
+	const relevantTokens = [];
+
+	// Only preserve top level tokens (idents, delims, ...)
+	// Discard all blocks, functions, ...
+	components.filter(isTokenNode).forEach((component, index, tokenNodes) => {
+		const [tokenType, , , ,] = component.value;
+
+		// E.g. $var
+		if (isScssVariableDelim(component)) return;
+
+		if (tokenType === TokenType.Ident && isScssVariableDelim(tokenNodes[index - 1])) {
+			return;
+		}
+
+		// E.g. namespace.$var
+		if (isScssNamespaceDelim(component)) return;
+
+		if (tokenType === TokenType.Ident && isScssNamespaceDelim(tokenNodes[index + 1])) {
+			return;
+		}
+
+		relevantTokens.push(component.value);
+	});
+
+	return relevantTokens;
+}
+
+/** @param {import('@csstools/css-parser-algorithms').TokenNode | undefined} component */
+function isScssVariableDelim(component) {
+	return component && component.value[0] === TokenType.Delim && component.value[4].value === '$';
+}
+
+/** @param {import('@csstools/css-parser-algorithms').TokenNode | undefined} component */
+function isScssNamespaceDelim(component) {
+	return component && component.value[0] === TokenType.Delim && component.value[4].value === '.';
+}

package/packages/config-stylelint/node_modules/stylelint/lib/utils/findNodeUpToRoot.mjs

@@ -0,0 +1,25 @@
+import eachNodeUpToRoot, { STOP } from './eachNodeUpToRoot.mjs';
+
+/** @import { Node } from 'postcss' */
+
+/**
+ * Finds the node satisfying the specified predicate up to the root node.
+ *
+ * @param {Node} node
+ * @param {(node: Node) => boolean} predicate
+ * @returns {Node | undefined}
+ */
+export default function findNodeUpToRoot(node, predicate) {
+	/** @type {Node | undefined} */
+	let found;
+
+	eachNodeUpToRoot(node, (current) => {
+		if (predicate(current)) {
+			found = current;
+
+			return STOP;
+		}
+	});
+
+	return found;
+}

package/packages/config-stylelint/node_modules/stylelint/lib/utils/fixEmptyLinesBefore.mjs

@@ -0,0 +1,26 @@
+import addEmptyLineBefore from './addEmptyLineBefore.mjs';
+import { assert } from './validateTypes.mjs';
+import removeEmptyLinesBefore from './removeEmptyLinesBefore.mjs';
+
+/**
+ * fix callback for *-empty-line-before rules
+ * @param {object} o
+ * @param {import('postcss').Node} o.node
+ * @param {string=} o.newline
+ * @param {'add'|'remove'} o.action
+ * @throws {TypeError}
+ */
+export default function fixEmptyLinesBefore({ node, newline, action }) {
+	assert(newline);
+
+	switch (action) {
+		case 'add':
+			addEmptyLineBefore(node, newline);
+			break;
+		case 'remove':
+			removeEmptyLinesBefore(node, newline);
+			break;
+		default:
+			throw new TypeError(`Unknown action ${action}`);
+	}
+}

package/packages/config-stylelint/node_modules/stylelint/lib/utils/functionArgumentsSearch.mjs

@@ -0,0 +1,65 @@
+import valueParser from 'postcss-value-parser';
+
+import { assert, isRegExp, isString } from './validateTypes.mjs';
+
+/** @typedef {(expression: string, expressionIndex: number, funcNode: valueParser.FunctionNode, parsedValue: valueParser.ParsedValue) => void} Callback */
+
+/**
+ * Search a CSS string for functions by name.
+ * For every match, invoke the callback, passing the function's
+ * "argument(s) string" (whatever is inside the parentheses)
+ * as an argument.
+ *
+ * Callback will be called once for every matching function found,
+ * with the function's "argument(s) string" and its starting index
+ * as the arguments.
+ *
+ * @param {string} source
+ * @param {string | RegExp} functionName
+ * @param {Callback} callback
+ * @returns {valueParser.ParsedValue}
+ */
+export default function functionArgumentsSearch(source, functionName, callback) {
+	const parsedValue = valueParser(source);
+
+	return parsedValue.walk((node) => {
+		if (node.type !== 'function') return;
+
+		const { value } = node;
+
+		if (isString(functionName) && value !== functionName) return;
+
+		if (isRegExp(functionName) && !functionName.test(node.value)) return;
+
+		const parenLength = 1; // == '('
+		const expressionIndex = node.sourceIndex + value.length + parenLength;
+
+		let expression;
+
+		if (node.value.toLowerCase() === 'url') {
+			// Re-parse url tokens as component values to support interpolation patterns in non-standard CSS
+			const [reParsedValue] = valueParser(
+				// Slice the source value at the opening parenthesis `url(foo) trailing` -> `(foo) trailing`
+				// When parsed as a list of component values the first node will be a simple block
+				source.slice(node.sourceIndex + value.length),
+			).nodes;
+
+			assert(reParsedValue);
+
+			const endIndex =
+				expressionIndex +
+				reParsedValue.sourceEndIndex -
+				1 -
+				(source[expressionIndex + reParsedValue.sourceEndIndex - 2] === ')' ? parenLength : 0);
+
+			expression = source.slice(expressionIndex, endIndex);
+		} else {
+			const endIndex =
+				node.sourceEndIndex - (source[node.sourceEndIndex - 1] === ')' ? parenLength : 0);
+
+			expression = source.slice(expressionIndex, endIndex);
+		}
+
+		callback(expression, expressionIndex, node, parsedValue);
+	});
+}

package/packages/config-stylelint/node_modules/stylelint/lib/utils/getAtRuleParams.mjs

@@ -0,0 +1,7 @@
+/**
+ * @param {import('postcss').AtRule} atRule
+ * @returns {string}
+ */
+export default function getAtRuleParams(atRule) {
+	return atRule.raws.params?.raw ?? atRule.params;
+}

package/packages/config-stylelint/node_modules/stylelint/lib/utils/getDeclarationValue.mjs

@@ -0,0 +1,9 @@
+/**
+ * @param {import('postcss').Declaration} decl
+ * @returns {string}
+ */
+export default function getDeclarationValue(decl) {
+	const raws = decl.raws;
+
+	return (raws.value && raws.value.raw) || decl.value;
+}