@teambit/typescript 0.0.738 → 0.0.739

package/transformers/enum-declaration.ts

@@ -0,0 +1,20 @@
+import ts, { Node, EnumDeclaration } from 'typescript';
+import { EnumSchema } from '@teambit/semantics.entities.semantic-schema';
+import { SchemaTransformer } from '../schema-transformer';
+import { SchemaExtractorContext } from '../schema-extractor-context';
+import { ExportIdentifier } from '../export-identifier';
+
+export class EnumDeclarationTransformer implements SchemaTransformer {
+  predicate(node: Node) {
+    return node.kind === ts.SyntaxKind.EnumDeclaration;
+  }
+
+  async getIdentifiers(node: EnumDeclaration): Promise<ExportIdentifier[]> {
+    return [new ExportIdentifier(node.name.getText(), node.getSourceFile().fileName)];
+  }
+
+  async transform(enumDec: EnumDeclaration, context: SchemaExtractorContext) {
+    const members = enumDec.members.map((member) => member.name.getText());
+    return new EnumSchema(context.getLocation(enumDec), enumDec.name.getText(), members);
+  }
+}

package/transformers/index.ts

@@ -13,3 +13,4 @@ export { LiteralTypeTransformer } from './literal-type';
 export { IndexSignature } from './index-signature';
 export { InterfaceDeclarationTransformer } from './interface-declaration';
 export { MethodSignatureTransformer } from './method-signature';
+export { EnumDeclarationTransformer } from './enum-declaration';

package/transformers/utils/get-params.ts

@@ -1,6 +1,19 @@
-import { ParameterSchema, SchemaNode, TypeRefSchema } from '@teambit/semantics.entities.semantic-schema';
+import {
+  InferenceTypeSchema,
+  ParameterSchema,
+  TupleTypeSchema,
+  TypeLiteralSchema,
+  SchemaNode,
+} from '@teambit/semantics.entities.semantic-schema';
 import pMapSeries from 'p-map-series';
-import { ParameterDeclaration, NodeArray } from 'typescript';
+import {
+  SyntaxKind,
+  ParameterDeclaration,
+  NodeArray,
+  isIdentifier,
+  BindingElement,
+  ArrayBindingElement,
+} from 'typescript';
 import { SchemaExtractorContext } from '../../schema-extractor-context';
 import { parseTypeFromQuickInfo } from './parse-type-from-quick-info';
 import { typeNodeToSchema } from './type-node-to-schema';
@@ -12,22 +25,53 @@ export async function getParams(
   return pMapSeries(parameterNodes, async (param) => {
     return new ParameterSchema(
       context.getLocation(param),
-      param.name.getText(),
+      getParamName(param),
       await getParamType(param, context),
       param.initializer ? param.initializer.getText() : undefined
     );
   });
 }
 
-/**
- * @todo: probably not needed. just call context.resolveType instead.
- */
+function getParamName(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 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(context.getLocation(param), parsed || 'any');
+  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`);
 }

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

@@ -1,6 +1,8 @@
 // eslint-disable-next-line import/no-unresolved
 import protocol from 'typescript/lib/protocol';
 
+export const UNRESOLVED = '<<unresolved>>';
+
 /**
  * try to parse the type from the quickinfo.
  * this is an error-prone process, we do our best here.
@@ -49,7 +51,13 @@ export function parseTypeFromQuickInfo(quickInfo: protocol.QuickInfoResponse | u
     case 'function': {
       const split = displayString.split('): ');
       if (split.length !== 2) {
-        throw new Error(`quickinfo of a function below was not implemented.\n${displayString}`);
+        // it's hard to determine where the return-type is. so it's better to show unresolved.
+        // maybe, in the UI, in this case, it's best to show the signature.
+        // e.g.
+        // (method) IssuesList.getIssue<T extends ComponentIssue>(IssueClass: {
+        //   new (): T;
+        // }): T | undefined
+        return UNRESOLVED;
       }
       return split[1].trim();
     }

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

@@ -11,9 +11,14 @@ import {
   IntersectionTypeNode,
   UnionTypeNode,
   TypeLiteralNode,
+  ParenthesizedTypeNode,
+  TypePredicateNode,
+  isIdentifier,
+  IndexedAccessTypeNode,
 } from 'typescript';
 import {
   SchemaNode,
+  TypeRefSchema,
   TypeIntersectionSchema,
   TypeUnionSchema,
   TypeLiteralSchema,
@@ -24,6 +29,9 @@ import {
   TypeOperatorSchema,
   TupleTypeSchema,
   FunctionLikeSchema,
+  ParenthesizedTypeSchema,
+  TypePredicateSchema,
+  IndexedAccessSchema,
 } from '@teambit/semantics.entities.semantic-schema';
 import pMapSeries from 'p-map-series';
 import { SchemaExtractorContext } from '../../schema-extractor-context';
@@ -56,16 +64,19 @@ export async function typeNodeToSchema(node: TypeNode, context: SchemaExtractorC
       return typeOperator(node as TypeOperatorNode, context);
     case SyntaxKind.TupleType:
       return tupleType(node as TupleTypeNode, context);
+    case SyntaxKind.ParenthesizedType:
+      return parenthesizedType(node as ParenthesizedTypeNode, context);
     case SyntaxKind.TypePredicate:
+      return typePredicate(node as TypePredicateNode, context);
+    case SyntaxKind.IndexedAccessType:
+      return indexedAccessType(node as IndexedAccessTypeNode, context);
     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:
@@ -82,10 +93,10 @@ export async function typeNodeToSchema(node: TypeNode, context: SchemaExtractorC
     case SyntaxKind.JSDocNamepathType:
     case SyntaxKind.JSDocSignature:
     case SyntaxKind.JSDocTypeLiteral:
-      throw new Error(`TypeNode "${SyntaxKind[node.kind]}" was not implemented yet.
+      throw new Error(`TypeNode ${node.kind} (probably ${SyntaxKind[node.kind]}) was not implemented yet.
 context: ${node.getText()}`);
     default:
-      throw new Error(`Node "${SyntaxKind[node.kind]}" is not a TypeNode.
+      throw new Error(`Node ${node.kind} (probably ${SyntaxKind[node.kind]}) is not a TypeNode.
 context: ${node.getText()}`);
   }
 }
@@ -154,6 +165,10 @@ async function typeLiteral(node: TypeLiteralNode, context: SchemaExtractorContex
 async function typeReference(node: TypeReferenceNode, context: SchemaExtractorContext) {
   const name = node.typeName.getText();
   const type = await context.resolveType(node, name, false);
+  if (node.typeArguments && type instanceof TypeRefSchema) {
+    const args = await pMapSeries(node.typeArguments, (arg) => typeNodeToSchema(arg, context));
+    type.typeArgs = args;
+  }
   return type;
 }
 
@@ -210,3 +225,21 @@ async function tupleType(node: TupleTypeNode, context: SchemaExtractorContext) {
   });
   return new TupleTypeSchema(context.getLocation(node), elements);
 }
+
+async function parenthesizedType(node: ParenthesizedTypeNode, context: SchemaExtractorContext) {
+  const type = await typeNodeToSchema(node.type, context);
+  return new ParenthesizedTypeSchema(context.getLocation(node), type);
+}
+
+async function typePredicate(node: TypePredicateNode, context: SchemaExtractorContext) {
+  const parameterName = isIdentifier(node.parameterName) ? node.parameterName.getText() : 'this';
+  const type = node.type ? await typeNodeToSchema(node.type, context) : undefined;
+  const hasAssertsModifier = Boolean(node.assertsModifier);
+  return new TypePredicateSchema(context.getLocation(node), parameterName, type, hasAssertsModifier);
+}
+
+async function indexedAccessType(node: IndexedAccessTypeNode, context: SchemaExtractorContext) {
+  const objectType = await typeNodeToSchema(node.objectType, context);
+  const indexType = await typeNodeToSchema(node.indexType, context);
+  return new IndexedAccessSchema(context.getLocation(node), objectType, indexType);
+}