Merge pull request #93 from SimplrJS/dev

v4.0.0-beta.7

Author: Martynas Žilinskas

examples/simple/index.ts

@@ -1,3 +1 @@
-export function Foo(arg: string | number) {
-    return arg;
-}
+export const ObjectLiteralConst = { Property: "value" };

package.json

@@ -1,6 +1,6 @@
 {
     "name": "ts-extractor",
-    "version": "4.0.0-beta.6",
+    "version": "4.0.0-beta.7",
     "description": "TypeScript AST extractor to useful JSON structure.",
     "keywords": [
         "typescript",

src/api-helpers.ts

@@ -66,7 +66,7 @@ export namespace ApiHelpers {
             apiItem = new ApiEnumMember(declaration, symbol, options);
         } else if (ts.isInterfaceDeclaration(declaration)) {
             apiItem = new ApiInterface(declaration, symbol, options);
-        } else if (ts.isPropertySignature(declaration)) {
+        } else if (ts.isPropertySignature(declaration) || ts.isPropertyAssignment(declaration)) {
             apiItem = new ApiProperty(declaration, symbol, options);
         } else if (ts.isMethodSignature(declaration)) {
             apiItem = new ApiMethod(declaration, symbol, options);
@@ -94,9 +94,9 @@ export namespace ApiHelpers {
             apiItem = new ApiConstruct(declaration, symbol, options);
         } else if (ts.isTypeParameterDeclaration(declaration)) {
             apiItem = new ApiTypeParameter(declaration, symbol, options);
-        } else if (ts.isTypeLiteralNode(declaration)) {
+        } else if (ts.isTypeLiteralNode(declaration) || ts.isObjectLiteralExpression(declaration)) {
             apiItem = new ApiTypeLiteral(declaration, symbol, options);
-        } else if (ts.isFunctionTypeNode(declaration)) {
+        } else if (ts.isFunctionTypeNode(declaration) || ts.isArrowFunction(declaration) || ts.isFunctionExpression(declaration)) {
             apiItem = new ApiFunctionType(declaration, symbol, options);
         } else if (ts.isMappedTypeNode(declaration)) {
             apiItem = new ApiMapped(declaration, symbol, options);
@@ -181,12 +181,22 @@ export namespace ApiHelpers {
         }
         const symbolItems: string[] = [];
 
-        symbol.declarations.forEach(declaration => {
+        // Filter out the same namespace.
+        const filteredDeclarations: ts.Declaration[] = [];
+        for (const declaration of symbol.declarations) {
+            if (filteredDeclarations.find(x => ts.isModuleDeclaration(x)) != null) {
+                continue;
+            }
+
+            filteredDeclarations.push(declaration);
+        }
+
+        for (const declaration of filteredDeclarations) {
             const itemId = GetItemId(declaration, symbol, options);
             if (itemId != null) {
                 symbolItems.push(itemId);
             }
-        });
+        }
 
         return {
             Alias: symbol.name,
@@ -263,7 +273,7 @@ export namespace ApiHelpers {
     export function LogWithNodePosition(logLevel: LogLevel, declaration: ts.Node, message: string): void {
         const sourceFile = declaration.getSourceFile();
         const position = sourceFile.getLineAndCharacterOfPosition(declaration.getStart());
-        const linePrefix = `${sourceFile.fileName}[${position.line + 1}:${position.character + 1}]`;
+        const linePrefix = `${sourceFile.fileName}(${position.line + 1},${position.character + 1})`;
         Logger.Log(logLevel, `${linePrefix}: ${message}`);
     }
 

src/contracts/api-item-kinds.ts

@@ -6,6 +6,7 @@ export enum ApiItemKinds {
     Interface = "interface",
     Method = "method",
     Namespace = "namespace",
+    ImportNamespace = "import-namespace",
     Parameter = "parameter",
     Property = "property",
     Variable = "variable",
@@ -24,6 +25,9 @@ export enum ApiItemKinds {
     ImportSpecifier = "import-specifier",
     TypeParameter = "type-parameter",
     TypeLiteral = "type-literal",
+    ObjectLiteral = "object-literal",
     FunctionType = "function-type",
+    ArrowFunction = "arrow-function",
+    FunctionExpression = "function-expression",
     Mapped = "mapped"
 }

src/contracts/definitions/api-function-type-dto.ts

@@ -2,5 +2,5 @@ import { ApiCallableDto } from "../api-callable-dto";
 import { ApiItemKinds } from "../api-item-kinds";
 
 export interface ApiFunctionTypeDto extends ApiCallableDto {
-    ApiKind: ApiItemKinds.FunctionType;
+    ApiKind: ApiItemKinds.FunctionType | ApiItemKinds.ArrowFunction | ApiItemKinds.FunctionExpression;
 }

src/contracts/definitions/api-namespace-dto.ts

@@ -3,6 +3,6 @@ import { ApiItemReference } from "../api-item-reference";
 import { ApiItemKinds } from "../api-item-kinds";
 
 export interface ApiNamespaceDto extends ApiBaseItemDto {
-    ApiKind: ApiItemKinds.Namespace;
+    ApiKind: ApiItemKinds.Namespace | ApiItemKinds.ImportNamespace;
     Members: ApiItemReference[];
 }

src/contracts/definitions/api-type-literal-dto.ts

@@ -3,6 +3,6 @@ import { ApiItemReference } from "../api-item-reference";
 import { ApiItemKinds } from "../api-item-kinds";
 
 export interface ApiTypeLiteralDto extends ApiBaseItemDto {
-    ApiKind: ApiItemKinds.TypeLiteral;
+    ApiKind: ApiItemKinds.TypeLiteral | ApiItemKinds.ObjectLiteral;
     Members: ApiItemReference[];
 }

src/definitions/api-function-type.ts

@@ -7,14 +7,28 @@ import { ApiMetadataDto } from "../contracts/api-metadata-dto";
 import { ApiCallableBase } from "../abstractions/api-callable-base";
 import { ApiItemLocationDto } from "../contracts/api-item-location-dto";
 
-export class ApiFunctionType extends ApiCallableBase<ts.FunctionTypeNode, ApiFunctionTypeDto> {
+export type FunctionTypes = ts.FunctionTypeNode | ts.ArrowFunction | ts.FunctionExpression;
+
+// TODO: Rename to appropriate class name.
+export class ApiFunctionType extends ApiCallableBase<FunctionTypes, ApiFunctionTypeDto> {
+    protected ResolveApiKind(): ApiItemKinds.FunctionType | ApiItemKinds.ArrowFunction | ApiItemKinds.FunctionExpression {
+        if (ts.isFunctionTypeNode(this.Declaration)) {
+            return ApiItemKinds.FunctionType;
+        } else if (ts.isFunctionExpression(this.Declaration)) {
+            return ApiItemKinds.FunctionExpression;
+        } else {
+            return ApiItemKinds.ArrowFunction;
+        }
+    }
+
     public OnExtract(): ApiFunctionTypeDto {
         const parentId: string | undefined = ApiHelpers.GetParentIdFromDeclaration(this.Declaration, this.Options);
         const metadata: ApiMetadataDto = this.GetItemMetadata();
         const location: ApiItemLocationDto = ApiHelpers.GetApiItemLocationDtoFromNode(this.Declaration, this.Options);
+        const apiKind = this.ResolveApiKind();
 
         return {
-            ApiKind: ApiItemKinds.FunctionType,
+            ApiKind: apiKind,
             Name: this.Symbol.name,
             ParentId: parentId,
             Metadata: metadata,

src/definitions/api-namespace.ts

@@ -11,6 +11,14 @@ import { ApiItemLocationDto } from "../contracts/api-item-location-dto";
 export class ApiNamespace extends ApiItem<ts.ModuleDeclaration | ts.NamespaceImport, ApiNamespaceDto> {
     private members: ApiItemReference[] = [];
 
+    protected ResolveApiKind(): ApiItemKinds.Namespace | ApiItemKinds.ImportNamespace {
+        if (ts.isModuleDeclaration(this.Declaration)) {
+            return ApiItemKinds.Namespace;
+        } else {
+            return ApiItemKinds.ImportNamespace;
+        }
+    }
+
     protected OnGatherData(): void {
         // Members
         this.members = ApiHelpers.GetItemsIdsFromSymbolsMap(this.Symbol.exports, this.Options);
@@ -20,9 +28,10 @@ export class ApiNamespace extends ApiItem<ts.ModuleDeclaration | ts.NamespaceImp
         const parentId: string | undefined = ApiHelpers.GetParentIdFromDeclaration(this.Declaration, this.Options);
         const metadata: ApiMetadataDto = this.GetItemMetadata();
         const location: ApiItemLocationDto = ApiHelpers.GetApiItemLocationDtoFromNode(this.Declaration, this.Options);
+        const apiKind = this.ResolveApiKind();
 
         return {
-            ApiKind: ApiItemKinds.Namespace,
+            ApiKind: apiKind,
             Name: this.Declaration.name.getText(),
             ParentId: parentId,
             Metadata: metadata,

src/definitions/api-property.ts

@@ -9,15 +9,16 @@ import { ApiMetadataDto } from "../contracts/api-metadata-dto";
 import { ApiItemLocationDto } from "../contracts/api-item-location-dto";
 import { ApiTypeHelpers } from "../api-type-helpers";
 
-export class ApiProperty extends ApiItem<ts.PropertySignature, ApiPropertyDto> {
+export class ApiProperty extends ApiItem<ts.PropertySignature | ts.PropertyAssignment, ApiPropertyDto> {
     private type: ApiType;
     private isOptional: boolean;
     private isReadonly: boolean;
 
     protected OnGatherData(): void {
         // Type
+        const typeNode: ts.TypeNode | undefined = ts.isPropertySignature(this.Declaration) ? this.Declaration.type : undefined;
         const type = this.TypeChecker.getTypeOfSymbolAtLocation(this.Symbol, this.Declaration);
-        this.type = ApiTypeHelpers.ResolveApiType(this.Options, type, this.Declaration.type);
+        this.type = ApiTypeHelpers.ResolveApiType(this.Options, type, typeNode);
 
         // IsOptional
         this.isOptional = Boolean(this.Declaration.questionToken);