@teambit/typescript 0.0.742 → 0.0.745

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@teambit/typescript",
-  "version": "0.0.742",
+  "version": "0.0.745",
   "homepage": "https://bit.dev/teambit/typescript/typescript",
   "main": "dist/index.js",
   "componentId": {
     "scope": "teambit.typescript",
     "name": "typescript",
-    "version": "0.0.742"
+    "version": "0.0.745"
   },
   "dependencies": {
     "lodash": "4.17.21",
@@ -18,21 +18,21 @@
     "@babel/runtime": "7.12.18",
     "core-js": "^3.0.0",
     "@teambit/harmony": "0.3.3",
-    "@teambit/compiler": "0.0.742",
+    "@teambit/compiler": "0.0.745",
     "@teambit/typescript.modules.ts-config-mutator": "0.0.68",
-    "@teambit/component": "0.0.742",
-    "@teambit/dependency-resolver": "0.0.742",
-    "@teambit/semantics.entities.semantic-schema": "0.0.15",
+    "@teambit/component": "0.0.745",
+    "@teambit/dependency-resolver": "0.0.745",
+    "@teambit/semantics.entities.semantic-schema": "0.0.16",
     "@teambit/ts-server": "0.0.32",
-    "@teambit/aspect-loader": "0.0.742",
+    "@teambit/aspect-loader": "0.0.745",
     "@teambit/bit-error": "0.0.394",
-    "@teambit/builder": "0.0.742",
-    "@teambit/isolator": "0.0.742",
-    "@teambit/logger": "0.0.584",
-    "@teambit/schema": "0.0.742",
-    "@teambit/workspace": "0.0.742",
-    "@teambit/cli": "0.0.492",
-    "@teambit/pkg": "0.0.742"
+    "@teambit/builder": "0.0.745",
+    "@teambit/isolator": "0.0.745",
+    "@teambit/logger": "0.0.586",
+    "@teambit/schema": "0.0.745",
+    "@teambit/workspace": "0.0.745",
+    "@teambit/cli": "0.0.493",
+    "@teambit/pkg": "0.0.745"
   },
   "devDependencies": {
     "@types/lodash": "4.14.165",
@@ -45,10 +45,10 @@
     "@types/jest": "^26.0.0",
     "@types/react-dom": "^17.0.5",
     "@types/node": "12.20.4",
-    "@teambit/typescript.aspect-docs.typescript": "0.0.137"
+    "@teambit/typescript.aspect-docs.typescript": "0.0.138"
   },
   "peerDependencies": {
-    "@teambit/legacy": "1.0.272",
+    "@teambit/legacy": "1.0.273",
     "react-dom": "^16.8.0 || ^17.0.0",
     "react": "^16.8.0 || ^17.0.0"
   },
@@ -76,7 +76,7 @@
         "react": "-"
       },
       "peerDependencies": {
-        "@teambit/legacy": "1.0.272",
+        "@teambit/legacy": "1.0.273",
         "react-dom": "^16.8.0 || ^17.0.0",
         "react": "^16.8.0 || ^17.0.0"
       }

package/{preview-1653535588073.js → preview-1653836960096.js}

@@ -1,2 +1,2 @@
-export const compositions = [require('/home/circleci/Library/Caches/Bit/capsules/8891be5ad3d35bfc38b9cd90c0e05b598a5a55af/teambit.typescript_typescript@0.0.742/dist/typescript.composition.js')]
-export const overview = [require('/home/circleci/Library/Caches/Bit/capsules/8891be5ad3d35bfc38b9cd90c0e05b598a5a55af/teambit.typescript_typescript@0.0.742/dist/typescript.docs.mdx')]
+export const compositions = [require('/home/circleci/Library/Caches/Bit/capsules/8891be5ad3d35bfc38b9cd90c0e05b598a5a55af/teambit.typescript_typescript@0.0.745/dist/typescript.composition.js')]
+export const overview = [require('/home/circleci/Library/Caches/Bit/capsules/8891be5ad3d35bfc38b9cd90c0e05b598a5a55af/teambit.typescript_typescript@0.0.745/dist/typescript.docs.mdx')]

package/transformers/class-deceleration.ts

@@ -1,12 +1,12 @@
 import pMapSeries from 'p-map-series';
 import { compact } from 'lodash';
-import { ClassSchema, GetAccessorSchema, SetAccessorSchema } from '@teambit/semantics.entities.semantic-schema';
-import ts, { Node, ClassDeclaration, isSemicolonClassElement } from 'typescript';
+import { ClassSchema } 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';
+import { jsDocToDocSchema } from './utils/jsdoc-to-doc-schema';
+import { classElementToSchema } from './utils/class-element-to-schema';
 
 export class ClassDecelerationTransformer implements SchemaTransformer {
   predicate(node: Node) {
@@ -29,28 +29,9 @@ export class ClassDecelerationTransformer implements SchemaTransformer {
       if (isPrivate) {
         return null;
       }
-      if (isSemicolonClassElement(member)) {
-        return null;
-      }
-      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(info);
-          const type = await context.resolveType(getter, typeStr);
-          return new GetAccessorSchema(context.getLocation(getter), getter.name.getText(), type, displaySig);
-        }
-        case ts.SyntaxKind.SetAccessor: {
-          const setter = member as ts.SetAccessorDeclaration;
-          const params = await getParams(setter.parameters, context);
-          const displaySig = await context.getQuickInfoDisplayString(setter.name);
-          return new SetAccessorSchema(context.getLocation(setter), setter.name.getText(), params[0], displaySig);
-        }
-        default:
-          return context.computeSchema(member);
-      }
+      return classElementToSchema(member, context);
     });
-    return new ClassSchema(className, compact(members), context.getLocation(node));
+    const doc = await jsDocToDocSchema(node, context);
+    return new ClassSchema(className, compact(members), context.getLocation(node), doc);
   }
 }

package/transformers/index.ts

@@ -1,16 +1,10 @@
 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 { Constructor } from './constructor';
-export { PropertySignature } from './property-signature';
 export { LiteralTypeTransformer } from './literal-type';
-export { IndexSignature } from './index-signature';
 export { InterfaceDeclarationTransformer } from './interface-declaration';
-export { MethodSignatureTransformer } from './method-signature';
 export { EnumDeclarationTransformer } from './enum-declaration';

package/transformers/interface-declaration.ts

@@ -1,13 +1,14 @@
-import ts, { Node, InterfaceDeclaration } from 'typescript';
+import { Node, InterfaceDeclaration, SyntaxKind } 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';
+import { typeElementToSchema } from './utils/type-element-to-schema';
 
 export class InterfaceDeclarationTransformer implements SchemaTransformer {
   predicate(node: Node) {
-    return node.kind === ts.SyntaxKind.InterfaceDeclaration;
+    return node.kind === SyntaxKind.InterfaceDeclaration;
   }
 
   async getIdentifiers(node: InterfaceDeclaration): Promise<ExportIdentifier[]> {
@@ -15,10 +16,7 @@ export class InterfaceDeclarationTransformer implements SchemaTransformer {
   }
 
   async transform(interfaceDec: InterfaceDeclaration, context: SchemaExtractorContext) {
-    const members = await pMapSeries(interfaceDec.members, async (member) => {
-      const typeSchema = await context.computeSchema(member);
-      return typeSchema;
-    });
+    const members = await pMapSeries(interfaceDec.members, (member) => typeElementToSchema(member, context));
     return new InterfaceSchema(context.getLocation(interfaceDec), interfaceDec.name.getText(), members);
   }
 }

package/transformers/utils/class-element-to-schema.ts

@@ -0,0 +1,61 @@
+import {
+  ClassElement,
+  ConstructorDeclaration,
+  GetAccessorDeclaration,
+  IndexSignatureDeclaration,
+  MethodDeclaration,
+  PropertyDeclaration,
+  SetAccessorDeclaration,
+  SyntaxKind,
+} from 'typescript';
+import { ConstructorSchema, SchemaNode, VariableSchema } from '@teambit/semantics.entities.semantic-schema';
+import { SchemaExtractorContext } from '../../schema-extractor-context';
+import { getParams } from './get-params';
+import { getAccessor, indexSignature, setAccessor } from './type-element-to-schema';
+import { parseTypeFromQuickInfo } from './parse-type-from-quick-info';
+import { toFunctionLikeSchema } from './to-function-schema';
+
+export async function classElementToSchema(
+  node: ClassElement,
+  context: SchemaExtractorContext
+): Promise<SchemaNode | null> {
+  switch (node.kind) {
+    case SyntaxKind.Constructor:
+      return constructor(node as ConstructorDeclaration, context);
+    case SyntaxKind.PropertyDeclaration:
+      return propertyDeclaration(node as PropertyDeclaration, context);
+    case SyntaxKind.MethodDeclaration:
+      return methodDeclaration(node as MethodDeclaration, context);
+    case SyntaxKind.GetAccessor:
+      return getAccessor(node as GetAccessorDeclaration, context);
+    case SyntaxKind.SetAccessor:
+      return setAccessor(node as SetAccessorDeclaration, context);
+    case SyntaxKind.IndexSignature:
+      return indexSignature(node as IndexSignatureDeclaration, context);
+    case SyntaxKind.ClassStaticBlockDeclaration: // not sure what is it, but the name sounds like not something we need
+    case SyntaxKind.SemicolonClassElement: // seems to be just a semicolon
+      return null;
+    default:
+      // should never be here unless typescript added new class elements
+      throw new Error(`unrecognized ClassElement type. got ${node.kind}`);
+  }
+}
+
+async function constructor(node: ConstructorDeclaration, context: SchemaExtractorContext) {
+  const args = await getParams(node.parameters, context);
+  return new ConstructorSchema(context.getLocation(node), args);
+}
+
+async function propertyDeclaration(node: PropertyDeclaration, context: SchemaExtractorContext) {
+  const name = node.name.getText();
+  const info = await context.getQuickInfo(node.name);
+  const displaySig = info?.body?.displayString;
+  const typeStr = parseTypeFromQuickInfo(info);
+  const type = await context.resolveType(node, typeStr);
+
+  return new VariableSchema(context.getLocation(node), name, displaySig || '', type);
+}
+
+async function methodDeclaration(node: MethodDeclaration, context: SchemaExtractorContext) {
+  return toFunctionLikeSchema(node, context);
+}

package/transformers/utils/jsdoc-to-doc-schema.ts

@@ -0,0 +1,81 @@
+/* eslint-disable no-fallthrough */
+import { getTextOfJSDocComment, JSDocReturnTag, JSDocTag, Node, SyntaxKind } from 'typescript';
+import { getJsDoc, canHaveJsDoc } from 'tsutils';
+import pMapSeries from 'p-map-series';
+import { DocSchema, ReturnTagSchema, TagName, TagSchema } from '@teambit/semantics.entities.semantic-schema';
+import { SchemaExtractorContext } from '../../schema-extractor-context';
+import { typeNodeToSchema } from './type-node-to-schema';
+
+export async function jsDocToDocSchema(node: Node, context: SchemaExtractorContext): Promise<DocSchema | undefined> {
+  if (!canHaveJsDoc(node)) {
+    return undefined;
+  }
+  const jsDocs = getJsDoc(node);
+  if (!jsDocs.length) {
+    return undefined;
+  }
+  // not sure how common it is to have multiple JSDocs. never seen it before.
+  // regardless, in typescript implementation of methods like `getJSDocDeprecatedTag()`, they use the first one. (`getFirstJSDocTag()`)
+  const jsDoc = jsDocs[0];
+  const location = context.getLocation(jsDoc);
+  const comment = getTextOfJSDocComment(jsDoc.comment);
+  const tags = jsDoc.tags ? await pMapSeries(jsDoc.tags, (tag) => tagParser(tag, context)) : undefined;
+  return new DocSchema(location, comment, tags);
+}
+
+async function tagParser(tag: JSDocTag, context: SchemaExtractorContext): Promise<TagSchema> {
+  let tagName: TagName | string = tag.tagName.getText();
+  switch (tag.kind) {
+    case SyntaxKind.JSDocReturnTag:
+      return returnTag(tag as JSDocReturnTag, context);
+    case SyntaxKind.JSDocAugmentsTag:
+      tagName = TagName.augments;
+    case SyntaxKind.JSDocAuthorTag:
+      tagName = TagName.author;
+    case SyntaxKind.JSDocClassTag:
+      tagName = TagName.class;
+    case SyntaxKind.JSDocCallbackTag:
+      tagName = TagName.callback;
+    case SyntaxKind.JSDocPublicTag:
+      tagName = TagName.public;
+    case SyntaxKind.JSDocPrivateTag:
+      tagName = TagName.private;
+    case SyntaxKind.JSDocProtectedTag:
+      tagName = TagName.protected;
+    case SyntaxKind.JSDocReadonlyTag:
+      tagName = TagName.readonly;
+    case SyntaxKind.JSDocOverrideTag:
+      tagName = TagName.override;
+    case SyntaxKind.JSDocDeprecatedTag:
+      tagName = TagName.deprecated;
+    case SyntaxKind.JSDocSeeTag:
+      tagName = TagName.see;
+    case SyntaxKind.JSDocEnumTag:
+      tagName = TagName.enum;
+    case SyntaxKind.JSDocParameterTag:
+      tagName = TagName.parameter;
+    case SyntaxKind.JSDocThisTag:
+      tagName = TagName.this;
+    case SyntaxKind.JSDocTypeTag:
+      tagName = TagName.type;
+    case SyntaxKind.JSDocTemplateTag:
+      tagName = TagName.template;
+    case SyntaxKind.JSDocTypedefTag:
+      tagName = TagName.typedef;
+    case SyntaxKind.JSDocPropertyTag:
+      tagName = TagName.property;
+    case SyntaxKind.JSDocImplementsTag:
+      tagName = TagName.implements;
+    default:
+      return simpleTag(tag, tagName, context);
+  }
+}
+
+function simpleTag(tag: JSDocTag, tagName: TagName | string, context: SchemaExtractorContext): TagSchema {
+  return new TagSchema(context.getLocation(tag), tagName, getTextOfJSDocComment(tag.comment));
+}
+
+async function returnTag(tag: JSDocReturnTag, context: SchemaExtractorContext) {
+  const type = tag.typeExpression?.type ? await typeNodeToSchema(tag.typeExpression?.type, context) : undefined;
+  return new ReturnTagSchema(context.getLocation(tag), TagName.return, getTextOfJSDocComment(tag.comment), type);
+}

package/transformers/utils/to-function-schema.ts

@@ -3,17 +3,21 @@ import { FunctionLikeSchema, Modifier } from '@teambit/semantics.entities.semant
 import { SchemaExtractorContext } from '../../schema-extractor-context';
 import { getParams } from './get-params';
 import { parseTypeFromQuickInfo } from './parse-type-from-quick-info';
+import { jsDocToDocSchema } from './jsdoc-to-doc-schema';
 
-export async function toFunctionLikeSchema(node: SignatureDeclaration, context: SchemaExtractorContext) {
-  const name = node.name?.getText() || '';
-  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-  const info = await context.getQuickInfo(node.name!);
-  const returnTypeStr = parseTypeFromQuickInfo(info);
+export async function toFunctionLikeSchema(
+  node: SignatureDeclaration,
+  context: SchemaExtractorContext,
+  funcName?: string
+) {
+  const name = funcName || node.name?.getText() || '';
+  const info = node.name ? await context.getQuickInfo(node.name) : null;
+  const returnTypeStr = info ? parseTypeFromQuickInfo(info) : 'any';
   const displaySig = info?.body?.displayString || '';
   const args = await getParams(node.parameters, context);
-  const returnType = await context.resolveType(node, returnTypeStr);
+  const returnType = await context.resolveType(node, returnTypeStr, Boolean(info));
   const modifiers = node.modifiers?.map((modifier) => modifier.getText()) || [];
   const location = context.getLocation(node);
-
-  return new FunctionLikeSchema(location, name, args, returnType, displaySig, modifiers as Modifier[]);
+  const doc = await jsDocToDocSchema(node, context);
+  return new FunctionLikeSchema(location, name, args, returnType, displaySig, modifiers as Modifier[], doc);
 }

package/transformers/utils/type-element-to-schema.ts

@@ -0,0 +1,72 @@
+import ts, {
+  SyntaxKind,
+  TypeElement,
+  MethodSignature,
+  isComputedPropertyName,
+  IndexSignatureDeclaration,
+  GetAccessorDeclaration,
+  SetAccessorDeclaration,
+  ConstructSignatureDeclaration,
+} from 'typescript';
+import {
+  GetAccessorSchema,
+  IndexSignatureSchema,
+  SchemaNode,
+  SetAccessorSchema,
+  VariableSchema,
+} from '@teambit/semantics.entities.semantic-schema';
+import { toFunctionLikeSchema } from './to-function-schema';
+import { SchemaExtractorContext } from '../../schema-extractor-context';
+import { parseTypeFromQuickInfo } from './parse-type-from-quick-info';
+import { typeNodeToSchema } from './type-node-to-schema';
+import { getParams } from './get-params';
+
+export async function typeElementToSchema(node: TypeElement, context: SchemaExtractorContext): Promise<SchemaNode> {
+  switch (node.kind) {
+    case SyntaxKind.MethodSignature:
+      return toFunctionLikeSchema(node as MethodSignature, context);
+    case SyntaxKind.ConstructSignature:
+      return toFunctionLikeSchema(node as ConstructSignatureDeclaration, context, 'new');
+    case SyntaxKind.CallSignature:
+      throw new Error(`CallSignature was not implemented yet`);
+    case SyntaxKind.PropertySignature:
+      return propertySignature(node as ts.PropertySignature, context);
+    case SyntaxKind.IndexSignature:
+      return indexSignature(node as IndexSignatureDeclaration, context);
+    case SyntaxKind.GetAccessor:
+      return getAccessor(node as GetAccessorDeclaration, context);
+    case SyntaxKind.SetAccessor:
+      return setAccessor(node as SetAccessorDeclaration, context);
+    default:
+      throw new Error(`typeElementToSchema expect type-element node. got ${node.kind}`);
+  }
+}
+
+async function propertySignature(node: ts.PropertySignature, context: SchemaExtractorContext) {
+  const name = node.name.getText();
+  const info = isComputedPropertyName(node.name) ? undefined : await context.getQuickInfo(node.name);
+  const displaySig = info?.body?.displayString || '';
+  const typeStr = parseTypeFromQuickInfo(info);
+  const type = await context.resolveType(node, typeStr);
+  return new VariableSchema(context.getLocation(node), name, displaySig, type);
+}
+
+export async function indexSignature(node: IndexSignatureDeclaration, context: SchemaExtractorContext) {
+  const params = await getParams(node.parameters, context);
+  const type = await typeNodeToSchema(node.type, context);
+  return new IndexSignatureSchema(context.getLocation(node), params, type);
+}
+
+export async function getAccessor(node: GetAccessorDeclaration, context: SchemaExtractorContext) {
+  const info = await context.getQuickInfo(node.name);
+  const displaySig = info?.body?.displayString || '';
+  const typeStr = parseTypeFromQuickInfo(info);
+  const type = await context.resolveType(node, typeStr);
+  return new GetAccessorSchema(context.getLocation(node), node.name.getText(), type, displaySig);
+}
+
+export async function setAccessor(node: SetAccessorDeclaration, context: SchemaExtractorContext) {
+  const params = await getParams(node.parameters, context);
+  const displaySig = await context.getQuickInfoDisplayString(node.name);
+  return new SetAccessorSchema(context.getLocation(node), node.name.getText(), params[0], displaySig);
+}

package/transformers/utils/type-node-to-schema.ts

@@ -17,6 +17,7 @@ import {
   IndexedAccessTypeNode,
   TemplateLiteralTypeNode,
   TemplateLiteralTypeSpan,
+  ThisTypeNode,
 } from 'typescript';
 import {
   SchemaNode,
@@ -36,10 +37,14 @@ import {
   IndexedAccessSchema,
   TemplateLiteralTypeSpanSchema,
   TemplateLiteralTypeSchema,
+  ThisTypeSchema,
+  Modifier,
 } from '@teambit/semantics.entities.semantic-schema';
 import pMapSeries from 'p-map-series';
 import { SchemaExtractorContext } from '../../schema-extractor-context';
 import { getParams } from './get-params';
+import { typeElementToSchema } from './type-element-to-schema';
+import { jsDocToDocSchema } from './jsdoc-to-doc-schema';
 
 // eslint-disable-next-line complexity
 export async function typeNodeToSchema(node: TypeNode, context: SchemaExtractorContext): Promise<SchemaNode> {
@@ -78,13 +83,14 @@ export async function typeNodeToSchema(node: TypeNode, context: SchemaExtractorC
       return templateLiteralTypeSpan(node as TemplateLiteralTypeSpan, context);
     case SyntaxKind.TemplateLiteralType:
       return templateLiteralType(node as TemplateLiteralTypeNode, context);
+    case SyntaxKind.ThisType:
+      return thisType(node as ThisTypeNode, context);
     case SyntaxKind.ConstructorType:
     case SyntaxKind.NamedTupleMember:
     case SyntaxKind.OptionalType:
     case SyntaxKind.RestType:
     case SyntaxKind.ConditionalType:
     case SyntaxKind.InferType:
-    case SyntaxKind.ThisType:
     case SyntaxKind.MappedType:
     case SyntaxKind.ImportType:
     case SyntaxKind.ExpressionWithTypeArguments:
@@ -153,10 +159,7 @@ async function unionType(node: UnionTypeNode, context: SchemaExtractorContext) {
  * this "TypeLiteral" is an object with properties, such as: `{ a: string; b: number }`, similar to Interface.
  */
 async function typeLiteral(node: TypeLiteralNode, context: SchemaExtractorContext) {
-  const members = await pMapSeries(node.members, async (member) => {
-    const typeSchema = await context.computeSchema(member);
-    return typeSchema;
-  });
+  const members = await pMapSeries(node.members, (member) => typeElementToSchema(member, context));
   const location = context.getLocation(node);
   return new TypeLiteralSchema(location, members);
 }
@@ -183,7 +186,9 @@ async function functionType(node: FunctionTypeNode, context: SchemaExtractorCont
   const params = await getParams(node.parameters, context);
   const returnType = await typeNodeToSchema(node.type, context);
   const location = context.getLocation(node);
-  return new FunctionLikeSchema(location, name, params, returnType, '');
+  const modifiers = node.modifiers?.map((modifier) => modifier.getText()) || [];
+  const doc = await jsDocToDocSchema(node, context);
+  return new FunctionLikeSchema(location, name, params, returnType, '', modifiers as Modifier[], doc);
 }
 
 /**
@@ -261,3 +266,7 @@ async function templateLiteralTypeSpan(node: TemplateLiteralTypeSpan, context: S
   const literal = node.literal.text;
   return new TemplateLiteralTypeSpanSchema(context.getLocation(node), literal, type);
 }
+
+async function thisType(node: ThisTypeNode, context: SchemaExtractorContext) {
+  return new ThisTypeSchema(context.getLocation(node));
+}

package/transformers/variable-declaration.ts

@@ -1,10 +1,11 @@
-import { SchemaNode, VariableSchema, FunctionLikeSchema } from '@teambit/semantics.entities.semantic-schema';
+import { SchemaNode, VariableSchema, FunctionLikeSchema, Modifier } 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';
+import { jsDocToDocSchema } from './utils/jsdoc-to-doc-schema';
 
 export class VariableDeclaration implements SchemaTransformer {
   predicate(node: Node) {
@@ -28,7 +29,9 @@ export class VariableDeclaration implements SchemaTransformer {
       const args = await getParams((varDec.initializer as ArrowFunction).parameters, context);
       const typeStr = parseReturnTypeFromQuickInfo(info);
       const returnType = await context.resolveType(varDec, typeStr);
-      return new FunctionLikeSchema(location, name, args, returnType, displaySig);
+      const modifiers = varDec.modifiers?.map((modifier) => modifier.getText()) || [];
+      const doc = await jsDocToDocSchema(varDec, context);
+      return new FunctionLikeSchema(location, name, args, returnType, displaySig, modifiers as Modifier[], doc);
     }
     const typeStr = parseTypeFromQuickInfo(info);
     const type = await context.resolveType(varDec, typeStr);

package/dist/transformers/constructor.d.ts

@@ -1,10 +0,0 @@
-import { SchemaNode } from '@teambit/semantics.entities.semantic-schema';
-import { Node, ConstructorDeclaration } from 'typescript';
-import { SchemaExtractorContext } from '../schema-extractor-context';
-import { SchemaTransformer } from '../schema-transformer';
-import { ExportIdentifier } from '../export-identifier';
-export declare class Constructor implements SchemaTransformer {
-    predicate(node: Node): boolean;
-    getIdentifiers(node: ConstructorDeclaration): Promise<ExportIdentifier[]>;
-    transform(constructorDec: ConstructorDeclaration, context: SchemaExtractorContext): Promise<SchemaNode>;
-}

package/dist/transformers/constructor.js

@@ -1,70 +0,0 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
-require("core-js/modules/es.promise.js");
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.Constructor = void 0;
-
-function _semanticsEntities() {
-  const data = require("@teambit/semantics.entities.semantic-schema");
-
-  _semanticsEntities = function () {
-    return data;
-  };
-
-  return data;
-}
-
-function _typescript() {
-  const data = _interopRequireDefault(require("typescript"));
-
-  _typescript = function () {
-    return data;
-  };
-
-  return data;
-}
-
-function _exportIdentifier() {
-  const data = require("../export-identifier");
-
-  _exportIdentifier = function () {
-    return data;
-  };
-
-  return data;
-}
-
-function _getParams() {
-  const data = require("./utils/get-params");
-
-  _getParams = function () {
-    return data;
-  };
-
-  return data;
-}
-
-class Constructor {
-  predicate(node) {
-    return node.kind === _typescript().default.SyntaxKind.Constructor;
-  }
-
-  async getIdentifiers(node) {
-    return [new (_exportIdentifier().ExportIdentifier)('constructor', node.getSourceFile().fileName)];
-  }
-
-  async transform(constructorDec, context) {
-    const args = await (0, _getParams().getParams)(constructorDec.parameters, context);
-    return new (_semanticsEntities().ConstructorSchema)(context.getLocation(constructorDec), args);
-  }
-
-}
-
-exports.Constructor = Constructor;
-
-//# sourceMappingURL=constructor.js.map

package/dist/transformers/constructor.js.map

@@ -1 +0,0 @@
-{"version":3,"names":["Constructor","predicate","node","kind","ts","SyntaxKind","getIdentifiers","ExportIdentifier","getSourceFile","fileName","transform","constructorDec","context","args","getParams","parameters","ConstructorSchema","getLocation"],"sources":["constructor.ts"],"sourcesContent":["import { SchemaNode, ConstructorSchema } from '@teambit/semantics.entities.semantic-schema';\nimport ts, { Node, ConstructorDeclaration } from 'typescript';\nimport { SchemaExtractorContext } from '../schema-extractor-context';\nimport { SchemaTransformer } from '../schema-transformer';\nimport { ExportIdentifier } from '../export-identifier';\nimport { getParams } from './utils/get-params';\n\nexport class Constructor implements SchemaTransformer {\n  predicate(node: Node) {\n    return node.kind === ts.SyntaxKind.Constructor;\n  }\n\n  async getIdentifiers(node: ConstructorDeclaration) {\n    return [new ExportIdentifier('constructor', node.getSourceFile().fileName)];\n  }\n\n  async transform(constructorDec: ConstructorDeclaration, context: SchemaExtractorContext): Promise<SchemaNode> {\n    const args = await getParams(constructorDec.parameters, context);\n\n    return new ConstructorSchema(context.getLocation(constructorDec), args);\n  }\n}\n"],"mappings":";;;;;;;;;;;AAAA;EAAA;;EAAA;IAAA;EAAA;;EAAA;AAAA;;AACA;EAAA;;EAAA;IAAA;EAAA;;EAAA;AAAA;;AAGA;EAAA;;EAAA;IAAA;EAAA;;EAAA;AAAA;;AACA;EAAA;;EAAA;IAAA;EAAA;;EAAA;AAAA;;AAEO,MAAMA,WAAN,CAA+C;EACpDC,SAAS,CAACC,IAAD,EAAa;IACpB,OAAOA,IAAI,CAACC,IAAL,KAAcC,qBAAA,CAAGC,UAAH,CAAcL,WAAnC;EACD;;EAEmB,MAAdM,cAAc,CAACJ,IAAD,EAA+B;IACjD,OAAO,CAAC,KAAIK,oCAAJ,EAAqB,aAArB,EAAoCL,IAAI,CAACM,aAAL,GAAqBC,QAAzD,CAAD,CAAP;EACD;;EAEc,MAATC,SAAS,CAACC,cAAD,EAAyCC,OAAzC,EAA+F;IAC5G,MAAMC,IAAI,GAAG,MAAM,IAAAC,sBAAA,EAAUH,cAAc,CAACI,UAAzB,EAAqCH,OAArC,CAAnB;IAEA,OAAO,KAAII,sCAAJ,EAAsBJ,OAAO,CAACK,WAAR,CAAoBN,cAApB,CAAtB,EAA2DE,IAA3D,CAAP;EACD;;AAbmD"}

package/dist/transformers/index-signature.d.ts

@@ -1,9 +0,0 @@
-import { SchemaNode } from '@teambit/semantics.entities.semantic-schema';
-import { Node, IndexSignatureDeclaration } from 'typescript';
-import { SchemaTransformer } from '../schema-transformer';
-import { SchemaExtractorContext } from '../schema-extractor-context';
-export declare class IndexSignature implements SchemaTransformer {
-    predicate(node: Node): boolean;
-    getIdentifiers(): Promise<never[]>;
-    transform(indexSig: IndexSignatureDeclaration, context: SchemaExtractorContext): Promise<SchemaNode>;
-}