@teambit/typescript 0.0.0-004aea01bc027e428dfd0f6583f49a1b8286bdd0

package/sourceFileTransformers/function.ts

@@ -0,0 +1,170 @@
+import ts from 'typescript';
+import type { SourceFileTransformer } from './index';
+import { replaceName } from './replaceName';
+
+export const functionNamesTransformer: SourceFileTransformer = (mapping: Record<string, string>) => {
+  return (context) => {
+    const updateTypeReference: ts.Visitor = (node) => {
+      try {
+        if (ts.isTypeReferenceNode(node) && node.typeName) {
+          const typeName = node.typeName.getText(node.getSourceFile());
+          const newTypeName = replaceName(typeName, mapping);
+          if (newTypeName) {
+            return ts.factory.updateTypeReferenceNode(
+              node,
+              ts.factory.createIdentifier(newTypeName),
+              node.typeArguments
+            );
+          }
+        }
+        return ts.visitEachChild(node, updateTypeReference, context);
+      } catch {
+        return node;
+      }
+    };
+
+    const visit: ts.Visitor = (node) => {
+      if (ts.isFunctionDeclaration(node) || ts.isArrowFunction(node) || ts.isFunctionExpression(node)) {
+        const functionName = node.name?.getText() ?? '';
+        const newName = Object.entries(mapping).find(([key]) => functionName.includes(key))?.[1] ?? functionName;
+        const parameters = node.parameters.map((param) => {
+          const newParamType = param.type ? (ts.visitNode(param.type, updateTypeReference) as ts.TypeNode) : param.type;
+          if (ts.isIdentifier(param.name)) {
+            const oldName = param.name.getText();
+            const newParamName = Object.keys(mapping).find((key) => oldName.includes(key));
+            if (newParamName) {
+              return ts.factory.updateParameterDeclaration(
+                param,
+                param.modifiers,
+                param.dotDotDotToken,
+                ts.factory.createIdentifier(newParamName),
+                param.questionToken,
+                newParamType,
+                param.initializer
+              );
+            }
+          } else if (ts.isObjectBindingPattern(param.name)) {
+            const elements = param.name.elements.map((element) => {
+              const newElementName = mapping[element.name.getText()];
+              if (newElementName) {
+                return ts.factory.updateBindingElement(
+                  element,
+                  element.dotDotDotToken,
+                  element.propertyName,
+                  ts.factory.createIdentifier(newElementName),
+                  element.initializer
+                );
+              }
+              return element;
+            });
+            const newParamName = ts.factory.createObjectBindingPattern(elements);
+            return ts.factory.updateParameterDeclaration(
+              param,
+              param.modifiers,
+              param.dotDotDotToken,
+              newParamName,
+              param.questionToken,
+              newParamType,
+              param.initializer
+            );
+          }
+          return param;
+        });
+
+        if (ts.isFunctionDeclaration(node)) {
+          const updatedBody = node.body && ts.isBlock(node.body) ? updateReturnStatement(node.body) : node.body;
+          return ts.factory.updateFunctionDeclaration(
+            node,
+            node.modifiers,
+            node.asteriskToken,
+            newName ? ts.factory.createIdentifier(newName) : node.name,
+            node.typeParameters,
+            parameters,
+            node.type,
+            updatedBody
+          );
+        }
+        if (ts.isArrowFunction(node)) {
+          const updatedBody = node.body && ts.isBlock(node.body) ? updateReturnStatement(node.body) : node.body;
+          return ts.factory.updateArrowFunction(
+            node,
+            node.modifiers,
+            node.typeParameters,
+            parameters,
+            node.type,
+            node.equalsGreaterThanToken,
+            updatedBody
+          );
+        }
+        if (ts.isFunctionExpression(node)) {
+          const updatedBody = node.body && ts.isBlock(node.body) ? updateReturnStatement(node.body) : node.body;
+          return ts.factory.updateFunctionExpression(
+            node,
+            node.modifiers,
+            node.asteriskToken,
+            newName ? ts.factory.createIdentifier(newName) : node.name,
+            node.typeParameters,
+            parameters,
+            node.type,
+            updatedBody
+          );
+        }
+      }
+      return ts.visitEachChild(node, visit, context);
+    };
+
+    function updateReturnStatement(body: ts.ConciseBody): ts.Block {
+      if (ts.isBlock(body)) {
+        const updatedStatements: ts.Statement[] = [];
+        for (const statement of body.statements) {
+          if (ts.isReturnStatement(statement) && statement.expression && ts.isJsxElement(statement.expression)) {
+            const jsxElement = statement.expression;
+            const openingElement = jsxElement.openingElement;
+            const tagName = openingElement.tagName.getText();
+            const newTagName = mapping[tagName];
+            if (newTagName) {
+              const updatedTagName = ts.factory.createIdentifier(newTagName);
+              const updatedOpeningElement = ts.factory.updateJsxOpeningElement(
+                openingElement,
+                updatedTagName,
+                openingElement.typeArguments,
+                openingElement.attributes
+              );
+              const updatedClosingElement = jsxElement.closingElement
+                ? ts.factory.updateJsxClosingElement(jsxElement.closingElement, updatedTagName)
+                : ts.factory.createJsxClosingElement(updatedTagName);
+              const updatedJsxElement = ts.factory.createJsxElement(
+                updatedOpeningElement,
+                jsxElement.children,
+                updatedClosingElement
+              );
+              const updatedStatement = ts.factory.createReturnStatement(updatedJsxElement);
+              updatedStatements.push(updatedStatement);
+            } else {
+              updatedStatements.push(statement);
+            }
+          } else {
+            updatedStatements.push(statement);
+          }
+        }
+        return ts.factory.updateBlock(body, updatedStatements);
+      }
+      if (
+        ts.isExpressionStatement(body) &&
+        ts.isReturnStatement(body.expression) &&
+        body.expression.expression &&
+        ts.isIdentifier(body.expression.expression)
+      ) {
+        const oldName = body.expression.expression.text;
+        const newName = mapping[oldName];
+        if (newName) {
+          const updatedExpression = ts.factory.createIdentifier(newName);
+          const updatedReturnStatement = ts.factory.createReturnStatement(updatedExpression);
+          return ts.factory.createBlock([updatedReturnStatement], true);
+        }
+      }
+      return ts.factory.createBlock([], true);
+    }
+    return (node) => ts.visitNode(node, visit) as ts.SourceFile;
+  };
+};

package/sourceFileTransformers/import.ts

@@ -0,0 +1,101 @@
+import ts from 'typescript';
+import type { SourceFileTransformer } from './index';
+
+export const importTransformer: SourceFileTransformer = (mapping: Record<string, string>) => {
+  return (context) => {
+    const visit: ts.Visitor = (node) => {
+      if (ts.isImportDeclaration(node)) {
+        let moduleSpecifier = node.moduleSpecifier.getText().slice(1, -1);
+        for (const [oldName, newName] of Object.entries(mapping)) {
+          if (moduleSpecifier.includes(oldName)) {
+            moduleSpecifier = moduleSpecifier.replace(oldName, newName);
+          }
+        }
+
+        if (node.importClause?.namedBindings && ts.isNamedImports(node.importClause.namedBindings)) {
+          const transformedBindings = node.importClause.namedBindings.elements.map((element) => {
+            let originalName = element.propertyName ? element.propertyName.text : element.name.text;
+            const aliasName = element.name.text;
+
+            for (const [oldName, newName] of Object.entries(mapping)) {
+              if (originalName.startsWith(oldName) || originalName.endsWith(oldName)) {
+                originalName = originalName.replace(oldName, newName);
+              }
+            }
+
+            return ts.factory.updateImportSpecifier(
+              element,
+              false,
+              element.propertyName ? ts.factory.createIdentifier(originalName) : undefined,
+              ts.factory.createIdentifier(aliasName)
+            );
+          });
+
+          const updatedImportClause = ts.factory.updateImportClause(
+            node.importClause,
+            node.importClause.isTypeOnly,
+            node.importClause.name,
+            ts.factory.createNamedImports(transformedBindings)
+          );
+
+          return ts.factory.updateImportDeclaration(
+            node,
+            node.modifiers,
+            updatedImportClause,
+            ts.factory.createStringLiteral(moduleSpecifier),
+            undefined
+          );
+        }
+
+        return ts.factory.updateImportDeclaration(
+          node,
+          node.modifiers,
+          node.importClause,
+          ts.factory.createStringLiteral(moduleSpecifier),
+          undefined
+        );
+      }
+      if (ts.isImportEqualsDeclaration(node)) {
+        let moduleSpecifier = node.moduleReference.getText().slice(1, -1);
+        for (const [oldName, newName] of Object.entries(mapping)) {
+          if (moduleSpecifier.includes(oldName)) {
+            moduleSpecifier = moduleSpecifier.replace(oldName, newName);
+          }
+        }
+
+        const updatedImportEqualsDeclaration = ts.factory.updateImportEqualsDeclaration(
+          node,
+          node.modifiers,
+          node.isTypeOnly,
+          node.name,
+          ts.factory.createExternalModuleReference(ts.factory.createStringLiteral(moduleSpecifier))
+        );
+
+        return updatedImportEqualsDeclaration;
+      }
+
+      if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && node.expression.text === 'require') {
+        const [firstArg] = node.arguments;
+
+        if (ts.isStringLiteral(firstArg)) {
+          let moduleSpecifier = firstArg.text;
+
+          for (const [oldName, newName] of Object.entries(mapping)) {
+            if (moduleSpecifier.includes(oldName)) {
+              moduleSpecifier = moduleSpecifier.replace(oldName, newName);
+            }
+          }
+
+          const updatedArg = ts.factory.createStringLiteral(moduleSpecifier);
+          return ts.factory.updateCallExpression(node, node.expression, node.typeArguments, [
+            updatedArg,
+            ...node.arguments.slice(1),
+          ]);
+        }
+      }
+
+      return ts.visitEachChild(node, visit, context);
+    };
+    return (node) => ts.visitNode(node, visit) as ts.SourceFile;
+  };
+};

package/sourceFileTransformers/index.ts

@@ -0,0 +1,14 @@
+import type ts from 'typescript';
+
+export type SourceFileTransformer = (mapping: Record<string, string>) => ts.TransformerFactory<ts.SourceFile>;
+
+export { classNamesTransformer } from './class';
+export { interfaceNamesTransformer } from './interface';
+export { variableNamesTransformer } from './variable';
+export { functionNamesTransformer } from './function';
+export { typeAliasNamesTransformer } from './typeAlias';
+export { importTransformer } from './import';
+export { expressionStatementTransformer } from './expression-statement';
+export { exportTransformer } from './export';
+export { transformSourceFile } from './transform';
+export { typeReferenceTransformer } from './type-reference';

package/sourceFileTransformers/interface.ts

@@ -0,0 +1,41 @@
+import ts from 'typescript';
+import { replaceName } from './replaceName';
+
+export function interfaceNamesTransformer(nameMapping: Record<string, string>): ts.TransformerFactory<ts.SourceFile> {
+  return (context) => {
+    const { factory } = context;
+    const visit: ts.Visitor = (node) => {
+      if (ts.isInterfaceDeclaration(node)) {
+        const oldName = node.name.text;
+        const newName = replaceName(oldName, nameMapping);
+        if (newName) {
+          const newMembers = node.members.map((member) => {
+            if (ts.isPropertySignature(member) && ts.isIdentifier(member.name)) {
+              const memberName = member.name.text;
+              if (nameMapping[memberName]) {
+                return factory.updatePropertySignature(
+                  member,
+                  member.modifiers,
+                  factory.createIdentifier(nameMapping[memberName]),
+                  member.questionToken,
+                  member.type
+                );
+              }
+            }
+            return member;
+          });
+          return factory.updateInterfaceDeclaration(
+            node,
+            node.modifiers,
+            factory.createIdentifier(newName),
+            node.typeParameters,
+            node.heritageClauses,
+            newMembers
+          );
+        }
+      }
+      return ts.visitEachChild(node, (child) => visit(child), context);
+    };
+    return (node) => ts.visitNode(node, visit) as ts.SourceFile;
+  };
+}

package/sourceFileTransformers/replaceName.ts

@@ -0,0 +1,11 @@
+export function replaceName(oldName: string, nameMapping: Record<string, string>): string | undefined {
+  for (const old of Object.keys(nameMapping)) {
+    if (oldName.startsWith(old) || oldName === old) {
+      return oldName.replace(new RegExp(`^${old}`), nameMapping[old]);
+    }
+    if (oldName.endsWith(old)) {
+      return oldName.replace(new RegExp(`${old}$`), nameMapping[old]);
+    }
+  }
+  return undefined;
+}

package/sourceFileTransformers/transform.ts

@@ -0,0 +1,70 @@
+import type { Formatter } from '@teambit/formatter';
+import ts from 'typescript';
+import * as path from 'path';
+import { EmptyLineEncoder } from './empty-line-encoder';
+/**
+ * Transforms a TypeScript source file using the provided transformer.
+ *
+ * @param sourceFilePath Path to the TypeScript source file.
+ * @param sourceFileContent The content of the source file.
+ * @param transformers The transformers to be applied on the source file.
+ * @param formatter (Optional) An optional formatter to format the transformed code. If no formatter is provided, the function returns the transformed source file as a string without any formatting.
+ * @returns A promise that resolves to the transformed source file as a string.
+ */
+export async function transformSourceFile(
+  sourceFilePath: string,
+  sourceFileContent: string,
+  transformers: ts.TransformerFactory<ts.SourceFile>[],
+  formatter?: Formatter,
+  updates?: Record<string, string>
+): Promise<string> {
+  const ext = path.extname(sourceFilePath);
+  const compatibleExts = ['.ts', '.tsx', '.js', '.jsx'];
+  if (!compatibleExts.includes(ext)) {
+    if (!updates) return sourceFileContent;
+    let transformed = sourceFileContent;
+    Object.entries(updates).forEach(([oldStr, newStr]) => {
+      const oldStringRegex = new RegExp(oldStr, 'g');
+      transformed = transformed.replace(oldStringRegex, newStr);
+    });
+    return transformed;
+  }
+
+  const encoder = new EmptyLineEncoder();
+  sourceFileContent = encoder.encode(sourceFileContent);
+
+  const sourceFile = ts.createSourceFile(
+    sourceFilePath,
+    sourceFileContent,
+    ts.ScriptTarget.Latest,
+    true,
+    ts.ScriptKind.TSX
+  );
+
+  const transformedResult: ts.TransformationResult<ts.SourceFile> = ts.transform<ts.SourceFile>(
+    sourceFile,
+    transformers
+  );
+  const transformedSourceFile: ts.SourceFile = transformedResult.transformed[0] as ts.SourceFile;
+
+  const printer: ts.Printer = ts.createPrinter({
+    removeComments: false,
+  });
+
+  let transformedSourceFileStr = printer.printFile(transformedSourceFile);
+  transformedSourceFileStr = encoder.decode(transformedSourceFileStr);
+  // Remove trailing empty line markers
+  const emptyLineComment = `\\s*\\/\\*${encoder.emptyLineMarker}\\*\\/\\s*$`;
+  const regex = new RegExp(emptyLineComment, 'g');
+  transformedSourceFileStr = transformedSourceFileStr.replace(regex, '');
+
+  try {
+    const formattedSourceFileStr = await formatter?.formatSnippet(transformedSourceFileStr, sourceFilePath);
+    return formattedSourceFileStr || transformedSourceFileStr;
+  } catch {
+    // We can ignore if the formatter fails
+    // TODO: log the error
+    // ignore
+  }
+  return transformedSourceFileStr;
+}

package/sourceFileTransformers/type-reference.ts

@@ -0,0 +1,19 @@
+import ts from 'typescript';
+import { replaceName } from './replaceName';
+
+export function typeReferenceTransformer(mapping: Record<string, string>): ts.TransformerFactory<ts.SourceFile> {
+  return (context) => {
+    const visit: ts.Visitor = (node) => {
+      if (ts.isTypeReferenceNode(node)) {
+        const oldName = node.typeName.getText();
+        const newName = replaceName(oldName, mapping);
+        if (newName) {
+          return ts.factory.updateTypeReferenceNode(node, ts.factory.createIdentifier(newName), node.typeArguments);
+        }
+      }
+      return ts.visitEachChild(node, visit, context);
+    };
+
+    return (node) => ts.visitNode(node, visit) as ts.SourceFile;
+  };
+}

package/sourceFileTransformers/typeAlias.ts

@@ -0,0 +1,25 @@
+import ts from 'typescript';
+import { replaceName } from './replaceName';
+
+export function typeAliasNamesTransformer(nameMapping: Record<string, string>): ts.TransformerFactory<ts.SourceFile> {
+  return (context) => {
+    const { factory } = context;
+    const visit: ts.Visitor = (node) => {
+      if (ts.isTypeAliasDeclaration(node)) {
+        const oldName = node.name.text;
+        const newName = replaceName(oldName, nameMapping);
+        if (newName) {
+          return factory.updateTypeAliasDeclaration(
+            node,
+            node.modifiers,
+            factory.createIdentifier(newName),
+            node.typeParameters,
+            node.type
+          );
+        }
+      }
+      return ts.visitEachChild(node, (child) => visit(child), context);
+    };
+    return (node) => ts.visitNode(node, visit) as ts.SourceFile;
+  };
+}

package/sourceFileTransformers/variable.ts

@@ -0,0 +1,25 @@
+import ts from 'typescript';
+import { replaceName } from './replaceName';
+
+export function variableNamesTransformer(nameMapping: Record<string, string>): ts.TransformerFactory<ts.SourceFile> {
+  return (context) => {
+    const { factory } = context;
+    const visit: ts.Visitor = (node) => {
+      if (ts.isVariableDeclaration(node) && node.name.kind === ts.SyntaxKind.Identifier) {
+        const oldName = node.name.text;
+        const newName = replaceName(oldName, nameMapping);
+        if (newName) {
+          return factory.updateVariableDeclaration(
+            node,
+            factory.createIdentifier(newName),
+            node.exclamationToken,
+            node.type,
+            node.initializer
+          );
+        }
+      }
+      return ts.visitEachChild(node, (child) => visit(child), context);
+    };
+    return (node) => ts.visitNode(node, visit) as ts.SourceFile;
+  };
+}

package/transformers/array-literal-expression.ts

@@ -0,0 +1,31 @@
+import type { SchemaNode } from '@teambit/semantics.entities.semantic-schema';
+import { ArrayLiteralExpressionSchema, UnImplementedSchema } from '@teambit/semantics.entities.semantic-schema';
+import pMapSeries from 'p-map-series';
+import type { ArrayLiteralExpression, Node } from 'typescript';
+import ts from 'typescript';
+import type { SchemaExtractorContext } from '../schema-extractor-context';
+import type { SchemaTransformer } from '../schema-transformer';
+import type { Identifier } from '../identifier';
+
+export class ArrayLiteralExpressionTransformer implements SchemaTransformer {
+  predicate(node: Node): boolean {
+    return node.kind === ts.SyntaxKind.ArrayLiteralExpression;
+  }
+
+  async getIdentifiers(): Promise<Identifier[]> {
+    return [];
+  }
+
+  async transform(node: ArrayLiteralExpression, context: SchemaExtractorContext): Promise<SchemaNode> {
+    const members = await pMapSeries(node.elements, async (element) => {
+      const schema = await context.computeSchema(element);
+      if (schema instanceof UnImplementedSchema) {
+        const typeRef = await context.resolveType(element, element.getText());
+        return typeRef;
+      }
+      return schema;
+    });
+    const location = context.getLocation(node);
+    return new ArrayLiteralExpressionSchema(members, location);
+  }
+}

package/transformers/array-type.ts

@@ -0,0 +1,22 @@
+import type { ArrayTypeNode, Node } from 'typescript';
+import ts from 'typescript';
+import { TypeArraySchema } 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 ArrayTypeTransformer implements SchemaTransformer {
+  predicate(node: Node) {
+    return node.kind === ts.SyntaxKind.ArrayType;
+  }
+
+  async getIdentifiers(): Promise<Identifier[]> {
+    return [];
+  }
+
+  async transform(node: ArrayTypeNode, context: SchemaExtractorContext) {
+    const type = await context.computeSchema(node.elementType);
+    const location = context.getLocation(node);
+    return new TypeArraySchema(location, type);
+  }
+}

package/transformers/binding-element.ts

@@ -0,0 +1,35 @@
+import type { BindingElement, Node } from 'typescript';
+import ts from 'typescript';
+import { VariableLikeSchema } 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 { Identifier } from '../identifier';
+
+/**
+ * for example:
+ *
+ * const objBindingElem = { elem1: 1, elem2: 2 };
+ * const { elem1 } = objBindingElem;
+ * export { elem1 };
+ */
+export class BindingElementTransformer implements SchemaTransformer {
+  predicate(node: Node) {
+    return node.kind === ts.SyntaxKind.BindingElement;
+  }
+
+  async getIdentifiers(node: BindingElement) {
+    return [new Identifier(node.name.getText(), node.getSourceFile().fileName)];
+  }
+
+  async transform(node: BindingElement, context: SchemaExtractorContext) {
+    const name = node.name.getText();
+    const info = await context.getQuickInfo(node.name);
+    const displaySig = info?.body?.displayString || '';
+    const typeStr = parseTypeFromQuickInfo(info);
+    const type = await context.resolveType(node, typeStr);
+    const doc = await context.jsDocToDocSchema(node);
+    const defaultValue = node.initializer ? node.initializer.getText() : undefined;
+    return new VariableLikeSchema(context.getLocation(node), name, displaySig, type, false, doc, defaultValue);
+  }
+}

package/transformers/class-declaration.ts

@@ -0,0 +1,109 @@
+import pMapSeries from 'p-map-series';
+import { compact } from 'lodash';
+import {
+  ClassSchema,
+  UnresolvedSchema,
+  ExpressionWithTypeArgumentsSchema,
+} from '@teambit/semantics.entities.semantic-schema';
+import type { Node, ClassDeclaration } from 'typescript';
+import ts from 'typescript';
+import type { SchemaTransformer } from '../schema-transformer';
+import type { SchemaExtractorContext } from '../schema-extractor-context';
+import { Identifier } from '../identifier';
+
+export class ClassDeclarationTransformer implements SchemaTransformer {
+  predicate(node: Node) {
+    if (node.kind !== ts.SyntaxKind.ClassDeclaration) {
+      return false;
+    }
+    const classNode = node as ClassDeclaration;
+    if (!classNode.members || (classNode.members as any).isMissingList) {
+      return false;
+    }
+    return true;
+  }
+
+  // @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 Identifier(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) => 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(node: ClassDeclaration, context: SchemaExtractorContext) {
+    const nodeDecorators = ts.canHaveDecorators(node) ? ts.getDecorators(node) : undefined;
+    const decorators = nodeDecorators?.length
+      ? await pMapSeries(nodeDecorators, (decorator) => context.computeSchema(decorator))
+      : undefined;
+    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 memberModifiers = ts.canHaveModifiers(member) ? ts.getModifiers(member) : undefined;
+      const isPrivate = memberModifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.PrivateKeyword);
+      if (isPrivate) {
+        return null;
+      }
+      return context.computeSchema(member);
+    });
+    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,
+      decorators
+    );
+  }
+}