@alexlit/lint-kit 182.2.0 → 182.3.0

package/packages/config-stylelint/node_modules/stylelint/lib/rules/shorthand-property-no-redundant-values/index.mjs

@@ -1,359 +0,0 @@
-import valueParser from 'postcss-value-parser';
-
-import { declarationValueIndex } from '../../utils/nodeFieldIndices.mjs';
-import isStandardSyntaxDeclaration from '../../utils/isStandardSyntaxDeclaration.mjs';
-import isStandardSyntaxProperty from '../../utils/isStandardSyntaxProperty.mjs';
-import isStandardSyntaxValue from '../../utils/isStandardSyntaxValue.mjs';
-import isVarFunction from '../../utils/isVarFunction.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';
-import vendor from '../../utils/vendor.mjs';
-
-import { isValueDiv, isValueFunction, isValueWord } from '../../utils/typeGuards.mjs';
-
-const ruleName = 'shorthand-property-no-redundant-values';
-
-const messages = ruleMessages(ruleName, {
-	expected: (actual, expected) => `Expected "${actual}" to be "${expected}"`,
-});
-
-const meta = {
-	url: 'https://stylelint.io/user-guide/rules/shorthand-property-no-redundant-values',
-	fixable: true,
-};
-
-// prettier-ignore
-/** @type {ReadonlySet<string>} */
-const SUPPORTED_SHORTHANDS = new Set([
-	'margin', 'margin-block', 'margin-inline',
-	'padding', 'padding-block', 'padding-inline',
-	'border-color', 'border-style', 'border-width',
-	'border-radius',
-	'border-block-color', 'border-block-style', 'border-block-width',
-	'border-inline-color', 'border-inline-style', 'border-inline-width',
-	'gap', 'grid-gap',
-	'overflow',
-	'overscroll-behavior',
-	'scroll-margin', 'scroll-margin-block', 'scroll-margin-inline',
-	'scroll-padding', 'scroll-padding-block', 'scroll-padding-inline',
-	'inset', 'inset-block', 'inset-inline',
-]);
-
-// prettier-ignore
-/** @type {ReadonlySet<string>} */
-const FOUR_DIRECTIONAL_SHORTHAND_PROPERTIES = new Set([
-	'margin',
-	'padding',
-	'border-color', 'border-style', 'border-width',
-	'scroll-margin', 'scroll-padding',
-	'inset',
-]);
-
-/**
- * @param {string} top
- * @param {string} right
- * @param {string} bottom
- * @param {string} left
- * @returns {string[]}
- */
-function canCondense(top, right, bottom, left) {
-	const lowerTop = top.toLowerCase();
-	const lowerRight = right.toLowerCase();
-	const lowerBottom = bottom && bottom.toLowerCase();
-	const lowerLeft = left && left.toLowerCase();
-
-	if (canCondenseToOneValue(lowerTop, lowerRight, lowerBottom, lowerLeft)) {
-		return [top];
-	}
-
-	if (canCondenseToTwoValues(lowerTop, lowerRight, lowerBottom, lowerLeft)) {
-		return [top, right];
-	}
-
-	if (canCondenseToThreeValues(lowerTop, lowerRight, lowerBottom, lowerLeft)) {
-		return [top, right, bottom];
-	}
-
-	return [top, right, bottom, left];
-}
-
-/**
- * @param {string} top
- * @param {string} right
- * @param {string} bottom
- * @param {string} left
- * @returns {boolean}
- */
-function canCondenseToOneValue(top, right, bottom, left) {
-	if (top !== right) {
-		return false;
-	}
-
-	return (top === bottom && (bottom === left || !left)) || (!bottom && !left);
-}
-
-/**
- * @param {string} top
- * @param {string} right
- * @param {string} bottom
- * @param {string} left
- * @returns {boolean}
- */
-function canCondenseToTwoValues(top, right, bottom, left) {
-	return (top === bottom && right === left) || (top === bottom && !left && top !== right);
-}
-
-/**
- * @param {string} _top
- * @param {string} right
- * @param {string} _bottom
- * @param {string} left
- * @returns {boolean}
- */
-function canCondenseToThreeValues(_top, right, _bottom, left) {
-	return right === left;
-}
-
-/**
- * Split the `border-radius` value into horizontal and vertical radius arrays.
- *
- * @param {string} value
- * @returns {{ horizontal: string[]; vertical: string[]; sawSlash: boolean, horizontalHasVar: boolean, verticalHasVar: boolean }}
- */
-function splitBorderRadius(value) {
-	/** @type {string[]} */
-	const horizontal = [];
-	/** @type {string[]} */
-	const vertical = [];
-	let sawSlash = false;
-
-	let horizontalHasVar = false;
-	let verticalHasVar = false;
-
-	for (const node of valueParser(value).nodes) {
-		// Handle dividers: we only care about the slash
-		if (isValueDiv(node)) {
-			if (node.value === '/') {
-				sawSlash = true;
-				continue;
-			}
-
-			// Any other divider means we cannot safely lint
-			return {
-				horizontal: [],
-				vertical: [],
-				sawSlash: false,
-				horizontalHasVar: false,
-				verticalHasVar: false,
-			};
-		}
-
-		if (isVarFunction(node)) {
-			if (sawSlash) {
-				verticalHasVar = true;
-			} else {
-				horizontalHasVar = true;
-			}
-		}
-
-		if (isValueWord(node) || isValueFunction(node)) {
-			const token = valueParser.stringify(node);
-
-			if (sawSlash) {
-				vertical.push(token);
-			} else {
-				horizontal.push(token);
-			}
-		}
-	}
-
-	return { horizontal, vertical, sawSlash, horizontalHasVar, verticalHasVar };
-}
-
-/**
- * Process the `border-radius` value when a slash is present.
- *
- * @param {import('stylelint').PostcssResult} result
- * @param {import('postcss').Declaration} decl
- * @param {string[]} horizontal
- * @param {string[]} vertical
- * @param {boolean} horizontalHasVar
- * @param {boolean} verticalHasVar
- */
-function processBorderRadiusValue(
-	result,
-	decl,
-	horizontal,
-	vertical,
-	horizontalHasVar,
-	verticalHasVar,
-) {
-	const [h1 = '', h2 = '', h3 = '', h4 = ''] = horizontal;
-	const [v1 = '', v2 = '', v3 = '', v4 = ''] = vertical;
-
-	// Skip condensation on the side containing `var()`, condense the other.
-	const condensedHorizontal = horizontalHasVar
-		? horizontal.join(' ')
-		: canCondense(h1, h2, h3, h4).filter(Boolean).join(' ');
-	const condensedVertical = verticalHasVar
-		? vertical.join(' ')
-		: canCondense(v1, v2, v3, v4).filter(Boolean).join(' ');
-
-	const shortestFormString = `${condensedHorizontal} / ${condensedVertical}`.trim();
-	const valueLower = decl.value.trim().toLowerCase().replace(/\s+/g, ' ');
-	const shortestLower = shortestFormString.toLowerCase();
-
-	if (valueLower === shortestLower) return; // Already optimal
-
-	const fix = () => {
-		decl.value = shortestFormString;
-	};
-
-	const index = declarationValueIndex(decl);
-	const endIndex = index + decl.value.length;
-
-	report({
-		message: messages.expected,
-		messageArgs: [decl.value, shortestFormString],
-		node: decl,
-		index,
-		endIndex,
-		result,
-		ruleName,
-		fix: {
-			apply: fix,
-			node: decl,
-		},
-	});
-}
-
-/** @type {import('stylelint').CoreRules[ruleName]} */
-const rule = (primary, secondaryOptions) => {
-	return (root, result) => {
-		const validOptions = validateOptions(
-			result,
-			ruleName,
-			{ actual: primary },
-			{
-				actual: secondaryOptions,
-				possible: {
-					ignore: ['four-into-three-edge-values'],
-				},
-				optional: true,
-			},
-		);
-
-		if (!validOptions) {
-			return;
-		}
-
-		root.walkDecls((decl) => {
-			const { prop, value } = decl;
-
-			if (!/\s/.test(value)) return;
-
-			if (!isStandardSyntaxDeclaration(decl)) return;
-
-			if (!isStandardSyntaxProperty(prop)) return;
-
-			if (!isStandardSyntaxValue(value)) return;
-
-			const normalizedProp = vendor.unprefixed(prop.toLowerCase());
-
-			if (!SUPPORTED_SHORTHANDS.has(normalizedProp)) return;
-
-			// Special handling for `border-radius` when a slash is present
-			if (normalizedProp === 'border-radius') {
-				const { horizontal, vertical, sawSlash, horizontalHasVar, verticalHasVar } =
-					splitBorderRadius(value);
-
-				if (sawSlash) {
-					processBorderRadiusValue(
-						result,
-						decl,
-						horizontal,
-						vertical,
-						horizontalHasVar,
-						verticalHasVar,
-					);
-
-					return;
-				}
-			}
-
-			/** @type {string[]} */
-			const valuesToShorthand = [];
-
-			for (const valueNode of valueParser(value).nodes) {
-				if (isValueDiv(valueNode)) {
-					return;
-				}
-
-				// `var()` should be ignored. E.g.
-				//
-				//   --padding: 20px 5px;
-				//   padding: 0 var(--padding) 0;
-				//
-				if (isVarFunction(valueNode)) {
-					return;
-				}
-
-				if (isValueWord(valueNode) || isValueFunction(valueNode)) {
-					valuesToShorthand.push(valueParser.stringify(valueNode));
-				}
-			}
-
-			if (valuesToShorthand.length <= 1 || valuesToShorthand.length > 4) {
-				return;
-			}
-
-			const [first = '', second = '', third = '', fourth = ''] = valuesToShorthand;
-			const shortestForm = canCondense(first, second, third, fourth);
-
-			if (optionsMatches(secondaryOptions, 'ignore', 'four-into-three-edge-values')) {
-				if (
-					FOUR_DIRECTIONAL_SHORTHAND_PROPERTIES.has(normalizedProp) &&
-					valuesToShorthand.length === 4 &&
-					shortestForm.length === 3
-				) {
-					return;
-				}
-			}
-
-			const shortestFormString = shortestForm.filter(Boolean).join(' ');
-			const valuesFormString = valuesToShorthand.join(' ');
-
-			if (shortestFormString.toLowerCase() === valuesFormString.toLowerCase()) {
-				return;
-			}
-
-			const fix = () => {
-				decl.value = decl.value.replace(value, shortestFormString);
-			};
-
-			const index = declarationValueIndex(decl);
-			const endIndex = index + decl.value.length;
-
-			report({
-				message: messages.expected,
-				messageArgs: [value, shortestFormString],
-				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/string-no-newline/index.mjs

@@ -1,120 +0,0 @@
-import { ParseErrorMessage, ParseErrorWithToken, tokenize } from '@csstools/css-tokenizer';
-
-import { atRuleParamIndex, declarationValueIndex } from '../../utils/nodeFieldIndices.mjs';
-import isStandardSyntaxSelector from '../../utils/isStandardSyntaxSelector.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 = 'string-no-newline';
-const reNewLine = /\r?\n/;
-
-const messages = ruleMessages(ruleName, {
-	rejected: 'Unexpected newline in string',
-});
-
-const meta = {
-	url: 'https://stylelint.io/user-guide/rules/string-no-newline',
-};
-
-/** @type {import('stylelint').CoreRules[ruleName]} */
-const rule = (primary, secondaryOptions) => {
-	return (root, result) => {
-		const validOptions = validateOptions(
-			result,
-			ruleName,
-			{ actual: primary },
-			{
-				actual: secondaryOptions,
-				possible: {
-					ignore: ['at-rule-preludes', 'declaration-values'],
-				},
-				optional: true,
-			},
-		);
-
-		if (!validOptions) {
-			return;
-		}
-
-		root.walk((node) => {
-			switch (node.type) {
-				case 'atrule':
-					if (optionsMatches(secondaryOptions, 'ignore', 'at-rule-preludes')) break;
-
-					check(node, node.params, atRuleParamIndex);
-					break;
-				case 'decl':
-					if (optionsMatches(secondaryOptions, 'ignore', 'declaration-values')) break;
-
-					check(node, node.value, declarationValueIndex);
-					break;
-				case 'rule':
-					checkRule(node);
-					break;
-			}
-		});
-
-		/**
-		 * @param {import('postcss').Rule} ruleNode
-		 * @returns {void}
-		 */
-		function checkRule(ruleNode) {
-			// Get out quickly if there are no new line
-			if (!reNewLine.test(ruleNode.selector)) {
-				return;
-			}
-
-			if (!isStandardSyntaxSelector(ruleNode.selector)) {
-				return;
-			}
-
-			check(ruleNode, ruleNode.selector, () => 0);
-		}
-
-		/**
-		 * @template {import('postcss').AtRule | import('postcss').Rule | import('postcss').Declaration} T
-		 * @param {T} node
-		 * @param {string} value
-		 * @param {(node: T) => number} getIndex
-		 * @returns {void}
-		 */
-		function check(node, value, getIndex) {
-			// Get out quickly if there are no new line
-			if (!reNewLine.test(value)) {
-				return;
-			}
-
-			tokenize(
-				{ css: value },
-				{
-					onParseError: (err) => {
-						if (!(err instanceof ParseErrorWithToken)) return;
-
-						if (err.message !== ParseErrorMessage.UnexpectedNewLineInString) return;
-
-						const [, , start, end] = err.token;
-
-						const nodeIndex = getIndex(node);
-
-						report({
-							message: messages.rejected,
-							messageArgs: [],
-							node,
-							index: nodeIndex + start,
-							endIndex: nodeIndex + end + 1,
-							result,
-							ruleName,
-						});
-					},
-				},
-			);
-		}
-	};
-};
-
-rule.ruleName = ruleName;
-rule.messages = messages;
-rule.meta = meta;
-export default rule;

package/packages/config-stylelint/node_modules/stylelint/lib/rules/syntax-string-no-invalid/index.mjs

@@ -1,80 +0,0 @@
-import { isTokenString, tokenize } from '@csstools/css-tokenizer';
-import { fork } from 'css-tree';
-
-import { atRuleRegexes, descriptorRegexes } from '../../utils/regexes.mjs';
-import { declarationValueIndex } from '../../utils/nodeFieldIndices.mjs';
-import report from '../../utils/report.mjs';
-import ruleMessages from '../../utils/ruleMessages.mjs';
-import validateOptions from '../../utils/validateOptions.mjs';
-
-const ruleName = 'syntax-string-no-invalid';
-
-const messages = ruleMessages(ruleName, {
-	rejected: (syntaxString) => `Unexpected invalid syntax string "${syntaxString}"`,
-});
-
-const meta = {
-	url: 'https://stylelint.io/user-guide/rules/syntax-string-no-invalid',
-};
-
-const forkedLexer = fork({
-	properties: {
-		'-stylelint-syntax': "'*' | <syntax-component> [ <syntax-combinator> <syntax-component> ]*",
-	},
-	types: {
-		'syntax-component': "<syntax-single-component> <syntax-multiplier>? | '<' transform-list '>'",
-		'syntax-single-component': "'<' <syntax-type-name> '>' | <ident>",
-		'syntax-type-name':
-			'angle | color | custom-ident | image | integer | length | length-percentage | number | percentage | resolution | string | time | url | transform-function',
-		'syntax-combinator': "'|'",
-		'syntax-multiplier': "[ '#' | '+' ]",
-	},
-}).lexer;
-
-/** @type {import('stylelint').CoreRules[ruleName]} */
-const rule = (primary) => {
-	return (root, result) => {
-		const validOptions = validateOptions(result, ruleName, { actual: primary });
-
-		if (!validOptions) {
-			return;
-		}
-
-		root.walkAtRules(atRuleRegexes.propertyName, (atRule) => {
-			atRule.walkDecls(descriptorRegexes.syntaxName, (decl) => {
-				const tokens = tokenize({ css: decl.value }).filter((token) => isTokenString(token));
-
-				tokens.forEach((token) => {
-					const { error } = forkedLexer.matchProperty('-stylelint-syntax', token[4].value);
-
-					if (!error) return;
-
-					if (!('mismatchLength' in error)) return;
-
-					const { name, rawMessage } = error;
-
-					if (name !== 'SyntaxMatchError') return;
-
-					if (rawMessage !== 'Mismatch') return;
-
-					const valueIndex = declarationValueIndex(decl);
-
-					report({
-						message: messages.rejected,
-						messageArgs: [token[1]],
-						node: decl,
-						index: valueIndex + token[2],
-						endIndex: valueIndex + token[3] + 1,
-						result,
-						ruleName,
-					});
-				});
-			});
-		});
-	};
-};
-
-rule.ruleName = ruleName;
-rule.messages = messages;
-rule.meta = meta;
-export default rule;