@teambit/typescript 0.0.736 → 0.0.739

package/transformers/type-alias.ts

@@ -22,6 +22,6 @@ export class TypeAliasTransformer implements SchemaTransformer {
     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);
+    return new TypeSchema(context.getLocation(typeAlias), this.getName(typeAlias), type, displaySig || '');
   }
 }

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';
@@ -11,19 +24,54 @@ export async function getParams(
 ): Promise<ParameterSchema[]> {
   return pMapSeries(parameterNodes, async (param) => {
     return new ParameterSchema(
-      param.name.getText(),
+      context.getLocation(param),
+      getParamName(param),
       await getParamType(param, context),
       param.initializer ? param.initializer.getText() : undefined
     );
   });
 }
 
+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(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/to-function-schema.ts

@@ -9,11 +9,11 @@ export async function toFunctionLikeSchema(node: SignatureDeclaration, context:
   // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
   const info = await context.getQuickInfo(node.name!);
   const returnTypeStr = parseTypeFromQuickInfo(info);
-  const displaySig = info?.body?.displayString;
+  const displaySig = info?.body?.displayString || '';
   const args = await getParams(node.parameters, context);
   const returnType = await context.resolveType(node, returnTypeStr);
   const modifiers = node.modifiers?.map((modifier) => modifier.getText()) || [];
   const location = context.getLocation(node);
 
-  return new FunctionLikeSchema(name, args, returnType, displaySig || '', location, modifiers as Modifier[]);
+  return new FunctionLikeSchema(location, name, args, returnType, displaySig, modifiers as Modifier[]);
 }

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';
@@ -31,8 +39,9 @@ import { getParams } from './get-params';
 
 // eslint-disable-next-line complexity
 export async function typeNodeToSchema(node: TypeNode, context: SchemaExtractorContext): Promise<SchemaNode> {
+  const location = context.getLocation(node);
   if (isKeywordType(node)) {
-    return new KeywordTypeSchema(node.getText());
+    return new KeywordTypeSchema(location, node.getText());
   }
   switch (node.kind) {
     case SyntaxKind.IntersectionType:
@@ -44,7 +53,7 @@ export async function typeNodeToSchema(node: TypeNode, context: SchemaExtractorC
     case SyntaxKind.TypeLiteral:
       return typeLiteral(node as TypeLiteralNode, context);
     case SyntaxKind.LiteralType: // e.g. string/boolean
-      return new LiteralTypeSchema(node.getText());
+      return new LiteralTypeSchema(location, node.getText());
     case SyntaxKind.FunctionType:
       return functionType(node as FunctionTypeNode, context);
     case SyntaxKind.TypeQuery:
@@ -55,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:
@@ -81,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()}`);
   }
 }
@@ -117,7 +129,8 @@ async function intersectionType(node: IntersectionTypeNode, context: SchemaExtra
     const typeSchema = await typeNodeToSchema(type, context);
     return typeSchema;
   });
-  return new TypeIntersectionSchema(types);
+  const location = context.getLocation(node);
+  return new TypeIntersectionSchema(location, types);
 }
 
 async function unionType(node: UnionTypeNode, context: SchemaExtractorContext) {
@@ -125,7 +138,8 @@ async function unionType(node: UnionTypeNode, context: SchemaExtractorContext) {
     const typeSchema = await typeNodeToSchema(type, context);
     return typeSchema;
   });
-  return new TypeUnionSchema(types);
+  const location = context.getLocation(node);
+  return new TypeUnionSchema(location, types);
 }
 
 /**
@@ -137,7 +151,8 @@ async function typeLiteral(node: TypeLiteralNode, context: SchemaExtractorContex
     const typeSchema = await context.computeSchema(member);
     return typeSchema;
   });
-  return new TypeLiteralSchema(members);
+  const location = context.getLocation(node);
+  return new TypeLiteralSchema(location, members);
 }
 
 /**
@@ -150,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;
 }
 
@@ -158,7 +177,7 @@ async function functionType(node: FunctionTypeNode, context: SchemaExtractorCont
   const params = await getParams(node.parameters, context);
   const returnType = await typeNodeToSchema(node.type, context);
   const location = context.getLocation(node);
-  return new FunctionLikeSchema(name, params, returnType, '', location);
+  return new FunctionLikeSchema(location, name, params, returnType, '');
 }
 
 /**
@@ -167,12 +186,14 @@ async function functionType(node: FunctionTypeNode, context: SchemaExtractorCont
 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);
+  const location = context.getLocation(node);
+  return new TypeQuerySchema(location, type, displaySig);
 }
 
 async function arrayType(node: ArrayTypeNode, context: SchemaExtractorContext) {
   const type = await typeNodeToSchema(node.elementType, context);
-  return new TypeArraySchema(type);
+  const location = context.getLocation(node);
+  return new TypeArraySchema(location, type);
 }
 
 /**
@@ -181,7 +202,7 @@ async function arrayType(node: ArrayTypeNode, context: SchemaExtractorContext) {
 async function typeOperator(node: TypeOperatorNode, context: SchemaExtractorContext) {
   const operatorName = getOperatorName(node.operator);
   const type = await typeNodeToSchema(node.type, context);
-  return new TypeOperatorSchema(operatorName, type);
+  return new TypeOperatorSchema(context.getLocation(node), operatorName, type);
 }
 
 function getOperatorName(operator: SyntaxKind.KeyOfKeyword | SyntaxKind.UniqueKeyword | SyntaxKind.ReadonlyKeyword) {
@@ -202,5 +223,23 @@ async function tupleType(node: TupleTypeNode, context: SchemaExtractorContext) {
     const typeSchema = await typeNodeToSchema(elem, context);
     return typeSchema;
   });
-  return new TupleTypeSchema(elements);
+  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);
 }

package/transformers/variable-declaration.ts

@@ -23,15 +23,15 @@ export class VariableDeclaration implements SchemaTransformer {
     const name = this.getName(varDec);
     const info = await context.getQuickInfo(varDec.name);
     const displaySig = info?.body?.displayString || '';
+    const location = context.getLocation(varDec);
     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);
-      const location = context.getLocation(varDec);
-      return new FunctionLikeSchema(name, args, returnType, displaySig, location);
+      return new FunctionLikeSchema(location, name, args, returnType, displaySig);
     }
     const typeStr = parseTypeFromQuickInfo(info);
     const type = await context.resolveType(varDec, typeStr);
-    return new VariableSchema(name, displaySig, type);
+    return new VariableSchema(location, name, displaySig, type);
   }
 }

package/transformers/variable-statement.ts

@@ -27,7 +27,6 @@ export class VariableStatementTransformer implements SchemaTransformer {
       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));
+    return new Module(context.getLocation(node), compact(schemas));
   }
 }

package/tsconfig.json

@@ -15,13 +15,13 @@
     "declaration": true,
     "sourceMap": true,
     "skipLibCheck": true,
+    "experimentalDecorators": true,
     "outDir": "dist",
     "moduleResolution": "node",
     "esModuleInterop": true,
     "rootDir": ".",
     "resolveJsonModule": true,
     "emitDeclarationOnly": true,
-    "experimentalDecorators": true,
     "emitDecoratorMetadata": true,
     "allowSyntheticDefaultImports": true,
     "strictPropertyInitialization": false,

package/dist/transformers/export-declaration-type.js

@@ -1,3 +0,0 @@
-"use strict";
-
-//# sourceMappingURL=export-declaration-type.js.map

package/dist/transformers/export-declaration-type.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":[],"names":[],"mappings":"","sourcesContent":[]}