@alexlit/lint-kit 176.0.1 → 177.0.0

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

@@ -1,211 +0,0 @@
-import {getNegativeIndexLengthNode, removeLengthNode} from './shared/negative-index.js';
-import typedArray from './shared/typed-array.js';
-import {isLiteral} from './ast/index.js';
-
-const MESSAGE_ID = 'prefer-negative-index';
-const messages = {
-	[MESSAGE_ID]: 'Prefer negative index over length minus index for `{{method}}`.',
-};
-
-const methods = new Map([
-	[
-		'slice',
-		{
-			argumentsIndexes: [0, 1],
-			supportObjects: new Set([
-				'Array',
-				'String',
-				'ArrayBuffer',
-				...typedArray,
-				// `{Blob,File}#slice()` are not generally used
-				// 'Blob'
-				// 'File'
-			]),
-		},
-	],
-	[
-		'subarray',
-		{
-			argumentsIndexes: [0, 1],
-			supportObjects: new Set(typedArray),
-		},
-	],
-	[
-		'splice',
-		{
-			argumentsIndexes: [0],
-			supportObjects: new Set([
-				'Array',
-			]),
-		},
-	],
-	[
-		'toSpliced',
-		{
-			argumentsIndexes: [0],
-			supportObjects: new Set([
-				'Array',
-			]),
-		},
-	],
-	[
-		'at',
-		{
-			argumentsIndexes: [0],
-			supportObjects: new Set([
-				'Array',
-				'String',
-				...typedArray,
-			]),
-		},
-	],
-	[
-		'with',
-		{
-			argumentsIndexes: [0],
-			supportObjects: new Set([
-				'Array',
-				...typedArray,
-			]),
-		},
-	],
-]);
-
-const getMemberName = node => {
-	const {type, property} = node;
-
-	if (
-		type === 'MemberExpression'
-		&& property.type === 'Identifier'
-	) {
-		return property.name;
-	}
-};
-
-function parse(node) {
-	const {callee, arguments: originalArguments} = node;
-
-	let method = callee.property.name;
-	let target = callee.object;
-	let argumentsNodes = originalArguments;
-
-	if (methods.has(method)) {
-		return {
-			method,
-			target,
-			argumentsNodes,
-		};
-	}
-
-	if (method !== 'call' && method !== 'apply') {
-		return;
-	}
-
-	const isApply = method === 'apply';
-
-	method = getMemberName(callee.object);
-
-	if (!methods.has(method)) {
-		return;
-	}
-
-	const {supportObjects} = methods.get(method);
-
-	const parentCallee = callee.object.object;
-
-	if (
-		// `[].{slice,splice,toSpliced,at,with}`
-		(
-			parentCallee.type === 'ArrayExpression'
-			&& parentCallee.elements.length === 0
-		)
-		// `''.slice`
-		|| (
-			method === 'slice'
-			&& isLiteral(parentCallee, '')
-		)
-		// {Array,String...}.prototype.slice
-		// Array.prototype.splice
-		|| (
-			getMemberName(parentCallee) === 'prototype'
-			&& parentCallee.object.type === 'Identifier'
-			&& supportObjects.has(parentCallee.object.name)
-		)
-	) {
-		[target] = originalArguments;
-
-		if (isApply) {
-			const [, secondArgument] = originalArguments;
-			if (!secondArgument || secondArgument.type !== 'ArrayExpression') {
-				return;
-			}
-
-			argumentsNodes = secondArgument.elements;
-		} else {
-			argumentsNodes = originalArguments.slice(1);
-		}
-
-		return {
-			method,
-			target,
-			argumentsNodes,
-		};
-	}
-}
-
-/** @param {import('eslint').Rule.RuleContext} context */
-const create = context => ({
-	CallExpression(node) {
-		if (node.callee.type !== 'MemberExpression') {
-			return;
-		}
-
-		const parsed = parse(node);
-
-		if (!parsed) {
-			return;
-		}
-
-		const {
-			method,
-			target,
-			argumentsNodes,
-		} = parsed;
-
-		const {argumentsIndexes} = methods.get(method);
-		const removableNodes = argumentsIndexes
-			.map(index => getNegativeIndexLengthNode(argumentsNodes[index], target))
-			.filter(Boolean);
-
-		if (removableNodes.length === 0) {
-			return;
-		}
-
-		return {
-			node,
-			messageId: MESSAGE_ID,
-			data: {method},
-			* fix(fixer) {
-				for (const node of removableNodes) {
-					yield removeLengthNode(node, fixer, context);
-				}
-			},
-		};
-	},
-});
-
-/** @type {import('eslint').Rule.RuleModule} */
-const config = {
-	create,
-	meta: {
-		type: 'suggestion',
-		docs: {
-			description: 'Prefer negative index over `.length - index` when possible.',
-			recommended: 'unopinionated',
-		},
-		fixable: 'code',
-		messages,
-	},
-};
-
-export default config;

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

@@ -1,86 +0,0 @@
-import isBuiltinModule from 'is-builtin-module';
-import {
-	isStaticRequire,
-	isMethodCall,
-} from './ast/index.js';
-
-const MESSAGE_ID = 'prefer-node-protocol';
-const messages = {
-	[MESSAGE_ID]: 'Prefer `node:{{moduleName}}` over `{{moduleName}}`.',
-};
-const NODE_PROTOCOL = 'node:';
-
-/**
-@param {import('eslint').Rule.RuleContext} context
-*/
-const create = context => ({
-	Literal(node) {
-		if (!(
-			(
-				(
-					node.parent.type === 'ImportDeclaration'
-					|| node.parent.type === 'ExportNamedDeclaration'
-					|| node.parent.type === 'ImportExpression'
-				)
-				&& node.parent.source === node
-			)
-			|| (
-				(
-					isMethodCall(node.parent, {
-						object: 'process',
-						method: 'getBuiltinModule',
-						argumentsLength: 1,
-						optionalCall: false,
-						optionalMember: false,
-					})
-					|| isStaticRequire(node.parent)
-				)
-				&& node.parent.arguments[0] === node
-			)
-			|| (
-				node.parent.type === 'TSLiteralType'
-				&& node.parent.literal === node
-				&& node.parent.parent.type === 'TSImportType'
-				&& node.parent.parent.argument === node.parent
-			)
-		)) {
-			return;
-		}
-
-		const {value} = node;
-
-		if (!(
-			typeof value === 'string'
-			&& !value.startsWith(NODE_PROTOCOL)
-			&& isBuiltinModule(value)
-			&& isBuiltinModule(`${NODE_PROTOCOL}${value}`)
-		)) {
-			return;
-		}
-
-		const insertPosition = context.sourceCode.getRange(node)[0] + 1; // After quote
-		return {
-			node,
-			messageId: MESSAGE_ID,
-			data: {moduleName: value},
-			/** @param {import('eslint').Rule.RuleFixer} fixer */
-			fix: fixer => fixer.insertTextAfterRange([insertPosition, insertPosition], NODE_PROTOCOL),
-		};
-	},
-});
-
-/** @type {import('eslint').Rule.RuleModule} */
-const config = {
-	create,
-	meta: {
-		type: 'suggestion',
-		docs: {
-			description: 'Prefer using the `node:` protocol when importing Node.js builtin modules.',
-			recommended: 'unopinionated',
-		},
-		fixable: 'code',
-		messages,
-	},
-};
-
-export default config;

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

@@ -1,142 +0,0 @@
-import {GlobalReferenceTracker} from './utils/global-reference-tracker.js';
-import {replaceReferenceIdentifier, fixSpaceAroundKeyword} from './fix/index.js';
-import isLeftHandSide from './utils/is-left-hand-side.js';
-
-const MESSAGE_ID_ERROR = 'error';
-const MESSAGE_ID_SUGGESTION = 'suggestion';
-const messages = {
-	[MESSAGE_ID_ERROR]: 'Prefer `Number.{{property}}` over `{{description}}`.',
-	[MESSAGE_ID_SUGGESTION]: 'Replace `{{description}}` with `Number.{{property}}`.',
-};
-
-const globalObjects = {
-	// Safe to replace with `Number` properties
-	parseInt: true,
-	parseFloat: true,
-	NaN: true,
-	Infinity: true,
-
-	// Unsafe to replace with `Number` properties
-	isNaN: false,
-	isFinite: false,
-};
-
-const isNegative = node => {
-	const {parent} = node;
-	return parent.type === 'UnaryExpression' && parent.operator === '-' && parent.argument === node;
-};
-
-function checkProperty({node, path: [name]}, context) {
-	const {parent} = node;
-
-	let property = name;
-	if (name === 'Infinity') {
-		property = isNegative(node) ? 'NEGATIVE_INFINITY' : 'POSITIVE_INFINITY';
-	}
-
-	const problem = {
-		node,
-		messageId: MESSAGE_ID_ERROR,
-		data: {
-			description: name,
-			property,
-		},
-	};
-
-	if (property === 'NEGATIVE_INFINITY') {
-		problem.node = parent;
-		problem.data.description = '-Infinity';
-		problem.fix = function * (fixer) {
-			yield fixer.replaceText(parent, 'Number.NEGATIVE_INFINITY');
-			yield fixSpaceAroundKeyword(fixer, parent, context);
-		};
-
-		return problem;
-	}
-
-	const fix = fixer => replaceReferenceIdentifier(node, `Number.${property}`, context, fixer);
-	const isSafeToFix = globalObjects[name];
-
-	if (isSafeToFix) {
-		problem.fix = fix;
-	} else {
-		problem.suggest = [
-			{
-				messageId: MESSAGE_ID_SUGGESTION,
-				fix,
-			},
-		];
-	}
-
-	return problem;
-}
-
-/** @param {import('eslint').Rule.RuleContext} context */
-const create = context => {
-	const {
-		checkInfinity,
-		checkNaN,
-	} = {
-		checkInfinity: false,
-		checkNaN: true,
-		...context.options[0],
-	};
-
-	const objects = Object.keys(globalObjects).filter(name => {
-		if (!checkInfinity && name === 'Infinity') {
-			return false;
-		}
-
-		if (!checkNaN && name === 'NaN') {
-			return false;
-		}
-
-		return true;
-	});
-
-	new GlobalReferenceTracker({
-		objects,
-		context,
-		handle: checkProperty,
-		filter: ({node}) => !isLeftHandSide(node),
-	}).listen();
-};
-
-const schema = [
-	{
-		type: 'object',
-		additionalProperties: false,
-		properties: {
-			checkInfinity: {
-				type: 'boolean',
-			},
-			checkNaN: {
-				type: 'boolean',
-			},
-		},
-	},
-];
-
-/** @type {import('eslint').Rule.RuleModule} */
-const config = {
-	create,
-	meta: {
-		type: 'suggestion',
-		docs: {
-			description: 'Prefer `Number` static properties over global ones.',
-			recommended: 'unopinionated',
-		},
-		fixable: 'code',
-		hasSuggestions: true,
-		schema,
-		defaultOptions: [
-			{
-				checkInfinity: false,
-				checkNaN: true,
-			},
-		],
-		messages,
-	},
-};
-
-export default config;

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/prefer-object-from-entries.js

@@ -1,256 +0,0 @@
-import {isCommaToken, isArrowToken, isClosingParenToken} from '@eslint-community/eslint-utils';
-import {isMethodCall, isLiteral} from './ast/index.js';
-import {removeParentheses} from './fix/index.js';
-import {
-	getParentheses,
-	getParenthesizedText,
-	isNodeMatchesNameOrPath,
-	isSameIdentifier,
-} from './utils/index.js';
-import {isCallExpression} from './ast/call-or-new-expression.js';
-
-const MESSAGE_ID_REDUCE = 'reduce';
-const MESSAGE_ID_FUNCTION = 'function';
-const messages = {
-	[MESSAGE_ID_REDUCE]: 'Prefer `Object.fromEntries()` over `Array#reduce()`.',
-	[MESSAGE_ID_FUNCTION]: 'Prefer `Object.fromEntries()` over `{{functionName}}()`.',
-};
-
-const isEmptyObject = node =>
-	// `{}`
-	(node.type === 'ObjectExpression' && node.properties.length === 0)
-	// `Object.create(null)`
-	|| (
-		isMethodCall(node, {
-			object: 'Object',
-			method: 'create',
-			argumentsLength: 1,
-			optionalCall: false,
-			optionalMember: false,
-		})
-		// eslint-disable-next-line unicorn/no-null
-		&& isLiteral(node.arguments[0], null)
-	);
-
-const isArrowFunctionCallback = node =>
-	node.type === 'ArrowFunctionExpression'
-	&& !node.async
-	&& node.params.length > 0
-	&& node.params[0].type === 'Identifier';
-
-const isProperty = node =>
-	node.type === 'Property'
-	&& node.kind === 'init'
-	&& !node.method;
-
-// - `pairs.reduce(…, {})`
-// - `pairs.reduce(…, Object.create(null))`
-const isArrayReduceWithEmptyObject = node =>
-	isMethodCall(node, {
-		method: 'reduce',
-		argumentsLength: 2,
-		optionalCall: false,
-		optionalMember: false,
-	})
-	&& isEmptyObject(node.arguments[1]);
-
-const fixableArrayReduceCases = [
-	{
-		test: callExpression =>
-			isArrayReduceWithEmptyObject(callExpression)
-			// `() => Object.assign(object, {key})`
-			&& isArrowFunctionCallback(callExpression.arguments[0])
-			&& isMethodCall(callExpression.arguments[0].body, {
-				object: 'Object',
-				method: 'assign',
-				argumentsLength: 2,
-				optionalCall: false,
-				optionalMember: false,
-			})
-			&& callExpression.arguments[0].body.arguments[1].type === 'ObjectExpression'
-			&& callExpression.arguments[0].body.arguments[1].properties.length === 1
-			&& isProperty(callExpression.arguments[0].body.arguments[1].properties[0])
-			&& isSameIdentifier(callExpression.arguments[0].params[0], callExpression.arguments[0].body.arguments[0]),
-		getProperty: callback => callback.body.arguments[1].properties[0],
-	},
-	{
-		test: callExpression =>
-			isArrayReduceWithEmptyObject(callExpression)
-			// `() => ({...object, key})`
-			&& isArrowFunctionCallback(callExpression.arguments[0])
-			&& callExpression.arguments[0].body.type === 'ObjectExpression'
-			&& callExpression.arguments[0].body.properties.length === 2
-			&& callExpression.arguments[0].body.properties[0].type === 'SpreadElement'
-			&& isProperty(callExpression.arguments[0].body.properties[1])
-			&& isSameIdentifier(callExpression.arguments[0].params[0], callExpression.arguments[0].body.properties[0].argument),
-		getProperty: callback => callback.body.properties[1],
-	},
-];
-
-// `_.flatten(array)`
-const lodashFromPairsFunctions = [
-	'_.fromPairs',
-	'lodash.fromPairs',
-];
-
-function fixReduceAssignOrSpread({context, callExpression, property}) {
-	const {sourceCode} = context;
-	const removeInitObject = fixer => {
-		const initObject = callExpression.arguments[1];
-		const parentheses = getParentheses(initObject, context);
-		const firstToken = parentheses[0] || initObject;
-		const lastToken = parentheses.at(-1) || initObject;
-		const startToken = sourceCode.getTokenBefore(firstToken);
-		const [start] = sourceCode.getRange(startToken);
-		const [, end] = sourceCode.getRange(lastToken);
-		return fixer.removeRange([start, end]);
-	};
-
-	function * removeFirstParameter(fixer) {
-		const parameters = callExpression.arguments[0].params;
-		const [firstParameter] = parameters;
-		const tokenAfter = sourceCode.getTokenAfter(firstParameter);
-
-		if (isCommaToken(tokenAfter)) {
-			yield fixer.remove(tokenAfter);
-		}
-
-		let shouldAddParentheses = false;
-		if (parameters.length === 1) {
-			const arrowToken = sourceCode.getTokenAfter(firstParameter, isArrowToken);
-			const tokenBeforeArrowToken = sourceCode.getTokenBefore(arrowToken);
-
-			if (!isClosingParenToken(tokenBeforeArrowToken)) {
-				shouldAddParentheses = true;
-			}
-		}
-
-		yield fixer.replaceText(firstParameter, shouldAddParentheses ? '()' : '');
-	}
-
-	const getKeyValueText = () => {
-		const {key, value} = property;
-		let keyText = getParenthesizedText(key, context);
-		const valueText = getParenthesizedText(value, context);
-
-		if (!property.computed && key.type === 'Identifier') {
-			keyText = `'${keyText}'`;
-		}
-
-		return {keyText, valueText};
-	};
-
-	function * replaceFunctionBody(fixer) {
-		const functionBody = callExpression.arguments[0].body;
-		const {keyText, valueText} = getKeyValueText();
-		yield fixer.replaceText(functionBody, `[${keyText}, ${valueText}]`);
-		yield removeParentheses(functionBody, fixer, context);
-	}
-
-	return function * (fixer) {
-		// Wrap `array.reduce()` with `Object.fromEntries()`
-		yield fixer.insertTextBefore(callExpression, 'Object.fromEntries(');
-		yield fixer.insertTextAfter(callExpression, ')');
-
-		// Switch `.reduce` to `.map`
-		yield fixer.replaceText(callExpression.callee.property, 'map');
-
-		// Remove empty object
-		yield removeInitObject(fixer);
-
-		// Remove the first parameter
-		yield removeFirstParameter(fixer);
-
-		// Replace function body
-		yield replaceFunctionBody(fixer);
-	};
-}
-
-/** @param {import('eslint').Rule.RuleContext} context */
-function create(context) {
-	const {sourceCode} = context;
-	const {functions: configFunctions} = {
-		functions: [],
-		...context.options[0],
-	};
-	const functions = [...configFunctions, ...lodashFromPairsFunctions];
-
-	return {
-		* CallExpression(callExpression) {
-			for (const {test, getProperty} of fixableArrayReduceCases) {
-				if (!test(callExpression)) {
-					continue;
-				}
-
-				const [callbackFunction] = callExpression.arguments;
-				const [firstParameter] = callbackFunction.params;
-				const variables = sourceCode.getDeclaredVariables(callbackFunction);
-				const firstParameterVariable = variables.find(variable => variable.identifiers.length === 1 && variable.identifiers[0] === firstParameter);
-				if (!firstParameterVariable || firstParameterVariable.references.length !== 1) {
-					continue;
-				}
-
-				yield {
-					node: callExpression.callee.property,
-					messageId: MESSAGE_ID_REDUCE,
-					fix: fixReduceAssignOrSpread({
-						context,
-						callExpression,
-						property: getProperty(callbackFunction),
-					}),
-				};
-			}
-
-			if (!isCallExpression(callExpression, {
-				argumentsLength: 1,
-				optional: false,
-			})) {
-				return;
-			}
-
-			const functionNode = callExpression.callee;
-			for (const nameOrPath of functions) {
-				const functionName = nameOrPath.trim();
-				if (isNodeMatchesNameOrPath(functionNode, functionName)) {
-					yield {
-						node: functionNode,
-						messageId: MESSAGE_ID_FUNCTION,
-						data: {functionName},
-						fix: fixer => fixer.replaceText(functionNode, 'Object.fromEntries'),
-					};
-				}
-			}
-		},
-	};
-}
-
-const schema = [
-	{
-		type: 'object',
-		additionalProperties: false,
-		properties: {
-			functions: {
-				type: 'array',
-				uniqueItems: true,
-			},
-		},
-	},
-];
-
-/** @type {import('eslint').Rule.RuleModule} */
-const config = {
-	create,
-	meta: {
-		type: 'suggestion',
-		docs: {
-			description: 'Prefer using `Object.fromEntries(…)` to transform a list of key-value pairs into an object.',
-			recommended: 'unopinionated',
-		},
-		fixable: 'code',
-		schema,
-		defaultOptions: [{}],
-		messages,
-	},
-};
-
-export default config;