@alexlit/lint-kit 182.2.0 → 182.3.0

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

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

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

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

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

@@ -1,90 +0,0 @@
-/** @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

@@ -1,9 +0,0 @@
-/**
- * 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

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

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

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