@alexlit/lint-kit 182.2.0 → 182.3.0

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

@@ -1,63 +0,0 @@
-import { isRegExp, isString } from '../../utils/validateTypes.mjs';
-import containsString from '../../utils/containsString.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 = 'comment-word-disallowed-list';
-
-const messages = ruleMessages(ruleName, {
-	rejected: (pattern) => `Unexpected word matching pattern "${pattern}"`,
-});
-
-const meta = {
-	url: 'https://stylelint.io/user-guide/rules/comment-word-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.walkComments((comment) => {
-			const text = comment.text;
-			const rawComment = comment.toString();
-			const firstFourChars = rawComment.slice(0, 4);
-
-			// Return early if sourcemap
-			if (firstFourChars === '/*# ') {
-				return;
-			}
-
-			const matchesWord = matchesStringOrRegExp(text, primary) || containsString(text, primary);
-
-			if (!matchesWord) {
-				return;
-			}
-
-			report({
-				message: messages.rejected,
-				messageArgs: [matchesWord.pattern],
-				node: comment,
-				word: matchesWord.substring,
-				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/container-name-pattern/index.mjs

@@ -1,107 +0,0 @@
-import valueParser from 'postcss-value-parser';
-
-import { atRuleParamIndex, declarationValueIndex } from '../../utils/nodeFieldIndices.mjs';
-import { atRuleRegexes, propertyRegexes } from '../../utils/regexes.mjs';
-import { isRegExp, isString } from '../../utils/validateTypes.mjs';
-import { basicKeywords } from '../../reference/keywords.mjs';
-import isStandardSyntaxAtRule from '../../utils/isStandardSyntaxAtRule.mjs';
-import isStandardSyntaxDeclaration from '../../utils/isStandardSyntaxDeclaration.mjs';
-import isStandardSyntaxValue from '../../utils/isStandardSyntaxValue.mjs';
-import report from '../../utils/report.mjs';
-import ruleMessages from '../../utils/ruleMessages.mjs';
-import validateOptions from '../../utils/validateOptions.mjs';
-
-const ruleName = 'container-name-pattern';
-
-const messages = ruleMessages(ruleName, {
-	expected: (containerName, pattern) => `Expected "${containerName}" to match pattern "${pattern}"`,
-});
-
-const meta = {
-	url: 'https://stylelint.io/user-guide/rules/container-name-pattern',
-};
-
-const KEYWORDS = new Set(['and', 'or', 'none', 'not']);
-
-/** @type {import('stylelint').CoreRules[ruleName]} */
-const rule = (primary) => {
-	return (root, result) => {
-		const validOptions = validateOptions(result, ruleName, {
-			actual: primary,
-			possible: [isRegExp, isString],
-		});
-
-		if (!validOptions) return;
-
-		const regex = isString(primary) ? new RegExp(primary) : primary;
-
-		const languageCssWideKeywords =
-			result.stylelint.config?.languageOptions?.syntax?.cssWideKeywords ?? [];
-
-		const cssWideKeywords = new Set([...basicKeywords, ...languageCssWideKeywords]);
-
-		root.walkDecls(propertyRegexes.containerNameAndShorthandName, (decl) => {
-			if (!isStandardSyntaxDeclaration(decl)) return;
-
-			const parsedValue = valueParser(decl.value);
-
-			let isContainerType = false;
-
-			parsedValue.walk(({ sourceIndex, type, value }) => {
-				if (isContainerType) return;
-
-				if (type === 'div' && value === '/') isContainerType = true;
-
-				if (type !== 'word') return false;
-
-				if (cssWideKeywords.has(value.toLowerCase())) return;
-
-				if (!isStandardSyntaxValue(value)) return;
-
-				if (regex.test(value)) return;
-
-				complain(declarationValueIndex(decl) + sourceIndex, value, decl);
-			});
-		});
-
-		root.walkAtRules(atRuleRegexes.containerName, (atRule) => {
-			if (!isStandardSyntaxAtRule(atRule)) return;
-
-			const { params } = atRule;
-
-			const parsedValue = valueParser(params);
-
-			parsedValue.walk(({ sourceIndex, type, value }) => {
-				if (type !== 'word') return false;
-
-				if (KEYWORDS.has(value.toLowerCase())) return;
-
-				if (regex.test(value)) return;
-
-				complain(atRuleParamIndex(atRule) + sourceIndex, value, atRule);
-			});
-		});
-
-		/**
-		 * @param {number} index
-		 * @param {string} containerName
-		 * @param {import('postcss').Declaration|import('postcss').AtRule} node
-		 */
-		function complain(index, containerName, node) {
-			report({
-				result,
-				ruleName,
-				message: messages.expected,
-				messageArgs: [containerName, primary],
-				node,
-				index,
-				endIndex: index + containerName.length,
-			});
-		}
-	};
-};
-
-rule.ruleName = ruleName;
-rule.messages = messages;
-rule.meta = meta;
-export default rule;

package/packages/config-stylelint/node_modules/stylelint/lib/rules/custom-media-pattern/index.mjs

@@ -1,61 +0,0 @@
-import { isRegExp, isString } from '../../utils/validateTypes.mjs';
-import { atRuleParamIndex } from '../../utils/nodeFieldIndices.mjs';
-import { atRuleRegexes } from '../../utils/regexes.mjs';
-import report from '../../utils/report.mjs';
-import ruleMessages from '../../utils/ruleMessages.mjs';
-import validateOptions from '../../utils/validateOptions.mjs';
-
-const ruleName = 'custom-media-pattern';
-
-const messages = ruleMessages(ruleName, {
-	expected: (mediaName, pattern) => `Expected "${mediaName}" to match pattern "${pattern}"`,
-});
-
-const meta = {
-	url: 'https://stylelint.io/user-guide/rules/custom-media-pattern',
-};
-
-/** @type {import('stylelint').CoreRules[ruleName]} */
-const rule = (primary) => {
-	return (root, result) => {
-		const validOptions = validateOptions(result, ruleName, {
-			actual: primary,
-			possible: [isRegExp, isString],
-		});
-
-		if (!validOptions) {
-			return;
-		}
-
-		const regexpPattern = isString(primary) ? new RegExp(primary) : primary;
-
-		root.walkAtRules(atRuleRegexes.customMediaName, (atRule) => {
-			const [fullName, customMediaName] = atRule.params.match(/^--(\S+)\b/) || [];
-
-			if (fullName === undefined || customMediaName === undefined) {
-				throw new Error(`Unexpected at-rule params: "${atRule.params}"`);
-			}
-
-			if (regexpPattern.test(customMediaName)) {
-				return;
-			}
-
-			const index = atRuleParamIndex(atRule);
-
-			report({
-				message: messages.expected,
-				messageArgs: [fullName, primary],
-				node: atRule,
-				index,
-				endIndex: index + fullName.length,
-				result,
-				ruleName,
-			});
-		});
-	};
-};
-
-rule.ruleName = ruleName;
-rule.messages = messages;
-rule.meta = meta;
-export default rule;

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

@@ -1,156 +0,0 @@
-import { isAtRule, isDeclaration, isRule } from '../../utils/typeGuards.mjs';
-import blockString from '../../utils/blockString.mjs';
-import fixEmptyLinesBefore from '../../utils/fixEmptyLinesBefore.mjs';
-import getPreviousNonSharedLineCommentNode from '../../utils/getPreviousNonSharedLineCommentNode.mjs';
-import hasEmptyLine from '../../utils/hasEmptyLine.mjs';
-import isAfterBlock from '../../utils/isAfterBlock.mjs';
-import isAfterComment from '../../utils/isAfterComment.mjs';
-import isCustomProperty from '../../utils/isCustomProperty.mjs';
-import isFirstNested from '../../utils/isFirstNested.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 = 'custom-property-empty-line-before';
-
-const messages = ruleMessages(ruleName, {
-	expected: 'Expected empty line before custom property',
-	rejected: 'Unexpected empty line before custom property',
-});
-
-const meta = {
-	url: 'https://stylelint.io/user-guide/rules/custom-property-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: ['after-block', 'after-comment', 'after-custom-property', 'first-nested'],
-					ignore: [
-						'after-comment',
-						'after-custom-property',
-						'first-nested',
-						'inside-single-line-block',
-					],
-				},
-				optional: true,
-			},
-		);
-
-		if (!validOptions) {
-			return;
-		}
-
-		root.walkDecls((decl) => {
-			const prop = decl.prop;
-			const parent = decl.parent;
-
-			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 custom property precedes it
-			if (
-				optionsMatches(secondaryOptions, 'ignore', 'after-custom-property') &&
-				isAfterCustomProperty(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') &&
-				parent != null &&
-				(isAtRule(parent) || isRule(parent)) &&
-				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-custom-property') &&
-					isAfterCustomProperty(decl))
-			) {
-				expectEmptyLineBefore = !expectEmptyLineBefore;
-			}
-
-			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,
-				},
-			});
-		});
-	};
-};
-
-/**
- * @param {import('postcss').Declaration} decl
- */
-function isAfterCustomProperty(decl) {
-	const prevNode = getPreviousNonSharedLineCommentNode(decl);
-
-	return prevNode != null && isDeclaration(prevNode) && isCustomProperty(prevNode.prop);
-}
-
-rule.ruleName = ruleName;
-rule.messages = messages;
-rule.meta = meta;
-export default rule;

package/packages/config-stylelint/node_modules/stylelint/lib/rules/custom-property-no-missing-var-function/index.mjs

@@ -1,148 +0,0 @@
-import valueParser from 'postcss-value-parser';
-
-import { atRuleRegexes, mayIncludeRegexes, propertyRegexes } from '../../utils/regexes.mjs';
-import { declarationValueIndex } from '../../utils/nodeFieldIndices.mjs';
-import isVarFunction from '../../utils/isVarFunction.mjs';
-import report from '../../utils/report.mjs';
-import ruleMessages from '../../utils/ruleMessages.mjs';
-import validateOptions from '../../utils/validateOptions.mjs';
-
-const ruleName = 'custom-property-no-missing-var-function';
-
-const messages = ruleMessages(ruleName, {
-	rejected: (customProperty) => `Unexpected missing var function for "${customProperty}"`,
-});
-
-const meta = {
-	url: 'https://stylelint.io/user-guide/rules/custom-property-no-missing-var-function',
-};
-
-/** @typedef {import('postcss-value-parser').Node} Node */
-
-// Properties that can receive a custom-ident
-const IGNORED_PROPERTIES = new Set([
-	'animation',
-	'animation-name',
-	'container-name',
-	'counter-increment',
-	'counter-reset',
-	'counter-set',
-	'grid-column',
-	'grid-column-end',
-	'grid-column-start',
-	'grid-row',
-	'grid-row-end',
-	'grid-row-start',
-	'list-style',
-	'list-style-type',
-	'transition',
-	'transition-property',
-	'view-transition-name',
-	'will-change',
-]);
-
-/** @type {import('stylelint').CoreRules[ruleName]} */
-const rule = (primary) => {
-	return (root, result) => {
-		const validOptions = validateOptions(result, ruleName, { actual: primary });
-
-		if (!validOptions) return;
-
-		/** @type {Set<string>} */
-		const knownCustomProperties = new Set();
-
-		root.walkAtRules(atRuleRegexes.propertyName, ({ params }) => {
-			knownCustomProperties.add(params);
-		});
-
-		root.walkDecls(propertyRegexes.custom, ({ prop }) => {
-			knownCustomProperties.add(prop);
-		});
-
-		root.walkDecls((decl) => {
-			const { prop, value } = decl;
-
-			if (!mayIncludeRegexes.customProperty.test(value)) return;
-
-			if (IGNORED_PROPERTIES.has(prop.toLowerCase())) return;
-
-			valueParser(value).nodes.forEach((childNode) => {
-				check(childNode, decl);
-			});
-		});
-
-		/**
-		 * @param {Node} node
-		 * @param {import('postcss').Declaration} decl
-		 */
-		function check(node, decl) {
-			if (node.type === 'function') {
-				const name = node.value.toLowerCase();
-
-				let args = node.nodes;
-
-				if (name === 'var') args = node.nodes.slice(1);
-				else if (name === 'running') {
-					const [child] = node.nodes;
-					const mustDrill = child && isVarFunction(child);
-
-					if (mustDrill) args = child.nodes.slice(1);
-					else return;
-				} else if (name === 'style') {
-					// For style() queries, only exempt the property name (first word before colon)
-					// but still check the value part after the colon
-					let foundColon = false;
-
-					node.nodes.forEach((arg) => {
-						if (arg.type === 'div' && arg.value === ':') {
-							foundColon = true;
-						} else if (!foundColon && isDashedIdent(arg)) {
-							// This is the property name in the query - skip it
-						} else if (foundColon) {
-							// This is after the colon (the value) - check it normally
-							check(arg, decl);
-						}
-					});
-
-					return;
-				}
-
-				args.forEach((arg) => check(arg, decl));
-
-				return;
-			}
-
-			if (!isDashedIdent(node)) return;
-
-			// `postcss-value-parser` incorrectly includes semicolons in word tokens.
-			const cleanValue = node.value.replace(/;+$/, '');
-
-			if (!knownCustomProperties.has(cleanValue)) return;
-
-			const index = declarationValueIndex(decl) + node.sourceIndex;
-			const endIndex = index + cleanValue.length;
-
-			report({
-				message: messages.rejected,
-				messageArgs: [cleanValue],
-				node: decl,
-				index,
-				endIndex,
-				result,
-				ruleName,
-			});
-		}
-	};
-};
-
-/**
- * @param {Node} node
- */
-function isDashedIdent({ type, value }) {
-	return type === 'word' && value.startsWith('--');
-}
-
-rule.ruleName = ruleName;
-rule.messages = messages;
-rule.meta = meta;
-export default rule;

package/packages/config-stylelint/node_modules/stylelint/lib/rules/custom-property-pattern/index.mjs

@@ -1,100 +0,0 @@
-import valueParser from 'postcss-value-parser';
-
-import { atRuleParamIndex, declarationValueIndex } from '../../utils/nodeFieldIndices.mjs';
-import { atRuleRegexes, mayIncludeRegexes } from '../../utils/regexes.mjs';
-import { isRegExp, isString } from '../../utils/validateTypes.mjs';
-import isCustomProperty from '../../utils/isCustomProperty.mjs';
-import isStandardSyntaxProperty from '../../utils/isStandardSyntaxProperty.mjs';
-import isVarFunction from '../../utils/isVarFunction.mjs';
-import report from '../../utils/report.mjs';
-import ruleMessages from '../../utils/ruleMessages.mjs';
-import validateOptions from '../../utils/validateOptions.mjs';
-
-const ruleName = 'custom-property-pattern';
-
-const messages = ruleMessages(ruleName, {
-	expected: (property, pattern) => `Expected "${property}" to match pattern "${pattern}"`,
-});
-
-const meta = {
-	url: 'https://stylelint.io/user-guide/rules/custom-property-pattern',
-};
-
-/** @type {import('stylelint').CoreRules[ruleName]} */
-const rule = (primary) => {
-	return (root, result) => {
-		const validOptions = validateOptions(result, ruleName, {
-			actual: primary,
-			possible: [isRegExp, isString],
-		});
-
-		if (!validOptions) return;
-
-		const regexpPattern = isString(primary) ? new RegExp(primary) : primary;
-
-		/**
-		 * @param {string} property
-		 * @returns {boolean}
-		 */
-		function check(property) {
-			return (
-				!isCustomProperty(property) ||
-				!isStandardSyntaxProperty(property) ||
-				regexpPattern.test(property.slice(2))
-			);
-		}
-
-		root.walkDecls((decl) => {
-			const { prop, value } = decl;
-
-			if (mayIncludeRegexes.varFunction.test(value)) {
-				const parsedValue = valueParser(value);
-
-				parsedValue.walk((node) => {
-					if (!isVarFunction(node)) return;
-
-					const { nodes } = node;
-					const firstNode = nodes[0];
-
-					if (!firstNode || check(firstNode.value)) return;
-
-					complain(declarationValueIndex(decl) + firstNode.sourceIndex, firstNode.value, decl);
-				});
-			}
-
-			if (check(prop)) return;
-
-			complain(0, prop, decl);
-		});
-
-		root.walkAtRules(atRuleRegexes.propertyName, (atRule) => {
-			const { params: propName } = atRule;
-
-			if (check(propName)) return;
-
-			complain(atRuleParamIndex(atRule), propName, atRule);
-		});
-
-		/**
-		 * @param {number} index
-		 * @param {string} propName
-		 * @param {import('postcss').Declaration|import('postcss').AtRule} node
-		 */
-		function complain(index, propName, node) {
-			report({
-				result,
-				ruleName,
-				message: messages.expected,
-				messageArgs: [propName, primary],
-				node,
-				index,
-				endIndex: index + propName.length,
-			});
-		}
-	};
-};
-
-rule.ruleName = ruleName;
-rule.messages = messages;
-rule.meta = meta;
-export default rule;