@alexlit/lint-kit 182.2.0 → 182.4.0

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,83 +0,0 @@
-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();
-}