@alexlit/lint-kit 182.1.0 → 182.2.0

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

@@ -0,0 +1,172 @@
+import { EOL } from 'node:os';
+
+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 getStylelintRule from './utils/getStylelintRule.mjs';
+import reportUnknownRuleNames from './reportUnknownRuleNames.mjs';
+import rules from './rules/index.mjs';
+import timing from './timing.mjs';
+
+/** @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 = [];
+
+	/** @type {string[]} */
+	let ruleNames;
+
+	if (config.rules) {
+		const rulesOrder = new Map(Object.keys(rules).map((ruleName, index) => [ruleName, index]));
+
+		ruleNames = Object.keys(config.rules).sort(
+			(a, b) => (rulesOrder.get(a) ?? -1) - (rulesOrder.get(b) ?? -1),
+		);
+	} else {
+		ruleNames = [];
+	}
+
+	// Load all rules in parallel.
+	/** @type {Array<[string, import('stylelint').Rule | undefined]>} */
+	const ruleEntries = await Promise.all(
+		ruleNames.map(async (ruleName) => {
+			const ruleFunction = await getStylelintRule(ruleName, config);
+
+			return [ruleName, ruleFunction];
+		}),
+	);
+
+	for (const [ruleName, ruleFunction] of ruleEntries) {
+		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 context = {
+			...ctx,
+			// 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' });
+}

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

@@ -0,0 +1,135 @@
+import { isAbsolute } from 'node:path';
+
+import postcss from 'postcss';
+
+import descriptionlessDisables from './descriptionlessDisables.mjs';
+import getConfigForFile from './getConfigForFile.mjs';
+import getLexer from './utils/getLexer.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 {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: {},
+			lexer: getLexer(config),
+		},
+	});
+
+	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,
+		lexer: getLexer({}),
+	};
+}
+
+/**
+ * @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

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

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

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

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

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

@@ -0,0 +1,44 @@
+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
+	);
+}