@alexlit/lint-kit 182.1.0 → 182.2.0

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

@@ -0,0 +1,41 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { isAbsolute, resolve } from 'node:path';
+import ignore from 'ignore';
+
+import { DEFAULT_IGNORE_FILENAME } from '../constants.mjs';
+
+/**
+ * @typedef {import('stylelint').LinterOptions} LinterOptions
+ *
+ * @param {Pick<LinterOptions, 'ignorePath' | 'ignorePattern'> & { cwd: string }} options
+ * @returns {import('ignore').Ignore}
+ */
+export default function getFileIgnorer({ ignorePath, ignorePattern, cwd }) {
+	const ignorer = ignore();
+	const ignorePaths = [ignorePath || []].flat();
+
+	if (ignorePaths.length === 0) {
+		ignorePaths.push(DEFAULT_IGNORE_FILENAME);
+	}
+
+	for (const ignoreFilePath of ignorePaths) {
+		const absoluteIgnoreFilePath = isAbsolute(ignoreFilePath)
+			? ignoreFilePath
+			: resolve(cwd, ignoreFilePath);
+
+		if (!existsSync(absoluteIgnoreFilePath)) continue;
+
+		const ignoreText = readFileSync(absoluteIgnoreFilePath, {
+			// utf must remain lowercased to hit the fast path
+			// see nodejs/node#49888
+			encoding: 'utf8',
+			flag: 'r',
+		});
+
+		ignorer.add(ignoreText);
+	}
+
+	if (ignorePattern) ignorer.add(ignorePattern);
+
+	return ignorer;
+}

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

@@ -0,0 +1,43 @@
+import { resolve } from 'node:path';
+
+import dynamicImport from './dynamicImport.mjs';
+import formatters from '../formatters/index.mjs';
+import getFormatterOptionsText from './getFormatterOptionsText.mjs';
+import pathExists from './pathExists.mjs';
+import resolveOptionValue from './resolveOptionValue.mjs';
+
+/** @import {Formatter, FormatterType, InternalApi} from 'stylelint' */
+
+/**
+ * @param {InternalApi} stylelint
+ * @returns {Promise<Formatter>}
+ */
+export default async function getFormatter(stylelint) {
+	/** @type {FormatterType | undefined} */
+	let formatter = await resolveOptionValue({ stylelint, name: 'formatter' });
+
+	if (typeof formatter === 'string') {
+		let formatterFunction = formatters[formatter];
+
+		if (formatterFunction === undefined) {
+			if (await pathExists(formatter)) {
+				formatterFunction = await dynamicImport(resolve(formatter)).then((m) => m.default);
+			} else {
+				const formattersText = getFormatterOptionsText(', ', '"');
+
+				throw new Error(`You must use a valid formatter option: ${formattersText} or a function`);
+			}
+		}
+
+		return formatterFunction;
+	}
+
+	// Assume a function or a promise of a function.
+	if (typeof formatter === 'function' || formatter) {
+		return Promise.resolve(formatter);
+	}
+
+	formatter ??= stylelint._options._defaultFormatter ?? 'json';
+
+	return formatters[formatter];
+}

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

@@ -0,0 +1,12 @@
+import formatters from '../formatters/index.mjs';
+
+/**
+ * @param {string} separator
+ * @param {string} [quote]
+ * @returns {string}
+ */
+export default function getFormatterOptionsText(separator, quote = '') {
+	return Object.keys(formatters)
+		.map((name) => `${quote}${name}${quote}`)
+		.join(separator);
+}

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

@@ -0,0 +1,15 @@
+/**
+ * Returns a position of `!important` (or `! important` including whitespaces)
+ * from the specified CSS source code. If not found, returns `undefined`.
+ *
+ * @param {string} source
+ * @returns {{ index: number, endIndex: number } | undefined}
+ */
+export default function getImportantPosition(source) {
+	const pattern = /!\s*important\b/gi;
+	const match = pattern.exec(source);
+
+	if (!match) return;
+
+	return { index: match.index, endIndex: pattern.lastIndex };
+}

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

@@ -0,0 +1,39 @@
+import { fork } from 'css-tree';
+import syntaxPatchesJson from '@csstools/css-syntax-patches-for-csstree' with { type: 'json' };
+
+import mergeSyntaxDefinitions from './mergeSyntaxDefinitions.mjs';
+
+/** @import { Lexer as CSSTreeLexer } from 'css-tree' */
+/** @import { Config as StylelintConfig } from 'stylelint' */
+/** @import { SyntaxDefinition } from './mergeSyntaxDefinitions.mjs' */
+
+const { next: syntaxPatches } = syntaxPatchesJson;
+
+const lexerCache = new Map();
+
+/**
+ * Get CSSTree lexer based on a Stylelint configuration and an additional syntax definition.
+ * The return value is cached for performance.
+ *
+ * @param {StylelintConfig} config
+ * @param {SyntaxDefinition} [additionalSyntax]
+ * @returns {CSSTreeLexer}
+ */
+export default function getLexer(config, additionalSyntax) {
+	const syntax = { ...config.languageOptions?.syntax, ...additionalSyntax };
+
+	if (syntax.atRules) {
+		syntax.atrules = syntax.atRules;
+	}
+
+	const cacheKey = JSON.stringify(syntax);
+	const lexer = lexerCache.get(cacheKey);
+
+	if (lexer) return lexer;
+
+	const { lexer: newLexer } = fork(mergeSyntaxDefinitions(syntaxPatches, syntax));
+
+	lexerCache.set(cacheKey, newLexer);
+
+	return newLexer;
+}

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

@@ -0,0 +1,35 @@
+import process from 'node:process';
+
+import globalModules from 'global-modules';
+
+import { ConfigurationError } from './errors.mjs';
+import resolveSilent from './resolveSilent.mjs';
+
+/**
+ * @param {string} basedir
+ * @param {string} lookup
+ * @param {string} [cwd]
+ * @returns {string}
+ */
+export default function getModulePath(basedir, lookup, cwd = process.cwd()) {
+	// 1. Try to resolve from the provided directory
+	// 2. Try to resolve from `cwd` or `process.cwd()`
+	// 3. Try to resolve from global `node_modules` directory
+	let path = resolveSilent(basedir, lookup);
+
+	if (!path) {
+		path = resolveSilent(cwd, lookup);
+	}
+
+	if (!path) {
+		path = resolveSilent(globalModules, lookup);
+	}
+
+	if (!path) {
+		throw new ConfigurationError(
+			`Could not find "${lookup}". Do you need to install the package or use the "configBasedir" option?`,
+		);
+	}
+
+	return path;
+}

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

@@ -0,0 +1,34 @@
+/** @typedef {import('postcss').Node} Node */
+
+/**
+ * @param {Node | void} node
+ */
+function getNodeLine(node) {
+	return node && node.source && node.source.start && node.source.start.line;
+}
+
+/**
+ * @param {Node | void} node
+ * @returns {Node | void}
+ */
+export default function getNextNonSharedLineCommentNode(node) {
+	if (node === undefined) {
+		return undefined;
+	}
+
+	/** @type {Node | void} */
+	const nextNode = node.next();
+
+	if (!nextNode || nextNode.type !== 'comment') {
+		return nextNode;
+	}
+
+	if (
+		getNodeLine(node) === getNodeLine(nextNode) ||
+		getNodeLine(nextNode) === getNodeLine(nextNode.next())
+	) {
+		return getNextNonSharedLineCommentNode(nextNode);
+	}
+
+	return nextNode;
+}

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

@@ -0,0 +1,36 @@
+/** @typedef {import('postcss').Node} Node */
+
+/**
+ * @param {Node} node
+ */
+function getNodeLine(node) {
+	return node.source && node.source.start && node.source.start.line;
+}
+
+/**
+ * @param {Node | undefined} node
+ * @returns {Node | undefined}
+ */
+export default function getPreviousNonSharedLineCommentNode(node) {
+	if (node === undefined) {
+		return undefined;
+	}
+
+	const previousNode = node.prev();
+
+	if (!previousNode || previousNode.type !== 'comment') {
+		return previousNode;
+	}
+
+	if (getNodeLine(node) === getNodeLine(previousNode)) {
+		return getPreviousNonSharedLineCommentNode(previousNode);
+	}
+
+	const previousNode2 = previousNode.prev();
+
+	if (previousNode2 && getNodeLine(previousNode) === getNodeLine(previousNode2)) {
+		return getPreviousNonSharedLineCommentNode(previousNode);
+	}
+
+	return previousNode;
+}

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

@@ -0,0 +1,12 @@
+import path from 'node:path';
+
+/**
+ * Returns the relative path of a file to the current working directory.
+ * Always in POSIX format for consistency and interoperability.
+ * @param {string} cwd The current working directory.
+ * @param {string} filePath The file path.
+ * @returns {string} The relative file path.
+ */
+export default function getRelativePath(cwd, filePath) {
+	return path.relative(cwd, filePath).split(path.sep).join(path.posix.sep);
+}

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

@@ -0,0 +1,9 @@
+/**
+ * @param {import('postcss').Rule} ruleNode
+ * @returns {string}
+ */
+export default function getRuleSelector(ruleNode) {
+	const raws = ruleNode.raws;
+
+	return (raws.selector && raws.selector.raw) || ruleNode.selector;
+}

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

@@ -0,0 +1,36 @@
+/**
+ * Get unit from value node
+ *
+ * Returns `null` if the unit is not found.
+ *
+ * @param {string} urlString
+ * @returns {string | null}
+ */
+export default function getSchemeFromUrl(urlString) {
+	let protocol = null;
+
+	try {
+		protocol = new URL(urlString).protocol;
+	} catch {
+		return null;
+	}
+
+	if (protocol === null || typeof protocol === 'undefined') {
+		return null;
+	}
+
+	const scheme = protocol.slice(0, -1); // strip trailing `:`
+
+	// The URL spec does not require a scheme to be followed by `//`, but checking
+	// for it allows this rule to differentiate <scheme>:<hostname> urls from
+	// <hostname>:<port> urls. `data:` scheme urls are an exception to this rule.
+	const slashIndex = protocol.length;
+	const expectedSlashes = urlString.slice(slashIndex, slashIndex + 2);
+	const isSchemeLessUrl = expectedSlashes !== '//' && scheme !== 'data';
+
+	if (isSchemeLessUrl) {
+		return null;
+	}
+
+	return scheme;
+}

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

@@ -0,0 +1,12 @@
+/**
+ * Get the source index of a selector, excluding leading whitespace.
+ *
+ * @param {import('postcss-selector-parser').Selector} node
+ *
+ * @returns {number}
+ */
+export default function getSelectorSourceIndex(node) {
+	// The first child node sourceIndex is the same as the parent sourceIndex without leading whitespace
+	// If the node doesn't have any children, use the node sourceIndex instead
+	return node.first?.sourceIndex ?? node.sourceIndex;
+}

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

@@ -0,0 +1,47 @@
+import selectorParser from 'postcss-selector-parser';
+
+const { isComment } = selectorParser;
+
+/**
+ * Get the source of a selector, excluding surrounding whitespace and comments.
+ *
+ * @param {import('postcss-selector-parser').Selector} node
+ *
+ * @returns {{selector: string, index: number, endIndex: number}}
+ */
+export default function getStrippedSelectorSource(node) {
+	const firstIndex = node.nodes.findIndex((x) => !isComment(x));
+	const lastIndex = node.nodes.findLastIndex((x) => !isComment(x));
+
+	const first = node.nodes[firstIndex];
+	let last = node.nodes[lastIndex];
+
+	if (!first || !last) {
+		const selector = node.toString().trim();
+		const index = node.sourceIndex ?? 0;
+		const endIndex = index + selector.length;
+
+		return {
+			selector,
+			index,
+			endIndex,
+		};
+	}
+
+	last = last.rawSpaceAfter.length ? last.clone() : last;
+	last.rawSpaceAfter = '';
+
+	let selector = node.nodes.slice(firstIndex, lastIndex).map(String).join('');
+
+	selector += last.toString();
+	selector = selector.trim();
+
+	const index = first.sourceIndex ?? 0;
+	const endIndex = index + selector.length;
+
+	return {
+		selector,
+		index,
+		endIndex,
+	};
+}

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

@@ -0,0 +1,22 @@
+import rules from '../rules/index.mjs';
+
+/**
+ * @param {string} ruleName
+ * @param {import('stylelint').Config | undefined} [config]
+ * @returns {Promise<import('stylelint').Rule | undefined>}
+ */
+export default function getStylelintRule(ruleName, config) {
+	if (isBuiltInRule(ruleName)) {
+		return rules[ruleName];
+	}
+
+	return Promise.resolve(config?.pluginFunctions?.[ruleName]);
+}
+
+/**
+ * @param {string} ruleName
+ * @returns {ruleName is keyof rules}
+ */
+function isBuiltInRule(ruleName) {
+	return ruleName in rules;
+}

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

@@ -0,0 +1,9 @@
+/**
+ * Check if a statement has an block (empty or otherwise).
+ *
+ * @param {import('postcss').Container} statement
+ * @returns {boolean} True if `statement` has a block (empty or otherwise)
+ */
+export default function hasBlock(statement) {
+	return statement.nodes !== undefined;
+}

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

@@ -0,0 +1,13 @@
+const HAS_EMPTY_LINE = /\n[\r\t ]*\n/;
+
+/**
+ * Check if a string contains at least one empty line
+ *
+ * @param {string | undefined} string
+ * @returns {boolean}
+ */
+export default function hasEmptyLine(string) {
+	if (string === '' || string === undefined) return false;
+
+	return HAS_EMPTY_LINE.test(string);
+}

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

@@ -0,0 +1,24 @@
+import hasLessInterpolation from './hasLessInterpolation.mjs';
+import hasPsvInterpolation from './hasPsvInterpolation.mjs';
+import hasScssInterpolation from './hasScssInterpolation.mjs';
+import hasTplInterpolation from './hasTplInterpolation.mjs';
+
+/**
+ * Check whether a string has interpolation
+ *
+ * @param {string} string
+ * @returns {boolean} If `true`, a string has interpolation
+ */
+export default function hasInterpolation(string) {
+	// SCSS or Less interpolation
+	if (
+		hasLessInterpolation(string) ||
+		hasScssInterpolation(string) ||
+		hasTplInterpolation(string) ||
+		hasPsvInterpolation(string)
+	) {
+		return true;
+	}
+
+	return false;
+}

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

@@ -0,0 +1,11 @@
+const HAS_LESS_INTERPOLATION = /@\{.+?\}/;
+
+/**
+ * Check whether a string has less interpolation
+ *
+ * @param {string} string
+ * @returns {boolean} If `true`, a string has less interpolation
+ */
+export default function hasLessInterpolation(string) {
+	return HAS_LESS_INTERPOLATION.test(string);
+}

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

@@ -0,0 +1,11 @@
+const HAS_PSV_INTERPOLATION = /\$\(.+?\)/;
+
+/**
+ * Check whether a string has postcss-simple-vars interpolation
+ *
+ * @param {string} string
+ * @returns {boolean}
+ */
+export default function hasPsvInterpolation(string) {
+	return HAS_PSV_INTERPOLATION.test(string);
+}

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

@@ -0,0 +1,11 @@
+const HAS_SCSS_INTERPOLATION = /#\{.+?\}/s;
+
+/**
+ * Check whether a string has scss interpolation
+ *
+ * @param {string} string
+ * @returns {boolean}
+ */
+export default function hasScssInterpolation(string) {
+	return HAS_SCSS_INTERPOLATION.test(string);
+}

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

@@ -0,0 +1,11 @@
+const HAS_TPL_INTERPOLATION = /\{.+?\}/s;
+
+/**
+ * Check whether a string has JS template literal interpolation or HTML-like template
+ *
+ * @param {string} string
+ * @returns {boolean} If `true`, a string has template literal interpolation
+ */
+export default function hasTplInterpolation(string) {
+	return HAS_TPL_INTERPOLATION.test(string);
+}

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

@@ -0,0 +1,10 @@
+import MurmurHash3 from 'imurmurhash';
+
+/**
+ * hash the given string
+ * @param {string} str the string to hash
+ * @returns {string} the hash
+ */
+export default function hash(str) {
+	return MurmurHash3(str).result().toString(36);
+}

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

@@ -0,0 +1,15 @@
+import { isAtRule, isRule } from './typeGuards.mjs';
+
+/**
+ * @param {import('postcss').Node} node
+ * @returns {boolean}
+ */
+export default function isAfterBlock(node) {
+	const previousNode = node.prev();
+
+	if (!previousNode) {
+		return false;
+	}
+
+	return isRule(previousNode) || isAtRule(previousNode);
+}

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

@@ -0,0 +1,15 @@
+import isSharedLineComment from './isSharedLineComment.mjs';
+
+/**
+ * @param {import('postcss').Node} node
+ * @returns {boolean}
+ */
+export default function isAfterComment(node) {
+	const previousNode = node.prev();
+
+	if (!previousNode || previousNode.type !== 'comment') {
+		return false;
+	}
+
+	return !isSharedLineComment(previousNode);
+}

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

@@ -0,0 +1,19 @@
+import isSharedLineComment from './isSharedLineComment.mjs';
+
+/**
+ * @param {import('postcss').Node} node
+ * @returns {boolean}
+ */
+export default function isAfterSingleLineComment(node) {
+	const prevNode = node.prev();
+
+	return (
+		prevNode !== undefined &&
+		prevNode.type === 'comment' &&
+		!isSharedLineComment(prevNode) &&
+		prevNode.source !== undefined &&
+		prevNode.source.start !== undefined &&
+		prevNode.source.end !== undefined &&
+		prevNode.source.start.line === prevNode.source.end.line
+	);
+}

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

@@ -0,0 +1,19 @@
+import getPreviousNonSharedLineCommentNode from './getPreviousNonSharedLineCommentNode.mjs';
+import isCustomProperty from './isCustomProperty.mjs';
+import { isDeclaration } from './typeGuards.mjs';
+import isStandardSyntaxDeclaration from './isStandardSyntaxDeclaration.mjs';
+
+/**
+ * @param {import('postcss').Node} node
+ * @returns {boolean}
+ */
+export default function isAfterStandardPropertyDeclaration(node) {
+	const prevNode = getPreviousNonSharedLineCommentNode(node);
+
+	return (
+		prevNode !== undefined &&
+		isDeclaration(prevNode) &&
+		isStandardSyntaxDeclaration(prevNode) &&
+		!isCustomProperty(prevNode.prop || '')
+	);
+}