@alexlit/lint-kit 176.0.1 → 177.0.0

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/no-accessor-recursion.js

@@ -1,160 +0,0 @@
-const MESSAGE_ID_ERROR = 'no-accessor-recursion/error';
-const messages = {
-	[MESSAGE_ID_ERROR]: 'Disallow recursive access to `this` within {{kind}}ters.',
-};
-
-/**
-Get the closest non-arrow function scope.
-
-@param {import('eslint').SourceCode} sourceCode
-@param {import('estree').Node} node
-@return {import('eslint').Scope.Scope | undefined}
-*/
-const getClosestFunctionScope = (sourceCode, node) => {
-	for (let scope = sourceCode.getScope(node); scope; scope = scope.upper) {
-		if (scope.type === 'class') {
-			return;
-		}
-
-		if (scope.type === 'function' && scope.block.type !== 'ArrowFunctionExpression') {
-			return scope;
-		}
-	}
-};
-
-/** @param {import('estree').Identifier | import('estree').PrivateIdentifier} node */
-const isIdentifier = node => node.type === 'Identifier' || node.type === 'PrivateIdentifier';
-
-/** @param {import('estree').ThisExpression} node */
-const isDotNotationAccess = node =>
-	node.parent.type === 'MemberExpression'
-	&& node.parent.object === node
-	&& !node.parent.computed
-	&& isIdentifier(node.parent.property);
-
-/**
-Check if a property is a valid getter or setter.
-
-@param {import('estree').Property | import('estree').MethodDefinition} property
-*/
-const isValidProperty = property =>
-	['Property', 'MethodDefinition'].includes(property?.type)
-	&& !property.computed
-	&& ['set', 'get'].includes(property.kind)
-	&& isIdentifier(property.key);
-
-/**
-Check if two property keys are the same.
-
-@param {import('estree').Property['key']} keyLeft
-@param {import('estree').Property['key']} keyRight
-*/
-const isSameKey = (keyLeft, keyRight) => ['type', 'name'].every(key => keyLeft[key] === keyRight[key]);
-
-/**
-Check if `this` is accessed recursively within a getter or setter.
-
-@param {import('estree').ThisExpression} node
-@param {import('estree').Property | import('estree').MethodDefinition} property
-*/
-const isMemberAccess = (node, property) =>
-	isDotNotationAccess(node)
-	&& isSameKey(node.parent.property, property.key);
-
-/**
-Check if `this` is accessed recursively within a destructuring assignment.
-
-@param {import('estree').ThisExpression} node
-@param {import('estree').Property | import('estree').MethodDefinition} property
-*/
-const isRecursiveDestructuringAccess = (node, property) =>
-	node.parent.type === 'VariableDeclarator'
-	&& node.parent.init === node
-	&& node.parent.id.type === 'ObjectPattern'
-	&& node.parent.id.properties.some(declaratorProperty =>
-		declaratorProperty.type === 'Property'
-		&& !declaratorProperty.computed
-		&& isSameKey(declaratorProperty.key, property.key),
-	);
-
-const isPropertyRead = (thisExpression, property) =>
-	isMemberAccess(thisExpression, property)
-	|| isRecursiveDestructuringAccess(thisExpression, property);
-
-const isPropertyWrite = (thisExpression, property) => {
-	if (!isMemberAccess(thisExpression, property)) {
-		return false;
-	}
-
-	const memberExpression = thisExpression.parent;
-	const {parent} = memberExpression;
-
-	// This part is similar to `isLeftHandSide`, try to DRY in future
-	return (
-		// `this.foo = …`
-		// `[this.foo = …] = …`
-		// `({property: this.foo = …] = …)`
-		(
-			(parent.type === 'AssignmentExpression' || parent.type === 'AssignmentPattern')
-			&& parent.left === memberExpression
-		)
-		// `++ this.foo`
-		|| (parent.type === 'UpdateExpression' && parent.argument === memberExpression)
-		// `[this.foo] = …`
-		|| (parent.type === 'ArrayPattern' && parent.elements.includes(memberExpression))
-		// `({property: this.foo} = …)`
-		|| (
-			parent.type === 'Property'
-			&& parent.value === memberExpression
-			&& parent.parent.type === 'ObjectPattern'
-			&& parent.parent.properties.includes(memberExpression.parent)
-		)
-	);
-};
-
-/** @param {import('eslint').Rule.RuleContext} context */
-const create = context => {
-	const {sourceCode} = context;
-
-	return {
-		/** @param {import('estree').ThisExpression} thisExpression */
-		ThisExpression(thisExpression) {
-			const scope = getClosestFunctionScope(sourceCode, thisExpression);
-
-			if (!scope) {
-				return;
-			}
-
-			/** @type {import('estree').Property | import('estree').MethodDefinition} */
-			const property = scope.block.parent;
-
-			if (!isValidProperty(property)) {
-				return;
-			}
-
-			if (property.kind === 'get' && isPropertyRead(thisExpression, property)) {
-				return {node: thisExpression.parent, messageId: MESSAGE_ID_ERROR, data: {kind: property.kind}};
-			}
-
-			if (property.kind === 'set' && isPropertyWrite(thisExpression, property)) {
-				return {node: thisExpression.parent, messageId: MESSAGE_ID_ERROR, data: {kind: property.kind}};
-			}
-		},
-	};
-};
-
-/** @type {import('eslint').Rule.RuleModule} */
-const config = {
-	create,
-	meta: {
-		type: 'problem',
-		docs: {
-			description: 'Disallow recursive access to `this` within getters and setters.',
-			recommended: 'unopinionated',
-		},
-		defaultOptions: [],
-		messages,
-	},
-};
-
-export default config;

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/no-anonymous-default-export.js

@@ -1,210 +0,0 @@
-import path from 'node:path';
-import {getFunctionHeadLocation, getFunctionNameWithKind, isOpeningParenToken} from '@eslint-community/eslint-utils';
-import helperValidatorIdentifier from '@babel/helper-validator-identifier';
-import {camelCase} from 'change-case';
-import getClassHeadLocation from './utils/get-class-head-location.js';
-import {getParenthesizedRange} from './utils/parentheses.js';
-import {getScopes, getAvailableVariableName, upperFirst} from './utils/index.js';
-import {isMemberExpression} from './ast/index.js';
-
-const {isIdentifierName} = helperValidatorIdentifier;
-
-const MESSAGE_ID_ERROR = 'no-anonymous-default-export/error';
-const MESSAGE_ID_SUGGESTION = 'no-anonymous-default-export/suggestion';
-const messages = {
-	[MESSAGE_ID_ERROR]: 'The {{description}} should be named.',
-	[MESSAGE_ID_SUGGESTION]: 'Name it as `{{name}}`.',
-};
-
-const isClassKeywordToken = token => token.type === 'Keyword' && token.value === 'class';
-const isAnonymousClassOrFunction = node =>
-	(
-		(
-			node.type === 'FunctionDeclaration'
-			|| node.type === 'FunctionExpression'
-			|| node.type === 'ClassDeclaration'
-			|| node.type === 'ClassExpression'
-		)
-		&& !node.id
-	)
-	|| node.type === 'ArrowFunctionExpression';
-
-function getSuggestionName(node, filename, sourceCode) {
-	if (filename === '<input>' || filename === '<text>') {
-		return;
-	}
-
-	let [name] = path.basename(filename).split('.');
-	name = camelCase(name);
-
-	if (!isIdentifierName(name)) {
-		return;
-	}
-
-	name = node.type === 'ClassDeclaration' || node.type === 'ClassExpression' ? upperFirst(name) : name;
-	name = getAvailableVariableName(name, getScopes(sourceCode.getScope(node)));
-
-	return name;
-}
-
-function addName(fixer, node, name, context) {
-	const {sourceCode} = context;
-	switch (node.type) {
-		case 'ClassDeclaration':
-		case 'ClassExpression': {
-			const lastDecorator = node.decorators?.at(-1);
-			const classToken = lastDecorator
-				? sourceCode.getTokenAfter(lastDecorator, isClassKeywordToken)
-				: sourceCode.getFirstToken(node, isClassKeywordToken);
-			return fixer.insertTextAfter(classToken, ` ${name}`);
-		}
-
-		case 'FunctionDeclaration':
-		case 'FunctionExpression': {
-			const openingParenthesisToken = sourceCode.getFirstToken(
-				node,
-				isOpeningParenToken,
-			);
-			const characterBefore = sourceCode.text.charAt(sourceCode.getRange(openingParenthesisToken)[0] - 1);
-			return fixer.insertTextBefore(
-				openingParenthesisToken,
-				`${characterBefore === ' ' ? '' : ' '}${name} `,
-			);
-		}
-
-		case 'ArrowFunctionExpression': {
-			const [exportDeclarationStart, exportDeclarationEnd]
-				= sourceCode.getRange(
-					node.parent.type === 'ExportDefaultDeclaration'
-						? node.parent
-						: node.parent.parent,
-				);
-			const [arrowFunctionStart, arrowFunctionEnd] = getParenthesizedRange(node, context);
-
-			let textBefore = sourceCode.text.slice(exportDeclarationStart, arrowFunctionStart);
-			let textAfter = sourceCode.text.slice(arrowFunctionEnd, exportDeclarationEnd);
-
-			textBefore = `\n${textBefore}`;
-			if (!/\s$/.test(textBefore)) {
-				textBefore = `${textBefore} `;
-			}
-
-			if (!textAfter.endsWith(';')) {
-				textAfter = `${textAfter};`;
-			}
-
-			return [
-				fixer.replaceTextRange(
-					[exportDeclarationStart, arrowFunctionStart],
-					`const ${name} = `,
-				),
-				fixer.replaceTextRange(
-					[arrowFunctionEnd, exportDeclarationEnd],
-					';',
-				),
-				fixer.insertTextAfterRange(
-					[exportDeclarationEnd, exportDeclarationEnd],
-					`${textBefore}${name}${textAfter}`,
-				),
-			];
-		}
-
-		// No default
-	}
-}
-
-function getProblem(node, context) {
-	const {sourceCode, physicalFilename} = context;
-
-	const suggestionName = getSuggestionName(node, physicalFilename, sourceCode);
-
-	let loc;
-	let description;
-	if (node.type === 'ClassDeclaration' || node.type === 'ClassExpression') {
-		loc = getClassHeadLocation(node, context);
-		description = 'class';
-	} else {
-		loc = getFunctionHeadLocation(node, sourceCode);
-		// [TODO: @fisker]: Ask `@eslint-community/eslint-utils` to expose `getFunctionKind`
-		const nameWithKind = getFunctionNameWithKind(node);
-		description = nameWithKind.replace(/ '.*?'$/, '');
-	}
-
-	const problem = {
-		node,
-		loc,
-		messageId: MESSAGE_ID_ERROR,
-		data: {
-			description,
-		},
-	};
-
-	if (!suggestionName) {
-		return problem;
-	}
-
-	problem.suggest = [
-		{
-			messageId: MESSAGE_ID_SUGGESTION,
-			data: {
-				name: suggestionName,
-			},
-			fix: fixer => addName(fixer, node, suggestionName, context),
-		},
-	];
-
-	return problem;
-}
-
-/** @param {import('eslint').Rule.RuleContext} context */
-const create = context => {
-	context.on('ExportDefaultDeclaration', node => {
-		if (!isAnonymousClassOrFunction(node.declaration)) {
-			return;
-		}
-
-		return getProblem(node.declaration, context);
-	});
-
-	context.on('AssignmentExpression', node => {
-		if (
-			!isAnonymousClassOrFunction(node.right)
-			|| !(
-				node.parent.type === 'ExpressionStatement'
-				&& node.parent.expression === node
-			)
-			|| !(
-				isMemberExpression(node.left, {
-					object: 'module',
-					property: 'exports',
-					computed: false,
-					optional: false,
-				})
-				|| (
-					node.left.type === 'Identifier',
-					node.left.name === 'exports'
-				)
-			)
-		) {
-			return;
-		}
-
-		return getProblem(node.right, context);
-	});
-};
-
-/** @type {import('eslint').Rule.RuleModule} */
-const config = {
-	create,
-	meta: {
-		type: 'suggestion',
-		docs: {
-			description: 'Disallow anonymous functions and classes as the default export.',
-			recommended: 'unopinionated',
-		},
-		hasSuggestions: true,
-		messages,
-	},
-};
-
-export default config;

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/no-array-callback-reference.js

@@ -1,285 +0,0 @@
-import {isMethodCall} from './ast/index.js';
-import {
-	isNodeMatches,
-	isNodeValueNotFunction,
-	isParenthesized,
-	getParenthesizedRange,
-	getParenthesizedText,
-	shouldAddParenthesesToCallExpressionCallee,
-} from './utils/index.js';
-
-const ERROR_WITH_NAME_MESSAGE_ID = 'error-with-name';
-const ERROR_WITHOUT_NAME_MESSAGE_ID = 'error-without-name';
-const REPLACE_WITH_NAME_MESSAGE_ID = 'replace-with-name';
-const REPLACE_WITHOUT_NAME_MESSAGE_ID = 'replace-without-name';
-const messages = {
-	[ERROR_WITH_NAME_MESSAGE_ID]: 'Do not pass function `{{name}}` directly to `.{{method}}(…)`.',
-	[ERROR_WITHOUT_NAME_MESSAGE_ID]: 'Do not pass function directly to `.{{method}}(…)`.',
-	[REPLACE_WITH_NAME_MESSAGE_ID]: 'Replace function `{{name}}` with `… => {{name}}({{parameters}})`.',
-	[REPLACE_WITHOUT_NAME_MESSAGE_ID]: 'Replace function with `… => …({{parameters}})`.',
-};
-
-const isAwaitExpressionArgument = node => node.parent.type === 'AwaitExpression' && node.parent.argument === node;
-
-const iteratorMethods = new Map([
-	{
-		method: 'every',
-		ignore: [
-			'Boolean',
-		],
-	},
-	{
-		method: 'filter',
-		shouldIgnoreCallExpression: node => (node.callee.object.type === 'Identifier' && node.callee.object.name === 'Vue'),
-		ignore: [
-			'Boolean',
-		],
-	},
-	{
-		method: 'find',
-		ignore: [
-			'Boolean',
-		],
-	},
-	{
-		method: 'findLast',
-		ignore: [
-			'Boolean',
-		],
-	},
-	{
-		method: 'findIndex',
-		ignore: [
-			'Boolean',
-		],
-	},
-	{
-		method: 'findLastIndex',
-		ignore: [
-			'Boolean',
-		],
-	},
-	{
-		method: 'flatMap',
-	},
-	{
-		method: 'forEach',
-		returnsUndefined: true,
-	},
-	{
-		method: 'map',
-		shouldIgnoreCallExpression: node => (node.callee.object.type === 'Identifier' && node.callee.object.name === 'types'),
-		ignore: [
-			'String',
-			'Number',
-			'BigInt',
-			'Boolean',
-			'Symbol',
-		],
-	},
-	{
-		method: 'reduce',
-		parameters: [
-			'accumulator',
-			'element',
-			'index',
-			'array',
-		],
-		minParameters: 2,
-	},
-	{
-		method: 'reduceRight',
-		parameters: [
-			'accumulator',
-			'element',
-			'index',
-			'array',
-		],
-		minParameters: 2,
-	},
-	{
-		method: 'some',
-		ignore: [
-			'Boolean',
-		],
-	},
-].map(({
-	method,
-	parameters = ['element', 'index', 'array'],
-	ignore = [],
-	minParameters = 1,
-	returnsUndefined = false,
-	shouldIgnoreCallExpression,
-}) => [method, {
-	minParameters,
-	parameters,
-	returnsUndefined,
-	shouldIgnoreCallExpression(callExpression) {
-		if (
-			method !== 'reduce'
-			&& method !== 'reduceRight'
-			&& isAwaitExpressionArgument(callExpression)
-		) {
-			return true;
-		}
-
-		if (isNodeMatches(callExpression.callee.object, ignoredCallee)) {
-			return true;
-		}
-
-		if (
-			callExpression.callee.object.type === 'CallExpression'
-			&& isNodeMatches(callExpression.callee.object.callee, ignoredCallee)
-		) {
-			return true;
-		}
-
-		return shouldIgnoreCallExpression?.(callExpression) ?? false;
-	},
-	shouldIgnoreCallback(callback) {
-		if (callback.type === 'Identifier' && ignore.includes(callback.name)) {
-			return true;
-		}
-
-		return false;
-	},
-}]));
-
-const ignoredCallee = [
-	// http://bluebirdjs.com/docs/api/promise.map.html
-	'Promise',
-	'React.Children',
-	'Children',
-	'lodash',
-	'underscore',
-	'_',
-	'Async',
-	'async',
-	'this',
-	'$',
-	'jQuery',
-];
-
-function getProblem(context, node, method, options) {
-	const {type} = node;
-
-	const name = type === 'Identifier' ? node.name : '';
-
-	const problem = {
-		node,
-		messageId: name ? ERROR_WITH_NAME_MESSAGE_ID : ERROR_WITHOUT_NAME_MESSAGE_ID,
-		data: {
-			name,
-			method,
-		},
-	};
-
-	if (node.type === 'YieldExpression' || node.type === 'AwaitExpression') {
-		return problem;
-	}
-
-	problem.suggest = [];
-
-	const {parameters, minParameters, returnsUndefined} = options;
-	for (let parameterLength = minParameters; parameterLength <= parameters.length; parameterLength++) {
-		const suggestionParameters = parameters.slice(0, parameterLength).join(', ');
-
-		const suggest = {
-			messageId: name ? REPLACE_WITH_NAME_MESSAGE_ID : REPLACE_WITHOUT_NAME_MESSAGE_ID,
-			data: {
-				name,
-				parameters: suggestionParameters,
-			},
-			fix(fixer) {
-				let text = getParenthesizedText(node, context);
-
-				if (
-					!isParenthesized(node, context.sourceCode)
-					&& shouldAddParenthesesToCallExpressionCallee(node)
-				) {
-					text = `(${text})`;
-				}
-
-				return fixer.replaceTextRange(
-					getParenthesizedRange(node, context),
-					returnsUndefined
-						? `(${suggestionParameters}) => { ${text}(${suggestionParameters}); }`
-						: `(${suggestionParameters}) => ${text}(${suggestionParameters})`,
-				);
-			},
-		};
-
-		problem.suggest.push(suggest);
-	}
-
-	return problem;
-}
-
-function * getTernaryConsequentAndALternate(node) {
-	if (node.type === 'ConditionalExpression') {
-		yield * getTernaryConsequentAndALternate(node.consequent);
-		yield * getTernaryConsequentAndALternate(node.alternate);
-		return;
-	}
-
-	yield node;
-}
-
-/** @param {import('eslint').Rule.RuleContext} context */
-const create = context => ({
-	* CallExpression(callExpression) {
-		if (
-			!isMethodCall(callExpression, {
-				minimumArguments: 1,
-				maximumArguments: 2,
-				optionalCall: false,
-				computed: false,
-			})
-			|| callExpression.callee.property.type !== 'Identifier'
-		) {
-			return;
-		}
-
-		const methodNode = callExpression.callee.property;
-		const methodName = methodNode.name;
-		if (!iteratorMethods.has(methodName)) {
-			return;
-		}
-
-		const options = iteratorMethods.get(methodName);
-		if (options.shouldIgnoreCallExpression(callExpression)) {
-			return;
-		}
-
-		for (const callback of getTernaryConsequentAndALternate(callExpression.arguments[0])) {
-			if (
-				callback.type === 'FunctionExpression'
-				|| callback.type === 'ArrowFunctionExpression'
-				// Ignore all `CallExpression`s include `function.bind()`
-				|| callback.type === 'CallExpression'
-				|| options.shouldIgnoreCallback(callback)
-				|| isNodeValueNotFunction(callback)
-			) {
-				continue;
-			}
-
-			yield getProblem(context, callback, methodName, options);
-		}
-	},
-});
-
-/** @type {import('eslint').Rule.RuleModule} */
-const config = {
-	create,
-	meta: {
-		type: 'problem',
-		docs: {
-			description: 'Prevent passing a function reference directly to iterator methods.',
-			recommended: true,
-		},
-		hasSuggestions: true,
-		messages,
-	},
-};
-
-export default config;