Add support �analyzing vue-class-component and vue-property-decorator

.gitignore

@@ -18,3 +18,4 @@ docs/.vuepress/dist
 
 .nyc_output
 coverage.lcov
+server/tsconfig.tsbuildinfo

server/src/modes/script/childComponents.ts

@@ -1,5 +1,5 @@
 import * as ts from 'typescript';
-import { getLastChild, buildDocumentation, getObjectLiteralExprFromExportExpr } from './componentInfo';
+import { getLastChild, buildDocumentation, getNodeFromExportNode } from './componentInfo';
 import { T_TypeScript } from '../../services/dependencyService';
 
 interface InternalChildComponent {
@@ -10,7 +10,7 @@ interface InternalChildComponent {
     start: number;
     end: number;
   };
-  defaultExportExpr?: ts.Node;
+  defaultExportNode?: ts.Node;
 }
 
 export function getChildComponents(
@@ -19,7 +19,15 @@ export function getChildComponents(
   checker: ts.TypeChecker,
   tagCasing = 'kebab'
 ): InternalChildComponent[] | undefined {
-  const componentsSymbol = checker.getPropertyOfType(defaultExportType, 'components');
+  let type = defaultExportType;
+  if (defaultExportType.isClass()) {
+    // get decorator argument type when class
+    type = checker.getTypeAtLocation(
+      (defaultExportType.symbol.declarations[0].decorators![0].expression as ts.CallExpression).arguments[0]
+    );
+  }
+
+  const componentsSymbol = checker.getPropertyOfType(type, 'components');
   if (!componentsSymbol || !componentsSymbol.valueDeclaration) {
     return undefined;
   }
@@ -56,22 +64,37 @@ export function getChildComponents(
       }
 
       if (objectLiteralSymbol.flags & tsModule.SymbolFlags.Alias) {
-        const definitionObjectLiteralSymbol = checker.getAliasedSymbol(objectLiteralSymbol);
-        if (definitionObjectLiteralSymbol.valueDeclaration) {
-          const defaultExportExpr = getLastChild(definitionObjectLiteralSymbol.valueDeclaration);
+        const definitionSymbol = checker.getAliasedSymbol(objectLiteralSymbol);
+        // definitionObjectLiteralSymbol.
+        if (tsModule.isClassDeclaration(
+          definitionSymbol.valueDeclaration
+        )) {
+          const defaultExportNode = definitionSymbol.valueDeclaration;
+          result.push({
+            name: componentName,
+            documentation: buildDocumentation(tsModule, definitionSymbol, checker),
+            definition: {
+              path: definitionSymbol.valueDeclaration.getSourceFile().fileName,
+              start: defaultExportNode.getStart(undefined, true),
+              end: defaultExportNode.getEnd()
+            },
+            defaultExportNode: getNodeFromExportNode(tsModule, defaultExportNode)
+          });
+        } else if (definitionSymbol.valueDeclaration) {
+          const defaultExportExpr = getLastChild(definitionSymbol.valueDeclaration);
           if (!defaultExportExpr) {
             return;
           }
 
           result.push({
             name: componentName,
-            documentation: buildDocumentation(tsModule, definitionObjectLiteralSymbol, checker),
+            documentation: buildDocumentation(tsModule, definitionSymbol, checker),
             definition: {
-              path: definitionObjectLiteralSymbol.valueDeclaration.getSourceFile().fileName,
+              path: definitionSymbol.valueDeclaration.getSourceFile().fileName,
               start: defaultExportExpr.getStart(undefined, true),
               end: defaultExportExpr.getEnd()
             },
-            defaultExportExpr: getObjectLiteralExprFromExportExpr(tsModule, defaultExportExpr)
+            defaultExportNode: getNodeFromExportNode(tsModule, defaultExportExpr)
           });
         }
       }