@alexlit/lint-kit 174.0.0 → 176.0.0

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/explicit-length-check.js

@@ -0,0 +1,236 @@
+import {isParenthesized, getStaticValue} from '@eslint-community/eslint-utils';
+import {checkVueTemplate} from './utils/rule.js';
+import isLogicalExpression from './utils/is-logical-expression.js';
+import {isBooleanNode, getBooleanAncestor} from './utils/boolean.js';
+import {fixSpaceAroundKeyword} from './fix/index.js';
+import {isLiteral, isMemberExpression, isNumericLiteral} from './ast/index.js';
+
+const TYPE_NON_ZERO = 'non-zero';
+const TYPE_ZERO = 'zero';
+const MESSAGE_ID_SUGGESTION = 'suggestion';
+const messages = {
+	[TYPE_NON_ZERO]: 'Use `.{{property}} {{code}}` when checking {{property}} is not zero.',
+	[TYPE_ZERO]: 'Use `.{{property}} {{code}}` when checking {{property}} is zero.',
+	[MESSAGE_ID_SUGGESTION]: 'Replace `.{{property}}` with `.{{property}} {{code}}`.',
+};
+
+const isCompareRight = (node, operator, value) =>
+	node.type === 'BinaryExpression'
+	&& node.operator === operator
+	&& isLiteral(node.right, value);
+const isCompareLeft = (node, operator, value) =>
+	node.type === 'BinaryExpression'
+	&& node.operator === operator
+	&& isLiteral(node.left, value);
+const nonZeroStyles = new Map([
+	[
+		'greater-than',
+		{
+			code: '> 0',
+			test: node => isCompareRight(node, '>', 0),
+		},
+	],
+	[
+		'not-equal',
+		{
+			code: '!== 0',
+			test: node => isCompareRight(node, '!==', 0),
+		},
+	],
+]);
+const zeroStyle = {
+	code: '=== 0',
+	test: node => isCompareRight(node, '===', 0),
+};
+
+function getLengthCheckNode(node) {
+	node = node.parent;
+
+	// Zero length check
+	if (
+		// `foo.length === 0`
+		isCompareRight(node, '===', 0)
+		// `foo.length == 0`
+		|| isCompareRight(node, '==', 0)
+		// `foo.length < 1`
+		|| isCompareRight(node, '<', 1)
+		// `0 === foo.length`
+		|| isCompareLeft(node, '===', 0)
+		// `0 == foo.length`
+		|| isCompareLeft(node, '==', 0)
+		// `1 > foo.length`
+		|| isCompareLeft(node, '>', 1)
+	) {
+		return {isZeroLengthCheck: true, node};
+	}
+
+	// Non-Zero length check
+	if (
+		// `foo.length !== 0`
+		isCompareRight(node, '!==', 0)
+		// `foo.length != 0`
+		|| isCompareRight(node, '!=', 0)
+		// `foo.length > 0`
+		|| isCompareRight(node, '>', 0)
+		// `foo.length >= 1`
+		|| isCompareRight(node, '>=', 1)
+		// `0 !== foo.length`
+		|| isCompareLeft(node, '!==', 0)
+		// `0 !== foo.length`
+		|| isCompareLeft(node, '!=', 0)
+		// `0 < foo.length`
+		|| isCompareLeft(node, '<', 0)
+		// `1 <= foo.length`
+		|| isCompareLeft(node, '<=', 1)
+	) {
+		return {isZeroLengthCheck: false, node};
+	}
+
+	return {};
+}
+
+function isNodeValueNumber(node, context) {
+	if (isNumericLiteral(node)) {
+		return true;
+	}
+
+	const staticValue = getStaticValue(node, context.sourceCode.getScope(node));
+	return staticValue && typeof staticValue.value === 'number';
+}
+
+function create(context) {
+	const options = {
+		'non-zero': 'greater-than',
+		...context.options[0],
+	};
+	const nonZeroStyle = nonZeroStyles.get(options['non-zero']);
+	const {sourceCode} = context;
+
+	function getProblem({node, isZeroLengthCheck, lengthNode, autoFix}) {
+		const {code, test} = isZeroLengthCheck ? zeroStyle : nonZeroStyle;
+		if (test(node)) {
+			return;
+		}
+
+		let fixed = `${sourceCode.getText(lengthNode)} ${code}`;
+		if (
+			!isParenthesized(node, sourceCode)
+			&& node.type === 'UnaryExpression'
+			&& (node.parent.type === 'UnaryExpression' || node.parent.type === 'AwaitExpression')
+		) {
+			fixed = `(${fixed})`;
+		}
+
+		const fix = function * (fixer) {
+			yield fixer.replaceText(node, fixed);
+			yield fixSpaceAroundKeyword(fixer, node, context);
+		};
+
+		const problem = {
+			node,
+			messageId: isZeroLengthCheck ? TYPE_ZERO : TYPE_NON_ZERO,
+			data: {code, property: lengthNode.property.name},
+		};
+
+		if (autoFix) {
+			problem.fix = fix;
+		} else {
+			problem.suggest = [
+				{
+					messageId: MESSAGE_ID_SUGGESTION,
+					fix,
+				},
+			];
+		}
+
+		return problem;
+	}
+
+	return {
+		MemberExpression(memberExpression) {
+			if (
+				!isMemberExpression(memberExpression, {
+					properties: ['length', 'size'],
+					optional: false,
+				})
+				|| memberExpression.object.type === 'ThisExpression'
+			) {
+				return;
+			}
+
+			const lengthNode = memberExpression;
+			const staticValue = getStaticValue(lengthNode, sourceCode.getScope(lengthNode));
+			if (staticValue && (!Number.isInteger(staticValue.value) || staticValue.value < 0)) {
+				// Ignore known, non-positive-integer length properties.
+				return;
+			}
+
+			let node;
+			let autoFix = true;
+			let {isZeroLengthCheck, node: lengthCheckNode} = getLengthCheckNode(lengthNode);
+			if (lengthCheckNode) {
+				const {isNegative, node: ancestor} = getBooleanAncestor(lengthCheckNode);
+				node = ancestor;
+				if (isNegative) {
+					isZeroLengthCheck = !isZeroLengthCheck;
+				}
+			} else {
+				const {isNegative, node: ancestor} = getBooleanAncestor(lengthNode);
+				if (isBooleanNode(ancestor)) {
+					isZeroLengthCheck = isNegative;
+					node = ancestor;
+				} else if (
+					isLogicalExpression(lengthNode.parent)
+					&& !(
+						lengthNode.parent.operator === '||'
+						&& isNodeValueNumber(lengthNode.parent.right, context)
+					)
+				) {
+					isZeroLengthCheck = isNegative;
+					node = lengthNode;
+					autoFix = false;
+				}
+			}
+
+			if (node) {
+				return getProblem({
+					node,
+					isZeroLengthCheck,
+					lengthNode,
+					autoFix,
+				});
+			}
+		},
+	};
+}
+
+const schema = [
+	{
+		type: 'object',
+		additionalProperties: false,
+		properties: {
+			'non-zero': {
+				enum: [...nonZeroStyles.keys()],
+				default: 'greater-than',
+			},
+		},
+	},
+];
+
+/** @type {import('eslint').Rule.RuleModule} */
+const config = {
+	create: checkVueTemplate(create),
+	meta: {
+		type: 'problem',
+		docs: {
+			description: 'Enforce explicitly comparing the `length` or `size` property of a value.',
+			recommended: true,
+		},
+		fixable: 'code',
+		schema,
+		messages,
+		hasSuggestions: true,
+	},
+};
+
+export default config;

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/filename-case.js

@@ -0,0 +1,276 @@
+import path from 'node:path';
+import {isRegExp} from 'node:util/types';
+import {
+	camelCase,
+	kebabCase,
+	snakeCase,
+	pascalCase,
+} from 'change-case';
+import cartesianProductSamples from './utils/cartesian-product-samples.js';
+
+const MESSAGE_ID = 'filename-case';
+const MESSAGE_ID_EXTENSION = 'filename-extension';
+const messages = {
+	[MESSAGE_ID]: 'Filename is not in {{chosenCases}}. Rename it to {{renamedFilenames}}.',
+	[MESSAGE_ID_EXTENSION]: 'File extension `{{extension}}` is not in lowercase. Rename it to `{{filename}}`.',
+};
+
+const isIgnoredChar = char => !/^[a-z\d-_]$/i.test(char);
+const ignoredByDefault = new Set(['index.js', 'index.mjs', 'index.cjs', 'index.ts', 'index.tsx', 'index.vue']);
+const isLowerCase = string => string === string.toLowerCase();
+
+const cases = {
+	camelCase: {
+		fn: camelCase,
+		name: 'camel case',
+	},
+	kebabCase: {
+		fn: kebabCase,
+		name: 'kebab case',
+	},
+	snakeCase: {
+		fn: snakeCase,
+		name: 'snake case',
+	},
+	pascalCase: {
+		fn: pascalCase,
+		name: 'pascal case',
+	},
+};
+
+/**
+Get the cases specified by the option.
+
+@param {object} options
+@returns {string[]} The chosen cases.
+*/
+function getChosenCases(options) {
+	if (options.case) {
+		return [options.case];
+	}
+
+	if (options.cases) {
+		const cases = Object.keys(options.cases)
+			.filter(cases => options.cases[cases]);
+
+		return cases.length > 0 ? cases : ['kebabCase'];
+	}
+
+	return ['kebabCase'];
+}
+
+function validateFilename(words, caseFunctions) {
+	return words
+		.filter(({ignored}) => !ignored)
+		.every(({word}) => caseFunctions.some(caseFunction => caseFunction(word) === word));
+}
+
+function fixFilename(words, caseFunctions, {leading, trailing}) {
+	const replacements = words
+		.map(({word, ignored}) => ignored ? [word] : caseFunctions.map(caseFunction => caseFunction(word)));
+
+	const {
+		samples: combinations,
+	} = cartesianProductSamples(replacements);
+
+	return [...new Set(combinations.map(parts => `${leading}${parts.join('')}${trailing}`))];
+}
+
+function getFilenameParts(filenameWithExtension, {multipleFileExtensions}) {
+	const extension = path.extname(filenameWithExtension);
+	const filename = path.basename(filenameWithExtension, extension);
+	const basename = filename + extension;
+
+	const parts = {
+		basename,
+		filename,
+		middle: '',
+		extension,
+	};
+
+	if (multipleFileExtensions) {
+		const [firstPart] = filename.split('.');
+		Object.assign(parts, {
+			filename: firstPart,
+			middle: filename.slice(firstPart.length),
+		});
+	}
+
+	return parts;
+}
+
+const leadingUnderscoresRegex = /^(?<leading>_+)(?<tailing>.*)$/;
+function splitFilename(filename) {
+	const result = leadingUnderscoresRegex.exec(filename) || {groups: {}};
+	const {leading = '', tailing = filename} = result.groups;
+
+	const words = [];
+
+	let lastWord;
+	for (const char of tailing) {
+		const isIgnored = isIgnoredChar(char);
+
+		if (lastWord?.ignored === isIgnored) {
+			lastWord.word += char;
+		} else {
+			lastWord = {
+				word: char,
+				ignored: isIgnored,
+			};
+			words.push(lastWord);
+		}
+	}
+
+	return {
+		leading,
+		words,
+	};
+}
+
+/**
+Turns `[a, b, c]` into `a, b, or c`.
+
+@param {string[]} words
+@returns {string}
+*/
+const englishishJoinWords = words => new Intl.ListFormat('en-US', {type: 'disjunction'}).format(words);
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => {
+	const options = context.options[0] || {};
+	const chosenCases = getChosenCases(options);
+	const ignore = (options.ignore || []).map(item => {
+		if (isRegExp(item)) {
+			return item;
+		}
+
+		return new RegExp(item, 'u');
+	});
+	const multipleFileExtensions = options.multipleFileExtensions !== false;
+	const chosenCasesFunctions = chosenCases.map(case_ => cases[case_].fn);
+	const filenameWithExtension = context.physicalFilename;
+
+	if (filenameWithExtension === '<input>' || filenameWithExtension === '<text>') {
+		return;
+	}
+
+	return {
+		Program() {
+			const {
+				basename,
+				filename,
+				middle,
+				extension,
+			} = getFilenameParts(filenameWithExtension, {multipleFileExtensions});
+
+			if (ignoredByDefault.has(basename) || ignore.some(regexp => regexp.test(basename))) {
+				return;
+			}
+
+			const {leading, words} = splitFilename(filename);
+			const isValid = validateFilename(words, chosenCasesFunctions);
+
+			if (isValid) {
+				if (!isLowerCase(extension)) {
+					return {
+						loc: {column: 0, line: 1},
+						messageId: MESSAGE_ID_EXTENSION,
+						data: {filename: filename + middle + extension.toLowerCase(), extension},
+					};
+				}
+
+				return;
+			}
+
+			const renamedFilenames = fixFilename(words, chosenCasesFunctions, {
+				leading,
+				trailing: middle + extension.toLowerCase(),
+			});
+
+			return {
+				// Report on first character like `unicode-bom` rule
+				// https://github.com/eslint/eslint/blob/8a77b661bc921c3408bae01b3aa41579edfc6e58/lib/rules/unicode-bom.js#L46
+				loc: {column: 0, line: 1},
+				messageId: MESSAGE_ID,
+				data: {
+					chosenCases: englishishJoinWords(chosenCases.map(x => cases[x].name)),
+					renamedFilenames: englishishJoinWords(renamedFilenames.map(x => `\`${x}\``)),
+				},
+			};
+		},
+	};
+};
+
+const schema = [
+	{
+		oneOf: [
+			{
+				properties: {
+					case: {
+						enum: [
+							'camelCase',
+							'snakeCase',
+							'kebabCase',
+							'pascalCase',
+						],
+					},
+					ignore: {
+						type: 'array',
+						uniqueItems: true,
+					},
+					multipleFileExtensions: {
+						type: 'boolean',
+					},
+				},
+				additionalProperties: false,
+			},
+			{
+				properties: {
+					cases: {
+						properties: {
+							camelCase: {
+								type: 'boolean',
+							},
+							snakeCase: {
+								type: 'boolean',
+							},
+							kebabCase: {
+								type: 'boolean',
+							},
+							pascalCase: {
+								type: 'boolean',
+							},
+						},
+						additionalProperties: false,
+					},
+					ignore: {
+						type: 'array',
+						uniqueItems: true,
+					},
+					multipleFileExtensions: {
+						type: 'boolean',
+					},
+				},
+				additionalProperties: false,
+			},
+		],
+	},
+];
+
+/** @type {import('eslint').Rule.RuleModule} */
+const config = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Enforce a case style for filenames.',
+			recommended: true,
+		},
+		schema,
+		// eslint-disable-next-line eslint-plugin/require-meta-default-options
+		defaultOptions: [],
+		messages,
+	},
+};
+
+export default config;

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/fix/add-parenthesizes-to-return-or-throw-expression.js

@@ -0,0 +1,29 @@
+import {isSemicolonToken} from '@eslint-community/eslint-utils';
+
+/**
+@import {TSESTree as ESTree} from '@typescript-eslint/types';
+@import * as ESLint from 'eslint';
+*/
+
+/**
+@param {ESLint.Rule.RuleFixer} fixer
+@param {ESTree.ReturnStatement | ESTree.ThrowStatement} node
+@param {ESLint.Rule.RuleContext} context - The ESLint rule context object.
+@returns {ESLint.Rule.ReportFixer}
+*/
+export default function * addParenthesizesToReturnOrThrowExpression(fixer, node, context) {
+	if (node.type !== 'ReturnStatement' && node.type !== 'ThrowStatement') {
+		return;
+	}
+
+	const {sourceCode} = context;
+	const returnOrThrowToken = sourceCode.getFirstToken(node);
+	yield fixer.insertTextAfter(returnOrThrowToken, ' (');
+	const lastToken = sourceCode.getLastToken(node);
+	if (!isSemicolonToken(lastToken)) {
+		yield fixer.insertTextAfter(node, ')');
+		return;
+	}
+
+	yield fixer.insertTextBefore(lastToken, ')');
+}

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/fix/append-argument.js

@@ -0,0 +1,30 @@
+import {isCommaToken} from '@eslint-community/eslint-utils';
+
+/**
+@import {TSESTree as ESTree} from '@typescript-eslint/types';
+@import * as ESLint from 'eslint';
+*/
+
+/**
+@param {ESLint.Rule.RuleFixer} fixer
+@param {ESTree.CallExpression} node
+@param {string} text
+@param {ESLint.Rule.RuleContext} context - The ESLint rule context object.
+@returns {ESLint.Rule.ReportFixer}
+*/
+export default function appendArgument(fixer, node, text, context) {
+	// This function should also work for `NewExpression`
+	// But parentheses of `NewExpression` could be omitted, add this check to prevent accident use on it
+	/* c8 ignore next 3 */
+	if (node.type !== 'CallExpression') {
+		throw new Error(`Unexpected node "${node.type}".`);
+	}
+
+	const {sourceCode} = context;
+	const [penultimateToken, lastToken] = sourceCode.getLastTokens(node, 2);
+	if (node.arguments.length > 0) {
+		text = isCommaToken(penultimateToken) ? ` ${text},` : `, ${text}`;
+	}
+
+	return fixer.insertTextBefore(lastToken, text);
+}

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/fix/extend-fix-range.js

@@ -0,0 +1,11 @@
+/**
+Extend fix range to prevent changes from other rules.
+https://github.com/eslint/eslint/pull/13748/files#diff-c692f3fde09eda7c89f1802c908511a3fb59f5d207fe95eb009cb52e46a99e84R348
+
+@param {ruleFixer} fixer - The fixer to fix.
+@param {int[]} range - The extended range node.
+*/
+export default function * extendFixRange(fixer, range) {
+	yield fixer.insertTextBeforeRange(range, '');
+	yield fixer.insertTextAfterRange(range, '');
+}

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/fix/fix-space-around-keywords.js

@@ -0,0 +1,43 @@
+import {getParenthesizedRange} from '../utils/parentheses.js';
+
+/**
+@import {TSESTree as ESTree} from '@typescript-eslint/types';
+@import * as ESLint from 'eslint';
+*/
+
+const isProblematicToken = ({type, value}) => (
+	(type === 'Keyword' && /^[a-z]*$/.test(value))
+	// ForOfStatement
+	|| (type === 'Identifier' && value === 'of')
+	// AwaitExpression
+	|| (type === 'Identifier' && value === 'await')
+);
+
+/**
+@param {ESLint.Rule.RuleFixer} fixer
+@param {ESTree.Node} node
+@param {ESLint.Rule.RuleContext} context - The ESLint rule context object.
+*/
+export default function * fixSpaceAroundKeyword(fixer, node, context) {
+	const {sourceCode} = context;
+	const range = getParenthesizedRange(node, context);
+	const tokenBefore = sourceCode.getTokenBefore({range}, {includeComments: true});
+
+	if (
+		tokenBefore
+		&& range[0] === sourceCode.getRange(tokenBefore)[1]
+		&& isProblematicToken(tokenBefore)
+	) {
+		yield fixer.insertTextAfter(tokenBefore, ' ');
+	}
+
+	const tokenAfter = sourceCode.getTokenAfter({range}, {includeComments: true});
+
+	if (
+		tokenAfter
+		&& range[1] === sourceCode.getRange(tokenAfter)[0]
+		&& isProblematicToken(tokenAfter)
+	) {
+		yield fixer.insertTextBefore(tokenAfter, ' ');
+	}
+}

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/fix/index.js

@@ -0,0 +1,23 @@
+export {default as extendFixRange} from './extend-fix-range.js';
+export {default as removeParentheses} from './remove-parentheses.js';
+export {default as appendArgument} from './append-argument.js';
+export {default as removeArgument} from './remove-argument.js';
+export {default as replaceArgument} from './replace-argument.js';
+export {default as switchNewExpressionToCallExpression} from './switch-new-expression-to-call-expression.js';
+export {default as switchCallExpressionToNewExpression} from './switch-call-expression-to-new-expression.js';
+export {
+	replaceMemberExpressionProperty,
+	removeMemberExpressionProperty,
+} from './replace-member-expression-property.js';
+export {default as removeMethodCall} from './remove-method-call.js';
+export {default as removeExpressionStatement} from './remove-expression-statement.js';
+export {default as removeSpacesAfter} from './remove-spaces-after.js';
+export {default as removeSpecifier} from './remove-specifier.js';
+export {default as removeObjectProperty} from './remove-object-property.js';
+export {default as renameVariable} from './rename-variable.js';
+export {default as replaceTemplateElement} from './replace-template-element.js';
+export {default as replaceReferenceIdentifier} from './replace-reference-identifier.js';
+export {default as replaceNodeOrTokenAndSpacesBefore} from './replace-node-or-token-and-spaces-before.js';
+export {default as fixSpaceAroundKeyword} from './fix-space-around-keywords.js';
+export {default as replaceStringRaw} from './replace-string-raw.js';
+export {default as addParenthesizesToReturnOrThrowExpression} from './add-parenthesizes-to-return-or-throw-expression.js';

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/fix/remove-argument.js

@@ -0,0 +1,40 @@
+import {isCommaToken} from '@eslint-community/eslint-utils';
+import {getParentheses} from '../utils/parentheses.js';
+
+/**
+@import {TSESTree as ESTree} from '@typescript-eslint/types';
+@import * as ESLint from 'eslint';
+*/
+
+/**
+@param {ESLint.Rule.RuleFixer} fixer
+@param {ESTree.NewExpression | ESTree.CallExpression} node
+@param {ESLint.Rule.RuleContext} context - The ESLint rule context object.
+@returns {ESLint.Rule.ReportFixer}
+*/
+export default function removeArgument(fixer, node, context) {
+	const callOrNewExpression = node.parent;
+	const index = callOrNewExpression.arguments.indexOf(node);
+	const parentheses = getParentheses(node, context);
+	const firstToken = parentheses[0] || node;
+	const lastToken = parentheses.at(-1) || node;
+	const {sourceCode} = context;
+
+	let [start] = sourceCode.getRange(firstToken);
+	let [, end] = sourceCode.getRange(lastToken);
+
+	if (index !== 0) {
+		const commaToken = sourceCode.getTokenBefore(firstToken);
+		[start] = sourceCode.getRange(commaToken);
+	}
+
+	// If the removed argument is the only argument, the trailing comma must be removed too
+	if (callOrNewExpression.arguments.length === 1) {
+		const tokenAfter = sourceCode.getTokenAfter(lastToken);
+		if (isCommaToken(tokenAfter)) {
+			[, end] = sourceCode.getRange(tokenAfter);
+		}
+	}
+
+	return fixer.removeRange([start, end]);
+}