@alexlit/lint-kit 183.4.0 → 183.6.0

package/packages/config-stylelint/node_modules/stylelint/lib/formatters/tapFormatter.mjs

@@ -0,0 +1,85 @@
+import { isNumber } from '../utils/validateTypes.mjs';
+import preprocessWarnings from './preprocessWarnings.mjs';
+
+/** @import {Warning, Formatter} from 'stylelint' */
+/** @typedef {Array<Omit<Warning, 'rule'>>} Warnings */
+
+/** @type {Formatter} */
+export default function tapFormatter(results) {
+	const lines = ['TAP version 14', `1..${results.length}`];
+
+	for (const [index, result] of results.entries()) {
+		preprocessWarnings(result);
+		// SKIP indicates "that a test was not run, or if it was,
+		// that its success or failure is being temporarily ignored."
+		// skipped tests must not be treated as test failures though
+		// if a file is ignored, errored is currently always false
+		const ignored = result.ignored ? ' # SKIP ignored' : '';
+		const error = result.errored ? 'not ' : '';
+
+		lines.push(`${error}ok ${index + 1} - ${getEscapedSource(result.source)}${ignored}`);
+
+		if (error) {
+			lines.push('  ---');
+
+			/** @type {Record<string, Warnings>} */
+			const rules = {};
+
+			for (const { rule, ...rest } of result.warnings) {
+				const name = rule || 'unknown';
+				const warnings = (rules[name] ??= []);
+
+				warnings.push(rest);
+			}
+
+			for (const [ruleName, warnings] of Object.entries(rules)) {
+				lines.push(`  ${ruleName}:`);
+
+				for (const { text, severity, line, column, endLine, endColumn } of warnings) {
+					lines.push(
+						`    - message: ${JSON.stringify(text)}`,
+						`      severity: ${severity}`,
+						`      line: ${line}`,
+						`      column: ${column}`,
+					);
+
+					if (isNumber(endLine)) lines.push(`      endLine: ${endLine}`);
+
+					if (isNumber(endColumn)) lines.push(`      endColumn: ${endColumn}`);
+				}
+			}
+
+			lines.push('  ...');
+		}
+	}
+
+	lines.push('');
+
+	return lines.join('\n');
+}
+
+/**
+ * Apply TAP escaping to the source that is part of the test point description
+ * @see {@link https://testanything.org/tap-version-14-specification.html#escaping TAP 14 specification}
+ * @param {string} [source]
+ */
+function getEscapedSource(source) {
+	if (!source) return source;
+
+	let output = '';
+
+	for (const char of source) {
+		switch (char.codePointAt(0)) {
+			case 0x005c: // `\`
+			case 0x0023: // `#`
+				output += '\\';
+				output += char;
+				break;
+			default:
+				output += char;
+				break;
+		}
+	}
+
+	return output;
+}

package/packages/config-stylelint/node_modules/stylelint/lib/formatters/terminalLink.mjs

@@ -0,0 +1,21 @@
+import supportsHyperlinks from 'supports-hyperlinks';
+
+// ANSI escapes
+const OSC = '\u001B]';
+const BEL = '\u0007';
+const SEP = ';';
+
+/**
+ * @see https://gist.github.com/egmontkob/eb114294efbcd5adb1944c9f3cb5feda
+ *
+ * @param {string} text
+ * @param {string} url
+ * @returns {string}
+ */
+export default function terminalLink(text, url) {
+	if (supportsHyperlinks.stdout) {
+		return [OSC, '8', SEP, SEP, url, BEL, text, OSC, '8', SEP, SEP, BEL].join('');
+	}
+
+	return text;
+}

package/packages/config-stylelint/node_modules/stylelint/lib/formatters/unixFormatter.mjs

@@ -0,0 +1,32 @@
+import calcSeverityCounts from './calcSeverityCounts.mjs';
+import pluralize from '../utils/pluralize.mjs';
+import preprocessWarnings from './preprocessWarnings.mjs';
+
+/**
+ * @type {import('stylelint').Formatter}
+ */
+export default function unixFormatter(results) {
+	const counts = { error: 0, warning: 0 };
+	const lines = results.flatMap((result) => {
+		preprocessWarnings(result);
+
+		return result.warnings.map((warning) => {
+			calcSeverityCounts(warning.severity, counts);
+
+			return (
+				`${result.source}:${warning.line}:${warning.column}: ` +
+				`${warning.text} [${warning.severity}]`
+			);
+		});
+	});
+	const total = lines.length;
+	let output = lines.join('\n');
+
+	if (total > 0) {
+		output += `\n\n${total} ${pluralize('problem', total)}`;
+		output += ` (${counts.error} ${pluralize('error', counts.error)}`;
+		output += `, ${counts.warning} ${pluralize('warning', counts.warning)})\n`;
+	}
+
+	return output;
+}

package/packages/config-stylelint/node_modules/stylelint/lib/formatters/verboseFormatter.mjs

@@ -0,0 +1,175 @@
+import picocolors from 'picocolors';
+const { underline, red, yellow, dim, green } = picocolors;
+
+import pluralize from '../utils/pluralize.mjs';
+import stringFormatter from './stringFormatter.mjs';
+import terminalLink from './terminalLink.mjs';
+
+/** @import {Formatter, LintResult, RuleMeta, Severity, Warning} from 'stylelint' */
+
+/**
+ * @type {Formatter}
+ */
+export default function verboseFormatter(results, returnValue) {
+	let output = stringFormatter(results, returnValue);
+
+	if (output === '') {
+		output = '\n';
+	}
+
+	const ignoredCount = results.filter((result) => result.ignored).length;
+	const checkedDisplay = ignoredCount
+		? `${results.length - ignoredCount} of ${results.length}`
+		: results.length;
+
+	output += underline(`${checkedDisplay} ${pluralize('source', results.length)} checked\n`);
+
+	for (const result of results) {
+		let formatting = green;
+
+		if (result.errored) {
+			formatting = red;
+		} else if (result.warnings.length) {
+			formatting = yellow;
+		} else if (result.ignored) {
+			formatting = dim;
+		}
+
+		let sourceText = fileLink(result.source);
+
+		if (result.ignored) {
+			sourceText += ' (ignored)';
+		}
+
+		output += formatting(`  ${sourceText}\n`);
+	}
+
+	const warnings = results.flatMap((r) => r.warnings);
+
+	if (warnings.length === 0) {
+		output += '\n0 problems found\n';
+	} else {
+		const warningsBySeverity = groupBy(warnings, (w) => w.severity);
+
+		/**
+		 * @param {Severity} severity
+		 */
+		const printProblems = (severity) => {
+			const problems = warningsBySeverity[severity];
+
+			if (problems === undefined) return;
+
+			output += '\n';
+			output += underline(`${problems.length} ${pluralize(severity, problems.length)} found\n`);
+
+			const problemsByRule = groupBy(problems, (w) => w.rule);
+			const metadata = returnValue.ruleMetadata;
+
+			for (const [rule, list] of Object.entries(problemsByRule)) {
+				const meta = metadata[rule] || {};
+
+				let additional = [meta.fixable ? 'maybe fixable' : '', meta.deprecated ? 'deprecated' : '']
+					.filter(Boolean)
+					.join(', ');
+
+				additional = additional ? ` (${additional})` : '';
+
+				output += dim(`  ${ruleLink(rule, meta)}: ${list.length}${additional}\n`);
+			}
+		};
+
+		printProblems('error');
+		printProblems('warning');
+	}
+
+	const fixedRules = getFixedRules(results);
+
+	if (fixedRules.size) {
+		let lines = '\n';
+		let total = 0;
+
+		for (const [name, count] of fixedRules) {
+			const meta = returnValue.ruleMetadata[name];
+
+			lines += dim(`  ${ruleLink(name, meta)}: ${count}\n`);
+			total += count;
+		}
+
+		output += '\n';
+		output += underline(`${total} ${pluralize('problem', total)} fixed`);
+		output += lines;
+	}
+
+	return `${output}\n`;
+}
+
+/**
+ * @template {string} K
+ * @param {Warning[]} array
+ * @param {(w: Warning) => K} keyFn
+ * @returns {Record<K, Warning[]>}
+ * @todo replace by Object.groupBy once support for Node.js version 20 is dropped
+ */
+function groupBy(array, keyFn) {
+	/** @type {Record<string, Warning[]>} */
+	const result = {};
+
+	for (const item of array) {
+		const key = keyFn(item);
+		let warnings = result[key];
+
+		if (warnings === undefined) {
+			result[key] = warnings = [];
+		}
+
+		warnings.push(item);
+	}
+
+	return result;
+}
+
+/**
+ * @param {string | undefined} source
+ * @returns {string}
+ */
+function fileLink(source) {
+	if (!source || source.startsWith('<')) {
+		return `${source}`;
+	}
+
+	return terminalLink(source, `file://${source}`);
+}
+
+/**
+ * @param {string} rule
+ * @param {Partial<RuleMeta> | undefined} metadata
+ * @returns {string}
+ */
+function ruleLink(rule, metadata) {
+	if (metadata && metadata.url) {
+		return terminalLink(rule, metadata.url);
+	}
+
+	return rule;
+}
+
+/** @param {LintResult[]} results */
+function getFixedRules(results) {
+	/** @type {Map<string, number>} */
+	const rules = new Map();
+
+	for (const { _postcssResult } of results) {
+		if (!_postcssResult) continue; // CSS syntax error
+
+		const {
+			stylelint: { fixersData },
+		} = _postcssResult;
+		const entries = Object.entries(fixersData);
+
+		for (const [ruleName, count] of entries) {
+			if (count) rules.set(ruleName, count);
+		}
+	}
+
+	return rules;
+}

package/packages/config-stylelint/node_modules/stylelint/lib/getConfigForFile.mjs

@@ -0,0 +1,110 @@
+import { join } from 'node:path';
+
+import { ConfigurationError } from './utils/errors.mjs';
+import { augmentConfigFull } from './augmentConfig.mjs';
+import normalizeFilePath from './utils/normalizeFilePath.mjs';
+
+/** @import {CosmiconfigResult, InternalApi} from 'stylelint' */
+
+/**
+ * Creates a cache key for the augmented config cache.
+ *
+ * @param {string} configPath Path to the config file
+ * @param {string} filePath Path to the target file
+ * @returns {string}
+ */
+function getAugmentedConfigCacheKey(configPath, filePath) {
+	return `${configPath || 'no-config'}::${filePath || 'no-file'}`;
+}
+
+/**
+ * Get a configuration by the following way:
+ *
+ * 1. If the `config` option is given, it's returned.
+ * 2. If the `configFile` option is given, the file's config is returned.
+ * 3. If the options above are not given, a config found in `searchPath` is returned.
+ *
+ * @param {Object} options
+ * @param {InternalApi} options.stylelint
+ * @param {string} [options.searchPath] - Defaults to `cwd`.
+ * @param {string} [options.filePath] - For applying overrides.
+ * @param {boolean} [options.failIfNoConfig=true] - Throws an error if a config is not found.
+ * @returns {Promise<CosmiconfigResult>}
+ */
+export default async function getConfigForFile({
+	stylelint,
+	searchPath = stylelint._options.cwd,
+	filePath,
+	failIfNoConfig = true,
+}) {
+	const optionsConfig = stylelint._options.config;
+	const cwd = stylelint._options.cwd;
+
+	if (optionsConfig) {
+		const filePathAsCacheKey = normalizeFilePath(filePath ?? '');
+		/** @type {Map<string, CosmiconfigResult>} */
+		const cachedForFiles = stylelint._specifiedConfigCache.get(optionsConfig) ?? new Map();
+		const cached = cachedForFiles.get(filePathAsCacheKey);
+
+		if (cached) {
+			return cached;
+		}
+
+		const augmentedResult = await augmentConfigFull(stylelint, filePath, {
+			config: optionsConfig,
+			// Add the extra path part so that we can get the directory without being
+			// confused
+			filepath: join(cwd, 'argument-config'),
+		});
+
+		cachedForFiles.set(filePathAsCacheKey, augmentedResult);
+		stylelint._specifiedConfigCache.set(optionsConfig, cachedForFiles);
+
+		return augmentedResult;
+	}
+
+	const configExplorer = stylelint._configExplorer;
+
+	const configFile = stylelint._options.configFile;
+
+	// First, discover the raw config, cached by cosmiconfig.
+	let rawConfig = configFile
+		? await configExplorer.load(configFile)
+		: await configExplorer.search(searchPath);
+
+	if (!rawConfig) {
+		rawConfig = await configExplorer.search(cwd);
+	}
+
+	if (!rawConfig && failIfNoConfig) {
+		throw new ConfigurationError(
+			`No configuration provided${searchPath ? ` for ${searchPath}` : ''}`,
+		);
+	}
+
+	if (!rawConfig) {
+		return rawConfig;
+	}
+
+	// Check the augmented config cache.
+	const cacheKey = getAugmentedConfigCacheKey(
+		rawConfig.filepath,
+		filePath ? normalizeFilePath(filePath) : '',
+	);
+
+	const cachedAugmented = stylelint._augmentedConfigCache.get(cacheKey);
+
+	if (cachedAugmented) {
+		return cachedAugmented;
+	}
+
+	// Perform full augmentation.
+	const augmentedResult = await augmentConfigFull(stylelint, filePath, rawConfig);
+
+	// Cache the augmented result.
+	if (augmentedResult) {
+		stylelint._augmentedConfigCache.set(cacheKey, augmentedResult);
+	}
+
+	return augmentedResult;
+}

package/packages/config-stylelint/node_modules/stylelint/lib/getPostcssResult.mjs

@@ -0,0 +1,131 @@
+import { readFile } from 'node:fs/promises';
+
+import postcss from 'postcss';
+
+import dynamicImport from './utils/dynamicImport.mjs';
+import getModulePath from './utils/getModulePath.mjs';
+import normalizeFilePath from './utils/normalizeFilePath.mjs';
+import normalizeFixMode from './utils/normalizeFixMode.mjs';
+
+/** @import {Result, Syntax} from 'postcss' */
+/** @import {CustomSyntax, GetPostcssOptions, InternalApi as StylelintInternalApi} from 'stylelint' */
+
+const postcssProcessor = postcss();
+
+/**
+ * @param {StylelintInternalApi} stylelint
+ * @param {GetPostcssOptions} options
+ *
+ * @returns {Promise<Result>}
+ */
+export default async function getPostcssResult(stylelint, { customSyntax, filePath, code } = {}) {
+	const normalizedPath = filePath ? normalizeFilePath(filePath) : undefined;
+	const cached = normalizedPath ? stylelint._postcssResultCache.get(normalizedPath) : undefined;
+
+	if (cached) {
+		return cached;
+	}
+
+	const fix = normalizeFixMode(stylelint._options.fix);
+	const syntax = await (customSyntax
+		? getCustomSyntax(customSyntax, stylelint._options.configBasedir)
+		: cssSyntax(fix === 'lax'));
+
+	const postcssOptions = {
+		from: filePath,
+		syntax,
+	};
+
+	/** @type {string | undefined} */
+	let getCode;
+
+	if (code !== undefined) {
+		getCode = code;
+	} else if (filePath) {
+		getCode = await readFile(filePath, 'utf8');
+	}
+
+	if (getCode === undefined) {
+		throw new Error('code or filePath required');
+	}
+
+	const postcssResult = await postcssProcessor.process(getCode, postcssOptions).async();
+
+	if (normalizedPath) {
+		stylelint._postcssResultCache.set(normalizedPath, postcssResult);
+	}
+
+	return postcssResult;
+}
+
+/**
+ * @param {CustomSyntax} customSyntax
+ * @param {string | undefined} basedir
+ * @returns {Promise<Syntax>}
+ */
+async function getCustomSyntax(customSyntax, basedir) {
+	if (typeof customSyntax === 'string') {
+		const customSyntaxLookup = basedir ? getModulePath(basedir, customSyntax) : customSyntax;
+
+		let resolved;
+
+		try {
+			resolved = await dynamicImport(customSyntaxLookup);
+			resolved = resolved.default ?? resolved;
+		} catch (error) {
+			if (
+				error &&
+				typeof error === 'object' &&
+				'code' in error &&
+				// TODO: Remove 'MODULE_NOT_FOUND' when we drop the CommonJS support.
+				// See https://nodejs.org/api/errors.html#module_not_found
+				(error.code === 'MODULE_NOT_FOUND' || error.code === 'ERR_MODULE_NOT_FOUND') &&
+				'message' in error &&
+				typeof error.message === 'string' &&
+				error.message.includes(customSyntax)
+			) {
+				throw new Error(
+					`Cannot resolve custom syntax module "${customSyntax}". Check that module "${customSyntax}" is available and spelled correctly.\n\nCaused by: ${error}`,
+					{ cause: error },
+				);
+			}
+
+			throw error;
+		}
+
+		/*
+		 * PostCSS allows for syntaxes that only contain a parser, however,
+		 * it then expects the syntax to be set as the `parse` option.
+		 */
+		if (!resolved.parse) {
+			resolved = {
+				parse: resolved,
+				stringify: postcss.stringify,
+			};
+		}
+
+		return resolved;
+	}
+
+	if (typeof customSyntax === 'object' || typeof customSyntax === 'function') {
+		if (typeof customSyntax.parse === 'function') {
+			return { ...customSyntax };
+		}
+
+		throw new TypeError(
+			'An object provided to the "customSyntax" option must have a "parse" property. Ensure the "parse" property exists and its value is a function.',
+		);
+	}
+
+	throw new Error('Custom syntax must be a string or a Syntax object');
+}
+
+/**
+ * @param {boolean} fix
+ * @returns {Promise<Syntax>}
+ */
+async function cssSyntax(fix) {
+	const parse = await (fix ? import('postcss-safe-parser').then((m) => m.default) : postcss.parse);
+
+	return { parse, stringify: postcss.stringify };
+}

package/packages/config-stylelint/node_modules/stylelint/lib/index.mjs

@@ -0,0 +1,38 @@
+import checkAgainstRule from './utils/checkAgainstRule.mjs';
+import createPlugin from './createPlugin.mjs';
+import createStylelint from './createStylelint.mjs';
+import formatters from './formatters/index.mjs';
+import { longhandSubPropertiesOfShorthandProperties } from './reference/properties.mjs';
+import postcssPlugin from './postcssPlugin.mjs';
+import report from './utils/report.mjs';
+import resolveConfig from './resolveConfig.mjs';
+import ruleMessages from './utils/ruleMessages.mjs';
+import rules from './rules/index.mjs';
+import standalone from './standalone.mjs';
+import validateOptions from './utils/validateOptions.mjs';
+
+/** @type {import('stylelint').PublicApi} */
+const stylelint = Object.assign(postcssPlugin, {
+	lint: standalone,
+	rules,
+	formatters,
+	createPlugin,
+	resolveConfig,
+	_createLinter: createStylelint,
+	utils: {
+		report,
+		ruleMessages,
+		validateOptions,
+		checkAgainstRule,
+	},
+	reference: {
+		longhandSubPropertiesOfShorthandProperties,
+	},
+});
+
+export default stylelint;
+
+// Special `require(ESM)` default export for CommonJS interoperability
+// See: https://joyeecheung.github.io/blog/2025/12/30/require-esm-in-node-js-from-experiment-to-stability/
+// See: https://joyeecheung.github.io/blog/2025/12/30/require-esm-in-node-js-implementers-tales/
+export { stylelint as 'module.exports' };

package/packages/config-stylelint/node_modules/stylelint/lib/invalidScopeDisables.mjs

@@ -0,0 +1,41 @@
+import { RULE_NAME_ALL } from './constants.mjs';
+
+import optionsMatches from './utils/optionsMatches.mjs';
+import reportCommentProblem from './utils/reportCommentProblem.mjs';
+import validateDisableSettings from './validateDisableSettings.mjs';
+
+/**
+ * @param {import('stylelint').PostcssResult} postcssResult
+ * @returns {void}
+ */
+export default function invalidScopeDisables(postcssResult) {
+	const [enabled, options] = validateDisableSettings(postcssResult, 'reportInvalidScopeDisables');
+
+	if (!options) return;
+
+	const configRules = postcssResult.stylelint.config?.rules;
+
+	if (!configRules) return;
+
+	const usedRules = new Set(Object.keys(configRules));
+
+	usedRules.add(RULE_NAME_ALL);
+
+	for (const [rule, ruleRanges] of Object.entries(postcssResult.stylelint.disabledRanges)) {
+		if (usedRules.has(rule)) continue;
+
+		if (enabled === optionsMatches(options, 'except', rule)) continue;
+
+		for (const range of ruleRanges) {
+			if (!range.strictStart && !range.strictEnd) continue;
+
+			reportCommentProblem({
+				rule: '--report-invalid-scope-disables',
+				message: `Rule "${rule}" isn't enabled`,
+				severity: options.severity,
+				node: range.node,
+				postcssResult,
+			});
+		}
+	}
+}

package/packages/config-stylelint/node_modules/stylelint/lib/isPathIgnored.mjs

@@ -0,0 +1,48 @@
+import { isAbsolute, relative, resolve } from 'node:path';
+import micromatch from 'micromatch';
+
+import filterFilePaths from './utils/filterFilePaths.mjs';
+import getConfigForFile from './getConfigForFile.mjs';
+import getFileIgnorer from './utils/getFileIgnorer.mjs';
+import normalizeFilePath from './utils/normalizeFilePath.mjs';
+
+/**
+ * To find out if a path is ignored, we need to load the config,
+ * which may have an ignoreFiles property. We then check the path
+ * against these.
+ * @param {import('stylelint').InternalApi} stylelint
+ * @param {string} [filePath]
+ * @returns {Promise<boolean>}
+ */
+export default async function isPathIgnored(stylelint, filePath) {
+	if (!filePath) {
+		return false;
+	}
+
+	const cwd = stylelint._options.cwd;
+	const result = await getConfigForFile({ stylelint, searchPath: filePath, filePath });
+
+	if (!result) {
+		return true;
+	}
+
+	const ignoreFiles = result.config.ignoreFiles || [];
+	const absoluteFilePath = isAbsolute(filePath) ? filePath : resolve(cwd, filePath);
+
+	const normalizedAbsolutePath = normalizeFilePath(absoluteFilePath);
+	const normalizedIgnoreFiles = ignoreFiles.map((/** @type {string} */ glob) =>
+		normalizeFilePath(String(glob)),
+	);
+
+	if (micromatch([normalizedAbsolutePath], normalizedIgnoreFiles).length > 0) {
+		return true;
+	}
+
+	const ignorer = getFileIgnorer(stylelint._options);
+
+	if (filterFilePaths(ignorer, [relative(cwd, absoluteFilePath)]).length === 0) {
+		return true;
+	}
+
+	return false;
+}