@teambit/typescript 0.0.736 → 0.0.739

package/dist/transformers/index.d.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/dist/transformers/index.js

@@ -15,6 +15,12 @@ Object.defineProperty(exports, "Constructor", {
     return _constructor().Constructor;
   }
 });
+Object.defineProperty(exports, "EnumDeclarationTransformer", {
+  enumerable: true,
+  get: function () {
+    return _enumDeclaration().EnumDeclarationTransformer;
+  }
+});
 Object.defineProperty(exports, "ExportDeclaration", {
   enumerable: true,
   get: function () {
@@ -244,4 +250,14 @@ function _methodSignature() {
   return data;
 }
 
+function _enumDeclaration() {
+  const data = require("./enum-declaration");
+
+  _enumDeclaration = function () {
+    return data;
+  };
+
+  return data;
+}
+
 //# sourceMappingURL=index.js.map

package/dist/transformers/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;;AACA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;;AACA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;;AACA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;;AACA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;;AACA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;;AACA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;;AACA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;;AACA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;;AACA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;;AACA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;;AACA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;;AACA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;;AACA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;;AACA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA","sourcesContent":["export { ExportDeclaration } from './export-declaration';\nexport { FunctionDeclaration } from './function-declaration';\nexport { MethodDeclaration } from './method-declaration';\nexport { PropertyDeclaration } from './property-declaration';\nexport { VariableStatementTransformer } from './variable-statement';\nexport { VariableDeclaration } from './variable-declaration';\nexport { SourceFileTransformer } from './source-file-transformer';\nexport { TypeAliasTransformer } from './type-alias';\nexport { ClassDecelerationTransformer } from './class-deceleration';\nexport { Constructor } from './constructor';\nexport { PropertySignature } from './property-signature';\nexport { LiteralTypeTransformer } from './literal-type';\nexport { IndexSignature } from './index-signature';\nexport { InterfaceDeclarationTransformer } from './interface-declaration';\nexport { MethodSignatureTransformer } from './method-signature';\n"]}
+{"version":3,"names":[],"sources":["index.ts"],"sourcesContent":["export { ExportDeclaration } from './export-declaration';\nexport { FunctionDeclaration } from './function-declaration';\nexport { MethodDeclaration } from './method-declaration';\nexport { PropertyDeclaration } from './property-declaration';\nexport { VariableStatementTransformer } from './variable-statement';\nexport { VariableDeclaration } from './variable-declaration';\nexport { SourceFileTransformer } from './source-file-transformer';\nexport { TypeAliasTransformer } from './type-alias';\nexport { ClassDecelerationTransformer } from './class-deceleration';\nexport { Constructor } from './constructor';\nexport { PropertySignature } from './property-signature';\nexport { LiteralTypeTransformer } from './literal-type';\nexport { IndexSignature } from './index-signature';\nexport { InterfaceDeclarationTransformer } from './interface-declaration';\nexport { MethodSignatureTransformer } from './method-signature';\nexport { EnumDeclarationTransformer } from './enum-declaration';\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;EAAA;;EAAA;IAAA;EAAA;;EAAA;AAAA;;AACA;EAAA;;EAAA;IAAA;EAAA;;EAAA;AAAA;;AACA;EAAA;;EAAA;IAAA;EAAA;;EAAA;AAAA;;AACA;EAAA;;EAAA;IAAA;EAAA;;EAAA;AAAA;;AACA;EAAA;;EAAA;IAAA;EAAA;;EAAA;AAAA;;AACA;EAAA;;EAAA;IAAA;EAAA;;EAAA;AAAA;;AACA;EAAA;;EAAA;IAAA;EAAA;;EAAA;AAAA;;AACA;EAAA;;EAAA;IAAA;EAAA;;EAAA;AAAA;;AACA;EAAA;;EAAA;IAAA;EAAA;;EAAA;AAAA;;AACA;EAAA;;EAAA;IAAA;EAAA;;EAAA;AAAA;;AACA;EAAA;;EAAA;IAAA;EAAA;;EAAA;AAAA;;AACA;EAAA;;EAAA;IAAA;EAAA;;EAAA;AAAA;;AACA;EAAA;;EAAA;IAAA;EAAA;;EAAA;AAAA;;AACA;EAAA;;EAAA;IAAA;EAAA;;EAAA;AAAA;;AACA;EAAA;;EAAA;IAAA;EAAA;;EAAA;AAAA;;AACA;EAAA;;EAAA;IAAA;EAAA;;EAAA;AAAA"}

package/dist/transformers/interface-declaration.js

@@ -63,7 +63,7 @@ class InterfaceDeclarationTransformer {
       const typeSchema = await context.computeSchema(member);
       return typeSchema;
     });
-    return new (_semanticsEntities().InterfaceSchema)(interfaceDec.name.getText(), members);
+    return new (_semanticsEntities().InterfaceSchema)(context.getLocation(interfaceDec), interfaceDec.name.getText(), members);
   }
 
 }

package/dist/transformers/interface-declaration.js.map

@@ -1 +1 @@
-{"version":3,"sources":["interface-declaration.ts"],"names":["InterfaceDeclarationTransformer","predicate","node","kind","ts","SyntaxKind","InterfaceDeclaration","getIdentifiers","ExportIdentifier","name","getText","getSourceFile","fileName","transform","interfaceDec","context","members","member","typeSchema","computeSchema","InterfaceSchema"],"mappings":";;;;;;;;;;;AAAA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;;AACA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;;AACA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;;AAGA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;;AAEO,MAAMA,+BAAN,CAAmE;AACxEC,EAAAA,SAAS,CAACC,IAAD,EAAa;AACpB,WAAOA,IAAI,CAACC,IAAL,KAAcC,sBAAGC,UAAH,CAAcC,oBAAnC;AACD;;AAEmB,QAAdC,cAAc,CAACL,IAAD,EAA0D;AAC5E,WAAO,CAAC,KAAIM,oCAAJ,EAAqBN,IAAI,CAACO,IAAL,CAAUC,OAAV,EAArB,EAA0CR,IAAI,CAACS,aAAL,GAAqBC,QAA/D,CAAD,CAAP;AACD;;AAEc,QAATC,SAAS,CAACC,YAAD,EAAqCC,OAArC,EAAsE;AACnF,UAAMC,OAAO,GAAG,MAAM,2BAAWF,YAAY,CAACE,OAAxB,EAAiC,MAAOC,MAAP,IAAkB;AACvE,YAAMC,UAAU,GAAG,MAAMH,OAAO,CAACI,aAAR,CAAsBF,MAAtB,CAAzB;AACA,aAAOC,UAAP;AACD,KAHqB,CAAtB;AAIA,WAAO,KAAIE,oCAAJ,EAAoBN,YAAY,CAACL,IAAb,CAAkBC,OAAlB,EAApB,EAAiDM,OAAjD,CAAP;AACD;;AAfuE","sourcesContent":["import ts, { Node, InterfaceDeclaration } from 'typescript';\nimport pMapSeries from 'p-map-series';\nimport { InterfaceSchema } from '@teambit/semantics.entities.semantic-schema';\nimport { SchemaTransformer } from '../schema-transformer';\nimport { SchemaExtractorContext } from '../schema-extractor-context';\nimport { ExportIdentifier } from '../export-identifier';\n\nexport class InterfaceDeclarationTransformer implements SchemaTransformer {\n  predicate(node: Node) {\n    return node.kind === ts.SyntaxKind.InterfaceDeclaration;\n  }\n\n  async getIdentifiers(node: InterfaceDeclaration): Promise<ExportIdentifier[]> {\n    return [new ExportIdentifier(node.name.getText(), node.getSourceFile().fileName)];\n  }\n\n  async transform(interfaceDec: InterfaceDeclaration, context: SchemaExtractorContext) {\n    const members = await pMapSeries(interfaceDec.members, async (member) => {\n      const typeSchema = await context.computeSchema(member);\n      return typeSchema;\n    });\n    return new InterfaceSchema(interfaceDec.name.getText(), members);\n  }\n}\n"]}
+{"version":3,"names":["InterfaceDeclarationTransformer","predicate","node","kind","ts","SyntaxKind","InterfaceDeclaration","getIdentifiers","ExportIdentifier","name","getText","getSourceFile","fileName","transform","interfaceDec","context","members","pMapSeries","member","typeSchema","computeSchema","InterfaceSchema","getLocation"],"sources":["interface-declaration.ts"],"sourcesContent":["import ts, { Node, InterfaceDeclaration } from 'typescript';\nimport pMapSeries from 'p-map-series';\nimport { InterfaceSchema } from '@teambit/semantics.entities.semantic-schema';\nimport { SchemaTransformer } from '../schema-transformer';\nimport { SchemaExtractorContext } from '../schema-extractor-context';\nimport { ExportIdentifier } from '../export-identifier';\n\nexport class InterfaceDeclarationTransformer implements SchemaTransformer {\n  predicate(node: Node) {\n    return node.kind === ts.SyntaxKind.InterfaceDeclaration;\n  }\n\n  async getIdentifiers(node: InterfaceDeclaration): Promise<ExportIdentifier[]> {\n    return [new ExportIdentifier(node.name.getText(), node.getSourceFile().fileName)];\n  }\n\n  async transform(interfaceDec: InterfaceDeclaration, context: SchemaExtractorContext) {\n    const members = await pMapSeries(interfaceDec.members, async (member) => {\n      const typeSchema = await context.computeSchema(member);\n      return typeSchema;\n    });\n    return new InterfaceSchema(context.getLocation(interfaceDec), interfaceDec.name.getText(), members);\n  }\n}\n"],"mappings":";;;;;;;;;;;AAAA;EAAA;;EAAA;IAAA;EAAA;;EAAA;AAAA;;AACA;EAAA;;EAAA;IAAA;EAAA;;EAAA;AAAA;;AACA;EAAA;;EAAA;IAAA;EAAA;;EAAA;AAAA;;AAGA;EAAA;;EAAA;IAAA;EAAA;;EAAA;AAAA;;AAEO,MAAMA,+BAAN,CAAmE;EACxEC,SAAS,CAACC,IAAD,EAAa;IACpB,OAAOA,IAAI,CAACC,IAAL,KAAcC,qBAAA,CAAGC,UAAH,CAAcC,oBAAnC;EACD;;EAEmB,MAAdC,cAAc,CAACL,IAAD,EAA0D;IAC5E,OAAO,CAAC,KAAIM,oCAAJ,EAAqBN,IAAI,CAACO,IAAL,CAAUC,OAAV,EAArB,EAA0CR,IAAI,CAACS,aAAL,GAAqBC,QAA/D,CAAD,CAAP;EACD;;EAEc,MAATC,SAAS,CAACC,YAAD,EAAqCC,OAArC,EAAsE;IACnF,MAAMC,OAAO,GAAG,MAAM,IAAAC,qBAAA,EAAWH,YAAY,CAACE,OAAxB,EAAiC,MAAOE,MAAP,IAAkB;MACvE,MAAMC,UAAU,GAAG,MAAMJ,OAAO,CAACK,aAAR,CAAsBF,MAAtB,CAAzB;MACA,OAAOC,UAAP;IACD,CAHqB,CAAtB;IAIA,OAAO,KAAIE,oCAAJ,EAAoBN,OAAO,CAACO,WAAR,CAAoBR,YAApB,CAApB,EAAuDA,YAAY,CAACL,IAAb,CAAkBC,OAAlB,EAAvD,EAAoFM,OAApF,CAAP;EACD;;AAfuE"}

package/dist/transformers/literal-type.d.ts

@@ -1,8 +1,9 @@
 import { LiteralTypeNode, Node } from 'typescript';
 import { TypeRefSchema } from '@teambit/semantics.entities.semantic-schema';
 import { SchemaTransformer } from '../schema-transformer';
+import { SchemaExtractorContext } from '../schema-extractor-context';
 export declare class LiteralTypeTransformer implements SchemaTransformer {
     predicate(node: Node): boolean;
     getIdentifiers(): Promise<never[]>;
-    transform(literalType: LiteralTypeNode): Promise<TypeRefSchema>;
+    transform(literalType: LiteralTypeNode, context: SchemaExtractorContext): Promise<TypeRefSchema>;
 }

package/dist/transformers/literal-type.js

@@ -38,9 +38,9 @@ class LiteralTypeTransformer {
     return [];
   }
 
-  async transform(literalType) {
+  async transform(literalType, context) {
     const type = literalType.literal.getText();
-    return new (_semanticsEntities().TypeRefSchema)(type);
+    return new (_semanticsEntities().TypeRefSchema)(context.getLocation(literalType), type);
   }
 
 }

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

@@ -1 +1 @@
-{"version":3,"sources":["literal-type.ts"],"names":["LiteralTypeTransformer","predicate","node","kind","ts","SyntaxKind","LiteralType","getIdentifiers","transform","literalType","type","literal","getText","TypeRefSchema"],"mappings":";;;;;;;;;;;AAAA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;;AACA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;;AAGO,MAAMA,sBAAN,CAA0D;AAC/DC,EAAAA,SAAS,CAACC,IAAD,EAAa;AACpB,WAAOA,IAAI,CAACC,IAAL,KAAcC,sBAAGC,UAAH,CAAcC,WAAnC;AACD;;AAEmB,QAAdC,cAAc,GAAG;AACrB,WAAO,EAAP;AACD;;AAEc,QAATC,SAAS,CAACC,WAAD,EAA+B;AAC5C,UAAMC,IAAI,GAAGD,WAAW,CAACE,OAAZ,CAAoBC,OAApB,EAAb;AACA,WAAO,KAAIC,kCAAJ,EAAkBH,IAAlB,CAAP;AACD;;AAZ8D","sourcesContent":["import ts, { LiteralTypeNode, Node } from 'typescript';\nimport { TypeRefSchema } from '@teambit/semantics.entities.semantic-schema';\nimport { SchemaTransformer } from '../schema-transformer';\n\nexport class LiteralTypeTransformer implements SchemaTransformer {\n  predicate(node: Node) {\n    return node.kind === ts.SyntaxKind.LiteralType;\n  }\n\n  async getIdentifiers() {\n    return [];\n  }\n\n  async transform(literalType: LiteralTypeNode) {\n    const type = literalType.literal.getText();\n    return new TypeRefSchema(type);\n  }\n}\n"]}
+{"version":3,"names":["LiteralTypeTransformer","predicate","node","kind","ts","SyntaxKind","LiteralType","getIdentifiers","transform","literalType","context","type","literal","getText","TypeRefSchema","getLocation"],"sources":["literal-type.ts"],"sourcesContent":["import ts, { LiteralTypeNode, Node } from 'typescript';\nimport { TypeRefSchema } from '@teambit/semantics.entities.semantic-schema';\nimport { SchemaTransformer } from '../schema-transformer';\nimport { SchemaExtractorContext } from '../schema-extractor-context';\n\nexport class LiteralTypeTransformer implements SchemaTransformer {\n  predicate(node: Node) {\n    return node.kind === ts.SyntaxKind.LiteralType;\n  }\n\n  async getIdentifiers() {\n    return [];\n  }\n\n  async transform(literalType: LiteralTypeNode, context: SchemaExtractorContext) {\n    const type = literalType.literal.getText();\n    return new TypeRefSchema(context.getLocation(literalType), type);\n  }\n}\n"],"mappings":";;;;;;;;;;;AAAA;EAAA;;EAAA;IAAA;EAAA;;EAAA;AAAA;;AACA;EAAA;;EAAA;IAAA;EAAA;;EAAA;AAAA;;AAIO,MAAMA,sBAAN,CAA0D;EAC/DC,SAAS,CAACC,IAAD,EAAa;IACpB,OAAOA,IAAI,CAACC,IAAL,KAAcC,qBAAA,CAAGC,UAAH,CAAcC,WAAnC;EACD;;EAEmB,MAAdC,cAAc,GAAG;IACrB,OAAO,EAAP;EACD;;EAEc,MAATC,SAAS,CAACC,WAAD,EAA+BC,OAA/B,EAAgE;IAC7E,MAAMC,IAAI,GAAGF,WAAW,CAACG,OAAZ,CAAoBC,OAApB,EAAb;IACA,OAAO,KAAIC,kCAAJ,EAAkBJ,OAAO,CAACK,WAAR,CAAoBN,WAApB,CAAlB,EAAoDE,IAApD,CAAP;EACD;;AAZ8D"}

package/dist/transformers/method-declaration.js.map

@@ -1 +1 @@
-{"version":3,"sources":["method-declaration.ts"],"names":["MethodDeclaration","predicate","node","kind","ts","SyntaxKind","getIdentifiers","funcDec","ExportIdentifier","getName","getSourceFile","fileName","name","getText","transform","methodDec","context"],"mappings":";;;;;;;;;;;AACA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;;AAGA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;;AACA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;;AAEO,MAAMA,iBAAN,CAAqD;AAC1DC,EAAAA,SAAS,CAACC,IAAD,EAAa;AACpB,WAAOA,IAAI,CAACC,IAAL,KAAcC,sBAAGC,UAAH,CAAcL,iBAAnC;AACD;;AAEmB,QAAdM,cAAc,CAACC,OAAD,EAAiC;AACnD,WAAO,CAAC,KAAIC,oCAAJ,EAAqB,KAAKC,OAAL,CAAaF,OAAb,CAArB,EAA4CA,OAAO,CAACG,aAAR,GAAwBC,QAApE,CAAD,CAAP;AACD;;AAEOF,EAAAA,OAAO,CAACF,OAAD,EAAiC;AAAA;;AAC9C,WAAO,kBAAAA,OAAO,CAACK,IAAR,gEAAcC,OAAd,OAA2B,EAAlC;AACD;;AAEc,QAATC,SAAS,CAACC,SAAD,EAAmCC,OAAnC,EAAyF;AACtG,WAAO,8CAAqBD,SAArB,EAAgCC,OAAhC,CAAP;AACD;;AAfyD","sourcesContent":["import { SchemaNode } from '@teambit/semantics.entities.semantic-schema';\nimport ts, { Node, MethodDeclaration as MethodDeclarationNode } from 'typescript';\nimport { SchemaExtractorContext } from '../schema-extractor-context';\nimport { SchemaTransformer } from '../schema-transformer';\nimport { ExportIdentifier } from '../export-identifier';\nimport { toFunctionLikeSchema } from './utils/to-function-schema';\n\nexport class MethodDeclaration implements SchemaTransformer {\n  predicate(node: Node) {\n    return node.kind === ts.SyntaxKind.MethodDeclaration;\n  }\n\n  async getIdentifiers(funcDec: MethodDeclarationNode) {\n    return [new ExportIdentifier(this.getName(funcDec), funcDec.getSourceFile().fileName)];\n  }\n\n  private getName(funcDec: MethodDeclarationNode) {\n    return funcDec.name?.getText() || '';\n  }\n\n  async transform(methodDec: MethodDeclarationNode, context: SchemaExtractorContext): Promise<SchemaNode> {\n    return toFunctionLikeSchema(methodDec, context);\n  }\n}\n"]}
+{"version":3,"names":["MethodDeclaration","predicate","node","kind","ts","SyntaxKind","getIdentifiers","funcDec","ExportIdentifier","getName","getSourceFile","fileName","name","getText","transform","methodDec","context","toFunctionLikeSchema"],"sources":["method-declaration.ts"],"sourcesContent":["import { SchemaNode } from '@teambit/semantics.entities.semantic-schema';\nimport ts, { Node, MethodDeclaration as MethodDeclarationNode } from 'typescript';\nimport { SchemaExtractorContext } from '../schema-extractor-context';\nimport { SchemaTransformer } from '../schema-transformer';\nimport { ExportIdentifier } from '../export-identifier';\nimport { toFunctionLikeSchema } from './utils/to-function-schema';\n\nexport class MethodDeclaration implements SchemaTransformer {\n  predicate(node: Node) {\n    return node.kind === ts.SyntaxKind.MethodDeclaration;\n  }\n\n  async getIdentifiers(funcDec: MethodDeclarationNode) {\n    return [new ExportIdentifier(this.getName(funcDec), funcDec.getSourceFile().fileName)];\n  }\n\n  private getName(funcDec: MethodDeclarationNode) {\n    return funcDec.name?.getText() || '';\n  }\n\n  async transform(methodDec: MethodDeclarationNode, context: SchemaExtractorContext): Promise<SchemaNode> {\n    return toFunctionLikeSchema(methodDec, context);\n  }\n}\n"],"mappings":";;;;;;;;;;;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;;EAEmB,MAAdM,cAAc,CAACC,OAAD,EAAiC;IACnD,OAAO,CAAC,KAAIC,oCAAJ,EAAqB,KAAKC,OAAL,CAAaF,OAAb,CAArB,EAA4CA,OAAO,CAACG,aAAR,GAAwBC,QAApE,CAAD,CAAP;EACD;;EAEOF,OAAO,CAACF,OAAD,EAAiC;IAAA;;IAC9C,OAAO,kBAAAA,OAAO,CAACK,IAAR,gEAAcC,OAAd,OAA2B,EAAlC;EACD;;EAEc,MAATC,SAAS,CAACC,SAAD,EAAmCC,OAAnC,EAAyF;IACtG,OAAO,IAAAC,wCAAA,EAAqBF,SAArB,EAAgCC,OAAhC,CAAP;EACD;;AAfyD"}

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

@@ -1 +1 @@
-{"version":3,"sources":["method-signature.ts"],"names":["MethodSignatureTransformer","predicate","node","kind","ts","SyntaxKind","MethodSignature","getName","name","getText","getIdentifiers","transform","methodSig","context"],"mappings":";;;;;;;;;;;AACA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;;AAGA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;;AAEO,MAAMA,0BAAN,CAA8D;AACnEC,EAAAA,SAAS,CAACC,IAAD,EAAa;AACpB,WAAOA,IAAI,CAACC,IAAL,KAAcC,sBAAGC,UAAH,CAAcC,eAAnC;AACD;;AAEDC,EAAAA,OAAO,CAACL,IAAD,EAA4B;AACjC,WAAOA,IAAI,CAACM,IAAL,CAAUC,OAAV,EAAP;AACD;;AAEmB,QAAdC,cAAc,GAAG;AACrB,WAAO,EAAP;AACD;;AAEc,QAATC,SAAS,CAACC,SAAD,EAAiCC,OAAjC,EAAuF;AACpG,WAAO,8CAAqBD,SAArB,EAAgCC,OAAhC,CAAP;AACD;;AAfkE","sourcesContent":["import { SchemaNode } from '@teambit/semantics.entities.semantic-schema';\nimport ts, { Node, MethodSignature as MethodSignatureNode } from 'typescript';\nimport { SchemaTransformer } from '../schema-transformer';\nimport { SchemaExtractorContext } from '../schema-extractor-context';\nimport { toFunctionLikeSchema } from './utils/to-function-schema';\n\nexport class MethodSignatureTransformer implements SchemaTransformer {\n  predicate(node: Node) {\n    return node.kind === ts.SyntaxKind.MethodSignature;\n  }\n\n  getName(node: MethodSignatureNode) {\n    return node.name.getText();\n  }\n\n  async getIdentifiers() {\n    return [];\n  }\n\n  async transform(methodSig: MethodSignatureNode, context: SchemaExtractorContext): Promise<SchemaNode> {\n    return toFunctionLikeSchema(methodSig, context);\n  }\n}\n"]}
+{"version":3,"names":["MethodSignatureTransformer","predicate","node","kind","ts","SyntaxKind","MethodSignature","getName","name","getText","getIdentifiers","transform","methodSig","context","toFunctionLikeSchema"],"sources":["method-signature.ts"],"sourcesContent":["import { SchemaNode } from '@teambit/semantics.entities.semantic-schema';\nimport ts, { Node, MethodSignature as MethodSignatureNode } from 'typescript';\nimport { SchemaTransformer } from '../schema-transformer';\nimport { SchemaExtractorContext } from '../schema-extractor-context';\nimport { toFunctionLikeSchema } from './utils/to-function-schema';\n\nexport class MethodSignatureTransformer implements SchemaTransformer {\n  predicate(node: Node) {\n    return node.kind === ts.SyntaxKind.MethodSignature;\n  }\n\n  getName(node: MethodSignatureNode) {\n    return node.name.getText();\n  }\n\n  async getIdentifiers() {\n    return [];\n  }\n\n  async transform(methodSig: MethodSignatureNode, context: SchemaExtractorContext): Promise<SchemaNode> {\n    return toFunctionLikeSchema(methodSig, context);\n  }\n}\n"],"mappings":";;;;;;;;;;;AACA;EAAA;;EAAA;IAAA;EAAA;;EAAA;AAAA;;AAGA;EAAA;;EAAA;IAAA;EAAA;;EAAA;AAAA;;AAEO,MAAMA,0BAAN,CAA8D;EACnEC,SAAS,CAACC,IAAD,EAAa;IACpB,OAAOA,IAAI,CAACC,IAAL,KAAcC,qBAAA,CAAGC,UAAH,CAAcC,eAAnC;EACD;;EAEDC,OAAO,CAACL,IAAD,EAA4B;IACjC,OAAOA,IAAI,CAACM,IAAL,CAAUC,OAAV,EAAP;EACD;;EAEmB,MAAdC,cAAc,GAAG;IACrB,OAAO,EAAP;EACD;;EAEc,MAATC,SAAS,CAACC,SAAD,EAAiCC,OAAjC,EAAuF;IACpG,OAAO,IAAAC,wCAAA,EAAqBF,SAArB,EAAgCC,OAAhC,CAAP;EACD;;AAfkE"}

package/dist/transformers/property-declaration.js

@@ -70,7 +70,7 @@ class PropertyDeclaration {
     const displaySig = info === null || info === void 0 ? void 0 : (_info$body = info.body) === null || _info$body === void 0 ? void 0 : _info$body.displayString;
     const typeStr = (0, _parseTypeFromQuickInfo().parseTypeFromQuickInfo)(info);
     const type = await context.resolveType(propertyDec, typeStr);
-    return new (_semanticsEntities().VariableSchema)(name || '', displaySig || '', type);
+    return new (_semanticsEntities().VariableSchema)(context.getLocation(propertyDec), name, displaySig || '', type);
   }
 
 }

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

@@ -1 +1 @@
-{"version":3,"sources":["property-declaration.ts"],"names":["PropertyDeclaration","predicate","node","kind","ts","SyntaxKind","getName","name","getText","getIdentifiers","ExportIdentifier","getSourceFile","fileName","transform","propertyDec","context","info","getQuickInfo","displaySig","body","displayString","typeStr","type","resolveType","VariableSchema"],"mappings":";;;;;;;;;;;AAAA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;;AACA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;;AAGA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;;AACA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;;AAEO,MAAMA,mBAAN,CAAuD;AAC5DC,EAAAA,SAAS,CAACC,IAAD,EAAa;AACpB,WAAOA,IAAI,CAACC,IAAL,KAAcC,sBAAGC,UAAH,CAAcL,mBAAnC;AACD;;AAEDM,EAAAA,OAAO,CAACJ,IAAD,EAAgC;AACrC,WAAOA,IAAI,CAACK,IAAL,CAAUC,OAAV,EAAP;AACD;;AAEmB,QAAdC,cAAc,CAACP,IAAD,EAAgC;AAClD,WAAO,CAAC,KAAIQ,oCAAJ,EAAqBR,IAAI,CAACK,IAAL,CAAUC,OAAV,EAArB,EAA0CN,IAAI,CAACS,aAAL,GAAqBC,QAA/D,CAAD,CAAP;AACD;;AAEc,QAATC,SAAS,CAACC,WAAD,EAAuCC,OAAvC,EAA6F;AAAA;;AAC1G,UAAMR,IAAI,GAAG,KAAKD,OAAL,CAAaQ,WAAb,CAAb;AACA,UAAME,IAAI,GAAG,MAAMD,OAAO,CAACE,YAAR,CAAqBH,WAAW,CAACP,IAAjC,CAAnB;AACA,UAAMW,UAAU,GAAGF,IAAH,aAAGA,IAAH,qCAAGA,IAAI,CAAEG,IAAT,+CAAG,WAAYC,aAA/B;AACA,UAAMC,OAAO,GAAG,sDAAuBL,IAAvB,CAAhB;AACA,UAAMM,IAAI,GAAG,MAAMP,OAAO,CAACQ,WAAR,CAAoBT,WAApB,EAAiCO,OAAjC,CAAnB;AAEA,WAAO,KAAIG,mCAAJ,EAAmBjB,IAAI,IAAI,EAA3B,EAA+BW,UAAU,IAAI,EAA7C,EAAiDI,IAAjD,CAAP;AACD;;AArB2D","sourcesContent":["import { SchemaNode, VariableSchema } from '@teambit/semantics.entities.semantic-schema';\nimport ts, { Node, PropertyDeclaration as PropertyDeclarationNode } from 'typescript';\nimport { SchemaTransformer } from '../schema-transformer';\nimport { SchemaExtractorContext } from '../schema-extractor-context';\nimport { ExportIdentifier } from '../export-identifier';\nimport { parseTypeFromQuickInfo } from './utils/parse-type-from-quick-info';\n\nexport class PropertyDeclaration implements SchemaTransformer {\n  predicate(node: Node) {\n    return node.kind === ts.SyntaxKind.PropertyDeclaration;\n  }\n\n  getName(node: PropertyDeclarationNode) {\n    return node.name.getText();\n  }\n\n  async getIdentifiers(node: PropertyDeclarationNode) {\n    return [new ExportIdentifier(node.name.getText(), node.getSourceFile().fileName)];\n  }\n\n  async transform(propertyDec: PropertyDeclarationNode, context: SchemaExtractorContext): Promise<SchemaNode> {\n    const name = this.getName(propertyDec);\n    const info = await context.getQuickInfo(propertyDec.name);\n    const displaySig = info?.body?.displayString;\n    const typeStr = parseTypeFromQuickInfo(info);\n    const type = await context.resolveType(propertyDec, typeStr);\n\n    return new VariableSchema(name || '', displaySig || '', type);\n  }\n}\n"]}
+{"version":3,"names":["PropertyDeclaration","predicate","node","kind","ts","SyntaxKind","getName","name","getText","getIdentifiers","ExportIdentifier","getSourceFile","fileName","transform","propertyDec","context","info","getQuickInfo","displaySig","body","displayString","typeStr","parseTypeFromQuickInfo","type","resolveType","VariableSchema","getLocation"],"sources":["property-declaration.ts"],"sourcesContent":["import { SchemaNode, VariableSchema } from '@teambit/semantics.entities.semantic-schema';\nimport ts, { Node, PropertyDeclaration as PropertyDeclarationNode } from 'typescript';\nimport { SchemaTransformer } from '../schema-transformer';\nimport { SchemaExtractorContext } from '../schema-extractor-context';\nimport { ExportIdentifier } from '../export-identifier';\nimport { parseTypeFromQuickInfo } from './utils/parse-type-from-quick-info';\n\nexport class PropertyDeclaration implements SchemaTransformer {\n  predicate(node: Node) {\n    return node.kind === ts.SyntaxKind.PropertyDeclaration;\n  }\n\n  getName(node: PropertyDeclarationNode) {\n    return node.name.getText();\n  }\n\n  async getIdentifiers(node: PropertyDeclarationNode) {\n    return [new ExportIdentifier(node.name.getText(), node.getSourceFile().fileName)];\n  }\n\n  async transform(propertyDec: PropertyDeclarationNode, context: SchemaExtractorContext): Promise<SchemaNode> {\n    const name = this.getName(propertyDec);\n    const info = await context.getQuickInfo(propertyDec.name);\n    const displaySig = info?.body?.displayString;\n    const typeStr = parseTypeFromQuickInfo(info);\n    const type = await context.resolveType(propertyDec, typeStr);\n\n    return new VariableSchema(context.getLocation(propertyDec), 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,mBAAN,CAAuD;EAC5DC,SAAS,CAACC,IAAD,EAAa;IACpB,OAAOA,IAAI,CAACC,IAAL,KAAcC,qBAAA,CAAGC,UAAH,CAAcL,mBAAnC;EACD;;EAEDM,OAAO,CAACJ,IAAD,EAAgC;IACrC,OAAOA,IAAI,CAACK,IAAL,CAAUC,OAAV,EAAP;EACD;;EAEmB,MAAdC,cAAc,CAACP,IAAD,EAAgC;IAClD,OAAO,CAAC,KAAIQ,oCAAJ,EAAqBR,IAAI,CAACK,IAAL,CAAUC,OAAV,EAArB,EAA0CN,IAAI,CAACS,aAAL,GAAqBC,QAA/D,CAAD,CAAP;EACD;;EAEc,MAATC,SAAS,CAACC,WAAD,EAAuCC,OAAvC,EAA6F;IAAA;;IAC1G,MAAMR,IAAI,GAAG,KAAKD,OAAL,CAAaQ,WAAb,CAAb;IACA,MAAME,IAAI,GAAG,MAAMD,OAAO,CAACE,YAAR,CAAqBH,WAAW,CAACP,IAAjC,CAAnB;IACA,MAAMW,UAAU,GAAGF,IAAH,aAAGA,IAAH,qCAAGA,IAAI,CAAEG,IAAT,+CAAG,WAAYC,aAA/B;IACA,MAAMC,OAAO,GAAG,IAAAC,gDAAA,EAAuBN,IAAvB,CAAhB;IACA,MAAMO,IAAI,GAAG,MAAMR,OAAO,CAACS,WAAR,CAAoBV,WAApB,EAAiCO,OAAjC,CAAnB;IAEA,OAAO,KAAII,mCAAJ,EAAmBV,OAAO,CAACW,WAAR,CAAoBZ,WAApB,CAAnB,EAAqDP,IAArD,EAA2DW,UAAU,IAAI,EAAzE,EAA6EK,IAA7E,CAAP;EACD;;AArB2D"}

package/dist/transformers/property-signature.js

@@ -77,7 +77,7 @@ class PropertySignature {
 
     const typeStr = (0, _parseTypeFromQuickInfo().parseTypeFromQuickInfo)(info);
     const type = await context.resolveType(prop, typeStr);
-    return new (_semanticsEntities().VariableSchema)(name, displaySig, type);
+    return new (_semanticsEntities().VariableSchema)(context.getLocation(prop), name, displaySig, type);
   }
 
 }

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

@@ -1 +1 @@
-{"version":3,"sources":["property-signature.ts"],"names":["PropertySignature","predicate","node","kind","ts","SyntaxKind","getName","name","getText","getIdentifiers","transform","prop","context","info","getQuickInfo","displaySig","body","displayString","type","FunctionType","propType","typeStr","resolveType","VariableSchema"],"mappings":";;;;;;;;;;;AAAA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;;AACA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;;AAGA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;;AACA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;;AAEO,MAAMA,iBAAN,CAAqD;AAC1DC,EAAAA,SAAS,CAACC,IAAD,EAAa;AACpB,WAAOA,IAAI,CAACC,IAAL,KAAcC,sBAAGC,UAAH,CAAcL,iBAAnC;AACD;;AAEDM,EAAAA,OAAO,CAACJ,IAAD,EAA8B;AACnC,WAAOA,IAAI,CAACK,IAAL,CAAUC,OAAV,EAAP;AACD;;AAEmB,QAAdC,cAAc,GAAG;AACrB,WAAO,EAAP;AACD;;AAEc,QAATC,SAAS,CAACC,IAAD,EAA8BC,OAA9B,EAAoF;AAAA;;AACjG,UAAML,IAAI,GAAG,KAAKD,OAAL,CAAaK,IAAb,CAAb;AACA,UAAME,IAAI,GAAG,MAAMD,OAAO,CAACE,YAAR,CAAqBH,IAAI,CAACJ,IAA1B,CAAnB;AACA,UAAMQ,UAAU,GAAG,CAAAF,IAAI,SAAJ,IAAAA,IAAI,WAAJ,0BAAAA,IAAI,CAAEG,IAAN,0DAAYC,aAAZ,KAA6B,EAAhD;;AACA,QAAI,eAAAN,IAAI,CAACO,IAAL,0DAAWf,IAAX,MAAoBC,sBAAGC,UAAH,CAAcc,YAAtC,EAAoD;AAClD;AACA,YAAMC,QAAQ,GAAGT,IAAI,CAACO,IAAtB;AACA,aAAO,0CAAiBE,QAAjB,EAA2BR,OAA3B,CAAP;AACD;;AACD,UAAMS,OAAO,GAAG,sDAAuBR,IAAvB,CAAhB;AACA,UAAMK,IAAI,GAAG,MAAMN,OAAO,CAACU,WAAR,CAAoBX,IAApB,EAA0BU,OAA1B,CAAnB;AACA,WAAO,KAAIE,mCAAJ,EAAmBhB,IAAnB,EAAyBQ,UAAzB,EAAqCG,IAArC,CAAP;AACD;;AAzByD","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(name, displaySig, type);\n  }\n}\n"]}
+{"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"}

package/dist/transformers/source-file-transformer.js

@@ -74,7 +74,7 @@ class SourceFileTransformer {
     const schemas = await (0, _pMapSeries().default)(exports, exportNode => {
       return context.computeSchema(exportNode);
     });
-    return new (_semanticsEntities().Module)(schemas);
+    return new (_semanticsEntities().Module)(context.getLocation(node), schemas);
   }
   /**
    * list all exports of a source file.

package/dist/transformers/source-file-transformer.js.map

@@ -1 +1 @@
-{"version":3,"sources":["source-file-transformer.ts"],"names":["SourceFileTransformer","predicate","node","kind","ts","SyntaxKind","SourceFile","getIdentifiers","sourceFile","context","exports","listExports","exportNames","Promise","all","map","getExportedIdentifiers","exportIds","reduce","acc","current","item","find","exportName","id","push","transform","schemas","exportNode","computeSchema","Module","ast","statements","statement","ExportDeclaration","isExport","Boolean","modifiers","modifier","ExportKeyword"],"mappings":";;;;;;;;;;;;;AAAA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;;AACA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;;AACA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;;AACA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;;AAKO,MAAMA,qBAAN,CAAyD;AAC9DC,EAAAA,SAAS,CAACC,IAAD,EAAa;AACpB,WAAOA,IAAI,CAACC,IAAL,KAAcC,sBAAGC,UAAH,CAAcC,UAAnC;AACD;;AAEmB,QAAdC,cAAc,CAACC,UAAD,EAAyBC,OAAzB,EAA0D;AAC5E,UAAMC,OAAO,GAAG,KAAKC,WAAL,CAAiBH,UAAjB,CAAhB;AAEA,UAAMI,WAAW,GAAG,MAAMC,OAAO,CAACC,GAAR,CACxBJ,OAAO,CAACK,GAAR,CAAab,IAAD,IAAgB;AAC1B,aAAOO,OAAO,CAACO,sBAAR,CAA+Bd,IAA/B,CAAP;AACD,KAFD,CADwB,CAA1B;AAMA,UAAMe,SAAS,GAAG,uBAAQL,WAAR,EAAqBM,MAArB,CAAgD,CAACC,GAAD,EAAMC,OAAN,KAAkB;AAClF,YAAMC,IAAI,GAAGF,GAAG,CAACG,IAAJ,CAAUC,UAAD,IAAgBA,UAAU,CAACC,EAAX,KAAkBJ,OAAO,CAACI,EAAnD,CAAb;AACA,UAAI,CAACH,IAAL,EAAWF,GAAG,CAACM,IAAJ,CAASL,OAAT;AACX,aAAOD,GAAP;AACD,KAJiB,EAIf,EAJe,CAAlB;AAMA,WAAOF,SAAP;AACD;;AAEc,QAATS,SAAS,CAACxB,IAAD,EAAmBO,OAAnB,EAAoD;AACjE,UAAMC,OAAO,GAAG,KAAKC,WAAL,CAAiBT,IAAjB,CAAhB;AACA,UAAMyB,OAAO,GAAG,MAAM,2BAAWjB,OAAX,EAAqBkB,UAAD,IAAgB;AACxD,aAAOnB,OAAO,CAACoB,aAAR,CAAsBD,UAAtB,CAAP;AACD,KAFqB,CAAtB;AAIA,WAAO,KAAIE,2BAAJ,EAAWH,OAAX,CAAP;AACD;AAED;AACF;AACA;;;AACUhB,EAAAA,WAAW,CAACoB,GAAD,EAA0B;AAC3C,WAAO,uBACLA,GAAG,CAACC,UAAJ,CAAejB,GAAf,CAAoBkB,SAAD,IAAe;AAAA;;AAChC,UAAIA,SAAS,CAAC9B,IAAV,KAAmBC,sBAAGC,UAAH,CAAc6B,iBAArC,EAAwD,OAAOD,SAAP;AACxD,YAAME,QAAQ,GAAGC,OAAO,yBACtBH,SAAS,CAACI,SADY,yDACtB,qBAAqBf,IAArB,CAA2BgB,QAAD,IAAc;AACtC,eAAOA,QAAQ,CAACnC,IAAT,KAAkBC,sBAAGC,UAAH,CAAckC,aAAvC;AACD,OAFD,CADsB,CAAxB,CAFgC,CAQhC;;AACA,UAAI,CAACJ,QAAL,EAAe;AACf,aAAOF,SAAP;AACD,KAXD,CADK,CAAP;AAcD;;AAlD6D","sourcesContent":["import ts, { Node, SourceFile } from 'typescript';\nimport { compact, flatten } from 'lodash';\nimport pMapSeries from 'p-map-series';\nimport { Module } from '@teambit/semantics.entities.semantic-schema';\nimport { SchemaTransformer } from '../schema-transformer';\nimport { ExportIdentifier } from '../export-identifier';\nimport { SchemaExtractorContext } from '../schema-extractor-context';\n\nexport class SourceFileTransformer implements SchemaTransformer {\n  predicate(node: Node) {\n    return node.kind === ts.SyntaxKind.SourceFile;\n  }\n\n  async getIdentifiers(sourceFile: SourceFile, context: SchemaExtractorContext) {\n    const exports = this.listExports(sourceFile);\n\n    const exportNames = await Promise.all(\n      exports.map((node: Node) => {\n        return context.getExportedIdentifiers(node);\n      })\n    );\n\n    const exportIds = flatten(exportNames).reduce<ExportIdentifier[]>((acc, current) => {\n      const item = acc.find((exportName) => exportName.id === current.id);\n      if (!item) acc.push(current);\n      return acc;\n    }, []);\n\n    return exportIds;\n  }\n\n  async transform(node: SourceFile, context: SchemaExtractorContext) {\n    const exports = this.listExports(node);\n    const schemas = await pMapSeries(exports, (exportNode) => {\n      return context.computeSchema(exportNode);\n    });\n\n    return new Module(schemas);\n  }\n\n  /**\n   * list all exports of a source file.\n   */\n  private listExports(ast: SourceFile): Node[] {\n    return compact(\n      ast.statements.map((statement) => {\n        if (statement.kind === ts.SyntaxKind.ExportDeclaration) return statement;\n        const isExport = Boolean(\n          statement.modifiers?.find((modifier) => {\n            return modifier.kind === ts.SyntaxKind.ExportKeyword;\n          })\n        );\n\n        // eslint-disable-next-line consistent-return\n        if (!isExport) return;\n        return statement;\n      })\n    );\n  }\n}\n"]}
+{"version":3,"names":["SourceFileTransformer","predicate","node","kind","ts","SyntaxKind","SourceFile","getIdentifiers","sourceFile","context","exports","listExports","exportNames","Promise","all","map","getExportedIdentifiers","exportIds","flatten","reduce","acc","current","item","find","exportName","id","push","transform","schemas","pMapSeries","exportNode","computeSchema","Module","getLocation","ast","compact","statements","statement","ExportDeclaration","isExport","Boolean","modifiers","modifier","ExportKeyword"],"sources":["source-file-transformer.ts"],"sourcesContent":["import ts, { Node, SourceFile } from 'typescript';\nimport { compact, flatten } from 'lodash';\nimport pMapSeries from 'p-map-series';\nimport { Module } from '@teambit/semantics.entities.semantic-schema';\nimport { SchemaTransformer } from '../schema-transformer';\nimport { ExportIdentifier } from '../export-identifier';\nimport { SchemaExtractorContext } from '../schema-extractor-context';\n\nexport class SourceFileTransformer implements SchemaTransformer {\n  predicate(node: Node) {\n    return node.kind === ts.SyntaxKind.SourceFile;\n  }\n\n  async getIdentifiers(sourceFile: SourceFile, context: SchemaExtractorContext) {\n    const exports = this.listExports(sourceFile);\n\n    const exportNames = await Promise.all(\n      exports.map((node: Node) => {\n        return context.getExportedIdentifiers(node);\n      })\n    );\n\n    const exportIds = flatten(exportNames).reduce<ExportIdentifier[]>((acc, current) => {\n      const item = acc.find((exportName) => exportName.id === current.id);\n      if (!item) acc.push(current);\n      return acc;\n    }, []);\n\n    return exportIds;\n  }\n\n  async transform(node: SourceFile, context: SchemaExtractorContext) {\n    const exports = this.listExports(node);\n    const schemas = await pMapSeries(exports, (exportNode) => {\n      return context.computeSchema(exportNode);\n    });\n\n    return new Module(context.getLocation(node), schemas);\n  }\n\n  /**\n   * list all exports of a source file.\n   */\n  private listExports(ast: SourceFile): Node[] {\n    return compact(\n      ast.statements.map((statement) => {\n        if (statement.kind === ts.SyntaxKind.ExportDeclaration) return statement;\n        const isExport = Boolean(\n          statement.modifiers?.find((modifier) => {\n            return modifier.kind === ts.SyntaxKind.ExportKeyword;\n          })\n        );\n\n        // eslint-disable-next-line consistent-return\n        if (!isExport) return;\n        return statement;\n      })\n    );\n  }\n}\n"],"mappings":";;;;;;;;;;;;;AAAA;EAAA;;EAAA;IAAA;EAAA;;EAAA;AAAA;;AACA;EAAA;;EAAA;IAAA;EAAA;;EAAA;AAAA;;AACA;EAAA;;EAAA;IAAA;EAAA;;EAAA;AAAA;;AACA;EAAA;;EAAA;IAAA;EAAA;;EAAA;AAAA;;AAKO,MAAMA,qBAAN,CAAyD;EAC9DC,SAAS,CAACC,IAAD,EAAa;IACpB,OAAOA,IAAI,CAACC,IAAL,KAAcC,qBAAA,CAAGC,UAAH,CAAcC,UAAnC;EACD;;EAEmB,MAAdC,cAAc,CAACC,UAAD,EAAyBC,OAAzB,EAA0D;IAC5E,MAAMC,OAAO,GAAG,KAAKC,WAAL,CAAiBH,UAAjB,CAAhB;IAEA,MAAMI,WAAW,GAAG,MAAMC,OAAO,CAACC,GAAR,CACxBJ,OAAO,CAACK,GAAR,CAAab,IAAD,IAAgB;MAC1B,OAAOO,OAAO,CAACO,sBAAR,CAA+Bd,IAA/B,CAAP;IACD,CAFD,CADwB,CAA1B;IAMA,MAAMe,SAAS,GAAG,IAAAC,iBAAA,EAAQN,WAAR,EAAqBO,MAArB,CAAgD,CAACC,GAAD,EAAMC,OAAN,KAAkB;MAClF,MAAMC,IAAI,GAAGF,GAAG,CAACG,IAAJ,CAAUC,UAAD,IAAgBA,UAAU,CAACC,EAAX,KAAkBJ,OAAO,CAACI,EAAnD,CAAb;MACA,IAAI,CAACH,IAAL,EAAWF,GAAG,CAACM,IAAJ,CAASL,OAAT;MACX,OAAOD,GAAP;IACD,CAJiB,EAIf,EAJe,CAAlB;IAMA,OAAOH,SAAP;EACD;;EAEc,MAATU,SAAS,CAACzB,IAAD,EAAmBO,OAAnB,EAAoD;IACjE,MAAMC,OAAO,GAAG,KAAKC,WAAL,CAAiBT,IAAjB,CAAhB;IACA,MAAM0B,OAAO,GAAG,MAAM,IAAAC,qBAAA,EAAWnB,OAAX,EAAqBoB,UAAD,IAAgB;MACxD,OAAOrB,OAAO,CAACsB,aAAR,CAAsBD,UAAtB,CAAP;IACD,CAFqB,CAAtB;IAIA,OAAO,KAAIE,2BAAJ,EAAWvB,OAAO,CAACwB,WAAR,CAAoB/B,IAApB,CAAX,EAAsC0B,OAAtC,CAAP;EACD;EAED;AACF;AACA;;;EACUjB,WAAW,CAACuB,GAAD,EAA0B;IAC3C,OAAO,IAAAC,iBAAA,EACLD,GAAG,CAACE,UAAJ,CAAerB,GAAf,CAAoBsB,SAAD,IAAe;MAAA;;MAChC,IAAIA,SAAS,CAAClC,IAAV,KAAmBC,qBAAA,CAAGC,UAAH,CAAciC,iBAArC,EAAwD,OAAOD,SAAP;MACxD,MAAME,QAAQ,GAAGC,OAAO,yBACtBH,SAAS,CAACI,SADY,yDACtB,qBAAqBlB,IAArB,CAA2BmB,QAAD,IAAc;QACtC,OAAOA,QAAQ,CAACvC,IAAT,KAAkBC,qBAAA,CAAGC,UAAH,CAAcsC,aAAvC;MACD,CAFD,CADsB,CAAxB,CAFgC,CAQhC;;MACA,IAAI,CAACJ,QAAL,EAAe;MACf,OAAOF,SAAP;IACD,CAXD,CADK,CAAP;EAcD;;AAlD6D"}

package/dist/transformers/type-alias.js

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

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

@@ -1 +1 @@
-{"version":3,"sources":["type-alias.ts"],"names":["TypeAliasTransformer","predicate","node","kind","ts","SyntaxKind","TypeAliasDeclaration","getIdentifiers","ExportIdentifier","name","getText","getSourceFile","fileName","getName","transform","typeAlias","context","type","info","getQuickInfo","displaySig","body","displayString","TypeSchema"],"mappings":";;;;;;;;;;;AAAA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;;AACA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;;AAGA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;;AACA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;;AAEO,MAAMA,oBAAN,CAAwD;AAC7DC,EAAAA,SAAS,CAACC,IAAD,EAAa;AACpB,WAAOA,IAAI,CAACC,IAAL,KAAcC,sBAAGC,UAAH,CAAcC,oBAAnC;AACD;;AAEmB,QAAdC,cAAc,CAACL,IAAD,EAA6B;AAC/C,WAAO,CAAC,KAAIM,oCAAJ,EAAqBN,IAAI,CAACO,IAAL,CAAUC,OAAV,EAArB,EAA0CR,IAAI,CAACS,aAAL,GAAqBC,QAA/D,CAAD,CAAP;AACD;;AAEOC,EAAAA,OAAO,CAACX,IAAD,EAAqC;AAClD,WAAOA,IAAI,CAACO,IAAL,CAAUC,OAAV,EAAP;AACD;;AAEc,QAATI,SAAS,CAACC,SAAD,EAAkCC,OAAlC,EAAmE;AAAA;;AAChF,UAAMC,IAAI,GAAG,MAAM,0CAAiBF,SAAS,CAACE,IAA3B,EAAiCD,OAAjC,CAAnB;AACA,UAAME,IAAI,GAAG,MAAMF,OAAO,CAACG,YAAR,CAAqBJ,SAAS,CAACN,IAA/B,CAAnB;AACA,UAAMW,UAAU,GAAGF,IAAH,aAAGA,IAAH,qCAAGA,IAAI,CAAEG,IAAT,+CAAG,WAAYC,aAA/B;AACA,WAAO,KAAIC,+BAAJ,EAAe,KAAKV,OAAL,CAAaE,SAAb,CAAf,EAAwCE,IAAxC,EAA8CG,UAA9C,CAAP;AACD;;AAlB4D","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(this.getName(typeAlias), type, displaySig as string);\n  }\n}\n"]}
+{"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"}

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,19 +61,59 @@ function _typeNodeToSchema() {
 
 async function getParams(parameterNodes, context) {
   return (0, _pMapSeries().default)(parameterNodes, async param => {
-    return new (_semanticsEntities().ParameterSchema)(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);
   });
 }
 
+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) {
     const type = param.type;
     return (0, _typeNodeToSchema().typeNodeToSchema)(type, context);
   }
 
-  const info = await context.getQuickInfo(param.name);
-  const parsed = (0, _parseTypeFromQuickInfo().parseTypeFromQuickInfo)(info);
-  return new (_semanticsEntities().TypeRefSchema)(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,"sources":["get-params.ts"],"names":["getParams","parameterNodes","context","param","ParameterSchema","name","getText","getParamType","initializer","undefined","type","info","getQuickInfo","parsed","TypeRefSchema"],"mappings":";;;;;;;;;;;AAAA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;;AACA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;;AAGA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;;AACA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;;AAEO,eAAeA,SAAf,CACLC,cADK,EAELC,OAFK,EAGuB;AAC5B,SAAO,2BAAWD,cAAX,EAA2B,MAAOE,KAAP,IAAiB;AACjD,WAAO,KAAIC,oCAAJ,EACLD,KAAK,CAACE,IAAN,CAAWC,OAAX,EADK,EAEL,MAAMC,YAAY,CAACJ,KAAD,EAAQD,OAAR,CAFb,EAGLC,KAAK,CAACK,WAAN,GAAoBL,KAAK,CAACK,WAAN,CAAkBF,OAAlB,EAApB,GAAkDG,SAH7C,CAAP;AAKD,GANM,CAAP;AAOD;;AAED,eAAeF,YAAf,CAA4BJ,KAA5B,EAAyDD,OAAzD,EAA+G;AAC7G,MAAIC,KAAK,CAACO,IAAV,EAAgB;AACd,UAAMA,IAAI,GAAGP,KAAK,CAACO,IAAnB;AACA,WAAO,0CAAiBA,IAAjB,EAAuBR,OAAvB,CAAP;AACD;;AACD,QAAMS,IAAI,GAAG,MAAMT,OAAO,CAACU,YAAR,CAAqBT,KAAK,CAACE,IAA3B,CAAnB;AACA,QAAMQ,MAAM,GAAG,sDAAuBF,IAAvB,CAAf;AACA,SAAO,KAAIG,kCAAJ,EAAkBD,MAAM,IAAI,KAA5B,CAAP;AACD","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      param.name.getText(),\n      await getParamType(param, context),\n      param.initializer ? param.initializer.getText() : undefined\n    );\n  });\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  const info = await context.getQuickInfo(param.name);\n  const parsed = parseTypeFromQuickInfo(info);\n  return new TypeRefSchema(parsed || 'any');\n}\n"]}
+{"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":";;;;;;;;;;;AAAA;EAAA;;EAAA;IAAA;EAAA;;EAAA;AAAA;;AAOA;EAAA;;EAAA;IAAA;EAAA;;EAAA;AAAA;;AACA;EAAA;;EAAA;IAAA;EAAA;;EAAA;AAAA;;AASA;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,EAELG,YAAY,CAACH,KAAD,CAFP,EAGL,MAAMI,YAAY,CAACJ,KAAD,EAAQF,OAAR,CAHb,EAILE,KAAK,CAACK,WAAN,GAAoBL,KAAK,CAACK,WAAN,CAAkBC,OAAlB,EAApB,GAAkDC,SAJ7C,CAAP;EAMD,CAPM,CAAP;AAQD;;AAED,SAASJ,YAAT,CAAsBH,KAAtB,EAA2D;EACzD,IAAI,IAAAQ,0BAAA,EAAaR,KAAK,CAACS,IAAnB,CAAJ,EAA8B;IAC5B,OAAOT,KAAK,CAACS,IAAN,CAAWH,OAAX,EAAP;EACD,CAHwD,CAIzD;;;EACA,MAAMI,QAAQ,GAAGV,KAAK,CAACS,IAAN,CAAWC,QAAX,CAAoBC,GAApB,CAAyBC,IAAD,IAAUA,IAAI,CAACN,OAAL,EAAlC,CAAjB;EACA,MAAMO,WAAW,GAAGH,QAAQ,CAACI,IAAT,CAAc,IAAd,CAApB;;EACA,IAAId,KAAK,CAACS,IAAN,CAAWM,IAAX,KAAoBC,wBAAA,CAAWC,mBAAnC,EAAwD;IACtD,OAAQ,KAAIJ,WAAY,IAAxB;EACD,CATwD,CAUzD;;;EACA,OAAQ,KAAIA,WAAY,IAAxB;AACD;;AAED,eAAeT,YAAf,CAA4BJ,KAA5B,EAAyDF,OAAzD,EAA+G;EAC7G,IAAIE,KAAK,CAACkB,IAAV,EAAgB;IACd,MAAMA,IAAI,GAAGlB,KAAK,CAACkB,IAAnB;IACA,OAAO,IAAAC,oCAAA,EAAiBD,IAAjB,EAAuBpB,OAAvB,CAAP;EACD;;EACD,IAAI,IAAAU,0BAAA,EAAaR,KAAK,CAACS,IAAnB,CAAJ,EAA8B;IAC5B,MAAMW,IAAI,GAAG,MAAMtB,OAAO,CAACuB,YAAR,CAAqBrB,KAAK,CAACS,IAA3B,CAAnB;IACA,MAAMa,MAAM,GAAG,IAAAC,gDAAA,EAAuBH,IAAvB,CAAf;IACA,OAAO,KAAII,wCAAJ,EAAwB1B,OAAO,CAACI,WAAR,CAAoBF,KAApB,CAAxB,EAAoDsB,MAApD,CAAP;EACD,CAT4G,CAU7G;;;EACA,IAAItB,KAAK,CAACS,IAAN,CAAWM,IAAX,KAAoBC,wBAAA,CAAWC,mBAAnC,EAAwD;IACtD,MAAMP,QAAQ,GAAG,MAAM,IAAAX,qBAAA,EAAWC,KAAK,CAACS,IAAN,CAAWC,QAAtB,EAAgC,MAAOE,IAAP,IAAqC;MAC1F,MAAMQ,IAAI,GAAG,MAAMtB,OAAO,CAACuB,YAAR,CAAqBT,IAArB,CAAnB;MACA,MAAMU,MAAM,GAAG,IAAAC,gDAAA,EAAuBH,IAAvB,CAAf;MACA,OAAO,KAAII,wCAAJ,EAAwB1B,OAAO,CAACI,WAAR,CAAoBF,KAApB,CAAxB,EAAoDsB,MAApD,CAAP;IACD,CAJsB,CAAvB;IAKA,OAAO,KAAIG,oCAAJ,EAAoB3B,OAAO,CAACI,WAAR,CAAoBF,KAApB,CAApB,EAAgDU,QAAhD,CAAP;EACD;;EACD,IAAIV,KAAK,CAACS,IAAN,CAAWM,IAAX,KAAoBC,wBAAA,CAAWU,oBAAnC,EAAyD;IACvD,MAAMhB,QAAQ,GAAG,MAAM,IAAAX,qBAAA,EAAWC,KAAK,CAACS,IAAN,CAAWC,QAAtB,EAAgC,MAAOE,IAAP,IAAgC;MACrF,MAAMQ,IAAI,GAAG,MAAMtB,OAAO,CAACuB,YAAR,CAAqBT,IAAI,CAACH,IAA1B,CAAnB;MACA,MAAMa,MAAM,GAAG,IAAAC,gDAAA,EAAuBH,IAAvB,CAAf;MACA,OAAO,KAAII,wCAAJ,EAAwB1B,OAAO,CAACI,WAAR,CAAoBF,KAApB,CAAxB,EAAoDsB,MAApD,EAA4DV,IAAI,CAACH,IAAL,CAAUH,OAAV,EAA5D,CAAP;IACD,CAJsB,CAAvB;IAKA,OAAO,KAAIqB,sCAAJ,EAAsB7B,OAAO,CAACI,WAAR,CAAoBF,KAApB,CAAtB,EAAkDU,QAAlD,CAAP;EACD;;EACD,MAAM,IAAIkB,KAAJ,CAAW,oBAAX,CAAN;AACD"}

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,"sources":["parse-type-from-quick-info.ts"],"names":["parseTypeFromQuickInfo","quickInfo","body","displayString","splitByColon","split","kind","tail","join","trim","length","Error","firstLine","splitBySpace","typeName","splitByEqual","parseReturnTypeFromQuickInfo","typeStr","array"],"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;AAAA;;AAChG,MAAI,EAACA,SAAD,aAACA,SAAD,kCAACA,SAAS,CAAEC,IAAZ,4CAAC,gBAAiBC,aAAlB,CAAJ,EAAqC,OAAO,EAAP;AACrC,QAAMA,aAAa,GAAGF,SAAS,CAACC,IAAV,CAAeC,aAArC;AACA,QAAMC,YAAY,GAAGD,aAAa,CAACE,KAAd,CAAoB,GAApB,CAArB;;AACA,UAAQJ,SAAS,CAACC,IAAV,CAAeI,IAAvB;AACE,SAAK,OAAL;AACA,SAAK,UAAL;AACA,SAAK,KAAL;AACA,SAAK,KAAL;AAAY;AACV,cAAM,GAAG,GAAGC,IAAN,IAAcH,YAApB;AACA,eAAOG,IAAI,CAACC,IAAL,CAAU,GAAV,EAAeC,IAAf,EAAP;AACD;;AACD,SAAK,QAAL;AACA,SAAK,UAAL;AAAiB;AACf,cAAMJ,KAAK,GAAGF,aAAa,CAACE,KAAd,CAAoB,KAApB,CAAd;;AACA,YAAIA,KAAK,CAACK,MAAN,KAAiB,CAArB,EAAwB;AACtB,gBAAM,IAAIC,KAAJ,CAAW,uDAAsDR,aAAc,EAA/E,CAAN;AACD;;AACD,eAAOE,KAAK,CAAC,CAAD,CAAL,CAASI,IAAT,EAAP;AACD;;AACD,SAAK,OAAL;AAAc;AACZ;AACA;AACA;AACA;AACA;AACA,cAAMG,SAAS,GAAGT,aAAa,CAACE,KAAd,CAAoB,IAApB,EAA0B,CAA1B,CAAlB;AACA,cAAMQ,YAAY,GAAGD,SAAS,CAACH,IAAV,GAAiBJ,KAAjB,CAAuB,GAAvB,CAArB,CAPY,CAQZ;;AACA,cAAM,IAAKS,QAAL,IAAiBD,YAAvB;AACA,eAAOC,QAAP;AACD;;AACD,SAAK,MAAL;AAAa;AACX;AACA,cAAMC,YAAY,GAAGZ,aAAa,CAACE,KAAd,CAAoB,GAApB,CAArB;AACA,cAAM,GAAG,GAAGE,IAAN,IAAcQ,YAApB;AACA,eAAOR,IAAI,CAACC,IAAL,CAAU,GAAV,EAAeC,IAAf,EAAP;AACD;;AACD;AACE,aAAOL,YAAY,CAACA,YAAY,CAACM,MAAb,GAAsB,CAAvB,CAAZ,CAAsCD,IAAtC,EAAP;AAnCJ;AAqCD;;AAEM,SAASO,4BAAT,CAAsCf,SAAtC,EAAiG;AACtG,MAAI,CAACA,SAAL,EAAgB,OAAO,EAAP;AAChB,QAAMgB,OAAO,GAAGjB,sBAAsB,CAACC,SAAD,CAAtC;AACA,QAAMiB,KAAK,GAAGD,OAAO,CAACZ,KAAR,CAAc,IAAd,CAAd;AACA,SAAOa,KAAK,CAACA,KAAK,CAACR,MAAN,GAAe,CAAhB,CAAL,CAAwBD,IAAxB,EAAP;AACD","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"]}
+{"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/to-function-schema.js

@@ -44,12 +44,12 @@ async function toFunctionLikeSchema(node, context) {
 
   const info = await context.getQuickInfo(node.name);
   const returnTypeStr = (0, _parseTypeFromQuickInfo().parseTypeFromQuickInfo)(info);
-  const displaySig = info === null || info === void 0 ? void 0 : (_info$body = info.body) === null || _info$body === void 0 ? void 0 : _info$body.displayString;
+  const displaySig = (info === null || info === void 0 ? void 0 : (_info$body = info.body) === null || _info$body === void 0 ? void 0 : _info$body.displayString) || '';
   const args = await (0, _getParams().getParams)(node.parameters, context);
   const returnType = await context.resolveType(node, returnTypeStr);
   const modifiers = ((_node$modifiers = node.modifiers) === null || _node$modifiers === void 0 ? void 0 : _node$modifiers.map(modifier => modifier.getText())) || [];
   const location = context.getLocation(node);
-  return new (_semanticsEntities().FunctionLikeSchema)(name, args, returnType, displaySig || '', location, modifiers);
+  return new (_semanticsEntities().FunctionLikeSchema)(location, name, args, returnType, displaySig, modifiers);
 }
 
 //# sourceMappingURL=to-function-schema.js.map

package/dist/transformers/utils/to-function-schema.js.map

@@ -1 +1 @@
-{"version":3,"sources":["to-function-schema.ts"],"names":["toFunctionLikeSchema","node","context","name","getText","info","getQuickInfo","returnTypeStr","displaySig","body","displayString","args","parameters","returnType","resolveType","modifiers","map","modifier","location","getLocation","FunctionLikeSchema"],"mappings":";;;;;;;;;AACA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;;AAEA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;;AACA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;;AAEO,eAAeA,oBAAf,CAAoCC,IAApC,EAAgEC,OAAhE,EAAiG;AAAA;;AACtG,QAAMC,IAAI,GAAG,eAAAF,IAAI,CAACE,IAAL,0DAAWC,OAAX,OAAwB,EAArC,CADsG,CAEtG;;AACA,QAAMC,IAAI,GAAG,MAAMH,OAAO,CAACI,YAAR,CAAqBL,IAAI,CAACE,IAA1B,CAAnB;AACA,QAAMI,aAAa,GAAG,sDAAuBF,IAAvB,CAAtB;AACA,QAAMG,UAAU,GAAGH,IAAH,aAAGA,IAAH,qCAAGA,IAAI,CAAEI,IAAT,+CAAG,WAAYC,aAA/B;AACA,QAAMC,IAAI,GAAG,MAAM,4BAAUV,IAAI,CAACW,UAAf,EAA2BV,OAA3B,CAAnB;AACA,QAAMW,UAAU,GAAG,MAAMX,OAAO,CAACY,WAAR,CAAoBb,IAApB,EAA0BM,aAA1B,CAAzB;AACA,QAAMQ,SAAS,GAAG,oBAAAd,IAAI,CAACc,SAAL,oEAAgBC,GAAhB,CAAqBC,QAAD,IAAcA,QAAQ,CAACb,OAAT,EAAlC,MAAyD,EAA3E;AACA,QAAMc,QAAQ,GAAGhB,OAAO,CAACiB,WAAR,CAAoBlB,IAApB,CAAjB;AAEA,SAAO,KAAImB,uCAAJ,EAAuBjB,IAAvB,EAA6BQ,IAA7B,EAAmCE,UAAnC,EAA+CL,UAAU,IAAI,EAA7D,EAAiEU,QAAjE,EAA2EH,SAA3E,CAAP;AACD","sourcesContent":["import { SignatureDeclaration } from 'typescript';\nimport { FunctionLikeSchema, Modifier } from '@teambit/semantics.entities.semantic-schema';\nimport { SchemaExtractorContext } from '../../schema-extractor-context';\nimport { getParams } from './get-params';\nimport { parseTypeFromQuickInfo } from './parse-type-from-quick-info';\n\nexport async function toFunctionLikeSchema(node: SignatureDeclaration, context: SchemaExtractorContext) {\n  const name = node.name?.getText() || '';\n  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n  const info = await context.getQuickInfo(node.name!);\n  const returnTypeStr = parseTypeFromQuickInfo(info);\n  const displaySig = info?.body?.displayString;\n  const args = await getParams(node.parameters, context);\n  const returnType = await context.resolveType(node, returnTypeStr);\n  const modifiers = node.modifiers?.map((modifier) => modifier.getText()) || [];\n  const location = context.getLocation(node);\n\n  return new FunctionLikeSchema(name, args, returnType, displaySig || '', location, modifiers as Modifier[]);\n}\n"]}
+{"version":3,"names":["toFunctionLikeSchema","node","context","name","getText","info","getQuickInfo","returnTypeStr","parseTypeFromQuickInfo","displaySig","body","displayString","args","getParams","parameters","returnType","resolveType","modifiers","map","modifier","location","getLocation","FunctionLikeSchema"],"sources":["to-function-schema.ts"],"sourcesContent":["import { SignatureDeclaration } from 'typescript';\nimport { FunctionLikeSchema, Modifier } from '@teambit/semantics.entities.semantic-schema';\nimport { SchemaExtractorContext } from '../../schema-extractor-context';\nimport { getParams } from './get-params';\nimport { parseTypeFromQuickInfo } from './parse-type-from-quick-info';\n\nexport async function toFunctionLikeSchema(node: SignatureDeclaration, context: SchemaExtractorContext) {\n  const name = node.name?.getText() || '';\n  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n  const info = await context.getQuickInfo(node.name!);\n  const returnTypeStr = parseTypeFromQuickInfo(info);\n  const displaySig = info?.body?.displayString || '';\n  const args = await getParams(node.parameters, context);\n  const returnType = await context.resolveType(node, returnTypeStr);\n  const modifiers = node.modifiers?.map((modifier) => modifier.getText()) || [];\n  const location = context.getLocation(node);\n\n  return new FunctionLikeSchema(location, name, args, returnType, displaySig, modifiers as Modifier[]);\n}\n"],"mappings":";;;;;;;;;AACA;EAAA;;EAAA;IAAA;EAAA;;EAAA;AAAA;;AAEA;EAAA;;EAAA;IAAA;EAAA;;EAAA;AAAA;;AACA;EAAA;;EAAA;IAAA;EAAA;;EAAA;AAAA;;AAEO,eAAeA,oBAAf,CAAoCC,IAApC,EAAgEC,OAAhE,EAAiG;EAAA;;EACtG,MAAMC,IAAI,GAAG,eAAAF,IAAI,CAACE,IAAL,0DAAWC,OAAX,OAAwB,EAArC,CADsG,CAEtG;;EACA,MAAMC,IAAI,GAAG,MAAMH,OAAO,CAACI,YAAR,CAAqBL,IAAI,CAACE,IAA1B,CAAnB;EACA,MAAMI,aAAa,GAAG,IAAAC,gDAAA,EAAuBH,IAAvB,CAAtB;EACA,MAAMI,UAAU,GAAG,CAAAJ,IAAI,SAAJ,IAAAA,IAAI,WAAJ,0BAAAA,IAAI,CAAEK,IAAN,0DAAYC,aAAZ,KAA6B,EAAhD;EACA,MAAMC,IAAI,GAAG,MAAM,IAAAC,sBAAA,EAAUZ,IAAI,CAACa,UAAf,EAA2BZ,OAA3B,CAAnB;EACA,MAAMa,UAAU,GAAG,MAAMb,OAAO,CAACc,WAAR,CAAoBf,IAApB,EAA0BM,aAA1B,CAAzB;EACA,MAAMU,SAAS,GAAG,oBAAAhB,IAAI,CAACgB,SAAL,oEAAgBC,GAAhB,CAAqBC,QAAD,IAAcA,QAAQ,CAACf,OAAT,EAAlC,MAAyD,EAA3E;EACA,MAAMgB,QAAQ,GAAGlB,OAAO,CAACmB,WAAR,CAAoBpB,IAApB,CAAjB;EAEA,OAAO,KAAIqB,uCAAJ,EAAuBF,QAAvB,EAAiCjB,IAAjC,EAAuCS,IAAvC,EAA6CG,UAA7C,EAAyDN,UAAzD,EAAqEQ,SAArE,CAAP;AACD"}