@alexlit/lint-kit 182.1.0 → 182.2.0

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

@@ -0,0 +1,35 @@
+/** @import { Node as PostcssNode } from 'postcss' */
+import { isAtRule } from './typeGuards.mjs';
+
+/**
+ * Adjust the text in EditInfo to include a semicolon when needed.
+ *
+ * @param {PostcssNode} node
+ * @param {{range: [number, number], text: string}} fixData
+ * @returns {{range: [number, number], text: string}}
+ */
+export default function addSemicolonForEditInfo(node, fixData) {
+	const { parent } = node;
+
+	if (!parent) return fixData;
+
+	if (node.type === 'decl') {
+		if (parent.raws.semicolon || parent.last !== node) {
+			return {
+				...fixData,
+				text: `${fixData.text};`,
+			};
+		}
+	}
+
+	if (isAtRule(node)) {
+		if (!node.nodes && (parent.raws.semicolon || parent.last !== node)) {
+			return {
+				...fixData,
+				text: `${fixData.text};`,
+			};
+		}
+	}
+
+	return fixData;
+}

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

@@ -0,0 +1,13 @@
+/**
+ * Ensures the given rule name is appended to the provided string.
+ *
+ * If the string does not already end with the rule name in parentheses, the rule name is appended in parentheses.
+ *
+ * @param {string} string - The message to which the rule name may be appended
+ * @param {string} ruleName - The rule name to append
+ *
+ * @returns {string} The provided string with the given rule name appended
+ */
+export default function appendRuleName(string, ruleName) {
+	return !string.endsWith(`(${ruleName})`) ? `${string} (${ruleName})` : string;
+}

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

@@ -0,0 +1,14 @@
+/**
+ * Tests if two arrays are equal.
+ *
+ * @param {unknown} a
+ * @param {unknown} b
+ * @returns {boolean}
+ */
+export default function arrayEqual(a, b) {
+	if (!Array.isArray(a) || !Array.isArray(b)) return false;
+
+	if (a.length !== b.length) return false;
+
+	return a.every((elem, index) => elem === b[index]);
+}

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

@@ -0,0 +1,28 @@
+import { isAtRule, isRule } from './typeGuards.mjs';
+
+/**
+ * @param {import('postcss').Container} statement
+ * @param {{ noRawBefore: boolean }} options
+ * @returns {string}
+ */
+export default function beforeBlockString(statement, { noRawBefore } = { noRawBefore: false }) {
+	let result = '';
+
+	const before = statement.raws.before || '';
+
+	if (!noRawBefore) {
+		result += before;
+	}
+
+	if (isRule(statement)) {
+		result += statement.selector;
+	} else if (isAtRule(statement)) {
+		result += `@${statement.name}${statement.raws.afterName || ''}${statement.params}`;
+	} else {
+		return '';
+	}
+
+	result += statement.raws.between || '';
+
+	return result;
+}

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

@@ -0,0 +1,19 @@
+import beforeBlockString from './beforeBlockString.mjs';
+import hasBlock from './hasBlock.mjs';
+import rawNodeString from './rawNodeString.mjs';
+
+/**
+ * Return a CSS statement's block -- the string that starts and `{` and ends with `}`.
+ *
+ * If the statement has no block (e.g. `@import url(foo.css);`), returns an empty string.
+ *
+ * @param {import('postcss').Container} statement
+ * @returns {string}
+ */
+export default function blockString(statement) {
+	if (!hasBlock(statement)) {
+		return '';
+	}
+
+	return rawNodeString(statement).slice(beforeBlockString(statement).length);
+}

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

@@ -0,0 +1,8 @@
+/**
+ * @param {string} source
+ * @param {string} [blurChar]
+ * @returns {string}
+ */
+export default function blurInterpolation(source, blurChar = ' ') {
+	return source.replace(/[#@{}]+/g, blurChar);
+}

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

@@ -0,0 +1,68 @@
+import dynamicImport from './dynamicImport.mjs';
+
+/** Maximum number of modules to cache to prevent unbounded memory growth. */
+const MAX_CACHE_SIZE = 1000;
+
+/** Time-to-live in milliseconds. Exported for tests. */
+export const TTL_MS = 30 * 60 * 1000;
+
+/**
+ * @typedef {Object} CacheEntry
+ * @property {Promise<any>} promise
+ * @property {number} timestamp
+ */
+
+/** @type {Map<string, CacheEntry>} */
+const moduleCache = new Map();
+
+/**
+ * Cached dynamic import - stores the Promise to avoid repeated resolution.
+ *
+ * While Node.js caches ES modules, we can avoid repeated async overhead by
+ * caching the Promise itself.
+ *
+ * @param {string} modulePath
+ * @returns {Promise<any>}
+ */
+export default function cachedImport(modulePath) {
+	const cached = moduleCache.get(modulePath);
+
+	if (cached) {
+		// Check if entry has expired.
+		if (Date.now() - cached.timestamp > TTL_MS) {
+			moduleCache.delete(modulePath);
+		} else {
+			return cached.promise;
+		}
+	}
+
+	const importPromise = dynamicImport(modulePath).catch((error) => {
+		// Remove failed imports from cache so they can be retried.
+		moduleCache.delete(modulePath);
+		throw error;
+	});
+
+	// Evict oldest entry if cache is full.
+	if (moduleCache.size >= MAX_CACHE_SIZE) {
+		const oldestKey = moduleCache.keys().next().value;
+
+		if (oldestKey) {
+			moduleCache.delete(oldestKey);
+		}
+	}
+
+	moduleCache.set(modulePath, {
+		promise: importPromise,
+		timestamp: Date.now(),
+	});
+
+	return importPromise;
+}
+
+/**
+ * Clear the module cache. Useful for testing or when modules need to be
+ * reloaded.
+ */
+export function clearModuleCache() {
+	moduleCache.clear();
+}

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

@@ -0,0 +1,71 @@
+import Result from 'postcss/lib/result';
+
+import getLexer from './getLexer.mjs';
+import getStylelintRule from './getStylelintRule.mjs';
+import { isPlainObject } from './validateTypes.mjs';
+import normalizeRuleSettings from '../normalizeRuleSettings.mjs';
+
+/**
+ * @type {import('stylelint').Utils['checkAgainstRule']}
+ */
+export default async function checkAgainstRule(options, callback) {
+	if (!isPlainObject(options)) throw new Error('Expected an options object');
+
+	if (!callback) throw new Error('Expected a callback function');
+
+	const { ruleName, ruleSettings, root, result, context = {} } = options;
+
+	if (!ruleName) throw new Error('Expected a "ruleName" option');
+
+	const rule = await getStylelintRule(ruleName, result?.stylelint?.config);
+
+	if (!rule) throw new Error(`Rule "${ruleName}" does not exist`);
+
+	if (!ruleSettings) throw new Error('Expected a "ruleSettings" option');
+
+	if (!root) throw new Error('Expected a "root" option');
+
+	const settings = normalizeRuleSettings(ruleSettings, rule);
+
+	if (!settings) {
+		return;
+	}
+
+	const tmpPostcssResult = new Result(
+		// NOTE: The first argument is unused, so passing `undefined` raises no problems.
+		//       But this PostCSS's behavior may change in the future.
+		// @ts-expect-error -- TS2345: Argument of type 'undefined' is not assignable to parameter of type 'Processor'.
+		undefined,
+		undefined,
+		undefined,
+	);
+
+	/** @type {import('stylelint').StylelintPostcssResult} */
+	const stylelint = result?.stylelint ?? {
+		ruleSeverities: {},
+		customMessages: {},
+		customUrls: {},
+		ruleMetadata: {},
+		fixersData: {},
+		rangesOfComputedEditInfos: [],
+		disabledRanges: {},
+		lexer: getLexer({}),
+	};
+
+	// @ts-expect-error -- TS2339: Property 'stylelint' does not exist on type 'Result<undefined>'.
+	tmpPostcssResult.stylelint = stylelint;
+
+	const [primary, secondary] = settings;
+	const ruleFunc = rule(primary, secondary || {}, context);
+
+	await ruleFunc(
+		root,
+
+		// NOTE: This temporary PostCSS result doesn't have a property for Stylelint use.
+		//       Problems may occur if some rules use the property.
+		// @ts-expect-error -- TS2345: Argument of type 'Result' is not assignable to parameter of type 'PostcssResult'.
+		tmpPostcssResult,
+	);
+
+	for (const warning of tmpPostcssResult.warnings()) callback(warning);
+}

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

@@ -0,0 +1,105 @@
+import { EOL } from 'node:os';
+
+import { distance } from 'fastest-levenshtein';
+import picocolors from 'picocolors';
+
+const { cyan, red } = picocolors;
+
+/**
+ * @param {{ [key: string]: { alias?: string } }} allowedOptions
+ * @returns {string[]}
+ */
+const buildAllowedOptions = (allowedOptions) => {
+	const options = Object.keys(allowedOptions);
+
+	for (const { alias } of Object.values(allowedOptions)) {
+		if (alias) {
+			options.push(alias);
+		}
+	}
+
+	options.sort();
+
+	return options;
+};
+
+/**
+ * @param {string[]} all
+ * @param {string} invalid
+ * @returns {null|string}
+ */
+const suggest = (all, invalid) => {
+	const maxThreshold = 10;
+
+	for (let threshold = 1; threshold <= maxThreshold; threshold++) {
+		const suggestion = all.find((option) => distance(option, invalid) <= threshold);
+
+		if (suggestion) {
+			return suggestion;
+		}
+	}
+
+	return null;
+};
+
+/**
+ * Converts a string to kebab case.
+ * For example, `kebabCase('oneTwoThree') === 'one-two-three'`.
+ * @param {string} opt
+ * @returns {string}
+ */
+const kebabCase = (opt) => {
+	const matches = opt.match(/[A-Z]?[a-z]+|[A-Z]|[0-9]+/g);
+
+	if (matches) {
+		return matches.map((s) => s.toLowerCase()).join('-');
+	}
+
+	return '';
+};
+
+/**
+ * @param {string} opt
+ * @returns {string}
+ */
+const cliOption = (opt) => {
+	if (opt.length === 1) {
+		return `"-${opt}"`;
+	}
+
+	return `"--${kebabCase(opt)}"`;
+};
+
+/**
+ * @param {string} invalid
+ * @param {string|null} suggestion
+ * @returns {string}
+ */
+const buildMessageLine = (invalid, suggestion) => {
+	let line = `Invalid option ${red(cliOption(invalid))}.`;
+
+	if (suggestion) {
+		line += ` Did you mean ${cyan(cliOption(suggestion))}?`;
+	}
+
+	return line + EOL;
+};
+
+/**
+ * @param {{ [key: string]: any }} allowedOptions
+ * @param {{ [key: string]: any }} inputOptions
+ * @returns {string}
+ */
+export default function checkInvalidCLIOptions(allowedOptions, inputOptions) {
+	const allOptions = buildAllowedOptions(allowedOptions);
+
+	return Object.keys(inputOptions)
+		.filter((opt) => !allOptions.includes(opt))
+		.map((opt) => kebabCase(opt))
+		.reduce((msg, invalid) => {
+			// NOTE: No suggestion for shortcut options because it's too difficult
+			const suggestion = invalid.length >= 2 ? suggest(allOptions, invalid) : null;
+
+			return msg + buildMessageLine(invalid, suggestion);
+		}, '');
+}

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

@@ -0,0 +1,74 @@
+import { assertString, isString } from './validateTypes.mjs';
+import { isComment } from './typeGuards.mjs';
+
+export const DISABLE_COMMAND = '-disable';
+export const DISABLE_LINE_COMMAND = '-disable-line';
+export const DISABLE_NEXT_LINE_COMMAND = '-disable-next-line';
+export const ENABLE_COMMAND = '-enable';
+
+const ALL_COMMANDS = new Set([
+	DISABLE_COMMAND,
+	DISABLE_LINE_COMMAND,
+	DISABLE_NEXT_LINE_COMMAND,
+	ENABLE_COMMAND,
+]);
+
+export const DEFAULT_CONFIGURATION_COMMENT = 'stylelint';
+
+/**
+ * Extract a command from a given comment.
+ *
+ * @param {string} commentText
+ * @param {string} [configurationComment]
+ * @returns {string}
+ */
+export function extractConfigurationComment(
+	commentText,
+	configurationComment = DEFAULT_CONFIGURATION_COMMENT,
+) {
+	if (!commentText) return commentText;
+
+	const [command] = commentText.split(/\s/, 1);
+
+	assertString(command);
+
+	return command.replace(configurationComment, '');
+}
+
+/**
+ * Tests if the given comment is a Stylelint command.
+ *
+ * @param {string | import('postcss').Node} textOrNode
+ * @param {string} [configurationComment]
+ * @returns {boolean}
+ */
+export function isConfigurationComment(
+	textOrNode,
+	configurationComment = DEFAULT_CONFIGURATION_COMMENT,
+) {
+	const commentText = isString(textOrNode)
+		? textOrNode
+		: isComment(textOrNode)
+			? textOrNode.text
+			: undefined;
+
+	if (!commentText) return false;
+
+	const command = extractConfigurationComment(commentText, configurationComment);
+
+	return command !== undefined && ALL_COMMANDS.has(command);
+}
+
+/**
+ * Get full stylelint command
+ *
+ * @param {string} command
+ * @param {string} [configurationComment]
+ * @returns {string}
+ */
+export function getConfigurationComment(
+	command,
+	configurationComment = DEFAULT_CONFIGURATION_COMMENT,
+) {
+	return `${configurationComment}${command}`;
+}

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

@@ -0,0 +1,52 @@
+import { isString } from './validateTypes.mjs';
+
+/** @typedef {false | { match: string, pattern: string, substring: string }} ReturnValue */
+
+/**
+ * Checks if a string contains a value. The comparison value can be a string or
+ * an array of strings.
+ *
+ * Any strings starting and ending with `/` are ignored. Use the
+ * matchesStringOrRegExp() util to match regexes.
+ *
+ * @template {unknown} T
+ * @param {string} input
+ * @param {T | T[]} comparison
+ * @returns {ReturnValue}
+ */
+export default function containsString(input, comparison) {
+	if (!Array.isArray(comparison)) {
+		return testAgainstString(input, comparison);
+	}
+
+	for (const comparisonItem of comparison) {
+		const testResult = testAgainstString(input, comparisonItem);
+
+		if (testResult) {
+			return testResult;
+		}
+	}
+
+	return false;
+}
+
+/**
+ * @param {string} value
+ * @param {unknown} comparison
+ * @returns {ReturnValue}
+ */
+function testAgainstString(value, comparison) {
+	if (!comparison) return false;
+
+	if (!isString(comparison)) return false;
+
+	if (comparison.startsWith('/') && comparison.endsWith('/')) {
+		return false;
+	}
+
+	if (value.includes(comparison)) {
+		return { match: value, pattern: comparison, substring: comparison };
+	}
+
+	return false;
+}

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

@@ -0,0 +1,19 @@
+/**
+ * Create a map with unique sets of values from a record.
+ *
+ * @template T
+ * @param {Record<string, T | T[]>} record
+ * @returns {Map<string, Set<T>>}
+ */
+export default function createMapWithSet(record) {
+	/** @type {Map<string, Set<T>>} */
+	const map = new Map();
+
+	for (const [key, value] of Object.entries(record)) {
+		const list = Array.isArray(value) ? value : [value];
+
+		map.set(key, new Set(list));
+	}
+
+	return map;
+}

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

@@ -0,0 +1,13 @@
+import { isAbsolute } from 'node:path';
+import { pathToFileURL } from 'node:url';
+
+/**
+ * Dynamic import wrapper for compatibility with absolute paths on Windows
+ *
+ * @see https://github.com/stylelint/stylelint/issues/7382
+ *
+ * @param {string} path
+ */
+export default function dynamicImport(path) {
+	return import(isAbsolute(path) ? pathToFileURL(path).toString() : path);
+}

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

@@ -0,0 +1,59 @@
+import { isAtRule, isRoot, isRule } from './typeGuards.mjs';
+
+/** @typedef {import('postcss').Root} Root */
+/** @typedef {import('postcss').Root} Document */
+/** @typedef {import('postcss').Node} PostcssNode */
+/** @typedef {import('postcss').Container} PostcssContainerNode */
+/** @typedef {import('postcss').Declaration} Declaration */
+/** @typedef {(callbackFn: (decl: Declaration, index: number, decls: Declaration[]) => void) => void} EachDeclaration */
+
+/**
+ * @param {PostcssNode} node
+ * @returns {node is PostcssContainerNode}
+ */
+function isContainerNode(node) {
+	return isRule(node) || isAtRule(node) || isRoot(node);
+}
+
+/**
+ * In order to accommodate nested blocks (postcss-nested),
+ * we need to run a shallow loop (instead of eachDecl() or eachRule(),
+ * which loop recursively) and allow each nested block to accumulate
+ * its own list of properties -- so that a property in a nested rule
+ * does not conflict with the same property in the parent rule
+ * executes a provided function once for each declaration block.
+ *
+ * @param {Root | Document} root - root element of file.
+ * @param {(eachDecl: EachDeclaration) => void} callback - Function to execute for each declaration block
+ *
+ * @returns {void}
+ */
+export default function eachDeclarationBlock(root, callback) {
+	/**
+	 * @param {PostcssNode} statement
+	 *
+	 * @returns {void}
+	 */
+	function each(statement) {
+		if (!isContainerNode(statement)) return;
+
+		if (statement.nodes && statement.nodes.length) {
+			/** @type {Declaration[]} */
+			const decls = [];
+
+			for (const node of statement.nodes) {
+				if (node.type === 'decl') {
+					decls.push(node);
+				}
+
+				each(node);
+			}
+
+			if (decls.length) {
+				callback(decls.forEach.bind(decls));
+			}
+		}
+	}
+
+	each(root);
+}

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

@@ -0,0 +1,22 @@
+import { isRoot } from './typeGuards.mjs';
+
+/** @import { Node } from 'postcss' */
+
+export const STOP = 'STOP';
+
+/**
+ * Iterates over each node up to the root node.
+ *
+ * @param {Node} node
+ * @param {(node: Node) => void | STOP} callback
+ * @returns {void}
+ */
+export default function eachNodeUpToRoot(node, callback) {
+	let currentNode = node.parent;
+
+	while (currentNode && !isRoot(currentNode)) {
+		if (callback(currentNode) === STOP) break;
+
+		currentNode = currentNode.parent;
+	}
+}

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

@@ -0,0 +1,83 @@
+import process from 'node:process';
+
+// Each code must be unique across all warning types.
+const DEPRECATION_CODES = {
+	// COMMONJS_PLUGINS: '001', // Can be used in Node.js 20.19+
+	// COMMONJS_NODEJS_API: '002', // Can be used in Node.js 20.19+
+	// RESULT_OUTPUT_PROPERTY: '003', // Removed in 17.0.0
+	// GITHUB_FORMATTER: '004', // Removed in 17.0.0
+	CONTEXT_FIX: '005',
+	RULE: '006', // either removal or renaming
+	// REPORT_AMBIGUOUS_POSITION: '007', // Removed in 17.0.0
+};
+
+const EXPERIMENTAL_CODES = {
+	SUPPRESSIONS: '101',
+};
+
+const emittedWarnings = new Set();
+
+/**
+ * @typedef {DEPRECATION_CODES[keyof DEPRECATION_CODES] |
+ *           EXPERIMENTAL_CODES[keyof EXPERIMENTAL_CODES]} WarningCode
+ */
+
+/**
+ * Emit a warning with the specified type.
+ *
+ * @param {string} message
+ * @param {'DeprecationWarning' | 'ExperimentalWarning'} type - See https://nodejs.org/api/process.html#nodejs-warning-names
+ * @param {WarningCode} code
+ * @param {string} detail
+ * @returns {void}
+ */
+function emitWarning(message, type, code, detail) {
+	const key = JSON.stringify({
+		message,
+		options: { type, code: `stylelint:${code}`, detail },
+	});
+
+	if (emittedWarnings.has(key)) return;
+
+	emittedWarnings.add(key);
+
+	process.emitWarning(message, { type, code: `stylelint:${code}`, detail });
+}
+
+/**
+ * Use this function for deprecation warnings, instead of `process.emitWarning()`.
+ *
+ * @param {string} message
+ * @param {keyof DEPRECATION_CODES} codeKey
+ * @param {string} detail
+ * @returns {void}
+ */
+export function emitDeprecationWarning(message, codeKey, detail) {
+	emitWarning(message, 'DeprecationWarning', DEPRECATION_CODES[codeKey], detail);
+}
+
+/**
+ * Use this function for experimental warnings, instead of `process.emitWarning()`.
+ *
+ * @param {string} message
+ * @param {keyof EXPERIMENTAL_CODES} codeKey
+ * @param {string} detail
+ * @returns {void}
+ */
+export function emitExperimentalWarning(message, codeKey, detail) {
+	emitWarning(message, 'ExperimentalWarning', EXPERIMENTAL_CODES[codeKey], detail);
+}
+
+/**
+ * Clear the already emitted warnings.
+ * Only useful in tests.
+ *
+ * @private
+ */
+export function clearEmittedWarnings() {
+	if (process.env.NODE_ENV !== 'test') {
+		throw new Error('This function can only be called in test environments!');
+	}
+
+	emittedWarnings.clear();
+}