@alexlit/lint-kit 183.4.0 → 183.6.0

package/packages/config-stylelint/node_modules/stylelint/lib/rules/block-no-redundant-nested-style-rules/index.mjs

@@ -0,0 +1,52 @@
+import { isRoot } from '../../utils/typeGuards.mjs';
+import isStandardSyntaxRule from '../../utils/isStandardSyntaxRule.mjs';
+import report from '../../utils/report.mjs';
+import ruleMessages from '../../utils/ruleMessages.mjs';
+import validateOptions from '../../utils/validateOptions.mjs';
+
+const ruleName = 'block-no-redundant-nested-style-rules';
+
+const messages = ruleMessages(ruleName, {
+	rejected: 'Unexpected redundant nested style rule',
+});
+
+const meta = {
+	url: 'https://stylelint.io/user-guide/rules/block-no-redundant-nested-style-rules',
+};
+
+/** @type {import('stylelint').CoreRules[ruleName]} */
+const rule = (primary) => {
+	return (root, result) => {
+		const validOptions = validateOptions(result, ruleName, {
+			actual: primary,
+			possible: [true],
+		});
+
+		if (!validOptions) return;
+
+		root.walkRules((ruleNode) => {
+			if (!isStandardSyntaxRule(ruleNode)) return;
+
+			const { parent, selector } = ruleNode;
+
+			if (selector !== '&') return;
+
+			if (!parent) return;
+
+			if (isRoot(parent)) return;
+
+			report({
+				message: messages.rejected,
+				messageArgs: [],
+				node: ruleNode,
+				result,
+				ruleName,
+			});
+		});
+	};
+};
+
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;
+export default rule;

package/packages/config-stylelint/node_modules/stylelint/lib/rules/color-function-alias-notation/index.mjs

@@ -0,0 +1,87 @@
+import valueParser from 'postcss-value-parser';
+
+import {
+	withAlphaAliasColorFunctions,
+	withoutAlphaAliasColorFunctions,
+} from '../../reference/functions.mjs';
+import { declarationValueIndex } from '../../utils/nodeFieldIndices.mjs';
+import getDeclarationValue from '../../utils/getDeclarationValue.mjs';
+import isStandardSyntaxColorFunction from '../../utils/isStandardSyntaxColorFunction.mjs';
+import { isValueFunction } from '../../utils/typeGuards.mjs';
+import { mayIncludeRegexes } from '../../utils/regexes.mjs';
+import report from '../../utils/report.mjs';
+import ruleMessages from '../../utils/ruleMessages.mjs';
+import setDeclarationValue from '../../utils/setDeclarationValue.mjs';
+import validateOptions from '../../utils/validateOptions.mjs';
+
+const ruleName = 'color-function-alias-notation';
+
+const messages = ruleMessages(ruleName, {
+	expected: (unfixed, fixed) => `Expected "${unfixed}" to be "${fixed}"`,
+});
+
+const meta = {
+	url: 'https://stylelint.io/user-guide/rules/color-function-alias-notation',
+	fixable: true,
+};
+
+/** @type {import('stylelint').CoreRules[ruleName]} */
+const rule = (primary) => {
+	return (root, result) => {
+		const validOptions = validateOptions(result, ruleName, {
+			actual: primary,
+			possible: ['with-alpha', 'without-alpha'],
+		});
+
+		if (!validOptions) return;
+
+		const targetFunctionCall =
+			primary === 'with-alpha'
+				? mayIncludeRegexes.withoutAlphaAliasColorFunction
+				: mayIncludeRegexes.withAlphaAliasColorFunction;
+		const targetFunctionName =
+			primary === 'with-alpha' ? withoutAlphaAliasColorFunctions : withAlphaAliasColorFunctions;
+
+		root.walkDecls((decl) => {
+			if (!targetFunctionCall.test(decl.value)) return;
+
+			const parsedValue = valueParser(getDeclarationValue(decl));
+
+			parsedValue.walk((node) => {
+				if (!isValueFunction(node) || !isStandardSyntaxColorFunction(node)) return;
+
+				const { value, sourceIndex } = node;
+
+				if (!targetFunctionName.has(value.toLowerCase())) return;
+
+				const fixed = primary === 'with-alpha' ? `${value}a` : value.slice(0, -1);
+				const fix = () => {
+					node.value = fixed;
+					setDeclarationValue(decl, parsedValue.toString());
+				};
+
+				const index = declarationValueIndex(decl) + sourceIndex;
+				const endIndex = index + value.length;
+
+				report({
+					message: messages.expected,
+					messageArgs: [value, fixed],
+					node: decl,
+					index,
+					endIndex,
+					result,
+					ruleName,
+					fix: {
+						apply: fix,
+						node: decl,
+					},
+				});
+			});
+		});
+	};
+};
+
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;
+export default rule;

package/packages/config-stylelint/node_modules/stylelint/lib/rules/color-function-notation/index.mjs

@@ -0,0 +1,168 @@
+import valueParser from 'postcss-value-parser';
+
+import {
+	legacyNotationColorFunctions,
+	withAlphaAliasColorFunctions,
+} from '../../reference/functions.mjs';
+import { declarationValueIndex } from '../../utils/nodeFieldIndices.mjs';
+import getDeclarationValue from '../../utils/getDeclarationValue.mjs';
+import isStandardSyntaxColorFunction from '../../utils/isStandardSyntaxColorFunction.mjs';
+import { isValueFunction } from '../../utils/typeGuards.mjs';
+import isVarFunction from '../../utils/isVarFunction.mjs';
+import { mayIncludeRegexes } from '../../utils/regexes.mjs';
+import optionsMatches from '../../utils/optionsMatches.mjs';
+import report from '../../utils/report.mjs';
+import ruleMessages from '../../utils/ruleMessages.mjs';
+import setDeclarationValue from '../../utils/setDeclarationValue.mjs';
+import validateOptions from '../../utils/validateOptions.mjs';
+
+const ruleName = 'color-function-notation';
+
+const messages = ruleMessages(ruleName, {
+	expected: (primary) => `Expected ${primary} color-function notation`,
+});
+
+const meta = {
+	url: 'https://stylelint.io/user-guide/rules/color-function-notation',
+	fixable: true,
+};
+
+/** @type {import('stylelint').CoreRules[ruleName]} */
+const rule = (primary, secondaryOptions) => {
+	return (root, result) => {
+		const validOptions = validateOptions(
+			result,
+			ruleName,
+			{
+				actual: primary,
+				possible: ['modern', 'legacy'],
+			},
+			{
+				actual: secondaryOptions,
+				possible: {
+					ignore: ['with-var-inside'],
+				},
+				optional: true,
+			},
+		);
+
+		if (!validOptions) return;
+
+		const ignoreWithVarInside = optionsMatches(secondaryOptions, 'ignore', 'with-var-inside');
+
+		root.walkDecls((decl) => {
+			if (!mayIncludeRegexes.legacyNotationColorFunction.test(decl.value)) return;
+
+			if (primary === 'modern' && !decl.value.includes(',')) return;
+
+			const parsedValue = valueParser(getDeclarationValue(decl));
+
+			parsedValue.walk((node) => {
+				if (!isValueFunction(node)) return;
+
+				if (!isStandardSyntaxColorFunction(node)) return;
+
+				const { value, sourceIndex, sourceEndIndex, nodes } = node;
+
+				if (ignoreWithVarInside && containsVariable(nodes)) return;
+
+				if (!legacyNotationColorFunctions.has(value.toLowerCase())) return;
+
+				const hasEnoughArguments = nodes.length >= 5;
+
+				if (!hasEnoughArguments) return;
+
+				if (primary === 'modern' && !isLikelyLegacy(nodes)) return;
+
+				if (primary === 'legacy' && isLikelyLegacy(nodes)) return;
+
+				const modernFixer = () => {
+					let commaCount = 0;
+
+					// Convert punctuation
+					node.nodes = nodes.map((childNode) => {
+						if (isComma(childNode)) {
+							// Non-alpha commas to space and alpha commas to slashes
+							if (commaCount < 2) {
+								// @ts-expect-error -- TS2322: Type '"space"' is not assignable to type '"div"'.
+								childNode.type = 'space';
+								childNode.value = atLeastOneSpace(childNode.after);
+								commaCount++;
+							} else {
+								childNode.value = '/';
+								childNode.before = atLeastOneSpace(childNode.before);
+								childNode.after = atLeastOneSpace(childNode.after);
+							}
+						}
+
+						return childNode;
+					});
+
+					// Remove trailing 'a' from legacy function name
+					if (withAlphaAliasColorFunctions.has(value.toLowerCase())) {
+						node.value = value.slice(0, -1);
+					}
+
+					setDeclarationValue(decl, parsedValue.toString());
+				};
+
+				const index = declarationValueIndex(decl) + sourceIndex;
+				const endIndex = index + (sourceEndIndex - sourceIndex);
+				const fix = primary === 'modern' ? modernFixer : undefined;
+
+				report({
+					message: messages.expected,
+					messageArgs: [primary],
+					node: decl,
+					index,
+					endIndex,
+					result,
+					ruleName,
+					fix: {
+						apply: fix,
+						node: decl,
+					},
+				});
+			});
+		});
+	};
+};
+
+/**
+ * @param {string} whitespace
+ */
+function atLeastOneSpace(whitespace) {
+	return whitespace !== '' ? whitespace : ' ';
+}
+
+/**
+ * @param {import('postcss-value-parser').Node[]} nodes
+ */
+function containsVariable(nodes) {
+	return nodes.some((node) => isVarFunction(node));
+}
+
+/**
+ * @param {import('postcss-value-parser').Node} node
+ * @returns {node is import('postcss-value-parser').DivNode}
+ */
+function isComma(node) {
+	return node.type === 'div' && node.value === ',';
+}
+
+/** @param {import('postcss-value-parser').Node[]} nodes */
+function isLikelyLegacy(nodes) {
+	let commas = 0;
+
+	for (const node of nodes) {
+		if (isComma(node)) commas++;
+		else if (node.value === '/') return false;
+	}
+
+	return commas && (commas === 2 || commas === 3);
+}
+
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;
+export default rule;

package/packages/config-stylelint/node_modules/stylelint/lib/rules/color-hex-alpha/index.mjs

@@ -0,0 +1,75 @@
+import valueParser from 'postcss-value-parser';
+
+import { declarationValueIndex } from '../../utils/nodeFieldIndices.mjs';
+import isHexColor from '../../utils/isHexColor.mjs';
+import isUrlFunction from '../../utils/isUrlFunction.mjs';
+import { mayIncludeRegexes } from '../../utils/regexes.mjs';
+import report from '../../utils/report.mjs';
+import ruleMessages from '../../utils/ruleMessages.mjs';
+import validateOptions from '../../utils/validateOptions.mjs';
+
+const ruleName = 'color-hex-alpha';
+
+const messages = ruleMessages(ruleName, {
+	expected: (hex) => `Expected alpha channel in "${hex}"`,
+	rejected: (hex) => `Unexpected alpha channel in "${hex}"`,
+});
+
+const meta = {
+	url: 'https://stylelint.io/user-guide/rules/color-hex-alpha',
+};
+
+/** @type {import('stylelint').CoreRules[ruleName]} */
+const rule = (primary) => {
+	return (root, result) => {
+		const validOptions = validateOptions(result, ruleName, {
+			actual: primary,
+			possible: ['always', 'never'],
+		});
+
+		if (!validOptions) return;
+
+		root.walkDecls((decl) => {
+			if (!mayIncludeRegexes.validHex.test(decl.value)) return;
+
+			const parsedValue = valueParser(decl.value);
+
+			parsedValue.walk((node) => {
+				if (isUrlFunction(node)) return false;
+
+				if (!isHexColor(node)) return;
+
+				const { value } = node;
+
+				if (primary === 'always' && hasAlphaChannel(value)) return;
+
+				if (primary === 'never' && !hasAlphaChannel(value)) return;
+
+				const index = declarationValueIndex(decl) + node.sourceIndex;
+				const endIndex = index + value.length;
+
+				report({
+					message: primary === 'never' ? messages.rejected : messages.expected,
+					messageArgs: [value],
+					node: decl,
+					index,
+					endIndex,
+					result,
+					ruleName,
+				});
+			});
+		});
+	};
+};
+
+/**
+ * @param {string} hex
+ */
+function hasAlphaChannel(hex) {
+	return hex.length === 5 || hex.length === 9;
+}
+
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;
+export default rule;

package/packages/config-stylelint/node_modules/stylelint/lib/rules/color-hex-length/index.mjs

@@ -0,0 +1,128 @@
+import valueParser from 'postcss-value-parser';
+
+import { declarationValueIndex } from '../../utils/nodeFieldIndices.mjs';
+import getDeclarationValue from '../../utils/getDeclarationValue.mjs';
+import isHexColor from '../../utils/isHexColor.mjs';
+import isUrlFunction from '../../utils/isUrlFunction.mjs';
+import { mayIncludeRegexes } from '../../utils/regexes.mjs';
+import report from '../../utils/report.mjs';
+import ruleMessages from '../../utils/ruleMessages.mjs';
+import setDeclarationValue from '../../utils/setDeclarationValue.mjs';
+import validateOptions from '../../utils/validateOptions.mjs';
+
+const ruleName = 'color-hex-length';
+
+const messages = ruleMessages(ruleName, {
+	expected: (actual, expected) => `Expected "${actual}" to be "${expected}"`,
+});
+
+const meta = {
+	url: 'https://stylelint.io/user-guide/rules/color-hex-length',
+	fixable: true,
+};
+
+/** @type {import('stylelint').CoreRules[ruleName]} */
+const rule = (primary) => {
+	return (root, result) => {
+		const validOptions = validateOptions(result, ruleName, {
+			actual: primary,
+			possible: ['short', 'long'],
+		});
+
+		if (!validOptions) {
+			return;
+		}
+
+		root.walkDecls((decl) => {
+			if (!mayIncludeRegexes.hexColor.test(decl.value)) return;
+
+			const parsedValue = valueParser(getDeclarationValue(decl));
+
+			parsedValue.walk((node) => {
+				const { value: hexValue } = node;
+
+				if (isUrlFunction(node)) return false;
+
+				if (!isHexColor(node)) return;
+
+				if (primary === 'long' && hexValue.length !== 4 && hexValue.length !== 5) {
+					return;
+				}
+
+				if (primary === 'short' && (hexValue.length < 6 || !canShrink(hexValue))) {
+					return;
+				}
+
+				const variant = primary === 'long' ? longer : shorter;
+				const expectedHex = variant(hexValue);
+
+				const fix = () => {
+					node.value = expectedHex;
+					setDeclarationValue(decl, parsedValue.toString());
+				};
+
+				const index = declarationValueIndex(decl) + node.sourceIndex;
+				const endIndex = index + node.value.length;
+
+				report({
+					message: messages.expected,
+					messageArgs: [hexValue, expectedHex],
+					node: decl,
+					index,
+					endIndex,
+					result,
+					ruleName,
+					fix: {
+						apply: fix,
+						node: decl,
+					},
+				});
+			});
+		});
+	};
+};
+
+/**
+ * @param {string} hex
+ */
+function canShrink(hex) {
+	hex = hex.toLowerCase();
+
+	return (
+		hex[1] === hex[2] &&
+		hex[3] === hex[4] &&
+		hex[5] === hex[6] &&
+		(hex.length === 7 || (hex.length === 9 && hex[7] === hex[8]))
+	);
+}
+
+/**
+ * @param {string} hex
+ */
+function shorter(hex) {
+	let hexVariant = '#';
+
+	for (let i = 1; i < hex.length; i += 2) {
+		hexVariant += hex[i];
+	}
+
+	return hexVariant;
+}
+
+/**
+ * @param {string} hex
+ */
+function longer(hex) {
+	let hexVariant = '#';
+
+	for (let i = 1; i < hex.length; i++) {
+		hexVariant += hex.charAt(i).repeat(2);
+	}
+
+	return hexVariant;
+}
+
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;
+export default rule;

package/packages/config-stylelint/node_modules/stylelint/lib/rules/color-named/colordUtils.mjs

@@ -0,0 +1,109 @@
+import { colord as colord_, extend } from 'colord';
+import valueParser from 'postcss-value-parser';
+
+import namesPlugin from 'colord/plugins/names';
+
+import hwbPlugin from 'colord/plugins/hwb';
+import labPlugin from 'colord/plugins/lab';
+import lchPlugin from 'colord/plugins/lch';
+
+extend([
+	// Type definitions are not compatible with commonjs.
+	/** @type {any} */ (namesPlugin),
+	/** @type {any} */ (hwbPlugin),
+	/** @type {any} */ (labPlugin),
+	/** @type {any} */ (lchPlugin),
+
+	/* Syntaxes that is removed in Color Module Level 4 specification. */
+
+	// hwb() with comma
+	(_colordClass, parsers) => {
+		parsers.string.push([parseHwbWithCommaString, /** @type {any} */ ('hwb-with-comma')]);
+	},
+	// gray()
+	(_colordClass, parsers) => {
+		parsers.string.push([parseGrayString, /** @type {any} */ ('gray')]);
+	},
+]);
+
+export const colord = colord_;
+
+/**
+ * Parses a valid hwb with comma CSS color function
+ * https://developer.mozilla.org/en-US/docs/Web/CSS/color_value/hwb()#syntax
+ * @param {string} input
+ * @returns {import('colord').RgbaColor | null}
+ */
+function parseHwbWithCommaString(input) {
+	input = input.toLowerCase();
+
+	if (!input.startsWith('hwb(') || !input.endsWith(')') || input.includes('/')) {
+		return null;
+	}
+
+	const [hue, whiteness = '', blackness = '', alpha, ...extraArgs] = input.slice(4, -1).split(',');
+
+	if (!hue || !hue.trim() || !whiteness.trim() || !blackness.trim() || extraArgs.length > 0) {
+		return null;
+	}
+
+	// Change the delimiter and parse with colord.
+	const colordInstance = colord(
+		`hwb(${hue} ${whiteness} ${blackness}${alpha ? ` / ${alpha}` : ''})`,
+	);
+
+	if (!colordInstance.isValid()) {
+		return null;
+	}
+
+	return colordInstance.rgba;
+}
+
+/**
+ * Parses a valid gray() CSS color function
+ * @param {string} input
+ * @returns {import('colord').RgbaColor | null}
+ */
+function parseGrayString(input) {
+	input = input.toLowerCase();
+
+	if (!input.startsWith('gray(') || !input.endsWith(')')) {
+		return null;
+	}
+
+	const [lightness, alpha, ...extraArgs] = input.slice(5, -1).split(',');
+
+	if (!lightness || extraArgs.length > 0) {
+		return null;
+	}
+
+	const lightnessWithUnit = valueParser.unit(lightness.trim());
+
+	if (!lightnessWithUnit || !['', '%'].includes(lightnessWithUnit.unit)) {
+		return null;
+	}
+
+	/**
+	 * @type {import('colord').LabColor | import('colord').LabaColor}
+	 */
+	let colorObject = {
+		l: Number(lightnessWithUnit.number),
+		a: 0,
+		b: 0,
+	};
+
+	if (alpha) {
+		const alphaWithUnit = valueParser.unit(alpha.trim());
+
+		if (!alphaWithUnit || !['', '%'].includes(alphaWithUnit.unit)) {
+			return null;
+		}
+
+		colorObject = {
+			...colorObject,
+			alpha: Number(alphaWithUnit.number) / (alphaWithUnit.unit ? 100 : 1),
+		};
+	}
+
+	return colord(colorObject).rgba;
+}