@teambit/typescript 0.0.738 → 0.0.741

package/dist/transformers/property-signature.js

@@ -1,7 +1,5 @@
 "use strict";
 
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
 require("core-js/modules/es.promise.js");
 
 Object.defineProperty(exports, "__esModule", {
@@ -20,7 +18,7 @@ function _semanticsEntities() {
 }
 
 function _typescript() {
-  const data = _interopRequireDefault(require("typescript"));
+  const data = _interopRequireWildcard(require("typescript"));
 
   _typescript = function () {
     return data;
@@ -39,15 +37,9 @@ function _parseTypeFromQuickInfo() {
   return data;
 }
 
-function _typeNodeToSchema() {
-  const data = require("./utils/type-node-to-schema");
-
-  _typeNodeToSchema = function () {
-    return data;
-  };
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
 
-  return data;
-}
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
 
 class PropertySignature {
   predicate(node) {
@@ -63,18 +55,11 @@ class PropertySignature {
   }
 
   async transform(prop, context) {
-    var _info$body, _prop$type;
+    var _info$body;
 
     const name = this.getName(prop);
-    const info = await context.getQuickInfo(prop.name);
+    const info = (0, _typescript().isComputedPropertyName)(prop.name) ? undefined : await context.getQuickInfo(prop.name);
     const displaySig = (info === null || info === void 0 ? void 0 : (_info$body = info.body) === null || _info$body === void 0 ? void 0 : _info$body.displayString) || '';
-
-    if (((_prop$type = prop.type) === null || _prop$type === void 0 ? void 0 : _prop$type.kind) === _typescript().default.SyntaxKind.FunctionType) {
-      // e.g. `propertySig: () => void;` inside interface
-      const propType = prop.type;
-      return (0, _typeNodeToSchema().typeNodeToSchema)(propType, context);
-    }
-
     const typeStr = (0, _parseTypeFromQuickInfo().parseTypeFromQuickInfo)(info);
     const type = await context.resolveType(prop, typeStr);
     return new (_semanticsEntities().VariableSchema)(context.getLocation(prop), name, displaySig, type);

package/dist/transformers/property-signature.js.map

@@ -1 +1 @@
-{"version":3,"names":["PropertySignature","predicate","node","kind","ts","SyntaxKind","getName","name","getText","getIdentifiers","transform","prop","context","info","getQuickInfo","displaySig","body","displayString","type","FunctionType","propType","typeNodeToSchema","typeStr","parseTypeFromQuickInfo","resolveType","VariableSchema","getLocation"],"sources":["property-signature.ts"],"sourcesContent":["import { SchemaNode, VariableSchema } from '@teambit/semantics.entities.semantic-schema';\nimport ts, { FunctionTypeNode, Node, PropertySignature as PropertySignatureNode } from 'typescript';\nimport { SchemaTransformer } from '../schema-transformer';\nimport { SchemaExtractorContext } from '../schema-extractor-context';\nimport { parseTypeFromQuickInfo } from './utils/parse-type-from-quick-info';\nimport { typeNodeToSchema } from './utils/type-node-to-schema';\n\nexport class PropertySignature implements SchemaTransformer {\n  predicate(node: Node) {\n    return node.kind === ts.SyntaxKind.PropertySignature;\n  }\n\n  getName(node: PropertySignatureNode) {\n    return node.name.getText();\n  }\n\n  async getIdentifiers() {\n    return [];\n  }\n\n  async transform(prop: PropertySignatureNode, context: SchemaExtractorContext): Promise<SchemaNode> {\n    const name = this.getName(prop);\n    const info = await context.getQuickInfo(prop.name);\n    const displaySig = info?.body?.displayString || '';\n    if (prop.type?.kind === ts.SyntaxKind.FunctionType) {\n      // e.g. `propertySig: () => void;` inside interface\n      const propType = prop.type as FunctionTypeNode;\n      return typeNodeToSchema(propType, context);\n    }\n    const typeStr = parseTypeFromQuickInfo(info);\n    const type = await context.resolveType(prop, typeStr);\n    return new VariableSchema(context.getLocation(prop), name, displaySig, type);\n  }\n}\n"],"mappings":";;;;;;;;;;;AAAA;EAAA;;EAAA;IAAA;EAAA;;EAAA;AAAA;;AACA;EAAA;;EAAA;IAAA;EAAA;;EAAA;AAAA;;AAGA;EAAA;;EAAA;IAAA;EAAA;;EAAA;AAAA;;AACA;EAAA;;EAAA;IAAA;EAAA;;EAAA;AAAA;;AAEO,MAAMA,iBAAN,CAAqD;EAC1DC,SAAS,CAACC,IAAD,EAAa;IACpB,OAAOA,IAAI,CAACC,IAAL,KAAcC,qBAAA,CAAGC,UAAH,CAAcL,iBAAnC;EACD;;EAEDM,OAAO,CAACJ,IAAD,EAA8B;IACnC,OAAOA,IAAI,CAACK,IAAL,CAAUC,OAAV,EAAP;EACD;;EAEmB,MAAdC,cAAc,GAAG;IACrB,OAAO,EAAP;EACD;;EAEc,MAATC,SAAS,CAACC,IAAD,EAA8BC,OAA9B,EAAoF;IAAA;;IACjG,MAAML,IAAI,GAAG,KAAKD,OAAL,CAAaK,IAAb,CAAb;IACA,MAAME,IAAI,GAAG,MAAMD,OAAO,CAACE,YAAR,CAAqBH,IAAI,CAACJ,IAA1B,CAAnB;IACA,MAAMQ,UAAU,GAAG,CAAAF,IAAI,SAAJ,IAAAA,IAAI,WAAJ,0BAAAA,IAAI,CAAEG,IAAN,0DAAYC,aAAZ,KAA6B,EAAhD;;IACA,IAAI,eAAAN,IAAI,CAACO,IAAL,0DAAWf,IAAX,MAAoBC,qBAAA,CAAGC,UAAH,CAAcc,YAAtC,EAAoD;MAClD;MACA,MAAMC,QAAQ,GAAGT,IAAI,CAACO,IAAtB;MACA,OAAO,IAAAG,oCAAA,EAAiBD,QAAjB,EAA2BR,OAA3B,CAAP;IACD;;IACD,MAAMU,OAAO,GAAG,IAAAC,gDAAA,EAAuBV,IAAvB,CAAhB;IACA,MAAMK,IAAI,GAAG,MAAMN,OAAO,CAACY,WAAR,CAAoBb,IAApB,EAA0BW,OAA1B,CAAnB;IACA,OAAO,KAAIG,mCAAJ,EAAmBb,OAAO,CAACc,WAAR,CAAoBf,IAApB,CAAnB,EAA8CJ,IAA9C,EAAoDQ,UAApD,EAAgEG,IAAhE,CAAP;EACD;;AAzByD"}
+{"version":3,"names":["PropertySignature","predicate","node","kind","ts","SyntaxKind","getName","name","getText","getIdentifiers","transform","prop","context","info","isComputedPropertyName","undefined","getQuickInfo","displaySig","body","displayString","typeStr","parseTypeFromQuickInfo","type","resolveType","VariableSchema","getLocation"],"sources":["property-signature.ts"],"sourcesContent":["import { SchemaNode, VariableSchema } from '@teambit/semantics.entities.semantic-schema';\nimport ts, { isComputedPropertyName, Node, PropertySignature as PropertySignatureNode } from 'typescript';\nimport { SchemaTransformer } from '../schema-transformer';\nimport { SchemaExtractorContext } from '../schema-extractor-context';\nimport { parseTypeFromQuickInfo } from './utils/parse-type-from-quick-info';\n\nexport class PropertySignature implements SchemaTransformer {\n  predicate(node: Node) {\n    return node.kind === ts.SyntaxKind.PropertySignature;\n  }\n\n  getName(node: PropertySignatureNode) {\n    return node.name.getText();\n  }\n\n  async getIdentifiers() {\n    return [];\n  }\n\n  async transform(prop: PropertySignatureNode, context: SchemaExtractorContext): Promise<SchemaNode> {\n    const name = this.getName(prop);\n    const info = isComputedPropertyName(prop.name) ? undefined : await context.getQuickInfo(prop.name);\n    const displaySig = info?.body?.displayString || '';\n    const typeStr = parseTypeFromQuickInfo(info);\n    const type = await context.resolveType(prop, typeStr);\n    return new VariableSchema(context.getLocation(prop), name, displaySig, type);\n  }\n}\n"],"mappings":";;;;;;;;;AAAA;EAAA;;EAAA;IAAA;EAAA;;EAAA;AAAA;;AACA;EAAA;;EAAA;IAAA;EAAA;;EAAA;AAAA;;AAGA;EAAA;;EAAA;IAAA;EAAA;;EAAA;AAAA;;;;;;AAEO,MAAMA,iBAAN,CAAqD;EAC1DC,SAAS,CAACC,IAAD,EAAa;IACpB,OAAOA,IAAI,CAACC,IAAL,KAAcC,qBAAA,CAAGC,UAAH,CAAcL,iBAAnC;EACD;;EAEDM,OAAO,CAACJ,IAAD,EAA8B;IACnC,OAAOA,IAAI,CAACK,IAAL,CAAUC,OAAV,EAAP;EACD;;EAEmB,MAAdC,cAAc,GAAG;IACrB,OAAO,EAAP;EACD;;EAEc,MAATC,SAAS,CAACC,IAAD,EAA8BC,OAA9B,EAAoF;IAAA;;IACjG,MAAML,IAAI,GAAG,KAAKD,OAAL,CAAaK,IAAb,CAAb;IACA,MAAME,IAAI,GAAG,IAAAC,oCAAA,EAAuBH,IAAI,CAACJ,IAA5B,IAAoCQ,SAApC,GAAgD,MAAMH,OAAO,CAACI,YAAR,CAAqBL,IAAI,CAACJ,IAA1B,CAAnE;IACA,MAAMU,UAAU,GAAG,CAAAJ,IAAI,SAAJ,IAAAA,IAAI,WAAJ,0BAAAA,IAAI,CAAEK,IAAN,0DAAYC,aAAZ,KAA6B,EAAhD;IACA,MAAMC,OAAO,GAAG,IAAAC,gDAAA,EAAuBR,IAAvB,CAAhB;IACA,MAAMS,IAAI,GAAG,MAAMV,OAAO,CAACW,WAAR,CAAoBZ,IAApB,EAA0BS,OAA1B,CAAnB;IACA,OAAO,KAAII,mCAAJ,EAAmBZ,OAAO,CAACa,WAAR,CAAoBd,IAApB,CAAnB,EAA8CJ,IAA9C,EAAoDU,UAApD,EAAgEK,IAAhE,CAAP;EACD;;AApByD"}

package/dist/transformers/type-alias.js

@@ -63,12 +63,9 @@ class TypeAliasTransformer {
   }
 
   async transform(typeAlias, context) {
-    var _info$body;
-
     const type = await (0, _typeNodeToSchema().typeNodeToSchema)(typeAlias.type, context);
-    const info = await context.getQuickInfo(typeAlias.name);
-    const displaySig = info === null || info === void 0 ? void 0 : (_info$body = info.body) === null || _info$body === void 0 ? void 0 : _info$body.displayString;
-    return new (_semanticsEntities().TypeSchema)(context.getLocation(typeAlias), this.getName(typeAlias), type, displaySig || '');
+    const displaySig = await context.getQuickInfoDisplayString(typeAlias.name);
+    return new (_semanticsEntities().TypeSchema)(context.getLocation(typeAlias), this.getName(typeAlias), type, displaySig);
   }
 
 }

package/dist/transformers/type-alias.js.map

@@ -1 +1 @@
-{"version":3,"names":["TypeAliasTransformer","predicate","node","kind","ts","SyntaxKind","TypeAliasDeclaration","getIdentifiers","ExportIdentifier","name","getText","getSourceFile","fileName","getName","transform","typeAlias","context","type","typeNodeToSchema","info","getQuickInfo","displaySig","body","displayString","TypeSchema","getLocation"],"sources":["type-alias.ts"],"sourcesContent":["import ts, { Node, TypeAliasDeclaration } from 'typescript';\nimport { TypeSchema } from '@teambit/semantics.entities.semantic-schema';\nimport { SchemaTransformer } from '../schema-transformer';\nimport { SchemaExtractorContext } from '../schema-extractor-context';\nimport { ExportIdentifier } from '../export-identifier';\nimport { typeNodeToSchema } from './utils/type-node-to-schema';\n\nexport class TypeAliasTransformer implements SchemaTransformer {\n  predicate(node: Node) {\n    return node.kind === ts.SyntaxKind.TypeAliasDeclaration;\n  }\n\n  async getIdentifiers(node: TypeAliasDeclaration) {\n    return [new ExportIdentifier(node.name.getText(), node.getSourceFile().fileName)];\n  }\n\n  private getName(node: TypeAliasDeclaration): string {\n    return node.name.getText();\n  }\n\n  async transform(typeAlias: TypeAliasDeclaration, context: SchemaExtractorContext) {\n    const type = await typeNodeToSchema(typeAlias.type, context);\n    const info = await context.getQuickInfo(typeAlias.name);\n    const displaySig = info?.body?.displayString;\n    return new TypeSchema(context.getLocation(typeAlias), this.getName(typeAlias), type, displaySig || '');\n  }\n}\n"],"mappings":";;;;;;;;;;;AAAA;EAAA;;EAAA;IAAA;EAAA;;EAAA;AAAA;;AACA;EAAA;;EAAA;IAAA;EAAA;;EAAA;AAAA;;AAGA;EAAA;;EAAA;IAAA;EAAA;;EAAA;AAAA;;AACA;EAAA;;EAAA;IAAA;EAAA;;EAAA;AAAA;;AAEO,MAAMA,oBAAN,CAAwD;EAC7DC,SAAS,CAACC,IAAD,EAAa;IACpB,OAAOA,IAAI,CAACC,IAAL,KAAcC,qBAAA,CAAGC,UAAH,CAAcC,oBAAnC;EACD;;EAEmB,MAAdC,cAAc,CAACL,IAAD,EAA6B;IAC/C,OAAO,CAAC,KAAIM,oCAAJ,EAAqBN,IAAI,CAACO,IAAL,CAAUC,OAAV,EAArB,EAA0CR,IAAI,CAACS,aAAL,GAAqBC,QAA/D,CAAD,CAAP;EACD;;EAEOC,OAAO,CAACX,IAAD,EAAqC;IAClD,OAAOA,IAAI,CAACO,IAAL,CAAUC,OAAV,EAAP;EACD;;EAEc,MAATI,SAAS,CAACC,SAAD,EAAkCC,OAAlC,EAAmE;IAAA;;IAChF,MAAMC,IAAI,GAAG,MAAM,IAAAC,oCAAA,EAAiBH,SAAS,CAACE,IAA3B,EAAiCD,OAAjC,CAAnB;IACA,MAAMG,IAAI,GAAG,MAAMH,OAAO,CAACI,YAAR,CAAqBL,SAAS,CAACN,IAA/B,CAAnB;IACA,MAAMY,UAAU,GAAGF,IAAH,aAAGA,IAAH,qCAAGA,IAAI,CAAEG,IAAT,+CAAG,WAAYC,aAA/B;IACA,OAAO,KAAIC,+BAAJ,EAAeR,OAAO,CAACS,WAAR,CAAoBV,SAApB,CAAf,EAA+C,KAAKF,OAAL,CAAaE,SAAb,CAA/C,EAAwEE,IAAxE,EAA8EI,UAAU,IAAI,EAA5F,CAAP;EACD;;AAlB4D"}
+{"version":3,"names":["TypeAliasTransformer","predicate","node","kind","ts","SyntaxKind","TypeAliasDeclaration","getIdentifiers","ExportIdentifier","name","getText","getSourceFile","fileName","getName","transform","typeAlias","context","type","typeNodeToSchema","displaySig","getQuickInfoDisplayString","TypeSchema","getLocation"],"sources":["type-alias.ts"],"sourcesContent":["import ts, { Node, TypeAliasDeclaration } from 'typescript';\nimport { TypeSchema } from '@teambit/semantics.entities.semantic-schema';\nimport { SchemaTransformer } from '../schema-transformer';\nimport { SchemaExtractorContext } from '../schema-extractor-context';\nimport { ExportIdentifier } from '../export-identifier';\nimport { typeNodeToSchema } from './utils/type-node-to-schema';\n\nexport class TypeAliasTransformer implements SchemaTransformer {\n  predicate(node: Node) {\n    return node.kind === ts.SyntaxKind.TypeAliasDeclaration;\n  }\n\n  async getIdentifiers(node: TypeAliasDeclaration) {\n    return [new ExportIdentifier(node.name.getText(), node.getSourceFile().fileName)];\n  }\n\n  private getName(node: TypeAliasDeclaration): string {\n    return node.name.getText();\n  }\n\n  async transform(typeAlias: TypeAliasDeclaration, context: SchemaExtractorContext) {\n    const type = await typeNodeToSchema(typeAlias.type, context);\n    const displaySig = await context.getQuickInfoDisplayString(typeAlias.name);\n    return new TypeSchema(context.getLocation(typeAlias), this.getName(typeAlias), type, displaySig);\n  }\n}\n"],"mappings":";;;;;;;;;;;AAAA;EAAA;;EAAA;IAAA;EAAA;;EAAA;AAAA;;AACA;EAAA;;EAAA;IAAA;EAAA;;EAAA;AAAA;;AAGA;EAAA;;EAAA;IAAA;EAAA;;EAAA;AAAA;;AACA;EAAA;;EAAA;IAAA;EAAA;;EAAA;AAAA;;AAEO,MAAMA,oBAAN,CAAwD;EAC7DC,SAAS,CAACC,IAAD,EAAa;IACpB,OAAOA,IAAI,CAACC,IAAL,KAAcC,qBAAA,CAAGC,UAAH,CAAcC,oBAAnC;EACD;;EAEmB,MAAdC,cAAc,CAACL,IAAD,EAA6B;IAC/C,OAAO,CAAC,KAAIM,oCAAJ,EAAqBN,IAAI,CAACO,IAAL,CAAUC,OAAV,EAArB,EAA0CR,IAAI,CAACS,aAAL,GAAqBC,QAA/D,CAAD,CAAP;EACD;;EAEOC,OAAO,CAACX,IAAD,EAAqC;IAClD,OAAOA,IAAI,CAACO,IAAL,CAAUC,OAAV,EAAP;EACD;;EAEc,MAATI,SAAS,CAACC,SAAD,EAAkCC,OAAlC,EAAmE;IAChF,MAAMC,IAAI,GAAG,MAAM,IAAAC,oCAAA,EAAiBH,SAAS,CAACE,IAA3B,EAAiCD,OAAjC,CAAnB;IACA,MAAMG,UAAU,GAAG,MAAMH,OAAO,CAACI,yBAAR,CAAkCL,SAAS,CAACN,IAA5C,CAAzB;IACA,OAAO,KAAIY,+BAAJ,EAAeL,OAAO,CAACM,WAAR,CAAoBP,SAApB,CAAf,EAA+C,KAAKF,OAAL,CAAaE,SAAb,CAA/C,EAAwEE,IAAxE,EAA8EE,UAA9E,CAAP;EACD;;AAjB4D"}

package/dist/transformers/utils/get-params.js

@@ -29,6 +29,16 @@ function _pMapSeries() {
   return data;
 }
 
+function _typescript() {
+  const data = require("typescript");
+
+  _typescript = function () {
+    return data;
+  };
+
+  return data;
+}
+
 function _parseTypeFromQuickInfo() {
   const data = require("./parse-type-from-quick-info");
 
@@ -51,13 +61,26 @@ function _typeNodeToSchema() {
 
 async function getParams(parameterNodes, context) {
   return (0, _pMapSeries().default)(parameterNodes, async param => {
-    return new (_semanticsEntities().ParameterSchema)(context.getLocation(param), param.name.getText(), await getParamType(param, context), param.initializer ? param.initializer.getText() : undefined);
+    return new (_semanticsEntities().ParameterSchema)(context.getLocation(param), getParamName(param), await getParamType(param, context), param.initializer ? param.initializer.getText() : undefined);
   });
 }
-/**
- * @todo: probably not needed. just call context.resolveType instead.
- */
 
+function getParamName(param) {
+  if ((0, _typescript().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 === _typescript().SyntaxKind.ArrayBindingPattern) {
+    return `[ ${elementsStr} ]`;
+  } // it's an object binding
+
+
+  return `{ ${elementsStr} }`;
+}
 
 async function getParamType(param, context) {
   if (param.type) {
@@ -65,9 +88,32 @@ async function getParamType(param, context) {
     return (0, _typeNodeToSchema().typeNodeToSchema)(type, context);
   }
 
-  const info = await context.getQuickInfo(param.name);
-  const parsed = (0, _parseTypeFromQuickInfo().parseTypeFromQuickInfo)(info);
-  return new (_semanticsEntities().TypeRefSchema)(context.getLocation(param), parsed || 'any');
+  if ((0, _typescript().isIdentifier)(param.name)) {
+    const info = await context.getQuickInfo(param.name);
+    const parsed = (0, _parseTypeFromQuickInfo().parseTypeFromQuickInfo)(info);
+    return new (_semanticsEntities().InferenceTypeSchema)(context.getLocation(param), parsed);
+  } // it's binding pattern, either an array or an object
+
+
+  if (param.name.kind === _typescript().SyntaxKind.ArrayBindingPattern) {
+    const elements = await (0, _pMapSeries().default)(param.name.elements, async elem => {
+      const info = await context.getQuickInfo(elem);
+      const parsed = (0, _parseTypeFromQuickInfo().parseTypeFromQuickInfo)(info);
+      return new (_semanticsEntities().InferenceTypeSchema)(context.getLocation(param), parsed);
+    });
+    return new (_semanticsEntities().TupleTypeSchema)(context.getLocation(param), elements);
+  }
+
+  if (param.name.kind === _typescript().SyntaxKind.ObjectBindingPattern) {
+    const elements = await (0, _pMapSeries().default)(param.name.elements, async elem => {
+      const info = await context.getQuickInfo(elem.name);
+      const parsed = (0, _parseTypeFromQuickInfo().parseTypeFromQuickInfo)(info);
+      return new (_semanticsEntities().InferenceTypeSchema)(context.getLocation(param), parsed, elem.name.getText());
+    });
+    return new (_semanticsEntities().TypeLiteralSchema)(context.getLocation(param), elements);
+  }
+
+  throw new Error(`unknown param type`);
 }
 
 //# sourceMappingURL=get-params.js.map

package/dist/transformers/utils/get-params.js.map

@@ -1 +1 @@
-{"version":3,"names":["getParams","parameterNodes","context","pMapSeries","param","ParameterSchema","getLocation","name","getText","getParamType","initializer","undefined","type","typeNodeToSchema","info","getQuickInfo","parsed","parseTypeFromQuickInfo","TypeRefSchema"],"sources":["get-params.ts"],"sourcesContent":["import { ParameterSchema, SchemaNode, TypeRefSchema } from '@teambit/semantics.entities.semantic-schema';\nimport pMapSeries from 'p-map-series';\nimport { ParameterDeclaration, NodeArray } from 'typescript';\nimport { SchemaExtractorContext } from '../../schema-extractor-context';\nimport { parseTypeFromQuickInfo } from './parse-type-from-quick-info';\nimport { typeNodeToSchema } from './type-node-to-schema';\n\nexport async function getParams(\n  parameterNodes: NodeArray<ParameterDeclaration>,\n  context: SchemaExtractorContext\n): Promise<ParameterSchema[]> {\n  return pMapSeries(parameterNodes, async (param) => {\n    return new ParameterSchema(\n      context.getLocation(param),\n      param.name.getText(),\n      await getParamType(param, context),\n      param.initializer ? param.initializer.getText() : undefined\n    );\n  });\n}\n\n/**\n * @todo: probably not needed. just call context.resolveType instead.\n */\nasync function getParamType(param: ParameterDeclaration, context: SchemaExtractorContext): Promise<SchemaNode> {\n  if (param.type) {\n    const type = param.type;\n    return typeNodeToSchema(type, context);\n  }\n  const info = await context.getQuickInfo(param.name);\n  const parsed = parseTypeFromQuickInfo(info);\n  return new TypeRefSchema(context.getLocation(param), parsed || 'any');\n}\n"],"mappings":";;;;;;;;;;;AAAA;EAAA;;EAAA;IAAA;EAAA;;EAAA;AAAA;;AACA;EAAA;;EAAA;IAAA;EAAA;;EAAA;AAAA;;AAGA;EAAA;;EAAA;IAAA;EAAA;;EAAA;AAAA;;AACA;EAAA;;EAAA;IAAA;EAAA;;EAAA;AAAA;;AAEO,eAAeA,SAAf,CACLC,cADK,EAELC,OAFK,EAGuB;EAC5B,OAAO,IAAAC,qBAAA,EAAWF,cAAX,EAA2B,MAAOG,KAAP,IAAiB;IACjD,OAAO,KAAIC,oCAAJ,EACLH,OAAO,CAACI,WAAR,CAAoBF,KAApB,CADK,EAELA,KAAK,CAACG,IAAN,CAAWC,OAAX,EAFK,EAGL,MAAMC,YAAY,CAACL,KAAD,EAAQF,OAAR,CAHb,EAILE,KAAK,CAACM,WAAN,GAAoBN,KAAK,CAACM,WAAN,CAAkBF,OAAlB,EAApB,GAAkDG,SAJ7C,CAAP;EAMD,CAPM,CAAP;AAQD;AAED;AACA;AACA;;;AACA,eAAeF,YAAf,CAA4BL,KAA5B,EAAyDF,OAAzD,EAA+G;EAC7G,IAAIE,KAAK,CAACQ,IAAV,EAAgB;IACd,MAAMA,IAAI,GAAGR,KAAK,CAACQ,IAAnB;IACA,OAAO,IAAAC,oCAAA,EAAiBD,IAAjB,EAAuBV,OAAvB,CAAP;EACD;;EACD,MAAMY,IAAI,GAAG,MAAMZ,OAAO,CAACa,YAAR,CAAqBX,KAAK,CAACG,IAA3B,CAAnB;EACA,MAAMS,MAAM,GAAG,IAAAC,gDAAA,EAAuBH,IAAvB,CAAf;EACA,OAAO,KAAII,kCAAJ,EAAkBhB,OAAO,CAACI,WAAR,CAAoBF,KAApB,CAAlB,EAA8CY,MAAM,IAAI,KAAxD,CAAP;AACD"}
+{"version":3,"names":["getParams","parameterNodes","context","pMapSeries","param","ParameterSchema","getLocation","getParamName","getParamType","initializer","getText","undefined","isIdentifier","name","elements","map","elem","elementsStr","join","kind","SyntaxKind","ArrayBindingPattern","type","typeNodeToSchema","info","getQuickInfo","parsed","parseTypeFromQuickInfo","InferenceTypeSchema","TupleTypeSchema","ObjectBindingPattern","TypeLiteralSchema","Error"],"sources":["get-params.ts"],"sourcesContent":["import {\n  InferenceTypeSchema,\n  ParameterSchema,\n  TupleTypeSchema,\n  TypeLiteralSchema,\n  SchemaNode,\n} from '@teambit/semantics.entities.semantic-schema';\nimport pMapSeries from 'p-map-series';\nimport {\n  SyntaxKind,\n  ParameterDeclaration,\n  NodeArray,\n  isIdentifier,\n  BindingElement,\n  ArrayBindingElement,\n} from 'typescript';\nimport { SchemaExtractorContext } from '../../schema-extractor-context';\nimport { parseTypeFromQuickInfo } from './parse-type-from-quick-info';\nimport { typeNodeToSchema } from './type-node-to-schema';\n\nexport async function getParams(\n  parameterNodes: NodeArray<ParameterDeclaration>,\n  context: SchemaExtractorContext\n): Promise<ParameterSchema[]> {\n  return pMapSeries(parameterNodes, async (param) => {\n    return new ParameterSchema(\n      context.getLocation(param),\n      getParamName(param),\n      await getParamType(param, context),\n      param.initializer ? param.initializer.getText() : undefined\n    );\n  });\n}\n\nfunction getParamName(param: ParameterDeclaration): string {\n  if (isIdentifier(param.name)) {\n    return param.name.getText();\n  }\n  // it's binding pattern, either an array or an object\n  const elements = param.name.elements.map((elem) => elem.getText());\n  const elementsStr = elements.join(', ');\n  if (param.name.kind === SyntaxKind.ArrayBindingPattern) {\n    return `[ ${elementsStr} ]`;\n  }\n  // it's an object binding\n  return `{ ${elementsStr} }`;\n}\n\nasync function getParamType(param: ParameterDeclaration, context: SchemaExtractorContext): Promise<SchemaNode> {\n  if (param.type) {\n    const type = param.type;\n    return typeNodeToSchema(type, context);\n  }\n  if (isIdentifier(param.name)) {\n    const info = await context.getQuickInfo(param.name);\n    const parsed = parseTypeFromQuickInfo(info);\n    return new InferenceTypeSchema(context.getLocation(param), parsed);\n  }\n  // it's binding pattern, either an array or an object\n  if (param.name.kind === SyntaxKind.ArrayBindingPattern) {\n    const elements = await pMapSeries(param.name.elements, async (elem: ArrayBindingElement) => {\n      const info = await context.getQuickInfo(elem);\n      const parsed = parseTypeFromQuickInfo(info);\n      return new InferenceTypeSchema(context.getLocation(param), parsed);\n    });\n    return new TupleTypeSchema(context.getLocation(param), elements);\n  }\n  if (param.name.kind === SyntaxKind.ObjectBindingPattern) {\n    const elements = await pMapSeries(param.name.elements, async (elem: BindingElement) => {\n      const info = await context.getQuickInfo(elem.name);\n      const parsed = parseTypeFromQuickInfo(info);\n      return new InferenceTypeSchema(context.getLocation(param), parsed, elem.name.getText());\n    });\n    return new TypeLiteralSchema(context.getLocation(param), elements);\n  }\n  throw new Error(`unknown param type`);\n}\n"],"mappings":"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"}

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

@@ -1,4 +1,5 @@
 import protocol from 'typescript/lib/protocol';
+export declare const UNRESOLVED = "<<unresolved>>";
 /**
  * try to parse the type from the quickinfo.
  * this is an error-prone process, we do our best here.

package/dist/transformers/utils/parse-type-from-quick-info.js

@@ -9,11 +9,11 @@ require("core-js/modules/es.string.trim.js");
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+exports.UNRESOLVED = void 0;
 exports.parseReturnTypeFromQuickInfo = parseReturnTypeFromQuickInfo;
 exports.parseTypeFromQuickInfo = parseTypeFromQuickInfo;
-
 // eslint-disable-next-line import/no-unresolved
-
+const UNRESOLVED = '<<unresolved>>';
 /**
  * try to parse the type from the quickinfo.
  * this is an error-prone process, we do our best here.
@@ -46,6 +46,9 @@ exports.parseTypeFromQuickInfo = parseTypeFromQuickInfo;
  *     b: number;
  * }
  */
+
+exports.UNRESOLVED = UNRESOLVED;
+
 function parseTypeFromQuickInfo(quickInfo) {
   var _quickInfo$body;
 
@@ -69,7 +72,13 @@ function parseTypeFromQuickInfo(quickInfo) {
         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/dist/transformers/utils/parse-type-from-quick-info.js.map

@@ -1 +1 @@
-{"version":3,"names":["parseTypeFromQuickInfo","quickInfo","body","displayString","splitByColon","split","kind","tail","join","trim","length","Error","firstLine","splitBySpace","typeName","splitByEqual","parseReturnTypeFromQuickInfo","typeStr","array"],"sources":["parse-type-from-quick-info.ts"],"sourcesContent":["// eslint-disable-next-line import/no-unresolved\nimport protocol from 'typescript/lib/protocol';\n\n/**\n * try to parse the type from the quickinfo.\n * this is an error-prone process, we do our best here.\n *\n * an example of a function with many \":\"\n * `export function getObj(a: string, func: (b: number) => {}) { return { a: 1, b: 2 } };`\n * which produce the following quickinfo:\n * ```ts\n * function getObj(a: string, func: (b: number) => {}): {\n *   a: number;\n *   b: number;\n * }\n * ```\n *\n * some examples of quickinfo:\n *\n * function ts.signatureToDisplayParts(typechecker: TypeChecker, signature: Signature, enclosingDeclaration?: Node | undefined, flags?: TypeFormatFlags): SymbolDisplayPart[]\n *\n * const enum ts.TypeFormatFlags\n *\n * (method) ts.TypeChecker.writeSignature(signature: Signature, enclosingDeclaration?: Node | undefined, flags?: TypeFormatFlags | undefined, kind?: SignatureKind | undefined, writer?: EmitTextWriter | undefined): string\n *\n * const obj: {\n *   a: number;\n *   b: number;\n *  }\n *\n * function getObj(a: string): {\n *     a: number;\n *     b: number;\n * }\n */\nexport function parseTypeFromQuickInfo(quickInfo: protocol.QuickInfoResponse | undefined): string {\n  if (!quickInfo?.body?.displayString) return '';\n  const displayString = quickInfo.body.displayString;\n  const splitByColon = displayString.split(':');\n  switch (quickInfo.body.kind) {\n    case 'const':\n    case 'property':\n    case 'let':\n    case 'var': {\n      const [, ...tail] = splitByColon;\n      return tail.join(':').trim();\n    }\n    case 'method':\n    case 'function': {\n      const split = displayString.split('): ');\n      if (split.length !== 2) {\n        throw new Error(`quickinfo of a function below was not implemented.\\n${displayString}`);\n      }\n      return split[1].trim();\n    }\n    case 'alias': {\n      // e.g. (alias) class BuilderService\\nimport BuilderService\n      // e.g. '(alias) type Serializable = {\\n' +\n      // '    toString(): string;\\n' +\n      // '}\\n' +\n      // 'import Serializable'\n      const firstLine = displayString.split('\\n')[0];\n      const splitBySpace = firstLine.trim().split(' ');\n      // first two are alias keyword and alias type\n      const [, , typeName] = splitBySpace;\n      return typeName;\n    }\n    case 'type': {\n      // e.g. `type TaskSlot = SlotRegistry<BuildTask[]>`\n      const splitByEqual = displayString.split('=');\n      const [, ...tail] = splitByEqual;\n      return tail.join('=').trim();\n    }\n    default:\n      return splitByColon[splitByColon.length - 1].trim();\n  }\n}\n\nexport function parseReturnTypeFromQuickInfo(quickInfo: protocol.QuickInfoResponse | undefined): string {\n  if (!quickInfo) return '';\n  const typeStr = parseTypeFromQuickInfo(quickInfo);\n  const array = typeStr.split('=>');\n  return array[array.length - 1].trim();\n}\n"],"mappings":";;;;;;;;;;;;;;AAAA;;AAGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASA,sBAAT,CAAgCC,SAAhC,EAA2F;EAAA;;EAChG,IAAI,EAACA,SAAD,aAACA,SAAD,kCAACA,SAAS,CAAEC,IAAZ,4CAAC,gBAAiBC,aAAlB,CAAJ,EAAqC,OAAO,EAAP;EACrC,MAAMA,aAAa,GAAGF,SAAS,CAACC,IAAV,CAAeC,aAArC;EACA,MAAMC,YAAY,GAAGD,aAAa,CAACE,KAAd,CAAoB,GAApB,CAArB;;EACA,QAAQJ,SAAS,CAACC,IAAV,CAAeI,IAAvB;IACE,KAAK,OAAL;IACA,KAAK,UAAL;IACA,KAAK,KAAL;IACA,KAAK,KAAL;MAAY;QACV,MAAM,GAAG,GAAGC,IAAN,IAAcH,YAApB;QACA,OAAOG,IAAI,CAACC,IAAL,CAAU,GAAV,EAAeC,IAAf,EAAP;MACD;;IACD,KAAK,QAAL;IACA,KAAK,UAAL;MAAiB;QACf,MAAMJ,KAAK,GAAGF,aAAa,CAACE,KAAd,CAAoB,KAApB,CAAd;;QACA,IAAIA,KAAK,CAACK,MAAN,KAAiB,CAArB,EAAwB;UACtB,MAAM,IAAIC,KAAJ,CAAW,uDAAsDR,aAAc,EAA/E,CAAN;QACD;;QACD,OAAOE,KAAK,CAAC,CAAD,CAAL,CAASI,IAAT,EAAP;MACD;;IACD,KAAK,OAAL;MAAc;QACZ;QACA;QACA;QACA;QACA;QACA,MAAMG,SAAS,GAAGT,aAAa,CAACE,KAAd,CAAoB,IAApB,EAA0B,CAA1B,CAAlB;QACA,MAAMQ,YAAY,GAAGD,SAAS,CAACH,IAAV,GAAiBJ,KAAjB,CAAuB,GAAvB,CAArB,CAPY,CAQZ;;QACA,MAAM,IAAKS,QAAL,IAAiBD,YAAvB;QACA,OAAOC,QAAP;MACD;;IACD,KAAK,MAAL;MAAa;QACX;QACA,MAAMC,YAAY,GAAGZ,aAAa,CAACE,KAAd,CAAoB,GAApB,CAArB;QACA,MAAM,GAAG,GAAGE,IAAN,IAAcQ,YAApB;QACA,OAAOR,IAAI,CAACC,IAAL,CAAU,GAAV,EAAeC,IAAf,EAAP;MACD;;IACD;MACE,OAAOL,YAAY,CAACA,YAAY,CAACM,MAAb,GAAsB,CAAvB,CAAZ,CAAsCD,IAAtC,EAAP;EAnCJ;AAqCD;;AAEM,SAASO,4BAAT,CAAsCf,SAAtC,EAAiG;EACtG,IAAI,CAACA,SAAL,EAAgB,OAAO,EAAP;EAChB,MAAMgB,OAAO,GAAGjB,sBAAsB,CAACC,SAAD,CAAtC;EACA,MAAMiB,KAAK,GAAGD,OAAO,CAACZ,KAAR,CAAc,IAAd,CAAd;EACA,OAAOa,KAAK,CAACA,KAAK,CAACR,MAAN,GAAe,CAAhB,CAAL,CAAwBD,IAAxB,EAAP;AACD"}
+{"version":3,"names":["UNRESOLVED","parseTypeFromQuickInfo","quickInfo","body","displayString","splitByColon","split","kind","tail","join","trim","length","firstLine","splitBySpace","typeName","splitByEqual","parseReturnTypeFromQuickInfo","typeStr","array"],"sources":["parse-type-from-quick-info.ts"],"sourcesContent":["// eslint-disable-next-line import/no-unresolved\nimport protocol from 'typescript/lib/protocol';\n\nexport const UNRESOLVED = '<<unresolved>>';\n\n/**\n * try to parse the type from the quickinfo.\n * this is an error-prone process, we do our best here.\n *\n * an example of a function with many \":\"\n * `export function getObj(a: string, func: (b: number) => {}) { return { a: 1, b: 2 } };`\n * which produce the following quickinfo:\n * ```ts\n * function getObj(a: string, func: (b: number) => {}): {\n *   a: number;\n *   b: number;\n * }\n * ```\n *\n * some examples of quickinfo:\n *\n * function ts.signatureToDisplayParts(typechecker: TypeChecker, signature: Signature, enclosingDeclaration?: Node | undefined, flags?: TypeFormatFlags): SymbolDisplayPart[]\n *\n * const enum ts.TypeFormatFlags\n *\n * (method) ts.TypeChecker.writeSignature(signature: Signature, enclosingDeclaration?: Node | undefined, flags?: TypeFormatFlags | undefined, kind?: SignatureKind | undefined, writer?: EmitTextWriter | undefined): string\n *\n * const obj: {\n *   a: number;\n *   b: number;\n *  }\n *\n * function getObj(a: string): {\n *     a: number;\n *     b: number;\n * }\n */\nexport function parseTypeFromQuickInfo(quickInfo: protocol.QuickInfoResponse | undefined): string {\n  if (!quickInfo?.body?.displayString) return '';\n  const displayString = quickInfo.body.displayString;\n  const splitByColon = displayString.split(':');\n  switch (quickInfo.body.kind) {\n    case 'const':\n    case 'property':\n    case 'let':\n    case 'var': {\n      const [, ...tail] = splitByColon;\n      return tail.join(':').trim();\n    }\n    case 'method':\n    case 'function': {\n      const split = displayString.split('): ');\n      if (split.length !== 2) {\n        // it's hard to determine where the return-type is. so it's better to show unresolved.\n        // maybe, in the UI, in this case, it's best to show the signature.\n        // e.g.\n        // (method) IssuesList.getIssue<T extends ComponentIssue>(IssueClass: {\n        //   new (): T;\n        // }): T | undefined\n        return UNRESOLVED;\n      }\n      return split[1].trim();\n    }\n    case 'alias': {\n      // e.g. (alias) class BuilderService\\nimport BuilderService\n      // e.g. '(alias) type Serializable = {\\n' +\n      // '    toString(): string;\\n' +\n      // '}\\n' +\n      // 'import Serializable'\n      const firstLine = displayString.split('\\n')[0];\n      const splitBySpace = firstLine.trim().split(' ');\n      // first two are alias keyword and alias type\n      const [, , typeName] = splitBySpace;\n      return typeName;\n    }\n    case 'type': {\n      // e.g. `type TaskSlot = SlotRegistry<BuildTask[]>`\n      const splitByEqual = displayString.split('=');\n      const [, ...tail] = splitByEqual;\n      return tail.join('=').trim();\n    }\n    default:\n      return splitByColon[splitByColon.length - 1].trim();\n  }\n}\n\nexport function parseReturnTypeFromQuickInfo(quickInfo: protocol.QuickInfoResponse | undefined): string {\n  if (!quickInfo) return '';\n  const typeStr = parseTypeFromQuickInfo(quickInfo);\n  const array = typeStr.split('=>');\n  return array[array.length - 1].trim();\n}\n"],"mappings":";;;;;;;;;;;;;;AAAA;AAGO,MAAMA,UAAU,GAAG,gBAAnB;AAEP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;AACO,SAASC,sBAAT,CAAgCC,SAAhC,EAA2F;EAAA;;EAChG,IAAI,EAACA,SAAD,aAACA,SAAD,kCAACA,SAAS,CAAEC,IAAZ,4CAAC,gBAAiBC,aAAlB,CAAJ,EAAqC,OAAO,EAAP;EACrC,MAAMA,aAAa,GAAGF,SAAS,CAACC,IAAV,CAAeC,aAArC;EACA,MAAMC,YAAY,GAAGD,aAAa,CAACE,KAAd,CAAoB,GAApB,CAArB;;EACA,QAAQJ,SAAS,CAACC,IAAV,CAAeI,IAAvB;IACE,KAAK,OAAL;IACA,KAAK,UAAL;IACA,KAAK,KAAL;IACA,KAAK,KAAL;MAAY;QACV,MAAM,GAAG,GAAGC,IAAN,IAAcH,YAApB;QACA,OAAOG,IAAI,CAACC,IAAL,CAAU,GAAV,EAAeC,IAAf,EAAP;MACD;;IACD,KAAK,QAAL;IACA,KAAK,UAAL;MAAiB;QACf,MAAMJ,KAAK,GAAGF,aAAa,CAACE,KAAd,CAAoB,KAApB,CAAd;;QACA,IAAIA,KAAK,CAACK,MAAN,KAAiB,CAArB,EAAwB;UACtB;UACA;UACA;UACA;UACA;UACA;UACA,OAAOX,UAAP;QACD;;QACD,OAAOM,KAAK,CAAC,CAAD,CAAL,CAASI,IAAT,EAAP;MACD;;IACD,KAAK,OAAL;MAAc;QACZ;QACA;QACA;QACA;QACA;QACA,MAAME,SAAS,GAAGR,aAAa,CAACE,KAAd,CAAoB,IAApB,EAA0B,CAA1B,CAAlB;QACA,MAAMO,YAAY,GAAGD,SAAS,CAACF,IAAV,GAAiBJ,KAAjB,CAAuB,GAAvB,CAArB,CAPY,CAQZ;;QACA,MAAM,IAAKQ,QAAL,IAAiBD,YAAvB;QACA,OAAOC,QAAP;MACD;;IACD,KAAK,MAAL;MAAa;QACX;QACA,MAAMC,YAAY,GAAGX,aAAa,CAACE,KAAd,CAAoB,GAApB,CAArB;QACA,MAAM,GAAG,GAAGE,IAAN,IAAcO,YAApB;QACA,OAAOP,IAAI,CAACC,IAAL,CAAU,GAAV,EAAeC,IAAf,EAAP;MACD;;IACD;MACE,OAAOL,YAAY,CAACA,YAAY,CAACM,MAAb,GAAsB,CAAvB,CAAZ,CAAsCD,IAAtC,EAAP;EAzCJ;AA2CD;;AAEM,SAASM,4BAAT,CAAsCd,SAAtC,EAAiG;EACtG,IAAI,CAACA,SAAL,EAAgB,OAAO,EAAP;EAChB,MAAMe,OAAO,GAAGhB,sBAAsB,CAACC,SAAD,CAAtC;EACA,MAAMgB,KAAK,GAAGD,OAAO,CAACX,KAAR,CAAc,IAAd,CAAd;EACA,OAAOY,KAAK,CAACA,KAAK,CAACP,MAAN,GAAe,CAAhB,CAAL,CAAwBD,IAAxB,EAAP;AACD"}

package/dist/transformers/utils/type-node-to-schema.js

@@ -89,19 +89,29 @@ async function typeNodeToSchema(node, context) {
     case _typescript().SyntaxKind.TupleType:
       return tupleType(node, context);
 
+    case _typescript().SyntaxKind.ParenthesizedType:
+      return parenthesizedType(node, context);
+
     case _typescript().SyntaxKind.TypePredicate:
+      return typePredicate(node, context);
+
+    case _typescript().SyntaxKind.IndexedAccessType:
+      return indexedAccessType(node, context);
+
+    case _typescript().SyntaxKind.TemplateLiteralTypeSpan:
+      return templateLiteralTypeSpan(node, context);
+
+    case _typescript().SyntaxKind.TemplateLiteralType:
+      return templateLiteralType(node, context);
+
     case _typescript().SyntaxKind.ConstructorType:
     case _typescript().SyntaxKind.NamedTupleMember:
     case _typescript().SyntaxKind.OptionalType:
     case _typescript().SyntaxKind.RestType:
     case _typescript().SyntaxKind.ConditionalType:
     case _typescript().SyntaxKind.InferType:
-    case _typescript().SyntaxKind.ParenthesizedType:
     case _typescript().SyntaxKind.ThisType:
-    case _typescript().SyntaxKind.IndexedAccessType:
     case _typescript().SyntaxKind.MappedType:
-    case _typescript().SyntaxKind.TemplateLiteralType:
-    case _typescript().SyntaxKind.TemplateLiteralTypeSpan:
     case _typescript().SyntaxKind.ImportType:
     case _typescript().SyntaxKind.ExpressionWithTypeArguments:
     case _typescript().SyntaxKind.JSDocTypeExpression:
@@ -115,11 +125,11 @@ async function typeNodeToSchema(node, context) {
     case _typescript().SyntaxKind.JSDocNamepathType:
     case _typescript().SyntaxKind.JSDocSignature:
     case _typescript().SyntaxKind.JSDocTypeLiteral:
-      throw new Error(`TypeNode "${_typescript().SyntaxKind[node.kind]}" was not implemented yet.
+      throw new Error(`TypeNode ${node.kind} (probably ${_typescript().SyntaxKind[node.kind]}) was not implemented yet.
 context: ${node.getText()}`);
 
     default:
-      throw new Error(`Node "${_typescript().SyntaxKind[node.kind]}" is not a TypeNode.
+      throw new Error(`Node ${node.kind} (probably ${_typescript().SyntaxKind[node.kind]}) is not a TypeNode.
 context: ${node.getText()}`);
   }
 }
@@ -192,6 +202,12 @@ async function typeLiteral(node, context) {
 async function typeReference(node, context) {
   const name = node.typeName.getText();
   const type = await context.resolveType(node, name, false);
+
+  if (node.typeArguments && type instanceof _semanticsEntities().TypeRefSchema) {
+    const args = await (0, _pMapSeries().default)(node.typeArguments, arg => typeNodeToSchema(arg, context));
+    type.typeArgs = args;
+  }
+
   return type;
 }
 
@@ -256,4 +272,34 @@ async function tupleType(node, context) {
   return new (_semanticsEntities().TupleTypeSchema)(context.getLocation(node), elements);
 }
 
+async function parenthesizedType(node, context) {
+  const type = await typeNodeToSchema(node.type, context);
+  return new (_semanticsEntities().ParenthesizedTypeSchema)(context.getLocation(node), type);
+}
+
+async function typePredicate(node, context) {
+  const parameterName = (0, _typescript().isIdentifier)(node.parameterName) ? node.parameterName.getText() : 'this';
+  const type = node.type ? await typeNodeToSchema(node.type, context) : undefined;
+  const hasAssertsModifier = Boolean(node.assertsModifier);
+  return new (_semanticsEntities().TypePredicateSchema)(context.getLocation(node), parameterName, type, hasAssertsModifier);
+}
+
+async function indexedAccessType(node, context) {
+  const objectType = await typeNodeToSchema(node.objectType, context);
+  const indexType = await typeNodeToSchema(node.indexType, context);
+  return new (_semanticsEntities().IndexedAccessSchema)(context.getLocation(node), objectType, indexType);
+}
+
+async function templateLiteralType(node, context) {
+  const templateSpans = await (0, _pMapSeries().default)(node.templateSpans, span => templateLiteralTypeSpan(span, context));
+  const head = node.head.text;
+  return new (_semanticsEntities().TemplateLiteralTypeSchema)(context.getLocation(node), head, templateSpans);
+}
+
+async function templateLiteralTypeSpan(node, context) {
+  const type = await typeNodeToSchema(node.type, context);
+  const literal = node.literal.text;
+  return new (_semanticsEntities().TemplateLiteralTypeSpanSchema)(context.getLocation(node), literal, type);
+}
+
 //# sourceMappingURL=type-node-to-schema.js.map

package/dist/transformers/utils/type-node-to-schema.js.map

@@ -1 +1 @@
-{"version":3,"names":["typeNodeToSchema","node","context","location","getLocation","isKeywordType","KeywordTypeSchema","getText","kind","SyntaxKind","IntersectionType","intersectionType","UnionType","unionType","TypeReference","typeReference","TypeLiteral","typeLiteral","LiteralType","LiteralTypeSchema","FunctionType","functionType","TypeQuery","typeQuery","ArrayType","arrayType","TypeOperator","typeOperator","TupleType","tupleType","TypePredicate","ConstructorType","NamedTupleMember","OptionalType","RestType","ConditionalType","InferType","ParenthesizedType","ThisType","IndexedAccessType","MappedType","TemplateLiteralType","TemplateLiteralTypeSpan","ImportType","ExpressionWithTypeArguments","JSDocTypeExpression","JSDocAllType","JSDocUnknownType","JSDocNonNullableType","JSDocNullableType","JSDocOptionalType","JSDocFunctionType","JSDocVariadicType","JSDocNamepathType","JSDocSignature","JSDocTypeLiteral","Error","AnyKeyword","BigIntKeyword","BooleanKeyword","IntrinsicKeyword","NeverKeyword","NumberKeyword","ObjectKeyword","StringKeyword","SymbolKeyword","UndefinedKeyword","UnknownKeyword","VoidKeyword","types","pMapSeries","type","typeSchema","TypeIntersectionSchema","TypeUnionSchema","members","member","computeSchema","TypeLiteralSchema","name","typeName","resolveType","params","getParams","parameters","returnType","FunctionLikeSchema","displaySig","getQuickInfoDisplayString","exprName","TypeQuerySchema","elementType","TypeArraySchema","operatorName","getOperatorName","operator","TypeOperatorSchema","KeyOfKeyword","UniqueKeyword","ReadonlyKeyword","elements","elem","TupleTypeSchema"],"sources":["type-node-to-schema.ts"],"sourcesContent":["import {\n  TypeNode,\n  SyntaxKind,\n  KeywordTypeNode,\n  FunctionTypeNode,\n  TypeQueryNode,\n  TypeReferenceNode,\n  ArrayTypeNode,\n  TypeOperatorNode,\n  TupleTypeNode,\n  IntersectionTypeNode,\n  UnionTypeNode,\n  TypeLiteralNode,\n} from 'typescript';\nimport {\n  SchemaNode,\n  TypeIntersectionSchema,\n  TypeUnionSchema,\n  TypeLiteralSchema,\n  TypeQuerySchema,\n  LiteralTypeSchema,\n  KeywordTypeSchema,\n  TypeArraySchema,\n  TypeOperatorSchema,\n  TupleTypeSchema,\n  FunctionLikeSchema,\n} from '@teambit/semantics.entities.semantic-schema';\nimport pMapSeries from 'p-map-series';\nimport { SchemaExtractorContext } from '../../schema-extractor-context';\nimport { getParams } from './get-params';\n\n// eslint-disable-next-line complexity\nexport async function typeNodeToSchema(node: TypeNode, context: SchemaExtractorContext): Promise<SchemaNode> {\n  const location = context.getLocation(node);\n  if (isKeywordType(node)) {\n    return new KeywordTypeSchema(location, node.getText());\n  }\n  switch (node.kind) {\n    case SyntaxKind.IntersectionType:\n      return intersectionType(node as IntersectionTypeNode, context);\n    case SyntaxKind.UnionType:\n      return unionType(node as UnionTypeNode, context);\n    case SyntaxKind.TypeReference:\n      return typeReference(node as TypeReferenceNode, context);\n    case SyntaxKind.TypeLiteral:\n      return typeLiteral(node as TypeLiteralNode, context);\n    case SyntaxKind.LiteralType: // e.g. string/boolean\n      return new LiteralTypeSchema(location, node.getText());\n    case SyntaxKind.FunctionType:\n      return functionType(node as FunctionTypeNode, context);\n    case SyntaxKind.TypeQuery:\n      return typeQuery(node as TypeQueryNode, context);\n    case SyntaxKind.ArrayType:\n      return arrayType(node as ArrayTypeNode, context);\n    case SyntaxKind.TypeOperator:\n      return typeOperator(node as TypeOperatorNode, context);\n    case SyntaxKind.TupleType:\n      return tupleType(node as TupleTypeNode, context);\n    case SyntaxKind.TypePredicate:\n    case SyntaxKind.ConstructorType:\n    case SyntaxKind.NamedTupleMember:\n    case SyntaxKind.OptionalType:\n    case SyntaxKind.RestType:\n    case SyntaxKind.ConditionalType:\n    case SyntaxKind.InferType:\n    case SyntaxKind.ParenthesizedType:\n    case SyntaxKind.ThisType:\n    case SyntaxKind.IndexedAccessType:\n    case SyntaxKind.MappedType:\n    case SyntaxKind.TemplateLiteralType:\n    case SyntaxKind.TemplateLiteralTypeSpan:\n    case SyntaxKind.ImportType:\n    case SyntaxKind.ExpressionWithTypeArguments:\n    case SyntaxKind.JSDocTypeExpression:\n    case SyntaxKind.JSDocAllType:\n    case SyntaxKind.JSDocUnknownType:\n    case SyntaxKind.JSDocNonNullableType:\n    case SyntaxKind.JSDocNullableType:\n    case SyntaxKind.JSDocOptionalType:\n    case SyntaxKind.JSDocFunctionType:\n    case SyntaxKind.JSDocVariadicType:\n    case SyntaxKind.JSDocNamepathType:\n    case SyntaxKind.JSDocSignature:\n    case SyntaxKind.JSDocTypeLiteral:\n      throw new Error(`TypeNode \"${SyntaxKind[node.kind]}\" was not implemented yet.\ncontext: ${node.getText()}`);\n    default:\n      throw new Error(`Node \"${SyntaxKind[node.kind]}\" is not a TypeNode.\ncontext: ${node.getText()}`);\n  }\n}\n\n/**\n * whether it's kind of `ts.KeywordTypeSyntaxKind`\n */\nfunction isKeywordType(node: TypeNode): node is KeywordTypeNode {\n  switch (node.kind) {\n    case SyntaxKind.AnyKeyword:\n    case SyntaxKind.BigIntKeyword:\n    case SyntaxKind.BooleanKeyword:\n    case SyntaxKind.IntrinsicKeyword:\n    case SyntaxKind.NeverKeyword:\n    case SyntaxKind.NumberKeyword:\n    case SyntaxKind.ObjectKeyword:\n    case SyntaxKind.StringKeyword:\n    case SyntaxKind.SymbolKeyword:\n    case SyntaxKind.UndefinedKeyword:\n    case SyntaxKind.UnknownKeyword:\n    case SyntaxKind.VoidKeyword:\n      return true;\n    default:\n      return false;\n  }\n}\n\nasync function intersectionType(node: IntersectionTypeNode, context: SchemaExtractorContext) {\n  const types = await pMapSeries(node.types, async (type) => {\n    const typeSchema = await typeNodeToSchema(type, context);\n    return typeSchema;\n  });\n  const location = context.getLocation(node);\n  return new TypeIntersectionSchema(location, types);\n}\n\nasync function unionType(node: UnionTypeNode, context: SchemaExtractorContext) {\n  const types = await pMapSeries(node.types, async (type) => {\n    const typeSchema = await typeNodeToSchema(type, context);\n    return typeSchema;\n  });\n  const location = context.getLocation(node);\n  return new TypeUnionSchema(location, types);\n}\n\n/**\n * not to be confused with \"LiteralType\", which is string/boolean/null.\n * this \"TypeLiteral\" is an object with properties, such as: `{ a: string; b: number }`, similar to Interface.\n */\nasync function typeLiteral(node: TypeLiteralNode, context: SchemaExtractorContext) {\n  const members = await pMapSeries(node.members, async (member) => {\n    const typeSchema = await context.computeSchema(member);\n    return typeSchema;\n  });\n  const location = context.getLocation(node);\n  return new TypeLiteralSchema(location, members);\n}\n\n/**\n * In the following example, `AriaButtonProps` is a type reference\n * ```ts\n * import type { AriaButtonProps } from '@react-types/button';\n * export type ButtonProps = AriaButtonProps & { a: string };\n * ```\n */\nasync function typeReference(node: TypeReferenceNode, context: SchemaExtractorContext) {\n  const name = node.typeName.getText();\n  const type = await context.resolveType(node, name, false);\n  return type;\n}\n\nasync function functionType(node: FunctionTypeNode, context: SchemaExtractorContext): Promise<SchemaNode> {\n  const name = node.name?.getText() || '';\n  const params = await getParams(node.parameters, context);\n  const returnType = await typeNodeToSchema(node.type, context);\n  const location = context.getLocation(node);\n  return new FunctionLikeSchema(location, name, params, returnType, '');\n}\n\n/**\n * e.g. `typeof Foo`\n */\nasync function typeQuery(node: TypeQueryNode, context: SchemaExtractorContext) {\n  const displaySig = await context.getQuickInfoDisplayString(node.exprName);\n  const type = await context.resolveType(node.exprName, node.exprName.getText(), false);\n  const location = context.getLocation(node);\n  return new TypeQuerySchema(location, type, displaySig);\n}\n\nasync function arrayType(node: ArrayTypeNode, context: SchemaExtractorContext) {\n  const type = await typeNodeToSchema(node.elementType, context);\n  const location = context.getLocation(node);\n  return new TypeArraySchema(location, type);\n}\n\n/**\n * e.g. keyof typeof Foo\n */\nasync function typeOperator(node: TypeOperatorNode, context: SchemaExtractorContext) {\n  const operatorName = getOperatorName(node.operator);\n  const type = await typeNodeToSchema(node.type, context);\n  return new TypeOperatorSchema(context.getLocation(node), operatorName, type);\n}\n\nfunction getOperatorName(operator: SyntaxKind.KeyOfKeyword | SyntaxKind.UniqueKeyword | SyntaxKind.ReadonlyKeyword) {\n  switch (operator) {\n    case SyntaxKind.KeyOfKeyword:\n      return 'keyof';\n    case SyntaxKind.UniqueKeyword:\n      return 'unique';\n    case SyntaxKind.ReadonlyKeyword:\n      return 'readonly';\n    default:\n      throw new Error(`getOperatorName: unable to find operator name for ${operator}`);\n  }\n}\n\nasync function tupleType(node: TupleTypeNode, context: SchemaExtractorContext) {\n  const elements = await pMapSeries(node.elements, async (elem) => {\n    const typeSchema = await typeNodeToSchema(elem, context);\n    return typeSchema;\n  });\n  return new TupleTypeSchema(context.getLocation(node), elements);\n}\n"],"mappings":"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"}
+{"version":3,"names":["typeNodeToSchema","node","context","location","getLocation","isKeywordType","KeywordTypeSchema","getText","kind","SyntaxKind","IntersectionType","intersectionType","UnionType","unionType","TypeReference","typeReference","TypeLiteral","typeLiteral","LiteralType","LiteralTypeSchema","FunctionType","functionType","TypeQuery","typeQuery","ArrayType","arrayType","TypeOperator","typeOperator","TupleType","tupleType","ParenthesizedType","parenthesizedType","TypePredicate","typePredicate","IndexedAccessType","indexedAccessType","TemplateLiteralTypeSpan","templateLiteralTypeSpan","TemplateLiteralType","templateLiteralType","ConstructorType","NamedTupleMember","OptionalType","RestType","ConditionalType","InferType","ThisType","MappedType","ImportType","ExpressionWithTypeArguments","JSDocTypeExpression","JSDocAllType","JSDocUnknownType","JSDocNonNullableType","JSDocNullableType","JSDocOptionalType","JSDocFunctionType","JSDocVariadicType","JSDocNamepathType","JSDocSignature","JSDocTypeLiteral","Error","AnyKeyword","BigIntKeyword","BooleanKeyword","IntrinsicKeyword","NeverKeyword","NumberKeyword","ObjectKeyword","StringKeyword","SymbolKeyword","UndefinedKeyword","UnknownKeyword","VoidKeyword","types","pMapSeries","type","typeSchema","TypeIntersectionSchema","TypeUnionSchema","members","member","computeSchema","TypeLiteralSchema","name","typeName","resolveType","typeArguments","TypeRefSchema","args","arg","typeArgs","params","getParams","parameters","returnType","FunctionLikeSchema","displaySig","getQuickInfoDisplayString","exprName","TypeQuerySchema","elementType","TypeArraySchema","operatorName","getOperatorName","operator","TypeOperatorSchema","KeyOfKeyword","UniqueKeyword","ReadonlyKeyword","elements","elem","TupleTypeSchema","ParenthesizedTypeSchema","parameterName","isIdentifier","undefined","hasAssertsModifier","Boolean","assertsModifier","TypePredicateSchema","objectType","indexType","IndexedAccessSchema","templateSpans","span","head","text","TemplateLiteralTypeSchema","literal","TemplateLiteralTypeSpanSchema"],"sources":["type-node-to-schema.ts"],"sourcesContent":["import {\n  TypeNode,\n  SyntaxKind,\n  KeywordTypeNode,\n  FunctionTypeNode,\n  TypeQueryNode,\n  TypeReferenceNode,\n  ArrayTypeNode,\n  TypeOperatorNode,\n  TupleTypeNode,\n  IntersectionTypeNode,\n  UnionTypeNode,\n  TypeLiteralNode,\n  ParenthesizedTypeNode,\n  TypePredicateNode,\n  isIdentifier,\n  IndexedAccessTypeNode,\n  TemplateLiteralTypeNode,\n  TemplateLiteralTypeSpan,\n} from 'typescript';\nimport {\n  SchemaNode,\n  TypeRefSchema,\n  TypeIntersectionSchema,\n  TypeUnionSchema,\n  TypeLiteralSchema,\n  TypeQuerySchema,\n  LiteralTypeSchema,\n  KeywordTypeSchema,\n  TypeArraySchema,\n  TypeOperatorSchema,\n  TupleTypeSchema,\n  FunctionLikeSchema,\n  ParenthesizedTypeSchema,\n  TypePredicateSchema,\n  IndexedAccessSchema,\n  TemplateLiteralTypeSpanSchema,\n  TemplateLiteralTypeSchema,\n} from '@teambit/semantics.entities.semantic-schema';\nimport pMapSeries from 'p-map-series';\nimport { SchemaExtractorContext } from '../../schema-extractor-context';\nimport { getParams } from './get-params';\n\n// eslint-disable-next-line complexity\nexport async function typeNodeToSchema(node: TypeNode, context: SchemaExtractorContext): Promise<SchemaNode> {\n  const location = context.getLocation(node);\n  if (isKeywordType(node)) {\n    return new KeywordTypeSchema(location, node.getText());\n  }\n  switch (node.kind) {\n    case SyntaxKind.IntersectionType:\n      return intersectionType(node as IntersectionTypeNode, context);\n    case SyntaxKind.UnionType:\n      return unionType(node as UnionTypeNode, context);\n    case SyntaxKind.TypeReference:\n      return typeReference(node as TypeReferenceNode, context);\n    case SyntaxKind.TypeLiteral:\n      return typeLiteral(node as TypeLiteralNode, context);\n    case SyntaxKind.LiteralType: // e.g. string/boolean\n      return new LiteralTypeSchema(location, node.getText());\n    case SyntaxKind.FunctionType:\n      return functionType(node as FunctionTypeNode, context);\n    case SyntaxKind.TypeQuery:\n      return typeQuery(node as TypeQueryNode, context);\n    case SyntaxKind.ArrayType:\n      return arrayType(node as ArrayTypeNode, context);\n    case SyntaxKind.TypeOperator:\n      return typeOperator(node as TypeOperatorNode, context);\n    case SyntaxKind.TupleType:\n      return tupleType(node as TupleTypeNode, context);\n    case SyntaxKind.ParenthesizedType:\n      return parenthesizedType(node as ParenthesizedTypeNode, context);\n    case SyntaxKind.TypePredicate:\n      return typePredicate(node as TypePredicateNode, context);\n    case SyntaxKind.IndexedAccessType:\n      return indexedAccessType(node as IndexedAccessTypeNode, context);\n    case SyntaxKind.TemplateLiteralTypeSpan:\n      return templateLiteralTypeSpan(node as TemplateLiteralTypeSpan, context);\n    case SyntaxKind.TemplateLiteralType:\n      return templateLiteralType(node as TemplateLiteralTypeNode, context);\n    case SyntaxKind.ConstructorType:\n    case SyntaxKind.NamedTupleMember:\n    case SyntaxKind.OptionalType:\n    case SyntaxKind.RestType:\n    case SyntaxKind.ConditionalType:\n    case SyntaxKind.InferType:\n    case SyntaxKind.ThisType:\n    case SyntaxKind.MappedType:\n    case SyntaxKind.ImportType:\n    case SyntaxKind.ExpressionWithTypeArguments:\n    case SyntaxKind.JSDocTypeExpression:\n    case SyntaxKind.JSDocAllType:\n    case SyntaxKind.JSDocUnknownType:\n    case SyntaxKind.JSDocNonNullableType:\n    case SyntaxKind.JSDocNullableType:\n    case SyntaxKind.JSDocOptionalType:\n    case SyntaxKind.JSDocFunctionType:\n    case SyntaxKind.JSDocVariadicType:\n    case SyntaxKind.JSDocNamepathType:\n    case SyntaxKind.JSDocSignature:\n    case SyntaxKind.JSDocTypeLiteral:\n      throw new Error(`TypeNode ${node.kind} (probably ${SyntaxKind[node.kind]}) was not implemented yet.\ncontext: ${node.getText()}`);\n    default:\n      throw new Error(`Node ${node.kind} (probably ${SyntaxKind[node.kind]}) is not a TypeNode.\ncontext: ${node.getText()}`);\n  }\n}\n\n/**\n * whether it's kind of `ts.KeywordTypeSyntaxKind`\n */\nfunction isKeywordType(node: TypeNode): node is KeywordTypeNode {\n  switch (node.kind) {\n    case SyntaxKind.AnyKeyword:\n    case SyntaxKind.BigIntKeyword:\n    case SyntaxKind.BooleanKeyword:\n    case SyntaxKind.IntrinsicKeyword:\n    case SyntaxKind.NeverKeyword:\n    case SyntaxKind.NumberKeyword:\n    case SyntaxKind.ObjectKeyword:\n    case SyntaxKind.StringKeyword:\n    case SyntaxKind.SymbolKeyword:\n    case SyntaxKind.UndefinedKeyword:\n    case SyntaxKind.UnknownKeyword:\n    case SyntaxKind.VoidKeyword:\n      return true;\n    default:\n      return false;\n  }\n}\n\nasync function intersectionType(node: IntersectionTypeNode, context: SchemaExtractorContext) {\n  const types = await pMapSeries(node.types, async (type) => {\n    const typeSchema = await typeNodeToSchema(type, context);\n    return typeSchema;\n  });\n  const location = context.getLocation(node);\n  return new TypeIntersectionSchema(location, types);\n}\n\nasync function unionType(node: UnionTypeNode, context: SchemaExtractorContext) {\n  const types = await pMapSeries(node.types, async (type) => {\n    const typeSchema = await typeNodeToSchema(type, context);\n    return typeSchema;\n  });\n  const location = context.getLocation(node);\n  return new TypeUnionSchema(location, types);\n}\n\n/**\n * not to be confused with \"LiteralType\", which is string/boolean/null.\n * this \"TypeLiteral\" is an object with properties, such as: `{ a: string; b: number }`, similar to Interface.\n */\nasync function typeLiteral(node: TypeLiteralNode, context: SchemaExtractorContext) {\n  const members = await pMapSeries(node.members, async (member) => {\n    const typeSchema = await context.computeSchema(member);\n    return typeSchema;\n  });\n  const location = context.getLocation(node);\n  return new TypeLiteralSchema(location, members);\n}\n\n/**\n * In the following example, `AriaButtonProps` is a type reference\n * ```ts\n * import type { AriaButtonProps } from '@react-types/button';\n * export type ButtonProps = AriaButtonProps & { a: string };\n * ```\n */\nasync function typeReference(node: TypeReferenceNode, context: SchemaExtractorContext) {\n  const name = node.typeName.getText();\n  const type = await context.resolveType(node, name, false);\n  if (node.typeArguments && type instanceof TypeRefSchema) {\n    const args = await pMapSeries(node.typeArguments, (arg) => typeNodeToSchema(arg, context));\n    type.typeArgs = args;\n  }\n  return type;\n}\n\nasync function functionType(node: FunctionTypeNode, context: SchemaExtractorContext): Promise<SchemaNode> {\n  const name = node.name?.getText() || '';\n  const params = await getParams(node.parameters, context);\n  const returnType = await typeNodeToSchema(node.type, context);\n  const location = context.getLocation(node);\n  return new FunctionLikeSchema(location, name, params, returnType, '');\n}\n\n/**\n * e.g. `typeof Foo`\n */\nasync function typeQuery(node: TypeQueryNode, context: SchemaExtractorContext) {\n  const displaySig = await context.getQuickInfoDisplayString(node.exprName);\n  const type = await context.resolveType(node.exprName, node.exprName.getText(), false);\n  const location = context.getLocation(node);\n  return new TypeQuerySchema(location, type, displaySig);\n}\n\nasync function arrayType(node: ArrayTypeNode, context: SchemaExtractorContext) {\n  const type = await typeNodeToSchema(node.elementType, context);\n  const location = context.getLocation(node);\n  return new TypeArraySchema(location, type);\n}\n\n/**\n * e.g. keyof typeof Foo\n */\nasync function typeOperator(node: TypeOperatorNode, context: SchemaExtractorContext) {\n  const operatorName = getOperatorName(node.operator);\n  const type = await typeNodeToSchema(node.type, context);\n  return new TypeOperatorSchema(context.getLocation(node), operatorName, type);\n}\n\nfunction getOperatorName(operator: SyntaxKind.KeyOfKeyword | SyntaxKind.UniqueKeyword | SyntaxKind.ReadonlyKeyword) {\n  switch (operator) {\n    case SyntaxKind.KeyOfKeyword:\n      return 'keyof';\n    case SyntaxKind.UniqueKeyword:\n      return 'unique';\n    case SyntaxKind.ReadonlyKeyword:\n      return 'readonly';\n    default:\n      throw new Error(`getOperatorName: unable to find operator name for ${operator}`);\n  }\n}\n\nasync function tupleType(node: TupleTypeNode, context: SchemaExtractorContext) {\n  const elements = await pMapSeries(node.elements, async (elem) => {\n    const typeSchema = await typeNodeToSchema(elem, context);\n    return typeSchema;\n  });\n  return new TupleTypeSchema(context.getLocation(node), elements);\n}\n\nasync function parenthesizedType(node: ParenthesizedTypeNode, context: SchemaExtractorContext) {\n  const type = await typeNodeToSchema(node.type, context);\n  return new ParenthesizedTypeSchema(context.getLocation(node), type);\n}\n\nasync function typePredicate(node: TypePredicateNode, context: SchemaExtractorContext) {\n  const parameterName = isIdentifier(node.parameterName) ? node.parameterName.getText() : 'this';\n  const type = node.type ? await typeNodeToSchema(node.type, context) : undefined;\n  const hasAssertsModifier = Boolean(node.assertsModifier);\n  return new TypePredicateSchema(context.getLocation(node), parameterName, type, hasAssertsModifier);\n}\n\nasync function indexedAccessType(node: IndexedAccessTypeNode, context: SchemaExtractorContext) {\n  const objectType = await typeNodeToSchema(node.objectType, context);\n  const indexType = await typeNodeToSchema(node.indexType, context);\n  return new IndexedAccessSchema(context.getLocation(node), objectType, indexType);\n}\n\nasync function templateLiteralType(node: TemplateLiteralTypeNode, context: SchemaExtractorContext) {\n  const templateSpans = await pMapSeries(node.templateSpans, (span) => templateLiteralTypeSpan(span, context));\n  const head = node.head.text;\n  return new TemplateLiteralTypeSchema(context.getLocation(node), head, templateSpans);\n}\n\nasync function templateLiteralTypeSpan(node: TemplateLiteralTypeSpan, context: SchemaExtractorContext) {\n  const type = await typeNodeToSchema(node.type, context);\n  const literal = node.literal.text;\n  return new TemplateLiteralTypeSpanSchema(context.getLocation(node), literal, type);\n}\n"],"mappings":"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"}

package/dist/typescript.extractor.d.ts

@@ -1,5 +1,7 @@
 import ts, { Node } from 'typescript';
 import { SchemaExtractor } from '@teambit/schema';
+import type { Workspace } from '@teambit/workspace';
+import { DependencyResolverMain } from '@teambit/dependency-resolver';
 import { SchemaNode, APISchema } from '@teambit/semantics.entities.semantic-schema';
 import { Component } from '@teambit/component';
 import { AbstractVinyl } from '@teambit/legacy/dist/consumer/component/sources';
@@ -10,7 +12,9 @@ export declare class TypeScriptExtractor implements SchemaExtractor {
     private schemaTransformerSlot;
     private tsMain;
     private rootPath;
-    constructor(tsconfig: any, schemaTransformerSlot: SchemaTransformerSlot, tsMain: TypescriptMain, rootPath: string);
+    private depResolver;
+    private workspace;
+    constructor(tsconfig: any, schemaTransformerSlot: SchemaTransformerSlot, tsMain: TypescriptMain, rootPath: string, depResolver: DependencyResolverMain, workspace: Workspace | undefined);
     parseSourceFile(file: AbstractVinyl): ts.SourceFile;
     /**
      * extract a component schema.
@@ -18,9 +22,11 @@ export declare class TypeScriptExtractor implements SchemaExtractor {
     extract(component: Component): Promise<APISchema>;
     computeExportedIdentifiers(node: Node, context: SchemaExtractorContext): Promise<import("./export-identifier").ExportIdentifier[]>;
     private createContext;
+    private getComponentDeps;
     private tsserver;
     private getTsServer;
     computeSchema(node: Node, context: SchemaExtractorContext): Promise<SchemaNode>;
+    getComponentIDByPath(file: string): Promise<import("@teambit/component").ComponentID | null | undefined>;
     /**
      * select the correct transformer for a node.
      */

package/dist/typescript.extractor.js

@@ -82,11 +82,13 @@ function _exportList() {
 }
 
 class TypeScriptExtractor {
-  constructor(tsconfig, schemaTransformerSlot, tsMain, rootPath) {
+  constructor(tsconfig, schemaTransformerSlot, tsMain, rootPath, depResolver, workspace) {
     this.tsconfig = tsconfig;
     this.schemaTransformerSlot = schemaTransformerSlot;
     this.tsMain = tsMain;
     this.rootPath = rootPath;
+    this.depResolver = depResolver;
+    this.workspace = workspace;
     (0, _defineProperty2().default)(this, "tsserver", undefined);
   }
 
@@ -102,7 +104,7 @@ class TypeScriptExtractor {
     const tsserver = await this.getTsServer();
     const mainFile = component.mainFile;
     const mainAst = this.parseSourceFile(mainFile);
-    const context = this.createContext(tsserver, component);
+    const context = await this.createContext(tsserver, component);
     const exportNames = await this.computeExportedIdentifiers(mainAst, context);
     context.setExports(new (_exportList().ExportList)(exportNames));
     const moduleSchema = await this.computeSchema(mainAst, context);
@@ -113,13 +115,24 @@ class TypeScriptExtractor {
   }
 
   async computeExportedIdentifiers(node, context) {
-    const transformer = this.getTransformer(node, context.component);
-    if (!transformer || !transformer.getIdentifiers) throw new (_exceptions().TransformerNotFound)(node, context.component);
+    const transformer = this.getTransformer(node, context);
+
+    if (!transformer || !transformer.getIdentifiers) {
+      throw new (_exceptions().TransformerNotFound)(node, context.component, context.getLocation(node));
+    }
+
     return transformer.getIdentifiers(node, context);
   }
 
-  createContext(tsserver, component) {
-    return new (_schemaExtractorContext().SchemaExtractorContext)(tsserver, component, this);
+  async createContext(tsserver, component) {
+    const componentDeps = await this.getComponentDeps(component);
+    return new (_schemaExtractorContext().SchemaExtractorContext)(tsserver, component, this, componentDeps);
+  }
+
+  async getComponentDeps(component) {
+    const deps = await this.depResolver.getDependencies(component);
+    const componentDeps = deps.getComponentDependencies();
+    return componentDeps;
   }
 
   async getTsServer() {
@@ -139,20 +152,28 @@ class TypeScriptExtractor {
   }
 
   async computeSchema(node, context) {
-    const transformer = this.getTransformer(node, context.component); // leave the next line commented out, it is used for debugging
+    const transformer = this.getTransformer(node, context); // leave the next line commented out, it is used for debugging
     // console.log('transformer', transformer.constructor.name, node.getText());
 
     return transformer.transform(node, context);
   }
+
+  async getComponentIDByPath(file) {
+    if (!this.workspace) {
+      return null;
+    }
+
+    return this.workspace.getComponentIdByPath(file);
+  }
   /**
    * select the correct transformer for a node.
    */
 
 
-  getTransformer(node, component) {
+  getTransformer(node, context) {
     const transformers = (0, _lodash().flatten)(this.schemaTransformerSlot.values());
     const transformer = transformers.find(singleTransformer => singleTransformer.predicate(node));
-    if (!transformer) throw new (_exceptions().TransformerNotFound)(node, component);
+    if (!transformer) throw new (_exceptions().TransformerNotFound)(node, context.component, context.getLocation(node));
     return transformer;
   }