@alexlit/lint-kit 173.2.2 → 174.0.0

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

@@ -1,379 +0,0 @@
-import { isAbsolute, join, normalize, relative } from 'node:path';
-import { existsSync } from 'node:fs';
-import process from 'node:process';
-
-import createDebug from 'debug';
-const debug = createDebug('stylelint:standalone');
-
-import fastGlob from 'fast-glob';
-import { globby } from 'globby';
-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 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
-		) {
-			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 = [files].flat().map((entry) => {
-		const globCWD = toPath(globbyOptions?.cwd) || cwd;
-		const absolutePath = !isAbsolute(entry) ? join(globCWD, entry) : normalize(entry);
-
-		if (existsSync(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 = existsSync(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

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

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

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

@@ -1,21 +0,0 @@
-/**
- * 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;
-}