javascript - Räkna alla funktioner, pilfunktioner, klassmetoder från TypeScript-fil med regex

Jag implementerar en funktion som tar emot en filsökväg som en parameter och returnerar det totala antalet vanliga funktioner, arrow-funktioner, klassmetoder, setters och getters som finns i filen.

Eftersom det finns flera sätt att deklarera en klassmetod på, (t.ex. public methodName(parameter 1, ...) , private methodName(...)) tänkte jag använda reguljära uttryck för att hämta antalet klassmetoder. Något i stil med:

const countClassMethods = (typescriptFileString: string): number => {
    return typescriptFileString.match('REGULAR_EXPRESSION_TO_COUNT_CLASS_METHODS')?.length || 0;
}

const extractAllFunctionOcurences = (filePath: string): number => {
    const typescriptFileString = fs.readFileSync(filePath, 'utf8');

    const quantityOfNormalFunctions = countNormalFunction(typescriptFileString);
    const quantityOfArrowFunctions = countArrowFunctions(typescriptFileString);
    const quantityOfClassMethods = countClassMethods(typescriptFileString);
    const quantityOfGettersAndSetters = countGettersAndSetters(typescriptFileString);
    return quantityOfNormalFunctions + quantityOfArrowFunctions + quantityOfClassMethods + quantityOfGettersAndSetters;
}

Mina frågor är:

1) Vilket är den lämpliga Regex att använda för att identifiera klassmetoder från en TypeScript-fil

2) Om det finns bättre sätt att identifiera dem, vilka är de.

Ps: Jag försökte leta efter detta på Google men kunde inte hitta ett tillfredsställande svar. Tack på förhand.

redigera: hittills har jag fått den nuvarande Regex att fungera för klassmetoder: "myFileString".match(/(public |private |protected )*\s{0,}[^\n\r\t\v\0\s]+\(\s*([^)]+?)\s*\)(\s*\:\s*[^\n\r\t\v\0\s]+)*\s*{/igm)

Jag kommer att uppdatera det om jag kan hitta en bättre.

redigera 2: Följande @Timos förslag, detta är min slutliga kod, om någon är intresserad:

'use strict';
import fs from 'fs';
import ts from 'typescript';

const extractAllFunctionOcurences = (filename: string): number => {

    let numOfFunctions = 0;
    const delintNode = (node: ts.Node) => {
        switch (node.kind) {
            case ts.SyntaxKind.FunctionDeclaration:
            case ts.SyntaxKind.FunctionKeyword:
            case ts.SyntaxKind.FunctionExpression:
            case ts.SyntaxKind.ArrowFunction:
            case ts.SyntaxKind.ClassDeclaration:
            case ts.SyntaxKind.MethodDeclaration:
            case ts.SyntaxKind.GetAccessor:
            case ts.SyntaxKind.SetAccessor:
                numOfFunctions += 1;
        }
        ts.forEachChild(node, delintNode);
    };

    if (!fs.existsSync(filename)) return 0;

    const sourceFile = ts.createSourceFile(
        filename,
        fs.readFileSync(filename).toString(),
        ts.ScriptTarget.ES2015,
        true
    );

    delintNode(sourceFile);

    return numOfFunctions;
};