@alexlit/lint-kit 182.1.0 → 182.2.0

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

@@ -0,0 +1,243 @@
+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 { propertyRegexes } from '../../utils/regexes.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(propertyRegexes.fontFamilyAndShorthandName, (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

@@ -0,0 +1,122 @@
+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 { propertyRegexes } from '../../utils/regexes.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(propertyRegexes.fontFamilyAndShorthandName, (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

@@ -0,0 +1,122 @@
+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 { propertyRegexes } from '../../utils/regexes.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(propertyRegexes.fontFamilyAndShorthandName, (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

@@ -0,0 +1,221 @@
+import valueParser from 'postcss-value-parser';
+
+import {
+	fontWeightNonNumericKeywords,
+	fontWeightRelativeKeywords,
+} from '../../reference/keywords.mjs';
+import { mayIncludeRegexes, propertyRegexes } from '../../utils/regexes.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(propertyRegexes.fontWeightAndShorthandName, (decl) => {
+			if (primary === 'numeric' && !mayIncludeRegexes.namedFontWeight.test(decl.value)) return;
+
+			if (
+				primary === 'named-where-possible' &&
+				!mayIncludeRegexes.numericFontWeight.test(decl.value)
+			)
+				return;
+
+			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;