@alexlit/lint-kit 183.6.0 → 183.7.0

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

@@ -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;

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

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