@alexlit/lint-kit 183.4.0 → 183.6.0

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

@@ -0,0 +1,18 @@
+/** @typedef {import('postcss').AtRule} AtRule */
+
+/**
+ * @param {AtRule} atRule
+ * @param {string} params
+ * @returns {AtRule} The atRulearation that was passed in.
+ */
+export default function setAtRuleParams(atRule, params) {
+	const raws = atRule.raws;
+
+	if (raws.params) {
+		raws.params.raw = params;
+	} else {
+		atRule.params = params;
+	}
+
+	return atRule;
+}

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

@@ -0,0 +1,18 @@
+/** @typedef {import('postcss').Declaration} Declaration */
+
+/**
+ * @param {Declaration} decl
+ * @param {string} value
+ * @returns {Declaration} The declaration that was passed in.
+ */
+export default function setDeclarationValue(decl, value) {
+	const raws = decl.raws;
+
+	if (raws.value) {
+		raws.value.raw = value;
+	} else {
+		decl.value = value;
+	}
+
+	return decl;
+}

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

@@ -0,0 +1,317 @@
+/*
+ * This file is based on ESLint's suppressions-service.js
+ * https://github.com/eslint/eslint/blob/v9.26.0/lib/services/suppressions-service.js
+ *
+ * Copyright OpenJS Foundation and other contributors, https://openjsf.org/
+ * Released under the MIT License:
+ * https://github.com/eslint/eslint/blob/main/LICENSE
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+
+import getRelativePath from './getRelativePath.mjs';
+import isPathNotFoundError from './isPathNotFoundError.mjs';
+
+/** @import {LintResult, Warning, SuppressedProblems} from 'stylelint' */
+
+/**
+ * Manages the suppressed problems.
+ */
+export class SuppressionsService {
+	filePath = '';
+	cwd = '';
+
+	/**
+	 * Creates a new instance of SuppressionsService.
+	 * @param {Object} options The options.
+	 * @param {string} options.filePath The path to the suppressions file.
+	 * @param {string} options.cwd The current working directory.
+	 */
+	constructor({ filePath, cwd }) {
+		this.filePath = filePath;
+		this.cwd = cwd;
+	}
+
+	/**
+	 * Updates the suppressions file based on the current problems and the provided rules.
+	 * If no rules are provided, all problems are suppressed.
+	 * This method now automatically prunes suppressions that no longer exist.
+	 * @param {LintResult[] | undefined} results The lint results.
+	 * @param {string[] | undefined} rules The rules to suppress.
+	 * @returns {Promise<void>}
+	 */
+	async suppress(results, rules) {
+		if (results === undefined) return;
+
+		const suppressions = await this.load();
+
+		for (const result of results) {
+			const source = result.source;
+
+			if (!source) continue;
+
+			const relativePath = path.isAbsolute(source) ? getRelativePath(this.cwd, source) : source;
+
+			const problemsByRule = SuppressionsService.countProblemsByRule(result.warnings);
+
+			for (const [rule, ruleData] of problemsByRule) {
+				if (rules && !rules.includes(rule)) continue;
+
+				if (!suppressions.has(relativePath)) {
+					suppressions.set(relativePath, new Map());
+				}
+
+				const fileRules = suppressions.get(relativePath);
+
+				if (!fileRules) continue;
+
+				fileRules.set(rule, ruleData);
+			}
+		}
+
+		const { unused } = this.applySuppressions(results, suppressions);
+
+		const prunedSuppressions = this.#prune(unused, suppressions);
+
+		return this.#save(prunedSuppressions);
+	}
+
+	/**
+	 * Removes old, unused suppressions for problems that do not occur anymore.
+	 * @param {SuppressedProblems} unused The unused suppressions.
+	 * @param {SuppressedProblems} suppressions The suppressions.
+	 * @returns {SuppressedProblems} The pruned suppressions.
+	 */
+	#prune(unused, suppressions) {
+		for (const [file, rules] of unused) {
+			if (!suppressions.has(file)) continue;
+
+			for (const [rule, ruleData] of rules) {
+				const fileRules = suppressions.get(file);
+
+				if (!fileRules) continue;
+
+				const suppressionData = fileRules.get(rule);
+
+				if (!suppressionData) continue;
+
+				const suppressionsCount = suppressionData.count;
+				const problemsCount = ruleData.count;
+
+				if (suppressionsCount === problemsCount) {
+					// Remove unused rules
+					fileRules.delete(rule);
+				} else {
+					// Update the count to match the new number of problems
+					const ruleDataForUpdate = fileRules.get(rule);
+
+					if (ruleDataForUpdate) {
+						ruleDataForUpdate.count -= problemsCount;
+					}
+				}
+			}
+
+			// Cleanup files with no rules
+			const fileRulesForCleanup = suppressions.get(file);
+
+			if (fileRulesForCleanup && fileRulesForCleanup.size === 0) {
+				suppressions.delete(file);
+			}
+		}
+
+		return suppressions;
+	}
+
+	/**
+	 * Checks the provided suppressions against the lint results.
+	 *
+	 * For each file, counts the number of problems per rule.
+	 * For each rule in each file, compares the number of problems against the counter from the suppressions file.
+	 * If the number of problems is less or equal to the counter, warnings are ignored.
+	 * Otherwise, all problems are reported as usual.
+	 * @param {LintResult[]} results The lint results.
+	 * @param {SuppressedProblems} suppressions The suppressions.
+	 * @returns {{
+	 *   results: LintResult[],
+	 *   unused: SuppressedProblems
+	 * }} The updated results and the unused suppressions.
+	 */
+	applySuppressions(results, suppressions) {
+		/**
+		 * We copy the results to avoid modifying the original objects
+		 * We remove only result warnings that are matched and hence suppressed
+		 * We leave the rest untouched to minimize the risk of losing parts of the original data
+		 */
+		const clonedResults = results.map((r) => {
+			return {
+				...r,
+				warnings: structuredClone(r.warnings),
+			};
+		});
+
+		/** @type {SuppressedProblems} */
+		const unused = new Map();
+
+		for (const result of clonedResults) {
+			const source = result.source;
+
+			if (!source) continue;
+
+			const relativePath = path.isAbsolute(source) ? getRelativePath(this.cwd, source) : source;
+
+			if (!suppressions.has(relativePath)) continue;
+
+			const problemsByRule = SuppressionsService.countProblemsByRule(result.warnings);
+
+			for (const [rule, ruleStats] of problemsByRule) {
+				const fileRules = suppressions.get(relativePath);
+
+				if (!fileRules) continue;
+
+				const ruleData = fileRules.get(rule);
+
+				if (!ruleData) continue;
+
+				const suppressionsCount = ruleData.count;
+
+				if (!ruleStats) continue;
+
+				const problemsCount = ruleStats.count;
+
+				// Suppress warnings if the number of problems is less or equal to the suppressions count
+				if (problemsCount <= suppressionsCount) {
+					result.warnings = result.warnings.filter((warning) => warning.rule !== rule);
+				}
+
+				// Update the count to match the new number of problems, otherwise remove the rule entirely
+				if (problemsCount < suppressionsCount) {
+					if (!unused.has(relativePath)) {
+						unused.set(relativePath, new Map());
+					}
+
+					const unusedFileRules = unused.get(relativePath);
+
+					if (unusedFileRules && !unusedFileRules.has(rule)) {
+						unusedFileRules.set(rule, { count: 0 });
+					}
+
+					if (unusedFileRules) {
+						const unusedRuleData = unusedFileRules.get(rule);
+
+						if (unusedRuleData) {
+							unusedRuleData.count = suppressionsCount - problemsCount;
+						}
+					}
+				}
+			}
+
+			// Mark as unused all the suppressions that were not matched against a rule
+			const fileRulesForUnused = suppressions.get(relativePath);
+
+			if (fileRulesForUnused) {
+				for (const [rule, savedEntry] of fileRulesForUnused) {
+					if (problemsByRule.has(rule)) continue;
+
+					if (!savedEntry) continue;
+
+					if (!unused.has(relativePath)) {
+						unused.set(relativePath, new Map());
+					}
+
+					const unusedFileRulesForSet = unused.get(relativePath);
+
+					if (!unusedFileRulesForSet) continue;
+
+					unusedFileRulesForSet.set(rule, savedEntry);
+				}
+			}
+		}
+
+		return {
+			results: clonedResults,
+			unused,
+		};
+	}
+
+	/**
+	 * Loads the suppressions file.
+	 * @throws {Error} If the suppressions file cannot be parsed.
+	 * @returns {Promise<SuppressedProblems>} The suppressions.
+	 */
+	async load() {
+		try {
+			const data = await fs.promises.readFile(this.filePath, 'utf8');
+			const parsed = JSON.parse(data);
+
+			// Convert Object to Map
+			const suppressions = new Map();
+
+			for (const [filePath, rules] of Object.entries(parsed)) {
+				const rulesMap = new Map();
+
+				for (const [ruleName, ruleData] of Object.entries(rules)) {
+					rulesMap.set(ruleName, ruleData);
+				}
+
+				suppressions.set(filePath, rulesMap);
+			}
+
+			return suppressions;
+		} catch (err) {
+			if (isPathNotFoundError(err)) {
+				return new Map();
+			}
+
+			throw new Error(`Failed to parse suppressions file at ${this.filePath}`, { cause: err });
+		}
+	}
+
+	/**
+	 * Updates the suppressions file.
+	 * @param {SuppressedProblems} suppressions The suppressions to save.
+	 * @returns {Promise<void>}
+	 */
+	#save(suppressions) {
+		// Convert Map to Object for JSON serialization
+		/** @type {Record<string, Record<string, {count: number}>>} */
+		const obj = {};
+
+		for (const [filePath, rulesMap] of suppressions) {
+			obj[filePath] = {};
+
+			for (const [ruleName, ruleData] of rulesMap) {
+				obj[filePath][ruleName] = ruleData;
+			}
+		}
+
+		return fs.promises.writeFile(this.filePath, `${JSON.stringify(obj, null, 2)}\n`);
+	}
+
+	/**
+	 * Counts the problems by rule, ignoring warnings.
+	 * @param {Warning[]} warnings The warnings to count.
+	 * @returns {Map<string, {count: number}>} The number of problems by rule.
+	 */
+	static countProblemsByRule(warnings) {
+		/** @type {Map<string, {count: number}>} */
+		const totals = new Map();
+
+		for (const warning of warnings) {
+			const rule = warning.rule;
+
+			if (warning.severity !== 'error' || !rule) continue;
+
+			if (!totals.has(rule)) {
+				totals.set(rule, { count: 0 });
+			}
+
+			const ruleData = totals.get(rule);
+
+			if (ruleData) {
+				ruleData.count += 1;
+			}
+		}
+
+		return totals;
+	}
+}

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

@@ -0,0 +1,23 @@
+import { fileURLToPath } from 'node:url';
+
+/**
+ * Converts a URL to a file path string, or returns the string as-is.
+ *
+ * @overload
+ * @param {string | URL} cwd
+ * @returns {string}
+ *
+ * @overload
+ * @param {undefined} cwd
+ * @returns {undefined}
+ *
+ * @overload
+ * @param {string | URL | undefined} cwd
+ * @returns {string | undefined}
+ *
+ * @param {string | URL | undefined} cwd
+ * @returns {string | undefined}
+ */
+export default function toPath(cwd) {
+	return cwd instanceof URL ? fileURLToPath(cwd) : cwd;
+}

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

@@ -0,0 +1,90 @@
+/** @typedef {import('postcss').Node} Node */
+/** @typedef {import('postcss').Source} NodeSource */
+
+/**
+ * @param {Node} node
+ * @returns {node is import('postcss').Root}
+ */
+export function isRoot(node) {
+	return node.type === 'root';
+}
+
+/**
+ * @param {Node} node
+ * @returns {node is import('postcss').Rule}
+ */
+export function isRule(node) {
+	return node.type === 'rule';
+}
+
+/**
+ * @param {Node} node
+ * @returns {node is import('postcss').AtRule}
+ */
+export function isAtRule(node) {
+	return node.type === 'atrule';
+}
+
+/**
+ * @param {Node} node
+ * @returns {node is import('postcss').Comment}
+ */
+export function isComment(node) {
+	return node.type === 'comment';
+}
+
+/**
+ * @param {Node} node
+ * @returns {node is import('postcss').Declaration}
+ */
+export function isDeclaration(node) {
+	return node.type === 'decl';
+}
+
+/**
+ * @param {Node} node
+ * @returns {node is import('postcss').Document}
+ */
+export function isDocument(node) {
+	return node.type === 'document';
+}
+
+/**
+ * @param {import('postcss-value-parser').Node} node
+ * @returns {node is import('postcss-value-parser').DivNode}
+ */
+export function isValueDiv(node) {
+	return node.type === 'div';
+}
+
+/**
+ * @param {import('postcss-value-parser').Node} node
+ * @returns {node is import('postcss-value-parser').FunctionNode}
+ */
+export function isValueFunction(node) {
+	return node.type === 'function';
+}
+
+/**
+ * @param {import('postcss-value-parser').Node} node
+ * @returns {node is import('postcss-value-parser').SpaceNode}
+ */
+export function isValueSpace(node) {
+	return node.type === 'space';
+}
+
+/**
+ * @param {import('postcss-value-parser').Node} node
+ * @returns {node is import('postcss-value-parser').WordNode}
+ */
+export function isValueWord({ type }) {
+	return type === 'word';
+}
+
+/**
+ * @param {Node} node
+ * @returns {node is (Node & {source: NodeSource})}
+ */
+export function hasSource(node) {
+	return Boolean(node.source);
+}

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

@@ -0,0 +1,9 @@
+/**
+ * Unite two or more sets
+ *
+ * @param {Iterable<string>[]} args
+ * @see {@link https://github.com/microsoft/TypeScript/issues/57228|GitHub}
+ */
+export default function uniteSets(...args) {
+	return new Set([...args].reduce((result, set) => [...result, ...set], []));
+}

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

@@ -0,0 +1,29 @@
+import { isPlainObject } from './validateTypes.mjs';
+
+/**
+ * Check whether the variable is an object and all its properties are one or more values
+ * that satisfy the specified validator(s):
+ *
+ * @example
+ * ignoreProperties = {
+ *   value1: ["item11", "item12", "item13"],
+ *   value2: "item2",
+ * };
+ * validateObjectWithArrayProps(isString)(ignoreProperties);
+ * //=> true
+ *
+ * @typedef {(value: unknown) => boolean} Validator
+ * @param {...Validator} validators
+ * @returns {Validator}
+ */
+export default function validateObjectWithArrayProps(...validators) {
+	return (value) => {
+		if (!isPlainObject(value)) {
+			return false;
+		}
+
+		return Object.values(value)
+			.flat()
+			.every((item) => validators.some((v) => v(item)));
+	};
+}

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

@@ -0,0 +1,28 @@
+import { isPlainObject } from './validateTypes.mjs';
+
+/**
+ * Check whether the variable is an object and all its properties agree with the provided validator.
+ *
+ * @example
+ * config = {
+ *   value1: 1,
+ *   value2: 2,
+ *   value3: 3,
+ * };
+ * validateObjectWithProps(isNumber)(config);
+ * //=> true
+ *
+ * @param {(value: unknown) => boolean} validator
+ * @returns {(value: unknown) => boolean}
+ */
+export default function validateObjectWithProps(validator) {
+	return (value) => {
+		if (!isPlainObject(value)) {
+			return false;
+		}
+
+		return Object.values(value).every((item) => {
+			return validator(item);
+		});
+	};
+}

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

@@ -0,0 +1,176 @@
+import arrayEqual from './arrayEqual.mjs';
+import { isPlainObject } from './validateTypes.mjs';
+
+const IGNORED_OPTIONS = new Set(['severity', 'message', 'url', 'reportDisables', 'disableFix']);
+const REPORT_OPTIONS = new Set([
+	'reportDescriptionlessDisables',
+	'reportInvalidScopeDisables',
+	'reportNeedlessDisables',
+	'reportUnscopedDisables',
+]);
+
+/** @typedef {import('stylelint').RuleOptions} RuleOptions */
+/** @typedef {import('stylelint').RuleOptionsPossible} RuleOptionsPossible */
+
+/**
+ * @type {import('stylelint').Utils['validateOptions']}
+ */
+export default function validateOptions(result, ruleName, ...optionDescriptions) {
+	const mustValidate = result.stylelint.config?.validate;
+
+	if (!mustValidate) return true;
+
+	let noErrors = true;
+
+	for (const optionDescription of optionDescriptions) {
+		validate(optionDescription, ruleName, complain);
+	}
+
+	/**
+	 * @param {string} message
+	 */
+	function complain(message) {
+		noErrors = false;
+		result.warn(message, {
+			stylelintType: 'invalidOption',
+		});
+		result.stylelint.stylelintError = true;
+	}
+
+	return noErrors;
+}
+
+/**
+ * @param {RuleOptions} opts
+ * @param {string} ruleName
+ * @param {(message: string) => void} complain
+ */
+function validate({ possible, actual, optional }, ruleName, complain) {
+	if (actual === false && !REPORT_OPTIONS.has(ruleName)) {
+		return complain(
+			`Invalid option value "false" for rule "${ruleName}". Are you trying to disable this rule? If so use "null" instead`,
+		);
+	}
+
+	// `null` means to turn off a rule.
+	if (actual === null || arrayEqual(actual, [null])) {
+		return;
+	}
+
+	const nothingPossible =
+		possible === undefined ||
+		possible === null ||
+		(Array.isArray(possible) && possible.length === 0) ||
+		(isPlainObject(possible) && Object.keys(possible).length === 0);
+
+	if (nothingPossible && actual === true) {
+		return;
+	}
+
+	if (actual === undefined) {
+		if (nothingPossible || optional) {
+			return;
+		}
+
+		complain(`Expected option value for rule "${ruleName}"`);
+
+		return;
+	}
+
+	if (nothingPossible) {
+		if (optional) {
+			complain(
+				`Incorrect configuration for rule "${ruleName}". Rule should have "possible" values for options validation`,
+			);
+
+			return;
+		}
+
+		complain(`Unexpected option value ${stringify(actual)} for rule "${ruleName}"`);
+
+		return;
+	}
+
+	if (typeof possible === 'function') {
+		if (!possible(actual)) {
+			complain(`Invalid option ${stringify(actual)} for rule "${ruleName}"`);
+		}
+
+		return;
+	}
+
+	// If `possible` is an array instead of an object ...
+	if (Array.isArray(possible)) {
+		for (const a of [actual].flat()) {
+			if (isValid(possible, a)) {
+				continue;
+			}
+
+			complain(`Invalid option value ${stringify(a)} for rule "${ruleName}"`);
+		}
+
+		return;
+	}
+
+	// If actual is NOT an object ...
+	if (!isPlainObject(actual) || typeof actual !== 'object' || actual === null) {
+		complain(
+			`Invalid option value ${stringify(actual)} for rule "${ruleName}": should be an object`,
+		);
+
+		return;
+	}
+
+	for (const [optionName, optionValue] of Object.entries(actual)) {
+		if (IGNORED_OPTIONS.has(optionName)) {
+			continue;
+		}
+
+		const possibleValue = possible && possible[optionName];
+
+		if (!possibleValue) {
+			complain(`Invalid option name "${optionName}" for rule "${ruleName}"`);
+
+			continue;
+		}
+
+		for (const a of [optionValue].flat()) {
+			if (isValid(possibleValue, a)) {
+				continue;
+			}
+
+			complain(`Invalid value ${stringify(a)} for option "${optionName}" of rule "${ruleName}"`);
+		}
+	}
+}
+
+/**
+ * @param {RuleOptionsPossible | RuleOptionsPossible[]} possible
+ * @param {unknown} actual
+ * @returns {boolean}
+ */
+function isValid(possible, actual) {
+	for (const possibility of [possible].flat()) {
+		if (typeof possibility === 'function' && possibility(actual)) {
+			return true;
+		}
+
+		if (actual === possibility) {
+			return true;
+		}
+	}
+
+	return false;
+}
+
+/**
+ * @param {unknown} value
+ * @returns {string}
+ */
+function stringify(value) {
+	if (typeof value === 'string') {
+		return `"${value}"`;
+	}
+
+	return `"${JSON.stringify(value)}"`;
+}