@alexlit/lint-kit 173.2.2 → 173.3.0

package/packages/config-stylelint/node_modules/stylelint/lib/rules/font-family-name-quotes/index.mjs

@@ -1,242 +0,0 @@
-import { fontFamilyKeywords, prefixedSystemFonts } from '../../reference/keywords.mjs';
-import findFontFamily from '../../utils/findFontFamily.mjs';
-import isStandardSyntaxValue from '../../utils/isStandardSyntaxValue.mjs';
-import isVariable from '../../utils/isVariable.mjs';
-import report from '../../utils/report.mjs';
-import ruleMessages from '../../utils/ruleMessages.mjs';
-import validateOptions from '../../utils/validateOptions.mjs';
-
-const ruleName = 'font-family-name-quotes';
-
-const messages = ruleMessages(ruleName, {
-	expected: (family) => `Expected quotes around "${family}"`,
-	rejected: (family) => `Unexpected quotes around "${family}"`,
-});
-
-const meta = {
-	url: 'https://stylelint.io/user-guide/rules/font-family-name-quotes',
-	fixable: true,
-};
-
-/**
- * @param {string} font
- * @returns {boolean}
- */
-function isSystemFontKeyword(font) {
-	if (prefixedSystemFonts.has(font)) {
-		return true;
-	}
-
-	if (font === 'BlinkMacSystemFont') {
-		return true;
-	}
-
-	return false;
-}
-
-/**
- * "To avoid mistakes in escaping, it is recommended to quote font family names
- * that contain white space, digits, or punctuation characters other than hyphens"
- * (https://www.w3.org/TR/CSS2/fonts.html#font-family-prop)
- *
- * @param {string} family
- * @returns {boolean}
- */
-function quotesRecommended(family) {
-	return !/^[-a-z]+$/i.test(family);
-}
-
-/**
- * Quotes are required if the family is not a valid CSS identifier
- * (regexes from https://mathiasbynens.be/notes/unquoted-font-family)
- *
- * @param {string} family
- * @returns {boolean}
- */
-function quotesRequired(family) {
-	return family
-		.split(/\s+/)
-		.some((word) => /^(?:-?\d|--)/.test(word) || !/^[-\w\u{00A0}-\u{10FFFF}]+$/u.test(word));
-}
-
-/**
- * @typedef {{
- *   name: string,
- *   rawName: string,
- *   hasQuotes: boolean,
- *   sourceIndex: number,
- *   resetIndexes: (offset: number) => void,
- *   removeQuotes: () => void,
- *   addQuotes: () => void,
- * }} MutableNode
- */
-
-/**
- * @param {import('postcss-value-parser').Node[]} fontFamilies
- * @param {import('postcss').Declaration} decl
- * @returns {MutableNode[]}
- */
-const makeMutableFontFamilies = (fontFamilies, decl) => {
-	/**
-	 * @type {MutableNode[]}
-	 */
-	const mutableNodes = [];
-
-	fontFamilies.forEach((fontFamily, idx) => {
-		const quote = 'quote' in fontFamily && fontFamily.quote;
-		const name = fontFamily.value;
-
-		/** @type {MutableNode} */
-		const newNode = {
-			name,
-			rawName: quote ? `${quote}${name}${quote}` : name,
-			sourceIndex: fontFamily.sourceIndex,
-			hasQuotes: Boolean(quote),
-			resetIndexes(offset) {
-				mutableNodes.slice(idx + 1).forEach((n) => (n.sourceIndex += offset));
-			},
-			removeQuotes() {
-				if (this.hasQuotes === false) return;
-
-				const openIndex = this.sourceIndex;
-				const closeIndex = openIndex + this.name.length + 2;
-
-				this.hasQuotes = false;
-				decl.value = decl.value.slice(0, openIndex) + this.name + decl.value.substring(closeIndex);
-				this.resetIndexes(-2);
-			},
-			addQuotes() {
-				if (this.hasQuotes === true) return;
-
-				const openIndex = this.sourceIndex;
-				const closeIndex = openIndex + this.name.length;
-
-				this.hasQuotes = true;
-				const fixedName = `"${this.name}"`;
-
-				decl.value = decl.value.slice(0, openIndex) + fixedName + decl.value.substring(closeIndex);
-				this.resetIndexes(2);
-			},
-		};
-
-		mutableNodes.push(newNode);
-	});
-
-	return mutableNodes;
-};
-
-/** @type {import('stylelint').CoreRules[ruleName]} */
-const rule = (primary) => {
-	return (root, result) => {
-		const validOptions = validateOptions(result, ruleName, {
-			actual: primary,
-			possible: ['always-where-required', 'always-where-recommended', 'always-unless-keyword'],
-		});
-
-		if (!validOptions) {
-			return;
-		}
-
-		root.walkDecls(/^font(-family)?$/i, (decl) => {
-			if (!isStandardSyntaxValue(decl.value)) {
-				return;
-			}
-
-			const fontFamilyNodes = makeMutableFontFamilies(findFontFamily(decl.value), decl);
-
-			if (fontFamilyNodes.length === 0) {
-				return;
-			}
-
-			for (const fontFamilyNode of fontFamilyNodes) {
-				checkFamilyName(fontFamilyNode, decl);
-			}
-		});
-
-		/**
-		 * @param {MutableNode} fontFamilyNode
-		 * @param {import('postcss').Declaration} decl
-		 */
-		function checkFamilyName(fontFamilyNode, decl) {
-			const { name: family, rawName: rawFamily, hasQuotes } = fontFamilyNode;
-
-			if (isVariable(rawFamily)) {
-				return;
-			}
-
-			// Disallow quotes around (case-insensitive) keywords
-			// and system font keywords in all cases
-			if (fontFamilyKeywords.has(family.toLowerCase()) || isSystemFontKeyword(family)) {
-				if (hasQuotes) {
-					return complain('rejected', fontFamilyNode, decl);
-				}
-
-				return;
-			}
-
-			const required = quotesRequired(family);
-			const recommended = quotesRecommended(family);
-
-			switch (primary) {
-				case 'always-unless-keyword':
-					if (!hasQuotes) {
-						return complain('expected', fontFamilyNode, decl);
-					}
-
-					return;
-
-				case 'always-where-recommended':
-					if (!recommended && hasQuotes) {
-						return complain('rejected', fontFamilyNode, decl);
-					}
-
-					if (recommended && !hasQuotes) {
-						return complain('expected', fontFamilyNode, decl);
-					}
-
-					return;
-
-				case 'always-where-required':
-					if (!required && hasQuotes) {
-						return complain('rejected', fontFamilyNode, decl);
-					}
-
-					if (required && !hasQuotes) {
-						return complain('expected', fontFamilyNode, decl);
-					}
-			}
-		}
-
-		/**
-		 * @param {keyof messages} messageType
-		 * @param {MutableNode} fontFamilyNode
-		 * @param {import('postcss').Declaration} decl
-		 */
-		function complain(messageType, fontFamilyNode, decl) {
-			const { name, rawName } = fontFamilyNode;
-			const fix = () => {
-				return messageType === 'expected'
-					? fontFamilyNode.addQuotes()
-					: fontFamilyNode.removeQuotes();
-			};
-
-			report({
-				result,
-				ruleName,
-				message: messages[messageType],
-				messageArgs: [name],
-				node: decl,
-				word: rawName,
-				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/font-family-no-duplicate-names/index.mjs

@@ -1,121 +0,0 @@
-import { isRegExp, isString } from '../../utils/validateTypes.mjs';
-import { declarationValueIndex } from '../../utils/nodeFieldIndices.mjs';
-import findFontFamily from '../../utils/findFontFamily.mjs';
-import { fontFamilyKeywords } from '../../reference/keywords.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 = 'font-family-no-duplicate-names';
-
-const messages = ruleMessages(ruleName, {
-	rejected: (name) => `Unexpected duplicate font-family name ${name}`,
-});
-
-const meta = {
-	url: 'https://stylelint.io/user-guide/rules/font-family-no-duplicate-names',
-};
-
-/**
- * @param {import('postcss-value-parser').Node} node
- */
-const isFamilyNameKeyword = (node) =>
-	!('quote' in node) && fontFamilyKeywords.has(node.value.toLowerCase());
-
-/** @type {import('stylelint').CoreRules[ruleName]} */
-const rule = (primary, secondaryOptions) => {
-	return (root, result) => {
-		const validOptions = validateOptions(
-			result,
-			ruleName,
-			{ actual: primary },
-			{
-				actual: secondaryOptions,
-				possible: {
-					ignoreFontFamilyNames: [isString, isRegExp],
-				},
-				optional: true,
-			},
-		);
-
-		if (!validOptions) {
-			return;
-		}
-
-		root.walkDecls(/^font(-family)?$/i, (decl) => {
-			const keywords = new Set();
-			const familyNames = new Set();
-
-			const fontFamilies = findFontFamily(decl.value);
-
-			if (fontFamilies.length === 0) {
-				return;
-			}
-
-			for (const fontFamilyNode of fontFamilies) {
-				const family = fontFamilyNode.value.trim();
-
-				if (optionsMatches(secondaryOptions, 'ignoreFontFamilyNames', family)) {
-					continue;
-				}
-
-				const rawFamily =
-					'quote' in fontFamilyNode ? fontFamilyNode.quote + family + fontFamilyNode.quote : family;
-
-				if (isFamilyNameKeyword(fontFamilyNode)) {
-					if (keywords.has(family.toLowerCase())) {
-						complain(
-							family,
-							declarationValueIndex(decl) + fontFamilyNode.sourceIndex,
-							rawFamily.length,
-							decl,
-						);
-
-						continue;
-					}
-
-					keywords.add(family);
-
-					continue;
-				}
-
-				if (familyNames.has(family)) {
-					complain(
-						family,
-						declarationValueIndex(decl) + fontFamilyNode.sourceIndex,
-						rawFamily.length,
-						decl,
-					);
-
-					continue;
-				}
-
-				familyNames.add(family);
-			}
-		});
-
-		/**
-		 * @param {string} name
-		 * @param {number} index
-		 * @param {number} length
-		 * @param {import('postcss').Declaration} decl
-		 */
-		function complain(name, index, length, decl) {
-			report({
-				result,
-				ruleName,
-				message: messages.rejected,
-				messageArgs: [name],
-				node: decl,
-				index,
-				endIndex: index + length,
-			});
-		}
-	};
-};
-
-rule.ruleName = ruleName;
-rule.messages = messages;
-rule.meta = meta;
-export default rule;

package/packages/config-stylelint/node_modules/stylelint/lib/rules/font-family-no-missing-generic-family-keyword/index.mjs

@@ -1,121 +0,0 @@
-import postcss from 'postcss';
-
-import { assert, isRegExp, isString } from '../../utils/validateTypes.mjs';
-import { fontFamilyKeywords, systemFontKeywords } from '../../reference/keywords.mjs';
-import { declarationValueIndex } from '../../utils/nodeFieldIndices.mjs';
-import findFontFamily from '../../utils/findFontFamily.mjs';
-import { isAtRule } from '../../utils/typeGuards.mjs';
-import isStandardSyntaxValue from '../../utils/isStandardSyntaxValue.mjs';
-import isVariable from '../../utils/isVariable.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 = 'font-family-no-missing-generic-family-keyword';
-
-const messages = ruleMessages(ruleName, {
-	rejected: 'Unexpected missing generic font family',
-});
-
-const meta = {
-	url: 'https://stylelint.io/user-guide/rules/font-family-no-missing-generic-family-keyword',
-};
-
-/**
- * @param {import('postcss-value-parser').Node} node
- * @returns {boolean}
- */
-const isFamilyNameKeyword = (node) =>
-	!('quote' in node) && fontFamilyKeywords.has(node.value.toLowerCase());
-
-/**
- * @param {string} value
- * @returns {boolean}
- */
-const isLastFontFamilyVariable = (value) => {
-	const lastValue = postcss.list.comma(value).pop();
-
-	return lastValue != null && (isVariable(lastValue) || !isStandardSyntaxValue(lastValue));
-};
-
-/** @type {import('stylelint').CoreRules[ruleName]} */
-const rule = (primary, secondaryOptions) => {
-	return (root, result) => {
-		const validOptions = validateOptions(
-			result,
-			ruleName,
-			{ actual: primary },
-			{
-				actual: secondaryOptions,
-				possible: {
-					ignoreFontFamilies: [isString, isRegExp],
-				},
-				optional: true,
-			},
-		);
-
-		if (!validOptions) {
-			return;
-		}
-
-		const ignoredAtRules = new Set(['font-face', 'font-palette-values']);
-
-		root.walkDecls(/^font(-family)?$/i, (decl) => {
-			const parent = decl.parent;
-
-			if (parent && isAtRule(parent) && ignoredAtRules.has(parent.name.toLowerCase())) {
-				return;
-			}
-
-			if (decl.prop === 'font' && systemFontKeywords.has(decl.value.toLowerCase())) {
-				return;
-			}
-
-			if (isLastFontFamilyVariable(decl.value)) {
-				return;
-			}
-
-			const fontFamilies = findFontFamily(decl.value);
-
-			if (fontFamilies.length === 0) {
-				return;
-			}
-
-			if (fontFamilies.some((node) => isFamilyNameKeyword(node))) {
-				return;
-			}
-
-			if (
-				fontFamilies.some((node) =>
-					optionsMatches(secondaryOptions, 'ignoreFontFamilies', node.value),
-				)
-			) {
-				return;
-			}
-
-			const lastFontFamily = fontFamilies[fontFamilies.length - 1];
-
-			assert(lastFontFamily);
-
-			const valueIndex = declarationValueIndex(decl);
-			const index = valueIndex + lastFontFamily.sourceIndex;
-			const endIndex = valueIndex + lastFontFamily.sourceEndIndex;
-
-			report({
-				result,
-				ruleName,
-				message: messages.rejected,
-				messageArgs: [],
-				node: decl,
-				index,
-				endIndex,
-			});
-		});
-	};
-};
-
-rule.ruleName = ruleName;
-rule.messages = messages;
-rule.meta = meta;
-export default rule;

package/packages/config-stylelint/node_modules/stylelint/lib/rules/font-weight-notation/index.mjs

@@ -1,212 +0,0 @@
-import valueParser from 'postcss-value-parser';
-
-import {
-	fontWeightNonNumericKeywords,
-	fontWeightRelativeKeywords,
-} from '../../reference/keywords.mjs';
-import { assertString } from '../../utils/validateTypes.mjs';
-import { declarationValueIndex } from '../../utils/nodeFieldIndices.mjs';
-import getDeclarationValue from '../../utils/getDeclarationValue.mjs';
-import isNumbery from '../../utils/isNumbery.mjs';
-import isStandardSyntaxValue from '../../utils/isStandardSyntaxValue.mjs';
-import isVariable from '../../utils/isVariable.mjs';
-import optionsMatches from '../../utils/optionsMatches.mjs';
-import report from '../../utils/report.mjs';
-import ruleMessages from '../../utils/ruleMessages.mjs';
-import setDeclarationValue from '../../utils/setDeclarationValue.mjs';
-import validateOptions from '../../utils/validateOptions.mjs';
-
-const ruleName = 'font-weight-notation';
-
-const messages = ruleMessages(ruleName, {
-	expected: (type) => `Expected ${type} font-weight notation`,
-	expectedWithActual: (actual, expected) => `Expected "${actual}" to be "${expected}"`,
-});
-
-const meta = {
-	url: 'https://stylelint.io/user-guide/rules/font-weight-notation',
-	fixable: true,
-};
-
-const NORMAL_KEYWORD = 'normal';
-
-const NAMED_TO_NUMERIC = new Map([
-	['normal', '400'],
-	['bold', '700'],
-]);
-const NUMERIC_TO_NAMED = new Map([
-	['400', 'normal'],
-	['700', 'bold'],
-]);
-
-/** @type {import('stylelint').CoreRules[ruleName]} */
-const rule = (primary, secondaryOptions) => {
-	return (root, result) => {
-		const validOptions = validateOptions(
-			result,
-			ruleName,
-			{
-				actual: primary,
-				possible: ['numeric', 'named-where-possible'],
-			},
-			{
-				actual: secondaryOptions,
-				possible: {
-					ignore: ['relative'],
-				},
-				optional: true,
-			},
-		);
-
-		if (!validOptions) {
-			return;
-		}
-
-		const ignoreRelative = optionsMatches(secondaryOptions, 'ignore', 'relative');
-
-		root.walkDecls(/^font(-weight)?$/i, (decl) => {
-			const isFontShorthandProp = decl.prop.toLowerCase() === 'font';
-			const parsedValue = valueParser(getDeclarationValue(decl));
-			const valueNodes = parsedValue.nodes;
-			const hasNumericFontWeight = valueNodes.some((node, index, nodes) => {
-				return isNumbery(node.value) && !isDivNode(nodes[index - 1]);
-			});
-
-			for (const [index, valueNode] of valueNodes.entries()) {
-				if (!isPossibleFontWeightNode(valueNode, index, valueNodes)) continue;
-
-				const { value } = valueNode;
-
-				if (isFontShorthandProp) {
-					if (value.toLowerCase() === NORMAL_KEYWORD && hasNumericFontWeight) {
-						continue; // Not `normal` for font-weight
-					}
-
-					if (checkWeight(decl, valueNode, parsedValue)) {
-						break; // Stop traverse if font-weight is processed
-					}
-				}
-
-				checkWeight(decl, valueNode, parsedValue);
-			}
-		});
-
-		/** @import { Node, ParsedValue } from 'postcss-value-parser' */
-
-		/**
-		 * @param {import('postcss').Declaration} decl
-		 * @param {Node} weightValueNode
-		 * @param {ParsedValue} parsedValue
-		 * @returns {true | undefined}
-		 */
-		function checkWeight(decl, weightValueNode, parsedValue) {
-			const weightValue = weightValueNode.value;
-
-			if (!isStandardSyntaxValue(weightValue)) {
-				return;
-			}
-
-			if (isVariable(weightValue)) {
-				return;
-			}
-
-			const lowerWeightValue = weightValue.toLowerCase();
-
-			if (ignoreRelative && fontWeightRelativeKeywords.has(lowerWeightValue)) {
-				return;
-			}
-
-			const fixer = (/** @type {string} */ value) => () => {
-				weightValueNode.value = value;
-				setDeclarationValue(decl, parsedValue.toString());
-			};
-
-			if (primary === 'numeric') {
-				if (!isNumbery(lowerWeightValue) && fontWeightNonNumericKeywords.has(lowerWeightValue)) {
-					const numericValue = NAMED_TO_NUMERIC.get(lowerWeightValue);
-
-					if (numericValue) {
-						complain(
-							messages.expectedWithActual,
-							[weightValue, numericValue],
-							weightValueNode,
-							fixer(numericValue),
-						);
-					} else {
-						complain(messages.expected, ['numeric'], weightValueNode, undefined);
-					}
-
-					return true;
-				}
-			} else if (primary === 'named-where-possible') {
-				if (isNumbery(lowerWeightValue) && NUMERIC_TO_NAMED.has(lowerWeightValue)) {
-					const namedValue = NUMERIC_TO_NAMED.get(lowerWeightValue);
-
-					// microsoft/TypeScript#13086
-					assertString(namedValue);
-
-					const fix = fixer(namedValue);
-
-					complain(messages.expectedWithActual, [weightValue, namedValue], weightValueNode, fix);
-
-					return true;
-				}
-			}
-
-			/**
-			 * @param {typeof messages[keyof messages]} message
-			 * @param {Array<string>} messageArgs
-			 * @param {import('postcss-value-parser').Node} valueNode
-			 * @param {(() => void) | undefined} fix
-			 */
-			function complain(message, messageArgs, valueNode, fix) {
-				const index = declarationValueIndex(decl) + valueNode.sourceIndex;
-				const endIndex = index + valueNode.value.length;
-
-				report({
-					ruleName,
-					result,
-					message,
-					messageArgs,
-					node: decl,
-					index,
-					endIndex,
-					fix: {
-						apply: fix,
-						node: decl,
-					},
-				});
-			}
-		}
-	};
-};
-
-/**
- * @param {Node | undefined} node
- * @returns {boolean}
- */
-function isDivNode(node) {
-	return node !== undefined && node.type === 'div';
-}
-
-/**
- * @param {Node} node
- * @param {number} index
- * @param {Node[]} nodes
- * @returns {boolean}
- */
-function isPossibleFontWeightNode(node, index, nodes) {
-	if (node.type !== 'word') return false;
-
-	// Exclude `<font-size>/<line-height>` format like `16px/3`.
-	if (isDivNode(nodes[index - 1])) return false;
-
-	if (isDivNode(nodes[index + 1])) return false;
-
-	return true;
-}
-
-rule.ruleName = ruleName;
-rule.messages = messages;
-rule.meta = meta;
-export default rule;