@alexlit/lint-kit 173.2.2 → 173.3.0

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

@@ -1,188 +0,0 @@
-import { EOL } from 'node:os';
-import syntaxPatchesJson from '@csstools/css-syntax-patches-for-csstree' with { type: 'json' };
-
-import { DEFAULT_SEVERITY, RULE_NAME_ALL } from './constants.mjs';
-import { DEFAULT_CONFIGURATION_COMMENT } from './utils/configurationComment.mjs';
-import assignDisabledRanges from './assignDisabledRanges.mjs';
-import { emitDeprecationWarning } from './utils/emitWarning.mjs';
-import { fork } from 'css-tree';
-import getStylelintRule from './utils/getStylelintRule.mjs';
-import mergeSyntaxDefinitions from './utils/mergeSyntaxDefinitions.mjs';
-import reportUnknownRuleNames from './reportUnknownRuleNames.mjs';
-import rules from './rules/index.mjs';
-import timing from './timing.mjs';
-
-const { next: syntaxPatches } = syntaxPatchesJson;
-
-/** @import {Config, LinterOptions, PostcssResult} from 'stylelint' */
-
-/**
- * @param {LinterOptions} stylelintOptions
- * @param {PostcssResult} postcssResult
- * @param {Config} config
- * @returns {Promise<any>}
- */
-export default async function lintPostcssResult(stylelintOptions, postcssResult, config) {
-	postcssResult.stylelint.stylelintError = false;
-	postcssResult.stylelint.stylelintWarning = false;
-	postcssResult.stylelint.quiet = config.quiet;
-	postcssResult.stylelint.quietDeprecationWarnings = stylelintOptions.quietDeprecationWarnings;
-	postcssResult.stylelint.config = config;
-
-	const postcssDoc = postcssResult.root;
-
-	if (!('type' in postcssDoc)) {
-		throw new Error('Unexpected Postcss root object!');
-	}
-
-	const newlineMatch = postcssDoc.source?.input.css.match(/\r?\n/);
-	const newline = newlineMatch ? newlineMatch[0] : EOL;
-	const configurationComment = config.configurationComment || DEFAULT_CONFIGURATION_COMMENT;
-	const ctx = { configurationComment, newline };
-
-	assignDisabledRanges(postcssDoc, postcssResult);
-
-	const postcssRoots = /** @type {import('postcss').Root[]} */ (
-		postcssDoc && postcssDoc.constructor.name === 'Document' ? postcssDoc.nodes : [postcssDoc]
-	);
-
-	// Promises for the rules. Although the rule code runs synchronously now,
-	// the use of Promises makes it compatible with the possibility of async
-	// rules down the line.
-	/** @type {Array<Promise<any>>} */
-	const performRules = [];
-
-	const rulesOrder = Object.keys(rules);
-	const ruleNames = config.rules
-		? Object.keys(config.rules).sort((a, b) => rulesOrder.indexOf(a) - rulesOrder.indexOf(b))
-		: [];
-
-	for (const ruleName of ruleNames) {
-		const ruleFunction = await getStylelintRule(ruleName, config);
-
-		if (ruleFunction === undefined) {
-			performRules.push(
-				Promise.all(
-					postcssRoots.map((postcssRoot) =>
-						reportUnknownRuleNames(ruleName, postcssRoot, postcssResult),
-					),
-				),
-			);
-
-			continue;
-		}
-
-		const ruleSettings = config.rules?.[ruleName];
-
-		if (ruleSettings === null || ruleSettings[0] === null) continue;
-
-		if (ruleFunction.meta?.deprecated && !stylelintOptions.quietDeprecationWarnings) {
-			warnDeprecatedRule(postcssResult, ruleName);
-		}
-
-		const primaryOption = ruleSettings[0];
-		const secondaryOptions = ruleSettings[1];
-
-		// Log the rule's severity in the PostCSS result
-		const defaultSeverity = config.defaultSeverity || DEFAULT_SEVERITY;
-
-		postcssResult.stylelint.ruleSeverities[ruleName] =
-			(secondaryOptions && secondaryOptions.severity) || defaultSeverity;
-		postcssResult.stylelint.customMessages[ruleName] = secondaryOptions && secondaryOptions.message;
-		postcssResult.stylelint.customUrls[ruleName] = secondaryOptions && secondaryOptions.url;
-		postcssResult.stylelint.ruleMetadata[ruleName] = ruleFunction.meta || {};
-
-		const shouldWarn = ruleFunction.meta?.fixable && !stylelintOptions.quietDeprecationWarnings;
-		const disableFix = secondaryOptions?.disableFix === true;
-		const fix = !disableFix && config.fix && isFixCompatible(postcssResult, ruleName);
-		const lexer = getCachedLexer(config);
-		const context = {
-			...ctx,
-			lexer,
-			// context.fix is unlikely to be removed in the foreseeable future
-			// due to the sheer number of rules in the wild that rely on it
-			get fix() {
-				if (shouldWarn) {
-					emitDeprecationWarning(
-						'`context.fix` is deprecated.',
-						'CONTEXT_FIX',
-						`Pass a \`fix\` callback to the \`report\` utility of "${ruleName}" instead.`,
-					);
-				}
-
-				return fix;
-			},
-		};
-
-		const ruleFn = ruleFunction(primaryOption, secondaryOptions, context);
-
-		/**
-		 * @param {import('postcss').Root} postcssRoot
-		 */
-		async function runRule(postcssRoot) {
-			if (timing.enabled) {
-				return timing.time(ruleName, () => ruleFn(postcssRoot, postcssResult))();
-			}
-
-			return ruleFn(postcssRoot, postcssResult);
-		}
-
-		performRules.push(Promise.all(postcssRoots.map(runRule)));
-	}
-
-	return Promise.all(performRules);
-}
-
-/**
- * using context.fix instead of the fix callback has the drawback
- * of not honouring the configuration comments in subtle ways
- * @see file://./../docs/user-guide/options.md#fix for details
- * @param {PostcssResult} postcssResult
- * @param {string} name
- * @returns {boolean}
- */
-function isFixCompatible({ stylelint: { disabledRanges } }, name) {
-	return !disabledRanges[RULE_NAME_ALL]?.length && !disabledRanges[name];
-}
-
-/**
- * @param {PostcssResult} result
- * @param {string} ruleName
- * @returns {void}
- */
-function warnDeprecatedRule(result, ruleName) {
-	const message = `The "${ruleName}" rule is deprecated.`;
-
-	emitDeprecationWarning(
-		message,
-		'RULE',
-		`Please be aware that the "${ruleName}" rule will soon be either removed or renamed.`,
-	);
-
-	result.warn(message, { stylelintType: 'deprecation' });
-}
-
-const lexerCache = new Map();
-
-/**
- * @param {Config} config
- * @returns {import('css-tree').Lexer}
- * */
-function getCachedLexer(config) {
-	const cacheKey = JSON.stringify(config.languageOptions?.syntax || {});
-
-	if (lexerCache.has(cacheKey)) {
-		return lexerCache.get(cacheKey);
-	}
-
-	const newLexer = fork(
-		mergeSyntaxDefinitions(syntaxPatches, {
-			...config.languageOptions?.syntax,
-			atrules: config.languageOptions?.syntax?.atRules,
-		}),
-	).lexer;
-
-	lexerCache.set(cacheKey, newLexer);
-
-	return newLexer;
-}

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

@@ -1,133 +0,0 @@
-import { isAbsolute } from 'node:path';
-
-import postcss from 'postcss';
-
-import descriptionlessDisables from './descriptionlessDisables.mjs';
-import getConfigForFile from './getConfigForFile.mjs';
-import getPostcssResult from './getPostcssResult.mjs';
-import invalidScopeDisables from './invalidScopeDisables.mjs';
-import isPathIgnored from './isPathIgnored.mjs';
-import isPathNotFoundError from './utils/isPathNotFoundError.mjs';
-import lintPostcssResult from './lintPostcssResult.mjs';
-import needlessDisables from './needlessDisables.mjs';
-import reportDisables from './reportDisables.mjs';
-import reportUnscopedDisables from './unscopedDisables.mjs';
-
-/** @import {Result} from 'postcss' */
-/** @import {GetLintSourceOptions as Options, InternalApi as StylelintInternalApi, PostcssResult, StylelintPostcssResult} from 'stylelint' */
-
-/**
- * Run stylelint on a PostCSS Result, either one that is provided
- * or one that we create
- * @param {StylelintInternalApi} stylelint
- * @param {Options} options
- * @returns {Promise<PostcssResult>}
- */
-export default async function lintSource(stylelint, options = {}) {
-	if (!options.filePath && options.code === undefined && !options.existingPostcssResult) {
-		return Promise.reject(new Error('You must provide filePath, code, or existingPostcssResult'));
-	}
-
-	const isCodeNotFile = options.code !== undefined;
-
-	const inputFilePath = isCodeNotFile ? options.codeFilename : options.filePath;
-
-	if (inputFilePath !== undefined && !isAbsolute(inputFilePath)) {
-		if (isCodeNotFile) {
-			return Promise.reject(new Error('codeFilename must be an absolute path'));
-		}
-
-		return Promise.reject(new Error('filePath must be an absolute path'));
-	}
-
-	const isIgnored = await isPathIgnored(stylelint, inputFilePath).catch((err) => {
-		if (isCodeNotFile && isPathNotFoundError(err)) return false;
-
-		throw err;
-	});
-
-	if (isIgnored) {
-		return createEmptyPostcssResult(inputFilePath, options.existingPostcssResult);
-	}
-
-	const configForFile = await getConfigForFile({
-		stylelint,
-		searchPath: inputFilePath,
-		filePath: inputFilePath,
-	});
-
-	if (!configForFile) {
-		return Promise.reject(new Error('Config file not found'));
-	}
-
-	const config = configForFile.config;
-	const existingPostcssResult = options.existingPostcssResult;
-
-	if (options.cache) {
-		stylelint._fileCache.calcHashOfConfig(config);
-
-		if (options.filePath && !stylelint._fileCache.hasFileChanged(options.filePath)) {
-			return createEmptyPostcssResult(inputFilePath, existingPostcssResult);
-		}
-	}
-
-	const postcssResult =
-		existingPostcssResult ||
-		(await getPostcssResult(stylelint, {
-			code: options.code,
-			codeFilename: options.codeFilename,
-			filePath: inputFilePath,
-			customSyntax: config.customSyntax,
-		}));
-
-	const stylelintPostcssResult = Object.assign(postcssResult, {
-		stylelint: {
-			ruleSeverities: {},
-			customMessages: {},
-			customUrls: {},
-			ruleMetadata: {},
-			fixersData: {},
-			rangesOfComputedEditInfos: [],
-			disabledRanges: {},
-		},
-	});
-
-	await lintPostcssResult(stylelint._options, stylelintPostcssResult, config);
-
-	reportDisables(stylelintPostcssResult);
-	needlessDisables(stylelintPostcssResult);
-	invalidScopeDisables(stylelintPostcssResult);
-	descriptionlessDisables(stylelintPostcssResult);
-	reportUnscopedDisables(stylelintPostcssResult);
-
-	return stylelintPostcssResult;
-}
-
-/**
- * @returns {StylelintPostcssResult}
- */
-function createEmptyStylelintPostcssResult() {
-	return {
-		ruleSeverities: {},
-		customMessages: {},
-		customUrls: {},
-		ruleMetadata: {},
-		fixersData: {},
-		rangesOfComputedEditInfos: [],
-		disabledRanges: {},
-		ignored: true,
-		stylelintError: false,
-		stylelintWarning: false,
-	};
-}
-
-/**
- * @param {string | undefined} filePath
- * @param {Options['existingPostcssResult']} existingPostcssResult
- * @returns {PostcssResult}
- */
-function createEmptyPostcssResult(filePath, existingPostcssResult) {
-	return Object.assign(existingPostcssResult ?? postcss().process('', { from: filePath }).sync(), {
-		stylelint: createEmptyStylelintPostcssResult(),
-	});
-}

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

@@ -1,91 +0,0 @@
-import { RULE_NAME_ALL } from './constants.mjs';
-
-import optionsMatches from './utils/optionsMatches.mjs';
-import putIfAbsent from './utils/putIfAbsent.mjs';
-import reportCommentProblem from './utils/reportCommentProblem.mjs';
-import validateDisableSettings from './validateDisableSettings.mjs';
-
-/**
- * @param {import('stylelint').PostcssResult} postcssResult
- * @returns {void}
- */
-export default function needlessDisables(postcssResult) {
-	const [enabled, options] = validateDisableSettings(postcssResult, 'reportNeedlessDisables');
-
-	if (!options) return;
-
-	const {
-		disabledRanges,
-		disabledRanges: { [RULE_NAME_ALL]: disabledRangesAll = [] },
-		disabledWarnings = [],
-	} = postcssResult.stylelint;
-
-	// A map from `stylelint-disable` comments to the set of rules that
-	// are usefully disabled by each comment. We track this
-	// comment-by-comment rather than range-by-range because ranges that
-	// disable *all* rules are duplicated for each rule they apply to in
-	// practice.
-	/** @type {Map<import('postcss').Node, Set<string>>}} */
-	const usefulDisables = new Map();
-
-	for (const warning of disabledWarnings) {
-		const rule = warning.rule;
-		const ruleRanges = disabledRanges[rule];
-
-		if (ruleRanges) {
-			for (const range of ruleRanges) {
-				if (isWarningInRange(warning, range)) {
-					putIfAbsent(usefulDisables, range.node, () => new Set()).add(rule);
-				}
-			}
-		}
-
-		for (const range of disabledRangesAll) {
-			if (isWarningInRange(warning, range)) {
-				putIfAbsent(usefulDisables, range.node, () => new Set()).add(rule);
-			}
-		}
-	}
-
-	const allRangeNodes = new Set(disabledRangesAll.map((range) => range.node));
-
-	for (const [rule, ranges] of Object.entries(disabledRanges)) {
-		for (const range of ranges) {
-			const node = range.node;
-
-			if (rule !== RULE_NAME_ALL && allRangeNodes.has(node)) continue;
-
-			if (enabled === optionsMatches(options, 'except', rule)) continue;
-
-			const useful = usefulDisables.get(node) || new Set();
-
-			// Only emit a warning if this range's comment isn't useful for this rule.
-			// For the special rule "all", only emit a warning if it's not useful for
-			// *any* rules, because it covers all of them.
-			if (rule === RULE_NAME_ALL ? useful.size !== 0 : useful.has(rule)) continue;
-
-			reportCommentProblem({
-				rule: '--report-needless-disables',
-				message: `Needless disable for "${rule}"`,
-				severity: options.severity,
-				node,
-				postcssResult,
-			});
-		}
-	}
-}
-
-/**
- * @param {import('stylelint').DisabledWarning} warning
- * @param {import('stylelint').DisabledRange} range
- * @returns {boolean}
- */
-function isWarningInRange(warning, range) {
-	const line = warning.line;
-
-	// Need to check if range.end exist, because line number type cannot be compared to undefined
-	return (
-		range.start <= line &&
-		((range.end !== undefined && range.end >= line) || range.end === undefined)
-	);
-}

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

@@ -1,29 +0,0 @@
-import getStylelintRule from './utils/getStylelintRule.mjs';
-import normalizeRuleSettings from './normalizeRuleSettings.mjs';
-
-/** @import {Config as StylelintConfig} from 'stylelint' */
-
-/**
- * @param {StylelintConfig} config
- * @returns {Promise<StylelintConfig>}
- */
-export default async function normalizeAllRuleSettings(config) {
-	if (!config.rules) return config;
-
-	/** @type {StylelintConfig['rules']} */
-	const normalizedRules = {};
-
-	for (const [ruleName, rawRuleSettings] of Object.entries(config.rules)) {
-		const rule = await getStylelintRule(ruleName, config);
-
-		if (rule) {
-			normalizedRules[ruleName] = normalizeRuleSettings(rawRuleSettings, rule);
-		} else {
-			normalizedRules[ruleName] = [];
-		}
-	}
-
-	config.rules = normalizedRules;
-
-	return config;
-}

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

@@ -1,56 +0,0 @@
-import { isPlainObject } from './utils/validateTypes.mjs';
-
-// Rule settings can take a number of forms, e.g.
-// a. "rule-name": null
-// b. "rule-name": [null, ...]
-// c. "rule-name": primaryOption
-// d. "rule-name": [primaryOption]
-// e. "rule-name": [primaryOption, secondaryOption]
-// Where primaryOption can be anything: primitive, Object, or Array.
-
-/**
- * This function normalizes all the possibilities into the
- * standard form: [primaryOption, secondaryOption]
- * Except in the cases with null, a & b, in which case
- * null is returned
- * @template T
- * @template {object} O
- * @param {import('stylelint').ConfigRuleSettings<T, O>} rawSettings
- * @param {import('stylelint').Rule<T, O>} [rule]
- * @returns {[T] | [T, O] | null}
- */
-export default function normalizeRuleSettings(rawSettings, rule) {
-	if (rawSettings === null || rawSettings === undefined) {
-		return null;
-	}
-
-	if (!Array.isArray(rawSettings)) {
-		return [rawSettings];
-	}
-	// Everything below is an array ...
-
-	const [primary, secondary] = rawSettings;
-
-	if (rawSettings.length > 0 && (primary === null || primary === undefined)) {
-		return null;
-	}
-
-	if (rule && !rule.primaryOptionArray) {
-		return rawSettings;
-	}
-	// Everything below is a rule that CAN have an array for a primary option ...
-	// (they might also have something else, e.g. rule-properties-order can
-	// have the string "alphabetical")
-
-	if (rawSettings.length === 1 && Array.isArray(primary)) {
-		return rawSettings;
-	}
-
-	if (rawSettings.length === 2 && !isPlainObject(primary) && isPlainObject(secondary)) {
-		return rawSettings;
-	}
-
-	// `T` must be an array type, but TSC thinks it's probably invalid to
-	// cast `[T]` to `T` so we cast through `any` first.
-	return [/** @type {T} */ (/** @type {any} */ (rawSettings))];
-}

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

@@ -1,50 +0,0 @@
-import { isAbsolute, join } from 'node:path';
-import process from 'node:process';
-
-import createStylelint from './createStylelint.mjs';
-import { isString } from './utils/validateTypes.mjs';
-import lintSource from './lintSource.mjs';
-
-/** @import {Config as StylelintConfig, PostcssPluginOptions} from 'stylelint' */
-
-/**
- * @type {import('postcss').PluginCreator<PostcssPluginOptions>}
- */
-export default function postcssPlugin(options = {}) {
-	const [cwd, tailoredOptions] = isConfig(options)
-		? [process.cwd(), { config: options }]
-		: [('cwd' in options && isString(options.cwd) && options.cwd) || process.cwd(), options];
-	const stylelint = createStylelint(tailoredOptions);
-
-	return {
-		postcssPlugin: 'stylelint',
-
-		/**
-		 * @param {import('postcss').Root} root
-		 * @param {import('postcss').Helpers} helpers
-		 * @returns {Promise<void>}
-		 */
-		async Once(root, { result }) {
-			let filePath = root.source && root.source.input.file;
-
-			if (filePath && !isAbsolute(filePath)) {
-				filePath = join(cwd, filePath);
-			}
-
-			await lintSource(stylelint, {
-				filePath,
-				existingPostcssResult: result,
-			});
-		},
-	};
-}
-
-postcssPlugin.postcss = true;
-
-/**
- * @param {PostcssPluginOptions} options
- * @returns {options is StylelintConfig}
- */
-function isConfig(options) {
-	return 'rules' in options;
-}

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

@@ -1,63 +0,0 @@
-import { SEVERITY_ERROR } from './constants.mjs';
-
-/** @import { Formatter, LinterOptions, LinterResult, LintResult } from 'stylelint' */
-
-/**
- * @param {object} args
- * @param {LintResult[]} args.results
- * @param {LinterOptions['maxWarnings']} args.maxWarnings
- * @param {LinterOptions['quietDeprecationWarnings']} args.quietDeprecationWarnings
- * @param {Formatter} args.formatter
- * @param {string} args.cwd
- * @returns {LinterResult}
- */
-export default function prepareReturnValue({ results, maxWarnings, formatter, cwd }) {
-	let errored = false;
-
-	for (const result of results) {
-		if (
-			result.errored ||
-			result.parseErrors.length > 0 ||
-			result.warnings.some((warning) => warning.severity === SEVERITY_ERROR)
-		) {
-			errored = true;
-			result.errored = true;
-		}
-	}
-
-	/** @type {LinterResult} */
-	const returnValue = {
-		cwd,
-		errored,
-		results: [],
-		report: '',
-		reportedDisables: [],
-		ruleMetadata: getRuleMetadata(results),
-	};
-
-	if (maxWarnings !== undefined) {
-		const foundWarnings = results.reduce((count, file) => count + file.warnings.length, 0);
-
-		if (foundWarnings > maxWarnings) {
-			returnValue.maxWarningsExceeded = { maxWarnings, foundWarnings };
-		}
-	}
-
-	returnValue.report = formatter(results, returnValue);
-	returnValue.results = results;
-
-	return returnValue;
-}
-
-/**
- * @param {LintResult[]} lintResults
- */
-function getRuleMetadata(lintResults) {
-	const [lintResult] = lintResults;
-
-	if (lintResult === undefined) return {};
-
-	if (lintResult._postcssResult === undefined) return {};
-
-	return lintResult._postcssResult.stylelint.ruleMetadata;
-}

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

@@ -1,44 +0,0 @@
-import process from 'node:process';
-
-import { isDynamicPattern } from 'globby';
-
-import resolveConfig from './resolveConfig.mjs';
-import toPath from './utils/toPath.mjs';
-
-/** @import {Config as StylelintConfig} from 'stylelint' */
-
-/**
- * @param {import('stylelint').LinterOptions} options
- * @returns {Promise<StylelintConfig | null>}
- */
-export default async function printConfig({
-	cwd = process.cwd(),
-	code,
-	config,
-	configBasedir,
-	configFile,
-	globbyOptions,
-	files,
-}) {
-	const isCodeNotFile = code !== undefined;
-	const filePath = files && files[0];
-
-	if (!files || files.length !== 1 || !filePath || isCodeNotFile) {
-		return Promise.reject(
-			new Error('The --print-config option must be used with exactly one file path.'),
-		);
-	}
-
-	if (isDynamicPattern(filePath)) {
-		return Promise.reject(new Error('The --print-config option does not support globs.'));
-	}
-
-	return (
-		(await resolveConfig(filePath, {
-			cwd: toPath(globbyOptions?.cwd) || cwd,
-			config,
-			configBasedir,
-			configFile,
-		})) || null
-	);
-}