@teambit/typescript 0.0.965 → 0.0.967

package/transformers/function-like.ts

@@ -0,0 +1,65 @@
+import { FunctionLikeSchema, ParameterSchema, SchemaNode, Modifier } from '@teambit/semantics.entities.semantic-schema';
+import ts, { Node, SignatureDeclaration } from 'typescript';
+import pMapSeries from 'p-map-series';
+import { SchemaExtractorContext } from '../schema-extractor-context';
+import { 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.IndexSignature ||
+      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 getQuickInfoFromDefaultModifier = async () => {
+      const defaultModifier = node.modifiers?.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, 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 context.jsDocToDocSchema(node);
+
+    return new FunctionLikeSchema(
+      location,
+      name,
+      args,
+      returnType,
+      displaySig,
+      modifiers as Modifier[],
+      doc,
+      typeParameters
+    );
+  }
+}

package/transformers/get-accessor.ts

@@ -0,0 +1,24 @@
+import ts, { Node, GetAccessorDeclaration } from 'typescript';
+import { GetAccessorSchema } 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 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,56 @@
+import { ImportDeclaration, Node, SyntaxKind } 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 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,24 @@
+import ts, { Node, IndexSignatureDeclaration } from 'typescript';
+import { IndexSignatureSchema, ParameterSchema } 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 IndexSignatureTransformer implements SchemaTransformer {
+  predicate(node: Node) {
+    return node.kind === ts.SyntaxKind.IndexSignature;
+  }
+
+  async getIdentifiers(): Promise<Identifier[]> {
+    return [];
+  }
+
+  async transform(node: IndexSignatureDeclaration, context: SchemaExtractorContext) {
+    const params = (await pMapSeries(node.parameters, async (param) =>
+      context.computeSchema(param)
+    )) as ParameterSchema[];
+    const type = await context.computeSchema(node.type);
+    return new IndexSignatureSchema(context.getLocation(node), params, type);
+  }
+}

package/transformers/index.ts

@@ -1,11 +1,36 @@
-export { ExportDeclaration } from './export-declaration';
-export { FunctionDeclaration } from './function-declaration';
+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 { ExportAssignmentDeclaration } from './export-assignment-declaration';
+export { ExportAssignmentTransformer } from './export-assignment';
+export { ImportDeclarationTransformer } from './import-declaration';

package/transformers/indexed-access-type.ts

@@ -0,0 +1,21 @@
+import { IndexedAccessTypeNode, Node, SyntaxKind } from 'typescript';
+import { IndexedAccessSchema } from '@teambit/semantics.entities.semantic-schema';
+import { SchemaTransformer } from '../schema-transformer';
+import { SchemaExtractorContext } from '../schema-extractor-context';
+import { 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);
+  }
+}

package/transformers/interface-declaration.ts

@@ -7,17 +7,15 @@ import {
 } 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 { typeNodeToSchema } from './utils/type-node-to-schema';
+import { Identifier } from '../identifier';
 
 export class InterfaceDeclarationTransformer implements SchemaTransformer {
   predicate(node: Node) {
     return node.kind === SyntaxKind.InterfaceDeclaration;
   }
 
-  async getIdentifiers(node: InterfaceDeclaration): Promise<ExportIdentifier[]> {
-    return [new ExportIdentifier(node.name.getText(), node.getSourceFile().fileName)];
+  async getIdentifiers(node: InterfaceDeclaration): Promise<Identifier[]> {
+    return [new Identifier(node.name.getText(), node.getSourceFile().fileName)];
   }
 
   private async getExpressionWithTypeArgs(node: InterfaceDeclaration, context: SchemaExtractorContext) {
@@ -33,7 +31,7 @@ export class InterfaceDeclarationTransformer implements SchemaTransformer {
         }),
       async (expressionWithTypeArgs: ts.ExpressionWithTypeArguments & { name: string }) => {
         const { typeArguments, expression, name } = expressionWithTypeArgs;
-        const typeArgsNodes = typeArguments ? await pMapSeries(typeArguments, (t) => typeNodeToSchema(t, context)) : [];
+        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());
@@ -43,7 +41,7 @@ export class InterfaceDeclarationTransformer implements SchemaTransformer {
   }
 
   async transform(interfaceDec: InterfaceDeclaration, context: SchemaExtractorContext) {
-    const members = await pMapSeries(interfaceDec.members, (member) => typeElementToSchema(member, context));
+    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);

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/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/parameter.ts

@@ -0,0 +1,110 @@
+import ts, {
+  BindingElement,
+  isIdentifier,
+  Node,
+  ParameterDeclaration,
+  SyntaxKind,
+  ArrayBindingElement,
+} 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) {
+    return new ParameterSchema(
+      context.getLocation(node),
+      this.getName(node),
+      await this.getType(node, context),
+      Boolean(node.questionToken),
+      node.initializer ? node.initializer.getText() : undefined,
+      undefined,
+      await this.getObjectBindingNodes(node, context)
+    );
+  }
+
+  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`);
+  }
+
+  async getObjectBindingNodes(
+    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 =
+        elem.name.kind === SyntaxKind.ObjectBindingPattern ? undefined : await context.getQuickInfo(elem.name);
+      // @todo look into extracting nested objected binding patters
+      /**
+         * apiNode: {
+            api: {
+              name,
+              signature: defaultSignature,
+              doc, 
+              location: { filePath },
+            },
+          },
+         */
+      const parsed = info ? parseTypeFromQuickInfo(info) : elem.getText();
+      return new InferenceTypeSchema(context.getLocation(param), parsed, elem.name.getText());
+    });
+  }
+}

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-declaration.ts

@@ -0,0 +1,33 @@
+import { Node, PropertyDeclaration, PropertySignature, SyntaxKind } 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);
+    const doc = await context.jsDocToDocSchema(node);
+    return new VariableLikeSchema(context.getLocation(node), name, displaySig, type, isOptional, doc);
+  }
+}

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);
+  }
+}