@alexlit/lint-kit 182.2.0 → 182.3.0

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

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

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

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

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