@alexlit/lint-kit 176.0.1 → 177.0.0

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

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

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

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