@alexlit/lint-kit 183.7.0 → 184.1.0

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

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

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

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

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

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

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

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