@teambit/typescript 0.0.0-02c0c8ffc2ebaf66ef5cbfc2e31c48e2b4acbfc7

package/transformers/interface-declaration.ts

@@ -0,0 +1,66 @@
+import ts, { Node, InterfaceDeclaration, SyntaxKind } from 'typescript';
+import pMapSeries from 'p-map-series';
+import {
+  ExpressionWithTypeArgumentsSchema,
+  InterfaceSchema,
+  UnresolvedSchema,
+} from '@teambit/semantics.entities.semantic-schema';
+import { SchemaTransformer } from '../schema-transformer';
+import { SchemaExtractorContext } from '../schema-extractor-context';
+import { Identifier } from '../identifier';
+
+export class InterfaceDeclarationTransformer implements SchemaTransformer {
+  predicate(node: Node) {
+    return node.kind === SyntaxKind.InterfaceDeclaration;
+  }
+
+  async getIdentifiers(node: InterfaceDeclaration): Promise<Identifier[]> {
+    return [new Identifier(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) => context.computeSchema(t)) : [];
+        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) => context.computeSchema(member));
+    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/intersection-type.ts

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

package/transformers/keyword-type.ts

@@ -0,0 +1,39 @@
+import { Node, SyntaxKind } from 'typescript';
+import { KeywordTypeSchema } from '@teambit/semantics.entities.semantic-schema';
+import { SchemaTransformer } from '../schema-transformer';
+import { SchemaExtractorContext } from '../schema-extractor-context';
+import { Identifier } from '../identifier';
+
+/**
+ * whether it's kind of `ts.KeywordTypeSyntaxKind`
+ */
+export class KeywordTypeTransformer implements SchemaTransformer {
+  predicate(node: Node) {
+    switch (node.kind) {
+      case SyntaxKind.AnyKeyword:
+      case SyntaxKind.BigIntKeyword:
+      case SyntaxKind.BooleanKeyword:
+      case SyntaxKind.IntrinsicKeyword:
+      case SyntaxKind.NeverKeyword:
+      case SyntaxKind.NumberKeyword:
+      case SyntaxKind.ObjectKeyword:
+      case SyntaxKind.StringKeyword:
+      case SyntaxKind.SymbolKeyword:
+      case SyntaxKind.UndefinedKeyword:
+      case SyntaxKind.UnknownKeyword:
+      case SyntaxKind.VoidKeyword:
+        return true;
+      default:
+        return false;
+    }
+  }
+
+  async getIdentifiers(): Promise<Identifier[]> {
+    return [];
+  }
+
+  async transform(node: Node, context: SchemaExtractorContext) {
+    const location = context.getLocation(node);
+    return new KeywordTypeSchema(location, node.getText());
+  }
+}

package/transformers/literal-type.ts

@@ -0,0 +1,23 @@
+import ts, { LiteralTypeNode, Node } from 'typescript';
+import { LiteralTypeSchema } from '@teambit/semantics.entities.semantic-schema';
+import { SchemaTransformer } from '../schema-transformer';
+import { SchemaExtractorContext } from '../schema-extractor-context';
+import { Identifier } from '../identifier';
+
+/**
+ * e.g. string/boolean
+ */
+export class LiteralTypeTransformer implements SchemaTransformer {
+  predicate(node: Node) {
+    return node.kind === ts.SyntaxKind.LiteralType;
+  }
+
+  async getIdentifiers(): Promise<Identifier[]> {
+    return [];
+  }
+
+  async transform(node: LiteralTypeNode, context: SchemaExtractorContext) {
+    const location = context.getLocation(node);
+    return new LiteralTypeSchema(location, node.getText());
+  }
+}

package/transformers/literal-value.ts

@@ -0,0 +1,38 @@
+import { LiteralValueSchema, SchemaNode } from '@teambit/semantics.entities.semantic-schema';
+import ts, { Node, StringLiteral } from 'typescript';
+import type { SchemaExtractorContext } from '../schema-extractor-context';
+import { SchemaTransformer } from '../schema-transformer';
+import { Identifier } from '../identifier';
+
+export type LiteralValueNode =
+  | StringLiteral
+  | ts.NumericLiteral
+  | ts.TrueLiteral
+  | ts.FalseLiteral
+  | ts.NullLiteral
+  | ts.BigIntLiteral
+  | ts.RegularExpressionLiteral
+  | ts.NewExpression;
+
+export class LiteralValueTransformer implements SchemaTransformer {
+  predicate(node: Node): boolean {
+    return (
+      node.kind === ts.SyntaxKind.StringLiteral ||
+      node.kind === ts.SyntaxKind.NumericLiteral ||
+      node.kind === ts.SyntaxKind.TrueKeyword ||
+      node.kind === ts.SyntaxKind.FalseKeyword ||
+      node.kind === ts.SyntaxKind.NullKeyword ||
+      node.kind === ts.SyntaxKind.UndefinedKeyword ||
+      node.kind === ts.SyntaxKind.BigIntLiteral ||
+      node.kind === ts.SyntaxKind.RegularExpressionLiteral ||
+      node.kind === ts.SyntaxKind.NewExpression ||
+      node.kind === ts.SyntaxKind.NoSubstitutionTemplateLiteral
+    );
+  }
+  async getIdentifiers(): Promise<Identifier[]> {
+    return [];
+  }
+  async transform(node: LiteralValueNode, context: SchemaExtractorContext): Promise<SchemaNode> {
+    return new LiteralValueSchema(context.getLocation(node), node.getText());
+  }
+}

package/transformers/module-declaration.ts

@@ -0,0 +1,20 @@
+import ts, { Node, ModuleDeclaration } from 'typescript';
+import { UnImplementedSchema } from '@teambit/semantics.entities.semantic-schema';
+import { SchemaTransformer } from '../schema-transformer';
+import { SchemaExtractorContext } from '../schema-extractor-context';
+import { Identifier } from '../identifier';
+
+export class ModuleDeclarationTransformer implements SchemaTransformer {
+  predicate(node: Node) {
+    return node.kind === ts.SyntaxKind.ModuleDeclaration;
+  }
+
+  async getIdentifiers(): Promise<Identifier[]> {
+    return [];
+  }
+
+  async transform(node: ModuleDeclaration, context: SchemaExtractorContext) {
+    const location = context.getLocation(node);
+    return new UnImplementedSchema(location, node.getText(), ts.SyntaxKind[node.kind]);
+  }
+}

package/transformers/named-tuple.ts

@@ -0,0 +1,22 @@
+import { Node, SyntaxKind, NamedTupleMember } from 'typescript';
+import { NamedTupleSchema } from '@teambit/semantics.entities.semantic-schema';
+import { SchemaTransformer } from '../schema-transformer';
+import { SchemaExtractorContext } from '../schema-extractor-context';
+import { Identifier } from '../identifier';
+
+export class NamedTupleTransformer implements SchemaTransformer {
+  predicate(node: Node) {
+    return node.kind === SyntaxKind.NamedTupleMember;
+  }
+
+  async getIdentifiers(): Promise<Identifier[]> {
+    return [];
+  }
+
+  async transform(node: NamedTupleMember, context: SchemaExtractorContext) {
+    const name = node.name.getText();
+    const location = context.getLocation(node);
+    const type = await context.computeSchema(node.type);
+    return new NamedTupleSchema(location, type, name);
+  }
+}

package/transformers/object-literal-expression.ts

@@ -0,0 +1,28 @@
+import ts, { Node, ObjectLiteralExpression } from 'typescript';
+import pMapSeries from 'p-map-series';
+import { ObjectLiteralExpressionSchema, UnImplementedSchema } from '@teambit/semantics.entities.semantic-schema';
+import type { SchemaExtractorContext } from '../schema-extractor-context';
+import { SchemaTransformer } from '../schema-transformer';
+
+export class ObjectLiteralExpressionTransformer implements SchemaTransformer {
+  predicate(node: Node) {
+    return node.kind === ts.SyntaxKind.ObjectLiteralExpression;
+  }
+
+  async getIdentifiers() {
+    return [];
+  }
+
+  async transform(node: ObjectLiteralExpression, context: SchemaExtractorContext) {
+    const properties = await pMapSeries(node.properties, async (prop) => {
+      const schema = await context.computeSchema(prop);
+      if (schema instanceof UnImplementedSchema) {
+        const typeRef = await context.resolveType(prop, prop.getText());
+        return typeRef;
+      }
+      return schema;
+    });
+    const location = context.getLocation(node);
+    return new ObjectLiteralExpressionSchema(properties, location);
+  }
+}

package/transformers/parameter.ts

@@ -0,0 +1,122 @@
+import ts, {
+  BindingElement,
+  isIdentifier,
+  Node,
+  ParameterDeclaration,
+  SyntaxKind,
+  ArrayBindingElement,
+  isComputedPropertyName,
+} from 'typescript';
+import {
+  InferenceTypeSchema,
+  ParameterSchema,
+  SchemaNode,
+  TupleTypeSchema,
+  TypeLiteralSchema,
+} from '@teambit/semantics.entities.semantic-schema';
+import pMapSeries from 'p-map-series';
+import { SchemaTransformer } from '../schema-transformer';
+import { SchemaExtractorContext } from '../schema-extractor-context';
+import { parseTypeFromQuickInfo } from './utils/parse-type-from-quick-info';
+import { Identifier } from '../identifier';
+
+export class ParameterTransformer implements SchemaTransformer {
+  predicate(node: Node) {
+    return node.kind === ts.SyntaxKind.Parameter;
+  }
+
+  async getIdentifiers(): Promise<Identifier[]> {
+    return [];
+  }
+
+  async transform(node: ParameterDeclaration, context: SchemaExtractorContext) {
+    const type = await this.getType(node, context);
+    return new ParameterSchema(
+      context.getLocation(node),
+      ParameterTransformer.getName(node),
+      type,
+      Boolean(node.questionToken) || Boolean(node.initializer),
+      node.initializer ? node.initializer.getText() : undefined,
+      undefined,
+      await ParameterTransformer.getObjectBindingNodes(node, type, context),
+      Boolean(node.dotDotDotToken)
+    );
+  }
+
+  static getName(param: ParameterDeclaration): string {
+    if (isIdentifier(param.name)) {
+      return param.name.getText();
+    }
+    // it's binding pattern, either an array or an object
+    const elements = param.name.elements.map((elem) => elem.getText());
+    const elementsStr = elements.join(', ');
+    if (param.name.kind === SyntaxKind.ArrayBindingPattern) {
+      return `[ ${elementsStr} ]`;
+    }
+    // it's an object binding
+    return `{ ${elementsStr} }`;
+  }
+
+  async getType(param: ParameterDeclaration, context: SchemaExtractorContext): Promise<SchemaNode> {
+    if (param.type) {
+      return context.computeSchema(param.type);
+    }
+
+    if (isIdentifier(param.name)) {
+      const info = await context.getQuickInfo(param.name);
+      const parsed = parseTypeFromQuickInfo(info);
+      return new InferenceTypeSchema(context.getLocation(param), parsed);
+    }
+    // it's binding pattern, either an array or an object
+    if (param.name.kind === SyntaxKind.ArrayBindingPattern) {
+      const elements = await pMapSeries(param.name.elements, async (elem: ArrayBindingElement) => {
+        const info = await context.getQuickInfo(elem);
+        const parsed = parseTypeFromQuickInfo(info);
+        return new InferenceTypeSchema(context.getLocation(param), parsed);
+      });
+      return new TupleTypeSchema(context.getLocation(param), elements);
+    }
+    if (param.name.kind === SyntaxKind.ObjectBindingPattern) {
+      const elements = await 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());
+      });
+      return new TypeLiteralSchema(context.getLocation(param), elements);
+    }
+    throw new Error(`unknown param type`);
+  }
+
+  static async getObjectBindingNodes(
+    param: ParameterDeclaration,
+    paramType: SchemaNode,
+    context: SchemaExtractorContext
+  ): Promise<SchemaNode[] | undefined> {
+    if (param.name.kind !== SyntaxKind.ObjectBindingPattern) return undefined;
+    return pMapSeries(param.name.elements, async (elem: BindingElement) => {
+      const existing = paramType.findNode?.((node) => {
+        return node.name === elem.name.getText().trim();
+      });
+      if (existing && existing.__schema !== 'InferenceTypeSchema') {
+        return existing;
+      }
+      const info = await context.getQuickInfo(elem.name);
+      const parsed = info ? parseTypeFromQuickInfo(info) : elem.getText();
+      const defaultValue = elem.initializer ? elem.initializer.getText() : undefined;
+      const alias =
+        elem.propertyName && isComputedPropertyName(elem.propertyName)
+          ? elem.propertyName?.expression.getText()
+          : undefined;
+
+      const name = elem.name.getText();
+      return new InferenceTypeSchema(
+        context.getLocation(elem.name),
+        parsed,
+        name,
+        defaultValue,
+        Boolean(elem.dotDotDotToken),
+        alias
+      );
+    });
+  }
+}

package/transformers/parenthesized-type.ts

@@ -0,0 +1,20 @@
+import { Node, ParenthesizedTypeNode, SyntaxKind } from 'typescript';
+import { ParenthesizedTypeSchema } from '@teambit/semantics.entities.semantic-schema';
+import { SchemaTransformer } from '../schema-transformer';
+import { SchemaExtractorContext } from '../schema-extractor-context';
+import { Identifier } from '../identifier';
+
+export class ParenthesizedTypeTransformer implements SchemaTransformer {
+  predicate(node: Node) {
+    return node.kind === SyntaxKind.ParenthesizedType;
+  }
+
+  async getIdentifiers(): Promise<Identifier[]> {
+    return [];
+  }
+
+  async transform(node: ParenthesizedTypeNode, context: SchemaExtractorContext) {
+    const type = await context.computeSchema(node.type);
+    return new ParenthesizedTypeSchema(context.getLocation(node), type);
+  }
+}

package/transformers/property-assignment.ts

@@ -0,0 +1,23 @@
+import { PropertyAssignmentSchema } from '@teambit/semantics.entities.semantic-schema';
+import ts, { Node, PropertyAssignment } from 'typescript';
+import { SchemaExtractorContext } from '../schema-extractor-context';
+import { SchemaTransformer } from '../schema-transformer';
+import { Identifier } from '../identifier';
+
+export class PropertyAssignmentTransformer implements SchemaTransformer {
+  predicate(node: Node): boolean {
+    return node.kind === ts.SyntaxKind.PropertyAssignment;
+  }
+
+  async getIdentifiers(): Promise<Identifier[]> {
+    return [];
+  }
+
+  async transform(node: PropertyAssignment, context: SchemaExtractorContext): Promise<any> {
+    const name = node.name.getText();
+    const value = await context.computeSchema(node.initializer);
+    const location = context.getLocation(node);
+    const docs = await context.jsDocToDocSchema(node);
+    return new PropertyAssignmentSchema(name, value, location, docs);
+  }
+}

package/transformers/property-declaration.ts

@@ -0,0 +1,34 @@
+import { Node, PropertyDeclaration, PropertySignature, SyntaxKind, isPropertyDeclaration } from 'typescript';
+import { VariableLikeSchema } from '@teambit/semantics.entities.semantic-schema';
+import { SchemaTransformer } from '../schema-transformer';
+import { SchemaExtractorContext } from '../schema-extractor-context';
+import { parseTypeFromQuickInfo } from './utils/parse-type-from-quick-info';
+import { Identifier } from '../identifier';
+
+export class PropertyDeclarationTransformer implements SchemaTransformer {
+  predicate(node: Node) {
+    return node.kind === SyntaxKind.PropertyDeclaration || node.kind === SyntaxKind.PropertySignature;
+  }
+
+  async getIdentifiers(): Promise<Identifier[]> {
+    return [];
+  }
+
+  // [computedName]: string
+  private isComputedProperty(node: PropertyDeclaration | PropertySignature) {
+    return node.name.kind === SyntaxKind.ComputedPropertyName;
+  }
+
+  // @todo - handle arrow function objects
+  async transform(node: PropertyDeclaration | PropertySignature, context: SchemaExtractorContext) {
+    const name = node.name.getText();
+    const info = this.isComputedProperty(node) ? undefined : await context.getQuickInfo(node.name);
+    const displaySig = info?.body?.displayString || node.getText();
+    const typeStr = parseTypeFromQuickInfo(info);
+    const type = await context.resolveType(node, typeStr);
+    const isOptional = Boolean(node.questionToken) || (isPropertyDeclaration(node) && Boolean(node.initializer));
+    const doc = await context.jsDocToDocSchema(node);
+    const defaultValue = isPropertyDeclaration(node) ? node.initializer?.getText() : undefined;
+    return new VariableLikeSchema(context.getLocation(node), name, displaySig, type, isOptional, doc, defaultValue);
+  }
+}

package/transformers/set-accessor.ts

@@ -0,0 +1,25 @@
+import ts, { Node, SetAccessorDeclaration } from 'typescript';
+import { ParameterSchema, SetAccessorSchema } from '@teambit/semantics.entities.semantic-schema';
+import pMapSeries from 'p-map-series';
+import { SchemaTransformer } from '../schema-transformer';
+import { SchemaExtractorContext } from '../schema-extractor-context';
+import { Identifier } from '../identifier';
+
+export class SetAccessorTransformer implements SchemaTransformer {
+  predicate(node: Node) {
+    return node.kind === ts.SyntaxKind.SetAccessor;
+  }
+
+  async getIdentifiers(): Promise<Identifier[]> {
+    return [];
+  }
+
+  async transform(node: SetAccessorDeclaration, context: SchemaExtractorContext) {
+    const params = (await pMapSeries(node.parameters, async (param) =>
+      context.computeSchema(param)
+    )) as ParameterSchema[];
+
+    const displaySig = await context.getQuickInfoDisplayString(node.name);
+    return new SetAccessorSchema(context.getLocation(node), node.name.getText(), params[0], displaySig);
+  }
+}

package/transformers/source-file-transformer.ts

@@ -0,0 +1,94 @@
+import ts, { Node, SourceFile } from 'typescript';
+import { flatten } from 'lodash';
+import pMapSeries from 'p-map-series';
+import { ModuleSchema } from '@teambit/semantics.entities.semantic-schema';
+import { SchemaTransformer } from '../schema-transformer';
+import { ExportIdentifier } from '../export-identifier';
+import { SchemaExtractorContext } from '../schema-extractor-context';
+import { Identifier } from '../identifier';
+
+export class SourceFileTransformer implements SchemaTransformer {
+  predicate(node: Node) {
+    return node.kind === ts.SyntaxKind.SourceFile;
+  }
+
+  async getIdentifiers(sourceFile: SourceFile, context: SchemaExtractorContext) {
+    const exports = this.listExports(sourceFile);
+    const internals = this.listInternalNodes(sourceFile);
+
+    // change to pMap series
+    const exportIdentifiers = flatten(
+      await pMapSeries(exports, (node) => {
+        return context.getIdentifiers(node);
+      })
+    ).reduce<ExportIdentifier[]>((acc, current) => {
+      const item = acc.find((exportIdentifier) => exportIdentifier.isEqual(current));
+      if (!item) acc.push(new ExportIdentifier(current.id, current.filePath, current.aliasId, current.sourceFilePath));
+      return acc;
+    }, []);
+
+    const internalIdentifiers = flatten(
+      await pMapSeries(internals, (node) => {
+        return context.getIdentifiers(node);
+      })
+    ).reduce<Identifier[]>((acc, current) => {
+      const item = acc.find((internalIdentifier) => internalIdentifier.isEqual(current));
+      if (!item) acc.push(current);
+      return acc;
+    }, []);
+
+    const identifiers = [...exportIdentifiers, ...internalIdentifiers];
+
+    return identifiers;
+  }
+
+  async transform(node: SourceFile, context: SchemaExtractorContext) {
+    const exports = this.listExports(node);
+    const internals = this.listInternalNodes(node).filter(
+      (internal) => internal.kind !== ts.SyntaxKind.ImportDeclaration
+    );
+
+    const exportDeclarations = await pMapSeries(exports, (exportNode) => {
+      return context.computeSchema(exportNode);
+    });
+
+    const internalDeclarations = await pMapSeries(internals, (internalNode) => {
+      return context.computeSchema(internalNode);
+    });
+
+    return new ModuleSchema(context.getLocation(node), exportDeclarations, internalDeclarations);
+  }
+
+  /**
+   * list all exports of a source file.
+   */
+  private listExports(ast: SourceFile): Node[] {
+    return ast.statements.filter((statement) => {
+      if (statement.kind === ts.SyntaxKind.ExportDeclaration || statement.kind === ts.SyntaxKind.ExportAssignment)
+        return true;
+      const modifiers = ts.canHaveModifiers(statement) ? ts.getModifiers(statement) : undefined;
+      const isExport = Boolean(
+        modifiers?.find((modifier) => {
+          return modifier.kind === ts.SyntaxKind.ExportKeyword;
+        })
+      );
+      return isExport;
+    });
+  }
+
+  private listInternalNodes(ast: SourceFile): Node[] {
+    return ast.statements.filter((statement) => {
+      const modifiers = ts.canHaveModifiers(statement) ? ts.getModifiers(statement) : undefined;
+      if (
+        !(statement.kind === ts.SyntaxKind.ExportDeclaration || statement.kind === ts.SyntaxKind.ExportAssignment) &&
+        !modifiers?.find((modifier) => {
+          return modifier.kind === ts.SyntaxKind.ExportKeyword;
+        })
+      ) {
+        return true;
+      }
+
+      return false;
+    });
+  }
+}

package/transformers/template-literal-type-span.ts

@@ -0,0 +1,21 @@
+import { Node, SyntaxKind, TemplateLiteralTypeSpan } from 'typescript';
+import { TemplateLiteralTypeSpanSchema } from '@teambit/semantics.entities.semantic-schema';
+import { SchemaTransformer } from '../schema-transformer';
+import { SchemaExtractorContext } from '../schema-extractor-context';
+import { Identifier } from '../identifier';
+
+export class TemplateLiteralTypeSpanTransformer implements SchemaTransformer {
+  predicate(node: Node) {
+    return node.kind === SyntaxKind.TemplateLiteralTypeSpan;
+  }
+
+  async getIdentifiers(): Promise<Identifier[]> {
+    return [];
+  }
+
+  async transform(node: TemplateLiteralTypeSpan, context: SchemaExtractorContext) {
+    const type = await context.computeSchema(node.type);
+    const literal = node.literal.text;
+    return new TemplateLiteralTypeSpanSchema(context.getLocation(node), literal, type);
+  }
+}

package/transformers/template-literal-type.ts

@@ -0,0 +1,24 @@
+import { Node, SyntaxKind, TemplateLiteralTypeNode } from 'typescript';
+import pMapSeries from 'p-map-series';
+import { TemplateLiteralTypeSchema, TemplateLiteralTypeSpanSchema } from '@teambit/semantics.entities.semantic-schema';
+import { SchemaTransformer } from '../schema-transformer';
+import { SchemaExtractorContext } from '../schema-extractor-context';
+import { Identifier } from '../identifier';
+
+export class TemplateLiteralTypeTransformer implements SchemaTransformer {
+  predicate(node: Node) {
+    return node.kind === SyntaxKind.TemplateLiteralType;
+  }
+
+  async getIdentifiers(): Promise<Identifier[]> {
+    return [];
+  }
+
+  async transform(node: TemplateLiteralTypeNode, context: SchemaExtractorContext) {
+    const templateSpans = (await pMapSeries(node.templateSpans, (span) =>
+      context.computeSchema(span)
+    )) as TemplateLiteralTypeSpanSchema[];
+    const head = node.head.text;
+    return new TemplateLiteralTypeSchema(context.getLocation(node), head, templateSpans);
+  }
+}

package/transformers/this-type.ts

@@ -0,0 +1,19 @@
+import { Node, SyntaxKind, ThisTypeNode } from 'typescript';
+import { ThisTypeSchema } from '@teambit/semantics.entities.semantic-schema';
+import { SchemaTransformer } from '../schema-transformer';
+import { SchemaExtractorContext } from '../schema-extractor-context';
+import { Identifier } from '../identifier';
+
+export class ThisTypeTransformer implements SchemaTransformer {
+  predicate(node: Node) {
+    return node.kind === SyntaxKind.ThisType;
+  }
+
+  async getIdentifiers(): Promise<Identifier[]> {
+    return [];
+  }
+
+  async transform(node: ThisTypeNode, context: SchemaExtractorContext) {
+    return new ThisTypeSchema(context.getLocation(node), 'this');
+  }
+}