@alexlit/lint-kit 173.2.2 → 173.3.0

package/packages/config-stylelint/node_modules/stylelint/lib/rules/number-max-precision/index.mjs

@@ -1,209 +0,0 @@
-import { TokenType, tokenize } from '@csstools/css-tokenizer';
-import {
-	isFunctionNode,
-	isTokenNode,
-	parseListOfComponentValues,
-	walk,
-} from '@csstools/css-parser-algorithms';
-
-import { atRuleParamIndex, declarationValueIndex } from '../../utils/nodeFieldIndices.mjs';
-import { isRegExp, isString } from '../../utils/validateTypes.mjs';
-import getAtRuleParams from '../../utils/getAtRuleParams.mjs';
-import getDeclarationValue from '../../utils/getDeclarationValue.mjs';
-import isNonNegativeInteger from '../../utils/isNonNegativeInteger.mjs';
-import matchesStringOrRegExp from '../../utils/matchesStringOrRegExp.mjs';
-import optionsMatches from '../../utils/optionsMatches.mjs';
-import report from '../../utils/report.mjs';
-import ruleMessages from '../../utils/ruleMessages.mjs';
-import validateObjectWithProps from '../../utils/validateObjectWithProps.mjs';
-import validateOptions from '../../utils/validateOptions.mjs';
-
-const ruleName = 'number-max-precision';
-
-const messages = ruleMessages(ruleName, {
-	expected: (actual, expected) => `Expected "${actual}" to be "${expected}"`,
-});
-
-const meta = {
-	url: 'https://stylelint.io/user-guide/rules/number-max-precision',
-};
-
-/** @type {import('stylelint').CoreRules[ruleName]} */
-const rule = (primary, secondaryOptions) => {
-	return (root, result) => {
-		const validOptions = validateOptions(
-			result,
-			ruleName,
-			{
-				actual: primary,
-				possible: [isNonNegativeInteger],
-			},
-			{
-				optional: true,
-				actual: secondaryOptions,
-				possible: {
-					ignoreProperties: [isString, isRegExp],
-					ignoreUnits: [isString, isRegExp],
-					insideFunctions: [validateObjectWithProps(isNonNegativeInteger)],
-				},
-			},
-		);
-
-		if (!validOptions) {
-			return;
-		}
-
-		/** @type {Map<string, number>} */
-		const insideFunctions = new Map(Object.entries(secondaryOptions?.insideFunctions ?? {}));
-
-		root.walkAtRules((atRule) => {
-			if (atRule.name.toLowerCase() === 'import') {
-				return;
-			}
-
-			check(atRule, atRuleParamIndex, getAtRuleParams(atRule));
-		});
-
-		root.walkDecls((decl) => {
-			check(decl, declarationValueIndex, getDeclarationValue(decl));
-		});
-
-		/**
-		 * @template {import('postcss').AtRule | import('postcss').Declaration} T
-		 * @param {T} node
-		 * @param {(node: T) => number} getIndex
-		 * @param {string} value
-		 */
-		function check(node, getIndex, value) {
-			// Get out quickly if there are no periods
-			if (!value.includes('.')) return;
-
-			const prop = 'prop' in node ? node.prop : undefined;
-
-			if (optionsMatches(secondaryOptions, 'ignoreProperties', prop)) {
-				return;
-			}
-
-			const initialState = {
-				ignored: false,
-				precision: primary,
-			};
-
-			walk(
-				parseListOfComponentValues(tokenize({ css: value })),
-				({ node: mediaNode, state }) => {
-					if (!state) return;
-
-					if (state.ignored) return;
-
-					walker(node, getIndex, mediaNode, state);
-				},
-				initialState,
-			);
-		}
-
-		/**
-		 * @template {import('postcss').AtRule | import('postcss').Declaration} T
-		 * @param {T} node
-		 * @param {(node: T) => number} getIndex
-		 * @param {import('@csstools/css-parser-algorithms').ComponentValue} componentValue
-		 * @param {{ ignored: boolean, precision: number }} state
-		 */
-		function walker(node, getIndex, componentValue, state) {
-			if (isFunctionNode(componentValue)) {
-				const name = componentValue.getName().toLowerCase();
-
-				if (name === 'url') {
-					// postcss-value-parser exposed url token contents as "word" tokens, these were indistinguishable from numeric values in any other function.
-					// With @csstools/css-tokenizer this is no longer relevant, but we preserve the old condition to avoid breaking changes.
-					state.ignored = true;
-
-					return;
-				}
-
-				state.precision = precisionInsideFunction(name, state.precision);
-
-				return;
-			}
-
-			if (!isTokenNode(componentValue)) {
-				return;
-			}
-
-			const [tokenType, raw, startIndex, endIndex, parsedValue] = componentValue.value;
-
-			if (
-				tokenType !== TokenType.Number &&
-				tokenType !== TokenType.Dimension &&
-				tokenType !== TokenType.Percentage
-			) {
-				return;
-			}
-
-			let unitStringLength = 0;
-
-			if (tokenType === TokenType.Dimension) {
-				const unit = parsedValue.unit;
-
-				unitStringLength = unit.length;
-
-				if (optionsMatches(secondaryOptions, 'ignoreUnits', unit)) {
-					return;
-				}
-			} else if (tokenType === TokenType.Percentage) {
-				unitStringLength = 1;
-
-				if (optionsMatches(secondaryOptions, 'ignoreUnits', '%')) {
-					return;
-				}
-			}
-
-			const match = /\d*\.(\d+)/.exec(raw);
-
-			if (match == null || match[0] == null || match[1] == null) {
-				return;
-			}
-
-			if (match[1].length <= state.precision) {
-				return;
-			}
-
-			const nodeIndex = getIndex(node);
-
-			report({
-				result,
-				ruleName,
-				node,
-				index: nodeIndex + startIndex,
-				endIndex: nodeIndex + (endIndex + 1) - unitStringLength,
-				message: messages.expected,
-				messageArgs: [parsedValue.value, parsedValue.value.toFixed(state.precision)],
-			});
-		}
-
-		/**
-		 * @param {string} functionName
-		 * @param {number} currentPrecision
-		 * @returns {number}
-		 */
-		function precisionInsideFunction(functionName, currentPrecision) {
-			const precisionForFunction = insideFunctions.get(functionName);
-			const hasPrecision = typeof precisionForFunction !== 'undefined';
-
-			if (hasPrecision) return precisionForFunction;
-
-			for (const [name, precision] of insideFunctions) {
-				if (matchesStringOrRegExp(functionName, name)) {
-					return precision;
-				}
-			}
-
-			return currentPrecision;
-		}
-	};
-};
-
-rule.ruleName = ruleName;
-rule.messages = messages;
-rule.meta = meta;
-export default rule;

package/packages/config-stylelint/node_modules/stylelint/lib/rules/property-allowed-list/index.mjs

@@ -1,58 +0,0 @@
-import { isRegExp, isString } from '../../utils/validateTypes.mjs';
-import isStandardSyntaxProperty from '../../utils/isStandardSyntaxProperty.mjs';
-import matchesStringOrRegExp from '../../utils/matchesStringOrRegExp.mjs';
-import report from '../../utils/report.mjs';
-import ruleMessages from '../../utils/ruleMessages.mjs';
-import validateOptions from '../../utils/validateOptions.mjs';
-
-const ruleName = 'property-allowed-list';
-
-const messages = ruleMessages(ruleName, {
-	rejected: (property) => `Unexpected property "${property}"`,
-});
-
-const meta = {
-	url: 'https://stylelint.io/user-guide/rules/property-allowed-list',
-};
-
-/** @type {import('stylelint').CoreRules[ruleName]} */
-const rule = (primary) => {
-	return (root, result) => {
-		const validOptions = validateOptions(result, ruleName, {
-			actual: primary,
-			possible: [isString, isRegExp],
-		});
-
-		if (!validOptions) {
-			return;
-		}
-
-		root.walkDecls((decl) => {
-			const prop = decl.prop;
-
-			if (!isStandardSyntaxProperty(prop)) {
-				return;
-			}
-
-			if (matchesStringOrRegExp(prop, primary)) {
-				return;
-			}
-
-			report({
-				message: messages.rejected,
-				messageArgs: [prop],
-				word: prop,
-				node: decl,
-				result,
-				ruleName,
-			});
-		});
-	};
-};
-
-rule.primaryOptionArray = true;
-
-rule.ruleName = ruleName;
-rule.messages = messages;
-rule.meta = meta;
-export default rule;

package/packages/config-stylelint/node_modules/stylelint/lib/rules/property-disallowed-list/index.mjs

@@ -1,58 +0,0 @@
-import { isRegExp, isString } from '../../utils/validateTypes.mjs';
-import isStandardSyntaxProperty from '../../utils/isStandardSyntaxProperty.mjs';
-import matchesStringOrRegExp from '../../utils/matchesStringOrRegExp.mjs';
-import report from '../../utils/report.mjs';
-import ruleMessages from '../../utils/ruleMessages.mjs';
-import validateOptions from '../../utils/validateOptions.mjs';
-
-const ruleName = 'property-disallowed-list';
-
-const messages = ruleMessages(ruleName, {
-	rejected: (property) => `Unexpected property "${property}"`,
-});
-
-const meta = {
-	url: 'https://stylelint.io/user-guide/rules/property-disallowed-list',
-};
-
-/** @type {import('stylelint').CoreRules[ruleName]} */
-const rule = (primary) => {
-	return (root, result) => {
-		const validOptions = validateOptions(result, ruleName, {
-			actual: primary,
-			possible: [isString, isRegExp],
-		});
-
-		if (!validOptions) {
-			return;
-		}
-
-		root.walkDecls((decl) => {
-			const prop = decl.prop;
-
-			if (!isStandardSyntaxProperty(prop)) {
-				return;
-			}
-
-			if (!matchesStringOrRegExp(prop, primary)) {
-				return;
-			}
-
-			report({
-				message: messages.rejected,
-				messageArgs: [prop],
-				word: prop,
-				node: decl,
-				result,
-				ruleName,
-			});
-		});
-	};
-};
-
-rule.primaryOptionArray = true;
-
-rule.ruleName = ruleName;
-rule.messages = messages;
-rule.meta = meta;
-export default rule;

package/packages/config-stylelint/node_modules/stylelint/lib/rules/property-no-deprecated/index.mjs

@@ -1,143 +0,0 @@
-import { isRegExp, isString } from '../../utils/validateTypes.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 = 'property-no-deprecated';
-
-const messages = ruleMessages(ruleName, {
-	expected: (unfixed, fixed) => `Expected "${unfixed}" to be "${fixed}"`,
-	rejected: (property) => `Unexpected deprecated property "${property}"`,
-});
-
-const meta = {
-	url: 'https://stylelint.io/user-guide/rules/property-no-deprecated',
-	fixable: true,
-};
-
-/** @type {Record<string, string | null>} */
-const DEPRECATED_PROPS_REMAP = {
-	'-khtml-box-align': 'align-items',
-	'-khtml-box-direction': null,
-	'-khtml-box-flex': 'flex-grow',
-	'-khtml-box-lines': null,
-	'-khtml-box-ordinal-group': 'order',
-	'-khtml-box-orient': null,
-	'-khtml-box-pack': null,
-	'-khtml-user-modify': null,
-	'-moz-box-align': 'align-items',
-	'-moz-box-direction': null,
-	'-moz-box-flex': 'flex-grow',
-	'-moz-box-lines': null,
-	'-moz-box-ordinal-group': 'order',
-	'-moz-box-orient': null,
-	'-moz-box-pack': null,
-	'-moz-user-modify': null,
-	'-ms-box-align': 'align-items',
-	'-ms-box-direction': null,
-	'-ms-box-flex': 'flex-grow',
-	'-ms-box-lines': null,
-	'-ms-box-ordinal-group': 'order',
-	'-ms-box-orient': null,
-	'-ms-box-pack': null,
-	'-webkit-box-align': 'align-items',
-	'-webkit-box-direction': null,
-	'-webkit-box-flex': 'flex-grow',
-	'-webkit-box-lines': null,
-	'-webkit-box-ordinal-group': 'order',
-	'-webkit-box-orient': null, // Allowed when the value is `vertical`
-	'-webkit-box-pack': null,
-	'-webkit-user-modify': null,
-	'grid-column-gap': 'column-gap',
-	'grid-gap': 'gap',
-	'grid-row-gap': 'row-gap',
-	'ime-mode': null,
-	'page-break-after': 'break-after',
-	'page-break-before': 'break-before',
-	'page-break-inside': 'break-inside',
-	'position-try-options': 'position-try-fallbacks',
-	'scroll-snap-coordinate': null,
-	'scroll-snap-destination': null,
-	'scroll-snap-margin-bottom': 'scroll-margin-bottom',
-	'scroll-snap-margin-left': 'scroll-margin-left',
-	'scroll-snap-margin-right': 'scroll-margin-right',
-	'scroll-snap-margin-top': 'scroll-margin-top',
-	'scroll-snap-margin': 'scroll-margin',
-	'scroll-snap-points-x': null,
-	'scroll-snap-points-y': null,
-	'scroll-snap-type-x': null,
-	'scroll-snap-type-y': null,
-	'word-wrap': 'overflow-wrap',
-	clip: null,
-};
-
-/** @type {import('stylelint').CoreRules[ruleName]} */
-const rule = (primary, secondaryOptions) => {
-	return (root, result) => {
-		const validOptions = validateOptions(
-			result,
-			ruleName,
-			{ actual: primary },
-			{
-				actual: secondaryOptions,
-				possible: {
-					ignoreProperties: [isString, isRegExp],
-				},
-				optional: true,
-			},
-		);
-
-		if (!validOptions) return;
-
-		root.walkDecls((decl) => {
-			if (!isStandardSyntaxDeclaration(decl)) return;
-
-			const { prop, value } = decl;
-
-			if (optionsMatches(secondaryOptions, 'ignoreProperties', prop)) return;
-
-			const normalizedProp = prop.toLowerCase();
-			const mappedProp = DEPRECATED_PROPS_REMAP[normalizedProp];
-
-			if (typeof mappedProp === 'undefined') return;
-
-			if (normalizedProp === '-webkit-box-orient' && value.toLowerCase() === 'vertical') return;
-
-			let fix;
-			let message;
-			let messageArgs = [];
-
-			if (mappedProp) {
-				message = messages.expected;
-				messageArgs = [prop, mappedProp];
-				fix = () => {
-					decl.prop = mappedProp;
-				};
-			} else {
-				message = messages.rejected;
-				messageArgs = [prop];
-			}
-
-			report({
-				message,
-				messageArgs,
-				node: decl,
-				index: 0,
-				endIndex: prop.length,
-				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/property-no-unknown/index.mjs

@@ -1,129 +0,0 @@
-import { all as knownProperties } from 'known-css-properties';
-
-import { isAtRule, isRule } from '../../utils/typeGuards.mjs';
-import { isBoolean, isRegExp, isString } from '../../utils/validateTypes.mjs';
-import findNodeUpToRoot from '../../utils/findNodeUpToRoot.mjs';
-import isCustomProperty from '../../utils/isCustomProperty.mjs';
-import isDescriptorDeclaration from '../../utils/isDescriptorDeclaration.mjs';
-import isStandardSyntaxDeclaration from '../../utils/isStandardSyntaxDeclaration.mjs';
-import isStandardSyntaxProperty from '../../utils/isStandardSyntaxProperty.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 = 'property-no-unknown';
-
-const messages = ruleMessages(ruleName, {
-	rejected: (property) => `Unexpected unknown property "${property}"`,
-});
-
-const meta = {
-	url: 'https://stylelint.io/user-guide/rules/property-no-unknown',
-};
-
-/** @type {import('stylelint').CoreRules[ruleName]} */
-const rule = (primary, secondaryOptions) => {
-	const allValidProperties = new Set(knownProperties);
-
-	return (root, result) => {
-		const validOptions = validateOptions(
-			result,
-			ruleName,
-			{ actual: primary },
-			{
-				actual: secondaryOptions,
-				possible: {
-					ignoreProperties: [isString, isRegExp],
-					checkPrefixed: [isBoolean],
-					ignoreSelectors: [isString, isRegExp],
-					ignoreAtRules: [isString, isRegExp],
-				},
-				optional: true,
-			},
-		);
-
-		if (!validOptions) {
-			return;
-		}
-
-		const shouldCheckPrefixed = secondaryOptions && secondaryOptions.checkPrefixed;
-
-		const languageProperties = result.stylelint.config?.languageOptions?.syntax?.properties || {};
-		const configuredPropertyNames = new Set(Object.keys(languageProperties));
-
-		root.walkDecls(checkStatement);
-
-		/**
-		 * @param {import('postcss').Declaration} decl
-		 */
-		function checkStatement(decl) {
-			const prop = decl.prop;
-
-			if (!isStandardSyntaxDeclaration(decl)) {
-				return;
-			}
-
-			if (isDescriptorDeclaration(decl)) {
-				return;
-			}
-
-			if (!isStandardSyntaxProperty(prop)) {
-				return;
-			}
-
-			if (isCustomProperty(prop)) {
-				return;
-			}
-
-			if (!shouldCheckPrefixed && vendor.prefix(prop)) {
-				return;
-			}
-
-			if (configuredPropertyNames.has(prop)) {
-				return;
-			}
-
-			if (optionsMatches(secondaryOptions, 'ignoreProperties', prop)) {
-				return;
-			}
-
-			const parent = decl.parent;
-
-			if (
-				parent &&
-				isRule(parent) &&
-				optionsMatches(secondaryOptions, 'ignoreSelectors', parent.selector)
-			) {
-				return;
-			}
-
-			/** @type {(node: import('postcss').Node) => boolean} */
-			const isIgnoredAtRule = (node) =>
-				isAtRule(node) && optionsMatches(secondaryOptions, 'ignoreAtRules', node.name);
-
-			if (findNodeUpToRoot(decl, isIgnoredAtRule)) {
-				return;
-			}
-
-			if (allValidProperties.has(prop.toLowerCase())) {
-				return;
-			}
-
-			report({
-				message: messages.rejected,
-				messageArgs: [prop],
-				node: decl,
-				result,
-				ruleName,
-				word: prop,
-			});
-		}
-	};
-};
-
-rule.ruleName = ruleName;
-rule.messages = messages;
-rule.meta = meta;
-export default rule;

package/packages/config-stylelint/node_modules/stylelint/lib/rules/property-no-vendor-prefix/index.mjs

@@ -1,100 +0,0 @@
-import { isRegExp, isString } from '../../utils/validateTypes.mjs';
-import { basicKeywords } from '../../reference/keywords.mjs';
-import isAutoprefixable from '../../utils/isAutoprefixable.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 = 'property-no-vendor-prefix';
-
-const messages = ruleMessages(ruleName, {
-	rejected: (property) => `Unexpected vendor-prefixed property "${property}"`,
-});
-
-const meta = {
-	url: 'https://stylelint.io/user-guide/rules/property-no-vendor-prefix',
-	fixable: true,
-};
-
-/** @type {import('stylelint').CoreRules[ruleName]} */
-const rule = (primary, secondaryOptions) => {
-	return (root, result) => {
-		const validOptions = validateOptions(
-			result,
-			ruleName,
-			{ actual: primary },
-			{
-				optional: true,
-				actual: secondaryOptions,
-				possible: {
-					ignoreProperties: [isString, isRegExp],
-				},
-			},
-		);
-
-		if (!validOptions) {
-			return;
-		}
-
-		root.walkDecls((decl) => {
-			const prop = decl.prop;
-
-			if (optionsMatches(secondaryOptions, 'ignoreProperties', prop)) return;
-
-			// Make sure there's a vendor prefix,
-			// but this isn't a custom property
-
-			if (prop[0] !== '-' || prop[1] === '-') {
-				return;
-			}
-
-			if (!isAutoprefixable.property(prop)) {
-				return;
-			}
-
-			// see whatwg/compat#28
-			if (prop === '-webkit-background-size') {
-				const backgrounds = decl.value.split(',');
-				const isSafe = backgrounds.every((background) => {
-					const values = background.trim().split(/\s+/);
-					const length = values.length;
-					const [first] = values;
-
-					switch (length) {
-						case 2:
-							return true;
-						case 1:
-							return first && (first === 'auto' || basicKeywords.has(first));
-						default:
-							return false;
-					}
-				});
-
-				if (!isSafe) return;
-			}
-
-			const fix = () => {
-				decl.prop = isAutoprefixable.unprefix(decl.prop);
-			};
-
-			report({
-				message: messages.rejected,
-				messageArgs: [prop],
-				word: prop,
-				node: decl,
-				result,
-				ruleName,
-				fix: {
-					apply: fix,
-					node: decl,
-				},
-			});
-		});
-	};
-};
-
-rule.ruleName = ruleName;
-rule.messages = messages;
-rule.meta = meta;
-export default rule;