@teambit/typescript 0.0.728 → 0.0.729

package/transformers/class-deceleration.ts

@@ -0,0 +1,49 @@
+import pMapSeries from 'p-map-series';
+import { ClassSchema, GetAccessorSchema, SetAccessorSchema } from '@teambit/semantics.entities.semantic-schema';
+import ts, { Node, ClassDeclaration } from 'typescript';
+import { SchemaTransformer } from '../schema-transformer';
+import { SchemaExtractorContext } from '../schema-extractor-context';
+import { ExportIdentifier } from '../export-identifier';
+import { parseTypeFromQuickInfo } from './utils/parse-type-from-quick-info';
+import { getParams } from './utils/get-params';
+
+export class ClassDecelerationTransformer implements SchemaTransformer {
+  predicate(node: Node) {
+    return node.kind === ts.SyntaxKind.ClassDeclaration;
+  }
+
+  // @todo: in case of `export default class` the class has no name.
+  private getName(node: ClassDeclaration) {
+    return node.name?.getText() || 'default';
+  }
+
+  async getIdentifiers(node: ClassDeclaration) {
+    return [new ExportIdentifier(this.getName(node), node.getSourceFile().fileName)];
+  }
+
+  async transform(node: ClassDeclaration, context: SchemaExtractorContext) {
+    const className = this.getName(node);
+    const members = await pMapSeries(node.members, async (member) => {
+      switch (member.kind) {
+        case ts.SyntaxKind.GetAccessor: {
+          const getter = member as ts.GetAccessorDeclaration;
+          const info = await context.getQuickInfo(getter.name);
+          const displaySig = info?.body?.displayString || '';
+          const typeStr = parseTypeFromQuickInfo(displaySig);
+          const type = await context.resolveType(getter, typeStr);
+          return new GetAccessorSchema(getter.name.getText(), type, displaySig);
+        }
+        case ts.SyntaxKind.SetAccessor: {
+          const setter = member as ts.SetAccessorDeclaration;
+          const params = await getParams(setter.parameters, context);
+          const info = await context.getQuickInfo(setter.name);
+          const displaySig = info?.body?.displayString || '';
+          return new SetAccessorSchema(setter.name.getText(), params[0], displaySig);
+        }
+        default:
+          return context.computeSchema(member);
+      }
+    });
+    return new ClassSchema(className, members);
+  }
+}

package/transformers/constructor.ts

@@ -0,0 +1,22 @@
+import { SchemaNode, ConstructorSchema } from '@teambit/semantics.entities.semantic-schema';
+import ts, { Node, ConstructorDeclaration } from 'typescript';
+import { SchemaExtractorContext } from '../schema-extractor-context';
+import { SchemaTransformer } from '../schema-transformer';
+import { ExportIdentifier } from '../export-identifier';
+import { getParams } from './utils/get-params';
+
+export class Constructor implements SchemaTransformer {
+  predicate(node: Node) {
+    return node.kind === ts.SyntaxKind.Constructor;
+  }
+
+  async getIdentifiers(node: ConstructorDeclaration) {
+    return [new ExportIdentifier('constructor', node.getSourceFile().fileName)];
+  }
+
+  async transform(constructorDec: ConstructorDeclaration, context: SchemaExtractorContext): Promise<SchemaNode> {
+    const args = await getParams(constructorDec.parameters, context);
+
+    return new ConstructorSchema(args);
+  }
+}

package/transformers/export-declaration.ts

@@ -1,4 +1,12 @@
-import ts, { Node, SyntaxKind, ExportDeclaration as ExportDeclarationNode, NamedExports } from 'typescript';
+import { SchemaNode, Module } from '@teambit/semantics.entities.semantic-schema';
+import { compact } from 'lodash';
+import ts, {
+  Node,
+  SyntaxKind,
+  ExportDeclaration as ExportDeclarationNode,
+  NamedExports,
+  NamespaceExport,
+} from 'typescript';
 import { SchemaExtractorContext } from '../schema-extractor-context';
 import { SchemaTransformer } from '../schema-transformer';
 import { ExportIdentifier } from '../export-identifier';
@@ -27,27 +35,48 @@ export class ExportDeclaration implements SchemaTransformer {
     return [];
   }
 
-  async transform(node: Node, context: SchemaExtractorContext) {
+  async transform(node: Node, context: SchemaExtractorContext): Promise<SchemaNode> {
     const exportDec = node as ExportDeclarationNode;
-    // sourceFile.sear
     const exportClause = exportDec.exportClause;
+    // e.g. `export { button1, button2 } as Composition from './button';
     if (exportClause?.kind === SyntaxKind.NamedExports) {
       exportClause as NamedExports;
-      // eslint-disable-next-line @typescript-eslint/no-unused-vars
-      const exports = await Promise.all(
+      const schemas = await Promise.all(
         exportClause.elements.map(async (element) => {
-          // const sig = await context.visitDefinition(element.name);
-          await context.visitDefinition(element.name);
-          return element.name;
+          return context.visitDefinition(element.name);
         })
       );
 
-      return [];
-      // return exports.map((identifier) => {
-      //   // const type = context.resolveType(identifier);
-      // });
+      return new Module(compact(schemas));
+    }
+    // e.g. `export * as Composition from './button';
+    if (exportClause?.kind === SyntaxKind.NamespaceExport) {
+      exportClause as NamespaceExport;
+      const namespace = exportClause.name.getText();
+      const sourceFile = await context.getSourceFileFromNode(exportClause.name);
+      if (!sourceFile) {
+        throw new Error(`unable to find the source-file for "${namespace}"`);
+      }
+      const result = await context.computeSchema(sourceFile);
+      if (!(result instanceof Module)) {
+        throw new Error(`expect result to be instance of Module`);
+      }
+      result.namespace = namespace;
+      return result;
+    }
+    // it's export-all, e.g. `export * from './button'`;
+    if (!exportClause) {
+      const specifier = exportDec.moduleSpecifier;
+      if (!specifier) {
+        throw new Error(`fatal: no specifier`);
+      }
+      const sourceFile = await context.getSourceFileFromNode(specifier);
+      if (!sourceFile) {
+        throw new Error(`unable to find the source-file`);
+      }
+      return context.computeSchema(sourceFile);
     }
 
-    return {};
+    throw new Error('unrecognized export type');
   }
 }

package/transformers/function-declaration.ts

@@ -3,6 +3,8 @@ import ts, { Node, FunctionDeclaration as FunctionDeclarationNode } from 'typesc
 import { SchemaExtractorContext } from '../schema-extractor-context';
 import { SchemaTransformer } from '../schema-transformer';
 import { ExportIdentifier } from '../export-identifier';
+import { getParams } from './utils/get-params';
+import { parseTypeFromQuickInfo } from './utils/parse-type-from-quick-info';
 
 export class FunctionDeclaration implements SchemaTransformer {
   predicate(node: Node) {
@@ -18,37 +20,15 @@ export class FunctionDeclaration implements SchemaTransformer {
     return funcDec.name?.getText() || '';
   }
 
-  private async getArgs(funcDec: FunctionDeclarationNode, context: SchemaExtractorContext) {
-    return Promise.all(
-      funcDec.parameters.map(async (param) => {
-        const type = param.type;
-        return {
-          name: param.name.getText(),
-          // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-          type: await context.resolveType(type!, type?.getText() || 'any'),
-        };
-      })
-    );
-  }
-
-  private parseReturnValue(displayString?: string) {
-    if (!displayString) return '';
-    const array = displayString.split(':');
-    return array[array.length - 1].trim();
-  }
-
-  async transform(node: Node, context: SchemaExtractorContext): Promise<SchemaNode> {
-    const funcDec = node as FunctionDeclarationNode;
+  async transform(funcDec: FunctionDeclarationNode, context: SchemaExtractorContext): Promise<SchemaNode> {
     const name = this.getName(funcDec);
     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
     const info = await context.getQuickInfo(funcDec.name!);
     const displaySig = info?.body?.displayString;
-    const returnTypeStr = this.parseReturnValue(displaySig);
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    const args = await this.getArgs(funcDec, context);
-    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-    const returnType = await context.resolveType(funcDec.name!, returnTypeStr);
+    const returnTypeStr = parseTypeFromQuickInfo(displaySig);
+    const args = await getParams(funcDec.parameters, context);
+    const returnType = await context.resolveType(funcDec, returnTypeStr);
 
-    return new FunctionSchema(name || '', [], returnType);
+    return new FunctionSchema(name || '', args, returnType, displaySig || '');
   }
 }

package/transformers/index-signature.ts

@@ -0,0 +1,21 @@
+import { SchemaNode, IndexSignatureSchema } from '@teambit/semantics.entities.semantic-schema';
+import ts, { Node, IndexSignatureDeclaration } from 'typescript';
+import { SchemaTransformer } from '../schema-transformer';
+import { SchemaExtractorContext } from '../schema-extractor-context';
+import { getParams } from './utils/get-params';
+
+export class IndexSignature implements SchemaTransformer {
+  predicate(node: Node) {
+    return node.kind === ts.SyntaxKind.IndexSignature;
+  }
+
+  async getIdentifiers() {
+    return [];
+  }
+
+  async transform(indexSig: IndexSignatureDeclaration, context: SchemaExtractorContext): Promise<SchemaNode> {
+    const params = await getParams(indexSig.parameters, context);
+    const type = await context.resolveType(indexSig, indexSig.type.getText());
+    return new IndexSignatureSchema(params, type);
+  }
+}

package/transformers/index.ts

@@ -1,5 +1,19 @@
 export { ExportDeclaration } from './export-declaration';
 export { FunctionDeclaration } from './function-declaration';
+export { MethodDeclaration } from './method-declaration';
+export { PropertyDeclaration } from './property-declaration';
 export { VariableStatementTransformer } from './variable-statement';
+export { VariableDeclaration } from './variable-declaration';
 export { SourceFileTransformer } from './source-file-transformer';
 export { TypeAliasTransformer } from './type-alias';
+export { ClassDecelerationTransformer } from './class-deceleration';
+export { TypeIntersectionTransformer } from './type-intersection';
+export { Constructor } from './constructor';
+export { TypeReferenceTransformer } from './type-reference';
+export { TypeLiteralTransformer } from './type-literal';
+export { PropertySignature } from './property-signature';
+export { TypeUnionTransformer } from './type-union';
+export { LiteralTypeTransformer } from './literal-type';
+export { IndexSignature } from './index-signature';
+export { InterfaceDeclarationTransformer } from './interface-declaration';
+export { MethodSignatureTransformer } from './method-signature';

package/transformers/interface-declaration.ts

@@ -0,0 +1,24 @@
+import ts, { Node, InterfaceDeclaration } from 'typescript';
+import pMapSeries from 'p-map-series';
+import { InterfaceSchema } from '@teambit/semantics.entities.semantic-schema';
+import { SchemaTransformer } from '../schema-transformer';
+import { SchemaExtractorContext } from '../schema-extractor-context';
+import { ExportIdentifier } from '../export-identifier';
+
+export class InterfaceDeclarationTransformer implements SchemaTransformer {
+  predicate(node: Node) {
+    return node.kind === ts.SyntaxKind.InterfaceDeclaration;
+  }
+
+  async getIdentifiers(node: InterfaceDeclaration): Promise<ExportIdentifier[]> {
+    return [new ExportIdentifier(node.name.getText(), node.getSourceFile().fileName)];
+  }
+
+  async transform(interfaceDec: InterfaceDeclaration, context: SchemaExtractorContext) {
+    const members = await pMapSeries(interfaceDec.members, async (member) => {
+      const typeSchema = await context.computeSchema(member);
+      return typeSchema;
+    });
+    return new InterfaceSchema(interfaceDec.name.getText(), members);
+  }
+}

package/transformers/literal-type.ts

@@ -0,0 +1,18 @@
+import ts, { LiteralTypeNode, Node } from 'typescript';
+import { TypeRefSchema } from '@teambit/semantics.entities.semantic-schema';
+import { SchemaTransformer } from '../schema-transformer';
+
+export class LiteralTypeTransformer implements SchemaTransformer {
+  predicate(node: Node) {
+    return node.kind === ts.SyntaxKind.LiteralType;
+  }
+
+  async getIdentifiers() {
+    return [];
+  }
+
+  async transform(literalType: LiteralTypeNode) {
+    const type = literalType.literal.getText();
+    return new TypeRefSchema(type);
+  }
+}

package/transformers/method-declaration.ts

@@ -0,0 +1,32 @@
+import { SchemaNode, FunctionSchema } from '@teambit/semantics.entities.semantic-schema';
+import ts, { Node, MethodDeclaration as MethodDeclarationNode } from 'typescript';
+import { SchemaExtractorContext } from '../schema-extractor-context';
+import { SchemaTransformer } from '../schema-transformer';
+import { ExportIdentifier } from '../export-identifier';
+import { parseTypeFromQuickInfo } from './utils/parse-type-from-quick-info';
+import { getParams } from './utils/get-params';
+
+export class MethodDeclaration implements SchemaTransformer {
+  predicate(node: Node) {
+    return node.kind === ts.SyntaxKind.MethodDeclaration;
+  }
+
+  async getIdentifiers(funcDec: MethodDeclarationNode) {
+    return [new ExportIdentifier(this.getName(funcDec), funcDec.getSourceFile().fileName)];
+  }
+
+  private getName(funcDec: MethodDeclarationNode) {
+    return funcDec.name?.getText() || '';
+  }
+
+  async transform(methodDec: MethodDeclarationNode, context: SchemaExtractorContext): Promise<SchemaNode> {
+    const name = this.getName(methodDec);
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    const info = await context.getQuickInfo(methodDec.name!);
+    const displaySig = info?.body?.displayString;
+    const returnTypeStr = parseTypeFromQuickInfo(displaySig);
+    const args = await getParams(methodDec.parameters, context);
+    const returnType = await context.resolveType(methodDec, returnTypeStr);
+    return new FunctionSchema(name || '', args, returnType, displaySig || '');
+  }
+}

package/transformers/method-signature.ts

@@ -0,0 +1,30 @@
+import { SchemaNode, FunctionSchema } from '@teambit/semantics.entities.semantic-schema';
+import ts, { Node, MethodSignature as MethodSignatureNode } from 'typescript';
+import { SchemaTransformer } from '../schema-transformer';
+import { SchemaExtractorContext } from '../schema-extractor-context';
+import { parseTypeFromQuickInfo } from './utils/parse-type-from-quick-info';
+import { getParams } from './utils/get-params';
+
+export class MethodSignatureTransformer implements SchemaTransformer {
+  predicate(node: Node) {
+    return node.kind === ts.SyntaxKind.MethodSignature;
+  }
+
+  getName(node: MethodSignatureNode) {
+    return node.name.getText();
+  }
+
+  async getIdentifiers() {
+    return [];
+  }
+
+  async transform(methodSig: MethodSignatureNode, context: SchemaExtractorContext): Promise<SchemaNode> {
+    const name = this.getName(methodSig);
+    const info = await context.getQuickInfo(methodSig.name);
+    const displaySig = info?.body?.displayString;
+    const returnTypeStr = parseTypeFromQuickInfo(displaySig);
+    const args = await getParams(methodSig.parameters, context);
+    const returnType = await context.resolveType(methodSig || methodSig, returnTypeStr);
+    return new FunctionSchema(name, args, returnType, displaySig || '');
+  }
+}

package/transformers/property-declaration.ts

@@ -0,0 +1,31 @@
+import { SchemaNode, VariableSchema } from '@teambit/semantics.entities.semantic-schema';
+import ts, { Node, PropertyDeclaration as PropertyDeclarationNode } from 'typescript';
+import { SchemaTransformer } from '../schema-transformer';
+import { SchemaExtractorContext } from '../schema-extractor-context';
+import { ExportIdentifier } from '../export-identifier';
+import { parseTypeFromQuickInfo } from './utils/parse-type-from-quick-info';
+
+export class PropertyDeclaration implements SchemaTransformer {
+  predicate(node: Node) {
+    return node.kind === ts.SyntaxKind.PropertyDeclaration;
+  }
+
+  getName(node: PropertyDeclarationNode) {
+    return node.name.getText();
+  }
+
+  async getIdentifiers(node: PropertyDeclarationNode) {
+    return [new ExportIdentifier(node.name.getText(), node.getSourceFile().fileName)];
+  }
+
+  async transform(propertyDec: PropertyDeclarationNode, context: SchemaExtractorContext): Promise<SchemaNode> {
+    const name = this.getName(propertyDec);
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    const info = await context.getQuickInfo(propertyDec.name!);
+    const displaySig = info?.body?.displayString;
+    const typeStr = parseTypeFromQuickInfo(displaySig);
+    const type = await context.resolveType(propertyDec, typeStr);
+
+    return new VariableSchema(name || '', displaySig || '', type);
+  }
+}

package/transformers/property-signature.ts

@@ -0,0 +1,38 @@
+import { FunctionSchema, SchemaNode, VariableSchema } from '@teambit/semantics.entities.semantic-schema';
+import ts, { FunctionTypeNode, Node, PropertySignature as PropertySignatureNode } from 'typescript';
+import { getParams } from './utils/get-params';
+import { SchemaTransformer } from '../schema-transformer';
+import { SchemaExtractorContext } from '../schema-extractor-context';
+import { parseReturnTypeFromQuickInfo, parseTypeFromQuickInfo } from './utils/parse-type-from-quick-info';
+
+export class PropertySignature implements SchemaTransformer {
+  predicate(node: Node) {
+    return node.kind === ts.SyntaxKind.PropertySignature;
+  }
+
+  getName(node: PropertySignatureNode) {
+    return node.name.getText();
+  }
+
+  async getIdentifiers() {
+    return [];
+  }
+
+  async transform(prop: PropertySignatureNode, context: SchemaExtractorContext): Promise<SchemaNode> {
+    const name = this.getName(prop);
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    const info = await context.getQuickInfo(prop.name!);
+    const displaySig = info?.body?.displayString || '';
+    if (prop.type?.kind === ts.SyntaxKind.FunctionType) {
+      // e.g. `propertySig: () => void;` inside interface
+      const propType = prop.type as FunctionTypeNode;
+      const args = await getParams(propType.parameters, context);
+      const typeStr = parseReturnTypeFromQuickInfo(displaySig);
+      const returnType = await context.resolveType(propType, typeStr);
+      return new FunctionSchema(name, args, returnType, displaySig);
+    }
+    const typeStr = parseTypeFromQuickInfo(displaySig);
+    const type = await context.resolveType(prop, typeStr);
+    return new VariableSchema(name, displaySig, type);
+  }
+}

package/transformers/source-file-transformer.ts

@@ -1,5 +1,7 @@
 import ts, { Node, SourceFile } from 'typescript';
 import { compact, flatten } from 'lodash';
+import pMapSeries from 'p-map-series';
+import { Module } from '@teambit/semantics.entities.semantic-schema';
 import { SchemaTransformer } from '../schema-transformer';
 import { ExportIdentifier } from '../export-identifier';
 import { SchemaExtractorContext } from '../schema-extractor-context';
@@ -29,13 +31,11 @@ export class SourceFileTransformer implements SchemaTransformer {
 
   async transform(node: SourceFile, context: SchemaExtractorContext) {
     const exports = this.listExports(node);
-    const schemas = await Promise.all(
-      exports.map((exportNode) => {
-        return context.computeSchema(exportNode);
-      })
-    );
+    const schemas = await pMapSeries(exports, (exportNode) => {
+      return context.computeSchema(exportNode);
+    });
 
-    return schemas;
+    return new Module(schemas);
   }
 
   /**

package/transformers/type-alias.ts

@@ -1,5 +1,7 @@
 import ts, { Node, TypeAliasDeclaration } from 'typescript';
+import { TypeSchema } from '@teambit/semantics.entities.semantic-schema';
 import { SchemaTransformer } from '../schema-transformer';
+import { SchemaExtractorContext } from '../schema-extractor-context';
 import { ExportIdentifier } from '../export-identifier';
 
 export class TypeAliasTransformer implements SchemaTransformer {
@@ -11,7 +13,15 @@ export class TypeAliasTransformer implements SchemaTransformer {
     return [new ExportIdentifier(node.name.getText(), node.getSourceFile().fileName)];
   }
 
-  async transform() {
-    return {};
+  private getName(node: TypeAliasDeclaration): string {
+    return node.name.getText();
+  }
+
+  async transform(typeAlias: TypeAliasDeclaration, context: SchemaExtractorContext) {
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    const info = await context.getQuickInfo(typeAlias.name!);
+    const displaySig = info?.body?.displayString;
+    const type = await context.computeSchema(typeAlias.type);
+    return new TypeSchema(this.getName(typeAlias), type, displaySig as string);
   }
 }

package/transformers/type-intersection.ts

@@ -0,0 +1,23 @@
+import ts, { Node, IntersectionTypeNode } from 'typescript';
+import pMapSeries from 'p-map-series';
+import { TypeIntersectionSchema } from '@teambit/semantics.entities.semantic-schema';
+import { SchemaTransformer } from '../schema-transformer';
+import { SchemaExtractorContext } from '../schema-extractor-context';
+
+export class TypeIntersectionTransformer implements SchemaTransformer {
+  predicate(node: Node) {
+    return node.kind === ts.SyntaxKind.IntersectionType;
+  }
+
+  async getIdentifiers() {
+    return [];
+  }
+
+  async transform(intersectionType: IntersectionTypeNode, context: SchemaExtractorContext) {
+    const types = await pMapSeries(intersectionType.types, async (type) => {
+      const typeSchema = await context.computeSchema(type);
+      return typeSchema;
+    });
+    return new TypeIntersectionSchema(types);
+  }
+}

package/transformers/type-literal.ts

@@ -0,0 +1,28 @@
+import ts, { Node, TypeLiteralNode } from 'typescript';
+import pMapSeries from 'p-map-series';
+import { TypeLiteralSchema } from '@teambit/semantics.entities.semantic-schema';
+import { SchemaTransformer } from '../schema-transformer';
+import { SchemaExtractorContext } from '../schema-extractor-context';
+import { ExportIdentifier } from '../export-identifier';
+
+/**
+ * not to be confused with "LiteralType", which is string/boolean/null.
+ * this "TypeLiteral" is an object with properties, such as: `{ a: string; b: number }`, similar to Interface.
+ */
+export class TypeLiteralTransformer implements SchemaTransformer {
+  predicate(node: Node) {
+    return node.kind === ts.SyntaxKind.TypeLiteral;
+  }
+
+  async getIdentifiers(): Promise<ExportIdentifier[]> {
+    return [];
+  }
+
+  async transform(typeLiteral: TypeLiteralNode, context: SchemaExtractorContext) {
+    const members = await pMapSeries(typeLiteral.members, async (member) => {
+      const typeSchema = await context.computeSchema(member);
+      return typeSchema;
+    });
+    return new TypeLiteralSchema(members);
+  }
+}

package/transformers/type-reference.ts

@@ -0,0 +1,19 @@
+import ts, { Node, TypeReferenceNode } from 'typescript';
+import { SchemaTransformer } from '../schema-transformer';
+import { SchemaExtractorContext } from '../schema-extractor-context';
+
+export class TypeReferenceTransformer implements SchemaTransformer {
+  predicate(node: Node) {
+    return node.kind === ts.SyntaxKind.TypeReference;
+  }
+
+  async getIdentifiers() {
+    return [];
+  }
+
+  async transform(typeReference: TypeReferenceNode, context: SchemaExtractorContext) {
+    const name = typeReference.typeName.getText();
+    const type = await context.resolveType(typeReference, name);
+    return type;
+  }
+}

package/transformers/type-union.ts

@@ -0,0 +1,23 @@
+import ts, { Node, UnionTypeNode } from 'typescript';
+import pMapSeries from 'p-map-series';
+import { TypeUnionSchema } from '@teambit/semantics.entities.semantic-schema';
+import { SchemaTransformer } from '../schema-transformer';
+import { SchemaExtractorContext } from '../schema-extractor-context';
+
+export class TypeUnionTransformer implements SchemaTransformer {
+  predicate(node: Node) {
+    return node.kind === ts.SyntaxKind.UnionType;
+  }
+
+  async getIdentifiers() {
+    return [];
+  }
+
+  async transform(unionType: UnionTypeNode, context: SchemaExtractorContext) {
+    const types = await pMapSeries(unionType.types, async (type) => {
+      const typeSchema = await context.computeSchema(type);
+      return typeSchema;
+    });
+    return new TypeUnionSchema(types);
+  }
+}

package/transformers/utils/get-params.ts

@@ -0,0 +1,30 @@
+import { Parameter, TypeRefSchema } from '@teambit/semantics.entities.semantic-schema';
+import pMapSeries from 'p-map-series';
+import { ParameterDeclaration, NodeArray } from 'typescript';
+import { SchemaExtractorContext } from '../../schema-extractor-context';
+import { parseTypeFromQuickInfo } from './parse-type-from-quick-info';
+
+export async function getParams(
+  parameterNodes: NodeArray<ParameterDeclaration>,
+  context: SchemaExtractorContext
+): Promise<Parameter[]> {
+  return pMapSeries(parameterNodes, async (param) => {
+    return {
+      name: param.name.getText(),
+      type: await getParamType(param, context),
+      defaultValue: param.initializer ? param.initializer.getText() : undefined,
+    };
+  });
+}
+
+async function getParamType(param: ParameterDeclaration, context: SchemaExtractorContext): Promise<TypeRefSchema> {
+  if (param.type) {
+    const type = param.type;
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    return context.resolveType(type!, type?.getText() || 'any');
+  }
+  const info = await context.getQuickInfo(param.name);
+  const displaySig = info?.body?.displayString;
+  const parsed = parseTypeFromQuickInfo(displaySig);
+  return new TypeRefSchema(parsed || 'any');
+}

package/transformers/utils/parse-type-from-quick-info.ts

@@ -0,0 +1,12 @@
+export function parseTypeFromQuickInfo(displayString?: string) {
+  if (!displayString) return '';
+  const array = displayString.split(':');
+  return array[array.length - 1].trim();
+}
+
+export function parseReturnTypeFromQuickInfo(displayString?: string) {
+  if (!displayString) return '';
+  const typeStr = parseTypeFromQuickInfo(displayString);
+  const array = typeStr.split('=>');
+  return array[array.length - 1].trim();
+}

package/transformers/variable-declaration.ts

@@ -0,0 +1,36 @@
+import { SchemaNode, VariableSchema, FunctionSchema } from '@teambit/semantics.entities.semantic-schema';
+import ts, { Node, VariableDeclaration as VariableDeclarationNode, ArrowFunction } from 'typescript';
+import { SchemaTransformer } from '../schema-transformer';
+import { SchemaExtractorContext } from '../schema-extractor-context';
+import { ExportIdentifier } from '../export-identifier';
+import { getParams } from './utils/get-params';
+import { parseReturnTypeFromQuickInfo, parseTypeFromQuickInfo } from './utils/parse-type-from-quick-info';
+
+export class VariableDeclaration implements SchemaTransformer {
+  predicate(node: Node) {
+    return node.kind === ts.SyntaxKind.VariableDeclaration;
+  }
+
+  getName(node: VariableDeclarationNode) {
+    return node.name.getText();
+  }
+
+  async getIdentifiers(node: VariableDeclarationNode) {
+    return [new ExportIdentifier(node.name.getText(), node.getSourceFile().fileName)];
+  }
+
+  async transform(varDec: VariableDeclarationNode, context: SchemaExtractorContext): Promise<SchemaNode> {
+    const name = this.getName(varDec);
+    const info = await context.getQuickInfo(varDec.name);
+    const displaySig = info?.body?.displayString || '';
+    if (varDec.initializer?.kind === ts.SyntaxKind.ArrowFunction) {
+      const args = await getParams((varDec.initializer as ArrowFunction).parameters, context);
+      const typeStr = parseReturnTypeFromQuickInfo(displaySig);
+      const returnType = await context.resolveType(varDec, typeStr);
+      return new FunctionSchema(name, args, returnType, displaySig);
+    }
+    const typeStr = parseTypeFromQuickInfo(displaySig);
+    const type = await context.resolveType(varDec, typeStr);
+    return new VariableSchema(name, displaySig, type);
+  }
+}