@alexlit/lint-kit 183.4.0 → 183.6.0

package/packages/config-stylelint/node_modules/stylelint/lib/rules/declaration-block-no-redundant-longhand-properties/index.mjs

@@ -0,0 +1,411 @@
+import valueParser from 'postcss-value-parser';
+
+import { isRegExp, isString } from '../../utils/validateTypes.mjs';
+import arrayEqual from '../../utils/arrayEqual.mjs';
+import { basicKeywords } from '../../reference/keywords.mjs';
+import eachDeclarationBlock from '../../utils/eachDeclarationBlock.mjs';
+import { longhandSubPropertiesOfShorthandProperties } from '../../reference/properties.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';
+
+const ruleName = 'declaration-block-no-redundant-longhand-properties';
+
+const messages = ruleMessages(ruleName, {
+	expected: (property) => `Expected shorthand property "${property}"`,
+	unexpectedLonghand: (longhand, shorthand) =>
+		`Unexpected longhand property "${longhand}" after shorthand property "${shorthand}" with same value`,
+});
+
+const meta = {
+	url: 'https://stylelint.io/user-guide/rules/declaration-block-no-redundant-longhand-properties',
+	fixable: true,
+};
+
+/** @typedef {import('postcss').Declaration} Declaration */
+
+/** @type {Map<string, (decls: Map<string, Declaration>) => (string | undefined)>} */
+const customResolvers = new Map([
+	[
+		'font-synthesis',
+		(decls) => {
+			const weight = decls.get('font-synthesis-weight')?.value.trim();
+			const style = decls.get('font-synthesis-style')?.value.trim();
+			const smallCaps = decls.get('font-synthesis-small-caps')?.value.trim();
+
+			/** @type {(s: string | undefined) => boolean} */
+			const isValidFontSynthesisValue = (s) => s === 'none' || s === 'auto';
+
+			if (
+				!isValidFontSynthesisValue(weight) ||
+				!isValidFontSynthesisValue(style) ||
+				!isValidFontSynthesisValue(smallCaps)
+			) {
+				return;
+			}
+
+			const autoShorthands = [];
+
+			if (weight === 'auto') {
+				autoShorthands.push('weight');
+			}
+
+			if (style === 'auto') {
+				autoShorthands.push('style');
+			}
+
+			if (smallCaps === 'auto') {
+				autoShorthands.push('small-caps');
+			}
+
+			if (autoShorthands.length === 0) return 'none';
+
+			return autoShorthands.join(' ');
+		},
+	],
+	[
+		'grid-column',
+		(decls) => {
+			const start = decls.get('grid-column-start')?.value.trim();
+			const end = decls.get('grid-column-end')?.value.trim();
+
+			if (!start || !end) return;
+
+			return `${start} / ${end}`;
+		},
+	],
+	[
+		'grid-row',
+		(decls) => {
+			const start = decls.get('grid-row-start')?.value.trim();
+			const end = decls.get('grid-row-end')?.value.trim();
+
+			if (!start || !end) return;
+
+			return `${start} / ${end}`;
+		},
+	],
+	[
+		'grid-template',
+		(decls) => {
+			const areas = decls.get('grid-template-areas')?.value.trim();
+			const columns = decls.get('grid-template-columns')?.value.trim();
+			const rows = decls.get('grid-template-rows')?.value.trim();
+
+			if (!(areas && columns && rows)) return;
+
+			// repeat() is not allowed inside track listings for grid-template.
+			// related issue: https://github.com/stylelint/stylelint/issues/7228
+			// spec ref: https://drafts.csswg.org/css-grid/#explicit-grid-shorthand
+
+			if (columns.includes('repeat(') || rows.includes('repeat(')) return;
+
+			const splitAreas = [...areas.matchAll(/"[^"]+"/g)].map((x) => x[0]);
+			const splitRows = rows.split(' ');
+
+			if (splitAreas.length === 0 || splitRows.length === 0) return;
+
+			if (splitAreas.length !== splitRows.length) return;
+
+			const zipped = splitAreas.map((area, i) => `${area} ${splitRows[i]}`).join(' ');
+
+			return `${zipped} / ${columns}`;
+		},
+	],
+	[
+		'transition',
+		(decls) => {
+			/** @type {(input: string | undefined) => string[]} */
+			const commaSeparated = (input = '') => {
+				const trimmedInput = input.trim();
+
+				if (!trimmedInput) return [];
+
+				if (trimmedInput.indexOf(',') === -1) return [trimmedInput];
+
+				/** @type {import('postcss-value-parser').ParsedValue} */
+				const parsedValue = valueParser(trimmedInput);
+				/** @type {Array<Array<import('postcss-value-parser').Node>>} */
+				const valueParts = [];
+
+				{
+					/** @type {Array<import('postcss-value-parser').Node>} */
+					let currentListItem = [];
+
+					parsedValue.nodes.forEach((node) => {
+						if (node.type === 'div' && node.value === ',') {
+							valueParts.push(currentListItem);
+							currentListItem = [];
+
+							return;
+						}
+
+						currentListItem.push(node);
+					});
+
+					valueParts.push(currentListItem);
+				}
+
+				return valueParts.map((s) => valueParser.stringify(s).trim()).filter((s) => s.length > 0);
+			};
+
+			const delays = commaSeparated(decls.get('transition-delay')?.value);
+			const durations = commaSeparated(decls.get('transition-duration')?.value);
+			const timingFunctions = commaSeparated(decls.get('transition-timing-function')?.value);
+			const properties = commaSeparated(decls.get('transition-property')?.value);
+
+			if (!(delays.length && durations.length && timingFunctions.length && properties.length)) {
+				return;
+			}
+
+			// transition-property is the canonical list of the number of properties;
+			// see spec: https://w3c.github.io/csswg-drafts/css-transitions/#transition-property-property
+			// if there are more transition-properties than duration/delay/timings,
+			// the other properties are computed cyclically -- ex with %
+			// see spec example #3: https://w3c.github.io/csswg-drafts/css-transitions/#example-d94cbd75
+			return properties
+				.map((property, i) => {
+					return [
+						property,
+						durations[i % durations.length],
+						timingFunctions[i % timingFunctions.length],
+						delays[i % delays.length],
+					]
+						.filter(isString)
+						.join(' ');
+				})
+				.join(', ');
+		},
+	],
+]);
+
+const haveConflicts = [
+	'border-width',
+	'border-style',
+	'border-color',
+	'border-top',
+	'border-right',
+	'border-bottom',
+	'border-left',
+	'grid-column',
+	'grid-row',
+];
+
+/**
+ * @param {string} prefixedShorthandProperty
+ * @param {string[]} prefixedShorthandData
+ * @param {Map<string, Declaration>} transformedDeclarationNodes
+ * @returns {string | undefined}
+ */
+const resolveShorthandValue = (
+	prefixedShorthandProperty,
+	prefixedShorthandData,
+	transformedDeclarationNodes,
+) => {
+	const resolver = customResolvers.get(prefixedShorthandProperty);
+
+	if (resolver === undefined) {
+		// the "default" resolver: sort the longhand values in the order
+		// of their properties
+		const values = prefixedShorthandData
+			.map((p) => transformedDeclarationNodes.get(p)?.value.trim())
+			.filter(Boolean);
+
+		return values.length > 0 ? values.join(' ') : undefined;
+	}
+
+	return resolver(transformedDeclarationNodes);
+};
+
+/** @type {import('stylelint').CoreRules[ruleName]} */
+const rule = (primary, secondaryOptions) => {
+	return (root, result) => {
+		const validOptions = validateOptions(
+			result,
+			ruleName,
+			{ actual: primary },
+			{
+				actual: secondaryOptions,
+				possible: {
+					ignoreShorthands: [isString, isRegExp],
+					ignoreLonghands: [isString],
+				},
+				optional: true,
+			},
+		);
+
+		if (!validOptions) {
+			return;
+		}
+
+		/** @type {Map<string, import('stylelint').ShorthandProperties[]>} */
+		const longhandToShorthands = new Map();
+		const ignoreLonghands = [secondaryOptions?.ignoreLonghands ?? []].flat();
+
+		for (const [shorthand, longhandProps] of longhandSubPropertiesOfShorthandProperties.entries()) {
+			if (optionsMatches(secondaryOptions, 'ignoreShorthands', shorthand)) {
+				continue;
+			}
+
+			for (const longhand of longhandProps) {
+				if (ignoreLonghands.includes(longhand)) continue;
+
+				const shorthands = longhandToShorthands.get(longhand) || [];
+
+				shorthands.push(shorthand);
+				longhandToShorthands.set(longhand, shorthands);
+			}
+		}
+
+		eachDeclarationBlock(root, (eachDecl) => {
+			/** @type {Map<string, string[]>} */
+			const longhandDeclarations = new Map();
+			/** @type {Map<string, Declaration[]>} */
+			const longhandDeclarationNodes = new Map();
+			/** @type {Map<string, string>} */
+			const declaredShorthands = new Map();
+
+			eachDecl((decl) => {
+				const declValue = decl.value.trim();
+
+				// basic keywords are not allowed in shorthand properties
+				if (basicKeywords.has(decl.value)) {
+					return;
+				}
+
+				const prop = decl.prop.toLowerCase();
+				const unprefixedProp = vendor.unprefixed(prop);
+				const prefix = vendor.prefix(prop);
+
+				if (
+					longhandSubPropertiesOfShorthandProperties.has(
+						/** @type {import('stylelint').ShorthandProperties} */ (unprefixedProp),
+					)
+				) {
+					declaredShorthands.set(prop, declValue);
+				}
+
+				const shorthandProperties = longhandToShorthands.get(unprefixedProp);
+
+				if (!shorthandProperties) {
+					return;
+				}
+
+				for (const shorthandProperty of shorthandProperties) {
+					const prefixedShorthandProperty = prefix + shorthandProperty;
+					const shorthandValue = declaredShorthands.get(prefixedShorthandProperty);
+
+					if (shorthandValue === declValue) {
+						const fix = () => {
+							decl.remove();
+						};
+
+						report({
+							ruleName,
+							result,
+							node: decl,
+							word: decl.prop,
+							message: messages.unexpectedLonghand,
+							messageArgs: [decl.prop, prefixedShorthandProperty],
+							fix: {
+								apply: fix,
+								node: decl.parent,
+							},
+						});
+
+						return;
+					}
+
+					const longhandDeclaration = longhandDeclarations.get(prefixedShorthandProperty) || [];
+					const longhandDeclarationNode =
+						longhandDeclarationNodes.get(prefixedShorthandProperty) || [];
+
+					longhandDeclaration.push(prop);
+					longhandDeclarations.set(prefixedShorthandProperty, longhandDeclaration);
+
+					longhandDeclarationNode.push(decl);
+					longhandDeclarationNodes.set(prefixedShorthandProperty, longhandDeclarationNode);
+
+					const shorthandProps = new Set(
+						longhandSubPropertiesOfShorthandProperties.get(shorthandProperty),
+					);
+
+					ignoreLonghands.forEach((value) => shorthandProps.delete(value));
+					const prefixedShorthandData = Array.from(shorthandProps, (item) => prefix + item);
+
+					if (!arrayEqual(prefixedShorthandData.toSorted(), longhandDeclaration.toSorted())) {
+						continue;
+					}
+
+					const declNodes = longhandDeclarationNodes.get(prefixedShorthandProperty) || [];
+
+					const importantDeclNodesCount = declNodes.reduce(
+						(count, declNode) => (declNode.important ? count + 1 : count),
+						0,
+					);
+
+					if (importantDeclNodesCount && importantDeclNodesCount !== declNodes.length) {
+						continue;
+					}
+
+					const [firstDeclNode] = declNodes;
+					let resolvedShorthandValue = undefined;
+
+					if (firstDeclNode) {
+						const transformedDeclarationNodes = new Map(
+							declNodes.map((d) => [d.prop.toLowerCase(), d]),
+						);
+
+						resolvedShorthandValue = resolveShorthandValue(
+							prefixedShorthandProperty,
+							prefixedShorthandData,
+							transformedDeclarationNodes,
+						);
+					}
+
+					const hasFix = firstDeclNode && resolvedShorthandValue;
+					const fix = hasFix
+						? () => {
+								const newShorthandDeclarationNode = firstDeclNode.clone({
+									prop: prefixedShorthandProperty,
+									value: resolvedShorthandValue,
+								});
+
+								firstDeclNode.replaceWith(newShorthandDeclarationNode);
+								declNodes.forEach((node) => node.remove());
+
+								if (haveConflicts.includes(shorthandProperty)) {
+									longhandDeclarations.forEach((longhands, shorthand) => {
+										longhandDeclarations.set(
+											shorthand,
+											longhands.filter((longhand) => !longhandDeclaration.includes(longhand)),
+										);
+									});
+								}
+							}
+						: undefined;
+
+					report({
+						ruleName,
+						result,
+						node: decl,
+						word: decl.prop,
+						message: messages.expected,
+						messageArgs: [prefixedShorthandProperty],
+						fix: {
+							apply: fix,
+							node: decl.parent,
+						},
+					});
+				}
+			});
+		});
+	};
+};
+
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;
+export default rule;

package/packages/config-stylelint/node_modules/stylelint/lib/rules/declaration-block-no-shorthand-property-overrides/index.mjs

@@ -0,0 +1,74 @@
+import eachDeclarationBlock from '../../utils/eachDeclarationBlock.mjs';
+import report from '../../utils/report.mjs';
+import ruleMessages from '../../utils/ruleMessages.mjs';
+import uniteSets from '../../utils/uniteSets.mjs';
+import validateOptions from '../../utils/validateOptions.mjs';
+import vendor from '../../utils/vendor.mjs';
+
+import {
+	longhandSubPropertiesOfShorthandProperties,
+	shorthandToResetToInitialProperty,
+} from '../../reference/properties.mjs';
+
+const ruleName = 'declaration-block-no-shorthand-property-overrides';
+
+const messages = ruleMessages(ruleName, {
+	rejected: (shorthand, original) => `Unexpected shorthand "${shorthand}" after "${original}"`,
+});
+
+const meta = {
+	url: 'https://stylelint.io/user-guide/rules/declaration-block-no-shorthand-property-overrides',
+};
+
+/** @type {import('stylelint').CoreRules[ruleName]} */
+const rule = (primary) => {
+	return (root, result) => {
+		const validOptions = validateOptions(result, ruleName, { actual: primary });
+
+		if (!validOptions) {
+			return;
+		}
+
+		eachDeclarationBlock(root, (eachDecl) => {
+			/** @type {Map<string, string>} */
+			const declarations = new Map();
+
+			eachDecl((decl) => {
+				const prop = decl.prop;
+				const unprefixedProp = vendor.unprefixed(prop).toLowerCase();
+				const prefix = vendor.prefix(prop).toLowerCase();
+				const subProperties = /** @type {Map<string, Set<string>>} */ (
+					longhandSubPropertiesOfShorthandProperties
+				).get(unprefixedProp);
+				const resettables = shorthandToResetToInitialProperty.get(unprefixedProp);
+				const union = uniteSets(subProperties ?? [], resettables ?? []);
+
+				declarations.set(prop.toLowerCase(), prop);
+
+				if (union.size === 0) return;
+
+				for (const property of union) {
+					const declaration = declarations.get(prefix + property);
+
+					if (!declaration) {
+						continue;
+					}
+
+					report({
+						ruleName,
+						result,
+						node: decl,
+						message: messages.rejected,
+						messageArgs: [prop, declaration || ''],
+						word: prop,
+					});
+				}
+			});
+		});
+	};
+};
+
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;
+export default rule;

package/packages/config-stylelint/node_modules/stylelint/lib/rules/declaration-block-single-line-max-declarations/index.mjs

@@ -0,0 +1,62 @@
+import blockString from '../../utils/blockString.mjs';
+import { isNumber } from '../../utils/validateTypes.mjs';
+import isSingleLineString from '../../utils/isSingleLineString.mjs';
+import report from '../../utils/report.mjs';
+import ruleMessages from '../../utils/ruleMessages.mjs';
+import validateOptions from '../../utils/validateOptions.mjs';
+
+const ruleName = 'declaration-block-single-line-max-declarations';
+
+const messages = ruleMessages(ruleName, {
+	expected: (max) => `Expected no more than ${max} ${max === 1 ? 'declaration' : 'declarations'}`,
+});
+
+const meta = {
+	url: 'https://stylelint.io/user-guide/rules/declaration-block-single-line-max-declarations',
+};
+
+/** @type {import('stylelint').CoreRules[ruleName]} */
+const rule = (primary) => {
+	return (root, result) => {
+		const validOptions = validateOptions(result, ruleName, {
+			actual: primary,
+			possible: [isNumber],
+		});
+
+		if (!validOptions) {
+			return;
+		}
+
+		root.walkRules((ruleNode) => {
+			const block = blockString(ruleNode);
+
+			if (!isSingleLineString(block)) {
+				return;
+			}
+
+			if (!ruleNode.nodes) {
+				return;
+			}
+
+			const decls = ruleNode.nodes.filter((node) => node.type === 'decl');
+
+			if (decls.length <= primary) {
+				return;
+			}
+
+			report({
+				message: messages.expected,
+				messageArgs: [primary],
+				node: ruleNode,
+				word: block,
+				result,
+				ruleName,
+			});
+		});
+	};
+};
+
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;
+export default rule;

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

@@ -0,0 +1,160 @@
+import { isAtRule, isRoot, isRule } from '../../utils/typeGuards.mjs';
+import blockString from '../../utils/blockString.mjs';
+import fixEmptyLinesBefore from '../../utils/fixEmptyLinesBefore.mjs';
+import hasEmptyLine from '../../utils/hasEmptyLine.mjs';
+import isAfterBlock from '../../utils/isAfterBlock.mjs';
+import isAfterComment from '../../utils/isAfterComment.mjs';
+import isAfterStandardPropertyDeclaration from '../../utils/isAfterStandardPropertyDeclaration.mjs';
+import isCustomProperty from '../../utils/isCustomProperty.mjs';
+import isFirstNested from '../../utils/isFirstNested.mjs';
+import isFirstNodeOfRoot from '../../utils/isFirstNodeOfRoot.mjs';
+import isSingleLineString from '../../utils/isSingleLineString.mjs';
+import isStandardSyntaxDeclaration from '../../utils/isStandardSyntaxDeclaration.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 = 'declaration-empty-line-before';
+
+const messages = ruleMessages(ruleName, {
+	expected: 'Expected empty line before declaration',
+	rejected: 'Unexpected empty line before declaration',
+});
+
+const meta = {
+	url: 'https://stylelint.io/user-guide/rules/declaration-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', 'after-block', 'after-comment', 'after-declaration'],
+					ignore: [
+						'after-comment',
+						'after-declaration',
+						'first-nested',
+						'inside-single-line-block',
+					],
+				},
+				optional: true,
+			},
+		);
+
+		if (!validOptions) {
+			return;
+		}
+
+		root.walkDecls((decl) => {
+			const prop = decl.prop;
+			const parent = decl.parent;
+
+			if (parent == null) {
+				return;
+			}
+
+			// Ignore the first node
+			if (isFirstNodeOfRoot(decl)) {
+				return;
+			}
+
+			if (!isAtRule(parent) && !isRule(parent) && !isRoot(parent)) {
+				return;
+			}
+
+			if (!isStandardSyntaxDeclaration(decl)) {
+				return;
+			}
+
+			if (isCustomProperty(prop)) {
+				return;
+			}
+
+			// Optionally ignore the node if a comment precedes it
+			if (optionsMatches(secondaryOptions, 'ignore', 'after-comment') && isAfterComment(decl)) {
+				return;
+			}
+
+			// Optionally ignore the node if a declaration precedes it
+			if (
+				optionsMatches(secondaryOptions, 'ignore', 'after-declaration') &&
+				isAfterStandardPropertyDeclaration(decl)
+			) {
+				return;
+			}
+
+			// Optionally ignore the node if it is the first nested
+			if (optionsMatches(secondaryOptions, 'ignore', 'first-nested') && isFirstNested(decl)) {
+				return;
+			}
+
+			// Optionally ignore nodes inside single-line blocks
+			if (
+				optionsMatches(secondaryOptions, 'ignore', 'inside-single-line-block') &&
+				isSingleLineString(blockString(parent))
+			) {
+				return;
+			}
+
+			let expectEmptyLineBefore = primary === 'always';
+
+			// Optionally reverse the expectation if any exceptions apply
+			if (
+				(optionsMatches(secondaryOptions, 'except', 'first-nested') && isFirstNested(decl)) ||
+				(optionsMatches(secondaryOptions, 'except', 'after-block') && isAfterBlock(decl)) ||
+				(optionsMatches(secondaryOptions, 'except', 'after-comment') && isAfterComment(decl)) ||
+				(optionsMatches(secondaryOptions, 'except', 'after-declaration') &&
+					isAfterStandardPropertyDeclaration(decl))
+			) {
+				expectEmptyLineBefore = !expectEmptyLineBefore;
+			}
+
+			// Check for at least one empty line
+			const hasEmptyLineBefore = hasEmptyLine(decl.raws.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: decl,
+					newline: context.newline,
+					action,
+				});
+
+			report({
+				message,
+				messageArgs: [],
+				node: decl,
+				result,
+				ruleName,
+				fix: {
+					apply: fix,
+					node: decl.parent,
+				},
+			});
+		});
+	};
+};
+
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;
+export default rule;