@alexlit/lint-kit 183.7.0 → 184.1.0

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

@@ -0,0 +1,119 @@
+import getAtRuleParams from './getAtRuleParams.mjs';
+import getRuleSelector from './getRuleSelector.mjs';
+
+import { isObject, isString } from './validateTypes.mjs';
+
+/** @import {AtRule, Declaration, Rule} from 'postcss' */
+
+/**
+ * @param {AtRule} atRule
+ * @returns {number}
+ */
+export function atRuleParamIndex(atRule) {
+	const index = atRuleAfterNameIndex(atRule);
+
+	return index + (atRule.raws.afterName?.length ?? 0);
+}
+
+/**
+ * @param {AtRule} atRule
+ * @returns {number}
+ */
+export function atRuleAfterIndex(atRule) {
+	// subtract 1 for `}`
+
+	const endOffset = atRule.source?.end?.offset;
+
+	if (!endOffset) return atRule.toString().length - 1;
+
+	const afterLength = atRule.raws?.after?.length;
+
+	if (!afterLength) return endOffset - 1;
+
+	return endOffset - (afterLength + 1);
+}
+
+/**
+ * @param {AtRule} atRule
+ * @returns {number}
+ */
+export function atRuleAfterNameIndex(atRule) {
+	// Initial 1 is for the `@`
+	return 1 + atRule.name.length;
+}
+
+/**
+ * @param {AtRule} atRule
+ * @returns {number}
+ */
+export function atRuleBetweenIndex(atRule) {
+	return atRuleParamIndex(atRule) + getAtRuleParams(atRule).length;
+}
+
+/**
+ * @param {Declaration} decl
+ * @returns {number}
+ */
+export function declarationBetweenIndex(decl) {
+	const { prop } = decl.raws;
+	const propIsObject = isObject(prop);
+
+	return countChars([
+		propIsObject && 'prefix' in prop && prop.prefix,
+		(propIsObject && 'raw' in prop && prop.raw) || decl.prop,
+		propIsObject && 'suffix' in prop && prop.suffix,
+	]);
+}
+
+/**
+ * Get the index of a declaration's value
+ *
+ * @param {Declaration} decl
+ * @returns {number}
+ */
+export function declarationValueIndex(decl) {
+	const { between, value } = decl.raws;
+
+	return (
+		declarationBetweenIndex(decl) +
+		countChars([between || ':', value && 'prefix' in value && value.prefix])
+	);
+}
+
+/**
+ * @param {Rule} rule
+ * @returns {number}
+ */
+export function ruleBetweenIndex(rule) {
+	return getRuleSelector(rule).length;
+}
+
+/**
+ * @param {Rule} rule
+ * @returns {number}
+ */
+export function ruleAfterIndex(rule) {
+	// subtract 1 for `}`
+
+	const endOffset = rule.source?.end?.offset;
+
+	if (!endOffset) return rule.toString().length - 1;
+
+	const afterLength = rule.raws?.after?.length;
+
+	if (!afterLength) return endOffset - 1;
+
+	return endOffset - (afterLength + 1);
+}
+
+/**
+ * @param {unknown[]} values
+ * @returns {number}
+ */
+function countChars(values) {
+	return values.reduce((/** @type {number} */ count, value) => {
+		if (isString(value)) return count + value.length;
+
+		return count;
+	}, 0);
+}

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

@@ -0,0 +1,26 @@
+import normalizePath from 'normalize-path';
+import process from 'node:process';
+
+/**
+ * Normalize a path for comparisons on Windows while keeping POSIX platforms
+ * untouched. On Windows, this lowercases the drive letter and converts
+ * backslashes to forward slashes. Only the drive letter is lowercased, since
+ * the rest of the path may be case-sensitive on certain file systems mounted
+ * on Windows.
+ *
+ * @param {string} filePath
+ * @param {NodeJS.Platform} [platform=process.platform]
+ * @returns {string}
+ */
+export default function normalizeFilePath(filePath, platform = process.platform) {
+	if (platform !== 'win32') {
+		return filePath;
+	}
+
+	const loweredDrive = filePath.replace(
+		/^(!?)([a-z]):/i,
+		(_, prefix, drive) => `${prefix}${drive.toLowerCase()}:`,
+	);
+
+	return normalizePath(loweredDrive);
+}

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

@@ -0,0 +1,22 @@
+import { DEFAULT_FIX_MODE } from '../constants.mjs';
+
+/** @import { FixMode } from 'stylelint' */
+
+/**
+ * Normalize the fix mode based on options and configuration.
+ * If the input is unknown, this returns `undefined`.
+ *
+ * @param {unknown} fix
+ * @returns {FixMode | undefined}
+ */
+export default function normalizeFixMode(fix) {
+	if (fix === true || fix === 'true' || fix === '' || fix === DEFAULT_FIX_MODE) {
+		return DEFAULT_FIX_MODE;
+	}
+
+	if (fix === 'lax') {
+		return 'lax';
+	}
+
+	return undefined;
+}

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

@@ -0,0 +1,231 @@
+import parser from 'postcss-selector-parser';
+
+/** @import { Node, Root, Selector } from 'postcss-selector-parser' */
+/** @import { PostcssResult } from 'stylelint' */
+
+/**
+ * @template T
+ * @typedef {{ node: T, string: string }} NormalizedEntry<T>
+ */
+
+/** @type {WeakMap<Root | Selector, Map<PostcssResult, NormalizedEntry<any>>>} */
+const cache = new WeakMap();
+
+/** @type {Map<string, NormalizedEntry<any>>} */
+const stringCache = new Map();
+const MAX_STRING_CACHE_SIZE = 10000;
+
+/**
+ * Normalize a selector node so that it can be more easily compared to other selectors
+ * Uses two-tier caching to minimise cloning:
+ * - Result-scoped cache for within-file reuse
+ * - Bounded string cache for cross-file reuse
+ *
+ * @template {Root | Selector} T
+ * @param {T} node
+ * @param {PostcssResult} result
+ * @returns {NormalizedEntry<T>}
+ */
+export default function normalizeSelector(node, result) {
+	let nodeCache = cache.get(node);
+
+	if (nodeCache) {
+		const cached = nodeCache.get(result);
+
+		if (cached) return cached;
+	} else {
+		nodeCache = new Map();
+		cache.set(node, nodeCache);
+	}
+
+	const selectorString = node.toString();
+	const cachedByString = stringCache.get(selectorString);
+
+	if (cachedByString) {
+		nodeCache.set(result, cachedByString);
+
+		return cachedByString;
+	}
+
+	const normalizedNode = /** @type {T} */ (normalize(node.clone()));
+	const entry = { node: normalizedNode, string: normalizedNode.toString() };
+
+	nodeCache.set(result, entry);
+
+	if (stringCache.size >= MAX_STRING_CACHE_SIZE) {
+		const oldestKey = stringCache.keys().next().value;
+
+		if (oldestKey !== undefined) stringCache.delete(oldestKey);
+	}
+
+	stringCache.set(selectorString, entry);
+
+	return entry;
+}
+
+/**
+ * @template {Root | Selector} T
+ * @param {T} node
+ * @returns {T}
+ */
+function normalize(node) {
+	normalizeNodeEscaping(node);
+	normalizeSelectorNodeWhitespaceAndComments(node);
+
+	node.walk((child) => {
+		normalizeNodeEscaping(child);
+		normalizeSelectorNodeWhitespaceAndComments(child);
+	});
+
+	normalizeSelectorNodesOrder(node);
+
+	return node;
+}
+
+/**
+ * @param {Node} node
+ */
+function normalizeSelectorNodeWhitespaceAndComments(node) {
+	if (parser.isComment(node)) {
+		node.remove();
+
+		return;
+	}
+
+	node.rawSpaceBefore = '';
+	node.rawSpaceAfter = '';
+
+	node.spaces.before = '';
+	node.spaces.after = '';
+
+	if (parser.isAttribute(node)) {
+		delete node.spaces.insensitive;
+		delete node.spaces.operator;
+		delete node.spaces.attribute;
+		delete node.spaces.value;
+
+		delete node.raws.spaces;
+	}
+}
+
+/**
+ * @param {Node} node
+ */
+function normalizeSelectorNodesOrder(node) {
+	if (!parser.isContainer(node)) return;
+
+	// Need to sort inside out, not outside in.
+	// As the parents needs to sorted with their children already in the right order.
+	node.each(normalizeSelectorNodesOrder);
+
+	if (parser.isRoot(node) || parser.isPseudoClass(node) || parser.isPseudoElement(node)) {
+		const nodes = node.nodes.map((childNode) => {
+			// Make sure to only stringify the node once.
+			return { node: childNode, string: childNode.toString() };
+		});
+
+		nodes.sort((a, b) => a.string.localeCompare(b.string));
+
+		const uniqueNodes = new Set();
+		const nodesIndices = new Map();
+
+		nodes.forEach((x, i) => {
+			if (uniqueNodes.has(x.string)) return;
+
+			uniqueNodes.add(x.string);
+			nodesIndices.set(x.node, i);
+		});
+
+		node.nodes = node.nodes
+			.filter((childNode) => {
+				return nodesIndices.has(childNode);
+			})
+			.sort((a, b) => {
+				return nodesIndices.get(a) - nodesIndices.get(b);
+			});
+	}
+
+	if (parser.isSelector(node)) {
+		// @ts-expect-error - `sortCompoundSelectors` returns the same nodes, just reordered
+		node.nodes = sortCompoundSelectors(node.nodes);
+	}
+}
+
+const selectorTypePriority = new Map([
+	['universal', 0],
+	['tag', 1],
+	['nesting', 2],
+	['id', 3],
+	['class', 4],
+	['attribute', 5],
+	['pseudo', 6],
+	['comment', 7],
+]);
+
+/**
+ * @param {Node} node
+ * @returns {number}
+ */
+function getSelectorTypePriority(node) {
+	return selectorTypePriority.get(node.type) ?? Number.MAX_SAFE_INTEGER;
+}
+
+/**
+ * @param {Node} a
+ * @param {Node} b
+ * @returns {number}
+ */
+function byPriority(a, b) {
+	const priorityDiff = getSelectorTypePriority(a) - getSelectorTypePriority(b);
+
+	if (priorityDiff !== 0) {
+		return priorityDiff;
+	}
+
+	return String(a).localeCompare(String(b));
+}
+
+/**
+ * @param {Node[]} nodes
+ * @returns {Node[]}
+ */
+function sortCompoundSelectors(nodes) {
+	/** @type {Node[][]} */
+	const compoundSelectorGroups = [];
+	/** @type {Node[]} */
+	let currentCompoundSelectorGroup = [];
+
+	nodes.forEach((childNode) => {
+		if (parser.isCombinator(childNode) || parser.isPseudoElement(childNode)) {
+			compoundSelectorGroups.push(currentCompoundSelectorGroup, [childNode]);
+			currentCompoundSelectorGroup = [];
+		} else {
+			currentCompoundSelectorGroup.push(childNode);
+		}
+	});
+
+	compoundSelectorGroups.push(currentCompoundSelectorGroup);
+
+	compoundSelectorGroups.forEach((group) => group.sort(byPriority));
+
+	return compoundSelectorGroups.flat();
+}
+
+/**
+ * Normalize CSS escaping in selector node values.
+ * Field getters return unescaped values, setters handle re-escaping.
+ * Setting a field to itself normalizes the escaping representation.
+ * This ensures selectors like `.u-m\00002b` and `.u-m\+` are treated as equivalent.
+ *
+ * @see https://github.com/postcss/postcss-selector-parser/blob/1b1e9c3bc10ccc3bc5f07a987caa7f2684c0b52f/src/selectors/className.js#L13-L28
+ * @param {Node} node
+ */
+function normalizeNodeEscaping(node) {
+	if (parser.isClassName(node)) {
+		// @ts-expect-error -- The `raws` property exists, but isn't exposed in the type. This check provides a performance benefit by avoiding extra escaping.
+		if (!node.raws?.value) return;
+
+		// eslint-disable-next-line no-self-assign -- Intentional: setter normalizes escaping
+		node.value = node.value;
+	}
+}

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

@@ -0,0 +1,20 @@
+import matchesStringOrRegExp from './matchesStringOrRegExp.mjs';
+
+/**
+ * Check if an options object's propertyName contains a user-defined string or
+ * regex that matches the passed in input.
+ *
+ * @param {{ [x: string]: any; }} options
+ * @param {string} propertyName
+ * @param {unknown} input
+ *
+ * @returns {boolean}
+ */
+export default function optionsMatches(options, propertyName, input) {
+	return Boolean(
+		options &&
+		options[propertyName] &&
+		typeof input === 'string' &&
+		matchesStringOrRegExp(input, options[propertyName]),
+	);
+}

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

@@ -0,0 +1,29 @@
+import matchesStringOrRegExp from './matchesStringOrRegExp.mjs';
+
+/**
+ * Check if an options object's propertyName contains a user-defined entry
+ * whose key pattern matches inputName and whose value pattern matches inputValue.
+ *
+ * @param {Record<string, unknown> | undefined} options
+ * @param {string} propertyName
+ * @param {string} inputName
+ * @param {string} inputValue
+ *
+ * @returns {boolean}
+ */
+export default function optionsMatchesEntry(options, propertyName, inputName, inputValue) {
+	if (!options) return false;
+
+	const propertyValue = options[propertyName];
+
+	if (!propertyValue) return false;
+
+	const entries = Object.entries(propertyValue);
+	const matchedEntry = entries.find(([namePattern]) =>
+		matchesStringOrRegExp(inputName, namePattern),
+	);
+
+	if (!matchedEntry) return false;
+
+	return Boolean(matchesStringOrRegExp(inputValue, matchedEntry[1]));
+}

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

@@ -0,0 +1,15 @@
+import { parseCustomMedia } from '@csstools/media-query-list-parser';
+
+import getAtRuleParams from './getAtRuleParams.mjs';
+
+/**
+ * @param {import('postcss').AtRule} atRule
+ * @returns {ReturnType<typeof import('@csstools/media-query-list-parser').parseCustomMedia>}
+ */
+export default function parseCustomMediaQuery(atRule) {
+	const mediaQuery = parseCustomMedia(getAtRuleParams(atRule), {
+		preserveInvalidMediaQueries: true,
+	});
+
+	return mediaQuery;
+}

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

@@ -0,0 +1,15 @@
+import { parse } from '@csstools/media-query-list-parser';
+
+import getAtRuleParams from './getAtRuleParams.mjs';
+
+/**
+ * @param {import('postcss').AtRule} atRule
+ * @returns {ReturnType<typeof import('@csstools/media-query-list-parser').parse>}
+ */
+export default function parseMediaQuery(atRule) {
+	const mediaQueries = parse(getAtRuleParams(atRule), {
+		preserveInvalidMediaQueries: true,
+	});
+
+	return mediaQueries;
+}

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

@@ -0,0 +1,19 @@
+import selectorParser from 'postcss-selector-parser';
+
+/**
+ * @param {string} selector
+ * @param {import('stylelint').PostcssResult} result
+ * @param {import('postcss').Node} node
+ * @returns {import('postcss-selector-parser').Root | undefined}
+ */
+export default function parseSelector(selector, result, node) {
+	if (!selector) return undefined;
+
+	try {
+		return selectorParser().astSync(selector);
+	} catch (err) {
+		result.warn(`Cannot parse selector (${err})`, { node, stylelintType: 'parseError' });
+
+		return undefined;
+	}
+}

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

@@ -0,0 +1,16 @@
+import { access } from 'node:fs/promises';
+
+/**
+ * Check if a file or directory exists at the given path.
+ * @param {string} path
+ * @returns {Promise<boolean>}
+ */
+export default async function pathExists(path) {
+	try {
+		await access(path);
+
+		return true;
+	} catch {
+		return false;
+	}
+}

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

@@ -0,0 +1,10 @@
+/**
+ * Returns the plural form of the given word.
+ *
+ * @param {string} singular
+ * @param {number} count
+ * @returns {string}
+ */
+export default function pluralize(singular, count) {
+	return count === 1 ? singular : `${singular}s`;
+}

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

@@ -0,0 +1,20 @@
+/**
+ * If `map` already has the given `key`, returns its value. Otherwise, calls
+ * `callback`, adds the result to `map` at `key`, and then returns it.
+ *
+ * @template K
+ * @template V
+ * @param {Map<K, V>} map
+ * @param {K} key
+ * @param {() => V} callback
+ * @returns {V}
+ */
+export default function putIfAbsent(map, key, callback) {
+	if (map.has(key)) return /** @type {V} */ (map.get(key));
+
+	const value = callback();
+
+	map.set(key, value);
+
+	return value;
+}

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

@@ -0,0 +1,19 @@
+/**
+ * Check if two ranges of source offsets overlap.
+ * This function assumes that the provided ranges have a width of at least one column.
+ *
+ * @param {[number, number]} a
+ * @param {[number, number]} b
+ * @returns {boolean}
+ */
+export default function rangesOverlap(a, b) {
+	// a: ----
+	// b:      ----
+	if (a[1] <= b[0]) return false;
+
+	// a:      ----
+	// b: ----
+	if (a[0] >= b[1]) return false;
+
+	return true;
+}

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

@@ -0,0 +1,29 @@
+/**
+ * @typedef {{result: string, before: string}} CacheEntry
+ */
+
+/** @type {WeakMap<import('postcss').Node, CacheEntry>} */
+const cache = new WeakMap();
+
+/**
+ * Stringify PostCSS node including its raw "before" string.
+ *
+ * @param {import('postcss').Node} node
+ *
+ * @returns {string}
+ */
+export default function rawNodeString(node) {
+	const cachedEntry = cache.get(node);
+	const before = node.raws.before ?? '';
+
+	// Valid cache only if `node.raws.before` is unchanged
+	if (cachedEntry && cachedEntry.before === before) {
+		return cachedEntry.result;
+	}
+
+	const result = before + node.toString();
+
+	cache.set(node, { result, before });
+
+	return result;
+}