@alexlit/lint-kit 175.0.0 → 176.0.0

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

@@ -0,0 +1,288 @@
+import {isParenthesized} from '@eslint-community/eslint-utils';
+import {
+	getAvailableVariableName,
+	needsSemicolon,
+	isSameReference,
+	getIndentString,
+	getParenthesizedText,
+	shouldAddParenthesesToConditionalExpressionChild,
+	getScopes,
+} from './utils/index.js';
+import {extendFixRange} from './fix/index.js';
+
+const messageId = 'prefer-ternary';
+
+const isTernary = node => node?.type === 'ConditionalExpression';
+
+function getNodeBody(node) {
+	/* c8 ignore next 3 */
+	if (!node) {
+		return;
+	}
+
+	if (node.type === 'ExpressionStatement') {
+		return getNodeBody(node.expression);
+	}
+
+	if (node.type === 'BlockStatement') {
+		const body = node.body.filter(({type}) => type !== 'EmptyStatement');
+		if (body.length === 1) {
+			return getNodeBody(body[0]);
+		}
+	}
+
+	return node;
+}
+
+const isSingleLineNode = (node, context) =>
+	context.sourceCode.getLoc(node).start.line === context.sourceCode.getLoc(node).end.line;
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => {
+	const onlySingleLine = context.options[0] === 'only-single-line';
+	const {sourceCode} = context;
+	const scopeToNamesGeneratedByFixer = new WeakMap();
+	const isSafeName = (name, scopes) => scopes.every(scope => {
+		const generatedNames = scopeToNamesGeneratedByFixer.get(scope);
+		return !generatedNames || !generatedNames.has(name);
+	});
+
+	const getText = node => {
+		let text = getParenthesizedText(node, context);
+		if (
+			!isParenthesized(node, sourceCode)
+			&& shouldAddParenthesesToConditionalExpressionChild(node)
+		) {
+			text = `(${text})`;
+		}
+
+		return text;
+	};
+
+	// eslint-disable-next-line complexity
+	function merge(options, mergeOptions) {
+		const {
+			before = '',
+			after = ';',
+			consequent,
+			alternate,
+			node,
+		} = options;
+
+		const {
+			checkThrowStatement,
+			returnFalseIfNotMergeable,
+		} = {
+			checkThrowStatement: false,
+			returnFalseIfNotMergeable: false,
+			...mergeOptions,
+		};
+
+		if (!consequent || !alternate || consequent.type !== alternate.type) {
+			return returnFalseIfNotMergeable ? false : options;
+		}
+
+		const {type, argument, delegate, left, right, operator} = consequent;
+
+		if (
+			type === 'ReturnStatement'
+			&& !isTernary(argument)
+			&& !isTernary(alternate.argument)
+		) {
+			return merge({
+				before: `${before}return `,
+				after,
+				consequent: argument === null ? 'undefined' : argument,
+				alternate: alternate.argument === null ? 'undefined' : alternate.argument,
+				node,
+			});
+		}
+
+		if (
+			type === 'YieldExpression'
+			&& delegate === alternate.delegate
+			&& !isTernary(argument)
+			&& !isTernary(alternate.argument)
+		) {
+			return merge({
+				before: `${before}yield${delegate ? '*' : ''} (`,
+				after: `)${after}`,
+				consequent: argument === null ? 'undefined' : argument,
+				alternate: alternate.argument === null ? 'undefined' : alternate.argument,
+				node,
+			});
+		}
+
+		if (
+			type === 'AwaitExpression'
+			&& !isTernary(argument)
+			&& !isTernary(alternate.argument)
+		) {
+			return merge({
+				before: `${before}await (`,
+				after: `)${after}`,
+				consequent: argument,
+				alternate: alternate.argument,
+				node,
+			});
+		}
+
+		if (
+			checkThrowStatement
+			&& type === 'ThrowStatement'
+			&& !isTernary(argument)
+			&& !isTernary(alternate.argument)
+		) {
+			// `ThrowStatement` don't check nested
+
+			// If `IfStatement` is not a `BlockStatement`, need add `{}`
+			const {parent} = node;
+			const needBraces = parent && parent.type !== 'BlockStatement';
+			return {
+				type,
+				before: `${before}${needBraces ? '{\n{{INDENT_STRING}}' : ''}const {{ERROR_NAME}} = `,
+				after: `;\n{{INDENT_STRING}}throw {{ERROR_NAME}};${needBraces ? '\n}' : ''}`,
+				consequent: argument,
+				alternate: alternate.argument,
+			};
+		}
+
+		if (
+			type === 'AssignmentExpression'
+			&& operator === alternate.operator
+			&& !isTernary(left)
+			&& !isTernary(alternate.left)
+			&& !isTernary(right)
+			&& !isTernary(alternate.right)
+			&& isSameReference(left, alternate.left)
+		) {
+			return merge({
+				before: `${before}${sourceCode.getText(left)} ${operator} `,
+				after,
+				consequent: right,
+				alternate: alternate.right,
+				node,
+			});
+		}
+
+		return returnFalseIfNotMergeable ? false : options;
+	}
+
+	return {
+		IfStatement(node) {
+			if (
+				(node.parent.type === 'IfStatement' && node.parent.alternate === node)
+				|| node.test.type === 'ConditionalExpression'
+				|| !node.consequent
+				|| !node.alternate
+			) {
+				return;
+			}
+
+			const consequent = getNodeBody(node.consequent);
+			const alternate = getNodeBody(node.alternate);
+
+			if (
+				onlySingleLine
+				&& [consequent, alternate, node.test].some(node => !isSingleLineNode(node, context))
+			) {
+				return;
+			}
+
+			const result = merge({node, consequent, alternate}, {
+				checkThrowStatement: true,
+				returnFalseIfNotMergeable: true,
+			});
+
+			if (!result) {
+				return;
+			}
+
+			const problem = {node, messageId};
+
+			// Don't fix if there are comments
+			if (sourceCode.getCommentsInside(node).length > 0) {
+				return problem;
+			}
+
+			const scope = sourceCode.getScope(node);
+			problem.fix = function * (fixer) {
+				const testText = getText(node.test);
+				const consequentText = typeof result.consequent === 'string'
+					? result.consequent
+					: getText(result.consequent);
+				const alternateText = typeof result.alternate === 'string'
+					? result.alternate
+					: getText(result.alternate);
+
+				let {type, before, after} = result;
+
+				let generateNewVariables = false;
+				if (type === 'ThrowStatement') {
+					const scopes = getScopes(scope);
+					const errorName = getAvailableVariableName('error', scopes, isSafeName);
+
+					for (const scope of scopes) {
+						if (!scopeToNamesGeneratedByFixer.has(scope)) {
+							scopeToNamesGeneratedByFixer.set(scope, new Set());
+						}
+
+						const generatedNames = scopeToNamesGeneratedByFixer.get(scope);
+						generatedNames.add(errorName);
+					}
+
+					const indentString = getIndentString(node, context);
+
+					after = after
+						.replace('{{INDENT_STRING}}', indentString)
+						.replace('{{ERROR_NAME}}', errorName);
+					before = before
+						.replace('{{INDENT_STRING}}', indentString)
+						.replace('{{ERROR_NAME}}', errorName);
+					generateNewVariables = true;
+				}
+
+				let fixed = `${before}${testText} ? ${consequentText} : ${alternateText}${after}`;
+				const tokenBefore = sourceCode.getTokenBefore(node);
+				const shouldAddSemicolonBefore = needsSemicolon(tokenBefore, context, fixed);
+				if (shouldAddSemicolonBefore) {
+					fixed = `;${fixed}`;
+				}
+
+				yield fixer.replaceText(node, fixed);
+
+				if (generateNewVariables) {
+					yield extendFixRange(fixer, sourceCode.getRange(sourceCode.ast));
+				}
+			};
+
+			return problem;
+		},
+	};
+};
+
+const schema = [
+	{
+		enum: ['always', 'only-single-line'],
+	},
+];
+
+/** @type {import('eslint').Rule.RuleModule} */
+const config = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Prefer ternary expressions over simple `if-else` statements.',
+			recommended: 'unopinionated',
+		},
+		fixable: 'code',
+		schema,
+		defaultOptions: ['always'],
+		messages: {
+			[messageId]: 'This `if` statement can be replaced by a ternary expression.',
+		},
+	},
+};
+
+export default config;

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/prefer-top-level-await.js

@@ -0,0 +1,154 @@
+import {findVariable, getFunctionHeadLocation} from '@eslint-community/eslint-utils';
+import {isFunction, isMemberExpression, isMethodCall} from './ast/index.js';
+
+const ERROR_PROMISE = 'promise';
+const ERROR_IIFE = 'iife';
+const ERROR_IDENTIFIER = 'identifier';
+const SUGGESTION_ADD_AWAIT = 'add-await';
+const messages = {
+	[ERROR_PROMISE]: 'Prefer top-level await over using a promise chain.',
+	[ERROR_IIFE]: 'Prefer top-level await over an async IIFE.',
+	[ERROR_IDENTIFIER]: 'Prefer top-level await over an async function `{{name}}` call.',
+	[SUGGESTION_ADD_AWAIT]: 'Insert `await`.',
+};
+
+const promisePrototypeMethods = ['then', 'catch', 'finally'];
+const isTopLevelCallExpression = node => {
+	if (node.type !== 'CallExpression') {
+		return false;
+	}
+
+	for (let ancestor = node.parent; ancestor; ancestor = ancestor.parent) {
+		if (
+			isFunction(ancestor)
+			|| ancestor.type === 'ClassDeclaration'
+			|| ancestor.type === 'ClassExpression'
+		) {
+			return false;
+		}
+	}
+
+	return true;
+};
+
+const isPromiseMethodCalleeObject = node =>
+	node.parent.type === 'MemberExpression'
+	&& node.parent.object === node
+	&& !node.parent.computed
+	&& node.parent.property.type === 'Identifier'
+	&& promisePrototypeMethods.includes(node.parent.property.name)
+	&& node.parent.parent.type === 'CallExpression'
+	&& node.parent.parent.callee === node.parent;
+const isAwaitExpressionArgument = node => {
+	if (node.parent.type === 'ChainExpression') {
+		node = node.parent;
+	}
+
+	return node.parent.type === 'AwaitExpression' && node.parent.argument === node;
+};
+
+// `Promise.{all,allSettled,any,race}([foo()])`
+const isInPromiseMethods = node =>
+	node.parent.type === 'ArrayExpression'
+	&& node.parent.elements.includes(node)
+	&& isMethodCall(node.parent.parent, {
+		object: 'Promise',
+		methods: ['all', 'allSettled', 'any', 'race'],
+		argumentsLength: 1,
+	})
+	&& node.parent.parent.arguments[0] === node.parent;
+
+/** @param {import('eslint').Rule.RuleContext} context */
+function create(context) {
+	if (context.filename.toLowerCase().endsWith('.cjs')) {
+		return;
+	}
+
+	return {
+		CallExpression(node) {
+			if (
+				!isTopLevelCallExpression(node)
+				|| isPromiseMethodCalleeObject(node)
+				|| isAwaitExpressionArgument(node)
+				|| isInPromiseMethods(node)
+			) {
+				return;
+			}
+
+			// Promises
+			if (isMemberExpression(node.callee, {
+				properties: promisePrototypeMethods,
+				computed: false,
+			})) {
+				return {
+					node: node.callee.property,
+					messageId: ERROR_PROMISE,
+				};
+			}
+
+			const {sourceCode} = context;
+
+			// IIFE
+			if (
+				(node.callee.type === 'FunctionExpression' || node.callee.type === 'ArrowFunctionExpression')
+				&& node.callee.async
+				&& !node.callee.generator
+			) {
+				return {
+					node,
+					loc: getFunctionHeadLocation(node.callee, sourceCode),
+					messageId: ERROR_IIFE,
+				};
+			}
+
+			// Identifier
+			if (node.callee.type !== 'Identifier') {
+				return;
+			}
+
+			const variable = findVariable(sourceCode.getScope(node), node.callee);
+			if (!variable || variable.defs.length !== 1) {
+				return;
+			}
+
+			const [definition] = variable.defs;
+			const value = definition.type === 'Variable' && definition.kind === 'const'
+				? definition.node.init
+				: definition.node;
+			if (
+				!value
+				|| !(isFunction(value) && !value.generator && value.async)
+			) {
+				return;
+			}
+
+			return {
+				node,
+				messageId: ERROR_IDENTIFIER,
+				data: {name: node.callee.name},
+				suggest: [
+					{
+						messageId: SUGGESTION_ADD_AWAIT,
+						fix: fixer => fixer.insertTextBefore(node, 'await '),
+					},
+				],
+			};
+		},
+	};
+}
+
+/** @type {import('eslint').Rule.RuleModule} */
+const config = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Prefer top-level await over top-level promises and async function calls.',
+			recommended: 'unopinionated',
+		},
+		hasSuggestions: true,
+		messages,
+	},
+};
+
+export default config;

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

@@ -0,0 +1,169 @@
+import {isNewExpression} from './ast/index.js';
+
+const MESSAGE_ID = 'prefer-type-error';
+const messages = {
+	[MESSAGE_ID]: '`new Error()` is too unspecific for a type check. Use `new TypeError()` instead.',
+};
+
+const typeCheckIdentifiers = new Set([
+	'isArguments',
+	'isArray',
+	'isArrayBuffer',
+	'isArrayLike',
+	'isArrayLikeObject',
+	'isBigInt',
+	'isBoolean',
+	'isBuffer',
+	'isDate',
+	'isElement',
+	'isError',
+	'isFinite',
+	'isFunction',
+	'isInteger',
+	'isLength',
+	'isMap',
+	'isNaN',
+	'isNative',
+	'isNil',
+	'isNull',
+	'isNumber',
+	'isObject',
+	'isObjectLike',
+	'isPlainObject',
+	'isPrototypeOf',
+	'isRegExp',
+	'isSafeInteger',
+	'isSet',
+	'isString',
+	'isSymbol',
+	'isTypedArray',
+	'isUndefined',
+	'isView',
+	'isWeakMap',
+	'isWeakSet',
+	'isWindow',
+	'isXMLDoc',
+]);
+
+const typeCheckGlobalIdentifiers = new Set([
+	'isNaN',
+	'isFinite',
+]);
+
+const isTypecheckingIdentifier = (node, callExpression, isMemberExpression) =>
+	callExpression !== undefined
+	&& callExpression.arguments.length > 0
+	&& node.type === 'Identifier'
+	&& (
+		(isMemberExpression === true && typeCheckIdentifiers.has(node.name))
+		|| (isMemberExpression === false && typeCheckGlobalIdentifiers.has(node.name))
+	);
+
+const isLone = node => node.parent && node.parent.body && node.parent.body.length === 1;
+
+const isTypecheckingMemberExpression = (node, callExpression) => {
+	if (isTypecheckingIdentifier(node.property, callExpression, true)) {
+		return true;
+	}
+
+	if (node.object.type === 'MemberExpression') {
+		return isTypecheckingMemberExpression(node.object, callExpression);
+	}
+
+	return false;
+};
+
+const errorNameRegexp = /^(?:[A-Z][\da-z]*)*Error$/;
+const isErrorConstructor = node => {
+	if (node.type === 'Identifier') {
+		return errorNameRegexp.test(node.name);
+	}
+
+	if (node.type === 'MemberExpression' && !node.optional && !node.computed && node.property.type === 'Identifier') {
+		return errorNameRegexp.test(node.property.name);
+	}
+
+	return false;
+};
+
+const isTypecheckingExpression = (node, callExpression) => {
+	switch (node.type) {
+		case 'Identifier': {
+			return isTypecheckingIdentifier(node, callExpression, false);
+		}
+
+		case 'MemberExpression': {
+			return isTypecheckingMemberExpression(node, callExpression);
+		}
+
+		case 'CallExpression': {
+			return isTypecheckingExpression(node.callee, node);
+		}
+
+		case 'UnaryExpression': {
+			return (
+				node.operator === 'typeof'
+				|| (node.operator === '!' && isTypecheckingExpression(node.argument))
+			);
+		}
+
+		case 'BinaryExpression': {
+			const {operator, left, right} = node;
+
+			if (operator === 'instanceof') {
+				return !isErrorConstructor(right);
+			}
+
+			return isTypecheckingExpression(left, callExpression)
+				|| isTypecheckingExpression(right, callExpression);
+		}
+
+		case 'LogicalExpression': {
+			return (
+				isTypecheckingExpression(node.left, callExpression)
+				&& isTypecheckingExpression(node.right, callExpression)
+			);
+		}
+
+		default: {
+			return false;
+		}
+	}
+};
+
+const isTypechecking = node => node.type === 'IfStatement' && isTypecheckingExpression(node.test);
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = () => ({
+	ThrowStatement(node) {
+		if (
+			isNewExpression(node.argument, {name: 'Error'})
+			&& isLone(node)
+			&& node.parent.parent
+			&& isTypechecking(node.parent.parent)
+		) {
+			const errorConstructor = node.argument.callee;
+			return {
+				node: errorConstructor,
+				messageId: MESSAGE_ID,
+				fix: fixer => fixer.insertTextBefore(errorConstructor, 'Type'),
+			};
+		}
+	},
+});
+
+/** @type {import('eslint').Rule.RuleModule} */
+const config = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Enforce throwing `TypeError` in type checking conditions.',
+			recommended: 'unopinionated',
+		},
+		fixable: 'code',
+		messages,
+	},
+};
+
+export default config;