@alexlit/lint-kit 182.1.0 → 182.2.0

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

@@ -0,0 +1,183 @@
+import valueParser from 'postcss-value-parser';
+
+import { isRegExp, isString } from '../../utils/validateTypes.mjs';
+import { acceptCustomIdentsProperties } from '../../reference/properties.mjs';
+import { colord } from './colordUtils.mjs';
+import { declarationValueIndex } from '../../utils/nodeFieldIndices.mjs';
+import isStandardSyntaxFunction from '../../utils/isStandardSyntaxFunction.mjs';
+import isStandardSyntaxValue from '../../utils/isStandardSyntaxValue.mjs';
+import { mayIncludeRegexes } from '../../utils/regexes.mjs';
+import { namedColorsKeywords } from '../../reference/keywords.mjs';
+import optionsMatches from '../../utils/optionsMatches.mjs';
+import report from '../../utils/report.mjs';
+import ruleMessages from '../../utils/ruleMessages.mjs';
+import validateOptions from '../../utils/validateOptions.mjs';
+
+const ruleName = 'color-named';
+
+const messages = ruleMessages(ruleName, {
+	expected: (actual, expected) => `Expected "${actual}" to be "${expected}"`,
+	rejected: (keyword) => `Unexpected named color "${keyword}"`,
+});
+
+const meta = {
+	url: 'https://stylelint.io/user-guide/rules/color-named',
+};
+
+// Todo tested on case insensitivity
+const NODE_TYPES = new Set(['word', 'function']);
+
+/** @type {import('stylelint').CoreRules[ruleName]} */
+const rule = (primary, secondaryOptions) => {
+	return (root, result) => {
+		const validOptions = validateOptions(
+			result,
+			ruleName,
+			{
+				actual: primary,
+				possible: ['never', 'always-where-possible'],
+			},
+			{
+				actual: secondaryOptions,
+				possible: {
+					ignoreProperties: [isString, isRegExp],
+					ignore: ['inside-function'],
+				},
+				optional: true,
+			},
+		);
+
+		if (!validOptions) {
+			return;
+		}
+
+		root.walkDecls((decl) => {
+			if (acceptCustomIdentsProperties.has(decl.prop)) {
+				return;
+			}
+
+			// Return early if the property is to be ignored
+			if (optionsMatches(secondaryOptions, 'ignoreProperties', decl.prop)) {
+				return;
+			}
+
+			const { value: declValue } = decl;
+
+			if (primary === 'never' && !mayIncludeRegexes.namedColor.test(declValue)) {
+				return;
+			}
+
+			if (
+				primary === 'always-where-possible' &&
+				!mayIncludeRegexes.validHex.test(declValue) &&
+				!mayIncludeRegexes.colorFunction.test(declValue) &&
+				!mayIncludeRegexes.grayFunction.test(declValue)
+			) {
+				return;
+			}
+
+			valueParser(declValue).walk((node) => {
+				const value = node.value;
+				const type = node.type;
+				const sourceIndex = node.sourceIndex;
+
+				if (optionsMatches(secondaryOptions, 'ignore', 'inside-function') && type === 'function') {
+					return false;
+				}
+
+				if (!isStandardSyntaxFunction(node)) {
+					return false;
+				}
+
+				if (!isStandardSyntaxValue(value)) {
+					return;
+				}
+
+				// Return early if neither a word nor a function
+				if (!NODE_TYPES.has(type)) {
+					return;
+				}
+
+				// Check for named colors for "never" option
+				if (
+					primary === 'never' &&
+					type === 'word' &&
+					namedColorsKeywords.has(value.toLowerCase())
+				) {
+					complain(
+						messages.rejected,
+						[value],
+						decl,
+						declarationValueIndex(decl) + sourceIndex,
+						value.length,
+					);
+
+					return;
+				}
+
+				// Check "always-where-possible" option ...
+				if (primary !== 'always-where-possible') {
+					return;
+				}
+
+				let rawColorString = null;
+				let colorString = null;
+
+				if (type === 'function') {
+					rawColorString = valueParser.stringify(node);
+
+					// First by checking for alternative color function representations ...
+					// Remove all spaces to match what's in `representations`
+					colorString = rawColorString.replace(/\s*([,/()])\s*/g, '$1').replace(/\s{2,}/g, ' ');
+				} else if (type === 'word' && value.startsWith('#')) {
+					// Then by checking for alternative hex representations
+					rawColorString = colorString = value;
+				} else {
+					return;
+				}
+
+				const color = colord(colorString);
+
+				if (!color.isValid()) {
+					return;
+				}
+
+				const namedColor = color.toName();
+
+				if (namedColor && namedColor.toLowerCase() !== 'transparent') {
+					complain(
+						messages.expected,
+						[colorString, namedColor],
+						decl,
+						declarationValueIndex(decl) + sourceIndex,
+						rawColorString.length,
+					);
+				}
+			});
+		});
+
+		/**
+		 * @param {typeof messages[keyof messages]} message
+		 * @param {string[]} messageArgs
+		 * @param {import('postcss').Node} node
+		 * @param {number} index
+		 * @param {number} length
+		 */
+		function complain(message, messageArgs, node, index, length) {
+			report({
+				result,
+				ruleName,
+				message,
+				messageArgs,
+				node,
+				index,
+				endIndex: index + length,
+			});
+		}
+	};
+};
+
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;
+export default rule;

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

@@ -0,0 +1,69 @@
+import valueParser from 'postcss-value-parser';
+
+import { declarationValueIndex } from '../../utils/nodeFieldIndices.mjs';
+import getDeclarationValue from '../../utils/getDeclarationValue.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-no-hex';
+
+const messages = ruleMessages(ruleName, {
+	rejected: (hex) => `Unexpected hex color "${hex}"`,
+});
+
+const meta = {
+	url: 'https://stylelint.io/user-guide/rules/color-no-hex',
+};
+
+const HEX = /^#[\da-z]+$/i;
+
+/** @type {import('stylelint').CoreRules[ruleName]} */
+const rule = (primary) => {
+	return (root, result) => {
+		const validOptions = validateOptions(result, ruleName, { actual: primary });
+
+		if (!validOptions) {
+			return;
+		}
+
+		root.walkDecls((decl) => {
+			if (!mayIncludeRegexes.hexColor.test(decl.value)) return;
+
+			const parsedValue = valueParser(getDeclarationValue(decl));
+
+			parsedValue.walk((node) => {
+				if (isUrlFunction(node)) return false;
+
+				if (!isHexColor(node)) return;
+
+				const index = declarationValueIndex(decl) + node.sourceIndex;
+				const endIndex = index + node.value.length;
+
+				report({
+					message: messages.rejected,
+					messageArgs: [node.value],
+					node: decl,
+					index,
+					endIndex,
+					result,
+					ruleName,
+				});
+			});
+		});
+	};
+};
+
+/**
+ * @param {import('postcss-value-parser').Node} node
+ */
+function isHexColor({ type, value }) {
+	return type === 'word' && HEX.test(value);
+}
+
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;
+export default rule;

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

@@ -0,0 +1,68 @@
+import valueParser from 'postcss-value-parser';
+
+import { declarationValueIndex } from '../../utils/nodeFieldIndices.mjs';
+import isStandardSyntaxHexColor from '../../utils/isStandardSyntaxHexColor.mjs';
+import isValidHex from '../../utils/isValidHex.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-no-invalid-hex';
+
+const messages = ruleMessages(ruleName, {
+	rejected: (hex) => `Unexpected invalid hex color "${hex}"`,
+});
+
+const meta = {
+	url: 'https://stylelint.io/user-guide/rules/color-no-invalid-hex',
+};
+
+/** @type {import('stylelint').CoreRules[ruleName]} */
+const rule = (primary) => {
+	return (root, result) => {
+		const validOptions = validateOptions(result, ruleName, { actual: primary });
+
+		if (!validOptions) {
+			return;
+		}
+
+		root.walkDecls((decl) => {
+			if (!mayIncludeRegexes.hexColor.test(decl.value)) return;
+
+			if (!isStandardSyntaxHexColor(decl.value)) return;
+
+			valueParser(decl.value).walk(({ value, type, sourceIndex }) => {
+				if (type === 'function' && value.endsWith('url')) return false;
+
+				if (type !== 'word') return;
+
+				const hexMatch = /^#[\da-z]+/i.exec(value);
+
+				if (!hexMatch) return;
+
+				const hexValue = hexMatch[0];
+
+				if (!hexValue || isValidHex(hexValue)) return;
+
+				const index = declarationValueIndex(decl) + sourceIndex;
+				const endIndex = index + hexValue.length;
+
+				report({
+					message: messages.rejected,
+					messageArgs: [hexValue],
+					node: decl,
+					index,
+					endIndex,
+					result,
+					ruleName,
+				});
+			});
+		});
+	};
+};
+
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;
+export default rule;

package/packages/config-stylelint/node_modules/stylelint/lib/rules/comment-empty-line-before/index.mjs

@@ -0,0 +1,131 @@
+import { isRegExp, isString } from '../../utils/validateTypes.mjs';
+import fixEmptyLinesBefore from '../../utils/fixEmptyLinesBefore.mjs';
+import hasEmptyLine from '../../utils/hasEmptyLine.mjs';
+import isAfterComment from '../../utils/isAfterComment.mjs';
+import { isConfigurationComment } from '../../utils/configurationComment.mjs';
+import isFirstNested from '../../utils/isFirstNested.mjs';
+import isFirstNodeOfRoot from '../../utils/isFirstNodeOfRoot.mjs';
+import isSharedLineComment from '../../utils/isSharedLineComment.mjs';
+import isStandardSyntaxComment from '../../utils/isStandardSyntaxComment.mjs';
+import optionsMatches from '../../utils/optionsMatches.mjs';
+import report from '../../utils/report.mjs';
+import ruleMessages from '../../utils/ruleMessages.mjs';
+import validateOptions from '../../utils/validateOptions.mjs';
+
+const ruleName = 'comment-empty-line-before';
+
+const messages = ruleMessages(ruleName, {
+	expected: 'Expected empty line before comment',
+	rejected: 'Unexpected empty line before comment',
+});
+
+const meta = {
+	url: 'https://stylelint.io/user-guide/rules/comment-empty-line-before',
+	fixable: true,
+};
+
+/** @type {import('stylelint').CoreRules[ruleName]} */
+const rule = (primary, secondaryOptions, context) => {
+	return (root, result) => {
+		const validOptions = validateOptions(
+			result,
+			ruleName,
+			{
+				actual: primary,
+				possible: ['always', 'never'],
+			},
+			{
+				actual: secondaryOptions,
+				possible: {
+					except: ['first-nested'],
+					ignore: ['stylelint-commands', 'after-comment'],
+					ignoreComments: [isString, isRegExp],
+				},
+				optional: true,
+			},
+		);
+
+		if (!validOptions) {
+			return;
+		}
+
+		root.walkComments((comment) => {
+			// Ignore the first node
+			if (isFirstNodeOfRoot(comment)) {
+				return;
+			}
+
+			// Optionally ignore stylelint commands
+			if (
+				isConfigurationComment(comment, context.configurationComment) &&
+				optionsMatches(secondaryOptions, 'ignore', 'stylelint-commands')
+			) {
+				return;
+			}
+
+			// Optionally ignore newlines between comments
+			if (optionsMatches(secondaryOptions, 'ignore', 'after-comment') && isAfterComment(comment)) {
+				return;
+			}
+
+			// Ignore comments matching the ignoreComments option.
+			if (optionsMatches(secondaryOptions, 'ignoreComments', comment.text)) {
+				return;
+			}
+
+			// Ignore shared-line comments
+			if (isSharedLineComment(comment)) {
+				return;
+			}
+
+			// Ignore non-standard comments
+			if (!isStandardSyntaxComment(comment)) {
+				return;
+			}
+
+			const expectEmptyLineBefore = (() => {
+				if (optionsMatches(secondaryOptions, 'except', 'first-nested') && isFirstNested(comment)) {
+					return false;
+				}
+
+				return primary === 'always';
+			})();
+
+			const before = comment.raws.before || '';
+			const hasEmptyLineBefore = hasEmptyLine(before);
+
+			// Return if the expectation is met
+			if (expectEmptyLineBefore === hasEmptyLineBefore) {
+				return;
+			}
+
+			const message = expectEmptyLineBefore ? messages.expected : messages.rejected;
+			const action = expectEmptyLineBefore ? 'add' : 'remove';
+
+			// Fix
+			const fix = () =>
+				fixEmptyLinesBefore({
+					node: comment,
+					newline: context.newline,
+					action,
+				});
+
+			report({
+				message,
+				messageArgs: [],
+				node: comment,
+				result,
+				ruleName,
+				fix: {
+					apply: fix,
+					node: comment.parent,
+				},
+			});
+		});
+	};
+};
+
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;
+export default rule;

package/packages/config-stylelint/node_modules/stylelint/lib/rules/comment-no-empty/index.mjs

@@ -0,0 +1,50 @@
+import isStandardSyntaxComment from '../../utils/isStandardSyntaxComment.mjs';
+import report from '../../utils/report.mjs';
+import ruleMessages from '../../utils/ruleMessages.mjs';
+import validateOptions from '../../utils/validateOptions.mjs';
+
+const ruleName = 'comment-no-empty';
+
+const messages = ruleMessages(ruleName, {
+	rejected: 'Unexpected empty comment',
+});
+
+const meta = {
+	url: 'https://stylelint.io/user-guide/rules/comment-no-empty',
+};
+
+/** @type {import('stylelint').CoreRules[ruleName]} */
+const rule = (primary) => {
+	return (root, result) => {
+		const validOptions = validateOptions(result, ruleName, { actual: primary });
+
+		if (!validOptions) {
+			return;
+		}
+
+		root.walkComments((comment) => {
+			// To ignore non-standard comments
+			if (!isStandardSyntaxComment(comment)) {
+				return;
+			}
+
+			// To ignore comments that are not empty
+			if (comment.text && comment.text.length !== 0) {
+				return;
+			}
+
+			report({
+				message: messages.rejected,
+				messageArgs: [],
+				node: comment,
+				result,
+				ruleName,
+			});
+		});
+	};
+};
+
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;
+export default rule;

package/packages/config-stylelint/node_modules/stylelint/lib/rules/comment-pattern/index.mjs

@@ -0,0 +1,51 @@
+import { isRegExp, isString } from '../../utils/validateTypes.mjs';
+import report from '../../utils/report.mjs';
+import ruleMessages from '../../utils/ruleMessages.mjs';
+import validateOptions from '../../utils/validateOptions.mjs';
+
+const ruleName = 'comment-pattern';
+
+const messages = ruleMessages(ruleName, {
+	expected: (pattern) => `Expected comment to match pattern "${pattern}"`,
+});
+
+const meta = {
+	url: 'https://stylelint.io/user-guide/rules/comment-pattern',
+};
+
+/** @type {import('stylelint').CoreRules[ruleName]} */
+const rule = (primary) => {
+	return (root, result) => {
+		const validOptions = validateOptions(result, ruleName, {
+			actual: primary,
+			possible: [isRegExp, isString],
+		});
+
+		if (!validOptions) {
+			return;
+		}
+
+		const normalizedPattern = isString(primary) ? new RegExp(primary) : primary;
+
+		root.walkComments((comment) => {
+			const text = comment.text;
+
+			if (normalizedPattern.test(text)) {
+				return;
+			}
+
+			report({
+				message: messages.expected,
+				messageArgs: [primary],
+				node: comment,
+				result,
+				ruleName,
+			});
+		});
+	};
+};
+
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;
+export default rule;

package/packages/config-stylelint/node_modules/stylelint/lib/rules/comment-whitespace-inside/index.mjs

@@ -0,0 +1,149 @@
+import isStandardSyntaxComment from '../../utils/isStandardSyntaxComment.mjs';
+import isWhitespace from '../../utils/isWhitespace.mjs';
+import report from '../../utils/report.mjs';
+import ruleMessages from '../../utils/ruleMessages.mjs';
+import validateOptions from '../../utils/validateOptions.mjs';
+
+const ruleName = 'comment-whitespace-inside';
+
+const messages = ruleMessages(ruleName, {
+	expectedOpening: 'Expected whitespace after "/*"',
+	rejectedOpening: 'Unexpected whitespace after "/*"',
+	expectedClosing: 'Expected whitespace before "*/"',
+	rejectedClosing: 'Unexpected whitespace before "*/"',
+});
+
+const meta = {
+	url: 'https://stylelint.io/user-guide/rules/comment-whitespace-inside',
+	fixable: true,
+};
+
+/**
+ * @param {import('postcss').Comment} comment
+ */
+function addWhitespaceBefore(comment) {
+	if (comment.text.startsWith('*')) {
+		comment.text = comment.text.replace(/^(\*+)/, `$1 `);
+	} else {
+		comment.raws.left = ' ';
+	}
+}
+
+/**
+ * @param {import('postcss').Comment} comment
+ */
+function addWhitespaceAfter(comment) {
+	if (comment.text[comment.text.length - 1] === '*') {
+		comment.text = comment.text.replace(/(\*+)$/, ` $1`);
+	} else {
+		comment.raws.right = ' ';
+	}
+}
+
+/** @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.walkComments((comment) => {
+			if (!isStandardSyntaxComment(comment)) {
+				return;
+			}
+
+			const rawComment = comment.toString();
+			const firstFourChars = rawComment.slice(0, 4);
+
+			// Return early if sourcemap or copyright comment
+			if (/^\/\*[#!]\s/.test(firstFourChars)) {
+				return;
+			}
+
+			const leftMatches = rawComment.match(/(^\/\*+)(\s*)/);
+
+			if (leftMatches == null || leftMatches[1] == null) {
+				throw new Error(`Invalid comment: "${rawComment}"`);
+			}
+
+			const rightMatches = rawComment.match(/(\s*)(\*+\/)$/);
+
+			if (rightMatches == null || rightMatches[2] == null) {
+				throw new Error(`Invalid comment: "${rawComment}"`);
+			}
+
+			const opener = leftMatches[1];
+			const leftWord = leftMatches[2] ?? '';
+			const leftSpace = leftWord.charAt(0);
+			const rightWord = rightMatches[1] ?? '';
+			const rightSpace = rightWord.charAt(0);
+			const closer = rightMatches[2];
+
+			if (primary === 'never' && leftSpace !== '') {
+				const index = opener.length;
+				const endIndex = index + leftWord.length;
+
+				complain(messages.rejectedOpening, index, endIndex);
+			}
+
+			if (primary === 'always' && !isWhitespace(leftSpace)) {
+				complain(messages.expectedOpening, opener.length);
+			}
+
+			if (primary === 'never' && rightSpace !== '') {
+				const endIndex = rawComment.length - closer.length;
+				const index = endIndex - rightWord.length;
+
+				complain(messages.rejectedClosing, index, endIndex);
+			}
+
+			if (primary === 'always' && !isWhitespace(rightSpace)) {
+				complain(messages.expectedClosing, rawComment.length - closer.length - 1);
+			}
+
+			/**
+			 * @param {string} message
+			 * @param {number} index
+			 * @param {number} endIndex
+			 */
+			function complain(message, index, endIndex = index) {
+				const fix = () => {
+					if (primary === 'never') {
+						comment.raws.left = '';
+						comment.raws.right = '';
+						comment.text = comment.text.replace(/^(\*+)(\s+)?/, '$1').replace(/(\s+)?(\*+)$/, '$2');
+					} else {
+						const mutate =
+							message === messages.expectedClosing ? addWhitespaceAfter : addWhitespaceBefore;
+
+						mutate(comment);
+					}
+				};
+
+				report({
+					message,
+					messageArgs: [],
+					index,
+					endIndex,
+					result,
+					ruleName,
+					node: comment,
+					fix: {
+						apply: fix,
+						node: comment,
+					},
+				});
+			}
+		});
+	};
+};
+
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;
+export default rule;