@alexlit/lint-kit 175.0.0 → 176.0.1

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

@@ -0,0 +1,211 @@
+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

@@ -0,0 +1,86 @@
+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

@@ -0,0 +1,142 @@
+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

@@ -0,0 +1,256 @@
+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;