@alexlit/lint-kit 184.1.0 → 185.0.0

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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