@alexlit/lint-kit 183.6.0 → 183.7.0

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

@@ -1,135 +0,0 @@
-import {
-	aNPlusBNotationPseudoClasses,
-	aNPlusBOfSNotationPseudoClasses,
-	percentageKeyframeWithNamedEquivalent,
-} from '../reference/selectors.mjs';
-import {
-	colorFunctions,
-	hueColorFunctions,
-	legacyNotationColorFunctions,
-	lightnessColorFunctions,
-	mathFunctions,
-	withAlphaAliasColorFunctions,
-	withoutAlphaAliasColorFunctions,
-} from '../reference/functions.mjs';
-import {
-	displayInsideKeywords,
-	displayLegacyKeywords,
-	displayListItemKeyword,
-	displayOutsideKeywords,
-	fontWeightNonNumericKeywords,
-	fontWeightNumericKeywordsWithNamedEquivalent,
-	fontWeightRelativeKeywords,
-	keyframeSelectorKeywords,
-	namedColorsKeywords,
-} from '../reference/keywords.mjs';
-import { deprecatedMediaTypesNames } from '../reference/mediaTypes.mjs';
-import { lengthUnits } from '../reference/units.mjs';
-import { nestingSupportedAtKeywords } from '../reference/atKeywords.mjs';
-import { prefixes } from '../reference/prefixes.mjs';
-
-const aNPlusBClasses = [
-	...aNPlusBNotationPseudoClasses.values(),
-	...aNPlusBOfSNotationPseudoClasses.values(),
-].join('|');
-
-export const atRuleRegexes = {
-	containerName: /^container$/i,
-	customMediaName: /^custom-media$/i,
-	importName: /^import$/i,
-	keyframesName: /^(-(o|moz|ms|webkit)-)?keyframes$/i,
-	layerName: /^layer$/i,
-	mediaName: /^media$/i,
-	pageName: /^page$/i,
-	propertyName: /^property$/i,
-	scopeName: /^scope$/i,
-	unsupportedNestingNames: new RegExp(
-		`^((?!${[...nestingSupportedAtKeywords.values()].join('|')}).)*$`,
-		'i',
-	),
-};
-
-export const descriptorRegexes = {
-	syntaxName: /^syntax$/i,
-};
-
-export const propertyRegexes = {
-	containerNameAndShorthandName: /^container(-name)?$/i,
-	custom: /^--/,
-	fontFamilyAndShorthandName: /^font(-family)?$/i,
-	fontWeightAndShorthandName: /^font(-weight)?$/i,
-	gridAreaNames: /^(?:grid|grid-template|grid-template-areas)$/i,
-};
-
-export const mayIncludeRegexes = {
-	aNPlusBNotationPseudoClass: new RegExp(`\\b:(?:${aNPlusBClasses})\\(`, 'i'),
-	annotation: /!/,
-	attributeSelector: /\[/,
-	attributeSelectorWithOperator: /\[.*=/,
-	classSelector: /\./,
-	colorFunction: new RegExp(`\\b(?:${[...colorFunctions.values()].join('|')})\\(`, 'i'),
-	legacyNotationColorFunction: new RegExp(
-		`\\b(?:${[...legacyNotationColorFunctions.values()].join('|')})\\(`,
-		'i',
-	),
-	combinator: /[>+~\s]/,
-	customProperty: /--/,
-	deprecatedMediaType: new RegExp(`\\b(?:${[...deprecatedMediaTypesNames].join('|')})\\b`, 'i'),
-	displayKeyword: new RegExp(
-		`\\b(?:${[...displayListItemKeyword, ...displayOutsideKeywords, ...displayInsideKeywords, ...displayLegacyKeywords].join('|')})\\b`,
-		'i',
-	),
-	dimension: /\d[%\w-]/,
-	grayFunction: /\bgray\(/i,
-	hexColor: /#[\da-z]+/i,
-	hueColorFunction: new RegExp(`\\b(?:${[...hueColorFunctions.values()].join('|')})\\(`, 'i'),
-	lightnessColorFunction: new RegExp(
-		`\\b(?:${[...lightnessColorFunctions.values()].join('|')})\\(`,
-		'i',
-	),
-	idClassAttributeSelector: /[#.[]/,
-	idSelector: /#/,
-	keyword: /(?<![0-9])[a-z]+(?!\()/i,
-	layerFunction: /\blayer\(/i,
-	mathFunction: new RegExp(`\\b(?:${[...mathFunctions.values()].join('|')})\\(`, 'i'),
-	namedFontWeight: new RegExp(
-		`\\b(?:${[...new Set([...fontWeightNonNumericKeywords, ...fontWeightRelativeKeywords])].join('|')})\\b`,
-		'i',
-	),
-	numericFontWeight: new RegExp(
-		`\\b(?:${[...fontWeightNumericKeywordsWithNamedEquivalent.values()].join('|')})\\b`,
-	),
-	namedKeyframeSelectorWithPercentageEquivalent: new RegExp(
-		`\\b(?:${[...keyframeSelectorKeywords.values()].join('|')})\\b`,
-		'i',
-	),
-	percentageKeyframeSelectorWithNamedEquivalent: new RegExp(
-		`(?:^|[,\\s])(?:${[...percentageKeyframeWithNamedEquivalent.values()].join('|')})`,
-	),
-	multipleValues: /\s|,/,
-	namedColor: new RegExp(`\\b(?:${[...namedColorsKeywords.values()].join('|')})\\b`, 'i'),
-	nestingSelector: /&/,
-	notPseudoClass: /:not\(/i,
-	operator: /[+-]/,
-	prefix: new RegExp(`(?:${[...prefixes].join('|')})`, 'i'),
-	pseudo: /:/,
-	pseudoElement: /::/,
-	time: /\dm?s/i,
-	typeSelector: /(?:[^.#[:a-z-]|^)[a-z]/i,
-	universalSelector: /\*/,
-	urlFunction: /\burl\(/i,
-	validHex: /#(?:[\da-f]{3,4}|[\da-f]{6}|[\da-f]{8})(?:$|[^\da-f])/i,
-	varFunction: /\bvar\(/i,
-	withAlphaAliasColorFunction: new RegExp(
-		`\\b(?:${[...withAlphaAliasColorFunctions.values()].join('|')})\\(`,
-		'i',
-	),
-	withoutAlphaAliasColorFunction: new RegExp(
-		`\\b(?:${[...withoutAlphaAliasColorFunctions.values()].join('|')})\\(`,
-		'i',
-	),
-	zeroLength: new RegExp(
-		`\\b[+-]?(?:0+|0*\\.\\d+)(?:${[...lengthUnits.values()].join('|')})\\b`,
-		'i',
-	),
-};

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

@@ -1,13 +0,0 @@
-/**
- * Remove empty lines before a node. Mutates the node.
- *
- * @template {import('postcss').Node} T
- * @param {T} node
- * @param {string} newline
- * @returns {T}
- */
-export default function removeEmptyLinesBefore(node, newline) {
-	node.raws.before = node.raws.before ? node.raws.before.replace(/(\r?\n\s*\n)+/g, newline) : '';
-
-	return node;
-}

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

@@ -1,321 +0,0 @@
-import {
-	isFunction as isFn,
-	isNumber,
-	isPlainObject,
-	isRange,
-	isString,
-} from '../utils/validateTypes.mjs';
-
-import {
-	DEFAULT_SEVERITY,
-	RULE_NAME_ALL,
-	SEVERITY_ERROR,
-	SEVERITY_WARNING,
-} from '../constants.mjs';
-import addSemicolonForEditInfo from './addSemicolonForEditInfo.mjs';
-import appendRuleName from './appendRuleName.mjs';
-import narrowFixRange from './narrowFixRange.mjs';
-import rangesOverlap from './rangesOverlap.mjs';
-
-/** @import { Config, DisabledRangeObject, FixObject, Problem, Range, RuleMessage, StylelintPostcssResult, Utils, WarningOptions } from 'stylelint' */
-
-/**
- * Report a problem.
- *
- * This function accounts for `disabledRanges` attached to the result.
- * That is, if the reported problem is within a disabledRange,
- * it is ignored. Otherwise, it is attached to the result as a
- * postcss warning.
- *
- * It also accounts for the rule's severity.
- *
- * You *must* pass *either* a node or a line number.
- *
- * @type {Utils['report']}
- */
-export default function report(problem) {
-	const { node, result, ruleName, fix, ...rest } = problem;
-	const problemRange = getProblemRange(problem);
-	const {
-		disabledRanges,
-		quiet,
-		ruleSeverities,
-		config: { defaultSeverity, ignoreDisables } = {},
-		customMessages: { [ruleName]: message = rest.message },
-		customUrls: { [ruleName]: customUrl },
-		ruleMetadata: { [ruleName]: metadata },
-	} = result.stylelint;
-	const { messageArgs = [], severity = ruleSeverities[ruleName] } = rest;
-	const ruleSeverity =
-		(isFn(severity) ? severity(...messageArgs) : severity) ?? defaultSeverity ?? DEFAULT_SEVERITY;
-
-	// In quiet mode, mere warnings are ignored
-	if (quiet && ruleSeverity === SEVERITY_WARNING) return;
-
-	if ((isFn(fix) || isFixObject(fix)) && metadata && !metadata.fixable) {
-		throw new Error(
-			`The "${ruleName}" rule requires "meta.fixable" to be truthy if the "fix" callback is being passed`,
-		);
-	}
-
-	if (isFixApplied(problem, problemRange.start.line)) return;
-
-	if (isDisabledOnLine(ruleName, problemRange.start.line, disabledRanges)) {
-		// Collect disabled warnings
-		// Used to report `needlessDisables` in subsequent processing.
-		const disabledWarnings = (result.stylelint.disabledWarnings ||= []);
-
-		disabledWarnings.push({
-			rule: ruleName,
-			line: problemRange.start.line,
-		});
-
-		if (!ignoreDisables) return;
-	}
-
-	if (!result.stylelint.stylelintError && ruleSeverity === SEVERITY_ERROR) {
-		result.stylelint.stylelintError = true;
-	}
-
-	if (!result.stylelint.stylelintWarning && ruleSeverity === SEVERITY_WARNING) {
-		result.stylelint.stylelintWarning = true;
-	}
-
-	/** @type {WarningOptions} */
-	const warningProperties = {
-		severity: ruleSeverity,
-		rule: ruleName,
-	};
-
-	if (node) {
-		warningProperties.node = node;
-	}
-
-	warningProperties.start = problemRange.start;
-	warningProperties.end = problemRange.end;
-
-	if (customUrl) {
-		warningProperties.url = customUrl;
-	}
-
-	warningProperties.fix = computeEditInfo({ ...problem, line: problemRange.start.line });
-
-	const warningMessage = buildWarningMessage(message, messageArgs, ruleName);
-
-	result.warn(warningMessage, warningProperties);
-}
-
-/**
- * @param {Problem} problem
- * @returns {Range}
- */
-function getProblemRange(problem) {
-	if (!problem.node) {
-		throw new Error(
-			`The "${problem.ruleName}" rule provided incorrect position arguments to \`utils.report()\`. To fix, pass a PostCSS \`node\` to the function.`,
-		);
-	}
-
-	// `start/end` based range
-	if (isRange(problem)) {
-		return {
-			start: problem.start,
-			end: problem.end,
-		};
-	}
-
-	if ('start' in problem || 'end' in problem) {
-		throw new Error(
-			`The "${problem.ruleName}" rule provided incomplete position arguments to \`utils.report()\`. To fix, provide both \`start\` and \`end\` as valid positions to the function.`,
-		);
-	}
-
-	// `index/endIndex` based range
-	if (hasIndices(problem)) {
-		return problem.node.rangeBy({ index: problem.index, endIndex: problem.endIndex });
-	}
-
-	if ('index' in problem || 'endIndex' in problem) {
-		throw new Error(
-			`The "${problem.ruleName}" rule provided incomplete position arguments to \`utils.report()\`. To fix, provide both \`index\` and \`endIndex\` as numbers to the function.`,
-		);
-	}
-
-	// `word` based range
-	if ('word' in problem && isString(problem.word)) {
-		return problem.node.rangeBy({ word: problem.word });
-	}
-
-	return problem.node.rangeBy({});
-}
-
-/**
- * @param {RuleMessage} message
- * @param {NonNullable<Problem['messageArgs']>} messageArgs
- * @param {string} ruleName
- * @returns {string}
- */
-function buildWarningMessage(message, messageArgs, ruleName) {
-	return appendRuleName(
-		isString(message) ? printfLike(message, ...messageArgs) : message(...messageArgs),
-		ruleName,
-	);
-}
-
-/**
- * @param {string} format
- * @param {Array<unknown>} args
- * @returns {string}
- */
-function printfLike(format, ...args) {
-	return args.reduce((/** @type {string} */ result, arg) => {
-		return result.replace(/%[ds]/, String(arg));
-	}, format);
-}
-
-/**
- * Check whether a rule is disabled for a given line
- * @param {string} ruleName
- * @param {number} startLine
- * @param {DisabledRangeObject} disabledRanges
- */
-function isDisabledOnLine(ruleName, startLine, disabledRanges) {
-	const ranges = disabledRanges[ruleName] ?? disabledRanges[RULE_NAME_ALL] ?? [];
-
-	for (const range of ranges) {
-		if (
-			// If the problem is within a disabledRange,
-			// and that disabledRange's rules include this one
-			range.start <= startLine &&
-			(range.end === undefined || range.end >= startLine) &&
-			/** @todo populate rules in assignDisabledRanges util */
-			(!range.rules || range.rules.includes(ruleName))
-		) {
-			return true;
-		}
-	}
-
-	return false;
-}
-
-/**
- * @param {Problem} problem
- * @param {number} line
- * @returns {boolean}
- */
-function isFixApplied({ fix, result: { stylelint }, ruleName }, line) {
-	if (!fix) return false;
-
-	const { disabledRanges, config = {}, fixersData } = stylelint;
-
-	if (!config.fix) return false;
-
-	if (isFixDisabled(line, ruleName, config, disabledRanges)) return false;
-
-	const apply = isFixObject(fix) ? fix.apply : fix;
-
-	if (!isFn(apply)) return false;
-
-	apply();
-
-	incrementFixCounter({ fixersData, ruleName });
-
-	return true;
-}
-
-/**
- * @param {Problem & { line: number }} problem
- * @returns {{range: [number, number], text: string} | undefined}
- */
-function computeEditInfo({ fix, line, result, ruleName }) {
-	if (!fix) return;
-
-	const { disabledRanges, config = {}, rangesOfComputedEditInfos } = result.stylelint;
-
-	if (!config.computeEditInfo || config.fix) return;
-
-	if (isFixDisabled(line, ruleName, config, disabledRanges)) return;
-
-	if (!isFixObject(fix) || !fix.apply || !fix.node) return;
-
-	const { apply, node } = fix;
-
-	if (!isNumber(node.source?.start?.offset) || !isNumber(node.source?.end?.offset)) return;
-
-	/** @type [number, number] */
-	const fixedNodeRange = [node.source.start.offset, node.source.end.offset];
-
-	// When recording edit info we want to ensure that there is no overlap with any other fix.
-	// We only record the first fix for each node.
-	if (rangesOfComputedEditInfos.some((range) => rangesOverlap(range, fixedNodeRange))) {
-		return;
-	}
-
-	// Apply the fix
-	apply();
-
-	let fixData = { range: fixedNodeRange, text: node.toString(result.opts?.syntax) };
-
-	fixData = addSemicolonForEditInfo(node, fixData);
-
-	// Compute the smallest range and text of the fix
-	fixData = narrowFixRange(node, fixData);
-
-	// Mark the fixed range as mutated
-	rangesOfComputedEditInfos.push(fixData.range);
-
-	return fixData;
-}
-
-/**
- * @param {number} line
- * @param {string} ruleName
- * @param {Config} config
- * @param {DisabledRangeObject} disabledRanges
- * @returns {boolean}
- */
-function isFixDisabled(line, ruleName, config, disabledRanges) {
-	if (config.rules?.[ruleName][1]?.disableFix) return true;
-
-	if (!config.ignoreDisables && isDisabledOnLine(ruleName, line, disabledRanges)) return true;
-
-	return false;
-}
-
-/**
- * @param {object} o
- * @param {StylelintPostcssResult['fixersData']} o.fixersData
- * @param {string} o.ruleName
- */
-function incrementFixCounter({ fixersData, ruleName }) {
-	fixersData[ruleName] ??= 0;
-	fixersData[ruleName]++;
-}
-
-/**
- * @param {unknown} value
- * @returns {value is { index: number, endIndex: number }}
- */
-function hasIndices(value) {
-	if (!isPlainObject(value)) return false;
-
-	if (!isNumber(value.index)) return false;
-
-	if (!isNumber(value.endIndex)) return false;
-
-	return true;
-}
-
-/**
- * @param {unknown} value
- * @returns {value is FixObject}
- */
-function isFixObject(value) {
-	if (!isPlainObject(value)) return false;
-
-	if (!value.node) return false;
-
-	if (!isFn(value.apply)) return false;
-
-	return true;
-}

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

@@ -1,39 +0,0 @@
-import { SEVERITY_ERROR, SEVERITY_WARNING } from '../constants.mjs';
-
-/**
- * @param {{
- *   rule: string;
- *   message: string;
- *   severity: import('stylelint').Severity;
- *   node: import('postcss').Node;
- *   postcssResult: import('stylelint').PostcssResult;
- * }} args
- * @returns {void}
- */
-export default function reportCommentProblem({ rule, message, severity, node, postcssResult }) {
-	const { source } = node;
-
-	// If the comment doesn't have a location, we can't report a useful error.
-	// In practice we expect all comments to have locations, though.
-	if (!source?.start) return;
-
-	postcssResult.warn(message, {
-		rule,
-		severity,
-		node,
-		start: source.start,
-		end: source.end,
-	});
-
-	switch (severity) {
-		case SEVERITY_ERROR:
-			postcssResult.stylelint.stylelintError = true;
-			break;
-		case SEVERITY_WARNING:
-			postcssResult.stylelint.stylelintWarning = true;
-			break;
-		default:
-			// no-op
-			break;
-	}
-}

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

@@ -1,38 +0,0 @@
-import { join, normalize, resolve, sep } from 'node:path';
-import { lstatSync } from 'node:fs';
-
-/**
- * Return the resolved file path, based on whether the provided parameter is
- * a directory or looks like a directory (ends in `path.sep`), in which case the file
- * name will be `location/defaultFileName`.
- *
- * If location points to a file or looks like a file, then it will just use that file.
- *
- * @param {string} location - The name of file or directory to be used
- * @param {string} cwd - Current working directory. Used for tests
- * @param {string} defaultFileName - Default filename to use when location is a directory
- * @returns {string} Resolved path to the file
- */
-export default function resolveFilePath(location, cwd, defaultFileName) {
-	/*
-	 * Make sure path separators are normalized for environment/os.
-	 * Also, keep trailing path separator if present.
-	 */
-	const normalizedLocation = normalize(location);
-
-	const resolvedLocation = resolve(cwd, normalizedLocation);
-
-	// If the location path ends with a separator, we assume is a directory.
-	const looksLikeADirectory = location.endsWith(sep);
-
-	if (
-		looksLikeADirectory ||
-		lstatSync(resolvedLocation, { throwIfNoEntry: false })?.isDirectory()
-	) {
-		// Return path to provided directory with the specified file name.
-		return join(resolvedLocation, defaultFileName);
-	}
-
-	// Return normalized path to file.
-	return resolvedLocation;
-}

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

@@ -1,108 +0,0 @@
-import { resolveNestedSelector } from '@csstools/selector-resolve-nested';
-
-import { isAtRule, isRule } from './typeGuards.mjs';
-import getRuleSelector from './getRuleSelector.mjs';
-import isStandardSyntaxRule from './isStandardSyntaxRule.mjs';
-import parseSelector from './parseSelector.mjs';
-import selectorParser from 'postcss-selector-parser';
-
-/** @import { Selector, Root as SelectorRoot } from 'postcss-selector-parser' */
-/** @import { Rule, Node } from 'postcss' */
-/** @import { PostcssResult } from 'stylelint' */
-
-/** @type {WeakMap<Rule, Map<PostcssResult, Array<ResolvedSelector>>>} */
-const cache = new WeakMap();
-
-/**
- * Resolve nested selectors following the CSS nesting specification
- *
- * @typedef {{selector: Selector, resolvedSelectors: SelectorRoot, nested: boolean}} ResolvedSelector
- *
- * @param {Rule} rule
- * @param {PostcssResult} result
- * @returns {Array<ResolvedSelector>}
- */
-export default function resolveNestedSelectorsForRule(rule, result) {
-	let ruleCache = cache.get(rule);
-
-	if (ruleCache) {
-		const cachedResolved = ruleCache.get(result);
-
-		if (cachedResolved) return cachedResolved;
-	} else {
-		ruleCache = new Map();
-		cache.set(rule, ruleCache);
-	}
-
-	const ownAST = parseSelector(getRuleSelector(rule), result, rule);
-
-	if (!ownAST) return [];
-
-	/** @type {SelectorRoot | undefined} */
-	let ast = undefined;
-
-	/** @type {Array<Node>} */
-	const ancestors = [];
-
-	{
-		/** @type {Node['parent']} */
-		let parent = rule.parent;
-
-		while (parent) {
-			ancestors.push(parent);
-			parent = parent.parent;
-		}
-	}
-
-	ancestors.reverse();
-
-	for (const child of ancestors) {
-		if (isAtRule(child) && child.name === 'scope') {
-			ast = parseSelector(':where(:scope)', result, child);
-			continue;
-		}
-
-		if (!isRule(child)) continue;
-
-		if (!isStandardSyntaxRule(child)) return [];
-
-		const childAST = parseSelector(getRuleSelector(child), result, child);
-
-		if (!childAST) return [];
-
-		if (ast) {
-			ast = resolveNestedSelector(childAST, ast);
-		} else {
-			ast = childAST;
-		}
-	}
-
-	const resolved = ownAST.map((selector) => {
-		if (!ast) {
-			return {
-				selector,
-				resolvedSelectors: selectorParser.root({
-					value: '',
-					nodes: [selector],
-				}),
-				nested: false,
-			};
-		}
-
-		return {
-			selector,
-			resolvedSelectors: resolveNestedSelector(
-				selectorParser.root({
-					nodes: [selector],
-					value: '',
-				}),
-				ast,
-			),
-			nested: true,
-		};
-	});
-
-	ruleCache.set(result, resolved);
-
-	return resolved;
-}

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

@@ -1,30 +0,0 @@
-import getConfigForFile from '../getConfigForFile.mjs';
-
-/** @import {InternalApi, LinterOptions, Config} from 'stylelint' */
-
-/**
- * Get a value of the specified lint option or configuration.
- *
- * @template T
- * @param {Object} options
- * @param {InternalApi} options.stylelint
- * @param {keyof LinterOptions & keyof Config} options.name
- * @param {T} [options.default]
- * @returns {Promise<T>}
- */
-export default async function resolveOptionValue({
-	stylelint,
-	name,
-	default: defaultValue = undefined,
-}) {
-	const options = stylelint._options;
-	const value = options[name] ?? options.config?.[name];
-
-	if (value != null) {
-		return /** @type {T} */ (value);
-	}
-
-	const configForFile = await getConfigForFile({ stylelint, failIfNoConfig: false });
-
-	return configForFile?.config?.[name] ?? defaultValue;
-}