@alexlit/lint-kit 182.1.0 → 182.2.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,166 @@
+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);
+			});
+	}
+}
+
+/**
+ * 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/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;
+}

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

@@ -0,0 +1,135 @@
+import {
+	aNPlusBNotationPseudoClasses,
+	aNPlusBOfSNotationPseudoClasses,
+	percentageKeyframeWithNamedEquivalent,
+} from '../reference/selectors.mjs';
+import {
+	colorFunctions,
+	hueColorFunctions,
+	legacyNotationColorFunctions,
+	lightnessColorFunctions,
+	mathFunctions,
+	withAlphaAliasColorFunctions,
+	withoutAlphaAliasColorFunctions,
+} from '../reference/functions.mjs';
+import {
+	displayInsideKeywords,
+	displayLegacyKeywords,
+	displayListItemKeyword,
+	displayOutsideKeywords,
+	fontWeightNonNumericKeywords,
+	fontWeightNumericKeywordsWithNamedEquivalent,
+	fontWeightRelativeKeywords,
+	keyframeSelectorKeywords,
+	namedColorsKeywords,
+} from '../reference/keywords.mjs';
+import { deprecatedMediaTypesNames } from '../reference/mediaTypes.mjs';
+import { lengthUnits } from '../reference/units.mjs';
+import { nestingSupportedAtKeywords } from '../reference/atKeywords.mjs';
+import { prefixes } from '../reference/prefixes.mjs';
+
+const aNPlusBClasses = [
+	...aNPlusBNotationPseudoClasses.values(),
+	...aNPlusBOfSNotationPseudoClasses.values(),
+].join('|');
+
+export const atRuleRegexes = {
+	containerName: /^container$/i,
+	customMediaName: /^custom-media$/i,
+	importName: /^import$/i,
+	keyframesName: /^(-(o|moz|ms|webkit)-)?keyframes$/i,
+	layerName: /^layer$/i,
+	mediaName: /^media$/i,
+	pageName: /^page$/i,
+	propertyName: /^property$/i,
+	scopeName: /^scope$/i,
+	unsupportedNestingNames: new RegExp(
+		`^((?!${[...nestingSupportedAtKeywords.values()].join('|')}).)*$`,
+		'i',
+	),
+};
+
+export const descriptorRegexes = {
+	syntaxName: /^syntax$/i,
+};
+
+export const propertyRegexes = {
+	containerNameAndShorthandName: /^container(-name)?$/i,
+	custom: /^--/,
+	fontFamilyAndShorthandName: /^font(-family)?$/i,
+	fontWeightAndShorthandName: /^font(-weight)?$/i,
+	gridAreaNames: /^(?:grid|grid-template|grid-template-areas)$/i,
+};
+
+export const mayIncludeRegexes = {
+	aNPlusBNotationPseudoClass: new RegExp(`\\b:(?:${aNPlusBClasses})\\(`, 'i'),
+	annotation: /!/,
+	attributeSelector: /\[/,
+	attributeSelectorWithOperator: /\[.*=/,
+	classSelector: /\./,
+	colorFunction: new RegExp(`\\b(?:${[...colorFunctions.values()].join('|')})\\(`, 'i'),
+	legacyNotationColorFunction: new RegExp(
+		`\\b(?:${[...legacyNotationColorFunctions.values()].join('|')})\\(`,
+		'i',
+	),
+	combinator: /[>+~\s]/,
+	customProperty: /--/,
+	deprecatedMediaType: new RegExp(`\\b(?:${[...deprecatedMediaTypesNames].join('|')})\\b`, 'i'),
+	displayKeyword: new RegExp(
+		`\\b(?:${[...displayListItemKeyword, ...displayOutsideKeywords, ...displayInsideKeywords, ...displayLegacyKeywords].join('|')})\\b`,
+		'i',
+	),
+	dimension: /\d[%\w-]/,
+	grayFunction: /\bgray\(/i,
+	hexColor: /#[\da-z]+/i,
+	hueColorFunction: new RegExp(`\\b(?:${[...hueColorFunctions.values()].join('|')})\\(`, 'i'),
+	lightnessColorFunction: new RegExp(
+		`\\b(?:${[...lightnessColorFunctions.values()].join('|')})\\(`,
+		'i',
+	),
+	idClassAttributeSelector: /[#.[]/,
+	idSelector: /#/,
+	keyword: /(?<![0-9])[a-z]+(?!\()/i,
+	layerFunction: /\blayer\(/i,
+	mathFunction: new RegExp(`\\b(?:${[...mathFunctions.values()].join('|')})\\(`, 'i'),
+	namedFontWeight: new RegExp(
+		`\\b(?:${[...new Set([...fontWeightNonNumericKeywords, ...fontWeightRelativeKeywords])].join('|')})\\b`,
+		'i',
+	),
+	numericFontWeight: new RegExp(
+		`\\b(?:${[...fontWeightNumericKeywordsWithNamedEquivalent.values()].join('|')})\\b`,
+	),
+	namedKeyframeSelectorWithPercentageEquivalent: new RegExp(
+		`\\b(?:${[...keyframeSelectorKeywords.values()].join('|')})\\b`,
+		'i',
+	),
+	percentageKeyframeSelectorWithNamedEquivalent: new RegExp(
+		`(?:^|[,\\s])(?:${[...percentageKeyframeWithNamedEquivalent.values()].join('|')})`,
+	),
+	multipleValues: /\s|,/,
+	namedColor: new RegExp(`\\b(?:${[...namedColorsKeywords.values()].join('|')})\\b`, 'i'),
+	nestingSelector: /&/,
+	notPseudoClass: /:not\(/i,
+	operator: /[+-]/,
+	prefix: new RegExp(`(?:${[...prefixes].join('|')})`, 'i'),
+	pseudo: /:/,
+	pseudoElement: /::/,
+	time: /\dm?s/i,
+	typeSelector: /(?:[^.#[:a-z-]|^)[a-z]/i,
+	universalSelector: /\*/,
+	urlFunction: /\burl\(/i,
+	validHex: /#(?:[\da-f]{3,4}|[\da-f]{6}|[\da-f]{8})(?:$|[^\da-f])/i,
+	varFunction: /\bvar\(/i,
+	withAlphaAliasColorFunction: new RegExp(
+		`\\b(?:${[...withAlphaAliasColorFunctions.values()].join('|')})\\(`,
+		'i',
+	),
+	withoutAlphaAliasColorFunction: new RegExp(
+		`\\b(?:${[...withoutAlphaAliasColorFunctions.values()].join('|')})\\(`,
+		'i',
+	),
+	zeroLength: new RegExp(
+		`\\b[+-]?(?:0+|0*\\.\\d+)(?:${[...lengthUnits.values()].join('|')})\\b`,
+		'i',
+	),
+};

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

@@ -0,0 +1,13 @@
+/**
+ * Remove empty lines before a node. Mutates the node.
+ *
+ * @template {import('postcss').Node} T
+ * @param {T} node
+ * @param {string} newline
+ * @returns {T}
+ */
+export default function removeEmptyLinesBefore(node, newline) {
+	node.raws.before = node.raws.before ? node.raws.before.replace(/(\r?\n\s*\n)+/g, newline) : '';
+
+	return node;
+}