chore: extracted node type checking functions to ts-utils

Author: marekdedic

packages/eslint-plugin-svelte/src/rules/require-event-prefix.ts

@@ -1,13 +1,15 @@
 import { createRule } from '../utils/index.js';
-import { type TSTools, getTypeScriptTools, isMethodType } from '../utils/ts-utils/index.js';
 import {
-	type MethodSignature,
-	type Symbol,
-	SyntaxKind,
-	type Type,
-	type TypeReferenceNode,
-	type PropertySignature
-} from 'typescript';
+	type TSTools,
+	getTypeScriptTools,
+	isMethodType,
+	isPropertySignatureKind,
+	isFunctionTypeKind,
+	isMethodSignatureKind,
+	isTypeReferenceKind,
+	isIdentifierKind
+} from '../utils/ts-utils/index.js';
+import type { Symbol, Type } from 'typescript';
 import type { CallExpression } from 'estree';
 
 export default createRule('require-event-prefix', {
@@ -58,7 +60,7 @@ export default createRule('require-event-prefix', {
 					if (
 						isFunctionLike(property, tsTools) &&
 						!property.getName().startsWith('on') &&
-						(checkAsyncFunctions || !isFunctionAsync(property))
+						(checkAsyncFunctions || !isFunctionAsync(property, tsTools))
 					) {
 						const declarationTsNode = property.getDeclarations()?.[0];
 						const declarationEstreeNode =
@@ -99,25 +101,25 @@ function isFunctionLike(functionSymbol: Symbol, tsTools: TSTools): boolean {
 			tsTools.service.program.getTypeChecker().getTypeOfSymbol(functionSymbol),
 			tsTools.ts
 		) ||
-		(functionSymbol.valueDeclaration?.kind === SyntaxKind.PropertySignature &&
-			(functionSymbol.valueDeclaration as PropertySignature).type?.kind === SyntaxKind.FunctionType)
+		(functionSymbol.valueDeclaration !== undefined &&
+			isPropertySignatureKind(functionSymbol.valueDeclaration, tsTools.ts) &&
+			functionSymbol.valueDeclaration.type !== undefined &&
+			isFunctionTypeKind(functionSymbol.valueDeclaration.type, tsTools.ts))
 	);
 }
 
-function isFunctionAsync(functionSymbol: Symbol): boolean {
+function isFunctionAsync(functionSymbol: Symbol, tsTools: TSTools): boolean {
 	return (
 		functionSymbol.getDeclarations()?.some((declaration) => {
-			if (declaration.kind !== SyntaxKind.MethodSignature) {
+			if (!isMethodSignatureKind(declaration, tsTools.ts)) {
 				return false;
 			}
-			const declarationType = (declaration as MethodSignature).type;
-			if (declarationType?.kind !== SyntaxKind.TypeReference) {
+			if (declaration.type === undefined || !isTypeReferenceKind(declaration.type, tsTools.ts)) {
 				return false;
 			}
-			const declarationTypeName = (declarationType as TypeReferenceNode).typeName;
 			return (
-				declarationTypeName.kind === SyntaxKind.Identifier &&
-				declarationTypeName.escapedText === 'Promise'
+				isIdentifierKind(declaration.type.typeName, tsTools.ts) &&
+				declaration.type.typeName.escapedText === 'Promise'
 			);
 		}) ?? false
 	);

packages/eslint-plugin-svelte/src/utils/ts-utils/index.ts

@@ -313,3 +313,41 @@ export function getTypeOfPropertyOfType(
 	// eslint-disable-next-line @typescript-eslint/no-explicit-any -- getTypeOfPropertyOfType is an internal API of TS.
 	return (checker as any).getTypeOfPropertyOfType(type, name);
 }
+
+/**
+ * Check whether the given node is a property signature kind or not.
+ */
+export function isPropertySignatureKind(
+	node: TS.Node,
+	ts: TypeScript
+): node is TS.PropertySignature {
+	return node.kind === ts.SyntaxKind.PropertySignature;
+}
+
+/**
+ * Check whether the given node is a function type kind or not.
+ */
+export function isFunctionTypeKind(node: TS.Node, ts: TypeScript): node is TS.FunctionTypeNode {
+	return node.kind === ts.SyntaxKind.FunctionType;
+}
+
+/**
+ * Check whether the given node is a method signature kind or not.
+ */
+export function isMethodSignatureKind(node: TS.Node, ts: TypeScript): node is TS.MethodSignature {
+	return node.kind === ts.SyntaxKind.MethodSignature;
+}
+
+/**
+ * Check whether the given node is a type reference kind or not.
+ */
+export function isTypeReferenceKind(node: TS.Node, ts: TypeScript): node is TS.TypeReferenceNode {
+	return node.kind === ts.SyntaxKind.TypeReference;
+}
+
+/**
+ * Check whether the given node is an identifier kind or not.
+ */
+export function isIdentifierKind(node: TS.Node, ts: TypeScript): node is TS.Identifier {
+	return node.kind === ts.SyntaxKind.Identifier;
+}