@alexlit/lint-kit 176.0.0 → 177.0.0

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/no-static-only-class.js

@@ -1,226 +0,0 @@
-import {isSemicolonToken} from '@eslint-community/eslint-utils';
-import getClassHeadLocation from './utils/get-class-head-location.js';
-import assertToken from './utils/assert-token.js';
-import {removeSpacesAfter} from './fix/index.js';
-
-const MESSAGE_ID = 'no-static-only-class';
-const messages = {
-	[MESSAGE_ID]: 'Use an object instead of a class with only static members.',
-};
-
-const isEqualToken = ({type, value}) => type === 'Punctuator' && value === '=';
-const isDeclarationOfExportDefaultDeclaration = node =>
-	node.type === 'ClassDeclaration'
-	&& node.parent.type === 'ExportDefaultDeclaration'
-	&& node.parent.declaration === node;
-
-const isPropertyDefinition = node => node.type === 'PropertyDefinition';
-const isMethodDefinition = node => node.type === 'MethodDefinition';
-
-function isStaticMember(node) {
-	const {
-		private: isPrivate,
-		static: isStatic,
-		declare: isDeclare,
-		readonly: isReadonly,
-		accessibility,
-		decorators,
-		key,
-	} = node;
-
-	// Avoid matching unexpected node. For example: https://github.com/tc39/proposal-class-static-block
-	if (!isPropertyDefinition(node) && !isMethodDefinition(node)) {
-		return false;
-	}
-
-	if (!isStatic || isPrivate || key.type === 'PrivateIdentifier') {
-		return false;
-	}
-
-	// TypeScript class
-	if (
-		isDeclare
-		|| isReadonly
-		|| accessibility !== undefined
-		|| (Array.isArray(decorators) && decorators.length > 0)
-	) {
-		return false;
-	}
-
-	return true;
-}
-
-function * switchClassMemberToObjectProperty(node, context, fixer) {
-	const {sourceCode} = context;
-	const staticToken = sourceCode.getFirstToken(node);
-	assertToken(staticToken, {
-		expected: {type: 'Keyword', value: 'static'},
-		ruleId: 'no-static-only-class',
-	});
-
-	yield fixer.remove(staticToken);
-	yield removeSpacesAfter(staticToken, context, fixer);
-
-	const maybeSemicolonToken = isPropertyDefinition(node)
-		? sourceCode.getLastToken(node)
-		: sourceCode.getTokenAfter(node);
-	const hasSemicolonToken = isSemicolonToken(maybeSemicolonToken);
-
-	if (isPropertyDefinition(node)) {
-		const {key, value} = node;
-
-		if (value) {
-			// Computed key may have `]` after `key`
-			const equalToken = sourceCode.getTokenAfter(key, isEqualToken);
-			yield fixer.replaceText(equalToken, ':');
-		} else if (hasSemicolonToken) {
-			yield fixer.insertTextBefore(maybeSemicolonToken, ': undefined');
-		} else {
-			yield fixer.insertTextAfter(node, ': undefined');
-		}
-	}
-
-	yield (
-		hasSemicolonToken
-			? fixer.replaceText(maybeSemicolonToken, ',')
-			: fixer.insertTextAfter(node, ',')
-	);
-}
-
-function switchClassToObject(node, context) {
-	const {
-		type,
-		id,
-		body,
-		declare: isDeclare,
-		abstract: isAbstract,
-		implements: classImplements,
-		parent,
-	} = node;
-
-	if (
-		isDeclare
-		|| isAbstract
-		|| (Array.isArray(classImplements) && classImplements.length > 0)
-	) {
-		return;
-	}
-
-	if (type === 'ClassExpression' && id) {
-		return;
-	}
-
-	const isExportDefault = isDeclarationOfExportDefaultDeclaration(node);
-
-	if (isExportDefault && id) {
-		return;
-	}
-
-	const {sourceCode} = context;
-	for (const node of body.body) {
-		if (
-			isPropertyDefinition(node)
-			&& (
-				node.typeAnnotation
-				// This is a stupid way to check if `value` of `PropertyDefinition` uses `this`
-				|| (node.value && sourceCode.getText(node.value).includes('this'))
-			)
-		) {
-			return;
-		}
-	}
-
-	return function * (fixer) {
-		const classToken = sourceCode.getFirstToken(node);
-		/* c8 ignore next */
-		assertToken(classToken, {
-			expected: {type: 'Keyword', value: 'class'},
-			ruleId: 'no-static-only-class',
-		});
-
-		if (isExportDefault || type === 'ClassExpression') {
-			/*
-				There are comments after return, and `{` is not on same line
-
-				```js
-				function a() {
-					return class // comment
-					{
-						static a() {}
-					}
-				}
-				```
-			*/
-			if (
-				type === 'ClassExpression'
-				&& parent.type === 'ReturnStatement'
-				&& sourceCode.getLoc(body).start.line !== sourceCode.getLoc(parent).start.line
-				&& sourceCode.text.slice(sourceCode.getRange(classToken)[1], sourceCode.getRange(body)[0]).trim()
-			) {
-				yield fixer.replaceText(classToken, '{');
-
-				const openingBraceToken = sourceCode.getFirstToken(body);
-				yield fixer.remove(openingBraceToken);
-			} else {
-				yield fixer.replaceText(classToken, '');
-
-				/*
-						Avoid breaking case like
-
-						```js
-						return class
-						{};
-						```
-				*/
-				yield removeSpacesAfter(classToken, context, fixer);
-			}
-
-			// There should not be ASI problem
-		} else {
-			yield fixer.replaceText(classToken, 'const');
-			yield fixer.insertTextBefore(body, '= ');
-			yield fixer.insertTextAfter(body, ';');
-		}
-
-		for (const node of body.body) {
-			yield switchClassMemberToObjectProperty(node, context, fixer);
-		}
-	};
-}
-
-function create(context) {
-	context.on(['ClassDeclaration', 'ClassExpression'], node => {
-		if (
-			node.superClass
-			|| (node.decorators && node.decorators.length > 0)
-			|| node.body.type !== 'ClassBody'
-			|| node.body.body.length === 0
-			|| node.body.body.some(node => !isStaticMember(node))
-		) {
-			return;
-		}
-
-		return {
-			node,
-			loc: getClassHeadLocation(node, context),
-			messageId: MESSAGE_ID,
-			fix: switchClassToObject(node, context),
-		};
-	});
-}
-
-/** @type {import('eslint').Rule.RuleModule} */
-const config = {
-	create,
-	meta: {
-		type: 'suggestion',
-		docs: {
-			description: 'Disallow classes that only have static members.',
-			recommended: 'unopinionated',
-		},
-		fixable: 'code',
-		messages,
-	},
-};
-
-export default config;

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

@@ -1,194 +0,0 @@
-import {getStaticValue, getPropertyName} from '@eslint-community/eslint-utils';
-import {isMethodCall} from './ast/index.js';
-
-const MESSAGE_ID_OBJECT = 'no-thenable-object';
-const MESSAGE_ID_EXPORT = 'no-thenable-export';
-const MESSAGE_ID_CLASS = 'no-thenable-class';
-const messages = {
-	[MESSAGE_ID_OBJECT]: 'Do not add `then` to an object.',
-	[MESSAGE_ID_EXPORT]: 'Do not export `then`.',
-	[MESSAGE_ID_CLASS]: 'Do not add `then` to a class.',
-};
-
-const isStringThen = (node, context) =>
-	getStaticValue(node, context.sourceCode.getScope(node))?.value === 'then';
-
-const isPropertyThen = (node, context) =>
-	getPropertyName(node, context.sourceCode.getScope(node)) === 'then';
-
-const cases = [
-	// `{then() {}}`,
-	// `{get then() {}}`,
-	// `{[computedKey]() {}}`,
-	// `{get [computedKey]() {}}`,
-	{
-		selector: 'ObjectExpression',
-		* getNodes(node, context) {
-			for (const property of node.properties) {
-				if (property.type === 'Property' && isPropertyThen(property, context)) {
-					yield property.key;
-				}
-			}
-		},
-		messageId: MESSAGE_ID_OBJECT,
-	},
-	// `class Foo {then}`,
-	// `class Foo {static then}`,
-	// `class Foo {get then() {}}`,
-	// `class Foo {static get then() {}}`,
-	{
-		selectors: ['PropertyDefinition', 'MethodDefinition'],
-		* getNodes(node, context) {
-			if (getPropertyName(node, context.sourceCode.getScope(node)) === 'then') {
-				yield node.key;
-			}
-		},
-		messageId: MESSAGE_ID_CLASS,
-	},
-	// `foo.then = …`
-	// `foo[computedKey] = …`
-	{
-		selector: 'MemberExpression',
-		* getNodes(node, context) {
-			if (!(node.parent.type === 'AssignmentExpression' && node.parent.left === node)) {
-				return;
-			}
-
-			if (getPropertyName(node, context.sourceCode.getScope(node)) === 'then') {
-				yield node.property;
-			}
-		},
-		messageId: MESSAGE_ID_OBJECT,
-	},
-	// `Object.defineProperty(foo, 'then', …)`
-	// `Reflect.defineProperty(foo, 'then', …)`
-	{
-		selector: 'CallExpression',
-		* getNodes(node, context) {
-			if (!(
-				isMethodCall(node, {
-					objects: ['Object', 'Reflect'],
-					method: 'defineProperty',
-					minimumArguments: 3,
-					optionalCall: false,
-					optionalMember: false,
-				})
-				&& node.arguments[0].type !== 'SpreadElement'
-			)) {
-				return;
-			}
-
-			const [, secondArgument] = node.arguments;
-			if (isStringThen(secondArgument, context)) {
-				yield secondArgument;
-			}
-		},
-		messageId: MESSAGE_ID_OBJECT,
-	},
-	// `Object.fromEntries([['then', …]])`
-	{
-		selector: 'CallExpression',
-		* getNodes(node, context) {
-			if (!(
-				isMethodCall(node, {
-					object: 'Object',
-					method: 'fromEntries',
-					argumentsLength: 1,
-					optionalCall: false,
-					optionalMember: false,
-				})
-				&& node.arguments[0].type === 'ArrayExpression'
-			)) {
-				return;
-			}
-
-			for (const pairs of node.arguments[0].elements) {
-				if (
-					pairs?.type === 'ArrayExpression'
-					&& pairs.elements[0]
-					&& pairs.elements[0].type !== 'SpreadElement'
-				) {
-					const [key] = pairs.elements;
-
-					if (isStringThen(key, context)) {
-						yield key;
-					}
-				}
-			}
-		},
-		messageId: MESSAGE_ID_OBJECT,
-	},
-	// `export {then}`
-	{
-		selector: 'Identifier',
-		* getNodes(node) {
-			if (
-				node.name === 'then'
-				&& node.parent.type === 'ExportSpecifier'
-				&& node.parent.exported === node
-			) {
-				yield node;
-			}
-		},
-		messageId: MESSAGE_ID_EXPORT,
-	},
-	// `export function then() {}`,
-	// `export class then {}`,
-	{
-		selector: 'Identifier',
-		* getNodes(node) {
-			if (
-				node.name === 'then'
-				&& (node.parent.type === 'FunctionDeclaration' || node.parent.type === 'ClassDeclaration')
-				&& node.parent.id === node
-				&& node.parent.parent.type === 'ExportNamedDeclaration'
-				&& node.parent.parent.declaration === node.parent
-			) {
-				yield node;
-			}
-		},
-		messageId: MESSAGE_ID_EXPORT,
-	},
-	// `export const … = …`;
-	{
-		selector: 'VariableDeclaration',
-		* getNodes(node, context) {
-			if (!(node.parent.type === 'ExportNamedDeclaration' && node.parent.declaration === node)) {
-				return;
-			}
-
-			for (const variable of context.sourceCode.getDeclaredVariables(node)) {
-				if (variable.name === 'then') {
-					yield * variable.identifiers;
-				}
-			}
-		},
-		messageId: MESSAGE_ID_EXPORT,
-	},
-];
-
-/** @param {import('eslint').Rule.RuleContext} context */
-const create = context => {
-	for (const {selector, selectors, messageId, getNodes} of cases) {
-		context.on(selector ?? selectors, function * (node) {
-			for (const problematicNode of getNodes(node, context)) {
-				yield {node: problematicNode, messageId};
-			}
-		});
-	}
-};
-
-/** @type {import('eslint').Rule.RuleModule} */
-const config = {
-	create,
-	meta: {
-		type: 'problem',
-		docs: {
-			description: 'Disallow `then` property.',
-			recommended: 'unopinionated',
-		},
-		messages,
-	},
-};
-
-export default config;

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/no-this-assignment.js

@@ -1,40 +0,0 @@
-const MESSAGE_ID = 'no-this-assignment';
-const messages = {
-	[MESSAGE_ID]: 'Do not assign `this` to `{{name}}`.',
-};
-
-function getProblem(variableNode, valueNode) {
-	if (
-		variableNode.type !== 'Identifier'
-		|| valueNode?.type !== 'ThisExpression'
-	) {
-		return;
-	}
-
-	return {
-		node: valueNode.parent,
-		data: {name: variableNode.name},
-		messageId: MESSAGE_ID,
-	};
-}
-
-/** @param {import('eslint').Rule.RuleContext} context */
-const create = context => {
-	context.on('VariableDeclarator', node => getProblem(node.id, node.init));
-	context.on('AssignmentExpression', node => getProblem(node.left, node.right));
-};
-
-/** @type {import('eslint').Rule.RuleModule} */
-const config = {
-	create,
-	meta: {
-		type: 'suggestion',
-		docs: {
-			description: 'Disallow assigning `this` to a variable.',
-			recommended: 'unopinionated',
-		},
-		messages,
-	},
-};
-
-export default config;

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

@@ -1,146 +0,0 @@
-import {isLiteral} from './ast/index.js';
-import {
-	addParenthesizesToReturnOrThrowExpression,
-	removeSpacesAfter,
-} from './fix/index.js';
-import {
-	needsSemicolon,
-	isParenthesized,
-	isOnSameLine,
-	isUnresolvedVariable,
-} from './utils/index.js';
-
-const MESSAGE_ID_ERROR = 'no-typeof-undefined/error';
-const MESSAGE_ID_SUGGESTION = 'no-typeof-undefined/suggestion';
-const messages = {
-	[MESSAGE_ID_ERROR]: 'Compare with `undefined` directly instead of using `typeof`.',
-	[MESSAGE_ID_SUGGESTION]: 'Switch to `… {{operator}} undefined`.',
-};
-
-/** @param {import('eslint').Rule.RuleContext} context */
-const create = context => {
-	const {
-		checkGlobalVariables,
-	} = {
-		checkGlobalVariables: false,
-		...context.options[0],
-	};
-
-	const {sourceCode} = context;
-
-	return {
-		BinaryExpression(binaryExpression) {
-			if (!(
-				(
-					binaryExpression.operator === '==='
-					|| binaryExpression.operator === '!=='
-					|| binaryExpression.operator === '=='
-					|| binaryExpression.operator === '!='
-				)
-				&& binaryExpression.left.type === 'UnaryExpression'
-				&& binaryExpression.left.operator === 'typeof'
-				&& binaryExpression.left.prefix
-				&& isLiteral(binaryExpression.right, 'undefined')
-			)) {
-				return;
-			}
-
-			const {left: typeofNode, right: undefinedString, operator} = binaryExpression;
-
-			const valueNode = typeofNode.argument;
-			const isGlobalVariable = valueNode.type === 'Identifier'
-				&& (sourceCode.isGlobalReference(valueNode) || isUnresolvedVariable(valueNode, context));
-
-			if (!checkGlobalVariables && isGlobalVariable) {
-				return;
-			}
-
-			const [typeofToken, secondToken] = sourceCode.getFirstTokens(typeofNode, 2);
-
-			const fix = function * (fixer) {
-				// Change `==`/`!=` to `===`/`!==`
-				if (operator === '==' || operator === '!=') {
-					const operatorToken = sourceCode.getTokenAfter(
-						typeofNode,
-						token => token.type === 'Punctuator' && token.value === operator,
-					);
-
-					yield fixer.insertTextAfter(operatorToken, '=');
-				}
-
-				yield fixer.replaceText(undefinedString, 'undefined');
-
-				yield fixer.remove(typeofToken);
-				yield removeSpacesAfter(typeofToken, context, fixer);
-
-				const {parent} = binaryExpression;
-				if (
-					(parent.type === 'ReturnStatement' || parent.type === 'ThrowStatement')
-					&& parent.argument === binaryExpression
-					&& !isOnSameLine(typeofToken, secondToken, context)
-					&& !isParenthesized(binaryExpression, sourceCode)
-					&& !isParenthesized(typeofNode, sourceCode)
-				) {
-					yield addParenthesizesToReturnOrThrowExpression(fixer, parent, context);
-					return;
-				}
-
-				const tokenBefore = sourceCode.getTokenBefore(binaryExpression);
-				if (needsSemicolon(tokenBefore, context, secondToken.value)) {
-					yield fixer.insertTextBefore(binaryExpression, ';');
-				}
-			};
-
-			const problem = {
-				node: binaryExpression,
-				loc: sourceCode.getLoc(typeofToken),
-				messageId: MESSAGE_ID_ERROR,
-			};
-
-			if (isGlobalVariable) {
-				problem.suggest = [
-					{
-						messageId: MESSAGE_ID_SUGGESTION,
-						data: {operator: operator.startsWith('!') ? '!==' : '==='},
-						fix,
-					},
-				];
-			} else {
-				problem.fix = fix;
-			}
-
-			return problem;
-		},
-	};
-};
-
-const schema = [
-	{
-		type: 'object',
-		additionalProperties: false,
-		properties: {
-			checkGlobalVariables: {
-				type: 'boolean',
-			},
-		},
-	},
-];
-
-/** @type {import('eslint').Rule.RuleModule} */
-const config = {
-	create,
-	meta: {
-		type: 'suggestion',
-		docs: {
-			description: 'Disallow comparing `undefined` using `typeof`.',
-			recommended: 'unopinionated',
-		},
-		fixable: 'code',
-		hasSuggestions: true,
-		schema,
-		defaultOptions: [{checkGlobalVariables: false}],
-		messages,
-	},
-};
-
-export default config;

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/no-unnecessary-array-flat-depth.js

@@ -1,49 +0,0 @@
-import {isMethodCall, isLiteral} from './ast/index.js';
-import {removeArgument} from './fix/index.js';
-
-const MESSAGE_ID = 'no-unnecessary-array-flat-depth';
-const messages = {
-	[MESSAGE_ID]: 'Passing `1` as the `depth` argument is unnecessary.',
-};
-
-/** @param {import('eslint').Rule.RuleContext} context */
-const create = context => {
-	context.on('CallExpression', callExpression => {
-		if (!(
-			isMethodCall(callExpression, {
-				method: 'flat',
-				argumentsLength: 1,
-				optionalCall: false,
-			})
-			&& isLiteral(callExpression.arguments[0], 1)
-		)) {
-			return;
-		}
-
-		const [numberOne] = callExpression.arguments;
-
-		return {
-			node: numberOne,
-			messageId: MESSAGE_ID,
-			/** @param {import('eslint').Rule.RuleFixer} fixer */
-			fix: fixer => removeArgument(fixer, numberOne, context),
-		};
-	});
-};
-
-/** @type {import('eslint').Rule.RuleModule} */
-const config = {
-	create,
-	meta: {
-		type: 'suggestion',
-		docs: {
-			description: 'Disallow using `1` as the `depth` argument of `Array#flat()`.',
-			recommended: 'unopinionated',
-		},
-		fixable: 'code',
-
-		messages,
-	},
-};
-
-export default config;

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/no-unnecessary-array-splice-count.js

@@ -1,23 +0,0 @@
-import {listen} from './shared/no-unnecessary-length-or-infinity-rule.js';
-
-const MESSAGE_ID = 'no-unnecessary-array-splice-count';
-const messages = {
-	[MESSAGE_ID]: 'Passing `{{description}}` as the `{{argumentName}}` argument is unnecessary.',
-};
-
-/** @type {import('eslint').Rule.RuleModule} */
-const config = {
-	create: context => listen(context, {methods: ['splice', 'toSpliced'], messageId: MESSAGE_ID}),
-	meta: {
-		type: 'suggestion',
-		docs: {
-			description: 'Disallow using `.length` or `Infinity` as the `deleteCount` or `skipCount` argument of `Array#{splice,toSpliced}()`.',
-			recommended: 'unopinionated',
-		},
-		fixable: 'code',
-
-		messages,
-	},
-};
-
-export default config;