@alexlit/lint-kit 176.0.0 → 177.0.0

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

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

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

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