@alexlit/lint-kit 183.4.0 → 183.6.0

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

@@ -0,0 +1,321 @@
+import {
+	isFunction as isFn,
+	isNumber,
+	isPlainObject,
+	isRange,
+	isString,
+} from '../utils/validateTypes.mjs';
+
+import {
+	DEFAULT_SEVERITY,
+	RULE_NAME_ALL,
+	SEVERITY_ERROR,
+	SEVERITY_WARNING,
+} from '../constants.mjs';
+import addSemicolonForEditInfo from './addSemicolonForEditInfo.mjs';
+import appendRuleName from './appendRuleName.mjs';
+import narrowFixRange from './narrowFixRange.mjs';
+import rangesOverlap from './rangesOverlap.mjs';
+
+/** @import { Config, DisabledRangeObject, FixObject, Problem, Range, RuleMessage, StylelintPostcssResult, Utils, WarningOptions } from 'stylelint' */
+
+/**
+ * Report a problem.
+ *
+ * This function accounts for `disabledRanges` attached to the result.
+ * That is, if the reported problem is within a disabledRange,
+ * it is ignored. Otherwise, it is attached to the result as a
+ * postcss warning.
+ *
+ * It also accounts for the rule's severity.
+ *
+ * You *must* pass *either* a node or a line number.
+ *
+ * @type {Utils['report']}
+ */
+export default function report(problem) {
+	const { node, result, ruleName, fix, ...rest } = problem;
+	const problemRange = getProblemRange(problem);
+	const {
+		disabledRanges,
+		quiet,
+		ruleSeverities,
+		config: { defaultSeverity, ignoreDisables } = {},
+		customMessages: { [ruleName]: message = rest.message },
+		customUrls: { [ruleName]: customUrl },
+		ruleMetadata: { [ruleName]: metadata },
+	} = result.stylelint;
+	const { messageArgs = [], severity = ruleSeverities[ruleName] } = rest;
+	const ruleSeverity =
+		(isFn(severity) ? severity(...messageArgs) : severity) ?? defaultSeverity ?? DEFAULT_SEVERITY;
+
+	// In quiet mode, mere warnings are ignored
+	if (quiet && ruleSeverity === SEVERITY_WARNING) return;
+
+	if ((isFn(fix) || isFixObject(fix)) && metadata && !metadata.fixable) {
+		throw new Error(
+			`The "${ruleName}" rule requires "meta.fixable" to be truthy if the "fix" callback is being passed`,
+		);
+	}
+
+	if (isFixApplied(problem, problemRange.start.line)) return;
+
+	if (isDisabledOnLine(ruleName, problemRange.start.line, disabledRanges)) {
+		// Collect disabled warnings
+		// Used to report `needlessDisables` in subsequent processing.
+		const disabledWarnings = (result.stylelint.disabledWarnings ||= []);
+
+		disabledWarnings.push({
+			rule: ruleName,
+			line: problemRange.start.line,
+		});
+
+		if (!ignoreDisables) return;
+	}
+
+	if (!result.stylelint.stylelintError && ruleSeverity === SEVERITY_ERROR) {
+		result.stylelint.stylelintError = true;
+	}
+
+	if (!result.stylelint.stylelintWarning && ruleSeverity === SEVERITY_WARNING) {
+		result.stylelint.stylelintWarning = true;
+	}
+
+	/** @type {WarningOptions} */
+	const warningProperties = {
+		severity: ruleSeverity,
+		rule: ruleName,
+	};
+
+	if (node) {
+		warningProperties.node = node;
+	}
+
+	warningProperties.start = problemRange.start;
+	warningProperties.end = problemRange.end;
+
+	if (customUrl) {
+		warningProperties.url = customUrl;
+	}
+
+	warningProperties.fix = computeEditInfo({ ...problem, line: problemRange.start.line });
+
+	const warningMessage = buildWarningMessage(message, messageArgs, ruleName);
+
+	result.warn(warningMessage, warningProperties);
+}
+
+/**
+ * @param {Problem} problem
+ * @returns {Range}
+ */
+function getProblemRange(problem) {
+	if (!problem.node) {
+		throw new Error(
+			`The "${problem.ruleName}" rule provided incorrect position arguments to \`utils.report()\`. To fix, pass a PostCSS \`node\` to the function.`,
+		);
+	}
+
+	// `start/end` based range
+	if (isRange(problem)) {
+		return {
+			start: problem.start,
+			end: problem.end,
+		};
+	}
+
+	if ('start' in problem || 'end' in problem) {
+		throw new Error(
+			`The "${problem.ruleName}" rule provided incomplete position arguments to \`utils.report()\`. To fix, provide both \`start\` and \`end\` as valid positions to the function.`,
+		);
+	}
+
+	// `index/endIndex` based range
+	if (hasIndices(problem)) {
+		return problem.node.rangeBy({ index: problem.index, endIndex: problem.endIndex });
+	}
+
+	if ('index' in problem || 'endIndex' in problem) {
+		throw new Error(
+			`The "${problem.ruleName}" rule provided incomplete position arguments to \`utils.report()\`. To fix, provide both \`index\` and \`endIndex\` as numbers to the function.`,
+		);
+	}
+
+	// `word` based range
+	if ('word' in problem && isString(problem.word)) {
+		return problem.node.rangeBy({ word: problem.word });
+	}
+
+	return problem.node.rangeBy({});
+}
+
+/**
+ * @param {RuleMessage} message
+ * @param {NonNullable<Problem['messageArgs']>} messageArgs
+ * @param {string} ruleName
+ * @returns {string}
+ */
+function buildWarningMessage(message, messageArgs, ruleName) {
+	return appendRuleName(
+		isString(message) ? printfLike(message, ...messageArgs) : message(...messageArgs),
+		ruleName,
+	);
+}
+
+/**
+ * @param {string} format
+ * @param {Array<unknown>} args
+ * @returns {string}
+ */
+function printfLike(format, ...args) {
+	return args.reduce((/** @type {string} */ result, arg) => {
+		return result.replace(/%[ds]/, String(arg));
+	}, format);
+}
+
+/**
+ * Check whether a rule is disabled for a given line
+ * @param {string} ruleName
+ * @param {number} startLine
+ * @param {DisabledRangeObject} disabledRanges
+ */
+function isDisabledOnLine(ruleName, startLine, disabledRanges) {
+	const ranges = disabledRanges[ruleName] ?? disabledRanges[RULE_NAME_ALL] ?? [];
+
+	for (const range of ranges) {
+		if (
+			// If the problem is within a disabledRange,
+			// and that disabledRange's rules include this one
+			range.start <= startLine &&
+			(range.end === undefined || range.end >= startLine) &&
+			/** @todo populate rules in assignDisabledRanges util */
+			(!range.rules || range.rules.includes(ruleName))
+		) {
+			return true;
+		}
+	}
+
+	return false;
+}
+
+/**
+ * @param {Problem} problem
+ * @param {number} line
+ * @returns {boolean}
+ */
+function isFixApplied({ fix, result: { stylelint }, ruleName }, line) {
+	if (!fix) return false;
+
+	const { disabledRanges, config = {}, fixersData } = stylelint;
+
+	if (!config.fix) return false;
+
+	if (isFixDisabled(line, ruleName, config, disabledRanges)) return false;
+
+	const apply = isFixObject(fix) ? fix.apply : fix;
+
+	if (!isFn(apply)) return false;
+
+	apply();
+
+	incrementFixCounter({ fixersData, ruleName });
+
+	return true;
+}
+
+/**
+ * @param {Problem & { line: number }} problem
+ * @returns {{range: [number, number], text: string} | undefined}
+ */
+function computeEditInfo({ fix, line, result, ruleName }) {
+	if (!fix) return;
+
+	const { disabledRanges, config = {}, rangesOfComputedEditInfos } = result.stylelint;
+
+	if (!config.computeEditInfo || config.fix) return;
+
+	if (isFixDisabled(line, ruleName, config, disabledRanges)) return;
+
+	if (!isFixObject(fix) || !fix.apply || !fix.node) return;
+
+	const { apply, node } = fix;
+
+	if (!isNumber(node.source?.start?.offset) || !isNumber(node.source?.end?.offset)) return;
+
+	/** @type [number, number] */
+	const fixedNodeRange = [node.source.start.offset, node.source.end.offset];
+
+	// When recording edit info we want to ensure that there is no overlap with any other fix.
+	// We only record the first fix for each node.
+	if (rangesOfComputedEditInfos.some((range) => rangesOverlap(range, fixedNodeRange))) {
+		return;
+	}
+
+	// Apply the fix
+	apply();
+
+	let fixData = { range: fixedNodeRange, text: node.toString(result.opts?.syntax) };
+
+	fixData = addSemicolonForEditInfo(node, fixData);
+
+	// Compute the smallest range and text of the fix
+	fixData = narrowFixRange(node, fixData);
+
+	// Mark the fixed range as mutated
+	rangesOfComputedEditInfos.push(fixData.range);
+
+	return fixData;
+}
+
+/**
+ * @param {number} line
+ * @param {string} ruleName
+ * @param {Config} config
+ * @param {DisabledRangeObject} disabledRanges
+ * @returns {boolean}
+ */
+function isFixDisabled(line, ruleName, config, disabledRanges) {
+	if (config.rules?.[ruleName][1]?.disableFix) return true;
+
+	if (!config.ignoreDisables && isDisabledOnLine(ruleName, line, disabledRanges)) return true;
+
+	return false;
+}
+
+/**
+ * @param {object} o
+ * @param {StylelintPostcssResult['fixersData']} o.fixersData
+ * @param {string} o.ruleName
+ */
+function incrementFixCounter({ fixersData, ruleName }) {
+	fixersData[ruleName] ??= 0;
+	fixersData[ruleName]++;
+}
+
+/**
+ * @param {unknown} value
+ * @returns {value is { index: number, endIndex: number }}
+ */
+function hasIndices(value) {
+	if (!isPlainObject(value)) return false;
+
+	if (!isNumber(value.index)) return false;
+
+	if (!isNumber(value.endIndex)) return false;
+
+	return true;
+}
+
+/**
+ * @param {unknown} value
+ * @returns {value is FixObject}
+ */
+function isFixObject(value) {
+	if (!isPlainObject(value)) return false;
+
+	if (!value.node) return false;
+
+	if (!isFn(value.apply)) return false;
+
+	return true;
+}

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

@@ -0,0 +1,39 @@
+import { SEVERITY_ERROR, SEVERITY_WARNING } from '../constants.mjs';
+
+/**
+ * @param {{
+ *   rule: string;
+ *   message: string;
+ *   severity: import('stylelint').Severity;
+ *   node: import('postcss').Node;
+ *   postcssResult: import('stylelint').PostcssResult;
+ * }} args
+ * @returns {void}
+ */
+export default function reportCommentProblem({ rule, message, severity, node, postcssResult }) {
+	const { source } = node;
+
+	// If the comment doesn't have a location, we can't report a useful error.
+	// In practice we expect all comments to have locations, though.
+	if (!source?.start) return;
+
+	postcssResult.warn(message, {
+		rule,
+		severity,
+		node,
+		start: source.start,
+		end: source.end,
+	});
+
+	switch (severity) {
+		case SEVERITY_ERROR:
+			postcssResult.stylelint.stylelintError = true;
+			break;
+		case SEVERITY_WARNING:
+			postcssResult.stylelint.stylelintWarning = true;
+			break;
+		default:
+			// no-op
+			break;
+	}
+}

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

@@ -0,0 +1,38 @@
+import { join, normalize, resolve, sep } from 'node:path';
+import { lstatSync } from 'node:fs';
+
+/**
+ * Return the resolved file path, based on whether the provided parameter is
+ * a directory or looks like a directory (ends in `path.sep`), in which case the file
+ * name will be `location/defaultFileName`.
+ *
+ * If location points to a file or looks like a file, then it will just use that file.
+ *
+ * @param {string} location - The name of file or directory to be used
+ * @param {string} cwd - Current working directory. Used for tests
+ * @param {string} defaultFileName - Default filename to use when location is a directory
+ * @returns {string} Resolved path to the file
+ */
+export default function resolveFilePath(location, cwd, defaultFileName) {
+	/*
+	 * Make sure path separators are normalized for environment/os.
+	 * Also, keep trailing path separator if present.
+	 */
+	const normalizedLocation = normalize(location);
+
+	const resolvedLocation = resolve(cwd, normalizedLocation);
+
+	// If the location path ends with a separator, we assume is a directory.
+	const looksLikeADirectory = location.endsWith(sep);
+
+	if (
+		looksLikeADirectory ||
+		lstatSync(resolvedLocation, { throwIfNoEntry: false })?.isDirectory()
+	) {
+		// Return path to provided directory with the specified file name.
+		return join(resolvedLocation, defaultFileName);
+	}
+
+	// Return normalized path to file.
+	return resolvedLocation;
+}

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

@@ -0,0 +1,108 @@
+import { resolveNestedSelector } from '@csstools/selector-resolve-nested';
+
+import { isAtRule, isRule } from './typeGuards.mjs';
+import getRuleSelector from './getRuleSelector.mjs';
+import isStandardSyntaxRule from './isStandardSyntaxRule.mjs';
+import parseSelector from './parseSelector.mjs';
+import selectorParser from 'postcss-selector-parser';
+
+/** @import { Selector, Root as SelectorRoot } from 'postcss-selector-parser' */
+/** @import { Rule, Node } from 'postcss' */
+/** @import { PostcssResult } from 'stylelint' */
+
+/** @type {WeakMap<Rule, Map<PostcssResult, Array<ResolvedSelector>>>} */
+const cache = new WeakMap();
+
+/**
+ * Resolve nested selectors following the CSS nesting specification
+ *
+ * @typedef {{selector: Selector, resolvedSelectors: SelectorRoot, nested: boolean}} ResolvedSelector
+ *
+ * @param {Rule} rule
+ * @param {PostcssResult} result
+ * @returns {Array<ResolvedSelector>}
+ */
+export default function resolveNestedSelectorsForRule(rule, result) {
+	let ruleCache = cache.get(rule);
+
+	if (ruleCache) {
+		const cachedResolved = ruleCache.get(result);
+
+		if (cachedResolved) return cachedResolved;
+	} else {
+		ruleCache = new Map();
+		cache.set(rule, ruleCache);
+	}
+
+	const ownAST = parseSelector(getRuleSelector(rule), result, rule);
+
+	if (!ownAST) return [];
+
+	/** @type {SelectorRoot | undefined} */
+	let ast = undefined;
+
+	/** @type {Array<Node>} */
+	const ancestors = [];
+
+	{
+		/** @type {Node['parent']} */
+		let parent = rule.parent;
+
+		while (parent) {
+			ancestors.push(parent);
+			parent = parent.parent;
+		}
+	}
+
+	ancestors.reverse();
+
+	for (const child of ancestors) {
+		if (isAtRule(child) && child.name === 'scope') {
+			ast = parseSelector(':where(:scope)', result, child);
+			continue;
+		}
+
+		if (!isRule(child)) continue;
+
+		if (!isStandardSyntaxRule(child)) return [];
+
+		const childAST = parseSelector(getRuleSelector(child), result, child);
+
+		if (!childAST) return [];
+
+		if (ast) {
+			ast = resolveNestedSelector(childAST, ast);
+		} else {
+			ast = childAST;
+		}
+	}
+
+	const resolved = ownAST.map((selector) => {
+		if (!ast) {
+			return {
+				selector,
+				resolvedSelectors: selectorParser.root({
+					value: '',
+					nodes: [selector],
+				}),
+				nested: false,
+			};
+		}
+
+		return {
+			selector,
+			resolvedSelectors: resolveNestedSelector(
+				selectorParser.root({
+					nodes: [selector],
+					value: '',
+				}),
+				ast,
+			),
+			nested: true,
+		};
+	});
+
+	ruleCache.set(result, resolved);
+
+	return resolved;
+}

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

@@ -0,0 +1,30 @@
+import getConfigForFile from '../getConfigForFile.mjs';
+
+/** @import {InternalApi, LinterOptions, Config} from 'stylelint' */
+
+/**
+ * Get a value of the specified lint option or configuration.
+ *
+ * @template T
+ * @param {Object} options
+ * @param {InternalApi} options.stylelint
+ * @param {keyof LinterOptions & keyof Config} options.name
+ * @param {T} [options.default]
+ * @returns {Promise<T>}
+ */
+export default async function resolveOptionValue({
+	stylelint,
+	name,
+	default: defaultValue = undefined,
+}) {
+	const options = stylelint._options;
+	const value = options[name] ?? options.config?.[name];
+
+	if (value != null) {
+		return /** @type {T} */ (value);
+	}
+
+	const configForFile = await getConfigForFile({ stylelint, failIfNoConfig: false });
+
+	return configForFile?.config?.[name] ?? defaultValue;
+}

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

@@ -0,0 +1,144 @@
+import fs from 'node:fs';
+import module from 'node:module';
+import path from 'node:path';
+import process from 'node:process';
+
+import { fileURLToPath, pathToFileURL } from 'node:url';
+
+// TODO: refactor to use `import.meta.resolve()` when the `parent` argument
+// is available without the --experimental-import-meta-resolve flag
+// @see https://github.com/stylelint/stylelint/pull/8886
+import { resolve } from 'import-meta-resolve';
+
+/**
+ * @typedef {object} PnpApi
+ * @property {(specifier: string, issuer: string | null) => string | null} resolveRequest
+ * @property {(specifier: string, issuer: string | null) => string | null} resolveToUnqualified
+ */
+
+/**
+ * @typedef {typeof module & { findPnpApi?: (issuer: string) => PnpApi | null }} ModuleWithPnp
+ */
+
+/**
+ * Attempts to resolve a module specifier using Yarn PnP's API.
+ *
+ * When running under Yarn PnP, the import-meta-resolve polyfill doesn't work
+ * because it bypasses PnP's virtual filesystem. This function uses
+ * Module.findPnpApi() to get the PnP API for the target directory and
+ * resolves packages through it.
+ *
+ * @see https://yarnpkg.com/advanced/pnpapi
+ * @see https://github.com/stylelint/stylelint/issues/8971
+ * @param {string} specifier The module specifier to resolve.
+ * @param {string} issuer The directory to resolve from. Must end with /.
+ * @returns {string | undefined} The resolved path, or undefined if resolution fails.
+ */
+function resolvePnP(specifier, issuer) {
+	// Module.findPnpApi is added by Yarn PnP at runtime.
+	const mod = /** @type {ModuleWithPnp} */ (module);
+
+	if (typeof mod.findPnpApi !== 'function') {
+		return undefined;
+	}
+
+	const pnpapi = mod.findPnpApi(issuer);
+
+	if (!pnpapi) {
+		return undefined;
+	}
+
+	try {
+		// First try resolveRequest.
+		return pnpapi.resolveRequest(specifier, issuer) ?? undefined;
+	} catch {
+		// resolveRequest can fail for packages with only exports field. Fall
+		// back to resolveToUnqualified to locate the package, then use import-
+		// meta-resolve to handle the exports field resolution correctly.
+		try {
+			const packagePath = pnpapi.resolveToUnqualified(specifier, issuer);
+
+			if (!packagePath) {
+				return undefined;
+			}
+
+			// Use import-meta-resolve from the package's location to resolve
+			// its entry point.
+			const packageBase = pathToFileURL(path.join(packagePath, 'noop.js')).toString();
+			const resolved = resolve(specifier, packageBase);
+
+			return fileURLToPath(resolved);
+		} catch {
+			return undefined;
+		}
+	}
+}
+
+// TODO: Remove support for CommonJS-style filename-less and extension-less paths in the
+// next major release to align with ESM import behavior.
+const pathSuffixes = ['', '.js', '.json', `${path.sep}index.js`, `${path.sep}index.json`];
+
+const specifierSuffixes = ['', '.js', '.json', '/index.js', '/index.json'];
+
+/**
+ * Checks whether the given file exists as a file.
+ * @param {string} filename The file to check.
+ * @returns {boolean} `true` if the file exists and is a file, otherwise `false`.
+ */
+function existsFile(filename) {
+	return fs.statSync(filename, { throwIfNoEntry: false })?.isFile() ?? false;
+}
+
+/**
+ * @param {string} parent
+ * @param {string} lookup
+ * @returns {string | undefined}
+ */
+export default function resolveSilent(parent, lookup) {
+	if (path.isAbsolute(lookup)) {
+		for (const suffix of pathSuffixes) {
+			const filename = lookup + suffix;
+
+			if (existsFile(filename)) {
+				return filename;
+			}
+		}
+
+		return;
+	}
+
+	const base = pathToFileURL(path.resolve(parent, 'noop.js')).toString();
+
+	// In Yarn PnP environments, try PnP resolution first for bare specifiers.
+	// The import-meta-resolve polyfill doesn't work with PnP because it
+	// bypasses the virtual filesystem.
+	const isBareSpecifier = !lookup.startsWith('./') && !lookup.startsWith('../');
+
+	if (isBareSpecifier && process.versions.pnp) {
+		const issuer = path.resolve(parent) + path.sep;
+
+		// Try with suffixes for CommonJS compatibility.
+		for (const suffix of specifierSuffixes) {
+			const resolved = resolvePnP(lookup + suffix, issuer);
+
+			if (resolved && existsFile(resolved)) {
+				return resolved;
+			}
+		}
+	}
+
+	// Try ESM resolution with suffixes for CommonJS compatibility.
+	for (const suffix of specifierSuffixes) {
+		try {
+			const resolved = fileURLToPath(resolve(lookup + suffix, base));
+
+			if (existsFile(resolved)) {
+				return resolved;
+			}
+		} catch {
+			//
+		}
+	}
+
+	return undefined;
+}

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

@@ -0,0 +1,18 @@
+/**
+ * @type {import('stylelint').Utils['ruleMessages']}
+ */
+export default function ruleMessages(ruleName, messages) {
+	/** @type {import('stylelint').RuleMessages} */
+	const newMessages = {};
+
+	for (const [messageId, messageText] of Object.entries(messages)) {
+		if (typeof messageText === 'string') {
+			newMessages[messageId] = `${messageText} (${ruleName})`;
+		} else {
+			newMessages[messageId] = (...args) => `${messageText(...args)} (${ruleName})`;
+		}
+	}
+
+	// @ts-expect-error -- TS2322: Type 'RuleMessages' is not assignable to type 'R'.
+	return newMessages;
+}