@alexlit/lint-kit 174.0.0 → 176.0.0

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/no-useless-spread.js

@@ -0,0 +1,389 @@
+import {isCommaToken} from '@eslint-community/eslint-utils';
+import typedArray from './shared/typed-array.js';
+import {removeParentheses, fixSpaceAroundKeyword, addParenthesizesToReturnOrThrowExpression} from './fix/index.js';
+import {isParenthesized, isOnSameLine} from './utils/index.js';
+import {isNewExpression, isMethodCall, isCallOrNewExpression} from './ast/index.js';
+
+const SPREAD_IN_LIST = 'spread-in-list';
+const ITERABLE_TO_ARRAY = 'iterable-to-array';
+const ITERABLE_TO_ARRAY_IN_FOR_OF = 'iterable-to-array-in-for-of';
+const ITERABLE_TO_ARRAY_IN_YIELD_STAR = 'iterable-to-array-in-yield-star';
+const CLONE_ARRAY = 'clone-array';
+const messages = {
+	[SPREAD_IN_LIST]: 'Spread an {{argumentType}} literal in {{parentDescription}} is unnecessary.',
+	[ITERABLE_TO_ARRAY]: '`{{parentDescription}}` accepts iterable as argument, it\'s unnecessary to convert to an array.',
+	[ITERABLE_TO_ARRAY_IN_FOR_OF]: '`for…of` can iterate over iterable, it\'s unnecessary to convert to an array.',
+	[ITERABLE_TO_ARRAY_IN_YIELD_STAR]: '`yield*` can delegate iterable, it\'s unnecessary to convert to an array.',
+	[CLONE_ARRAY]: 'Unnecessarily cloning an array.',
+};
+
+const isSingleArraySpread = node =>
+	node.type === 'ArrayExpression'
+	&& node.elements.length === 1
+	&& node.elements[0]?.type === 'SpreadElement';
+
+const parentDescriptions = {
+	ArrayExpression: 'array literal',
+	ObjectExpression: 'object literal',
+	CallExpression: 'arguments',
+	NewExpression: 'arguments',
+};
+
+function getCommaTokens(arrayExpression, sourceCode) {
+	let startToken = sourceCode.getFirstToken(arrayExpression);
+
+	return arrayExpression.elements.map((element, index, elements) => {
+		if (index === elements.length - 1) {
+			const penultimateToken = sourceCode.getLastToken(arrayExpression, {skip: 1});
+			if (isCommaToken(penultimateToken)) {
+				return penultimateToken;
+			}
+
+			return;
+		}
+
+		const commaToken = sourceCode.getTokenAfter(element || startToken, isCommaToken);
+		startToken = commaToken;
+		return commaToken;
+	});
+}
+
+function * unwrapSingleArraySpread(fixer, arrayExpression, context) {
+	const {sourceCode} = context;
+	const [
+		openingBracketToken,
+		spreadToken,
+		thirdToken,
+	] = sourceCode.getFirstTokens(arrayExpression, 3);
+
+	// `[...value]`
+	//  ^
+	yield fixer.remove(openingBracketToken);
+
+	// `[...value]`
+	//   ^^^
+	yield fixer.remove(spreadToken);
+
+	const [
+		commaToken,
+		closingBracketToken,
+	] = sourceCode.getLastTokens(arrayExpression, 2);
+
+	// `[...value]`
+	//           ^
+	yield fixer.remove(closingBracketToken);
+
+	// `[...value,]`
+	//           ^
+	if (isCommaToken(commaToken)) {
+		yield fixer.remove(commaToken);
+	}
+
+	/*
+	```js
+	function foo() {
+		return [
+			...value,
+		];
+	}
+	```
+	*/
+	const {parent} = arrayExpression;
+	if (
+		(parent.type === 'ReturnStatement' || parent.type === 'ThrowStatement')
+		&& parent.argument === arrayExpression
+		&& !isOnSameLine(openingBracketToken, thirdToken, context)
+		&& !isParenthesized(arrayExpression, sourceCode)
+	) {
+		yield addParenthesizesToReturnOrThrowExpression(fixer, parent, context);
+		return;
+	}
+
+	yield fixSpaceAroundKeyword(fixer, arrayExpression, context);
+}
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => {
+	const {sourceCode} = context;
+
+	// Useless spread in list
+	context.on(['ArrayExpression', 'ObjectExpression'], node => {
+		if (!(
+			node.parent.type === 'SpreadElement'
+			&& node.parent.argument === node
+			&& (
+				(
+					node.type === 'ObjectExpression'
+					&& node.parent.parent.type === 'ObjectExpression'
+					&& node.parent.parent.properties.includes(node.parent)
+				)
+				|| (
+					node.type === 'ArrayExpression'
+					&& (
+						(
+							node.parent.parent.type === 'ArrayExpression'
+							&& node.parent.parent.elements.includes(node.parent)
+						)
+						|| (
+							isCallOrNewExpression(node.parent.parent)
+							&& node.parent.parent.arguments.includes(node.parent)
+						)
+					)
+				)
+			)
+		)) {
+			return;
+		}
+
+		const spreadObject = node;
+		const spreadElement = spreadObject.parent;
+		const spreadToken = sourceCode.getFirstToken(spreadElement);
+		const parentType = spreadElement.parent.type;
+
+		return {
+			node: spreadToken,
+			messageId: SPREAD_IN_LIST,
+			data: {
+				argumentType: spreadObject.type === 'ArrayExpression' ? 'array' : 'object',
+				parentDescription: parentDescriptions[parentType],
+			},
+			/** @param {import('eslint').Rule.RuleFixer} fixer */
+			* fix(fixer) {
+				// `[...[foo]]`
+				//   ^^^
+				yield fixer.remove(spreadToken);
+
+				// `[...(( [foo] ))]`
+				//      ^^       ^^
+				yield removeParentheses(spreadObject, fixer, context);
+
+				// `[...[foo]]`
+				//      ^
+				const firstToken = sourceCode.getFirstToken(spreadObject);
+				yield fixer.remove(firstToken);
+
+				const [
+					penultimateToken,
+					lastToken,
+				] = sourceCode.getLastTokens(spreadObject, 2);
+
+				// `[...[foo]]`
+				//          ^
+				yield fixer.remove(lastToken);
+
+				// `[...[foo,]]`
+				//          ^
+				if (isCommaToken(penultimateToken)) {
+					yield fixer.remove(penultimateToken);
+				}
+
+				// `[...[], 1]`
+				//        ^
+				if (
+					(node.type === 'ArrayExpression' && node.elements.length === 0)
+					|| (node.type === 'ObjectExpression' && node.properties.length === 0)
+				) {
+					const nextToken = sourceCode.getTokenAfter(spreadElement);
+					if (isCommaToken(nextToken)) {
+						yield fixer.remove(nextToken);
+					}
+				}
+
+				if (parentType !== 'CallExpression' && parentType !== 'NewExpression') {
+					return;
+				}
+
+				const commaTokens = getCommaTokens(spreadObject, sourceCode);
+				for (const [index, commaToken] of commaTokens.entries()) {
+					if (spreadObject.elements[index]) {
+						continue;
+					}
+
+					// `call(...[foo, , bar])`
+					//               ^ Replace holes with `undefined`
+					yield fixer.insertTextBefore(commaToken, 'undefined');
+				}
+			},
+		};
+	});
+
+	// Useless iterable to array
+	context.on('ArrayExpression', arrayExpression => {
+		if (!isSingleArraySpread(arrayExpression)) {
+			return;
+		}
+
+		const {parent} = arrayExpression;
+		if (!(
+			(parent.type === 'ForOfStatement' && parent.right === arrayExpression)
+			|| (parent.type === 'YieldExpression' && parent.delegate && parent.argument === arrayExpression)
+			|| (
+				(
+					isNewExpression(parent, {names: ['Map', 'WeakMap', 'Set', 'WeakSet'], argumentsLength: 1})
+					|| isNewExpression(parent, {names: typedArray, minimumArguments: 1})
+					|| isMethodCall(parent, {
+						object: 'Promise',
+						methods: ['all', 'allSettled', 'any', 'race'],
+						argumentsLength: 1,
+						optionalCall: false,
+						optionalMember: false,
+					})
+					|| isMethodCall(parent, {
+						objects: ['Array', ...typedArray],
+						method: 'from',
+						argumentsLength: 1,
+						optionalCall: false,
+						optionalMember: false,
+					})
+					|| isMethodCall(parent, {
+						object: 'Object',
+						method: 'fromEntries',
+						argumentsLength: 1,
+						optionalCall: false,
+						optionalMember: false,
+					})
+				)
+				&& parent.arguments[0] === arrayExpression
+			)
+		)) {
+			return;
+		}
+
+		let parentDescription = '';
+		let messageId = ITERABLE_TO_ARRAY;
+		switch (parent.type) {
+			case 'ForOfStatement': {
+				messageId = ITERABLE_TO_ARRAY_IN_FOR_OF;
+				break;
+			}
+
+			case 'YieldExpression': {
+				messageId = ITERABLE_TO_ARRAY_IN_YIELD_STAR;
+				break;
+			}
+
+			case 'NewExpression': {
+				parentDescription = `new ${parent.callee.name}(…)`;
+				break;
+			}
+
+			case 'CallExpression': {
+				parentDescription = `${parent.callee.object.name}.${parent.callee.property.name}(…)`;
+				break;
+			}
+			// No default
+		}
+
+		return {
+			node: arrayExpression,
+			messageId,
+			data: {parentDescription},
+			fix: fixer => unwrapSingleArraySpread(fixer, arrayExpression, context),
+		};
+	});
+
+	// Useless array clone
+	context.on('ArrayExpression', arrayExpression => {
+		if (!isSingleArraySpread(arrayExpression)) {
+			return;
+		}
+
+		const node = arrayExpression.elements[0].argument;
+		if (!(
+			// Array methods returns a new array
+			isMethodCall(node, {
+				methods: [
+					'concat',
+					'copyWithin',
+					'filter',
+					'flat',
+					'flatMap',
+					'map',
+					'slice',
+					'splice',
+					'toReversed',
+					'toSorted',
+					'toSpliced',
+					'with',
+				],
+				optionalCall: false,
+				optionalMember: false,
+			})
+			// `String#split()`
+			|| isMethodCall(node, {
+				method: 'split',
+				optionalCall: false,
+				optionalMember: false,
+			})
+			// `Object.keys()` and `Object.values()`
+			|| isMethodCall(node, {
+				object: 'Object',
+				methods: ['keys', 'values'],
+				argumentsLength: 1,
+				optionalCall: false,
+				optionalMember: false,
+			})
+			// `await Promise.all()` and `await Promise.allSettled`
+			|| (
+				node.type === 'AwaitExpression'
+				&& isMethodCall(node.argument, {
+					object: 'Promise',
+					methods: ['all', 'allSettled'],
+					argumentsLength: 1,
+					optionalCall: false,
+					optionalMember: false,
+				})
+			)
+			// `Array.from()`, `Array.of()`
+			|| isMethodCall(node, {
+				object: 'Array',
+				methods: ['from', 'of'],
+				optionalCall: false,
+				optionalMember: false,
+			})
+			// `new Array()`
+			|| isNewExpression(node, {name: 'Array'})
+		)) {
+			return;
+		}
+
+		const problem = {
+			node: arrayExpression,
+			messageId: CLONE_ARRAY,
+		};
+
+		if (
+			// `[...new Array(1)]` -> `new Array(1)` is not safe to fix since there are holes
+			isNewExpression(node, {name: 'Array'})
+			// `[...foo.slice(1)]` -> `foo.slice(1)` is not safe to fix since `foo` can be a string
+			|| (
+				node.type === 'CallExpression'
+				&& node.callee.type === 'MemberExpression'
+				&& node.callee.property.type === 'Identifier'
+				&& node.callee.property.name === 'slice'
+			)
+		) {
+			return problem;
+		}
+
+		return Object.assign(problem, {
+			fix: fixer => unwrapSingleArraySpread(fixer, arrayExpression, context),
+		});
+	});
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+const config = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Disallow unnecessary spread.',
+			recommended: 'unopinionated',
+		},
+		fixable: 'code',
+		messages,
+	},
+};
+
+export default config;

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/no-useless-switch-case.js

@@ -0,0 +1,59 @@
+import {isEmptyNode} from './ast/index.js';
+import getSwitchCaseHeadLocation from './utils/get-switch-case-head-location.js';
+
+const MESSAGE_ID_ERROR = 'no-useless-switch-case/error';
+const MESSAGE_ID_SUGGESTION = 'no-useless-switch-case/suggestion';
+const messages = {
+	[MESSAGE_ID_ERROR]: 'Useless case in switch statement.',
+	[MESSAGE_ID_SUGGESTION]: 'Remove this case.',
+};
+
+const isEmptySwitchCase = node => node.consequent.every(node => isEmptyNode(node));
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => ({
+	* SwitchStatement(switchStatement) {
+		const {cases} = switchStatement;
+
+		// We only check cases where the last case is the `default` case
+		if (cases.length < 2 || cases.at(-1).test !== null) {
+			return;
+		}
+
+		for (let index = cases.length - 2; index >= 0; index--) {
+			const node = cases[index];
+			if (!isEmptySwitchCase(node)) {
+				break;
+			}
+
+			yield {
+				node,
+				loc: getSwitchCaseHeadLocation(node, context),
+				messageId: MESSAGE_ID_ERROR,
+				suggest: [
+					{
+						messageId: MESSAGE_ID_SUGGESTION,
+						/** @param {import('eslint').Rule.RuleFixer} fixer */
+						fix: fixer => fixer.remove(node),
+					},
+				],
+			};
+		}
+	},
+});
+
+/** @type {import('eslint').Rule.RuleModule} */
+const config = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Disallow useless case in switch statements.',
+			recommended: 'unopinionated',
+		},
+		hasSuggestions: true,
+		messages,
+	},
+};
+
+export default config;

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/no-useless-undefined.js

@@ -0,0 +1,275 @@
+import {removeArgument, replaceNodeOrTokenAndSpacesBefore} from './fix/index.js';
+import {isUndefined, isFunction} from './ast/index.js';
+
+const messageId = 'no-useless-undefined';
+const messages = {
+	[messageId]: 'Do not use useless `undefined`.',
+};
+
+const compareFunctionNames = new Set([
+	'is',
+	'equal',
+	'notEqual',
+	'strictEqual',
+	'notStrictEqual',
+	'propertyVal',
+	'notPropertyVal',
+	'not',
+	'include',
+	'property',
+	'toBe',
+	'toHaveBeenCalledWith',
+	'toContain',
+	'toContainEqual',
+	'toEqual',
+	'same',
+	'notSame',
+	'strictSame',
+	'strictNotSame',
+]);
+const shouldIgnore = node => {
+	let name;
+
+	if (node.type === 'Identifier') {
+		name = node.name;
+	} else if (
+		node.type === 'MemberExpression'
+		&& node.computed === false
+		&& node.property.type === 'Identifier'
+	) {
+		name = node.property.name;
+	}
+
+	return compareFunctionNames.has(name)
+		// `array.push(undefined)`
+		|| name === 'push'
+		// `array.unshift(undefined)`
+		|| name === 'unshift'
+		// `array.includes(undefined)`
+		|| name === 'includes'
+
+		// `set.add(undefined)`
+		|| name === 'add'
+		// `set.has(undefined)`
+		|| name === 'has'
+		// `set.delete(undefined)`
+		|| name === 'delete'
+
+		// `map.set(foo, undefined)`
+		|| name === 'set'
+
+		// `React.createContext(undefined)`
+		|| name === 'createContext'
+		// `setState(undefined)`
+		|| /^set[A-Z]/.test(name)
+		// React 19 useRef
+		|| name === 'useRef'
+
+		// https://vuejs.org/api/reactivity-core.html#ref
+		|| name === 'ref';
+};
+
+const getFunction = scope => {
+	for (; scope; scope = scope.upper) {
+		if (scope.type === 'function') {
+			return scope.block;
+		}
+	}
+};
+
+const isFunctionBindCall = node =>
+	!node.optional
+	&& node.callee.type === 'MemberExpression'
+	&& !node.callee.computed
+	&& node.callee.property.type === 'Identifier'
+	&& node.callee.property.name === 'bind';
+
+const isTypeScriptFile = context =>
+	/\.(?:ts|mts|cts|tsx)$/i.test(context.physicalFilename);
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => {
+	const {sourceCode} = context;
+
+	const getProblem = (node, fix, checkFunctionReturnType) => {
+		if (checkFunctionReturnType) {
+			const functionNode = getFunction(sourceCode.getScope(node));
+			if (functionNode?.returnType) {
+				return;
+			}
+		}
+
+		return {
+			node,
+			messageId,
+			fix,
+		};
+	};
+
+	const options = {
+		checkArguments: true,
+		checkArrowFunctionBody: true,
+		...context.options[0],
+	};
+
+	const removeNodeAndLeadingSpace = (node, fixer) =>
+		replaceNodeOrTokenAndSpacesBefore(node, '', fixer, context);
+
+	// `return undefined`
+	context.on('Identifier', node => {
+		if (
+			isUndefined(node)
+			&& node.parent.type === 'ReturnStatement'
+			&& node.parent.argument === node
+		) {
+			return getProblem(
+				node,
+				fixer => removeNodeAndLeadingSpace(node, fixer),
+				/* CheckFunctionReturnType */ true,
+			);
+		}
+	});
+
+	// `yield undefined`
+	context.on('Identifier', node => {
+		if (
+			isUndefined(node)
+			&& node.parent.type === 'YieldExpression'
+			&& !node.parent.delegate
+			&& node.parent.argument === node
+		) {
+			return getProblem(
+				node,
+				fixer => removeNodeAndLeadingSpace(node, fixer),
+			);
+		}
+	});
+
+	// `() => undefined`
+	if (options.checkArrowFunctionBody) {
+		context.on('Identifier', node => {
+			if (
+				isUndefined(node)
+				&& node.parent.type === 'ArrowFunctionExpression'
+				&& node.parent.body === node
+			) {
+				return getProblem(
+					node,
+					fixer => replaceNodeOrTokenAndSpacesBefore(node, ' {}', fixer, context),
+					/* CheckFunctionReturnType */ true,
+				);
+			}
+		});
+	}
+
+	// `let foo = undefined` / `var foo = undefined`
+	context.on('Identifier', node => {
+		if (
+			isUndefined(node)
+			&& node.parent.type === 'VariableDeclarator'
+			&& node.parent.init === node
+			&& node.parent.parent.type === 'VariableDeclaration'
+			&& node.parent.parent.kind !== 'const'
+			&& node.parent.parent.declarations.includes(node.parent)
+		) {
+			const [, start] = sourceCode.getRange(node.parent.id);
+			const [, end] = sourceCode.getRange(node);
+			return getProblem(
+				node,
+				fixer => fixer.removeRange([start, end]),
+				/* CheckFunctionReturnType */ true,
+			);
+		}
+	});
+
+	// `const {foo = undefined} = {}`
+	context.on('Identifier', node => {
+		if (
+			isUndefined(node)
+			&& node.parent.type === 'AssignmentPattern'
+			&& node.parent.right === node
+		) {
+			return getProblem(
+				node,
+				function * (fixer) {
+					const assignmentPattern = node.parent;
+					const {left} = assignmentPattern;
+					const [, start] = sourceCode.getRange(left);
+					const [, end] = sourceCode.getRange(node);
+
+					yield fixer.removeRange([start, end]);
+					if (
+						(left.typeAnnotation || isTypeScriptFile(context))
+						&& !left.optional
+						&& isFunction(assignmentPattern.parent)
+						&& assignmentPattern.parent.params.includes(assignmentPattern)
+					) {
+						yield (
+							left.typeAnnotation
+								? fixer.insertTextBefore(left.typeAnnotation, '?')
+								: fixer.insertTextAfter(left, '?')
+						);
+					}
+				},
+				/* CheckFunctionReturnType */ true,
+			);
+		}
+	});
+
+	if (!options.checkArguments) {
+		return;
+	}
+
+	context.on('CallExpression', node => {
+		const argumentNodes = node.arguments;
+		const lastArgument = argumentNodes.at(-1);
+
+		if (!isUndefined(lastArgument) || shouldIgnore(node.callee)) {
+			return;
+		}
+
+		// Ignore arguments in `Function#bind()`, but not `this` argument
+		if (isFunctionBindCall(node) && argumentNodes.length !== 1) {
+			return;
+		}
+
+		return {
+			node: lastArgument,
+			messageId,
+			fix: fixer => removeArgument(fixer, lastArgument, context),
+		};
+	});
+};
+
+const schema = [
+	{
+		type: 'object',
+		additionalProperties: false,
+		properties: {
+			checkArguments: {
+				type: 'boolean',
+			},
+			checkArrowFunctionBody: {
+				type: 'boolean',
+			},
+		},
+	},
+];
+
+/** @type {import('eslint').Rule.RuleModule} */
+const config = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Disallow useless `undefined`.',
+			recommended: 'unopinionated',
+		},
+		fixable: 'code',
+		schema,
+		defaultOptions: [{}],
+		messages,
+	},
+};
+
+export default config;