support function

factory/parser.ts

@@ -38,6 +38,7 @@ import { UndefinedTypeNodeParser } from "../src/NodeParser/UndefinedTypeNodePars
 import { UnionNodeParser } from "../src/NodeParser/UnionNodeParser";
 import { SubNodeParser } from "../src/SubNodeParser";
 import { TopRefNodeParser } from "../src/TopRefNodeParser";
+import { FunctionDeclarationTypeNodeParser } from "../src/NodeParser/FunctionDeclarationTypeNodeParser";
 
 
 export function createParser(program: ts.Program, config: Config): NodeParser {
@@ -107,7 +108,8 @@ export function createParser(program: ts.Program, config: Config): NodeParser {
             new TypeLiteralNodeParser(withJsDoc(chainNodeParser)),
         ))))
 
-        .addNodeParser(new ArrayNodeParser(chainNodeParser));
+        .addNodeParser(new ArrayNodeParser(chainNodeParser))
+        .addNodeParser(new FunctionDeclarationTypeNodeParser(typeChecker, chainNodeParser));
 
     return withTopRef(chainNodeParser);
 }

src/NodeParser/FunctionDeclarationTypeNodeParser.ts

@@ -0,0 +1,40 @@
+import * as ts from "typescript";
+import { Context, NodeParser } from "../NodeParser";
+import { SubNodeParser } from "../SubNodeParser";
+import { BaseType } from "../Type/BaseType";
+import { ObjectProperty, ObjectType } from "../Type/ObjectType";
+import { getKey } from "../Utils/nodeKey";
+
+export class FunctionDeclarationTypeNodeParser implements SubNodeParser {
+    public constructor(
+        private typeChecker: ts.TypeChecker,
+        private childNodeParser: NodeParser,
+    ) {
+    }
+
+    public supportsNode(node: ts.FunctionDeclaration): boolean {
+        return node.kind === ts.SyntaxKind.FunctionDeclaration;
+    }
+    public createType(node: ts.FunctionDeclaration, context: Context): BaseType {
+        return new ObjectType(
+            this.getTypeId(node, context),
+            [],
+            this.getParameters(node, context),
+            false,
+        );
+    }
+
+    private getParameters(node: ts.FunctionDeclaration, context: Context): ObjectProperty[] {
+        return node.parameters.map(paramNode => {
+            return new ObjectProperty(
+                paramNode.name.getText(),
+                this.childNodeParser.createType(paramNode.type!, context),
+                !paramNode.questionToken,
+            );
+        });
+    }
+
+    private getTypeId(node: ts.Node, context: Context): string {
+        return `function-${getKey(node, context)}`;
+    }
+}

src/SchemaGenerator.ts

@@ -75,7 +75,8 @@ export class SchemaGenerator {
         if (
             node.kind === ts.SyntaxKind.InterfaceDeclaration ||
             node.kind === ts.SyntaxKind.EnumDeclaration ||
-            node.kind === ts.SyntaxKind.TypeAliasDeclaration
+            node.kind === ts.SyntaxKind.TypeAliasDeclaration ||
+            node.kind === ts.SyntaxKind.FunctionDeclaration
         ) {
             if (!this.isExportType(node)) {
                 return;