@teambit/typescript 0.0.894 → 0.0.896

package/package.json

@@ -1,40 +1,41 @@
 {
   "name": "@teambit/typescript",
-  "version": "0.0.894",
+  "version": "0.0.896",
   "homepage": "https://bit.dev/teambit/typescript/typescript",
   "main": "dist/index.js",
   "componentId": {
     "scope": "teambit.typescript",
     "name": "typescript",
-    "version": "0.0.894"
+    "version": "0.0.896"
   },
   "dependencies": {
     "lodash": "4.17.21",
+    "p-map-series": "2.1.0",
     "tsutils": "3.21.0",
     "typescript": "4.7.4",
     "chalk": "2.4.2",
     "fs-extra": "10.0.0",
     "yesno": "0.4.0",
-    "p-map-series": "2.1.0",
     "@babel/runtime": "7.20.0",
     "core-js": "^3.0.0",
     "@teambit/harmony": "0.3.3",
-    "@teambit/compiler": "0.0.894",
+    "@teambit/compiler": "0.0.896",
     "@teambit/typescript.modules.ts-config-mutator": "0.0.76",
-    "@teambit/component": "0.0.894",
-    "@teambit/dependency-resolver": "0.0.894",
-    "@teambit/semantics.entities.semantic-schema": "0.0.46",
+    "@teambit/component": "0.0.896",
+    "@teambit/dependency-resolver": "0.0.896",
+    "@teambit/formatter": "0.0.447",
+    "@teambit/semantics.entities.semantic-schema": "0.0.48",
     "@teambit/ts-server": "0.0.39",
-    "@teambit/aspect-loader": "0.0.894",
-    "@teambit/envs": "0.0.894",
+    "@teambit/aspect-loader": "0.0.896",
+    "@teambit/envs": "0.0.896",
     "@teambit/logger": "0.0.692",
-    "@teambit/workspace": "0.0.894",
+    "@teambit/workspace": "0.0.896",
     "@teambit/bit-error": "0.0.402",
-    "@teambit/builder": "0.0.894",
-    "@teambit/isolator": "0.0.894",
-    "@teambit/schema": "0.0.894",
+    "@teambit/builder": "0.0.896",
+    "@teambit/isolator": "0.0.896",
+    "@teambit/schema": "0.0.896",
     "@teambit/cli": "0.0.599",
-    "@teambit/pkg": "0.0.894"
+    "@teambit/pkg": "0.0.896"
   },
   "devDependencies": {
     "@types/lodash": "4.14.165",

package/{preview-1667878820252.js → preview-1668051814135.js}

@@ -1,5 +1,5 @@
-import * as compositions_0 from '/home/circleci/Library/Caches/Bit/capsules/8891be5ad3d35bfc38b9cd90c0e05b598a5a55af/teambit.typescript_typescript@0.0.894/dist/typescript.composition.js';
-import * as overview_0 from '/home/circleci/Library/Caches/Bit/capsules/8891be5ad3d35bfc38b9cd90c0e05b598a5a55af/teambit.typescript_typescript@0.0.894/dist/typescript.docs.mdx';
+import * as compositions_0 from '/home/circleci/Library/Caches/Bit/capsules/8891be5ad3d35bfc38b9cd90c0e05b598a5a55af/teambit.typescript_typescript@0.0.896/dist/typescript.composition.js';
+import * as overview_0 from '/home/circleci/Library/Caches/Bit/capsules/8891be5ad3d35bfc38b9cd90c0e05b598a5a55af/teambit.typescript_typescript@0.0.896/dist/typescript.docs.mdx';
 
 export const compositions = [compositions_0];
 export const overview = [overview_0];

package/transformers/binding-element.ts

@@ -4,7 +4,6 @@ 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 { jsDocToDocSchema } from './utils/jsdoc-to-doc-schema';
 
 /**
  * for example:
@@ -28,7 +27,7 @@ export class BindingElementTransformer implements SchemaTransformer {
     const displaySig = info?.body?.displayString || '';
     const typeStr = parseTypeFromQuickInfo(info);
     const type = await context.resolveType(node, typeStr);
-    const doc = await jsDocToDocSchema(node, context);
+    const doc = await context.jsDocToDocSchema(node);
     return new VariableLikeSchema(context.getLocation(node), name, displaySig, type, false, doc);
   }
 }

package/transformers/class-declaration.ts

@@ -0,0 +1,97 @@
+import pMapSeries from 'p-map-series';
+import { compact } from 'lodash';
+import {
+  ClassSchema,
+  UnresolvedSchema,
+  ExpressionWithTypeArgumentsSchema,
+} 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 { classElementToSchema } from './utils/class-element-to-schema';
+import { typeNodeToSchema } from './utils/type-node-to-schema';
+
+export class ClassDeclarationTransformer 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)];
+  }
+
+  private async getExpressionWithTypeArgs(
+    node: ClassDeclaration,
+    context: SchemaExtractorContext,
+    token: ts.SyntaxKind.ExtendsKeyword | ts.SyntaxKind.ImplementsKeyword
+  ) {
+    if (!node.heritageClauses) return [];
+
+    return pMapSeries(
+      node.heritageClauses
+        .filter((heritageClause: ts.HeritageClause) => heritageClause.token === token)
+        .flatMap((h: ts.HeritageClause) => {
+          const { types } = h;
+          const name = h.getText();
+          return types.map((type) => ({ ...type, name }));
+        }),
+      async (expressionWithTypeArgs: ts.ExpressionWithTypeArguments & { name: string }) => {
+        const { typeArguments, expression, name } = expressionWithTypeArgs;
+        const typeArgsNodes = typeArguments ? await pMapSeries(typeArguments, (t) => typeNodeToSchema(t, context)) : [];
+        const location = context.getLocation(expression);
+        const expressionNode =
+          (await context.visitDefinition(expression)) || new UnresolvedSchema(location, expression.getText());
+        return new ExpressionWithTypeArgumentsSchema(typeArgsNodes, expressionNode, name, location);
+      }
+    );
+  }
+
+  async transform(node: ClassDeclaration, context: SchemaExtractorContext) {
+    const className = this.getName(node);
+    const extendsExpressionsWithTypeArgs = await this.getExpressionWithTypeArgs(
+      node,
+      context,
+      ts.SyntaxKind.ExtendsKeyword
+    );
+
+    const implementsExpressionsWithTypeArgs = await this.getExpressionWithTypeArgs(
+      node,
+      context,
+      ts.SyntaxKind.ImplementsKeyword
+    );
+
+    const typeParameters = node.typeParameters?.map((typeParam) => {
+      return typeParam.name.getText();
+    });
+    const signature = node.name ? await context.getQuickInfoDisplayString(node.name) : undefined;
+    const members = await pMapSeries(node.members, async (member) => {
+      const isPrivate = member.modifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.PrivateKeyword);
+      if (isPrivate) {
+        return null;
+      }
+      return classElementToSchema(member, context);
+    });
+    const doc = await context.jsDocToDocSchema(node);
+
+    if (!signature) {
+      throw Error(`Missing signature for class ${className} declaration`);
+    }
+
+    return new ClassSchema(
+      className,
+      compact(members),
+      context.getLocation(node),
+      signature,
+      doc,
+      typeParameters,
+      extendsExpressionsWithTypeArgs,
+      implementsExpressionsWithTypeArgs
+    );
+  }
+}

package/transformers/enum-declaration.ts

@@ -1,5 +1,6 @@
 import ts, { Node, EnumDeclaration } from 'typescript';
-import { EnumSchema } from '@teambit/semantics.entities.semantic-schema';
+import { EnumMemberSchema, EnumSchema } from '@teambit/semantics.entities.semantic-schema';
+import pMapSeries from 'p-map-series';
 import { SchemaTransformer } from '../schema-transformer';
 import { SchemaExtractorContext } from '../schema-extractor-context';
 import { ExportIdentifier } from '../export-identifier';
@@ -14,7 +15,17 @@ export class EnumDeclarationTransformer implements SchemaTransformer {
   }
 
   async transform(enumDec: EnumDeclaration, context: SchemaExtractorContext) {
-    const members = enumDec.members.map((member) => member.name.getText());
-    return new EnumSchema(context.getLocation(enumDec), enumDec.name.getText(), members);
+    const name = enumDec.name.getText();
+    const members = await pMapSeries(enumDec.members, async (member) => {
+      const memberName = member.name.getText();
+      const memberSignature = await context.getQuickInfoDisplayString(member);
+      const memberDoc = await context.jsDocToDocSchema(member);
+      const memberLocation = await context.getLocation(member);
+      const memberValue = member.initializer?.getText();
+      return new EnumMemberSchema(memberLocation, memberName, memberSignature, memberValue, memberDoc);
+    });
+    const signature = await context.getQuickInfoDisplayString(enumDec.name);
+    const doc = await context.jsDocToDocSchema(enumDec);
+    return new EnumSchema(context.getLocation(enumDec), name, members, signature, doc);
   }
 }

package/transformers/export-declaration.ts

@@ -1,4 +1,4 @@
-import { SchemaNode, Module, UnresolvedSchema } from '@teambit/semantics.entities.semantic-schema';
+import { SchemaNode, ModuleSchema, UnresolvedSchema } from '@teambit/semantics.entities.semantic-schema';
 import ts, {
   Node,
   SyntaxKind,
@@ -54,7 +54,7 @@ export class ExportDeclaration implements SchemaTransformer {
     // e.g. `export { button1, button2 } as Composition from './button';
     if (exportClause.kind === SyntaxKind.NamedExports) {
       const schemas = await namedExport(exportClause, context);
-      return new Module(context.getLocation(exportDec), schemas);
+      return new ModuleSchema(context.getLocation(exportDec), schemas);
     }
     // e.g. `export * as Composition from './button';
     if (exportClause.kind === SyntaxKind.NamespaceExport) {
@@ -128,7 +128,7 @@ async function namespaceExport(
     return context.getTypeRefForExternalPath(namespace, filePath, context.getLocation(exportDec));
   }
   const result = await context.computeSchema(sourceFile);
-  if (!(result instanceof Module)) {
+  if (!(result instanceof ModuleSchema)) {
     throw new Error(`expect result to be instance of Module`);
   }
   result.namespace = namespace;

package/transformers/index.ts

@@ -4,7 +4,7 @@ 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 { ClassDeclarationTransformer } from './class-declaration';
 export { InterfaceDeclarationTransformer } from './interface-declaration';
 export { EnumDeclarationTransformer } from './enum-declaration';
 export { BindingElementTransformer } from './binding-element';

package/transformers/interface-declaration.ts

@@ -1,11 +1,15 @@
-import { Node, InterfaceDeclaration, SyntaxKind } from 'typescript';
+import ts, { Node, InterfaceDeclaration, SyntaxKind } from 'typescript';
 import pMapSeries from 'p-map-series';
-import { InterfaceSchema } from '@teambit/semantics.entities.semantic-schema';
+import {
+  ExpressionWithTypeArgumentsSchema,
+  InterfaceSchema,
+  UnresolvedSchema,
+} 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';
-import { jsDocToDocSchema } from './utils/jsdoc-to-doc-schema';
+import { typeNodeToSchema } from './utils/type-node-to-schema';
 
 export class InterfaceDeclarationTransformer implements SchemaTransformer {
   predicate(node: Node) {
@@ -16,9 +20,49 @@ export class InterfaceDeclarationTransformer implements SchemaTransformer {
     return [new ExportIdentifier(node.name.getText(), node.getSourceFile().fileName)];
   }
 
+  private async getExpressionWithTypeArgs(node: InterfaceDeclaration, context: SchemaExtractorContext) {
+    if (!node.heritageClauses) return [];
+
+    return pMapSeries(
+      node.heritageClauses
+        .filter((heritageClause: ts.HeritageClause) => heritageClause.token === SyntaxKind.ExtendsKeyword)
+        .flatMap((h: ts.HeritageClause) => {
+          const { types } = h;
+          const name = h.getText();
+          return types.map((type) => ({ ...type, name }));
+        }),
+      async (expressionWithTypeArgs: ts.ExpressionWithTypeArguments & { name: string }) => {
+        const { typeArguments, expression, name } = expressionWithTypeArgs;
+        const typeArgsNodes = typeArguments ? await pMapSeries(typeArguments, (t) => typeNodeToSchema(t, context)) : [];
+        const location = context.getLocation(expression);
+        const expressionNode =
+          (await context.visitDefinition(expression)) || new UnresolvedSchema(location, expression.getText());
+        return new ExpressionWithTypeArgumentsSchema(typeArgsNodes, expressionNode, name, location);
+      }
+    );
+  }
+
   async transform(interfaceDec: InterfaceDeclaration, context: SchemaExtractorContext) {
     const members = await pMapSeries(interfaceDec.members, (member) => typeElementToSchema(member, context));
-    const doc = await jsDocToDocSchema(interfaceDec, context);
-    return new InterfaceSchema(context.getLocation(interfaceDec), interfaceDec.name.getText(), members, doc);
+    const doc = await context.jsDocToDocSchema(interfaceDec);
+    const signature = interfaceDec.name ? await context.getQuickInfoDisplayString(interfaceDec.name) : undefined;
+    const extendsNodes = await this.getExpressionWithTypeArgs(interfaceDec, context);
+    const typeParameters = interfaceDec.typeParameters?.map((typeParam) => {
+      return typeParam.name.getText();
+    });
+
+    if (!signature) {
+      throw Error(`Missing signature for interface ${interfaceDec.name.getText()} declaration`);
+    }
+
+    return new InterfaceSchema(
+      context.getLocation(interfaceDec),
+      interfaceDec.name.getText(),
+      signature,
+      extendsNodes,
+      members,
+      doc,
+      typeParameters
+    );
   }
 }

package/transformers/source-file-transformer.ts

@@ -1,7 +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 { ModuleSchema } from '@teambit/semantics.entities.semantic-schema';
 import { SchemaTransformer } from '../schema-transformer';
 import { ExportIdentifier } from '../export-identifier';
 import { SchemaExtractorContext } from '../schema-extractor-context';
@@ -35,7 +35,7 @@ export class SourceFileTransformer implements SchemaTransformer {
       return context.computeSchema(exportNode);
     });
 
-    return new Module(context.getLocation(node), schemas);
+    return new ModuleSchema(context.getLocation(node), schemas);
   }
 
   /**

package/transformers/type-alias.ts

@@ -4,7 +4,6 @@ import { SchemaTransformer } from '../schema-transformer';
 import { SchemaExtractorContext } from '../schema-extractor-context';
 import { ExportIdentifier } from '../export-identifier';
 import { typeNodeToSchema } from './utils/type-node-to-schema';
-import { jsDocToDocSchema } from './utils/jsdoc-to-doc-schema';
 
 export class TypeAliasTransformer implements SchemaTransformer {
   predicate(node: Node) {
@@ -22,7 +21,7 @@ export class TypeAliasTransformer implements SchemaTransformer {
   async transform(typeAlias: TypeAliasDeclaration, context: SchemaExtractorContext) {
     const type = await typeNodeToSchema(typeAlias.type, context);
     const displaySig = await context.getQuickInfoDisplayString(typeAlias.name);
-    const doc = await jsDocToDocSchema(typeAlias, context);
+    const doc = await context.jsDocToDocSchema(typeAlias);
     return new TypeSchema(context.getLocation(typeAlias), this.getName(typeAlias), type, displaySig, doc);
   }
 }

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

@@ -14,7 +14,6 @@ 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-like-schema';
-import { jsDocToDocSchema } from './jsdoc-to-doc-schema';
 
 export async function classElementToSchema(
   node: ClassElement,
@@ -44,7 +43,9 @@ export async function classElementToSchema(
 
 async function constructor(node: ConstructorDeclaration, context: SchemaExtractorContext) {
   const args = await getParams(node.parameters, context);
-  return new ConstructorSchema(context.getLocation(node), args);
+  const info = await context.getQuickInfo(node);
+  const displaySig = info?.body?.displayString;
+  return new ConstructorSchema(context.getLocation(node), args, displaySig);
 }
 
 async function propertyDeclaration(node: PropertyDeclaration, context: SchemaExtractorContext) {
@@ -54,7 +55,7 @@ async function propertyDeclaration(node: PropertyDeclaration, context: SchemaExt
   const typeStr = parseTypeFromQuickInfo(info);
   const type = await context.resolveType(node, typeStr);
   const isOptional = Boolean(node.questionToken);
-  const doc = await jsDocToDocSchema(node, context);
+  const doc = await context.jsDocToDocSchema(node);
   return new VariableLikeSchema(context.getLocation(node), name, displaySig || '', type, isOptional, doc);
 }
 

package/transformers/utils/get-params.ts

@@ -28,7 +28,9 @@ export async function getParams(
       getParamName(param),
       await getParamType(param, context),
       Boolean(param.questionToken),
-      param.initializer ? param.initializer.getText() : undefined
+      param.initializer ? param.initializer.getText() : undefined,
+      undefined,
+      await getParamObjectBindingNodes(param, context)
     );
   });
 }
@@ -47,6 +49,18 @@ function getParamName(param: ParameterDeclaration): string {
   return `{ ${elementsStr} }`;
 }
 
+async function getParamObjectBindingNodes(
+  param: ParameterDeclaration,
+  context: SchemaExtractorContext
+): Promise<SchemaNode[] | undefined> {
+  if (param.name.kind !== SyntaxKind.ObjectBindingPattern) return undefined;
+  return pMapSeries(param.name.elements, async (elem: BindingElement) => {
+    const info = await context.getQuickInfo(elem.name);
+    const parsed = parseTypeFromQuickInfo(info);
+    return new InferenceTypeSchema(context.getLocation(param), parsed, elem.name.getText());
+  });
+}
+
 async function getParamType(param: ParameterDeclaration, context: SchemaExtractorContext): Promise<SchemaNode> {
   if (param.type) {
     const type = param.type;

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

@@ -6,39 +6,23 @@ import {
   JSDocPropertyTag,
   JSDocReturnTag,
   JSDocTag,
-  Node,
   SyntaxKind,
 } from 'typescript';
-import { getJsDoc, canHaveJsDoc } from 'tsutils';
-import pMapSeries from 'p-map-series';
 import {
-  DocSchema,
   PropertyLikeTagSchema,
   ReturnTagSchema,
   TagName,
   TagSchema,
 } from '@teambit/semantics.entities.semantic-schema';
+import { Formatter } from '@teambit/formatter';
 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, jsDoc.getText(), comment, tags);
-}
-
-async function tagParser(tag: JSDocTag, context: SchemaExtractorContext): Promise<TagSchema> {
+export async function tagParser(
+  tag: JSDocTag,
+  context: SchemaExtractorContext,
+  formatter: Formatter
+): Promise<TagSchema> {
   // for some reason, in some cases, if `tag.getSourceFile()` is not provided to the `getText()`, it throws "Cannot read property 'text' of undefined"
 
   switch (tag.kind) {
@@ -84,6 +68,15 @@ async function tagParser(tag: JSDocTag, context: SchemaExtractorContext): Promis
       return simpleTag(tag, TagName.implements, context);
     default: {
       const tagName: TagName | string = tag.tagName.getText(tag.getSourceFile());
+      if (tagName === 'example') {
+        const comment = getTextOfJSDocComment(tag.comment);
+        try {
+          const formattedComment = comment && (await formatter.formatSnippet(comment));
+          return new TagSchema(context.getLocation(tag), tagName, formattedComment);
+        } catch (e) {
+          return simpleTag(tag, tagName, context);
+        }
+      }
       return simpleTag(tag, tagName, context);
     }
   }

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

@@ -40,6 +40,9 @@ export function parseTypeFromQuickInfo(quickInfo: protocol.QuickInfoResponse | u
   const displayString = quickInfo.body.displayString;
   const splitByColon = displayString.split(':');
   switch (quickInfo.body.kind) {
+    case 'type parameter':
+      // (type parameter) T in concat<T, K, V>(array1: T[], array2: T[]): T[]
+      return displayString.replace(`(${quickInfo.body.kind}) `, '').split(' ')[0];
     case 'const':
     case 'property':
     case 'let':
@@ -79,6 +82,10 @@ export function parseTypeFromQuickInfo(quickInfo: protocol.QuickInfoResponse | u
       const [, ...tail] = splitByEqual;
       return tail.join('=').trim();
     }
+    case 'parameter': {
+      const typeColonIndex = displayString.indexOf(':');
+      return displayString.slice(typeColonIndex + 1).trim();
+    }
     default:
       return splitByColon[splitByColon.length - 1].trim();
   }

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

@@ -3,7 +3,6 @@ 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,
@@ -21,11 +20,12 @@ export async function toFunctionLikeSchema(
   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, Boolean(info));
   const modifiers = node.modifiers?.map((modifier) => modifier.getText()) || [];
   const typeParameters = node.typeParameters?.map((typeParam) => typeParam.name.getText());
   const location = context.getLocation(node);
-  const doc = await jsDocToDocSchema(node, context);
+  const doc = await context.jsDocToDocSchema(node);
   return new FunctionLikeSchema(
     location,
     name,

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

@@ -21,7 +21,6 @@ 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';
-import { jsDocToDocSchema } from './jsdoc-to-doc-schema';
 
 export async function typeElementToSchema(node: TypeElement, context: SchemaExtractorContext): Promise<SchemaNode> {
   switch (node.kind) {
@@ -51,7 +50,7 @@ async function propertySignature(node: ts.PropertySignature, context: SchemaExtr
   const typeStr = parseTypeFromQuickInfo(info);
   const type = await context.resolveType(node, typeStr);
   const isOptional = Boolean(node.questionToken);
-  const doc = await jsDocToDocSchema(node, context);
+  const doc = await context.jsDocToDocSchema(node);
   return new VariableLikeSchema(context.getLocation(node), name, displaySig, type, isOptional, doc);
 }
 

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

@@ -19,6 +19,7 @@ import {
   TemplateLiteralTypeSpan,
   ThisTypeNode,
   ConditionalTypeNode,
+  NamedTupleMember,
 } from 'typescript';
 import {
   SchemaNode,
@@ -41,13 +42,13 @@ import {
   ThisTypeSchema,
   Modifier,
   ConditionalTypeSchema,
+  NamedTupleSchema,
   UnImplementedSchema,
 } 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> {
@@ -90,8 +91,9 @@ export async function typeNodeToSchema(node: TypeNode, context: SchemaExtractorC
       return thisType(node as ThisTypeNode, context);
     case SyntaxKind.ConditionalType:
       return conditionalType(node as ConditionalTypeNode, context);
-    case SyntaxKind.ConstructorType:
     case SyntaxKind.NamedTupleMember:
+      return namedTupleType(node as NamedTupleMember, context);
+    case SyntaxKind.ConstructorType:
     case SyntaxKind.OptionalType:
     case SyntaxKind.RestType:
     case SyntaxKind.InferType:
@@ -192,7 +194,7 @@ async function functionType(node: FunctionTypeNode, context: SchemaExtractorCont
   const returnType = await typeNodeToSchema(node.type, context);
   const location = context.getLocation(node);
   const modifiers = node.modifiers?.map((modifier) => modifier.getText()) || [];
-  const doc = await jsDocToDocSchema(node, context);
+  const doc = await context.jsDocToDocSchema(node);
   return new FunctionLikeSchema(location, name, params, returnType, '', modifiers as Modifier[], doc);
 }
 
@@ -283,3 +285,10 @@ async function conditionalType(node: ConditionalTypeNode, context: SchemaExtract
   const falseType = await typeNodeToSchema(node.falseType, context);
   return new ConditionalTypeSchema(context.getLocation(node), checkType, extendsType, trueType, falseType);
 }
+
+async function namedTupleType(node: NamedTupleMember, context: SchemaExtractorContext) {
+  const name = node.name.getText();
+  const location = context.getLocation(node);
+  const type = await typeNodeToSchema(node.type, context);
+  return new NamedTupleSchema(location, type, name);
+}

package/transformers/variable-declaration.ts

@@ -10,7 +10,6 @@ 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) {
@@ -30,12 +29,27 @@ export class VariableDeclaration implements SchemaTransformer {
     const info = await context.getQuickInfo(varDec.name);
     const displaySig = info?.body?.displayString || '';
     const location = context.getLocation(varDec);
-    const doc = await jsDocToDocSchema(varDec, context);
+    const doc = await context.jsDocToDocSchema(varDec);
+    const modifiers = varDec.modifiers?.map((modifier) => modifier.getText()) || [];
     if (varDec.initializer?.kind === ts.SyntaxKind.ArrowFunction) {
       const args = await getParams((varDec.initializer as ArrowFunction).parameters, context);
+      // example => export const useLanesContext: () => LanesContextModel | undefined = () => {
+      if (varDec.type) {
+        const funcType = await context.resolveType(varDec, '');
+        if (isFunctionLike(funcType)) {
+          return new FunctionLikeSchema(
+            location,
+            name,
+            funcType.params,
+            funcType.returnType,
+            displaySig,
+            modifiers as Modifier[],
+            doc
+          );
+        }
+      }
       const typeStr = parseReturnTypeFromQuickInfo(info);
       const returnType = await context.resolveType(varDec, typeStr);
-      const modifiers = varDec.modifiers?.map((modifier) => modifier.getText()) || [];
       return new FunctionLikeSchema(location, name, args, returnType, displaySig, modifiers as Modifier[], doc);
     }
     const typeStr = parseTypeFromQuickInfo(info);
@@ -43,3 +57,7 @@ export class VariableDeclaration implements SchemaTransformer {
     return new VariableLikeSchema(location, name, displaySig, type, false, doc);
   }
 }
+
+function isFunctionLike(node: SchemaNode): node is FunctionLikeSchema {
+  return node instanceof FunctionLikeSchema;
+}

package/transformers/variable-statement.ts

@@ -1,4 +1,4 @@
-import { SchemaNode, Module } from '@teambit/semantics.entities.semantic-schema';
+import { SchemaNode, ModuleSchema } from '@teambit/semantics.entities.semantic-schema';
 import { compact } from 'lodash';
 import pMapSeries from 'p-map-series';
 import ts, { Node, VariableStatement } from 'typescript';
@@ -27,6 +27,6 @@ export class VariableStatementTransformer implements SchemaTransformer {
       const schema = await context.visitDefinition(dec.name);
       return schema;
     });
-    return new Module(context.getLocation(node), compact(schemas));
+    return new ModuleSchema(context.getLocation(node), compact(schemas));
   }
 }