@alexlit/lint-kit 176.0.1 → 177.0.0

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

@@ -1,128 +0,0 @@
-import {isMethodCall} from './ast/index.js';
-import {isNodeValueNotFunction, isArrayPrototypeProperty} from './utils/index.js';
-
-const MESSAGE_ID_REDUCE = 'reduce';
-const MESSAGE_ID_REDUCE_RIGHT = 'reduceRight';
-const messages = {
-	[MESSAGE_ID_REDUCE]: '`Array#reduce()` is not allowed. Prefer other types of loop for readability.',
-	[MESSAGE_ID_REDUCE_RIGHT]: '`Array#reduceRight()` is not allowed. Prefer other types of loop for readability. You may want to call `Array#toReversed()` before looping it.',
-};
-
-const cases = [
-	// `array.{reduce,reduceRight}()`
-	{
-		test: callExpression =>
-			isMethodCall(callExpression, {
-				methods: ['reduce', 'reduceRight'],
-				minimumArguments: 1,
-				maximumArguments: 2,
-				optionalCall: false,
-			})
-			&& !isNodeValueNotFunction(callExpression.arguments[0]),
-		getMethodNode: callExpression => callExpression.callee.property,
-		isSimpleOperation(callExpression) {
-			const [callback] = callExpression.arguments;
-
-			return (
-				callback
-				&& (
-					// `array.reduce((accumulator, element) => accumulator + element)`
-					(callback.type === 'ArrowFunctionExpression' && callback.body.type === 'BinaryExpression')
-					// `array.reduce((accumulator, element) => {return accumulator + element;})`
-					// `array.reduce(function (accumulator, element){return accumulator + element;})`
-					|| (
-						(callback.type === 'ArrowFunctionExpression' || callback.type === 'FunctionExpression')
-						&& callback.body.type === 'BlockStatement'
-						&& callback.body.body.length === 1
-						&& callback.body.body[0].type === 'ReturnStatement'
-						&& callback.body.body[0].argument.type === 'BinaryExpression'
-					)
-				)
-			);
-		},
-	},
-	// `[].{reduce,reduceRight}.call()` and `Array.{reduce,reduceRight}.call()`
-	{
-		test: callExpression =>
-			isMethodCall(callExpression, {
-				method: 'call',
-				optionalCall: false,
-				optionalMember: false,
-			})
-			&& isArrayPrototypeProperty(callExpression.callee.object, {
-				properties: ['reduce', 'reduceRight'],
-			})
-			&& (
-				!callExpression.arguments[1]
-				|| !isNodeValueNotFunction(callExpression.arguments[1])
-			),
-		getMethodNode: callExpression => callExpression.callee.object.property,
-	},
-	// `[].{reduce,reduceRight}.apply()` and `Array.{reduce,reduceRight}.apply()`
-	{
-		test: callExpression =>
-			isMethodCall(callExpression, {
-				method: 'apply',
-				optionalCall: false,
-				optionalMember: false,
-			})
-			&& isArrayPrototypeProperty(callExpression.callee.object, {
-				properties: ['reduce', 'reduceRight'],
-			}),
-		getMethodNode: callExpression => callExpression.callee.object.property,
-	},
-];
-
-const schema = [
-	{
-		type: 'object',
-		additionalProperties: false,
-		properties: {
-			allowSimpleOperations: {
-				type: 'boolean',
-			},
-		},
-	},
-];
-
-/** @param {import('eslint').Rule.RuleContext} context */
-const create = context => {
-	const {allowSimpleOperations} = {allowSimpleOperations: true, ...context.options[0]};
-
-	return {
-		* CallExpression(callExpression) {
-			for (const {test, getMethodNode, isSimpleOperation} of cases) {
-				if (!test(callExpression)) {
-					continue;
-				}
-
-				if (allowSimpleOperations && isSimpleOperation?.(callExpression)) {
-					continue;
-				}
-
-				const methodNode = getMethodNode(callExpression);
-				yield {
-					node: methodNode,
-					messageId: methodNode.name,
-				};
-			}
-		},
-	};
-};
-
-/** @type {import('eslint').Rule.RuleModule} */
-const config = {
-	create,
-	meta: {
-		type: 'suggestion',
-		docs: {
-			description: 'Disallow `Array#reduce()` and `Array#reduceRight()`.',
-			recommended: true,
-		},
-		schema,
-		defaultOptions: [{allowSimpleOperations: true}],
-		messages,
-	},
-};
-
-export default config;

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

@@ -1,6 +0,0 @@
-import noArrayMutateRule from './shared/no-array-mutate-rule.js';
-
-/** @type {import('eslint').Rule.RuleModule} */
-const config = noArrayMutateRule('reverse');
-
-export default config;

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

@@ -1,6 +0,0 @@
-import noArrayMutateRule from './shared/no-array-mutate-rule.js';
-
-/** @type {import('eslint').Rule.RuleModule} */
-const config = noArrayMutateRule('sort');
-
-export default config;

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/no-await-expression-member.js

@@ -1,85 +0,0 @@
-import {removeParentheses, removeMemberExpressionProperty} from './fix/index.js';
-import {isLiteral} from './ast/index.js';
-
-const MESSAGE_ID = 'no-await-expression-member';
-const messages = {
-	[MESSAGE_ID]: 'Do not access a member directly from an await expression.',
-};
-
-/** @param {import('eslint').Rule.RuleContext} context */
-const create = context => {
-	context.on('MemberExpression', memberExpression => {
-		if (memberExpression.object.type !== 'AwaitExpression') {
-			return;
-		}
-
-		const {property} = memberExpression;
-		const problem = {
-			node: property,
-			messageId: MESSAGE_ID,
-		};
-
-		// `const foo = (await bar)[0]`
-		if (
-			memberExpression.computed
-			&& !memberExpression.optional
-			&& (isLiteral(property, 0) || isLiteral(property, 1))
-			&& memberExpression.parent.type === 'VariableDeclarator'
-			&& memberExpression.parent.init === memberExpression
-			&& memberExpression.parent.id.type === 'Identifier'
-			&& !memberExpression.parent.id.typeAnnotation
-		) {
-			problem.fix = function * (fixer) {
-				const variable = memberExpression.parent.id;
-				yield fixer.insertTextBefore(variable, property.value === 0 ? '[' : '[, ');
-				yield fixer.insertTextAfter(variable, ']');
-
-				yield removeMemberExpressionProperty(fixer, memberExpression, context);
-				yield removeParentheses(memberExpression.object, fixer, context);
-			};
-
-			return problem;
-		}
-
-		// `const foo = (await bar).foo`
-		if (
-			!memberExpression.computed
-			&& !memberExpression.optional
-			&& property.type === 'Identifier'
-			&& memberExpression.parent.type === 'VariableDeclarator'
-			&& memberExpression.parent.init === memberExpression
-			&& memberExpression.parent.id.type === 'Identifier'
-			&& memberExpression.parent.id.name === property.name
-			&& !memberExpression.parent.id.typeAnnotation
-		) {
-			problem.fix = function * (fixer) {
-				const variable = memberExpression.parent.id;
-				yield fixer.insertTextBefore(variable, '{');
-				yield fixer.insertTextAfter(variable, '}');
-
-				yield removeMemberExpressionProperty(fixer, memberExpression, context);
-				yield removeParentheses(memberExpression.object, fixer, context);
-			};
-
-			return problem;
-		}
-
-		return problem;
-	});
-};
-
-/** @type {import('eslint').Rule.RuleModule} */
-const config = {
-	create,
-	meta: {
-		type: 'suggestion',
-		docs: {
-			description: 'Disallow member access from await expression.',
-			recommended: true,
-		},
-		fixable: 'code',
-		messages,
-	},
-};
-
-export default config;

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/no-await-in-promise-methods.js

@@ -1,69 +0,0 @@
-import {isMethodCall} from './ast/index.js';
-import {removeSpacesAfter} from './fix/index.js';
-
-const MESSAGE_ID_ERROR = 'no-await-in-promise-methods/error';
-const MESSAGE_ID_SUGGESTION = 'no-await-in-promise-methods/suggestion';
-const messages = {
-	[MESSAGE_ID_ERROR]: 'Promise in `Promise.{{method}}()` should not be awaited.',
-	[MESSAGE_ID_SUGGESTION]: 'Remove `await`.',
-};
-const METHODS = ['all', 'allSettled', 'any', 'race'];
-
-const isPromiseMethodCallWithArrayExpression = node =>
-	isMethodCall(node, {
-		object: 'Promise',
-		methods: METHODS,
-		optionalMember: false,
-		optionalCall: false,
-		argumentsLength: 1,
-	})
-	&& node.arguments[0].type === 'ArrayExpression';
-
-/** @param {import('eslint').Rule.RuleContext} context */
-const create = context => ({
-	* CallExpression(callExpression) {
-		if (!isPromiseMethodCallWithArrayExpression(callExpression)) {
-			return;
-		}
-
-		for (const element of callExpression.arguments[0].elements) {
-			if (element?.type !== 'AwaitExpression') {
-				continue;
-			}
-
-			yield {
-				node: element,
-				messageId: MESSAGE_ID_ERROR,
-				data: {
-					method: callExpression.callee.property.name,
-				},
-				suggest: [
-					{
-						messageId: MESSAGE_ID_SUGGESTION,
-						* fix(fixer) {
-							const awaitToken = context.sourceCode.getFirstToken(element);
-							yield fixer.remove(awaitToken);
-							yield removeSpacesAfter(awaitToken, context, fixer);
-						},
-					},
-				],
-			};
-		}
-	},
-});
-
-/** @type {import('eslint').Rule.RuleModule} */
-const config = {
-	create,
-	meta: {
-		type: 'suggestion',
-		docs: {
-			description: 'Disallow using `await` in `Promise` method parameters.',
-			recommended: 'unopinionated',
-		},
-		hasSuggestions: true,
-		messages,
-	},
-};
-
-export default config;

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

@@ -1,89 +0,0 @@
-import toLocation from './utils/to-location.js';
-import {isStringLiteral, isMethodCall} from './ast/index.js';
-
-const MESSAGE_ID = 'no-console-spaces';
-const messages = {
-	[MESSAGE_ID]: 'Do not use {{position}} space between `console.{{method}}` parameters.',
-};
-
-// Find exactly one leading space, allow exactly one space
-const hasLeadingSpace = value => value.length > 1 && value.charAt(0) === ' ' && value.charAt(1) !== ' ';
-
-// Find exactly one trailing space, allow exactly one space
-const hasTrailingSpace = value => value.length > 1 && value.at(-1) === ' ' && value.at(-2) !== ' ';
-
-/** @param {import('eslint').Rule.RuleContext} context */
-const create = context => {
-	const {sourceCode} = context;
-	const getProblem = (node, method, position) => {
-		const [start, end] = sourceCode.getRange(node);
-		const index = position === 'leading'
-			? start + 1
-			: end - 2;
-		const range = [index, index + 1];
-
-		return {
-			loc: toLocation(range, context),
-			messageId: MESSAGE_ID,
-			data: {method, position},
-			fix: fixer => fixer.removeRange(range),
-		};
-	};
-
-	return {
-		* CallExpression(node) {
-			if (
-				!isMethodCall(node, {
-					object: 'console',
-					methods: [
-						'log',
-						'debug',
-						'info',
-						'warn',
-						'error',
-					],
-					minimumArguments: 1,
-					optionalCall: false,
-					optionalMember: false,
-				})
-			) {
-				return;
-			}
-
-			const method = node.callee.property.name;
-			const {arguments: messages} = node;
-			const {length} = messages;
-			for (const [index, node] of messages.entries()) {
-				if (!isStringLiteral(node) && node.type !== 'TemplateLiteral') {
-					continue;
-				}
-
-				const raw = sourceCode.getText(node).slice(1, -1);
-
-				if (index !== 0 && hasLeadingSpace(raw)) {
-					yield getProblem(node, method, 'leading');
-				}
-
-				if (index !== length - 1 && hasTrailingSpace(raw)) {
-					yield getProblem(node, method, 'trailing');
-				}
-			}
-		},
-	};
-};
-
-/** @type {import('eslint').Rule.RuleModule} */
-const config = {
-	create,
-	meta: {
-		type: 'suggestion',
-		docs: {
-			description: 'Do not use leading/trailing space between `console.log` parameters.',
-			recommended: 'unopinionated',
-		},
-		fixable: 'code',
-		messages,
-	},
-};
-
-export default config;

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

@@ -1,27 +0,0 @@
-import {GlobalReferenceTracker} from './utils/global-reference-tracker.js';
-
-const MESSAGE_ID = 'no-document-cookie';
-const messages = {
-	[MESSAGE_ID]: 'Do not use `document.cookie` directly.',
-};
-
-const tracker = new GlobalReferenceTracker({
-	object: 'document.cookie',
-	filter: ({node}) => node.parent.type === 'AssignmentExpression' && node.parent.left === node,
-	handle: ({node}) => ({node, messageId: MESSAGE_ID}),
-});
-
-/** @type {import('eslint').Rule.RuleModule} */
-const config = {
-	create: context => tracker.listen({context}),
-	meta: {
-		type: 'problem',
-		docs: {
-			description: 'Do not use `document.cookie` directly.',
-			recommended: 'unopinionated',
-		},
-		messages,
-	},
-};
-
-export default config;

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

@@ -1,58 +0,0 @@
-import {isEmptyNode, isDirective} from './ast/index.js';
-
-const MESSAGE_ID = 'no-empty-file';
-const messages = {
-	[MESSAGE_ID]: 'Empty files are not allowed.',
-};
-
-const isEmpty = node => isEmptyNode(node, isDirective);
-
-const isTripleSlashDirective = node =>
-	node.type === 'Line' && node.value.startsWith('/');
-
-const hasTripeSlashDirectives = comments =>
-	comments.some(currentNode => isTripleSlashDirective(currentNode));
-
-/** @param {import('eslint').Rule.RuleContext} context */
-const create = context => {
-	const filename = context.physicalFilename;
-
-	if (!/\.(?:js|mjs|cjs|jsx|ts|mts|cts|tsx)$/i.test(filename)) {
-		return;
-	}
-
-	return {
-		Program(node) {
-			if (node.body.some(node => !isEmpty(node))) {
-				return;
-			}
-
-			const {sourceCode} = context;
-			const comments = sourceCode.getAllComments();
-
-			if (hasTripeSlashDirectives(comments)) {
-				return;
-			}
-
-			return {
-				node,
-				messageId: MESSAGE_ID,
-			};
-		},
-	};
-};
-
-/** @type {import('eslint').Rule.RuleModule} */
-const config = {
-	create,
-	meta: {
-		type: 'suggestion',
-		docs: {
-			description: 'Disallow empty files.',
-			recommended: 'unopinionated',
-		},
-		messages,
-	},
-};
-
-export default config;