@alexlit/lint-kit 183.4.0 → 183.6.0

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

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

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

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

@@ -0,0 +1,126 @@
+import { isAtRule, isRule } from '../../utils/typeGuards.mjs';
+import { isBoolean, isRegExp, isString } from '../../utils/validateTypes.mjs';
+import {
+	previouslyKnownPrefixedProperties,
+	previouslyKnownProperties,
+} from '../../reference/properties.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) => {
+	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 lexer = /** @type {import('css-tree').Lexer} */ (result.stylelint.lexer);
+
+		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 (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 (lexer.getProperty(prop)) return;
+
+			if (previouslyKnownProperties.has(prop.toLowerCase())) return;
+
+			if (shouldCheckPrefixed && previouslyKnownPrefixedProperties.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

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

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

@@ -0,0 +1,156 @@
+import fixEmptyLinesBefore from '../../utils/fixEmptyLinesBefore.mjs';
+import getPreviousNonSharedLineCommentNode from '../../utils/getPreviousNonSharedLineCommentNode.mjs';
+import hasEmptyLine from '../../utils/hasEmptyLine.mjs';
+import isAfterSingleLineComment from '../../utils/isAfterSingleLineComment.mjs';
+import isFirstNested from '../../utils/isFirstNested.mjs';
+import isFirstNodeOfRoot from '../../utils/isFirstNodeOfRoot.mjs';
+import isSingleLineString from '../../utils/isSingleLineString.mjs';
+import isStandardSyntaxRule from '../../utils/isStandardSyntaxRule.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 = 'rule-empty-line-before';
+
+const messages = ruleMessages(ruleName, {
+	expected: 'Expected empty line before rule',
+	rejected: 'Unexpected empty line before rule',
+});
+
+const meta = {
+	url: 'https://stylelint.io/user-guide/rules/rule-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', 'always-multi-line', 'never-multi-line'],
+			},
+			{
+				actual: secondaryOptions,
+				possible: {
+					ignore: ['after-comment', 'first-nested', 'inside-block'],
+					except: [
+						'after-rule',
+						'after-single-line-comment',
+						'first-nested',
+						'inside-block-and-after-rule',
+						'inside-block',
+					],
+				},
+				optional: true,
+			},
+		);
+
+		if (!validOptions) {
+			return;
+		}
+
+		const expectation = /** @type {string} */ (primary);
+
+		root.walkRules((ruleNode) => {
+			if (!isStandardSyntaxRule(ruleNode)) {
+				return;
+			}
+
+			// Ignore the first node
+			if (isFirstNodeOfRoot(ruleNode)) {
+				return;
+			}
+
+			// Optionally ignore the expectation if a comment precedes this node
+			if (optionsMatches(secondaryOptions, 'ignore', 'after-comment')) {
+				const prevNode = ruleNode.prev();
+
+				if (prevNode && prevNode.type === 'comment') {
+					return;
+				}
+			}
+
+			// Optionally ignore the node if it is the first nested
+			if (optionsMatches(secondaryOptions, 'ignore', 'first-nested') && isFirstNested(ruleNode)) {
+				return;
+			}
+
+			const isNested = ruleNode.parent && ruleNode.parent.type !== 'root';
+
+			// Optionally ignore the expectation if inside a block
+			if (optionsMatches(secondaryOptions, 'ignore', 'inside-block') && isNested) {
+				return;
+			}
+
+			// Ignore if the expectation is for multiple and the rule is single-line
+			if (expectation.includes('multi-line') && isSingleLineString(ruleNode.toString())) {
+				return;
+			}
+
+			let expectEmptyLineBefore = expectation.includes('always');
+
+			// Optionally reverse the expectation if any exceptions apply
+			if (
+				(optionsMatches(secondaryOptions, 'except', 'first-nested') && isFirstNested(ruleNode)) ||
+				(optionsMatches(secondaryOptions, 'except', 'after-rule') && isAfterRule(ruleNode)) ||
+				(optionsMatches(secondaryOptions, 'except', 'inside-block-and-after-rule') &&
+					isNested &&
+					isAfterRule(ruleNode)) ||
+				(optionsMatches(secondaryOptions, 'except', 'after-single-line-comment') &&
+					isAfterSingleLineComment(ruleNode)) ||
+				(optionsMatches(secondaryOptions, 'except', 'inside-block') && isNested)
+			) {
+				expectEmptyLineBefore = !expectEmptyLineBefore;
+			}
+
+			const hasEmptyLineBefore = hasEmptyLine(ruleNode.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: ruleNode,
+					newline: context.newline,
+					action,
+				});
+
+			report({
+				message,
+				messageArgs: [],
+				node: ruleNode,
+				result,
+				ruleName,
+				fix: {
+					apply: fix,
+					node: ruleNode.parent,
+				},
+			});
+		});
+	};
+};
+
+/**
+ * @param {import('postcss').Rule} ruleNode
+ * @returns {boolean}
+ */
+function isAfterRule(ruleNode) {
+	const prevNode = getPreviousNonSharedLineCommentNode(ruleNode);
+
+	return prevNode != null && prevNode.type === 'rule';
+}
+
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;
+export default rule;