@alexlit/lint-kit 176.0.1 → 177.0.0

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

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

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

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

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

@@ -1,11 +0,0 @@
-/**
-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

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

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

@@ -1,40 +0,0 @@
-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]);
-}