@alexlit/lint-kit 182.2.0 → 182.3.0

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

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

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

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

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

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

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

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