@alexlit/lint-kit 176.0.1 → 177.0.0

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/consistent-empty-array-spread.js

@@ -1,127 +0,0 @@
-import {getStaticValue} from '@eslint-community/eslint-utils';
-
-const MESSAGE_ID = 'consistent-empty-array-spread';
-const messages = {
-	[MESSAGE_ID]: 'Prefer using empty {{replacementDescription}} since the {{anotherNodePosition}} is {{anotherNodeDescription}}.',
-};
-
-const isEmptyArrayExpression = node =>
-	node.type === 'ArrayExpression'
-	&& node.elements.length === 0;
-
-const isEmptyStringLiteral = node =>
-	node.type === 'Literal'
-	&& node.value === '';
-
-const isString = (node, context) => {
-	const staticValueResult = getStaticValue(node, context.sourceCode.getScope(node));
-	return typeof staticValueResult?.value === 'string';
-};
-
-const isArray = (node, context) => {
-	if (node.type === 'ArrayExpression') {
-		return true;
-	}
-
-	const staticValueResult = getStaticValue(node, context.sourceCode.getScope(node));
-	return Array.isArray(staticValueResult?.value);
-};
-
-const cases = [
-	{
-		oneSidePredicate: isEmptyStringLiteral,
-		anotherSidePredicate: isArray,
-		anotherNodeDescription: 'an array',
-		replacementDescription: 'array',
-		replacementCode: '[]',
-	},
-	{
-		oneSidePredicate: isEmptyArrayExpression,
-		anotherSidePredicate: isString,
-		anotherNodeDescription: 'a string',
-		replacementDescription: 'string',
-		replacementCode: '\'\'',
-	},
-];
-
-function createProblem({
-	problemNode,
-	anotherNodePosition,
-	anotherNodeDescription,
-	replacementDescription,
-	replacementCode,
-}) {
-	return {
-		node: problemNode,
-		messageId: MESSAGE_ID,
-		data: {
-			replacementDescription,
-			anotherNodePosition,
-			anotherNodeDescription,
-		},
-		fix: fixer => fixer.replaceText(problemNode, replacementCode),
-	};
-}
-
-function getProblem(conditionalExpression, context) {
-	const {
-		consequent,
-		alternate,
-	} = conditionalExpression;
-
-	for (const problemCase of cases) {
-		const {
-			oneSidePredicate,
-			anotherSidePredicate,
-		} = problemCase;
-
-		if (oneSidePredicate(consequent, context) && anotherSidePredicate(alternate, context)) {
-			return createProblem({
-				...problemCase,
-				problemNode: consequent,
-				anotherNodePosition: 'alternate',
-			});
-		}
-
-		if (oneSidePredicate(alternate, context) && anotherSidePredicate(consequent, context)) {
-			return createProblem({
-				...problemCase,
-				problemNode: alternate,
-				anotherNodePosition: 'consequent',
-			});
-		}
-	}
-}
-
-/** @param {import('eslint').Rule.RuleContext} context */
-const create = context => ({
-	* ArrayExpression(arrayExpression) {
-		for (const element of arrayExpression.elements) {
-			if (
-				element?.type !== 'SpreadElement'
-				|| element.argument.type !== 'ConditionalExpression'
-			) {
-				continue;
-			}
-
-			yield getProblem(element.argument, context);
-		}
-	},
-});
-
-/** @type {import('eslint').Rule.RuleModule} */
-const config = {
-	create,
-	meta: {
-		type: 'suggestion',
-		docs: {
-			description: 'Prefer consistent types when spreading a ternary in an array literal.',
-			recommended: true,
-		},
-		fixable: 'code',
-
-		messages,
-	},
-};
-
-export default config;

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/consistent-existence-index-check.js

@@ -1,137 +0,0 @@
-import toLocation from './utils/to-location.js';
-import {isMethodCall, isNegativeOne, isNumericLiteral} from './ast/index.js';
-
-const MESSAGE_ID = 'consistent-existence-index-check';
-const messages = {
-	[MESSAGE_ID]: 'Prefer `{{replacementOperator}} {{replacementValue}}` over `{{originalOperator}} {{originalValue}}` to check {{existenceOrNonExistence}}.',
-};
-
-const isZero = node => isNumericLiteral(node) && node.value === 0;
-
-/**
-@param {parent: import('estree').BinaryExpression} binaryExpression
-@returns {{
-	replacementOperator: string,
-	replacementValue: string,
-	originalOperator: string,
-	originalValue: string,
-} | undefined}
-*/
-function getReplacement(binaryExpression) {
-	const {operator, right} = binaryExpression;
-
-	if (operator === '<' && isZero(right)) {
-		return {
-			replacementOperator: '===',
-			replacementValue: '-1',
-			originalOperator: operator,
-			originalValue: '0',
-		};
-	}
-
-	if (operator === '>' && isNegativeOne(right)) {
-		return {
-			replacementOperator: '!==',
-			replacementValue: '-1',
-			originalOperator: operator,
-			originalValue: '-1',
-		};
-	}
-
-	if (operator === '>=' && isZero(right)) {
-		return {
-			replacementOperator: '!==',
-			replacementValue: '-1',
-			originalOperator: operator,
-			originalValue: '0',
-		};
-	}
-}
-
-/** @param {import('eslint').Rule.RuleContext} context */
-const create = context => ({
-	/** @param {import('estree').VariableDeclarator} variableDeclarator */
-	* VariableDeclarator(variableDeclarator) {
-		if (!(
-			variableDeclarator.parent.type === 'VariableDeclaration'
-			&& variableDeclarator.parent.kind === 'const'
-			&& variableDeclarator.id.type === 'Identifier'
-			&& isMethodCall(variableDeclarator.init, {methods: ['indexOf', 'lastIndexOf', 'findIndex', 'findLastIndex']})
-		)) {
-			return;
-		}
-
-		const variableIdentifier = variableDeclarator.id;
-		const variables = context.sourceCode.getDeclaredVariables(variableDeclarator);
-		const [variable] = variables;
-
-		// Just for safety
-		if (
-			variables.length !== 1
-			|| variable.identifiers.length !== 1
-			|| variable.identifiers[0] !== variableIdentifier
-		) {
-			return;
-		}
-
-		for (const {identifier} of variable.references) {
-			/** @type {{parent: import('estree').BinaryExpression}} */
-			const binaryExpression = identifier.parent;
-
-			if (binaryExpression.type !== 'BinaryExpression' || binaryExpression.left !== identifier) {
-				continue;
-			}
-
-			const replacement = getReplacement(binaryExpression);
-
-			if (!replacement) {
-				return;
-			}
-
-			const {left, operator, right} = binaryExpression;
-			const {sourceCode} = context;
-
-			const operatorToken = sourceCode.getTokenAfter(
-				left,
-				token => token.type === 'Punctuator' && token.value === operator,
-			);
-
-			const [start] = sourceCode.getRange(operatorToken);
-			const [, end] = sourceCode.getRange(right);
-
-			yield {
-				node: binaryExpression,
-				loc: toLocation([start, end], context),
-				messageId: MESSAGE_ID,
-				data: {
-					...replacement,
-					existenceOrNonExistence: `${replacement.replacementOperator === '===' ? 'non-' : ''}existence`,
-				},
-				* fix(fixer) {
-					yield fixer.replaceText(operatorToken, replacement.replacementOperator);
-
-					if (replacement.replacementValue !== replacement.originalValue) {
-						yield fixer.replaceText(right, replacement.replacementValue);
-					}
-				},
-			};
-		}
-	},
-});
-
-/** @type {import('eslint').Rule.RuleModule} */
-const config = {
-	create,
-	meta: {
-		type: 'problem',
-		docs: {
-			description:
-				'Enforce consistent style for element existence checks with `indexOf()`, `lastIndexOf()`, `findIndex()`, and `findLastIndex()`.',
-			recommended: 'unopinionated',
-		},
-		fixable: 'code',
-		messages,
-	},
-};
-
-export default config;

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/consistent-function-scoping.js

@@ -1,265 +0,0 @@
-import {getFunctionHeadLocation, getFunctionNameWithKind} from '@eslint-community/eslint-utils';
-import {getReferences, isNodeMatches} from './utils/index.js';
-import {functionTypes} from './ast/index.js';
-
-const MESSAGE_ID = 'consistent-function-scoping';
-const messages = {
-	[MESSAGE_ID]: 'Move {{functionNameWithKind}} to the outer scope.',
-};
-
-const isSameScope = (scope1, scope2) =>
-	scope1 && scope2 && (scope1 === scope2 || scope1.block === scope2.block);
-
-function checkReferences(scope, parent, scopeManager) {
-	const hitReference = references => references.some(reference => {
-		if (isSameScope(parent, reference.from)) {
-			return true;
-		}
-
-		const {resolved} = reference;
-		const [definition] = resolved.defs;
-
-		// Skip recursive function name
-		if (definition?.type === 'FunctionName' && resolved.name === definition.name.name) {
-			return false;
-		}
-
-		return isSameScope(parent, resolved.scope);
-	});
-
-	const hitDefinitions = definitions => definitions.some(definition => {
-		const scope = scopeManager.acquire(definition.node);
-		return isSameScope(parent, scope);
-	});
-
-	// This check looks for neighboring function definitions
-	const hitIdentifier = identifiers => identifiers.some(identifier => {
-		// Only look at identifiers that live in a FunctionDeclaration
-		if (
-			!identifier.parent
-			|| identifier.parent.type !== 'FunctionDeclaration'
-		) {
-			return false;
-		}
-
-		const identifierScope = scopeManager.acquire(identifier);
-
-		// If we have a scope, the earlier checks should have worked so ignore them here
-		/* c8 ignore next 3 */
-		if (identifierScope) {
-			return false;
-		}
-
-		const identifierParentScope = scopeManager.acquire(identifier.parent);
-		/* c8 ignore next 3 */
-		if (!identifierParentScope) {
-			return false;
-		}
-
-		// Ignore identifiers from our own scope
-		if (isSameScope(scope, identifierParentScope)) {
-			return false;
-		}
-
-		// Look at the scope above the function definition to see if lives
-		// next to the reference being checked
-		return isSameScope(parent, identifierParentScope.upper);
-	});
-
-	return getReferences(scope)
-		.map(({resolved}) => resolved)
-		.filter(Boolean)
-		.some(variable =>
-			hitReference(variable.references)
-			|| hitDefinitions(variable.defs)
-			|| hitIdentifier(variable.identifiers),
-		);
-}
-
-// https://reactjs.org/docs/hooks-reference.html
-const reactHooks = [
-	'useState',
-	'useEffect',
-	'useContext',
-	'useReducer',
-	'useCallback',
-	'useMemo',
-	'useRef',
-	'useImperativeHandle',
-	'useLayoutEffect',
-	'useDebugValue',
-].flatMap(hookName => [hookName, `React.${hookName}`]);
-
-const isReactHook = scope =>
-	scope.block?.parent?.callee
-	&& isNodeMatches(scope.block.parent.callee, reactHooks);
-
-const isArrowFunctionWithThis = scope =>
-	scope.type === 'function'
-	&& scope.block?.type === 'ArrowFunctionExpression'
-	&& (scope.thisFound || scope.childScopes.some(scope => isArrowFunctionWithThis(scope)));
-
-const iifeFunctionTypes = new Set([
-	'FunctionExpression',
-	'ArrowFunctionExpression',
-]);
-const isIife = node =>
-	iifeFunctionTypes.has(node.type)
-	&& node.parent.type === 'CallExpression'
-	&& node.parent.callee === node;
-
-// Helper to walk up the chain to find the first non-arrow ancestor
-function getNonArrowAncestor(node) {
-	let ancestor = node;
-	while (ancestor && ancestor.type === 'ArrowFunctionExpression') {
-		ancestor = ancestor.parent;
-	}
-
-	return ancestor;
-}
-
-// Helper to skip over a chain of ArrowFunctionExpression nodes
-function skipArrowFunctionChain(node) {
-	let current = node;
-	while (current.type === 'ArrowFunctionExpression') {
-		current = current.parent;
-	}
-
-	return current;
-}
-
-function handleNestedArrowFunctions(parentNode, node) {
-	// Skip over arrow function expressions when they are parents and we came from a ReturnStatement
-	// This handles nested arrow functions: return next => action => { ... }
-	// But only when we're in a return statement context
-	if (parentNode.type === 'ArrowFunctionExpression' && node.type === 'ArrowFunctionExpression') {
-		const ancestor = getNonArrowAncestor(parentNode);
-		if (ancestor && ancestor.type === 'ReturnStatement') {
-			parentNode = skipArrowFunctionChain(parentNode);
-			if (parentNode.type === 'ReturnStatement') {
-				parentNode = parentNode.parent;
-			}
-		}
-	}
-
-	return parentNode;
-}
-
-function checkNode(node, scopeManager) {
-	const scope = scopeManager.acquire(node);
-
-	if (!scope || isArrowFunctionWithThis(scope)) {
-		return true;
-	}
-
-	let parentNode = node.parent;
-
-	// Skip over junk like the block statement inside of a function declaration
-	// or the various pieces of an arrow function.
-
-	if (parentNode.type === 'VariableDeclarator') {
-		parentNode = parentNode.parent;
-	}
-
-	if (parentNode.type === 'VariableDeclaration') {
-		parentNode = parentNode.parent;
-	}
-
-	// Only skip ReturnStatement for arrow functions
-	// Regular function expressions have different semantics and shouldn't be moved
-	if (parentNode?.type === 'ReturnStatement' && node.type === 'ArrowFunctionExpression') {
-		parentNode = parentNode.parent;
-	}
-
-	parentNode = handleNestedArrowFunctions(parentNode, node);
-
-	if (parentNode?.type === 'BlockStatement') {
-		parentNode = parentNode.parent;
-	}
-
-	const parentScope = scopeManager.acquire(parentNode);
-	if (
-		!parentScope
-		|| parentScope.type === 'global'
-		|| isReactHook(parentScope)
-		|| isIife(parentNode)
-	) {
-		return true;
-	}
-
-	return checkReferences(scope, parentScope, scopeManager);
-}
-
-/** @param {import('eslint').Rule.RuleContext} context */
-const create = context => {
-	const {checkArrowFunctions} = {checkArrowFunctions: true, ...context.options[0]};
-	const {sourceCode} = context;
-	const {scopeManager} = sourceCode;
-
-	const functions = [];
-
-	context.on(functionTypes, () => {
-		functions.push(false);
-	});
-
-	context.on('JSXElement', () => {
-		// Turn off this rule if we see a JSX element because scope
-		// references does not include JSXElement nodes.
-		if (functions.length > 0) {
-			functions[functions.length - 1] = true;
-		}
-	});
-
-	context.onExit(functionTypes, node => {
-		const currentFunctionHasJsx = functions.pop();
-		if (currentFunctionHasJsx) {
-			return;
-		}
-
-		if (node.type === 'ArrowFunctionExpression' && !checkArrowFunctions) {
-			return;
-		}
-
-		if (checkNode(node, scopeManager)) {
-			return;
-		}
-
-		return {
-			node,
-			loc: getFunctionHeadLocation(node, sourceCode),
-			messageId: MESSAGE_ID,
-			data: {
-				functionNameWithKind: getFunctionNameWithKind(node, sourceCode),
-			},
-		};
-	});
-};
-
-const schema = [
-	{
-		type: 'object',
-		additionalProperties: false,
-		properties: {
-			checkArrowFunctions: {
-				type: 'boolean',
-			},
-		},
-	},
-];
-
-/** @type {import('eslint').Rule.RuleModule} */
-const config = {
-	create,
-	meta: {
-		type: 'suggestion',
-		docs: {
-			description: 'Move function definitions to the highest possible scope.',
-			recommended: true,
-		},
-		schema,
-		defaultOptions: [{checkArrowFunctions: true}],
-		messages,
-	},
-};
-
-export default config;