docs support enum generationg

docs/api/LayoutType.md

+# LayoutType
+
+- BottomTabs
+- Component
+- ExternalComponent
+- SideMenuCenter
+- SideMenuLeft
+- SideMenuRight
+- SideMenuRoot
+- Stack
+- TopTabs

docs/api/README.md

 - [CommandsObserver](/api/CommandsObserver)
 - [ComponentEventsObserver](/api/ComponentEventsObserver)
 - [EventsRegistry](/api/EventsRegistry)
+- [LayoutType](/api/LayoutType)

docs/api/_sidebar.md

 - [CommandsObserver](/api/CommandsObserver)
 - [ComponentEventsObserver](/api/ComponentEventsObserver)
 - [EventsRegistry](/api/EventsRegistry)
+- [LayoutType](/api/LayoutType)

scripts/gen-docs/ClassParser.ts

 export class ClassParser {
   constructor(private sourceLinkPrefix: string) { }
 
-  public parseClass(reflection: Typedoc.DeclarationReflection): ClassContext {
+  public parseClasses(classReflections: Typedoc.DeclarationReflection[]): ClassContext[] {
+    return classReflections.map((r) => this.parseClass(r));
+  }
+
+  private parseClass(classReflection: Typedoc.DeclarationReflection): ClassContext {
     return {
-      name: reflection.name,
-      properties: this.parseProperties(reflection),
-      methods: this.parseMethods(reflection)
+      name: classReflection.name,
+      properties: this.parseProperties(classReflection),
+      methods: this.parseMethods(classReflection)
     };
   }
 

scripts/gen-docs/EnumParser.ts

+import { DeclarationReflection, ReflectionKind } from 'typedoc';
+
+export interface EnumContext {
+  name: string;
+  values: string[];
+}
+
+export class EnumParser {
+  public parse(enumReflections: DeclarationReflection[]): EnumContext[] {
+    return enumReflections.map((r) => this.parseEnum(r));
+  }
+
+  private parseEnum(enumReflection: DeclarationReflection): EnumContext {
+    return {
+      name: enumReflection.name,
+      values: enumReflection.getChildrenByKind(ReflectionKind.EnumMember).map((child) => child.name)
+    };
+  }
+}

scripts/gen-docs/Main.ts

 import { ClassParser } from './ClassParser';
 import { MarkdownWriter } from './MarkdownWriter';
 import { ReflectionKind } from 'typedoc';
+import { EnumParser } from './EnumParser';
 
 const INPUT_DIR = `${__dirname}/../../lib/src`;
 const OUTPUT_DIR = `${__dirname}/../../docs/api`;
     const markdownWriter = new MarkdownWriter(TEMPLATES_DIR, OUTPUT_DIR);
     const reflections = new ReflectionsReader(TSCONFIG_PATH).read(INPUT_DIR);
 
-    const parsedClasses = reflections.classReflections.map((c) => classParser.parseClass(c));
+    const parsedClasses = classParser.parseClasses(reflections.classReflections);
+    const parsedEnums = new EnumParser().parse(reflections.enumReflections);
     markdownWriter.writeClasses(parsedClasses);
-    markdownWriter.writeMenu(parsedClasses);
+    markdownWriter.writeEnums(parsedEnums);
+    markdownWriter.writeMenu(parsedClasses, parsedEnums);
   }
 }
 

scripts/gen-docs/MarkdownWriter.ts

+import * as _ from 'lodash';
 import * as Handlebars from 'handlebars';
 import * as fs from 'fs';
 import { ClassContext } from './ClassParser';
+import { EnumContext } from './EnumParser';
 
 export class MarkdownWriter {
   private classFn;
+  private enumFn;
   private menuFn;
   constructor(private templatesDir: string, private outputDir: string) {
     this.classFn = this.setupClassHandlebars();
+    this.enumFn = this.setupEnumHandlebars();
     this.menuFn = this.setupMenuHandlebars();
   }
 
   public writeClasses(classContexts: ClassContext[]) {
     classContexts.forEach((c) => {
-      const classMarkdown = this.classFn(c);
-      fs.writeFileSync(`${this.outputDir}/${c.name}.md`, classMarkdown, { encoding: 'utf8' });
+      const markdown = this.classFn(c);
+      fs.writeFileSync(`${this.outputDir}/${c.name}.md`, markdown, { encoding: 'utf8' });
     });
   }
 
-  public writeMenu(classContexts: ClassContext[]) {
+  public writeEnums(enumContexts: EnumContext[]) {
+    enumContexts.forEach((c) => {
+      const markdown = this.enumFn(c);
+      fs.writeFileSync(`${this.outputDir}/${c.name}.md`, markdown, { encoding: 'utf8' });
+    });
+  }
+
+  public writeMenu(classContexts: ClassContext[], enumContexts: EnumContext[]) {
     const files = classContexts.map((c) => ({ name: c.name, path: `/api/${c.name}` }));
-    const menuMarkdown = this.menuFn({ files });
+    const files2 = enumContexts.map((c) => ({ name: c.name, path: `/api/${c.name}` }));
+    const menuMarkdown = this.menuFn({ files: _.concat(files, files2) });
     fs.writeFileSync(`${this.outputDir}/_sidebar.md`, menuMarkdown, { encoding: 'utf8' });
     fs.writeFileSync(`${this.outputDir}/README.md`, menuMarkdown, { encoding: 'utf8' });
   }
     return Handlebars.compile('{{> class}}', { strict: true, noEscape: true });
   }
 
+  private setupEnumHandlebars() {
+    const enumTemplate = fs.readFileSync(`${this.templatesDir}/enum.hbs`).toString();
+    return Handlebars.compile(enumTemplate, { strict: true, noEscape: true });
+  }
+
   private setupMenuHandlebars() {
     const template = fs.readFileSync(`${this.templatesDir}/menu.hbs`).toString();
     return Handlebars.compile(template, { strict: true, noEscape: true });

scripts/gen-docs/ReflectionsReader.ts

 
 export interface Reflections {
   classReflections: DeclarationReflection[];
+  enumReflections: DeclarationReflection[];
 }
 
 export class ReflectionsReader {
     // console.log(JSON.stringify(this.typedocApp.serializer.projectToObject(projectReflection)));
 
     const externalModules = this.externalModulesWithoutTestsAndMocks(projectReflection);
-    const classReflections = this.classReflections(externalModules);
+    const classReflections = this.reflections(externalModules, ReflectionKind.Class);
+    const enumReflections = this.reflections(externalModules, ReflectionKind.Enum);
 
     return {
-      classReflections
+      classReflections,
+      enumReflections
     };
   }
 
       .filter((m) => !m.name.endsWith('.mock"') && !m.name.endsWith('.test"'));
   }
 
-  private classReflections(externalModules: DeclarationReflection[]): DeclarationReflection[] {
-    return externalModules.filter((m) => m.getChildrenByKind(ReflectionKind.Class).length === 1)
-      .map((m) => m.getChildrenByKind(ReflectionKind.Class)[0]);
+  private reflections(externalModules: DeclarationReflection[], kind: ReflectionKind): DeclarationReflection[] {
+    return externalModules.filter((m) => m.getChildrenByKind(kind).length === 1)
+      .map((m) => m.getChildrenByKind(kind)[0]);
   }
 }

scripts/gen-docs/templates/enum.hbs

+# {{name}}
+
+{{#each values}}
+- {{this}}
+{{/each}}