chore: extracted node type checking functions to ts-utils

Author: marekdedic

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

@@ -1,13 +1,15 @@
 import { createRule } from '../utils/index.js';
-import { type TSTools, getTypeScriptTools, isMethodSymbol } from '../utils/ts-utils/index.js';
 import {
-	type MethodSignature,
-	type Symbol,
-	SyntaxKind,
-	type Type,
-	type TypeReferenceNode,
-	type PropertySignature
-} from 'typescript';
+	type TSTools,
+	getTypeScriptTools,
+	isMethodSymbol,
+	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 =
@@ -96,25 +98,25 @@ function getPropsType(node: CallExpression, tsTools: TSTools): Type | undefined
 function isFunctionLike(functionSymbol: Symbol, tsTools: TSTools): boolean {
 	return (
 		isMethodSymbol(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
 	);

Diff for: packages/eslint-plugin-svelte/src/utils/ts-utils/index.ts

@@ -314,3 +314,41 @@ export function getTypeOfPropertyOfType(
 export function isMethodSymbol(type: TS.Symbol, ts: TypeScript): boolean {
 	return (type.getFlags() & ts.SymbolFlags.Method) !== 0;
 }
+
+/**
+ * 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;
+}