@alexlit/lint-kit 182.2.0 → 182.4.0

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

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

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

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

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

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

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

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