@alexlit/lint-kit 183.4.0 → 183.6.0

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

@@ -0,0 +1,383 @@
+import { isAbsolute, join, normalize, relative } from 'node:path';
+import process from 'node:process';
+
+import createDebug from 'debug';
+const debug = createDebug('stylelint:standalone');
+
+import fastGlob from 'fast-glob';
+import { globby } from 'globby';
+import micromatch from 'micromatch';
+import normalizePath from 'normalize-path';
+import writeFileAtomic from 'write-file-atomic';
+
+import {
+	AllFilesIgnoredError,
+	NoFilesFoundError,
+	SuppressionFileNotFoundError,
+} from './utils/errors.mjs';
+import { assertString, isString } from './utils/validateTypes.mjs';
+import { DEFAULT_SUPPRESSION_FILENAME } from './constants.mjs';
+import { SuppressionsService } from './utils/suppressionsService.mjs';
+import createPartialStylelintResult from './createPartialStylelintResult.mjs';
+import createStylelint from './createStylelint.mjs';
+import { emitExperimentalWarning } from './utils/emitWarning.mjs';
+import filterFilePaths from './utils/filterFilePaths.mjs';
+import getConfigForFile from './getConfigForFile.mjs';
+import getFileIgnorer from './utils/getFileIgnorer.mjs';
+import getFormatter from './utils/getFormatter.mjs';
+import lintSource from './lintSource.mjs';
+import normalizeFixMode from './utils/normalizeFixMode.mjs';
+import pathExists from './utils/pathExists.mjs';
+import prepareReturnValue from './prepareReturnValue.mjs';
+import resolveFilePath from './utils/resolveFilePath.mjs';
+import resolveOptionValue from './utils/resolveOptionValue.mjs';
+import toPath from './utils/toPath.mjs';
+
+const ALWAYS_IGNORED_GLOBS = ['**/node_modules/**'];
+
+/** @import {InternalApi, LintResult} from 'stylelint' */
+
+/**
+ * @type {import('stylelint').PublicApi['lint']}
+ */
+export default async function standalone({
+	allowEmptyInput,
+	cache,
+	cacheLocation,
+	cacheStrategy,
+	code,
+	codeFilename,
+	config,
+	configBasedir,
+	configFile,
+	customSyntax,
+	cwd = process.cwd(),
+	disableDefaultIgnores,
+	files,
+	fix,
+	computeEditInfo,
+	formatter,
+	_defaultFormatter,
+	globbyOptions,
+	ignoreDisables,
+	ignorePath,
+	ignorePattern,
+	maxWarnings,
+	quiet,
+	quietDeprecationWarnings = false,
+	reportDescriptionlessDisables,
+	reportInvalidScopeDisables,
+	reportNeedlessDisables,
+	reportUnscopedDisables,
+	suppressAll,
+	suppressRule,
+	suppressLocation,
+	validate = true,
+}) {
+	const startTime = Date.now();
+
+	const useInputCode = !files && isString(code);
+	const hasOneValidInput = (files && !isString(code)) || useInputCode;
+
+	if (!hasOneValidInput) {
+		return Promise.reject(
+			new Error('You must pass stylelint a `files` glob or a `code` string, though not both'),
+		);
+	}
+
+	// The ignorer will be used to filter file paths after the glob is checked,
+	// before any files are actually read
+	/** @type {import('ignore').Ignore} */
+	let ignorer;
+
+	try {
+		ignorer = getFileIgnorer({ cwd, ignorePath, ignorePattern });
+	} catch (error) {
+		return Promise.reject(error);
+	}
+
+	const stylelint = createStylelint({
+		allowEmptyInput,
+		cache,
+		cacheLocation,
+		cacheStrategy,
+		config,
+		configFile,
+		configBasedir,
+		cwd,
+		formatter,
+		_defaultFormatter,
+		ignoreDisables,
+		ignorePath,
+		reportNeedlessDisables,
+		reportInvalidScopeDisables,
+		reportDescriptionlessDisables,
+		reportUnscopedDisables,
+		customSyntax,
+		fix,
+		computeEditInfo,
+		quiet,
+		quietDeprecationWarnings,
+		validate,
+	});
+
+	const formatterFunction = await getFormatter(stylelint);
+
+	if (!files) {
+		assertString(code);
+
+		const absoluteCodeFilename =
+			codeFilename !== undefined && !isAbsolute(codeFilename)
+				? join(cwd, codeFilename)
+				: codeFilename;
+
+		// if file is ignored, return nothing
+		if (
+			absoluteCodeFilename &&
+			(!filterFilePaths(ignorer, [relative(cwd, absoluteCodeFilename)]).length ||
+				(!disableDefaultIgnores && micromatch.isMatch(absoluteCodeFilename, ALWAYS_IGNORED_GLOBS)))
+		) {
+			return prepareReturnValue({
+				results: [],
+				maxWarnings,
+				quietDeprecationWarnings,
+				formatter: formatterFunction,
+				cwd,
+			});
+		}
+
+		let stylelintResult;
+
+		try {
+			const postcssResult = await lintSource(stylelint, {
+				code,
+				codeFilename: absoluteCodeFilename,
+			});
+
+			stylelintResult = createPartialStylelintResult(postcssResult);
+		} catch (error) {
+			stylelintResult = handleError(error);
+		}
+
+		await postProcessStylelintResult(stylelint, stylelintResult, absoluteCodeFilename);
+
+		const postcssResult = stylelintResult._postcssResult;
+		const returnValue = prepareReturnValue({
+			results: [stylelintResult],
+			maxWarnings,
+			quietDeprecationWarnings,
+			formatter: formatterFunction,
+			cwd,
+		});
+
+		const autofix = normalizeFixMode(stylelint._options.fix) ?? config?.fix ?? false;
+
+		if (autofix && postcssResult && !postcssResult.stylelint.ignored) {
+			returnValue.code = postcssResult.opts
+				? // If we're fixing, the output should be the fixed code
+					postcssResult.root.toString(postcssResult.opts.syntax)
+				: // If the writing of the fix is disabled, the input code is returned as-is
+					code;
+		}
+
+		return returnValue;
+	}
+
+	let fileList = await Promise.all(
+		(typeof files === 'string' ? [files] : files).map(async (entry) => {
+			const globCWD = toPath(globbyOptions?.cwd) || cwd;
+			const absolutePath = !isAbsolute(entry) ? join(globCWD, entry) : normalize(entry);
+
+			if (await pathExists(absolutePath)) {
+				// This path points to a file. Return an escaped path to avoid globbing
+				return fastGlob.escapePath(normalizePath(entry));
+			}
+
+			return entry;
+		}),
+	);
+
+	if (!disableDefaultIgnores) {
+		fileList = fileList.concat(ALWAYS_IGNORED_GLOBS.map((glob) => `!${glob}`));
+	}
+
+	const useCache = await resolveOptionValue({ stylelint, name: 'cache', default: false });
+
+	if (!useCache) {
+		stylelint._fileCache.destroy();
+	}
+
+	const effectiveGlobbyOptions = {
+		cwd,
+		...(globbyOptions || {}),
+		absolute: true,
+	};
+
+	const globCWD = toPath(effectiveGlobbyOptions.cwd);
+
+	let filePaths = await globby(fileList, effectiveGlobbyOptions);
+
+	// Record the length of filePaths before ignore operation
+	// Prevent prompting "No files matching the pattern 'xx' were found." when .stylelintignore ignore all input files
+	const filePathsLengthBeforeIgnore = filePaths.length;
+
+	// The ignorer filter needs to check paths relative to cwd
+	filePaths = filterFilePaths(
+		ignorer,
+		filePaths.map((p) => relative(globCWD, p)),
+	);
+
+	let stylelintResults;
+
+	if (filePaths.length) {
+		const absoluteFilePaths = filePaths.map((filePath) =>
+			isAbsolute(filePath) ? normalize(filePath) : join(globCWD, filePath),
+		);
+
+		const getStylelintResults = absoluteFilePaths.map(async (absoluteFilepath) => {
+			debug(`Processing ${absoluteFilepath}`);
+
+			try {
+				const postcssResult = await lintSource(stylelint, {
+					filePath: absoluteFilepath,
+					cache: useCache,
+				});
+
+				if (
+					(postcssResult.stylelint.stylelintError || postcssResult.stylelint.stylelintWarning) &&
+					useCache
+				) {
+					debug(`${absoluteFilepath} contains linting errors and will not be cached.`);
+					stylelint._fileCache.removeEntry(absoluteFilepath);
+				}
+
+				/**
+				 * If we're fixing, save the file with changed code
+				 */
+				if (postcssResult.root && postcssResult.opts && !postcssResult.stylelint.ignored && fix) {
+					const fixedCss = postcssResult.root.toString(postcssResult.opts.syntax);
+
+					if (
+						postcssResult.root &&
+						postcssResult.root.source &&
+						postcssResult.root.source.input.css !== fixedCss
+					) {
+						await writeFileAtomic(absoluteFilepath, fixedCss);
+					}
+				}
+
+				const stylelintResult = createPartialStylelintResult(postcssResult);
+
+				await postProcessStylelintResult(stylelint, stylelintResult, absoluteFilepath);
+
+				return stylelintResult;
+			} catch (error) {
+				// On any error, we should not cache the lint result
+				stylelint._fileCache.removeEntry(absoluteFilepath);
+
+				const stylelintResult = handleError(error);
+
+				await postProcessStylelintResult(stylelint, stylelintResult, absoluteFilepath);
+
+				return stylelintResult;
+			}
+		});
+
+		stylelintResults = await Promise.all(getStylelintResults);
+	} else if (await resolveOptionValue({ stylelint, name: 'allowEmptyInput', default: false })) {
+		stylelintResults = await Promise.all([]);
+	} else if (filePathsLengthBeforeIgnore) {
+		// All input files ignored
+		stylelintResults = await Promise.reject(new AllFilesIgnoredError());
+	} else {
+		stylelintResults = await Promise.reject(new NoFilesFoundError(fileList));
+	}
+
+	if (!useInputCode) {
+		const resolvedSuppressLocation = resolveFilePath(
+			suppressLocation || DEFAULT_SUPPRESSION_FILENAME,
+			cwd,
+			DEFAULT_SUPPRESSION_FILENAME,
+		);
+
+		const existsSuppressionsFile = await pathExists(resolvedSuppressLocation);
+
+		if (suppressLocation && !existsSuppressionsFile && !suppressAll && !suppressRule) {
+			throw new SuppressionFileNotFoundError();
+		}
+
+		if (suppressAll || suppressRule || existsSuppressionsFile) {
+			emitExperimentalWarning(
+				'The suppressions feature is experimental.',
+				'SUPPRESSIONS',
+				'See https://stylelint.io/user-guide/suppressions for more information.',
+			);
+
+			const suppressions = new SuppressionsService({
+				filePath: resolvedSuppressLocation,
+				cwd: process.cwd(),
+			});
+
+			if (suppressAll || suppressRule) {
+				await suppressions.suppress(stylelintResults, suppressRule);
+			}
+
+			const suppressionResults = suppressions.applySuppressions(
+				stylelintResults,
+				await suppressions.load(),
+			);
+
+			stylelintResults = suppressionResults.results;
+		}
+	}
+
+	if (useCache) {
+		stylelint._fileCache.reconcile();
+	}
+
+	const result = prepareReturnValue({
+		results: stylelintResults,
+		maxWarnings,
+		quietDeprecationWarnings,
+		formatter: formatterFunction,
+		cwd,
+	});
+
+	debug(`Linting complete in ${Date.now() - startTime}ms`);
+
+	return result;
+}
+
+/**
+ * @import {CssSyntaxError} from 'stylelint'
+ *
+ * @param {unknown} error
+ * @returns {LintResult}
+ */
+function handleError(error) {
+	if (error instanceof Error && error.name === 'CssSyntaxError') {
+		return createPartialStylelintResult(undefined, /** @type {CssSyntaxError} */ (error));
+	}
+
+	throw error;
+}
+
+/**
+ * @param {InternalApi} stylelint
+ * @param {LintResult} stylelintResult
+ * @param {string} [filePath]
+ * @returns {Promise<void>}
+ */
+async function postProcessStylelintResult(stylelint, stylelintResult, filePath) {
+	const configForFile = await getConfigForFile({ stylelint, searchPath: filePath, filePath });
+
+	const config = configForFile === null ? {} : configForFile.config;
+
+	if (!config._processorFunctions) {
+		return;
+	}
+
+	for (const postprocess of config._processorFunctions.values()) {
+		postprocess?.(stylelintResult, stylelintResult._postcssResult?.root);
+	}
+}

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

@@ -0,0 +1,134 @@
+import process from 'node:process';
+import { table } from 'table';
+
+// Inspired by ESLint's timing.js
+// https://github.com/eslint/eslint/blob/09bc2a88c00aa9a93c7de505795fc4e85b2e6357/lib/linter/timing.js
+
+/**
+ * Start time measurement.
+ * @returns {bigint} Variable for tracking time in nanoseconds.
+ */
+function startTime() {
+	return process.hrtime.bigint();
+}
+
+/**
+ * End time measurement.
+ * @param {bigint} start Variable for tracking time in nanoseconds.
+ * @returns {number} The measured time in milliseconds.
+ */
+function endTime(start) {
+	const diff = process.hrtime.bigint() - start;
+
+	return Number(diff) / 1e6;
+}
+
+const HEADERS = ['#', 'Rule', 'Time (ms)', 'Relative'];
+
+/**
+ * Decide how many rules to show in the output list.
+ * @returns {number} The number of rules to show.
+ */
+function getListSize() {
+	const TIMING = process.env.TIMING;
+
+	if (typeof TIMING === 'undefined') {
+		return 0;
+	}
+
+	if (TIMING.toLowerCase() === 'all') {
+		return Number.POSITIVE_INFINITY;
+	}
+
+	const parsed = Number.parseInt(TIMING, 10);
+
+	if (!Number.isNaN(parsed) && parsed >= 1) {
+		return parsed;
+	}
+
+	return 0;
+}
+
+const listSize = getListSize();
+const enabled = listSize !== 0;
+
+/** @type {import('table').TableUserConfig}  */
+const tableConfig = {
+	columns: [
+		{ alignment: 'right' },
+		{ alignment: 'left' },
+		{ alignment: 'right' },
+		{ alignment: 'right' },
+	],
+};
+
+/**
+ * Display the timing data.
+ * @param {{ [key: string]: number }} data Data object to be displayed.
+ * @returns {void}
+ * @private
+ */
+function display(data) {
+	let total = 0;
+
+	/** @type {Array<[string, number]>} */
+	const rows = Object.keys(data).map((key) => {
+		const t = data[key] ?? 0;
+
+		total += t;
+
+		return [key, t];
+	});
+
+	rows.sort((a, b) => b[1] - a[1]);
+	const limitedRows = rows.slice(0, listSize);
+
+	// Format rows with percentages
+	const formattedRows = limitedRows.map((row, index) => {
+		const percentage = total > 0 ? `${((row[1] * 100) / total).toFixed(1)}%` : '0.0%';
+		const timeStr = row[1].toFixed(3);
+
+		return [index + 1, row[0], timeStr, percentage];
+	});
+
+	formattedRows.unshift(HEADERS);
+
+	// eslint-disable-next-line no-console
+	console.log(table(formattedRows, tableConfig));
+}
+
+/** @type {{ [key: string]: number }} */
+const data = Object.create(null);
+
+/**
+ * Time the execution of a function.
+ * @param {string} key Key from the data object.
+ * @param {Function} fn Function to be called.
+ * @returns {Function} Function to be executed.
+ * @private
+ */
+function time(key, fn) {
+	return function timedFunction(/** @type {any} */ ...args) {
+		const t = startTime();
+		const result = fn(...args);
+		const timeDiff = endTime(t);
+
+		data[key] = (data[key] ?? 0) + timeDiff;
+
+		return result;
+	};
+}
+
+if (enabled) {
+	process.on('exit', () => {
+		display(data);
+	});
+}
+
+export default {
+	display,
+	enabled,
+	getListSize,
+	tableConfig,
+	time,
+};

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

@@ -0,0 +1,66 @@
+import { RULE_NAME_ALL } from './constants.mjs';
+
+import optionsMatches from './utils/optionsMatches.mjs';
+import reportCommentProblem from './utils/reportCommentProblem.mjs';
+import validateDisableSettings from './validateDisableSettings.mjs';
+
+/** @typedef {import('postcss').Node} Node */
+
+/** @param {import('stylelint').PostcssResult} postcssResult */
+export default function reportUnscopedDisables(postcssResult) {
+	const [enabled, options] = validateDisableSettings(postcssResult, 'reportUnscopedDisables');
+
+	if (!options) return;
+
+	const isDisabled = !enabled && !options.except.length;
+
+	if (isDisabled) return;
+
+	const stylelint = postcssResult.stylelint;
+	const unscopedComments = stylelint.disabledRanges[RULE_NAME_ALL];
+
+	if (!unscopedComments) return;
+
+	/** @param {Node} node */
+	const report = (node) => {
+		reportCommentProblem({
+			rule: '--report-unscoped-disables',
+			message: `Configuration comment must be scoped`,
+			severity: options.severity,
+			node,
+			postcssResult,
+		});
+	};
+
+	const hasExceptions = options.except.length;
+
+	if (hasExceptions && !enabled) {
+		const configRules = stylelint.config?.rules;
+
+		if (!configRules) return;
+
+		const warnings = stylelint.disabledWarnings;
+
+		if (!warnings) return;
+
+		/** @type {Set<Node>} */
+		const alreadyReported = new Set();
+
+		for (const { line, rule } of warnings) {
+			const isException = optionsMatches(options, 'except', rule);
+
+			if (!isException) continue;
+
+			for (const { start, end, node } of unscopedComments) {
+				if (alreadyReported.has(node)) continue;
+
+				if (start <= line && (end === undefined || end >= line)) {
+					report(node);
+					alreadyReported.add(node);
+				}
+			}
+		}
+	} else if (enabled) {
+		for (const { node } of unscopedComments) report(node);
+	}
+}

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

@@ -0,0 +1,115 @@
+import { readFileSync, rmSync } from 'node:fs';
+import process from 'node:process';
+import { resolve } from 'node:path';
+
+import createDebug from 'debug';
+import fileEntryCache from 'file-entry-cache';
+
+import {
+	CACHE_STRATEGY_CONTENT,
+	CACHE_STRATEGY_METADATA,
+	DEFAULT_CACHE_LOCATION,
+	DEFAULT_CACHE_STRATEGY,
+} from '../constants.mjs';
+import hash from './hash.mjs';
+import resolveFilePath from './resolveFilePath.mjs';
+
+const debug = createDebug('stylelint:file-cache');
+
+const pkg = JSON.parse(readFileSync(new URL('../../package.json', import.meta.url), 'utf8'));
+
+export default class FileCache {
+	constructor(
+		cacheLocation = DEFAULT_CACHE_LOCATION,
+		cacheStrategy = DEFAULT_CACHE_STRATEGY,
+		cwd = process.cwd(),
+	) {
+		if (![CACHE_STRATEGY_METADATA, CACHE_STRATEGY_CONTENT].includes(cacheStrategy)) {
+			throw new Error(
+				`"${cacheStrategy}" cache strategy is unsupported. Specify either "${CACHE_STRATEGY_METADATA}" or "${CACHE_STRATEGY_CONTENT}"`,
+			);
+		}
+
+		const cacheFile = resolve(resolveFilePath(cacheLocation, cwd, `.stylelintcache_${hash(cwd)}`));
+		const useCheckSum = cacheStrategy === CACHE_STRATEGY_CONTENT;
+
+		debug(`Cache file is created at ${cacheFile}`);
+
+		try {
+			this._fileCache = fileEntryCache.createFromFile(cacheFile, { useCheckSum, cwd: undefined });
+		} catch {
+			debug(`Cache file might be corrupt, attempting to remove and recreate the cache file`);
+
+			rmSync(cacheFile, { force: true });
+			this._fileCache = fileEntryCache.createFromFile(cacheFile, { useCheckSum, cwd: undefined });
+		}
+
+		this._hashOfConfig = '';
+		this._useCheckSum = useCheckSum;
+	}
+
+	/**
+	 * @param {import('stylelint').Config} config
+	 */
+	calcHashOfConfig(config) {
+		if (this._hashOfConfig) return;
+
+		const stylelintVersion = pkg.version;
+		const configString = JSON.stringify(config || {});
+
+		this._hashOfConfig = hash(`${stylelintVersion}_${configString}`);
+	}
+
+	/**
+	 * @param {string} absoluteFilepath
+	 * @returns {boolean}
+	 */
+	hasFileChanged(absoluteFilepath) {
+		// Get file descriptor compares current metadata against cached
+		// one and stores the result to "changed" prop.w
+
+		/** @type {import('file-entry-cache').FileDescriptorMeta | undefined} */
+		const metaCache = this._fileCache.cache.getKey(this._fileCache.createFileKey(absoluteFilepath));
+		const descriptor = this._fileCache.getFileDescriptor(absoluteFilepath);
+
+		/** @type {{ hashOfConfig?: string; }} */
+		const metadata = (descriptor.meta.data ??= {});
+
+		const configChanged = metadata.hashOfConfig !== this._hashOfConfig;
+
+		let changed;
+
+		if (this._useCheckSum) {
+			changed = configChanged || !metaCache?.hash || metaCache.hash !== descriptor.meta.hash;
+		} else {
+			changed = configChanged || Boolean(descriptor.changed);
+		}
+
+		if (!changed) {
+			debug(`Skip linting ${absoluteFilepath}. File hasn't changed.`);
+		}
+
+		// Mutate file descriptor object and store config hash to each file.
+		// Running lint with different config should invalidate the cache.
+		if (metadata.hashOfConfig !== this._hashOfConfig) {
+			metadata.hashOfConfig = this._hashOfConfig;
+		}
+
+		return changed;
+	}
+
+	reconcile() {
+		this._fileCache.reconcile();
+	}
+
+	destroy() {
+		this._fileCache.destroy();
+	}
+
+	/**
+	 * @param {string} absoluteFilepath
+	 */
+	removeEntry(absoluteFilepath) {
+		this._fileCache.removeEntry(absoluteFilepath);
+	}
+}

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

@@ -0,0 +1,21 @@
+/**
+ * Add one or two empty line(s) before a node. Mutates the node.
+ *
+ * @template {import('postcss').Node} T
+ * @param {T} node
+ * @param {string} newline
+ * @returns {T}
+ */
+export default function addEmptyLineBefore(node, newline) {
+	const { raws } = node;
+
+	if (typeof raws.before !== 'string') {
+		return node;
+	}
+
+	raws.before = !/\r?\n/.test(raws.before)
+		? newline.repeat(2) + raws.before
+		: raws.before.replace(/(\r?\n)/, `${newline}$1`);
+
+	return node;
+}