@alexlit/lint-kit 176.0.1 → 177.0.0

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/prefer-at.js

@@ -1,380 +0,0 @@
-import {
-	isOpeningBracketToken,
-	isClosingBracketToken,
-	getStaticValue,
-} from '@eslint-community/eslint-utils';
-import {
-	isParenthesized,
-	getParenthesizedRange,
-	getParenthesizedText,
-	isNodeMatchesNameOrPath,
-	needsSemicolon,
-	shouldAddParenthesesToMemberExpressionObject,
-	isLeftHandSide,
-} from './utils/index.js';
-import {
-	getNegativeIndexLengthNode,
-	removeLengthNode,
-} from './shared/negative-index.js';
-import {removeMemberExpressionProperty, removeMethodCall} from './fix/index.js';
-import {
-	isLiteral,
-	isCallExpression,
-	isMethodCall,
-	isMemberExpression,
-} from './ast/index.js';
-
-const MESSAGE_ID_NEGATIVE_INDEX = 'negative-index';
-const MESSAGE_ID_INDEX = 'index';
-const MESSAGE_ID_STRING_CHAR_AT_NEGATIVE = 'string-char-at-negative';
-const MESSAGE_ID_STRING_CHAR_AT = 'string-char-at';
-const MESSAGE_ID_SLICE = 'slice';
-const MESSAGE_ID_GET_LAST_FUNCTION = 'get-last-function';
-const SUGGESTION_ID = 'use-at';
-const messages = {
-	[MESSAGE_ID_NEGATIVE_INDEX]: 'Prefer `.at(…)` over `[….length - index]`.',
-	[MESSAGE_ID_INDEX]: 'Prefer `.at(…)` over index access.',
-	[MESSAGE_ID_STRING_CHAR_AT_NEGATIVE]: 'Prefer `String#at(…)` over `String#charAt(….length - index)`.',
-	[MESSAGE_ID_STRING_CHAR_AT]: 'Prefer `String#at(…)` over `String#charAt(…)`.',
-	[MESSAGE_ID_SLICE]: 'Prefer `.at(…)` over the first element from `.slice(…)`.',
-	[MESSAGE_ID_GET_LAST_FUNCTION]: 'Prefer `.at(-1)` over `{{description}}(…)` to get the last element.',
-	[SUGGESTION_ID]: 'Use `.at(…)`.',
-};
-
-const isArguments = node => node.type === 'Identifier' && node.name === 'arguments';
-
-const isLiteralNegativeInteger = node =>
-	node.type === 'UnaryExpression'
-	&& node.prefix
-	&& node.operator === '-'
-	&& node.argument.type === 'Literal'
-	&& Number.isInteger(node.argument.value)
-	&& node.argument.value > 0;
-const isZeroIndexAccess = node =>
-	isMemberExpression(node.parent, {
-		optional: false,
-		computed: true,
-	})
-	&& node.parent.object === node
-	&& isLiteral(node.parent.property, 0);
-
-const isArrayPopOrShiftCall = (node, method) =>
-	isMethodCall(node.parent.parent, {
-		method,
-		argumentsLength: 0,
-		optionalCall: false,
-		optionalMember: false,
-	})
-	&& node.parent.object === node;
-
-const isArrayPopCall = node => isArrayPopOrShiftCall(node, 'pop');
-const isArrayShiftCall = node => isArrayPopOrShiftCall(node, 'shift');
-
-function checkSliceCall(node) {
-	const sliceArgumentsLength = node.arguments.length;
-	const [startIndexNode, endIndexNode] = node.arguments;
-
-	if (!isLiteralNegativeInteger(startIndexNode)) {
-		return;
-	}
-
-	let firstElementGetMethod = '';
-	if (isZeroIndexAccess(node)) {
-		if (isLeftHandSide(node.parent)) {
-			return;
-		}
-
-		firstElementGetMethod = 'zero-index';
-	} else if (isArrayShiftCall(node)) {
-		firstElementGetMethod = 'shift';
-	} else if (isArrayPopCall(node)) {
-		firstElementGetMethod = 'pop';
-	}
-
-	if (!firstElementGetMethod) {
-		return;
-	}
-
-	const startIndex = -startIndexNode.argument.value;
-	if (sliceArgumentsLength === 1) {
-		if (
-			startIndexNode.argument.value === 1
-			&& (
-				firstElementGetMethod === 'zero-index'
-				|| firstElementGetMethod === 'shift'
-				|| (startIndex === -1 && firstElementGetMethod === 'pop')
-			)
-		) {
-			return {safeToFix: true, firstElementGetMethod};
-		}
-
-		return;
-	}
-
-	if (
-		isLiteralNegativeInteger(endIndexNode)
-		&& -endIndexNode.argument.value === startIndex + 1
-	) {
-		return {safeToFix: true, firstElementGetMethod};
-	}
-
-	if (firstElementGetMethod === 'pop') {
-		return;
-	}
-
-	return {safeToFix: false, firstElementGetMethod};
-}
-
-const lodashLastFunctions = [
-	'_.last',
-	'lodash.last',
-	'underscore.last',
-];
-
-/** @param {import('eslint').Rule.RuleContext} context */
-function create(context) {
-	const {
-		getLastElementFunctions,
-		checkAllIndexAccess,
-	} = {
-		getLastElementFunctions: [],
-		checkAllIndexAccess: false,
-		...context.options[0],
-	};
-	const getLastFunctions = [...getLastElementFunctions, ...lodashLastFunctions];
-	const {sourceCode} = context;
-
-	// Index access
-	context.on('MemberExpression', node => {
-		if (
-			!node.computed
-			|| isLeftHandSide(node)
-		) {
-			return;
-		}
-
-		const indexNode = node.property;
-		const lengthNode = getNegativeIndexLengthNode(indexNode, node.object);
-
-		if (!lengthNode) {
-			if (!checkAllIndexAccess) {
-				return;
-			}
-
-			// Only if we are sure it's an positive integer
-			const staticValue = getStaticValue(indexNode, sourceCode.getScope(indexNode));
-			if (!staticValue || !Number.isInteger(staticValue.value) || staticValue.value < 0) {
-				return;
-			}
-		}
-
-		const problem = {
-			node: indexNode,
-			messageId: lengthNode ? MESSAGE_ID_NEGATIVE_INDEX : MESSAGE_ID_INDEX,
-		};
-
-		if (isArguments(node.object)) {
-			return problem;
-		}
-
-		problem.fix = function * (fixer) {
-			if (lengthNode) {
-				yield removeLengthNode(lengthNode, fixer, context);
-			}
-
-			// Only remove space for `foo[foo.length - 1]`
-			if (
-				indexNode.type === 'BinaryExpression'
-				&& indexNode.operator === '-'
-				&& indexNode.left === lengthNode
-				&& indexNode.right.type === 'Literal'
-				&& /^\d+$/.test(indexNode.right.raw)
-			) {
-				const numberNode = indexNode.right;
-				const tokenBefore = sourceCode.getTokenBefore(numberNode);
-				if (
-					tokenBefore.type === 'Punctuator'
-					&& tokenBefore.value === '-'
-					&& /^\s+$/.test(sourceCode.text.slice(sourceCode.getRange(tokenBefore)[1], sourceCode.getRange(numberNode)[0]))
-				) {
-					yield fixer.removeRange([sourceCode.getRange(tokenBefore)[1], sourceCode.getRange(numberNode)[0]]);
-				}
-			}
-
-			const isOptional = node.optional;
-			const openingBracketToken = sourceCode.getTokenBefore(indexNode, isOpeningBracketToken);
-			yield fixer.replaceText(openingBracketToken, `${isOptional ? '' : '.'}at(`);
-
-			const closingBracketToken = sourceCode.getTokenAfter(indexNode, isClosingBracketToken);
-			yield fixer.replaceText(closingBracketToken, ')');
-		};
-
-		return problem;
-	});
-
-	// `string.charAt`
-	context.on('CallExpression', node => {
-		if (!isMethodCall(node, {
-			method: 'charAt',
-			argumentsLength: 1,
-			optionalCall: false,
-		})) {
-			return;
-		}
-
-		const [indexNode] = node.arguments;
-		const lengthNode = getNegativeIndexLengthNode(indexNode, node.callee.object);
-
-		// `String#charAt` don't care about index value, we assume it's always number
-		if (!lengthNode && !checkAllIndexAccess) {
-			return;
-		}
-
-		return {
-			node: indexNode,
-			messageId: lengthNode ? MESSAGE_ID_STRING_CHAR_AT_NEGATIVE : MESSAGE_ID_STRING_CHAR_AT,
-			suggest: [{
-				messageId: SUGGESTION_ID,
-				* fix(fixer) {
-					if (lengthNode) {
-						yield removeLengthNode(lengthNode, fixer, context);
-					}
-
-					yield fixer.replaceText(node.callee.property, 'at');
-				},
-			}],
-		};
-	});
-
-	// `.slice()`
-	context.on('CallExpression', sliceCall => {
-		if (!isMethodCall(sliceCall, {
-			method: 'slice',
-			minimumArguments: 1,
-			maximumArguments: 2,
-			optionalCall: false,
-		})) {
-			return;
-		}
-
-		const result = checkSliceCall(sliceCall);
-		if (!result) {
-			return;
-		}
-
-		const {safeToFix, firstElementGetMethod} = result;
-
-		/** @param {import('eslint').Rule.RuleFixer} fixer */
-		function * fix(fixer) {
-			// `.slice` to `.at`
-			yield fixer.replaceText(sliceCall.callee.property, 'at');
-
-			// Remove extra arguments
-			if (sliceCall.arguments.length !== 1) {
-				const [, start] = getParenthesizedRange(sliceCall.arguments[0], context);
-				const [end] = sourceCode.getRange(sourceCode.getLastToken(sliceCall));
-				yield fixer.removeRange([start, end]);
-			}
-
-			yield (
-				// Remove `[0]`, `.shift()`, or `.pop()`
-				firstElementGetMethod === 'zero-index'
-					? removeMemberExpressionProperty(fixer, sliceCall.parent, context)
-					: removeMethodCall(fixer, sliceCall.parent.parent, context)
-			);
-		}
-
-		const problem = {
-			node: sliceCall.callee.property,
-			messageId: MESSAGE_ID_SLICE,
-		};
-
-		if (safeToFix) {
-			problem.fix = fix;
-		} else {
-			problem.suggest = [{messageId: SUGGESTION_ID, fix}];
-		}
-
-		return problem;
-	});
-
-	context.on('CallExpression', node => {
-		if (!isCallExpression(node, {argumentsLength: 1, optional: false})) {
-			return;
-		}
-
-		const matchedFunction = getLastFunctions.find(nameOrPath => isNodeMatchesNameOrPath(node.callee, nameOrPath));
-		if (!matchedFunction) {
-			return;
-		}
-
-		const problem = {
-			node: node.callee,
-			messageId: MESSAGE_ID_GET_LAST_FUNCTION,
-			data: {description: matchedFunction.trim()},
-		};
-
-		const [array] = node.arguments;
-
-		if (isArguments(array)) {
-			return problem;
-		}
-
-		problem.fix = function (fixer) {
-			let fixed = getParenthesizedText(array, context);
-
-			if (
-				!isParenthesized(array, sourceCode)
-				&& shouldAddParenthesesToMemberExpressionObject(array, context)
-			) {
-				fixed = `(${fixed})`;
-			}
-
-			fixed = `${fixed}.at(-1)`;
-
-			const tokenBefore = sourceCode.getTokenBefore(node);
-			if (needsSemicolon(tokenBefore, context, fixed)) {
-				fixed = `;${fixed}`;
-			}
-
-			return fixer.replaceText(node, fixed);
-		};
-
-		return problem;
-	});
-}
-
-const schema = [
-	{
-		type: 'object',
-		additionalProperties: false,
-		properties: {
-			getLastElementFunctions: {
-				type: 'array',
-				uniqueItems: true,
-			},
-			checkAllIndexAccess: {
-				type: 'boolean',
-			},
-		},
-	},
-];
-
-/** @type {import('eslint').Rule.RuleModule} */
-const config = {
-	create,
-	meta: {
-		type: 'suggestion',
-		docs: {
-			description: 'Prefer `.at()` method for index access and `String#charAt()`.',
-			recommended: 'unopinionated',
-		},
-		fixable: 'code',
-		hasSuggestions: true,
-		schema,
-		defaultOptions: [{getLastElementFunctions: [], checkAllIndexAccess: false}],
-		messages,
-	},
-};
-
-export default config;

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/prefer-bigint-literals.js

@@ -1,129 +0,0 @@
-import {
-	isCallExpression,
-	isStringLiteral,
-} from './ast/index.js';
-
-const MESSAGE_ID_ERROR = 'prefer-bigint-literals/error';
-const MESSAGE_ID_SUGGESTION = 'prefer-bigint-literals/suggestion';
-const messages = {
-	[MESSAGE_ID_ERROR]: 'Prefer using bigint literal over `BigInt(…)`.',
-	[MESSAGE_ID_SUGGESTION]: 'Replace with {{replacement}}.',
-};
-
-const canUseNumericLiteralRaw = numericLiteral => {
-	const raw = numericLiteral.raw.replaceAll('_', '').toLowerCase();
-
-	if (raw.includes('.')) {
-		return false;
-	}
-
-	const {value} = numericLiteral;
-
-	for (const {prefix, base} of [
-		{prefix: '0b', base: 2},
-		{prefix: '0o', base: 8},
-		{prefix: '0x', base: 16},
-	]) {
-		if (raw.startsWith(prefix)) {
-			return raw.slice(2) === value.toString(base);
-		}
-	}
-
-	if (raw.includes('e')) {
-		return false;
-	}
-
-	return raw === String(value);
-};
-
-function getReplacement(valueNode) {
-	if (isStringLiteral(valueNode)) {
-		const raw = valueNode.raw.slice(1, -1);
-		try {
-			BigInt(raw);
-		} catch {
-			return;
-		}
-
-		return {shouldUseSuggestion: false, text: `${raw.trimEnd()}n`};
-	}
-
-	const {value, raw} = valueNode;
-
-	if (!Number.isInteger(value)) {
-		return;
-	}
-
-	let bigint;
-	try {
-		bigint = BigInt(value);
-	} catch {
-		return;
-	}
-
-	const shouldUseSuggestion = !canUseNumericLiteralRaw(valueNode);
-	const text = shouldUseSuggestion ? `${bigint}n` : `${raw}n`;
-	return {shouldUseSuggestion, text};
-}
-
-/** @param {import('eslint').Rule.RuleContext} context */
-const create = context => ({
-	CallExpression(callExpression) {
-		if (!isCallExpression(callExpression, {
-			name: 'BigInt',
-			argumentsLength: 1,
-			optional: false,
-		})) {
-			return;
-		}
-
-		const [valueNode] = callExpression.arguments;
-		const replacement = getReplacement(valueNode);
-		if (!replacement) {
-			return;
-		}
-
-		const problem = {
-			node: callExpression,
-			messageId: MESSAGE_ID_ERROR,
-		};
-
-		const {shouldUseSuggestion, text} = replacement;
-
-		/** @param {import('eslint').Rule.RuleFixer} fixer */
-		const fix = fixer => fixer.replaceText(callExpression, text);
-
-		if (shouldUseSuggestion || context.sourceCode.getCommentsInside(callExpression).length > 0) {
-			problem.suggest = [
-				{
-					messageId: MESSAGE_ID_SUGGESTION,
-					data: {
-						replacement: text.length < 20 ? `\`${text}\`` : 'a bigint literal',
-					},
-					fix,
-				},
-			];
-		} else {
-			problem.fix = fix;
-		}
-
-		return problem;
-	},
-});
-
-/** @type {import('eslint').Rule.RuleModule} */
-const config = {
-	create,
-	meta: {
-		type: 'suggestion',
-		docs: {
-			description: 'Prefer `BigInt` literals over the constructor.',
-			recommended: 'unopinionated',
-		},
-		fixable: 'code',
-		hasSuggestions: true,
-		messages,
-	},
-};
-
-export default config;

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/prefer-blob-reading-methods.js

@@ -1,47 +0,0 @@
-import {isMethodCall} from './ast/index.js';
-
-const MESSAGE_ID = 'error';
-const messages = {
-	[MESSAGE_ID]: 'Prefer `Blob#{{replacement}}()` over `FileReader#{{method}}(blob)`.',
-};
-
-/** @param {import('eslint').Rule.RuleContext} context */
-const create = () => ({
-	CallExpression(node) {
-		if (!isMethodCall(node, {
-			methods: ['readAsText', 'readAsArrayBuffer'],
-			argumentsLength: 1,
-			optionalCall: false,
-			optionalMember: false,
-		})) {
-			return;
-		}
-
-		const method = node.callee.property;
-		const methodName = method.name;
-
-		return {
-			node: method,
-			messageId: MESSAGE_ID,
-			data: {
-				method: methodName,
-				replacement: methodName === 'readAsArrayBuffer' ? 'arrayBuffer' : 'text',
-			},
-		};
-	},
-});
-
-/** @type {import('eslint').Rule.RuleModule} */
-const config = {
-	create,
-	meta: {
-		type: 'suggestion',
-		docs: {
-			description: 'Prefer `Blob#arrayBuffer()` over `FileReader#readAsArrayBuffer(…)` and `Blob#text()` over `FileReader#readAsText(…)`.',
-			recommended: 'unopinionated',
-		},
-		messages,
-	},
-};
-
-export default config;

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/prefer-class-fields.js

@@ -1,158 +0,0 @@
-import {isSemicolonToken} from '@eslint-community/eslint-utils';
-import getIndentString from './utils/get-indent-string.js';
-
-const MESSAGE_ID_ERROR = 'prefer-class-fields/error';
-const MESSAGE_ID_SUGGESTION = 'prefer-class-fields/suggestion';
-const messages = {
-	[MESSAGE_ID_ERROR]:
-		'Prefer class field declaration over `this` assignment in constructor for static values.',
-	[MESSAGE_ID_SUGGESTION]:
-		'Encountered same-named class field declaration and `this` assignment in constructor. Replace the class field declaration with the value from `this` assignment.',
-};
-
-/**
-@param {import('eslint').Rule.Node} node
-@param {import('eslint').Rule.RuleContext['sourceCode']} sourceCode
-@param {import('eslint').Rule.RuleFixer} fixer
-*/
-const removeFieldAssignment = (node, sourceCode, fixer) => {
-	const {line} = sourceCode.getLoc(node).start;
-	const nodeText = sourceCode.getText(node);
-	const lineText = sourceCode.lines[line - 1];
-	const isOnlyNodeOnLine = lineText.trim() === nodeText;
-
-	return isOnlyNodeOnLine
-		? fixer.removeRange([
-			sourceCode.getIndexFromLoc({line, column: 0}),
-			sourceCode.getIndexFromLoc({line: line + 1, column: 0}),
-		])
-		: fixer.remove(node);
-};
-
-/**
-@type {import('eslint').Rule.RuleModule['create']}
-*/
-const create = context => {
-	const {sourceCode} = context;
-
-	return {
-		ClassBody(classBody) {
-			const constructor = classBody.body.find(node =>
-				node.kind === 'constructor'
-				&& !node.computed
-				&& !node.static
-				&& node.type === 'MethodDefinition'
-				&& node.value.type === 'FunctionExpression',
-			);
-
-			if (!constructor) {
-				return;
-			}
-
-			const node = constructor.value.body.body.find(node => node.type !== 'EmptyStatement');
-
-			if (!(
-				node?.type === 'ExpressionStatement'
-				&& node.expression.type === 'AssignmentExpression'
-				&& node.expression.operator === '='
-				&& node.expression.left.type === 'MemberExpression'
-				&& node.expression.left.object.type === 'ThisExpression'
-				&& !node.expression.left.computed
-				&& ['Identifier', 'PrivateIdentifier'].includes(node.expression.left.property.type)
-				&& node.expression.right.type === 'Literal'
-			)) {
-				return;
-			}
-
-			const propertyName = node.expression.left.property.name;
-			const propertyValue = node.expression.right.raw;
-			const propertyType = node.expression.left.property.type;
-			const existingProperty = classBody.body.find(node =>
-				node.type === 'PropertyDefinition'
-				&& !node.computed
-				&& !node.static
-				&& node.key.type === propertyType
-				&& node.key.name === propertyName,
-			);
-
-			const problem = {
-				node,
-				messageId: MESSAGE_ID_ERROR,
-			};
-
-			/**
-			@param {import('eslint').Rule.RuleFixer} fixer
-			*/
-			function * fix(fixer) {
-				yield removeFieldAssignment(node, sourceCode, fixer);
-
-				if (existingProperty) {
-					if (existingProperty.value) {
-						yield fixer.replaceText(existingProperty.value, propertyValue);
-						return;
-					}
-
-					const text = ` = ${propertyValue}`;
-					const lastToken = sourceCode.getLastToken(existingProperty);
-					if (isSemicolonToken(lastToken)) {
-						yield fixer.insertTextBefore(lastToken, text);
-						return;
-					}
-
-					yield fixer.insertTextAfter(existingProperty, `${text};`);
-					return;
-				}
-
-				const closingBrace = sourceCode.getLastToken(classBody);
-				const indent = getIndentString(constructor, context);
-
-				let text = `${indent}${propertyName} = ${propertyValue};\n`;
-
-				const characterBefore = sourceCode.getText()[sourceCode.getRange(closingBrace)[0] - 1];
-				if (characterBefore !== '\n') {
-					text = `\n${text}`;
-				}
-
-				const lastProperty = classBody.body.at(-1);
-				if (
-					lastProperty.type === 'PropertyDefinition'
-					&& sourceCode.getLastToken(lastProperty).value !== ';'
-				) {
-					text = `;${text}`;
-				}
-
-				yield fixer.insertTextBefore(closingBrace, text);
-			}
-
-			if (existingProperty?.value) {
-				problem.suggest = [
-					{
-						messageId: MESSAGE_ID_SUGGESTION,
-						fix,
-					},
-				];
-				return problem;
-			}
-
-			problem.fix = fix;
-			return problem;
-		},
-	};
-};
-
-/** @type {import('eslint').Rule.RuleModule} */
-const config = {
-	create,
-	meta: {
-		type: 'suggestion',
-		docs: {
-			description: 'Prefer class field declarations over `this` assignments in constructors.',
-			recommended: 'unopinionated',
-		},
-		fixable: 'code',
-		hasSuggestions: true,
-		messages,
-	},
-};
-
-export default config;