@alexlit/lint-kit 176.0.1 → 177.0.0

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/utils/parentheses.js

@@ -1,71 +0,0 @@
-import {isParenthesized, isOpeningParenToken, isClosingParenToken} from '@eslint-community/eslint-utils';
-
-/**
-@import {TSESTree as ESTree} from '@typescript-eslint/types';
-@import * as ESLint from 'eslint';
-*/
-
-/*
-Get how many times the node is parenthesized.
-
-@param {ESTree.Node} node - The node to be checked.
-@param {ESLint.Rule.RuleContext} context - The ESLint rule context object.
-@returns {number}
-*/
-function getParenthesizedTimes(node, context) {
-	let times = 0;
-
-	while (isParenthesized(times + 1, node, context.sourceCode)) {
-		times++;
-	}
-
-	return times;
-}
-
-/*
-Get all parentheses tokens around the node.
-
-@param {ESTree.Node} node - The node to be checked.
-@param {ESLint.Rule.RuleContext} context - The ESLint rule context object.
-@returns {Token[]}
-*/
-export function getParentheses(node, context) {
-	const count = getParenthesizedTimes(node, context);
-
-	if (count === 0) {
-		return [];
-	}
-
-	return [
-		...context.sourceCode.getTokensBefore(node, {count, filter: isOpeningParenToken}),
-		...context.sourceCode.getTokensAfter(node, {count, filter: isClosingParenToken}),
-	];
-}
-
-/*
-Get the parenthesized range of the node.
-
-@param {ESTree.Node} node - The node to be checked.
-@param {ESLint.Rule.RuleContext} context - The ESLint rule context object.
-@returns {number[]}
-*/
-export function getParenthesizedRange(node, context) {
-	const parentheses = getParentheses(node, context);
-	const [start] = context.sourceCode.getRange(parentheses[0] ?? node);
-	const [, end] = context.sourceCode.getRange(parentheses.at(-1) ?? node);
-	return [start, end];
-}
-
-/*
-Get the parenthesized text of the node.
-
-@param {ESTree.Node} node - The node to be checked.
-@param {ESLint.Rule.RuleContext} context - The ESLint rule context object.
-@returns {string}
-*/
-export function getParenthesizedText(node, context) {
-	const [start, end] = getParenthesizedRange(node, context);
-	return context.sourceCode.text.slice(start, end);
-}
-
-export {isParenthesized} from '@eslint-community/eslint-utils';

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/utils/resolve-variable-name.js

@@ -1,18 +0,0 @@
-/**
-Finds a variable named `name` in the scope `scope` (or it's parents).
-
-@param {string} name - The variable name to be resolve.
-@param {import('eslint').Scope.Scope} scope - The scope to look for the variable in.
-@returns {import('eslint').Scope.Variable | void} - The found variable, if any.
-*/
-export default function resolveVariableName(name, scope) {
-	while (scope) {
-		const variable = scope.set.get(name);
-
-		if (variable) {
-			return variable;
-		}
-
-		scope = scope.upper;
-	}
-}

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/utils/rule.js

@@ -1,27 +0,0 @@
-import toEslintCreate, {markFunctionWrapped} from '../rule/to-eslint-create.js';
-
-export function checkVueTemplate(unicornCreate, options) {
-	const {
-		visitScriptBlock,
-	} = {
-		visitScriptBlock: true,
-		...options,
-	};
-
-	const create = toEslintCreate(unicornCreate);
-
-	return markFunctionWrapped(context => {
-		const listeners = create(context);
-		const {parserServices} = context.sourceCode;
-
-		// `vue-eslint-parser`
-		if (parserServices?.defineTemplateBodyVisitor) {
-			return visitScriptBlock
-				? parserServices.defineTemplateBodyVisitor(listeners, listeners)
-				: parserServices.defineTemplateBodyVisitor(listeners);
-		}
-
-		return listeners;
-	});
-}
-

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/utils/should-add-parentheses-to-await-expression-argument.js

@@ -1,17 +0,0 @@
-/**
-Check if parentheses should be added to a `node` when it's used as `argument` of `AwaitExpression`.
-
-@param {Node} node - The AST node to check.
-@returns {boolean}
-*/
-export default function shouldAddParenthesesToAwaitExpressionArgument(node) {
-	return (
-		node.type === 'SequenceExpression'
-		|| node.type === 'YieldExpression'
-		|| node.type === 'ArrowFunctionExpression'
-		|| node.type === 'ConditionalExpression'
-		|| node.type === 'AssignmentExpression'
-		|| node.type === 'LogicalExpression'
-		|| node.type === 'BinaryExpression'
-	);
-}

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/utils/should-add-parentheses-to-call-expression-callee.js

@@ -1,18 +0,0 @@
-/**
-Check if parentheses should be added to a `node` when it's used as `callee` of `CallExpression`.
-
-@param {Node} node - The AST node to check.
-@returns {boolean}
-*/
-export default function shouldAddParenthesesToCallExpressionCallee(node) {
-	return node.type === 'SequenceExpression'
-		|| node.type === 'YieldExpression'
-		|| node.type === 'ArrowFunctionExpression'
-		|| node.type === 'ConditionalExpression'
-		|| node.type === 'AssignmentExpression'
-		|| node.type === 'LogicalExpression'
-		|| node.type === 'BinaryExpression'
-		|| node.type === 'UnaryExpression'
-		|| node.type === 'UpdateExpression'
-		|| node.type === 'NewExpression';
-}

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/utils/should-add-parentheses-to-conditional-expression-child.js

@@ -1,13 +0,0 @@
-/**
-Check if parentheses should be added to a `node` when it's used as child of `ConditionalExpression`.
-
-@param {Node} node - The AST node to check.
-@returns {boolean}
-*/
-export default function shouldAddParenthesesToConditionalExpressionChild(node) {
-	return node.type === 'AwaitExpression'
-		// Lower precedence, see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Operator_Precedence#Table
-		|| node.type === 'AssignmentExpression'
-		|| node.type === 'YieldExpression'
-		|| node.type === 'SequenceExpression';
-}

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/utils/should-add-parentheses-to-expression-statement-expression.js

@@ -1,22 +0,0 @@
-/**
-Check if parentheses should to be added to a `node` when it's used as an `expression` of `ExpressionStatement`.
-
-@param {Node} node - The AST node to check.
-@param {SourceCode} sourceCode - The source code object.
-@returns {boolean}
-*/
-export default function shouldAddParenthesesToExpressionStatementExpression(node) {
-	switch (node.type) {
-		case 'ObjectExpression': {
-			return true;
-		}
-
-		case 'AssignmentExpression': {
-			return node.left.type === 'ObjectPattern' || node.left.type === 'ArrayPattern';
-		}
-
-		default: {
-			return false;
-		}
-	}
-}

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/utils/should-add-parentheses-to-logical-expression-child.js

@@ -1,43 +0,0 @@
-/**
-Check if parentheses should be added to a `node` when it's used as child of `LogicalExpression`.
-@param {Node} node - The AST node to check.
-@param {{operator: string, property: string}} options - Options
-@returns {boolean}
-*/
-export default function shouldAddParenthesesToLogicalExpressionChild(node, {operator, property}) {
-	// We are not using this, but we can improve this function with it
-	/* c8 ignore next 3 */
-	if (!property) {
-		throw new Error('`property` is required.');
-	}
-
-	if (
-		node.type === 'LogicalExpression'
-		&& node.operator === operator
-	) {
-		return false;
-	}
-
-	// Not really needed, but more readable
-	if (
-		node.type === 'AwaitExpression'
-		|| node.type === 'BinaryExpression'
-	) {
-		return true;
-	}
-
-	// Lower precedence than `LogicalExpression`
-	// see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Operator_Precedence#Table
-	if (
-		node.type === 'LogicalExpression'
-		|| node.type === 'ConditionalExpression'
-		|| node.type === 'AssignmentExpression'
-		|| node.type === 'ArrowFunctionExpression'
-		|| node.type === 'YieldExpression'
-		|| node.type === 'SequenceExpression'
-	) {
-		return true;
-	}
-
-	return false;
-}

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/utils/should-add-parentheses-to-member-expression-object.js

@@ -1,47 +0,0 @@
-import isNewExpressionWithParentheses from './is-new-expression-with-parentheses.js';
-import {isDecimalIntegerNode} from './numeric.js';
-/**
-@import {TSESTree as ESTree} from '@typescript-eslint/types';
-@import * as ESLint from 'eslint';
-*/
-
-/**
-Check if parentheses should to be added to a `node` when it's used as an `object` of `MemberExpression`.
-
-@param {ESTree.Node} node - The AST node to check.
-@param {ESLint.Rule.RuleContext} context - The ESLint rule context object.
-@returns {boolean}
-*/
-export default function shouldAddParenthesesToMemberExpressionObject(node, context) {
-	switch (node.type) {
-		// This is not a full list. Some other nodes like `FunctionDeclaration` don't need parentheses,
-		// but it's not possible to be in the place we are checking at this point.
-		case 'Identifier':
-		case 'MemberExpression':
-		case 'CallExpression':
-		case 'ChainExpression':
-		case 'TemplateLiteral':
-		case 'ThisExpression':
-		case 'ArrayExpression':
-		case 'FunctionExpression': {
-			return false;
-		}
-
-		case 'NewExpression': {
-			return !isNewExpressionWithParentheses(node, context);
-		}
-
-		case 'Literal': {
-			/* c8 ignore next */
-			if (isDecimalIntegerNode(node)) {
-				return true;
-			}
-
-			return false;
-		}
-
-		default: {
-			return true;
-		}
-	}
-}

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/utils/should-add-parentheses-to-new-expression-callee.js

@@ -1,28 +0,0 @@
-// Copied from https://github.com/eslint/eslint/blob/aa87329d919f569404ca573b439934552006572f/lib/rules/no-extra-parens.js#L448
-/**
-Check if a member expression contains a call expression.
-
-@param {ASTNode} node - The `MemberExpression` node to evaluate.
-@returns {boolean} true if found, false if not.
-*/
-function doesMemberExpressionContainCallExpression(node) {
-	let currentNode = node.object;
-	let currentNodeType = node.object.type;
-
-	while (currentNodeType === 'MemberExpression') {
-		currentNode = currentNode.object;
-		currentNodeType = currentNode.type;
-	}
-
-	return currentNodeType === 'CallExpression';
-}
-
-/**
-Check if parentheses should be added to a `node` when it's used as `callee` of `NewExpression`.
-
-@param {Node} node - The AST node to check.
-@returns {boolean}
-*/
-export default function shouldAddParenthesesToNewExpressionCallee(node) {
-	return node.type === 'MemberExpression' && doesMemberExpressionContainCallExpression(node);
-}

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/utils/should-add-parentheses-to-unary-expression.js

@@ -1,24 +0,0 @@
-/**
-Check if parentheses should be added to a `node` when it's used as `argument` of `UnaryExpression`.
-
-@param {Node} node - The AST node to check.
-@param {string} operator - The UnaryExpression operator.
-@returns {boolean}
-*/
-export default function shouldAddParenthesesToUnaryExpressionArgument(node, operator) {
-	// Only support `!` operator
-	if (operator !== '!') {
-		throw new Error('Unexpected operator');
-	}
-
-	return (
-		node.type === 'UpdateExpression'
-		|| node.type === 'BinaryExpression'
-		|| node.type === 'LogicalExpression'
-		|| node.type === 'ConditionalExpression'
-		|| node.type === 'AssignmentExpression'
-		|| node.type === 'ArrowFunctionExpression'
-		|| node.type === 'YieldExpression'
-		|| node.type === 'SequenceExpression'
-	);
-}

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/utils/singular.js

@@ -1,16 +0,0 @@
-import pluralize_ from 'pluralize';
-
-/**
-Singularizes a word/name, i.e. `items` to `item`.
-
-@param {string} original - The word/name to singularize.
-@returns {string|undefined} - The singularized result, or `undefined` if attempting singularization resulted in no change.
-*/
-const singular = original => {
-	const singularized = pluralize_.singular(original);
-	if (singularized !== original) {
-		return singularized;
-	}
-};
-
-export default singular;

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/utils/string-cases.js

@@ -1,2 +0,0 @@
-export const upperFirst = string => string.charAt(0).toUpperCase() + string.slice(1);
-export const lowerFirst = string => string.charAt(0).toLowerCase() + string.slice(1);

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/utils/to-location.js

@@ -1,25 +0,0 @@
-/**
-@import {TSESTree as ESTree} from '@typescript-eslint/types';
-@import * as ESLint from 'eslint';
-*/
-
-/**
-Get location info for the given node or range.
-
-@param {ESTree.Node | ESTree.Range} nodeOrRange - The AST node or range to get the location for.
-@param {ESLint.Rule.RuleContext} context - The ESLint rule context object.
-@param {int} [startOffset] - Start position offset.
-@param {int} [endOffset] - End position offset.
-@returns {ESTree.SourceLocation}
-*/
-function toLocation(nodeOrRange, context, startOffset = 0, endOffset = 0) {
-	const {sourceCode} = context;
-	const [start, end] = Array.isArray(nodeOrRange) ? nodeOrRange : sourceCode.getRange(nodeOrRange);
-
-	return {
-		start: sourceCode.getLocFromIndex(start + startOffset),
-		end: sourceCode.getLocFromIndex(end + endOffset),
-	};
-}
-
-export default toLocation;