@teambit/typescript 0.0.730 → 0.0.731

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","info","getQuickInfo","displaySig","body","displayString","returnTypeStr","args","parameters","returnType","resolveType","FunctionSchema"],"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;;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;AAAA;;AACtG,UAAMJ,IAAI,GAAG,KAAKH,OAAL,CAAaM,SAAb,CAAb,CADsG,CAEtG;;AACA,UAAME,IAAI,GAAG,MAAMD,OAAO,CAACE,YAAR,CAAqBH,SAAS,CAACH,IAA/B,CAAnB;AACA,UAAMO,UAAU,GAAGF,IAAH,aAAGA,IAAH,qCAAGA,IAAI,CAAEG,IAAT,+CAAG,WAAYC,aAA/B;AACA,UAAMC,aAAa,GAAG,sDAAuBH,UAAvB,CAAtB;AACA,UAAMI,IAAI,GAAG,MAAM,4BAAUR,SAAS,CAACS,UAApB,EAAgCR,OAAhC,CAAnB;AACA,UAAMS,UAAU,GAAG,MAAMT,OAAO,CAACU,WAAR,CAAoBX,SAApB,EAA+BO,aAA/B,CAAzB;AACA,WAAO,KAAIK,mCAAJ,EAAmBf,IAAI,IAAI,EAA3B,EAA+BW,IAA/B,EAAqCE,UAArC,EAAiDN,UAAU,IAAI,EAA/D,CAAP;AACD;;AAtByD","sourcesContent":["import { SchemaNode, FunctionSchema } 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 { parseTypeFromQuickInfo } from './utils/parse-type-from-quick-info';\nimport { getParams } from './utils/get-params';\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    const name = this.getName(methodDec);\n    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n    const info = await context.getQuickInfo(methodDec.name!);\n    const displaySig = info?.body?.displayString;\n    const returnTypeStr = parseTypeFromQuickInfo(displaySig);\n    const args = await getParams(methodDec.parameters, context);\n    const returnType = await context.resolveType(methodDec, returnTypeStr);\n    return new FunctionSchema(name || '', args, returnType, displaySig || '');\n  }\n}\n"]}
+{"version":3,"sources":["method-declaration.ts"],"names":["MethodDeclaration","predicate","node","kind","ts","SyntaxKind","getIdentifiers","funcDec","ExportIdentifier","getName","getSourceFile","fileName","name","getText","transform","methodDec","context","info","getQuickInfo","displaySig","body","displayString","returnTypeStr","params","parameters","modifiers","map","modifier","returnType","resolveType","FunctionSchema"],"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;;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;AAAA;;AACtG,UAAMJ,IAAI,GAAG,KAAKH,OAAL,CAAaM,SAAb,CAAb;AACA,UAAME,IAAI,GAAG,MAAMD,OAAO,CAACE,YAAR,CAAqBH,SAAS,CAACH,IAA/B,CAAnB;AACA,UAAMO,UAAU,GAAGF,IAAH,aAAGA,IAAH,qCAAGA,IAAI,CAAEG,IAAT,+CAAG,WAAYC,aAA/B;AACA,UAAMC,aAAa,GAAG,sDAAuBL,IAAvB,CAAtB;AACA,UAAMM,MAAM,GAAG,MAAM,4BAAUR,SAAS,CAACS,UAApB,EAAgCR,OAAhC,CAArB;AACA,UAAMS,SAAS,GAAG,yBAAAV,SAAS,CAACU,SAAV,8EAAqBC,GAArB,CAA0BC,QAAD,IAAcA,QAAQ,CAACd,OAAT,EAAvC,MAA8D,EAAhF;AACA,UAAMe,UAAU,GAAG,MAAMZ,OAAO,CAACa,WAAR,CAAoBd,SAApB,EAA+BO,aAA/B,CAAzB;AACA,WAAO,KAAIQ,mCAAJ,EAAmBlB,IAAnB,EAAyBW,MAAzB,EAAiCK,UAAjC,EAA6CT,UAAU,IAAI,EAA3D,EAA+DM,SAA/D,CAAP;AACD;;AAtByD","sourcesContent":["import { SchemaNode, FunctionSchema, Modifier } 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 { parseTypeFromQuickInfo } from './utils/parse-type-from-quick-info';\nimport { getParams } from './utils/get-params';\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    const name = this.getName(methodDec);\n    const info = await context.getQuickInfo(methodDec.name);\n    const displaySig = info?.body?.displayString;\n    const returnTypeStr = parseTypeFromQuickInfo(info);\n    const params = await getParams(methodDec.parameters, context);\n    const modifiers = methodDec.modifiers?.map((modifier) => modifier.getText()) || [];\n    const returnType = await context.resolveType(methodDec, returnTypeStr);\n    return new FunctionSchema(name, params, returnType, displaySig || '', modifiers as Modifier[]);\n  }\n}\n"]}

package/dist/transformers/method-signature.js

@@ -68,9 +68,9 @@ class MethodSignatureTransformer {
     const name = this.getName(methodSig);
     const info = await context.getQuickInfo(methodSig.name);
     const displaySig = info === null || info === void 0 ? void 0 : (_info$body = info.body) === null || _info$body === void 0 ? void 0 : _info$body.displayString;
-    const returnTypeStr = (0, _parseTypeFromQuickInfo().parseTypeFromQuickInfo)(displaySig);
+    const returnTypeStr = (0, _parseTypeFromQuickInfo().parseTypeFromQuickInfo)(info);
     const args = await (0, _getParams().getParams)(methodSig.parameters, context);
-    const returnType = await context.resolveType(methodSig || methodSig, returnTypeStr);
+    const returnType = await context.resolveType(methodSig, returnTypeStr);
     return new (_semanticsEntities().FunctionSchema)(name, args, returnType, displaySig || '');
   }
 

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","info","getQuickInfo","displaySig","body","displayString","returnTypeStr","args","parameters","returnType","resolveType","FunctionSchema"],"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,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;AAAA;;AACpG,UAAML,IAAI,GAAG,KAAKD,OAAL,CAAaK,SAAb,CAAb;AACA,UAAME,IAAI,GAAG,MAAMD,OAAO,CAACE,YAAR,CAAqBH,SAAS,CAACJ,IAA/B,CAAnB;AACA,UAAMQ,UAAU,GAAGF,IAAH,aAAGA,IAAH,qCAAGA,IAAI,CAAEG,IAAT,+CAAG,WAAYC,aAA/B;AACA,UAAMC,aAAa,GAAG,sDAAuBH,UAAvB,CAAtB;AACA,UAAMI,IAAI,GAAG,MAAM,4BAAUR,SAAS,CAACS,UAApB,EAAgCR,OAAhC,CAAnB;AACA,UAAMS,UAAU,GAAG,MAAMT,OAAO,CAACU,WAAR,CAAoBX,SAAS,IAAIA,SAAjC,EAA4CO,aAA5C,CAAzB;AACA,WAAO,KAAIK,mCAAJ,EAAmBhB,IAAnB,EAAyBY,IAAzB,EAA+BE,UAA/B,EAA2CN,UAAU,IAAI,EAAzD,CAAP;AACD;;AArBkE","sourcesContent":["import { SchemaNode, FunctionSchema } 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 { parseTypeFromQuickInfo } from './utils/parse-type-from-quick-info';\nimport { getParams } from './utils/get-params';\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    const name = this.getName(methodSig);\n    const info = await context.getQuickInfo(methodSig.name);\n    const displaySig = info?.body?.displayString;\n    const returnTypeStr = parseTypeFromQuickInfo(displaySig);\n    const args = await getParams(methodSig.parameters, context);\n    const returnType = await context.resolveType(methodSig || methodSig, returnTypeStr);\n    return new FunctionSchema(name, args, returnType, displaySig || '');\n  }\n}\n"]}
+{"version":3,"sources":["method-signature.ts"],"names":["MethodSignatureTransformer","predicate","node","kind","ts","SyntaxKind","MethodSignature","getName","name","getText","getIdentifiers","transform","methodSig","context","info","getQuickInfo","displaySig","body","displayString","returnTypeStr","args","parameters","returnType","resolveType","FunctionSchema"],"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,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;AAAA;;AACpG,UAAML,IAAI,GAAG,KAAKD,OAAL,CAAaK,SAAb,CAAb;AACA,UAAME,IAAI,GAAG,MAAMD,OAAO,CAACE,YAAR,CAAqBH,SAAS,CAACJ,IAA/B,CAAnB;AACA,UAAMQ,UAAU,GAAGF,IAAH,aAAGA,IAAH,qCAAGA,IAAI,CAAEG,IAAT,+CAAG,WAAYC,aAA/B;AACA,UAAMC,aAAa,GAAG,sDAAuBL,IAAvB,CAAtB;AACA,UAAMM,IAAI,GAAG,MAAM,4BAAUR,SAAS,CAACS,UAApB,EAAgCR,OAAhC,CAAnB;AACA,UAAMS,UAAU,GAAG,MAAMT,OAAO,CAACU,WAAR,CAAoBX,SAApB,EAA+BO,aAA/B,CAAzB;AACA,WAAO,KAAIK,mCAAJ,EAAmBhB,IAAnB,EAAyBY,IAAzB,EAA+BE,UAA/B,EAA2CN,UAAU,IAAI,EAAzD,CAAP;AACD;;AArBkE","sourcesContent":["import { SchemaNode, FunctionSchema } 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 { parseTypeFromQuickInfo } from './utils/parse-type-from-quick-info';\nimport { getParams } from './utils/get-params';\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    const name = this.getName(methodSig);\n    const info = await context.getQuickInfo(methodSig.name);\n    const displaySig = info?.body?.displayString;\n    const returnTypeStr = parseTypeFromQuickInfo(info);\n    const args = await getParams(methodSig.parameters, context);\n    const returnType = await context.resolveType(methodSig, returnTypeStr);\n    return new FunctionSchema(name, args, returnType, displaySig || '');\n  }\n}\n"]}

package/dist/transformers/property-declaration.js

@@ -65,11 +65,10 @@ class PropertyDeclaration {
   async transform(propertyDec, context) {
     var _info$body;
 
-    const name = this.getName(propertyDec); // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-
+    const name = this.getName(propertyDec);
     const info = await context.getQuickInfo(propertyDec.name);
     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)(displaySig);
+    const typeStr = (0, _parseTypeFromQuickInfo().parseTypeFromQuickInfo)(info);
     const type = await context.resolveType(propertyDec, typeStr);
     return new (_semanticsEntities().VariableSchema)(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,CAD0G,CAE1G;;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,sDAAuBH,UAAvB,CAAhB;AACA,UAAMI,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;;AAtB2D","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    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n    const info = await context.getQuickInfo(propertyDec.name!);\n    const displaySig = info?.body?.displayString;\n    const typeStr = parseTypeFromQuickInfo(displaySig);\n    const type = await context.resolveType(propertyDec, typeStr);\n\n    return new VariableSchema(name || '', displaySig || '', type);\n  }\n}\n"]}
+{"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"]}

package/dist/transformers/property-signature.js

@@ -65,8 +65,7 @@ class PropertySignature {
   async transform(prop, context) {
     var _info$body, _prop$type;
 
-    const name = this.getName(prop); // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-
+    const name = this.getName(prop);
     const info = 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) || '';
 
@@ -74,12 +73,12 @@ class PropertySignature {
       // e.g. `propertySig: () => void;` inside interface
       const propType = prop.type;
       const args = await (0, _getParams().getParams)(propType.parameters, context);
-      const typeStr = (0, _parseTypeFromQuickInfo().parseReturnTypeFromQuickInfo)(displaySig);
+      const typeStr = (0, _parseTypeFromQuickInfo().parseReturnTypeFromQuickInfo)(info);
       const returnType = await context.resolveType(propType, typeStr);
       return new (_semanticsEntities().FunctionSchema)(name, args, returnType, displaySig);
     }
 
-    const typeStr = (0, _parseTypeFromQuickInfo().parseTypeFromQuickInfo)(displaySig);
+    const typeStr = (0, _parseTypeFromQuickInfo().parseTypeFromQuickInfo)(info);
     const type = await context.resolveType(prop, typeStr);
     return new (_semanticsEntities().VariableSchema)(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","args","parameters","typeStr","returnType","resolveType","FunctionSchema","VariableSchema"],"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,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,CADiG,CAEjG;;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,YAAMG,IAAI,GAAG,MAAM,4BAAUD,QAAQ,CAACE,UAAnB,EAA+BV,OAA/B,CAAnB;AACA,YAAMW,OAAO,GAAG,4DAA6BR,UAA7B,CAAhB;AACA,YAAMS,UAAU,GAAG,MAAMZ,OAAO,CAACa,WAAR,CAAoBL,QAApB,EAA8BG,OAA9B,CAAzB;AACA,aAAO,KAAIG,mCAAJ,EAAmBnB,IAAnB,EAAyBc,IAAzB,EAA+BG,UAA/B,EAA2CT,UAA3C,CAAP;AACD;;AACD,UAAMQ,OAAO,GAAG,sDAAuBR,UAAvB,CAAhB;AACA,UAAMG,IAAI,GAAG,MAAMN,OAAO,CAACa,WAAR,CAAoBd,IAApB,EAA0BY,OAA1B,CAAnB;AACA,WAAO,KAAII,mCAAJ,EAAmBpB,IAAnB,EAAyBQ,UAAzB,EAAqCG,IAArC,CAAP;AACD;;AA7ByD","sourcesContent":["import { FunctionSchema, SchemaNode, VariableSchema } from '@teambit/semantics.entities.semantic-schema';\nimport ts, { FunctionTypeNode, Node, PropertySignature as PropertySignatureNode } from 'typescript';\nimport { getParams } from './utils/get-params';\nimport { SchemaTransformer } from '../schema-transformer';\nimport { SchemaExtractorContext } from '../schema-extractor-context';\nimport { parseReturnTypeFromQuickInfo, 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    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\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      const args = await getParams(propType.parameters, context);\n      const typeStr = parseReturnTypeFromQuickInfo(displaySig);\n      const returnType = await context.resolveType(propType, typeStr);\n      return new FunctionSchema(name, args, returnType, displaySig);\n    }\n    const typeStr = parseTypeFromQuickInfo(displaySig);\n    const type = await context.resolveType(prop, typeStr);\n    return new VariableSchema(name, displaySig, type);\n  }\n}\n"]}
+{"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","args","parameters","typeStr","returnType","resolveType","FunctionSchema","VariableSchema"],"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,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,YAAMG,IAAI,GAAG,MAAM,4BAAUD,QAAQ,CAACE,UAAnB,EAA+BV,OAA/B,CAAnB;AACA,YAAMW,OAAO,GAAG,4DAA6BV,IAA7B,CAAhB;AACA,YAAMW,UAAU,GAAG,MAAMZ,OAAO,CAACa,WAAR,CAAoBL,QAApB,EAA8BG,OAA9B,CAAzB;AACA,aAAO,KAAIG,mCAAJ,EAAmBnB,IAAnB,EAAyBc,IAAzB,EAA+BG,UAA/B,EAA2CT,UAA3C,CAAP;AACD;;AACD,UAAMQ,OAAO,GAAG,sDAAuBV,IAAvB,CAAhB;AACA,UAAMK,IAAI,GAAG,MAAMN,OAAO,CAACa,WAAR,CAAoBd,IAApB,EAA0BY,OAA1B,CAAnB;AACA,WAAO,KAAII,mCAAJ,EAAmBpB,IAAnB,EAAyBQ,UAAzB,EAAqCG,IAArC,CAAP;AACD;;AA5ByD","sourcesContent":["import { FunctionSchema, SchemaNode, VariableSchema } from '@teambit/semantics.entities.semantic-schema';\nimport ts, { FunctionTypeNode, Node, PropertySignature as PropertySignatureNode } from 'typescript';\nimport { getParams } from './utils/get-params';\nimport { SchemaTransformer } from '../schema-transformer';\nimport { SchemaExtractorContext } from '../schema-extractor-context';\nimport { parseReturnTypeFromQuickInfo, 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 = 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      const args = await getParams(propType.parameters, context);\n      const typeStr = parseReturnTypeFromQuickInfo(info);\n      const returnType = await context.resolveType(propType, typeStr);\n      return new FunctionSchema(name, args, returnType, displaySig);\n    }\n    const typeStr = parseTypeFromQuickInfo(info);\n    const type = await context.resolveType(prop, typeStr);\n    return new VariableSchema(name, displaySig, type);\n  }\n}\n"]}

package/dist/transformers/type-alias.js

@@ -39,6 +39,16 @@ function _exportIdentifier() {
   return data;
 }
 
+function _typeNodeToSchema() {
+  const data = require("./utils/type-node-to-schema");
+
+  _typeNodeToSchema = function () {
+    return data;
+  };
+
+  return data;
+}
+
 class TypeAliasTransformer {
   predicate(node) {
     return node.kind === _typescript().default.SyntaxKind.TypeAliasDeclaration;
@@ -55,10 +65,9 @@ class TypeAliasTransformer {
   async transform(typeAlias, context) {
     var _info$body;
 
-    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    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;
-    const type = await context.computeSchema(typeAlias.type);
     return new (_semanticsEntities().TypeSchema)(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","info","getQuickInfo","displaySig","body","displayString","type","computeSchema","TypeSchema"],"mappings":";;;;;;;;;;;AAAA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;;AACA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;;AAGA;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;AACA,UAAMC,IAAI,GAAG,MAAMD,OAAO,CAACE,YAAR,CAAqBH,SAAS,CAACN,IAA/B,CAAnB;AACA,UAAMU,UAAU,GAAGF,IAAH,aAAGA,IAAH,qCAAGA,IAAI,CAAEG,IAAT,+CAAG,WAAYC,aAA/B;AACA,UAAMC,IAAI,GAAG,MAAMN,OAAO,CAACO,aAAR,CAAsBR,SAAS,CAACO,IAAhC,CAAnB;AACA,WAAO,KAAIE,+BAAJ,EAAe,KAAKX,OAAL,CAAaE,SAAb,CAAf,EAAwCO,IAAxC,EAA8CH,UAA9C,CAAP;AACD;;AAnB4D","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';\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    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n    const info = await context.getQuickInfo(typeAlias.name!);\n    const displaySig = info?.body?.displayString;\n    const type = await context.computeSchema(typeAlias.type);\n    return new TypeSchema(this.getName(typeAlias), type, displaySig as string);\n  }\n}\n"]}
+{"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"]}

package/dist/transformers/utils/get-params.d.ts

@@ -1,4 +1,4 @@
-import { Parameter } from '@teambit/semantics.entities.semantic-schema';
+import { ParameterSchema } from '@teambit/semantics.entities.semantic-schema';
 import { ParameterDeclaration, NodeArray } from 'typescript';
 import { SchemaExtractorContext } from '../../schema-extractor-context';
-export declare function getParams(parameterNodes: NodeArray<ParameterDeclaration>, context: SchemaExtractorContext): Promise<Parameter[]>;
+export declare function getParams(parameterNodes: NodeArray<ParameterDeclaration>, context: SchemaExtractorContext): Promise<ParameterSchema[]>;

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

@@ -39,28 +39,30 @@ function _parseTypeFromQuickInfo() {
   return data;
 }
 
+function _typeNodeToSchema() {
+  const data = require("./type-node-to-schema");
+
+  _typeNodeToSchema = function () {
+    return data;
+  };
+
+  return data;
+}
+
 async function getParams(parameterNodes, context) {
   return (0, _pMapSeries().default)(parameterNodes, async param => {
-    return {
-      name: param.name.getText(),
-      type: await getParamType(param, context),
-      defaultValue: param.initializer ? param.initializer.getText() : undefined
-    };
+    return new (_semanticsEntities().ParameterSchema)(param.name.getText(), await getParamType(param, context), param.initializer ? param.initializer.getText() : undefined);
   });
 }
 
 async function getParamType(param, context) {
-  var _info$body;
-
   if (param.type) {
-    const type = param.type; // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-
-    return context.resolveType(type, (type === null || type === void 0 ? void 0 : type.getText()) || 'any');
+    const type = param.type;
+    return (0, _typeNodeToSchema().typeNodeToSchema)(type, context);
   }
 
   const info = await context.getQuickInfo(param.name);
-  const displaySig = info === null || info === void 0 ? void 0 : (_info$body = info.body) === null || _info$body === void 0 ? void 0 : _info$body.displayString;
-  const parsed = (0, _parseTypeFromQuickInfo().parseTypeFromQuickInfo)(displaySig);
+  const parsed = (0, _parseTypeFromQuickInfo().parseTypeFromQuickInfo)(info);
   return new (_semanticsEntities().TypeRefSchema)(parsed || 'any');
 }
 

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

@@ -1 +1 @@
-{"version":3,"sources":["get-params.ts"],"names":["getParams","parameterNodes","context","param","name","getText","type","getParamType","defaultValue","initializer","undefined","resolveType","info","getQuickInfo","displaySig","body","displayString","parsed","TypeRefSchema"],"mappings":";;;;;;;;;;;AAAA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;;AACA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;;AAGA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;;AAEO,eAAeA,SAAf,CACLC,cADK,EAELC,OAFK,EAGiB;AACtB,SAAO,2BAAWD,cAAX,EAA2B,MAAOE,KAAP,IAAiB;AACjD,WAAO;AACLC,MAAAA,IAAI,EAAED,KAAK,CAACC,IAAN,CAAWC,OAAX,EADD;AAELC,MAAAA,IAAI,EAAE,MAAMC,YAAY,CAACJ,KAAD,EAAQD,OAAR,CAFnB;AAGLM,MAAAA,YAAY,EAAEL,KAAK,CAACM,WAAN,GAAoBN,KAAK,CAACM,WAAN,CAAkBJ,OAAlB,EAApB,GAAkDK;AAH3D,KAAP;AAKD,GANM,CAAP;AAOD;;AAED,eAAeH,YAAf,CAA4BJ,KAA5B,EAAyDD,OAAzD,EAAkH;AAAA;;AAChH,MAAIC,KAAK,CAACG,IAAV,EAAgB;AACd,UAAMA,IAAI,GAAGH,KAAK,CAACG,IAAnB,CADc,CAEd;;AACA,WAAOJ,OAAO,CAACS,WAAR,CAAoBL,IAApB,EAA2B,CAAAA,IAAI,SAAJ,IAAAA,IAAI,WAAJ,YAAAA,IAAI,CAAED,OAAN,OAAmB,KAA9C,CAAP;AACD;;AACD,QAAMO,IAAI,GAAG,MAAMV,OAAO,CAACW,YAAR,CAAqBV,KAAK,CAACC,IAA3B,CAAnB;AACA,QAAMU,UAAU,GAAGF,IAAH,aAAGA,IAAH,qCAAGA,IAAI,CAAEG,IAAT,+CAAG,WAAYC,aAA/B;AACA,QAAMC,MAAM,GAAG,sDAAuBH,UAAvB,CAAf;AACA,SAAO,KAAII,kCAAJ,EAAkBD,MAAM,IAAI,KAA5B,CAAP;AACD","sourcesContent":["import { Parameter, 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';\n\nexport async function getParams(\n  parameterNodes: NodeArray<ParameterDeclaration>,\n  context: SchemaExtractorContext\n): Promise<Parameter[]> {\n  return pMapSeries(parameterNodes, async (param) => {\n    return {\n      name: param.name.getText(),\n      type: await getParamType(param, context),\n      defaultValue: param.initializer ? param.initializer.getText() : undefined,\n    };\n  });\n}\n\nasync function getParamType(param: ParameterDeclaration, context: SchemaExtractorContext): Promise<TypeRefSchema> {\n  if (param.type) {\n    const type = param.type;\n    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n    return context.resolveType(type!, type?.getText() || 'any');\n  }\n  const info = await context.getQuickInfo(param.name);\n  const displaySig = info?.body?.displayString;\n  const parsed = parseTypeFromQuickInfo(displaySig);\n  return new TypeRefSchema(parsed || 'any');\n}\n"]}
+{"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"]}

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

@@ -1,2 +1,35 @@
-export declare function parseTypeFromQuickInfo(displayString?: string): string;
-export declare function parseReturnTypeFromQuickInfo(displayString?: string): string;
+import protocol from 'typescript/lib/protocol';
+/**
+ * try to parse the type from the quickinfo.
+ * this is an error-prone process, we do our best here.
+ *
+ * an example of a function with many ":"
+ * `export function getObj(a: string, func: (b: number) => {}) { return { a: 1, b: 2 } };`
+ * which produce the following quickinfo:
+ * ```ts
+ * function getObj(a: string, func: (b: number) => {}): {
+ *   a: number;
+ *   b: number;
+ * }
+ * ```
+ *
+ * some examples of quickinfo:
+ *
+ * function ts.signatureToDisplayParts(typechecker: TypeChecker, signature: Signature, enclosingDeclaration?: Node | undefined, flags?: TypeFormatFlags): SymbolDisplayPart[]
+ *
+ * const enum ts.TypeFormatFlags
+ *
+ * (method) ts.TypeChecker.writeSignature(signature: Signature, enclosingDeclaration?: Node | undefined, flags?: TypeFormatFlags | undefined, kind?: SignatureKind | undefined, writer?: EmitTextWriter | undefined): string
+ *
+ * const obj: {
+ *   a: number;
+ *   b: number;
+ *  }
+ *
+ * function getObj(a: string): {
+ *     a: number;
+ *     b: number;
+ * }
+ */
+export declare function parseTypeFromQuickInfo(quickInfo: protocol.QuickInfoResponse | undefined): string;
+export declare function parseReturnTypeFromQuickInfo(quickInfo: protocol.QuickInfoResponse | undefined): string;

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

@@ -1,5 +1,7 @@
 "use strict";
 
+require("core-js/modules/es.array.iterator.js");
+
 require("core-js/modules/es.regexp.exec.js");
 
 require("core-js/modules/es.string.trim.js");
@@ -10,15 +12,99 @@ Object.defineProperty(exports, "__esModule", {
 exports.parseReturnTypeFromQuickInfo = parseReturnTypeFromQuickInfo;
 exports.parseTypeFromQuickInfo = parseTypeFromQuickInfo;
 
-function parseTypeFromQuickInfo(displayString) {
-  if (!displayString) return '';
-  const array = displayString.split(':');
-  return array[array.length - 1].trim();
+// eslint-disable-next-line import/no-unresolved
+
+/**
+ * try to parse the type from the quickinfo.
+ * this is an error-prone process, we do our best here.
+ *
+ * an example of a function with many ":"
+ * `export function getObj(a: string, func: (b: number) => {}) { return { a: 1, b: 2 } };`
+ * which produce the following quickinfo:
+ * ```ts
+ * function getObj(a: string, func: (b: number) => {}): {
+ *   a: number;
+ *   b: number;
+ * }
+ * ```
+ *
+ * some examples of quickinfo:
+ *
+ * function ts.signatureToDisplayParts(typechecker: TypeChecker, signature: Signature, enclosingDeclaration?: Node | undefined, flags?: TypeFormatFlags): SymbolDisplayPart[]
+ *
+ * const enum ts.TypeFormatFlags
+ *
+ * (method) ts.TypeChecker.writeSignature(signature: Signature, enclosingDeclaration?: Node | undefined, flags?: TypeFormatFlags | undefined, kind?: SignatureKind | undefined, writer?: EmitTextWriter | undefined): string
+ *
+ * const obj: {
+ *   a: number;
+ *   b: number;
+ *  }
+ *
+ * function getObj(a: string): {
+ *     a: number;
+ *     b: number;
+ * }
+ */
+function parseTypeFromQuickInfo(quickInfo) {
+  var _quickInfo$body;
+
+  if (!(quickInfo !== null && quickInfo !== void 0 && (_quickInfo$body = quickInfo.body) !== null && _quickInfo$body !== void 0 && _quickInfo$body.displayString)) return '';
+  const displayString = quickInfo.body.displayString;
+  const splitByColon = displayString.split(':');
+
+  switch (quickInfo.body.kind) {
+    case 'const':
+    case 'property':
+    case 'let':
+    case 'var':
+      {
+        const [, ...tail] = splitByColon;
+        return tail.join(':').trim();
+      }
+
+    case 'method':
+    case 'function':
+      {
+        const split = displayString.split('): ');
+
+        if (split.length !== 2) {
+          throw new Error(`quickinfo of a function below was not implemented.\n${displayString}`);
+        }
+
+        return split[1].trim();
+      }
+
+    case 'alias':
+      {
+        // e.g. (alias) class BuilderService\nimport BuilderService
+        // e.g. '(alias) type Serializable = {\n' +
+        // '    toString(): string;\n' +
+        // '}\n' +
+        // 'import Serializable'
+        const firstLine = displayString.split('\n')[0];
+        const splitBySpace = firstLine.trim().split(' '); // first two are alias keyword and alias type
+
+        const [,, typeName] = splitBySpace;
+        return typeName;
+      }
+
+    case 'type':
+      {
+        // e.g. `type TaskSlot = SlotRegistry<BuildTask[]>`
+        const splitByEqual = displayString.split('=');
+        const [, ...tail] = splitByEqual;
+        return tail.join('=').trim();
+      }
+
+    default:
+      return splitByColon[splitByColon.length - 1].trim();
+  }
 }
 
-function parseReturnTypeFromQuickInfo(displayString) {
-  if (!displayString) return '';
-  const typeStr = parseTypeFromQuickInfo(displayString);
+function parseReturnTypeFromQuickInfo(quickInfo) {
+  if (!quickInfo) return '';
+  const typeStr = parseTypeFromQuickInfo(quickInfo);
   const array = typeStr.split('=>');
   return array[array.length - 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","displayString","array","split","length","trim","parseReturnTypeFromQuickInfo","typeStr"],"mappings":";;;;;;;;;;;;AAAO,SAASA,sBAAT,CAAgCC,aAAhC,EAAwD;AAC7D,MAAI,CAACA,aAAL,EAAoB,OAAO,EAAP;AACpB,QAAMC,KAAK,GAAGD,aAAa,CAACE,KAAd,CAAoB,GAApB,CAAd;AACA,SAAOD,KAAK,CAACA,KAAK,CAACE,MAAN,GAAe,CAAhB,CAAL,CAAwBC,IAAxB,EAAP;AACD;;AAEM,SAASC,4BAAT,CAAsCL,aAAtC,EAA8D;AACnE,MAAI,CAACA,aAAL,EAAoB,OAAO,EAAP;AACpB,QAAMM,OAAO,GAAGP,sBAAsB,CAACC,aAAD,CAAtC;AACA,QAAMC,KAAK,GAAGK,OAAO,CAACJ,KAAR,CAAc,IAAd,CAAd;AACA,SAAOD,KAAK,CAACA,KAAK,CAACE,MAAN,GAAe,CAAhB,CAAL,CAAwBC,IAAxB,EAAP;AACD","sourcesContent":["export function parseTypeFromQuickInfo(displayString?: string) {\n  if (!displayString) return '';\n  const array = displayString.split(':');\n  return array[array.length - 1].trim();\n}\n\nexport function parseReturnTypeFromQuickInfo(displayString?: string) {\n  if (!displayString) return '';\n  const typeStr = parseTypeFromQuickInfo(displayString);\n  const array = typeStr.split('=>');\n  return array[array.length - 1].trim();\n}\n"]}
+{"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"]}

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

@@ -0,0 +1,4 @@
+import { TypeNode } from 'typescript';
+import { SchemaNode } from '@teambit/semantics.entities.semantic-schema';
+import { SchemaExtractorContext } from '../../schema-extractor-context';
+export declare function typeNodeToSchema(node: TypeNode, context: SchemaExtractorContext): Promise<SchemaNode>;