@alexlit/lint-kit 182.1.0 → 182.2.0

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

@@ -0,0 +1,25 @@
+export const DEFAULT_CACHE_LOCATION = './.stylelintcache';
+export const CACHE_STRATEGY_METADATA = 'metadata';
+export const CACHE_STRATEGY_CONTENT = 'content';
+export const DEFAULT_CACHE_STRATEGY = CACHE_STRATEGY_METADATA;
+
+export const DEFAULT_IGNORE_FILENAME = '.stylelintignore';
+
+export const DEFAULT_SUPPRESSION_FILENAME = 'stylelint-suppressions.json';
+
+export const DEFAULT_FORMATTER = 'string';
+
+// NOTE: Partially based on `sysexits.h`.
+export const EXIT_CODE_SUCCESS = 0;
+export const EXIT_CODE_FATAL_ERROR = 1;
+export const EXIT_CODE_LINT_PROBLEM = 2;
+export const EXIT_CODE_INVALID_USAGE = 64;
+export const EXIT_CODE_INVALID_CONFIG = 78;
+
+export const RULE_NAME_ALL = 'all';
+
+export const SEVERITY_ERROR = 'error';
+export const SEVERITY_WARNING = 'warning';
+export const DEFAULT_SEVERITY = SEVERITY_ERROR;
+
+export const DEFAULT_FIX_MODE = 'strict';

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

@@ -0,0 +1,114 @@
+import { SEVERITY_ERROR } from './constants.mjs';
+import process from 'node:process';
+
+/** @import {LintResult as StylelintResult, PostcssResult} from 'stylelint' */
+
+/**
+ * @param {PostcssResult} [postcssResult]
+ * @param {import('stylelint').CssSyntaxError} [cssSyntaxError]
+ * @returns {StylelintResult}
+ */
+export default function createPartialStylelintResult(postcssResult, cssSyntaxError) {
+	/** @type {StylelintResult} */
+	let stylelintResult;
+	/** @type {string | undefined} */
+	let source;
+
+	if (postcssResult && postcssResult.root) {
+		if (postcssResult.root.source) {
+			source = postcssResult.root.source.input.file;
+
+			if (!source && 'id' in postcssResult.root.source.input) {
+				source = postcssResult.root.source.input.id;
+			}
+		}
+
+		// @ts-expect-error -- TS2339: Property 'noDeprecation' does not exist on type 'Process'.
+		// https://github.com/nodejs/node/blob/main/doc/api/process.md#processnodeprecation
+		const includeDeprecations = !process.noDeprecation;
+		const deprecationMessages = includeDeprecations
+			? postcssResult.messages.filter((message) => message.stylelintType === 'deprecation')
+			: [];
+		const deprecations = deprecationMessages.map((deprecationMessage) => {
+			return {
+				text: deprecationMessage.text,
+				reference: deprecationMessage.stylelintReference,
+			};
+		});
+
+		const invalidOptionMessages = postcssResult.messages.filter(
+			(message) => message.stylelintType === 'invalidOption',
+		);
+		const invalidOptionWarnings = invalidOptionMessages.map((invalidOptionMessage) => {
+			return {
+				text: invalidOptionMessage.text,
+			};
+		});
+
+		const parseErrors = postcssResult.messages.filter(
+			(message) => message.stylelintType === 'parseError',
+		);
+
+		// Remove deprecation warnings, invalid options, and parse errors from the messages
+		postcssResult.messages = postcssResult.messages.filter(
+			(message) =>
+				message.stylelintType !== 'deprecation' &&
+				message.stylelintType !== 'invalidOption' &&
+				message.stylelintType !== 'parseError',
+		);
+
+		// This defines the stylelint result object that formatters receive
+		stylelintResult = {
+			source,
+			deprecations,
+			invalidOptionWarnings,
+			// @ts-expect-error -- TS2322: Type 'Message[]' is not assignable to type '(Warning & { stylelintType: string; })[]'.
+			parseErrors,
+			errored: postcssResult.stylelint.stylelintError,
+			warnings: postcssResult.messages.map((message) => {
+				return {
+					line: message.line,
+					column: message.column,
+					endLine: message.endLine,
+					endColumn: message.endColumn,
+					fix: message.fix,
+					rule: message.rule,
+					severity: message.severity,
+					text: message.text,
+					url: message.url,
+				};
+			}),
+			ignored: postcssResult.stylelint.ignored,
+			_postcssResult: postcssResult,
+		};
+	} else if (cssSyntaxError) {
+		if (cssSyntaxError.name !== 'CssSyntaxError') {
+			throw cssSyntaxError;
+		}
+
+		stylelintResult = {
+			source: cssSyntaxError.file || '<input css 1>',
+			deprecations: [],
+			invalidOptionWarnings: [],
+			parseErrors: [],
+			errored: true,
+			warnings: [
+				{
+					line: cssSyntaxError.line,
+					column: cssSyntaxError.column,
+					endLine: cssSyntaxError.endLine,
+					endColumn: cssSyntaxError.endColumn,
+					rule: cssSyntaxError.name,
+					severity: SEVERITY_ERROR,
+					text: `${cssSyntaxError.reason} (${cssSyntaxError.name})`,
+				},
+			],
+		};
+	} else {
+		throw new Error(
+			'createPartialStylelintResult must be called with either postcssResult or CssSyntaxError',
+		);
+	}
+
+	return stylelintResult;
+}

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

@@ -0,0 +1,9 @@
+/**
+ * @type {import('stylelint').PublicApi['createPlugin']}
+ */
+export default function createPlugin(ruleName, rule) {
+	return {
+		ruleName,
+		rule,
+	};
+}

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

@@ -0,0 +1,37 @@
+import process from 'node:process';
+
+import { cosmiconfig } from 'cosmiconfig';
+
+import FileCache from './utils/FileCache.mjs';
+import { augmentConfigExtended } from './augmentConfig.mjs';
+
+const IS_TEST = process.env.NODE_ENV === 'test';
+const STOP_DIR = IS_TEST ? process.cwd() : undefined;
+
+/**
+ * @type {import('stylelint').PublicApi['_createLinter']}
+ */
+export default function createStylelint(options = {}) {
+	const cwd = options.cwd || process.cwd();
+
+	return {
+		_options: { ...options, cwd },
+
+		_extendExplorer: cosmiconfig('', {
+			transform: augmentConfigExtended(cwd),
+			stopDir: STOP_DIR,
+			searchStrategy: 'global', // for backward compatibility
+		}),
+
+		_configExplorer: cosmiconfig('stylelint', {
+			stopDir: STOP_DIR,
+			searchStrategy: 'global', // for backward compatibility
+		}),
+
+		_specifiedConfigCache: new Map(),
+		_augmentedConfigCache: new Map(),
+		_postcssResultCache: new Map(),
+		_compiledOverridesCache: new Map(),
+		_fileCache: new FileCache(options.cacheLocation, options.cacheStrategy, cwd),
+	};
+}

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

@@ -0,0 +1,51 @@
+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 descriptionlessDisables(postcssResult) {
+	const [enabled, options] = validateDisableSettings(
+		postcssResult,
+		'reportDescriptionlessDisables',
+	);
+
+	if (!options) return;
+
+	/** @type {Set<import('postcss').Node>} */
+	const alreadyReported = new Set();
+
+	for (const [rule, ruleRanges] of Object.entries(postcssResult.stylelint.disabledRanges)) {
+		for (const range of ruleRanges) {
+			if (range.description) continue;
+
+			const node = range.node;
+
+			if (alreadyReported.has(node)) continue;
+
+			if (enabled === optionsMatches(options, 'except', rule)) {
+				// An 'all' rule will get copied for each individual rule. If the
+				// configuration is `[false, {except: ['specific-rule']}]`, we
+				// don't want to report the copies that match except, so we record
+				// the comment as already reported.
+				if (!enabled && rule === RULE_NAME_ALL) alreadyReported.add(node);
+
+				continue;
+			}
+
+			alreadyReported.add(node);
+
+			reportCommentProblem({
+				rule: '--report-descriptionless-disables',
+				message: `Disable for "${rule}" is missing a description`,
+				severity: options.severity,
+				node,
+				postcssResult,
+			});
+		}
+	}
+}

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

@@ -0,0 +1,21 @@
+import { SEVERITY_ERROR, SEVERITY_WARNING } from '../constants.mjs';
+
+/**
+ * @import {Severity} from 'stylelint'
+ *
+ * @param {Severity} severity
+ * @param {Record<Severity, number>} counts
+ * @returns {void}
+ */
+export default function calcSeverityCounts(severity, counts) {
+	switch (severity) {
+		case SEVERITY_ERROR:
+			counts.error += 1;
+			break;
+		case SEVERITY_WARNING:
+			counts.warning += 1;
+			break;
+		default:
+			throw new Error(`Unknown severity: "${severity}"`);
+	}
+}

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

@@ -0,0 +1,23 @@
+import preprocessWarnings from './preprocessWarnings.mjs';
+
+/**
+ * @type {import('stylelint').Formatter}
+ */
+export default function compactFormatter(results) {
+	const lines = results.flatMap((result) => {
+		const { warnings } = preprocessWarnings(result);
+
+		return warnings.map(
+			(warning) =>
+				`${result.source}: ` +
+				`line ${warning.line}, ` +
+				`col ${warning.column}, ` +
+				`${warning.severity} - ` +
+				`${warning.text}`,
+		);
+	});
+
+	lines.push('');
+
+	return lines.join('\n');
+}

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

@@ -0,0 +1,23 @@
+/** @type {import('stylelint').PublicApi['formatters']} */
+const formatters = {
+	get compact() {
+		return import('./compactFormatter.mjs').then((m) => m.default);
+	},
+	get json() {
+		return import('./jsonFormatter.mjs').then((m) => m.default);
+	},
+	get string() {
+		return import('./stringFormatter.mjs').then((m) => m.default);
+	},
+	get tap() {
+		return import('./tapFormatter.mjs').then((m) => m.default);
+	},
+	get unix() {
+		return import('./unixFormatter.mjs').then((m) => m.default);
+	},
+	get verbose() {
+		return import('./verboseFormatter.mjs').then((m) => m.default);
+	},
+};
+
+export default formatters;

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

@@ -0,0 +1,10 @@
+/**
+ * Omit any properties starting with `_`, which are fake-private
+ *
+ * @type {import('stylelint').Formatter}
+ */
+export default function jsonFormatter(results) {
+	return JSON.stringify(results, (key, value) => {
+		return key[0] === '_' ? undefined : value;
+	});
+}

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

@@ -0,0 +1,74 @@
+import { DEFAULT_SEVERITY, SEVERITY_ERROR } from '../constants.mjs';
+
+/** @import {LintResult} from 'stylelint' */
+/** @typedef {LintResult['parseErrors'][0]} ParseError */
+/** @typedef {LintResult['warnings'][0]} Warning */
+/** @typedef {Warning['severity']} Severity */
+
+/**
+ * Preprocess warnings in a given lint result.
+ * Note that this function has a side-effect.
+ *
+ * @param {LintResult} result
+ * @returns {LintResult}
+ */
+export default function preprocessWarnings(result) {
+	for (const error of result.parseErrors || []) {
+		result.warnings.push(parseErrorToWarning(error));
+	}
+
+	for (const warning of result.warnings) {
+		warning.severity = normalizeSeverity(warning);
+	}
+
+	result.warnings.sort(byLocationOrder);
+
+	return result;
+}
+
+/**
+ * @param {ParseError} error
+ * @returns {Warning}
+ */
+function parseErrorToWarning(error) {
+	return {
+		line: error.line,
+		column: error.column,
+		rule: error.stylelintType,
+		severity: SEVERITY_ERROR,
+		text: `${error.text} (${error.stylelintType})`,
+	};
+}
+
+/**
+ * @param {Warning} warning
+ * @returns {Severity}
+ */
+function normalizeSeverity(warning) {
+	// NOTE: Plugins may add a warning without severity, for example,
+	// by directly using the PostCSS `Result#warn()` API.
+	return warning.severity || DEFAULT_SEVERITY;
+}
+
+/**
+ * @param {Warning} a
+ * @param {Warning} b
+ * @returns {number}
+ */
+function byLocationOrder(a, b) {
+	// positionless first
+	if (!a.line && b.line) return -1;
+
+	// positionless first
+	if (a.line && !b.line) return 1;
+
+	if (a.line < b.line) return -1;
+
+	if (a.line > b.line) return 1;
+
+	if (a.column < b.column) return -1;
+
+	if (a.column > b.column) return 1;
+
+	return 0;
+}

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

@@ -0,0 +1,308 @@
+import { relative, sep } from 'node:path';
+import process from 'node:process';
+
+import { getBorderCharacters, table } from 'table';
+import picocolors from 'picocolors';
+import stringWidth from 'string-width';
+
+import { assertNumber } from '../utils/validateTypes.mjs';
+import calcSeverityCounts from './calcSeverityCounts.mjs';
+import isUnicodeSupported from '../utils/isUnicodeSupported.mjs';
+import pluralize from '../utils/pluralize.mjs';
+import preprocessWarnings from './preprocessWarnings.mjs';
+import terminalLink from './terminalLink.mjs';
+
+const { yellow, dim, underline, blue, red, green } = picocolors;
+
+const NON_ASCII_PATTERN = /\P{ASCII}/u;
+const MARGIN_WIDTHS = 9;
+
+/**
+ * @param {string} s
+ * @returns {string}
+ */
+function identity(s) {
+	return s;
+}
+
+const levelColors = {
+	info: blue,
+	warning: yellow,
+	error: red,
+	success: identity,
+};
+
+const supportsUnicode = isUnicodeSupported();
+
+const symbols = {
+	info: blue(supportsUnicode ? 'ℹ' : 'i'),
+	warning: yellow(supportsUnicode ? '⚠' : '‼'),
+	error: red(supportsUnicode ? '✖' : '×'),
+	success: green(supportsUnicode ? '✔' : '√'),
+};
+
+/**
+ * @param {import('stylelint').LintResult[]} results
+ * @returns {string}
+ */
+function deprecationsFormatter(results) {
+	const allDeprecationWarnings = results.flatMap((result) => result.deprecations || []);
+
+	if (allDeprecationWarnings.length === 0) {
+		return '';
+	}
+
+	const seenText = new Set();
+	const lines = [];
+
+	for (const { text, reference } of allDeprecationWarnings) {
+		if (seenText.has(text)) continue;
+
+		seenText.add(text);
+
+		let line = ` ${dim('-')} ${text}`;
+
+		if (reference) {
+			line += dim(` See: ${underline(reference)}`);
+		}
+
+		lines.push(line);
+	}
+
+	return ['', yellow('Deprecation warnings:'), ...lines, ''].join('\n');
+}
+
+/**
+ * @param {import('stylelint').LintResult[]} results
+ * @returns {string}
+ */
+function invalidOptionsFormatter(results) {
+	const allInvalidOptionWarnings = results.flatMap((result) =>
+		(result.invalidOptionWarnings || []).map((warning) => warning.text),
+	);
+	const uniqueInvalidOptionWarnings = [...new Set(allInvalidOptionWarnings)];
+
+	return uniqueInvalidOptionWarnings.reduce((output, warning) => {
+		output += red('Invalid Option: ');
+		output += warning;
+
+		return `${output}\n`;
+	}, '\n');
+}
+
+/**
+ * @param {string} fromValue
+ * @param {string} cwd
+ * @returns {string}
+ */
+function logFrom(fromValue, cwd) {
+	if (fromValue.startsWith('<')) {
+		return underline(fromValue);
+	}
+
+	const filePath = relative(cwd, fromValue).split(sep).join('/');
+
+	return terminalLink(filePath, `file://${fromValue}`);
+}
+
+/**
+ * @param {{[k: number]: number}} columnWidths
+ * @returns {number}
+ */
+function getMessageWidth(columnWidths) {
+	const width = columnWidths[3];
+
+	assertNumber(width);
+
+	if (!process.stdout.isTTY) {
+		return width;
+	}
+
+	const availableWidth = process.stdout.columns < 80 ? 80 : process.stdout.columns;
+	const fullWidth = Object.values(columnWidths).reduce((a, b) => a + b);
+
+	// If there is no reason to wrap the text, we won't align the last column to the right
+	if (availableWidth > fullWidth + MARGIN_WIDTHS) {
+		return width;
+	}
+
+	return availableWidth - (fullWidth - width + MARGIN_WIDTHS);
+}
+
+/**
+ * @param {import('stylelint').Warning[]} messages
+ * @param {string} source
+ * @param {string} cwd
+ * @returns {string}
+ */
+function formatter(messages, source, cwd) {
+	if (messages.length === 0) return '';
+
+	/**
+	 * Create a list of column widths, needed to calculate
+	 * the size of the message column and if needed wrap it.
+	 * @type {{[k: string]: number}}
+	 */
+	const columnWidths = { 0: 1, 1: 1, 2: 1, 3: 1, 4: 1 };
+
+	/**
+	 * @param {[string, string, string, string, string]} columns
+	 * @returns {[string, string, string, string, string]}
+	 */
+	function calculateWidths(columns) {
+		for (const [key, value] of Object.entries(columns)) {
+			const normalisedValue = value ? value.toString() : value;
+			const width = columnWidths[key];
+
+			assertNumber(width);
+			columnWidths[key] = Math.max(width, stringWidth(normalisedValue));
+		}
+
+		return columns;
+	}
+
+	let output = '\n';
+
+	if (source) {
+		output += `${logFrom(source, cwd)}\n`;
+	}
+
+	/**
+	 * @param {import('stylelint').Warning} message
+	 * @returns {string}
+	 */
+	function formatMessageText(message) {
+		let result = message.text;
+
+		result = result
+			// Remove all control characters (newline, tab and etc)
+			.replace(/[\u0001-\u001A]+/g, ' ') // eslint-disable-line no-control-regex
+			.replace(/\.$/, '');
+
+		const ruleString = ` (${message.rule})`;
+
+		if (result.endsWith(ruleString)) {
+			result = result.slice(0, result.lastIndexOf(ruleString));
+		}
+
+		return result;
+	}
+
+	const cleanedMessages = messages.map((message) => {
+		const { line, column, severity } = message;
+		/**
+		 * @type {[string, string, string, string, string]}
+		 */
+		const row = [
+			line ? line.toString() : '',
+			column ? column.toString() : '',
+			symbols[severity] ? levelColors[severity](symbols[severity]) : severity,
+			formatMessageText(message),
+			dim(message.rule || ''),
+		];
+
+		calculateWidths(row);
+
+		return row;
+	});
+
+	const messageWidth = getMessageWidth(columnWidths);
+	const hasNonAsciiChar = messages.some((msg) => NON_ASCII_PATTERN.test(msg.text));
+
+	output += table(cleanedMessages, {
+		border: getBorderCharacters('void'),
+		columns: {
+			0: { alignment: 'right', width: columnWidths[0], paddingRight: 0, paddingLeft: 2 },
+			1: { alignment: 'left', width: columnWidths[1] },
+			2: { alignment: 'center', width: columnWidths[2] },
+			3: {
+				alignment: 'left',
+				width: messageWidth,
+				wrapWord: messageWidth > 1 && !hasNonAsciiChar,
+			},
+			4: { alignment: 'left', width: columnWidths[4], paddingRight: 0 },
+		},
+		drawHorizontalLine: () => false,
+	})
+		.split('\n')
+		.map((el) => el.replace(/(\d+)\s+(\d+)/, (_m, p1, p2) => dim(`${p1}:${p2}`)).trimEnd())
+		.join('\n');
+
+	return output;
+}
+
+/**
+ * @type {import('stylelint').Formatter}
+ */
+export default function stringFormatter(results, returnValue) {
+	let output = invalidOptionsFormatter(results);
+
+	output += deprecationsFormatter(results);
+
+	const resultCounts = { error: 0, warning: 0 };
+	const fixableCounts = { error: 0, warning: 0 };
+
+	output = results.reduce((accum, result) => {
+		preprocessWarnings(result);
+
+		accum += formatter(
+			result.warnings,
+			result.source || '',
+			(returnValue && returnValue.cwd) || process.cwd(),
+		);
+
+		for (const warning of result.warnings) {
+			calcSeverityCounts(warning.severity, resultCounts);
+			const fixable = returnValue.ruleMetadata?.[warning.rule]?.fixable;
+
+			if (fixable === true) {
+				calcSeverityCounts(warning.severity, fixableCounts);
+			}
+		}
+
+		return accum;
+	}, output);
+
+	// Ensure consistent padding
+	output = output.trim();
+
+	if (output !== '') {
+		output = `\n${output}\n`;
+
+		const errorCount = resultCounts.error;
+		const warningCount = resultCounts.warning;
+		const total = errorCount + warningCount;
+
+		if (total > 0) {
+			const error = red(`${errorCount} ${pluralize('error', errorCount)}`);
+			const warning = yellow(`${warningCount} ${pluralize('warning', warningCount)}`);
+			const symbol = errorCount > 0 ? symbols.error : symbols.warning;
+
+			output += `\n${symbol} ${total} ${pluralize('problem', total)} (${error}, ${warning})`;
+		}
+
+		const fixErrorCount = fixableCounts.error;
+		const fixWarningCount = fixableCounts.warning;
+
+		if (fixErrorCount > 0 || fixWarningCount > 0) {
+			let fixErrorText;
+			let fixWarningText;
+
+			if (fixErrorCount > 0) {
+				fixErrorText = `${fixErrorCount} ${pluralize('error', fixErrorCount)}`;
+			}
+
+			if (fixWarningCount > 0) {
+				fixWarningText = `${fixWarningCount} ${pluralize('warning', fixWarningCount)}`;
+			}
+
+			const countText = [fixErrorText, fixWarningText].filter(Boolean).join(' and ');
+
+			output += `\n  ${countText} potentially fixable with the "--fix" option.`;
+		}
+
+		output += '\n\n';
+	}
+
+	return output;
+}