@teambit/typescript 0.0.728 → 0.0.731

package/transformers/type-alias.ts

@@ -1,6 +1,9 @@
 import ts, { Node, TypeAliasDeclaration } from 'typescript';
+import { TypeSchema } from '@teambit/semantics.entities.semantic-schema';
 import { SchemaTransformer } from '../schema-transformer';
+import { SchemaExtractorContext } from '../schema-extractor-context';
 import { ExportIdentifier } from '../export-identifier';
+import { typeNodeToSchema } from './utils/type-node-to-schema';
 
 export class TypeAliasTransformer implements SchemaTransformer {
   predicate(node: Node) {
@@ -11,7 +14,14 @@ export class TypeAliasTransformer implements SchemaTransformer {
     return [new ExportIdentifier(node.name.getText(), node.getSourceFile().fileName)];
   }
 
-  async transform() {
-    return {};
+  private getName(node: TypeAliasDeclaration): string {
+    return node.name.getText();
+  }
+
+  async transform(typeAlias: TypeAliasDeclaration, context: SchemaExtractorContext) {
+    const type = await typeNodeToSchema(typeAlias.type, context);
+    const info = await context.getQuickInfo(typeAlias.name);
+    const displaySig = info?.body?.displayString;
+    return new TypeSchema(this.getName(typeAlias), type, displaySig as string);
   }
 }

package/transformers/utils/get-params.ts

@@ -0,0 +1,29 @@
+import { ParameterSchema, SchemaNode, TypeRefSchema } from '@teambit/semantics.entities.semantic-schema';
+import pMapSeries from 'p-map-series';
+import { ParameterDeclaration, NodeArray } from 'typescript';
+import { SchemaExtractorContext } from '../../schema-extractor-context';
+import { parseTypeFromQuickInfo } from './parse-type-from-quick-info';
+import { typeNodeToSchema } from './type-node-to-schema';
+
+export async function getParams(
+  parameterNodes: NodeArray<ParameterDeclaration>,
+  context: SchemaExtractorContext
+): Promise<ParameterSchema[]> {
+  return pMapSeries(parameterNodes, async (param) => {
+    return new ParameterSchema(
+      param.name.getText(),
+      await getParamType(param, context),
+      param.initializer ? param.initializer.getText() : undefined
+    );
+  });
+}
+
+async function getParamType(param: ParameterDeclaration, context: SchemaExtractorContext): Promise<SchemaNode> {
+  if (param.type) {
+    const type = param.type;
+    return typeNodeToSchema(type, context);
+  }
+  const info = await context.getQuickInfo(param.name);
+  const parsed = parseTypeFromQuickInfo(info);
+  return new TypeRefSchema(parsed || 'any');
+}

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

@@ -0,0 +1,84 @@
+// eslint-disable-next-line import/no-unresolved
+import protocol from 'typescript/lib/protocol';
+
+/**
+ * try to parse the type from the quickinfo.
+ * this is an error-prone process, we do our best here.
+ *
+ * an example of a function with many ":"
+ * `export function getObj(a: string, func: (b: number) => {}) { return { a: 1, b: 2 } };`
+ * which produce the following quickinfo:
+ * ```ts
+ * function getObj(a: string, func: (b: number) => {}): {
+ *   a: number;
+ *   b: number;
+ * }
+ * ```
+ *
+ * some examples of quickinfo:
+ *
+ * function ts.signatureToDisplayParts(typechecker: TypeChecker, signature: Signature, enclosingDeclaration?: Node | undefined, flags?: TypeFormatFlags): SymbolDisplayPart[]
+ *
+ * const enum ts.TypeFormatFlags
+ *
+ * (method) ts.TypeChecker.writeSignature(signature: Signature, enclosingDeclaration?: Node | undefined, flags?: TypeFormatFlags | undefined, kind?: SignatureKind | undefined, writer?: EmitTextWriter | undefined): string
+ *
+ * const obj: {
+ *   a: number;
+ *   b: number;
+ *  }
+ *
+ * function getObj(a: string): {
+ *     a: number;
+ *     b: number;
+ * }
+ */
+export function parseTypeFromQuickInfo(quickInfo: protocol.QuickInfoResponse | undefined): string {
+  if (!quickInfo?.body?.displayString) return '';
+  const displayString = quickInfo.body.displayString;
+  const splitByColon = displayString.split(':');
+  switch (quickInfo.body.kind) {
+    case 'const':
+    case 'property':
+    case 'let':
+    case 'var': {
+      const [, ...tail] = splitByColon;
+      return tail.join(':').trim();
+    }
+    case 'method':
+    case 'function': {
+      const split = displayString.split('): ');
+      if (split.length !== 2) {
+        throw new Error(`quickinfo of a function below was not implemented.\n${displayString}`);
+      }
+      return split[1].trim();
+    }
+    case 'alias': {
+      // e.g. (alias) class BuilderService\nimport BuilderService
+      // e.g. '(alias) type Serializable = {\n' +
+      // '    toString(): string;\n' +
+      // '}\n' +
+      // 'import Serializable'
+      const firstLine = displayString.split('\n')[0];
+      const splitBySpace = firstLine.trim().split(' ');
+      // first two are alias keyword and alias type
+      const [, , typeName] = splitBySpace;
+      return typeName;
+    }
+    case 'type': {
+      // e.g. `type TaskSlot = SlotRegistry<BuildTask[]>`
+      const splitByEqual = displayString.split('=');
+      const [, ...tail] = splitByEqual;
+      return tail.join('=').trim();
+    }
+    default:
+      return splitByColon[splitByColon.length - 1].trim();
+  }
+}
+
+export function parseReturnTypeFromQuickInfo(quickInfo: protocol.QuickInfoResponse | undefined): string {
+  if (!quickInfo) return '';
+  const typeStr = parseTypeFromQuickInfo(quickInfo);
+  const array = typeStr.split('=>');
+  return array[array.length - 1].trim();
+}

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

@@ -0,0 +1,205 @@
+import {
+  TypeNode,
+  SyntaxKind,
+  KeywordTypeNode,
+  FunctionTypeNode,
+  TypeQueryNode,
+  TypeReferenceNode,
+  ArrayTypeNode,
+  TypeOperatorNode,
+  TupleTypeNode,
+  IntersectionTypeNode,
+  UnionTypeNode,
+  TypeLiteralNode,
+} from 'typescript';
+import {
+  SchemaNode,
+  TypeIntersectionSchema,
+  TypeUnionSchema,
+  TypeLiteralSchema,
+  FunctionSchema,
+  TypeQuerySchema,
+  LiteralTypeSchema,
+  KeywordTypeSchema,
+  TypeArraySchema,
+  TypeOperatorSchema,
+  TupleTypeSchema,
+} from '@teambit/semantics.entities.semantic-schema';
+import pMapSeries from 'p-map-series';
+import { SchemaExtractorContext } from '../../schema-extractor-context';
+import { getParams } from './get-params';
+
+// eslint-disable-next-line complexity
+export async function typeNodeToSchema(node: TypeNode, context: SchemaExtractorContext): Promise<SchemaNode> {
+  if (isKeywordType(node)) {
+    return new KeywordTypeSchema(node.getText());
+  }
+  switch (node.kind) {
+    case SyntaxKind.IntersectionType:
+      return intersectionType(node as IntersectionTypeNode, context);
+    case SyntaxKind.UnionType:
+      return unionType(node as UnionTypeNode, context);
+    case SyntaxKind.TypeReference:
+      return typeReference(node as TypeReferenceNode, context);
+    case SyntaxKind.TypeLiteral:
+      return typeLiteral(node as TypeLiteralNode, context);
+    case SyntaxKind.LiteralType: // e.g. string/boolean
+      return new LiteralTypeSchema(node.getText());
+    case SyntaxKind.FunctionType:
+      return functionType(node as FunctionTypeNode, context);
+    case SyntaxKind.TypeQuery:
+      return typeQuery(node as TypeQueryNode, context);
+    case SyntaxKind.ArrayType:
+      return arrayType(node as ArrayTypeNode, context);
+    case SyntaxKind.TypeOperator:
+      return typeOperator(node as TypeOperatorNode, context);
+    case SyntaxKind.TupleType:
+      return tupleType(node as TupleTypeNode, context);
+    case SyntaxKind.TypePredicate:
+    case SyntaxKind.ConstructorType:
+    case SyntaxKind.NamedTupleMember:
+    case SyntaxKind.OptionalType:
+    case SyntaxKind.RestType:
+    case SyntaxKind.ConditionalType:
+    case SyntaxKind.InferType:
+    case SyntaxKind.ParenthesizedType:
+    case SyntaxKind.ThisType:
+    case SyntaxKind.IndexedAccessType:
+    case SyntaxKind.MappedType:
+    case SyntaxKind.TemplateLiteralType:
+    case SyntaxKind.TemplateLiteralTypeSpan:
+    case SyntaxKind.ImportType:
+    case SyntaxKind.ExpressionWithTypeArguments:
+    case SyntaxKind.JSDocTypeExpression:
+    case SyntaxKind.JSDocAllType:
+    case SyntaxKind.JSDocUnknownType:
+    case SyntaxKind.JSDocNonNullableType:
+    case SyntaxKind.JSDocNullableType:
+    case SyntaxKind.JSDocOptionalType:
+    case SyntaxKind.JSDocFunctionType:
+    case SyntaxKind.JSDocVariadicType:
+    case SyntaxKind.JSDocNamepathType:
+    case SyntaxKind.JSDocSignature:
+    case SyntaxKind.JSDocTypeLiteral:
+      throw new Error(`TypeNode "${SyntaxKind[node.kind]}" was not implemented yet.
+context: ${node.getText()}`);
+    default:
+      throw new Error(`Node "${SyntaxKind[node.kind]}" is not a TypeNode.
+context: ${node.getText()}`);
+  }
+}
+
+/**
+ * whether it's kind of `ts.KeywordTypeSyntaxKind`
+ */
+function isKeywordType(node: TypeNode): node is KeywordTypeNode {
+  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 function intersectionType(node: IntersectionTypeNode, context: SchemaExtractorContext) {
+  const types = await pMapSeries(node.types, async (type) => {
+    const typeSchema = await typeNodeToSchema(type, context);
+    return typeSchema;
+  });
+  return new TypeIntersectionSchema(types);
+}
+
+async function unionType(node: UnionTypeNode, context: SchemaExtractorContext) {
+  const types = await pMapSeries(node.types, async (type) => {
+    const typeSchema = await typeNodeToSchema(type, context);
+    return typeSchema;
+  });
+  return new TypeUnionSchema(types);
+}
+
+/**
+ * not to be confused with "LiteralType", which is string/boolean/null.
+ * this "TypeLiteral" is an object with properties, such as: `{ a: string; b: number }`, similar to Interface.
+ */
+async function typeLiteral(node: TypeLiteralNode, context: SchemaExtractorContext) {
+  const members = await pMapSeries(node.members, async (member) => {
+    const typeSchema = await context.computeSchema(member);
+    return typeSchema;
+  });
+  return new TypeLiteralSchema(members);
+}
+
+/**
+ * In the following example, `AriaButtonProps` is a type reference
+ * ```ts
+ * import type { AriaButtonProps } from '@react-types/button';
+ * export type ButtonProps = AriaButtonProps & { a: string };
+ * ```
+ */
+async function typeReference(node: TypeReferenceNode, context: SchemaExtractorContext) {
+  const name = node.typeName.getText();
+  const type = await context.resolveType(node, name, false);
+  return type;
+}
+
+async function functionType(node: FunctionTypeNode, context: SchemaExtractorContext): Promise<SchemaNode> {
+  const name = node.name?.getText() || '';
+  const params = await getParams(node.parameters, context);
+  const returnType = await typeNodeToSchema(node.type, context);
+  return new FunctionSchema(name, params, returnType, '');
+}
+
+/**
+ * e.g. `typeof Foo`
+ */
+async function typeQuery(node: TypeQueryNode, context: SchemaExtractorContext) {
+  const displaySig = await context.getQuickInfoDisplayString(node.exprName);
+  const type = await context.resolveType(node.exprName, node.exprName.getText(), false);
+  return new TypeQuerySchema(type, displaySig);
+}
+
+async function arrayType(node: ArrayTypeNode, context: SchemaExtractorContext) {
+  const type = await typeNodeToSchema(node.elementType, context);
+  return new TypeArraySchema(type);
+}
+
+/**
+ * e.g. keyof typeof Foo
+ */
+async function typeOperator(node: TypeOperatorNode, context: SchemaExtractorContext) {
+  const operatorName = getOperatorName(node.operator);
+  const type = await typeNodeToSchema(node.type, context);
+  return new TypeOperatorSchema(operatorName, type);
+}
+
+function getOperatorName(operator: SyntaxKind.KeyOfKeyword | SyntaxKind.UniqueKeyword | SyntaxKind.ReadonlyKeyword) {
+  switch (operator) {
+    case SyntaxKind.KeyOfKeyword:
+      return 'keyof';
+    case SyntaxKind.UniqueKeyword:
+      return 'unique';
+    case SyntaxKind.ReadonlyKeyword:
+      return 'readonly';
+    default:
+      throw new Error(`getOperatorName: unable to find operator name for ${operator}`);
+  }
+}
+
+async function tupleType(node: TupleTypeNode, context: SchemaExtractorContext) {
+  const elements = await pMapSeries(node.elements, async (elem) => {
+    const typeSchema = await typeNodeToSchema(elem, context);
+    return typeSchema;
+  });
+  return new TupleTypeSchema(elements);
+}

package/transformers/variable-declaration.ts

@@ -0,0 +1,36 @@
+import { SchemaNode, VariableSchema, FunctionSchema } from '@teambit/semantics.entities.semantic-schema';
+import ts, { Node, VariableDeclaration as VariableDeclarationNode, ArrowFunction } from 'typescript';
+import { SchemaTransformer } from '../schema-transformer';
+import { SchemaExtractorContext } from '../schema-extractor-context';
+import { ExportIdentifier } from '../export-identifier';
+import { getParams } from './utils/get-params';
+import { parseReturnTypeFromQuickInfo, parseTypeFromQuickInfo } from './utils/parse-type-from-quick-info';
+
+export class VariableDeclaration implements SchemaTransformer {
+  predicate(node: Node) {
+    return node.kind === ts.SyntaxKind.VariableDeclaration;
+  }
+
+  getName(node: VariableDeclarationNode) {
+    return node.name.getText();
+  }
+
+  async getIdentifiers(node: VariableDeclarationNode) {
+    return [new ExportIdentifier(node.name.getText(), node.getSourceFile().fileName)];
+  }
+
+  async transform(varDec: VariableDeclarationNode, context: SchemaExtractorContext): Promise<SchemaNode> {
+    const name = this.getName(varDec);
+    const info = await context.getQuickInfo(varDec.name);
+    const displaySig = info?.body?.displayString || '';
+    if (varDec.initializer?.kind === ts.SyntaxKind.ArrowFunction) {
+      const args = await getParams((varDec.initializer as ArrowFunction).parameters, context);
+      const typeStr = parseReturnTypeFromQuickInfo(info);
+      const returnType = await context.resolveType(varDec, typeStr);
+      return new FunctionSchema(name, args, returnType, displaySig);
+    }
+    const typeStr = parseTypeFromQuickInfo(info);
+    const type = await context.resolveType(varDec, typeStr);
+    return new VariableSchema(name, displaySig, type);
+  }
+}

package/transformers/variable-statement.ts

@@ -1,7 +1,15 @@
+import { SchemaNode, Module } from '@teambit/semantics.entities.semantic-schema';
+import { compact } from 'lodash';
+import pMapSeries from 'p-map-series';
 import ts, { Node, VariableStatement } from 'typescript';
 import { SchemaTransformer } from '../schema-transformer';
+import { SchemaExtractorContext } from '../schema-extractor-context';
 import { ExportIdentifier } from '../export-identifier';
 
+/**
+ * variable statement is a collection of variable declarations.
+ * e.g. `export const a = 1, b = () => {}, c = {};`
+ */
 export class VariableStatementTransformer implements SchemaTransformer {
   predicate(node: Node) {
     return node.kind === ts.SyntaxKind.VariableStatement;
@@ -13,7 +21,13 @@ export class VariableStatementTransformer implements SchemaTransformer {
     });
   }
 
-  async transform() {
-    return {};
+  async transform(node: VariableStatement, context: SchemaExtractorContext): Promise<SchemaNode> {
+    const schemas = await pMapSeries(node.declarationList.declarations, async (dec) => {
+      // this will get the schema from variable-declaration
+      const schema = await context.visitDefinition(dec.name);
+      return schema;
+    });
+    // @todo: find a better way to return an array of SchemaNode. this is not really a module
+    return new Module(compact(schemas));
   }
 }