@teambit/typescript 0.0.0-004aea01bc027e428dfd0f6583f49a1b8286bdd0

package/transformers/conditional-type.ts

@@ -0,0 +1,24 @@
+import type { Node, ConditionalTypeNode } from 'typescript';
+import { SyntaxKind } from 'typescript';
+import { ConditionalTypeSchema } from '@teambit/semantics.entities.semantic-schema';
+import type { SchemaTransformer } from '../schema-transformer';
+import type { SchemaExtractorContext } from '../schema-extractor-context';
+import type { Identifier } from '../identifier';
+
+export class ConditionalTypeTransformer implements SchemaTransformer {
+  predicate(node: Node) {
+    return node.kind === SyntaxKind.ConditionalType;
+  }
+
+  async getIdentifiers(): Promise<Identifier[]> {
+    return [];
+  }
+
+  async transform(node: ConditionalTypeNode, context: SchemaExtractorContext) {
+    const checkType = await context.computeSchema(node.checkType);
+    const extendsType = await context.computeSchema(node.extendsType);
+    const trueType = await context.computeSchema(node.trueType);
+    const falseType = await context.computeSchema(node.falseType);
+    return new ConditionalTypeSchema(context.getLocation(node), checkType, extendsType, trueType, falseType);
+  }
+}

package/transformers/constructor.ts

@@ -0,0 +1,37 @@
+import type { Node, ConstructorDeclaration } from 'typescript';
+import ts from 'typescript';
+import type { ParameterSchema, Modifier } from '@teambit/semantics.entities.semantic-schema';
+import { ConstructorSchema, ThisTypeSchema } from '@teambit/semantics.entities.semantic-schema';
+import pMapSeries from 'p-map-series';
+import type { SchemaTransformer } from '../schema-transformer';
+import type { SchemaExtractorContext } from '../schema-extractor-context';
+import type { Identifier } from '../identifier';
+
+export class ConstructorTransformer implements SchemaTransformer {
+  predicate(node: Node) {
+    return node.kind === ts.SyntaxKind.Constructor;
+  }
+
+  async getIdentifiers(): Promise<Identifier[]> {
+    return [];
+  }
+
+  async transform(node: ConstructorDeclaration, context: SchemaExtractorContext) {
+    const args = await pMapSeries(node.parameters, async (param) => context.computeSchema(param));
+    const info = await context.getQuickInfo(node);
+    const displaySig = info?.body?.displayString || '';
+    const name = node.parent?.name?.getText() || '';
+    const returns = new ThisTypeSchema(context.getLocation(node.parent), name);
+    const modifiers = node.modifiers?.map((modifier) => modifier.getText()) || [];
+    const doc = await context.jsDocToDocSchema(node);
+
+    return new ConstructorSchema(
+      context.getLocation(node),
+      args as ParameterSchema[],
+      returns,
+      displaySig,
+      modifiers as Modifier[],
+      doc
+    );
+  }
+}

package/transformers/decorator.ts

@@ -0,0 +1,30 @@
+import type { SchemaNode } from '@teambit/semantics.entities.semantic-schema';
+import { DecoratorSchema } from '@teambit/semantics.entities.semantic-schema';
+import type { Decorator, Node } from 'typescript';
+import ts from 'typescript';
+import pMapSeries from 'p-map-series';
+import type { SchemaExtractorContext } from '../schema-extractor-context';
+import type { SchemaTransformer } from '../schema-transformer';
+import { Identifier } from '../identifier';
+
+export class DecoratorTransformer implements SchemaTransformer {
+  predicate(node: Node) {
+    return node.kind === ts.SyntaxKind.Decorator;
+  }
+
+  async getIdentifiers(decorator: Decorator) {
+    const identifierText = decorator.expression.getFirstToken()?.getText() || '';
+    return [new Identifier(identifierText, decorator.getSourceFile().fileName)];
+  }
+
+  async transform(node: Decorator, context: SchemaExtractorContext): Promise<SchemaNode> {
+    const name = node.expression.getFirstToken()?.getText() || '';
+    const location = context.getLocation(node);
+    const doc = await context.jsDocToDocSchema(node);
+    const args =
+      ts.isCallExpression(node.expression) && node.expression.arguments.length
+        ? await pMapSeries(node.expression.arguments, (arg) => context.computeSchema(arg))
+        : undefined;
+    return new DecoratorSchema(location, name, doc, args);
+  }
+}

package/transformers/enum-declaration.ts

@@ -0,0 +1,32 @@
+import type { Node, EnumDeclaration } from 'typescript';
+import ts from 'typescript';
+import { EnumMemberSchema, EnumSchema } from '@teambit/semantics.entities.semantic-schema';
+import pMapSeries from 'p-map-series';
+import type { SchemaTransformer } from '../schema-transformer';
+import type { SchemaExtractorContext } from '../schema-extractor-context';
+import { Identifier } from '../identifier';
+
+export class EnumDeclarationTransformer implements SchemaTransformer {
+  predicate(node: Node) {
+    return node.kind === ts.SyntaxKind.EnumDeclaration;
+  }
+
+  async getIdentifiers(node: EnumDeclaration): Promise<Identifier[]> {
+    return [new Identifier(node.name.getText(), node.getSourceFile().fileName)];
+  }
+
+  async transform(enumDec: EnumDeclaration, context: SchemaExtractorContext) {
+    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-assignment.ts

@@ -0,0 +1,48 @@
+import type { SchemaNode } from '@teambit/semantics.entities.semantic-schema';
+import { ExportSchema, TypeRefSchema } from '@teambit/semantics.entities.semantic-schema';
+import type { Node, ExportAssignment as ExportAssignmentNode } from 'typescript';
+import { SyntaxKind } from 'typescript';
+import { ExportIdentifier } from '../export-identifier';
+import type { SchemaExtractorContext } from '../schema-extractor-context';
+import type { SchemaTransformer } from '../schema-transformer';
+
+/**
+ * This is either an export = or an export default declaration.
+ * Unless isExportEquals is set, this node was parsed as an export default
+ */
+export class ExportAssignmentTransformer implements SchemaTransformer {
+  predicate(node: Node) {
+    return node.kind === SyntaxKind.ExportAssignment;
+  }
+
+  async getIdentifiers(exportDec: ExportAssignmentNode) {
+    return [new ExportIdentifier('default', exportDec.getSourceFile().fileName)];
+  }
+
+  async transform(exportDec: ExportAssignmentNode, context: SchemaExtractorContext): Promise<SchemaNode> {
+    const specifier = exportDec.expression;
+    const location = context.getLocation(exportDec);
+    const absoluteFilePath = exportDec.getSourceFile().fileName;
+
+    const exportNode = await context.getTypeRef(specifier.getText(), absoluteFilePath, location);
+
+    if (exportNode) {
+      return new ExportSchema(
+        location,
+        `${exportNode.name} (default)`,
+        new TypeRefSchema(
+          exportNode.location,
+          exportNode.name,
+          exportNode.componentId,
+          exportNode.packageName,
+          exportNode.internalFilePath
+        ),
+        `${exportNode.name} (default)`
+      );
+    }
+
+    const schemaNode = await context.computeSchema(specifier);
+    const nodeName = schemaNode.name ? `${schemaNode.name} (default)` : 'default';
+    return new ExportSchema(location, nodeName, schemaNode, nodeName);
+  }
+}

package/transformers/export-declaration.ts

@@ -0,0 +1,182 @@
+import type { SchemaNode } from '@teambit/semantics.entities.semantic-schema';
+import {
+  ModuleSchema,
+  UnresolvedSchema,
+  UnImplementedSchema,
+  ExportSchema,
+} from '@teambit/semantics.entities.semantic-schema';
+import type {
+  Node,
+  ExportDeclaration as ExportDeclarationNode,
+  NamedExports,
+  NamespaceExport,
+  ExportSpecifier,
+} from 'typescript';
+import ts, { SyntaxKind } from 'typescript';
+import type { SchemaExtractorContext } from '../schema-extractor-context';
+import type { SchemaTransformer } from '../schema-transformer';
+import { ExportIdentifier } from '../export-identifier';
+
+export class ExportDeclarationTransformer implements SchemaTransformer {
+  predicate(node: Node) {
+    return node.kind === SyntaxKind.ExportDeclaration;
+  }
+
+  async getIdentifiers(exportDec: ExportDeclarationNode, context: SchemaExtractorContext) {
+    // e.g. `export { button1, button2 } as Composition from './button';
+    const rawSourceFilePath = exportDec.moduleSpecifier?.getText();
+
+    // strip off quotes ''
+    const sourceFilePath = rawSourceFilePath && rawSourceFilePath.substring(1, rawSourceFilePath?.length - 1);
+
+    if (exportDec.exportClause?.kind === ts.SyntaxKind.NamedExports) {
+      return exportDec.exportClause.elements.map((elm) => {
+        const alias = (elm.propertyName && elm.name.getText()) || undefined;
+        const id = elm.propertyName?.getText() || elm.name.getText();
+        const fileName = elm.getSourceFile().fileName;
+
+        return new ExportIdentifier(id, fileName, alias, sourceFilePath);
+      });
+    }
+
+    //  e.g. `export * as Composition from './button';
+    if (exportDec.exportClause?.kind === ts.SyntaxKind.NamespaceExport) {
+      return [
+        new ExportIdentifier(
+          exportDec.exportClause.name.getText(),
+          exportDec.getSourceFile().fileName,
+          undefined,
+          sourceFilePath
+        ),
+      ];
+    }
+
+    if (exportDec.moduleSpecifier) {
+      return context.getFileExports(exportDec);
+    }
+
+    return [];
+  }
+
+  async transform(exportDec: ExportDeclarationNode, context: SchemaExtractorContext): Promise<SchemaNode> {
+    const exportClause = exportDec.exportClause;
+
+    // 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);
+      // export * from 'webpack', export-all from a package
+      if (!sourceFile) {
+        return new UnImplementedSchema(
+          context.getLocation(exportDec),
+          exportDec.getText(),
+          SyntaxKind[SyntaxKind.ExportDeclaration]
+        );
+      }
+      return context.computeSchema(sourceFile);
+    }
+
+    // e.g. `export { button1, button2 } as Composition from './button';
+    if (exportClause.kind === SyntaxKind.NamedExports) {
+      const schemas = await namedExport(exportClause, context);
+      return new ModuleSchema(context.getLocation(exportDec), schemas, []);
+    }
+    // e.g. `export * as Composition from './button';
+    if (exportClause.kind === SyntaxKind.NamespaceExport) {
+      return namespaceExport(exportClause, exportDec, context);
+    }
+
+    // should never reach here. exportClause can be either NamespaceExport or NamedExports
+    throw new Error(`unrecognized exportClause type`);
+  }
+}
+
+function isSameNode(nodeA: Node, nodeB: Node): boolean {
+  return nodeA.kind === nodeB.kind && nodeA.pos === nodeB.pos && nodeA.end === nodeB.end;
+}
+
+async function namedExport(exportClause: NamedExports, context: SchemaExtractorContext): Promise<ExportSchema[]> {
+  const schemas = await Promise.all(
+    exportClause.elements.map(async (element) => {
+      return exportSpecifierToSchemaNode(element, context);
+    })
+  );
+
+  return schemas;
+}
+
+async function exportSpecifierToSchemaNode(
+  element: ExportSpecifier,
+  context: SchemaExtractorContext
+): Promise<ExportSchema> {
+  try {
+    const name = element.propertyName?.getText() || element.name.getText();
+    const alias = element.propertyName ? element.name.getText() : undefined;
+    const location = context.getLocation(element.name);
+    const definitionInfo = element.isTypeOnly
+      ? await context.definitionInfo(element.name)
+      : await context.definitionInfo(element);
+
+    if (!definitionInfo) {
+      const exportNode = new UnresolvedSchema(location, element.name.getText());
+      // happens for example when the main index.ts file exports variable from an mdx file.
+      // tsserver is unable to get the definition node because it doesn't know to parse mdx files.
+      // return new UnresolvedSchema(context.getLocation(element.name), element.name.getText());
+      return new ExportSchema(location, name, exportNode, alias);
+    }
+
+    const definitionNode = await context.definition(definitionInfo);
+
+    if (!definitionNode) {
+      const exportNode = await context.resolveType(element, name);
+      return new ExportSchema(location, name, exportNode, alias);
+    }
+
+    // if it is reexported from another export
+    if (isSameNode(element, definitionNode.parent)) {
+      // the definition node is the same node as element.name. tsserver wasn't able to find the source for it
+      // normally, "bit install" should fix it. another option is to open vscode and look for errors.
+      throw new Error(`error: tsserver is unable to locate the identifier "${element.name.getText()}" at ${context.getLocationAsString(
+        element.name
+      )}.
+make sure "bit status" is clean and there are no errors about missing packages/links.
+also, make sure the tsconfig.json in the root has the "jsx" setting defined.`);
+    }
+
+    if (definitionNode.parent.kind === SyntaxKind.ExportSpecifier) {
+      return await exportSpecifierToSchemaNode(definitionNode.parent as ExportSpecifier, context);
+    }
+
+    const exportNode = await context.computeSchema(definitionNode.parent);
+    return new ExportSchema(location, name, exportNode, alias);
+  } catch {
+    const exportNode = new UnresolvedSchema(context.getLocation(element.name), element.name.getText());
+    return new ExportSchema(context.getLocation(element.name), element.name.getText(), exportNode);
+  }
+}
+
+async function namespaceExport(
+  exportClause: NamespaceExport,
+  exportDec: ExportDeclarationNode,
+  context: SchemaExtractorContext
+) {
+  const namespace = exportClause.name.getText();
+  const filePath = await context.getFilePathByNode(exportClause.name);
+  if (!filePath) {
+    throw new Error(`unable to find the file-path for "${namespace}"`);
+  }
+  const sourceFile = context.getSourceFileInsideComponent(filePath);
+  if (!sourceFile) {
+    // it's a namespace from another component or an external package.
+    return context.getTypeRefForExternalPath(namespace, filePath, context.getLocation(exportDec));
+  }
+  const result = await context.computeSchema(sourceFile);
+  if (!(result instanceof ModuleSchema)) {
+    throw new Error(`expect result to be instance of Module`);
+  }
+  result.namespace = namespace;
+  return result;
+}

package/transformers/expression-statement.ts

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

package/transformers/function-like.ts

@@ -0,0 +1,72 @@
+import type { ParameterSchema, SchemaNode, Modifier } from '@teambit/semantics.entities.semantic-schema';
+import { FunctionLikeSchema } from '@teambit/semantics.entities.semantic-schema';
+import type { Node, SignatureDeclaration } from 'typescript';
+import ts from 'typescript';
+import pMapSeries from 'p-map-series';
+import type { SchemaExtractorContext } from '../schema-extractor-context';
+import type { SchemaTransformer } from '../schema-transformer';
+import { parseTypeFromQuickInfo } from './utils/parse-type-from-quick-info';
+import { Identifier } from '../identifier';
+
+export class FunctionLikeTransformer implements SchemaTransformer {
+  predicate(node: Node) {
+    return (
+      node.kind === ts.SyntaxKind.FunctionDeclaration ||
+      node.kind === ts.SyntaxKind.ArrowFunction ||
+      node.kind === ts.SyntaxKind.MethodDeclaration ||
+      node.kind === ts.SyntaxKind.CallSignature ||
+      node.kind === ts.SyntaxKind.ConstructSignature ||
+      node.kind === ts.SyntaxKind.FunctionType ||
+      node.kind === ts.SyntaxKind.MethodSignature
+    );
+  }
+
+  // need to check for anonymous functions assigned for vars, const and let.
+  async getIdentifiers(funcDec: SignatureDeclaration) {
+    return [new Identifier(this.getName(funcDec), funcDec.getSourceFile().fileName)];
+  }
+
+  private getName(funcDec: SignatureDeclaration) {
+    if (funcDec.kind === ts.SyntaxKind.ConstructSignature) return 'new';
+    return funcDec.name?.getText() || '';
+  }
+
+  async transform(node: SignatureDeclaration, context: SchemaExtractorContext): Promise<SchemaNode> {
+    const name = this.getName(node);
+    const nodeModifiers = ts.canHaveModifiers(node) ? ts.getModifiers(node) : undefined;
+    const getQuickInfoFromDefaultModifier = async () => {
+      const defaultModifier = nodeModifiers?.find((modifier) => modifier.kind === ts.SyntaxKind.DefaultKeyword);
+      if (defaultModifier) return context.getQuickInfo(defaultModifier);
+      if (node.kind === ts.SyntaxKind.ArrowFunction) return context.getQuickInfo(node.equalsGreaterThanToken);
+      return null;
+    };
+    const info = node.name ? await context.getQuickInfo(node.name) : await getQuickInfoFromDefaultModifier();
+    const returnTypeStr = info ? parseTypeFromQuickInfo(info) : 'any';
+    const displaySig = info?.body?.displayString || '';
+    const args = (await pMapSeries(node.parameters, async (param) =>
+      context.computeSchema(param)
+    )) as ParameterSchema[];
+
+    const returnType = await context.resolveType(node, returnTypeStr);
+    const modifiers = nodeModifiers?.map((modifier) => modifier.getText()) || [];
+    const typeParameters = node.typeParameters?.map((typeParam) => typeParam.name.getText());
+    const location = context.getLocation(node);
+    const doc = await context.jsDocToDocSchema(node);
+    const nodeDecorators = ts.canHaveDecorators(node) ? ts.getDecorators(node) : undefined;
+    const decorators = nodeDecorators?.length
+      ? await pMapSeries(nodeDecorators, (decorator) => context.computeSchema(decorator))
+      : undefined;
+
+    return new FunctionLikeSchema(
+      location,
+      name,
+      args,
+      returnType,
+      displaySig,
+      modifiers as Modifier[],
+      doc,
+      typeParameters,
+      decorators
+    );
+  }
+}

package/transformers/get-accessor.ts

@@ -0,0 +1,25 @@
+import type { Node, GetAccessorDeclaration } from 'typescript';
+import ts from 'typescript';
+import { GetAccessorSchema } from '@teambit/semantics.entities.semantic-schema';
+import type { SchemaTransformer } from '../schema-transformer';
+import type { SchemaExtractorContext } from '../schema-extractor-context';
+import { parseTypeFromQuickInfo } from './utils/parse-type-from-quick-info';
+import type { Identifier } from '../identifier';
+
+export class GetAccessorTransformer implements SchemaTransformer {
+  predicate(node: Node) {
+    return node.kind === ts.SyntaxKind.GetAccessor;
+  }
+
+  async getIdentifiers(): Promise<Identifier[]> {
+    return [];
+  }
+
+  async transform(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);
+  }
+}

package/transformers/import-declaration.ts

@@ -0,0 +1,57 @@
+import type { ImportDeclaration, Node } from 'typescript';
+import { SyntaxKind } from 'typescript';
+import { UnImplementedSchema } from '@teambit/semantics.entities.semantic-schema';
+import type { SchemaTransformer } from '../schema-transformer';
+import type { SchemaExtractorContext } from '../schema-extractor-context';
+import { Identifier } from '../identifier';
+
+export class ImportDeclarationTransformer implements SchemaTransformer {
+  predicate(node: Node) {
+    return node.kind === SyntaxKind.ImportDeclaration;
+  }
+
+  async getIdentifiers(importDec: ImportDeclaration): Promise<Identifier[]> {
+    if (!importDec.importClause) return [];
+
+    const sourceFile = importDec.getSourceFile().fileName;
+    const rawSourceFilePath = importDec.moduleSpecifier.getText();
+    const sourceFilePath = rawSourceFilePath.substring(1, rawSourceFilePath.length - 1);
+
+    // import A from 'a'
+    if (!importDec.importClause.namedBindings) {
+      return [new Identifier(importDec.importClause.getText(), sourceFile, undefined, sourceFilePath)];
+    }
+
+    // import { A } from 'a'
+    if (importDec.importClause.namedBindings?.kind === SyntaxKind.NamedImports) {
+      const { elements } = importDec.importClause.namedBindings;
+
+      return elements.map(({ name, propertyName }) => {
+        const id = propertyName?.getText() || name.getText();
+        const alias = (propertyName && name.getText()) || undefined;
+        const identifier = new Identifier(id, sourceFile, alias, sourceFilePath);
+        return identifier;
+      });
+    }
+
+    // import * as A from 'a';
+    if (importDec.importClause.namedBindings.kind === SyntaxKind.NamespaceImport) {
+      return [
+        new Identifier(
+          importDec.importClause.namedBindings.name.getText(),
+          sourceFile,
+          undefined,
+          importDec.moduleSpecifier.getText()
+        ),
+      ];
+    }
+
+    return [];
+  }
+
+  async transform(node: ImportDeclaration, context: SchemaExtractorContext) {
+    const location = context.getLocation(node);
+
+    return new UnImplementedSchema(location, node.getText(), node.kind.toString());
+  }
+}

package/transformers/index-signature.ts

@@ -0,0 +1,27 @@
+import type { Node, IndexSignatureDeclaration } from 'typescript';
+import ts from 'typescript';
+import type { ParameterSchema } from '@teambit/semantics.entities.semantic-schema';
+import { IndexSignatureSchema, UnresolvedSchema } from '@teambit/semantics.entities.semantic-schema';
+import type { SchemaTransformer } from '../schema-transformer';
+import type { SchemaExtractorContext } from '../schema-extractor-context';
+import type { Identifier } from '../identifier';
+
+export class IndexSignatureTransformer implements SchemaTransformer {
+  predicate(node: Node) {
+    return node.kind === ts.SyntaxKind.IndexSignature;
+  }
+
+  async getIdentifiers(): Promise<Identifier[]> {
+    return [];
+  }
+
+  async transform(node: IndexSignatureDeclaration, context: SchemaExtractorContext) {
+    const param = node.parameters[0];
+    if (!param) {
+      return new UnresolvedSchema(context.getLocation(node), `IndexSignatureTransformer: no parameter found`);
+    }
+    const keyType = (await context.computeSchema(param)) as ParameterSchema;
+    const valueType = await context.computeSchema(node.type);
+    return new IndexSignatureSchema(context.getLocation(node), keyType, valueType);
+  }
+}

package/transformers/index.ts

@@ -0,0 +1,43 @@
+export { ExportDeclarationTransformer } from './export-declaration';
+export { FunctionLikeTransformer } from './function-like';
+export { ParameterTransformer } from './parameter';
+export { VariableStatementTransformer } from './variable-statement';
+export { VariableDeclaration } from './variable-declaration';
+export { SourceFileTransformer } from './source-file-transformer';
+export { TypeAliasTransformer } from './type-alias';
+export { IntersectionTypeTransformer } from './intersection-type';
+export { UnionTypeTransformer } from './union-type';
+export { TypeReferenceTransformer } from './type-reference';
+export { TypeLiteralTransformer } from './type-literal';
+export { LiteralTypeTransformer } from './literal-type';
+export { TypeQueryTransformer } from './type-query';
+export { TypeOperatorTransformer } from './type-operator';
+export { KeywordTypeTransformer } from './keyword-type';
+export { TupleTypeTransformer } from './tuple-type';
+export { ParenthesizedTypeTransformer } from './parenthesized-type';
+export { TypePredicateTransformer } from './type-predicate';
+export { IndexedAccessTypeTransformer } from './indexed-access-type';
+export { TemplateLiteralTypeSpanTransformer } from './template-literal-type-span';
+export { TemplateLiteralTypeTransformer } from './template-literal-type';
+export { ThisTypeTransformer } from './this-type';
+export { ConditionalTypeTransformer } from './conditional-type';
+export { NamedTupleTransformer } from './named-tuple';
+export { ArrayTypeTransformer } from './array-type';
+export { ClassDeclarationTransformer } from './class-declaration';
+export { ConstructorTransformer } from './constructor';
+export { PropertyDeclarationTransformer } from './property-declaration';
+export { SetAccessorTransformer } from './set-accessor';
+export { GetAccessorTransformer } from './get-accessor';
+export { IndexSignatureTransformer } from './index-signature';
+export { InterfaceDeclarationTransformer } from './interface-declaration';
+export { EnumDeclarationTransformer } from './enum-declaration';
+export { BindingElementTransformer } from './binding-element';
+export { ExportAssignmentTransformer } from './export-assignment';
+export { ImportDeclarationTransformer } from './import-declaration';
+export { ExpressionStatementTransformer } from './expression-statement';
+export { ModuleDeclarationTransformer } from './module-declaration';
+export { DecoratorTransformer } from './decorator';
+export { ArrayLiteralExpressionTransformer } from './array-literal-expression';
+export { ObjectLiteralExpressionTransformer } from './object-literal-expression';
+export { PropertyAssignmentTransformer } from './property-assignment';
+export { LiteralValueTransformer } from './literal-value';

package/transformers/indexed-access-type.ts

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