@alexlit/lint-kit 173.2.2 → 173.3.0

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

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

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

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

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

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

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

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

@@ -1,45 +0,0 @@
-import balancedMatch from 'balanced-match';
-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 parensMatch = balancedMatch('(', ')', source.slice(node.sourceIndex));
-
-		assert(parensMatch);
-
-		const expression = parensMatch.body;
-		const parenLength = 1; // == '('
-		const expressionIndex = node.sourceIndex + value.length + parenLength;
-
-		callback(expression, expressionIndex, node, parsedValue);
-	});
-}

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

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

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

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

@@ -1,62 +0,0 @@
-import valueParser from 'postcss-value-parser';
-
-import blurInterpolation from './blurInterpolation.mjs';
-import isStandardSyntaxValue from './isStandardSyntaxValue.mjs';
-
-/**
- * Get Dimension from value node;
- * `unit` and `number` return null if neither is found
- *
- * @param {import('postcss-value-parser').Node} node
- *
- * @returns {{unit: null, number: null} | valueParser.Dimension}
- */
-export default function getDimension(node) {
-	if (!node || !node.value) {
-		return {
-			unit: null,
-			number: null,
-		};
-	}
-
-	// Ignore non-word nodes
-	if (node.type !== 'word') {
-		return {
-			unit: null,
-			number: null,
-		};
-	}
-
-	// Ignore non standard syntax
-	if (!isStandardSyntaxValue(node.value)) {
-		return {
-			unit: null,
-			number: null,
-		};
-	}
-
-	// Ignore HEX
-	if (node.value.startsWith('#')) {
-		return {
-			unit: null,
-			number: null,
-		};
-	}
-
-	// Remove non standard stuff
-	const value = blurInterpolation(node.value, '')
-		// ignore hack unit
-		.replace('\\0', '')
-		.replace('\\9', '');
-
-	const parsedUnit = valueParser.unit(value);
-
-	if (!parsedUnit) {
-		return {
-			unit: null,
-			number: null,
-		};
-	}
-
-	return parsedUnit;
-}

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

@@ -1,41 +0,0 @@
-import { existsSync, readFileSync } from 'node:fs';
-import { isAbsolute, resolve } from 'node:path';
-import ignore from 'ignore';
-
-import { DEFAULT_IGNORE_FILENAME } from '../constants.mjs';
-
-/**
- * @typedef {import('stylelint').LinterOptions} LinterOptions
- *
- * @param {Pick<LinterOptions, 'ignorePath' | 'ignorePattern'> & { cwd: string }} options
- * @returns {import('ignore').Ignore}
- */
-export default function getFileIgnorer({ ignorePath, ignorePattern, cwd }) {
-	const ignorer = ignore();
-	const ignorePaths = [ignorePath || []].flat();
-
-	if (ignorePaths.length === 0) {
-		ignorePaths.push(DEFAULT_IGNORE_FILENAME);
-	}
-
-	for (const ignoreFilePath of ignorePaths) {
-		const absoluteIgnoreFilePath = isAbsolute(ignoreFilePath)
-			? ignoreFilePath
-			: resolve(cwd, ignoreFilePath);
-
-		if (!existsSync(absoluteIgnoreFilePath)) continue;
-
-		const ignoreText = readFileSync(absoluteIgnoreFilePath, {
-			// utf must remain lowercased to hit the fast path
-			// see nodejs/node#49888
-			encoding: 'utf8',
-			flag: 'r',
-		});
-
-		ignorer.add(ignoreText);
-	}
-
-	if (ignorePattern) ignorer.add(ignorePattern);
-
-	return ignorer;
-}

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

@@ -1,43 +0,0 @@
-import { existsSync } from 'node:fs';
-import { resolve } from 'node:path';
-
-import dynamicImport from './dynamicImport.mjs';
-import formatters from '../formatters/index.mjs';
-import getFormatterOptionsText from './getFormatterOptionsText.mjs';
-import resolveOptionValue from './resolveOptionValue.mjs';
-
-/** @import {Formatter, FormatterType, InternalApi} from 'stylelint' */
-
-/**
- * @param {InternalApi} stylelint
- * @returns {Promise<Formatter>}
- */
-export default async function getFormatter(stylelint) {
-	/** @type {FormatterType | undefined} */
-	let formatter = await resolveOptionValue({ stylelint, name: 'formatter' });
-
-	if (typeof formatter === 'string') {
-		let formatterFunction = formatters[formatter];
-
-		if (formatterFunction === undefined) {
-			if (existsSync(formatter)) {
-				formatterFunction = await dynamicImport(resolve(formatter)).then((m) => m.default);
-			} else {
-				const formattersText = getFormatterOptionsText(', ', '"');
-
-				throw new Error(`You must use a valid formatter option: ${formattersText} or a function`);
-			}
-		}
-
-		return formatterFunction;
-	}
-
-	// Assume a function or a promise of a function.
-	if (typeof formatter === 'function' || formatter) {
-		return Promise.resolve(formatter);
-	}
-
-	formatter ??= stylelint._options._defaultFormatter ?? 'json';
-
-	return formatters[formatter];
-}