@teambit/typescript 0.0.737 → 0.0.740

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.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","getLocation"],"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,EAAmBT,OAAO,CAACU,WAAR,CAAoBX,WAApB,CAAnB,EAAqDP,IAArD,EAA2DW,UAAU,IAAI,EAAzE,EAA6EI,IAA7E,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(context.getLocation(propertyDec), 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.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","getLocation"],"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,EAAmBX,OAAO,CAACY,WAAR,CAAoBb,IAApB,CAAnB,EAA8CJ,IAA9C,EAAoDQ,UAApD,EAAgEG,IAAhE,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(context.getLocation(prop), 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.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","getLocation","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,EAAWrB,OAAO,CAACsB,WAAR,CAAoB7B,IAApB,CAAX,EAAsCyB,OAAtC,CAAP;AACD;AAED;AACF;AACA;;;AACUhB,EAAAA,WAAW,CAACqB,GAAD,EAA0B;AAC3C,WAAO,uBACLA,GAAG,CAACC,UAAJ,CAAelB,GAAf,CAAoBmB,SAAD,IAAe;AAAA;;AAChC,UAAIA,SAAS,CAAC/B,IAAV,KAAmBC,sBAAGC,UAAH,CAAc8B,iBAArC,EAAwD,OAAOD,SAAP;AACxD,YAAME,QAAQ,GAAGC,OAAO,yBACtBH,SAAS,CAACI,SADY,yDACtB,qBAAqBhB,IAArB,CAA2BiB,QAAD,IAAc;AACtC,eAAOA,QAAQ,CAACpC,IAAT,KAAkBC,sBAAGC,UAAH,CAAcmC,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(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"]}
+{"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.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","getLocation"],"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,EAAeP,OAAO,CAACQ,WAAR,CAAoBT,SAApB,CAAf,EAA+C,KAAKF,OAAL,CAAaE,SAAb,CAA/C,EAAwEE,IAAxE,EAA8EG,UAAU,IAAI,EAA5F,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(context.getLocation(typeAlias), this.getName(typeAlias), type, displaySig || '');\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,13 +61,26 @@ function _typeNodeToSchema() {
 
 async function getParams(parameterNodes, context) {
   return (0, _pMapSeries().default)(parameterNodes, async param => {
-    return new (_semanticsEntities().ParameterSchema)(context.getLocation(param), param.name.getText(), await getParamType(param, context), param.initializer ? param.initializer.getText() : undefined);
+    return new (_semanticsEntities().ParameterSchema)(context.getLocation(param), getParamName(param), await getParamType(param, context), param.initializer ? param.initializer.getText() : undefined);
   });
 }
-/**
- * @todo: probably not needed. just call context.resolveType instead.
- */
 
+function getParamName(param) {
+  if ((0, _typescript().isIdentifier)(param.name)) {
+    return param.name.getText();
+  } // it's binding pattern, either an array or an object
+
+
+  const elements = param.name.elements.map(elem => elem.getText());
+  const elementsStr = elements.join(', ');
+
+  if (param.name.kind === _typescript().SyntaxKind.ArrayBindingPattern) {
+    return `[ ${elementsStr} ]`;
+  } // it's an object binding
+
+
+  return `{ ${elementsStr} }`;
+}
 
 async function getParamType(param, context) {
   if (param.type) {
@@ -65,9 +88,32 @@ async function getParamType(param, context) {
     return (0, _typeNodeToSchema().typeNodeToSchema)(type, context);
   }
 
-  const info = await context.getQuickInfo(param.name);
-  const parsed = (0, _parseTypeFromQuickInfo().parseTypeFromQuickInfo)(info);
-  return new (_semanticsEntities().TypeRefSchema)(context.getLocation(param), parsed || 'any');
+  if ((0, _typescript().isIdentifier)(param.name)) {
+    const info = await context.getQuickInfo(param.name);
+    const parsed = (0, _parseTypeFromQuickInfo().parseTypeFromQuickInfo)(info);
+    return new (_semanticsEntities().InferenceTypeSchema)(context.getLocation(param), parsed);
+  } // it's binding pattern, either an array or an object
+
+
+  if (param.name.kind === _typescript().SyntaxKind.ArrayBindingPattern) {
+    const elements = await (0, _pMapSeries().default)(param.name.elements, async elem => {
+      const info = await context.getQuickInfo(elem);
+      const parsed = (0, _parseTypeFromQuickInfo().parseTypeFromQuickInfo)(info);
+      return new (_semanticsEntities().InferenceTypeSchema)(context.getLocation(param), parsed);
+    });
+    return new (_semanticsEntities().TupleTypeSchema)(context.getLocation(param), elements);
+  }
+
+  if (param.name.kind === _typescript().SyntaxKind.ObjectBindingPattern) {
+    const elements = await (0, _pMapSeries().default)(param.name.elements, async elem => {
+      const info = await context.getQuickInfo(elem.name);
+      const parsed = (0, _parseTypeFromQuickInfo().parseTypeFromQuickInfo)(info);
+      return new (_semanticsEntities().InferenceTypeSchema)(context.getLocation(param), parsed, elem.name.getText());
+    });
+    return new (_semanticsEntities().TypeLiteralSchema)(context.getLocation(param), elements);
+  }
+
+  throw new Error(`unknown param type`);
 }
 
 //# sourceMappingURL=get-params.js.map

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

@@ -1 +1 @@
-{"version":3,"sources":["get-params.ts"],"names":["getParams","parameterNodes","context","param","ParameterSchema","getLocation","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,EACLF,OAAO,CAACG,WAAR,CAAoBF,KAApB,CADK,EAELA,KAAK,CAACG,IAAN,CAAWC,OAAX,EAFK,EAGL,MAAMC,YAAY,CAACL,KAAD,EAAQD,OAAR,CAHb,EAILC,KAAK,CAACM,WAAN,GAAoBN,KAAK,CAACM,WAAN,CAAkBF,OAAlB,EAApB,GAAkDG,SAJ7C,CAAP;AAMD,GAPM,CAAP;AAQD;AAED;AACA;AACA;;;AACA,eAAeF,YAAf,CAA4BL,KAA5B,EAAyDD,OAAzD,EAA+G;AAC7G,MAAIC,KAAK,CAACQ,IAAV,EAAgB;AACd,UAAMA,IAAI,GAAGR,KAAK,CAACQ,IAAnB;AACA,WAAO,0CAAiBA,IAAjB,EAAuBT,OAAvB,CAAP;AACD;;AACD,QAAMU,IAAI,GAAG,MAAMV,OAAO,CAACW,YAAR,CAAqBV,KAAK,CAACG,IAA3B,CAAnB;AACA,QAAMQ,MAAM,GAAG,sDAAuBF,IAAvB,CAAf;AACA,SAAO,KAAIG,kCAAJ,EAAkBb,OAAO,CAACG,WAAR,CAAoBF,KAApB,CAAlB,EAA8CW,MAAM,IAAI,KAAxD,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      context.getLocation(param),\n      param.name.getText(),\n      await getParamType(param, context),\n      param.initializer ? param.initializer.getText() : undefined\n    );\n  });\n}\n\n/**\n * @todo: probably not needed. just call context.resolveType instead.\n */\nasync function getParamType(param: ParameterDeclaration, context: SchemaExtractorContext): Promise<SchemaNode> {\n  if (param.type) {\n    const type = param.type;\n    return typeNodeToSchema(type, context);\n  }\n  const info = await context.getQuickInfo(param.name);\n  const parsed = parseTypeFromQuickInfo(info);\n  return new TypeRefSchema(context.getLocation(param), parsed || 'any');\n}\n"]}
+{"version":3,"names":["getParams","parameterNodes","context","pMapSeries","param","ParameterSchema","getLocation","getParamName","getParamType","initializer","getText","undefined","isIdentifier","name","elements","map","elem","elementsStr","join","kind","SyntaxKind","ArrayBindingPattern","type","typeNodeToSchema","info","getQuickInfo","parsed","parseTypeFromQuickInfo","InferenceTypeSchema","TupleTypeSchema","ObjectBindingPattern","TypeLiteralSchema","Error"],"sources":["get-params.ts"],"sourcesContent":["import {\n  InferenceTypeSchema,\n  ParameterSchema,\n  TupleTypeSchema,\n  TypeLiteralSchema,\n  SchemaNode,\n} from '@teambit/semantics.entities.semantic-schema';\nimport pMapSeries from 'p-map-series';\nimport {\n  SyntaxKind,\n  ParameterDeclaration,\n  NodeArray,\n  isIdentifier,\n  BindingElement,\n  ArrayBindingElement,\n} from 'typescript';\nimport { SchemaExtractorContext } from '../../schema-extractor-context';\nimport { parseTypeFromQuickInfo } from './parse-type-from-quick-info';\nimport { typeNodeToSchema } from './type-node-to-schema';\n\nexport async function getParams(\n  parameterNodes: NodeArray<ParameterDeclaration>,\n  context: SchemaExtractorContext\n): Promise<ParameterSchema[]> {\n  return pMapSeries(parameterNodes, async (param) => {\n    return new ParameterSchema(\n      context.getLocation(param),\n      getParamName(param),\n      await getParamType(param, context),\n      param.initializer ? param.initializer.getText() : undefined\n    );\n  });\n}\n\nfunction getParamName(param: ParameterDeclaration): string {\n  if (isIdentifier(param.name)) {\n    return param.name.getText();\n  }\n  // it's binding pattern, either an array or an object\n  const elements = param.name.elements.map((elem) => elem.getText());\n  const elementsStr = elements.join(', ');\n  if (param.name.kind === SyntaxKind.ArrayBindingPattern) {\n    return `[ ${elementsStr} ]`;\n  }\n  // it's an object binding\n  return `{ ${elementsStr} }`;\n}\n\nasync function getParamType(param: ParameterDeclaration, context: SchemaExtractorContext): Promise<SchemaNode> {\n  if (param.type) {\n    const type = param.type;\n    return typeNodeToSchema(type, context);\n  }\n  if (isIdentifier(param.name)) {\n    const info = await context.getQuickInfo(param.name);\n    const parsed = parseTypeFromQuickInfo(info);\n    return new InferenceTypeSchema(context.getLocation(param), parsed);\n  }\n  // it's binding pattern, either an array or an object\n  if (param.name.kind === SyntaxKind.ArrayBindingPattern) {\n    const elements = await pMapSeries(param.name.elements, async (elem: ArrayBindingElement) => {\n      const info = await context.getQuickInfo(elem);\n      const parsed = parseTypeFromQuickInfo(info);\n      return new InferenceTypeSchema(context.getLocation(param), parsed);\n    });\n    return new TupleTypeSchema(context.getLocation(param), elements);\n  }\n  if (param.name.kind === SyntaxKind.ObjectBindingPattern) {\n    const elements = await pMapSeries(param.name.elements, async (elem: BindingElement) => {\n      const info = await context.getQuickInfo(elem.name);\n      const parsed = parseTypeFromQuickInfo(info);\n      return new InferenceTypeSchema(context.getLocation(param), parsed, elem.name.getText());\n    });\n    return new TypeLiteralSchema(context.getLocation(param), elements);\n  }\n  throw new Error(`unknown param type`);\n}\n"],"mappings":"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"}

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

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

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

@@ -9,11 +9,11 @@ require("core-js/modules/es.string.trim.js");
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+exports.UNRESOLVED = void 0;
 exports.parseReturnTypeFromQuickInfo = parseReturnTypeFromQuickInfo;
 exports.parseTypeFromQuickInfo = parseTypeFromQuickInfo;
-
 // eslint-disable-next-line import/no-unresolved
-
+const UNRESOLVED = '<<unresolved>>';
 /**
  * try to parse the type from the quickinfo.
  * this is an error-prone process, we do our best here.
@@ -46,6 +46,9 @@ exports.parseTypeFromQuickInfo = parseTypeFromQuickInfo;
  *     b: number;
  * }
  */
+
+exports.UNRESOLVED = UNRESOLVED;
+
 function parseTypeFromQuickInfo(quickInfo) {
   var _quickInfo$body;
 
@@ -69,7 +72,13 @@ function parseTypeFromQuickInfo(quickInfo) {
         const split = displayString.split('): ');
 
         if (split.length !== 2) {
-          throw new Error(`quickinfo of a function below was not implemented.\n${displayString}`);
+          // it's hard to determine where the return-type is. so it's better to show unresolved.
+          // maybe, in the UI, in this case, it's best to show the signature.
+          // e.g.
+          // (method) IssuesList.getIssue<T extends ComponentIssue>(IssueClass: {
+          //   new (): T;
+          // }): T | undefined
+          return UNRESOLVED;
         }
 
         return split[1].trim();

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

@@ -1 +1 @@
-{"version":3,"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.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,GAAG,CAAAH,IAAI,SAAJ,IAAAA,IAAI,WAAJ,0BAAAA,IAAI,CAAEI,IAAN,0DAAYC,aAAZ,KAA6B,EAAhD;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,EAAuBF,QAAvB,EAAiCf,IAAjC,EAAuCQ,IAAvC,EAA6CE,UAA7C,EAAyDL,UAAzD,EAAqEO,SAArE,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(location, name, args, returnType, displaySig, 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"}

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

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

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

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

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

@@ -1 +1 @@
-{"version":3,"sources":["variable-declaration.ts"],"names":["VariableDeclaration","predicate","node","kind","ts","SyntaxKind","getName","name","getText","getIdentifiers","ExportIdentifier","getSourceFile","fileName","transform","varDec","context","info","getQuickInfo","displaySig","body","displayString","location","getLocation","initializer","ArrowFunction","args","parameters","typeStr","returnType","resolveType","FunctionLikeSchema","type","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;;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,MAAD,EAAkCC,OAAlC,EAAwF;AAAA;;AACrG,UAAMR,IAAI,GAAG,KAAKD,OAAL,CAAaQ,MAAb,CAAb;AACA,UAAME,IAAI,GAAG,MAAMD,OAAO,CAACE,YAAR,CAAqBH,MAAM,CAACP,IAA5B,CAAnB;AACA,UAAMW,UAAU,GAAG,CAAAF,IAAI,SAAJ,IAAAA,IAAI,WAAJ,0BAAAA,IAAI,CAAEG,IAAN,0DAAYC,aAAZ,KAA6B,EAAhD;AACA,UAAMC,QAAQ,GAAGN,OAAO,CAACO,WAAR,CAAoBR,MAApB,CAAjB;;AACA,QAAI,wBAAAA,MAAM,CAACS,WAAP,4EAAoBpB,IAApB,MAA6BC,sBAAGC,UAAH,CAAcmB,aAA/C,EAA8D;AAC5D,YAAMC,IAAI,GAAG,MAAM,4BAAWX,MAAM,CAACS,WAAR,CAAsCG,UAAhD,EAA4DX,OAA5D,CAAnB;AACA,YAAMY,OAAO,GAAG,4DAA6BX,IAA7B,CAAhB;AACA,YAAMY,UAAU,GAAG,MAAMb,OAAO,CAACc,WAAR,CAAoBf,MAApB,EAA4Ba,OAA5B,CAAzB;AACA,aAAO,KAAIG,uCAAJ,EAAuBT,QAAvB,EAAiCd,IAAjC,EAAuCkB,IAAvC,EAA6CG,UAA7C,EAAyDV,UAAzD,CAAP;AACD;;AACD,UAAMS,OAAO,GAAG,sDAAuBX,IAAvB,CAAhB;AACA,UAAMe,IAAI,GAAG,MAAMhB,OAAO,CAACc,WAAR,CAAoBf,MAApB,EAA4Ba,OAA5B,CAAnB;AACA,WAAO,KAAIK,mCAAJ,EAAmBX,QAAnB,EAA6Bd,IAA7B,EAAmCW,UAAnC,EAA+Ca,IAA/C,CAAP;AACD;;AA3B2D","sourcesContent":["import { SchemaNode, VariableSchema, FunctionLikeSchema } from '@teambit/semantics.entities.semantic-schema';\nimport ts, { Node, VariableDeclaration as VariableDeclarationNode, ArrowFunction } from 'typescript';\nimport { SchemaTransformer } from '../schema-transformer';\nimport { SchemaExtractorContext } from '../schema-extractor-context';\nimport { ExportIdentifier } from '../export-identifier';\nimport { getParams } from './utils/get-params';\nimport { parseReturnTypeFromQuickInfo, parseTypeFromQuickInfo } from './utils/parse-type-from-quick-info';\n\nexport class VariableDeclaration implements SchemaTransformer {\n  predicate(node: Node) {\n    return node.kind === ts.SyntaxKind.VariableDeclaration;\n  }\n\n  getName(node: VariableDeclarationNode) {\n    return node.name.getText();\n  }\n\n  async getIdentifiers(node: VariableDeclarationNode) {\n    return [new ExportIdentifier(node.name.getText(), node.getSourceFile().fileName)];\n  }\n\n  async transform(varDec: VariableDeclarationNode, context: SchemaExtractorContext): Promise<SchemaNode> {\n    const name = this.getName(varDec);\n    const info = await context.getQuickInfo(varDec.name);\n    const displaySig = info?.body?.displayString || '';\n    const location = context.getLocation(varDec);\n    if (varDec.initializer?.kind === ts.SyntaxKind.ArrowFunction) {\n      const args = await getParams((varDec.initializer as ArrowFunction).parameters, context);\n      const typeStr = parseReturnTypeFromQuickInfo(info);\n      const returnType = await context.resolveType(varDec, typeStr);\n      return new FunctionLikeSchema(location, name, args, returnType, displaySig);\n    }\n    const typeStr = parseTypeFromQuickInfo(info);\n    const type = await context.resolveType(varDec, typeStr);\n    return new VariableSchema(location, name, displaySig, type);\n  }\n}\n"]}
+{"version":3,"names":["VariableDeclaration","predicate","node","kind","ts","SyntaxKind","getName","name","getText","getIdentifiers","ExportIdentifier","getSourceFile","fileName","transform","varDec","context","info","getQuickInfo","displaySig","body","displayString","location","getLocation","initializer","ArrowFunction","args","getParams","parameters","typeStr","parseReturnTypeFromQuickInfo","returnType","resolveType","FunctionLikeSchema","parseTypeFromQuickInfo","type","VariableSchema"],"sources":["variable-declaration.ts"],"sourcesContent":["import { SchemaNode, VariableSchema, FunctionLikeSchema } from '@teambit/semantics.entities.semantic-schema';\nimport ts, { Node, VariableDeclaration as VariableDeclarationNode, ArrowFunction } from 'typescript';\nimport { SchemaTransformer } from '../schema-transformer';\nimport { SchemaExtractorContext } from '../schema-extractor-context';\nimport { ExportIdentifier } from '../export-identifier';\nimport { getParams } from './utils/get-params';\nimport { parseReturnTypeFromQuickInfo, parseTypeFromQuickInfo } from './utils/parse-type-from-quick-info';\n\nexport class VariableDeclaration implements SchemaTransformer {\n  predicate(node: Node) {\n    return node.kind === ts.SyntaxKind.VariableDeclaration;\n  }\n\n  getName(node: VariableDeclarationNode) {\n    return node.name.getText();\n  }\n\n  async getIdentifiers(node: VariableDeclarationNode) {\n    return [new ExportIdentifier(node.name.getText(), node.getSourceFile().fileName)];\n  }\n\n  async transform(varDec: VariableDeclarationNode, context: SchemaExtractorContext): Promise<SchemaNode> {\n    const name = this.getName(varDec);\n    const info = await context.getQuickInfo(varDec.name);\n    const displaySig = info?.body?.displayString || '';\n    const location = context.getLocation(varDec);\n    if (varDec.initializer?.kind === ts.SyntaxKind.ArrowFunction) {\n      const args = await getParams((varDec.initializer as ArrowFunction).parameters, context);\n      const typeStr = parseReturnTypeFromQuickInfo(info);\n      const returnType = await context.resolveType(varDec, typeStr);\n      return new FunctionLikeSchema(location, name, args, returnType, displaySig);\n    }\n    const typeStr = parseTypeFromQuickInfo(info);\n    const type = await context.resolveType(varDec, typeStr);\n    return new VariableSchema(location, 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;;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,MAAD,EAAkCC,OAAlC,EAAwF;IAAA;;IACrG,MAAMR,IAAI,GAAG,KAAKD,OAAL,CAAaQ,MAAb,CAAb;IACA,MAAME,IAAI,GAAG,MAAMD,OAAO,CAACE,YAAR,CAAqBH,MAAM,CAACP,IAA5B,CAAnB;IACA,MAAMW,UAAU,GAAG,CAAAF,IAAI,SAAJ,IAAAA,IAAI,WAAJ,0BAAAA,IAAI,CAAEG,IAAN,0DAAYC,aAAZ,KAA6B,EAAhD;IACA,MAAMC,QAAQ,GAAGN,OAAO,CAACO,WAAR,CAAoBR,MAApB,CAAjB;;IACA,IAAI,wBAAAA,MAAM,CAACS,WAAP,4EAAoBpB,IAApB,MAA6BC,qBAAA,CAAGC,UAAH,CAAcmB,aAA/C,EAA8D;MAC5D,MAAMC,IAAI,GAAG,MAAM,IAAAC,sBAAA,EAAWZ,MAAM,CAACS,WAAR,CAAsCI,UAAhD,EAA4DZ,OAA5D,CAAnB;MACA,MAAMa,OAAO,GAAG,IAAAC,sDAAA,EAA6Bb,IAA7B,CAAhB;MACA,MAAMc,UAAU,GAAG,MAAMf,OAAO,CAACgB,WAAR,CAAoBjB,MAApB,EAA4Bc,OAA5B,CAAzB;MACA,OAAO,KAAII,uCAAJ,EAAuBX,QAAvB,EAAiCd,IAAjC,EAAuCkB,IAAvC,EAA6CK,UAA7C,EAAyDZ,UAAzD,CAAP;IACD;;IACD,MAAMU,OAAO,GAAG,IAAAK,gDAAA,EAAuBjB,IAAvB,CAAhB;IACA,MAAMkB,IAAI,GAAG,MAAMnB,OAAO,CAACgB,WAAR,CAAoBjB,MAApB,EAA4Bc,OAA5B,CAAnB;IACA,OAAO,KAAIO,mCAAJ,EAAmBd,QAAnB,EAA6Bd,IAA7B,EAAmCW,UAAnC,EAA+CgB,IAA/C,CAAP;EACD;;AA3B2D"}

package/dist/transformers/variable-statement.js.map

@@ -1 +1 @@
-{"version":3,"sources":["variable-statement.ts"],"names":["VariableStatementTransformer","predicate","node","kind","ts","SyntaxKind","VariableStatement","getIdentifiers","declarationList","declarations","map","dec","ExportIdentifier","name","getText","getSourceFile","fileName","transform","context","schemas","schema","visitDefinition","Module","getLocation"],"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;;AAGA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;;AAEA;AACA;AACA;AACA;AACO,MAAMA,4BAAN,CAAgE;AACrEC,EAAAA,SAAS,CAACC,IAAD,EAAa;AACpB,WAAOA,IAAI,CAACC,IAAL,KAAcC,sBAAGC,UAAH,CAAcC,iBAAnC;AACD;;AAEmB,QAAdC,cAAc,CAACL,IAAD,EAA0B;AAC5C,WAAOA,IAAI,CAACM,eAAL,CAAqBC,YAArB,CAAkCC,GAAlC,CAAuCC,GAAD,IAAS;AACpD,aAAO,KAAIC,oCAAJ,EAAqBD,GAAG,CAACE,IAAJ,CAASC,OAAT,EAArB,EAAyCH,GAAG,CAACI,aAAJ,GAAoBC,QAA7D,CAAP;AACD,KAFM,CAAP;AAGD;;AAEc,QAATC,SAAS,CAACf,IAAD,EAA0BgB,OAA1B,EAAgF;AAC7F,UAAMC,OAAO,GAAG,MAAM,2BAAWjB,IAAI,CAACM,eAAL,CAAqBC,YAAhC,EAA8C,MAAOE,GAAP,IAAe;AACjF;AACA,YAAMS,MAAM,GAAG,MAAMF,OAAO,CAACG,eAAR,CAAwBV,GAAG,CAACE,IAA5B,CAArB;AACA,aAAOO,MAAP;AACD,KAJqB,CAAtB;AAKA,WAAO,KAAIE,2BAAJ,EAAWJ,OAAO,CAACK,WAAR,CAAoBrB,IAApB,CAAX,EAAsC,uBAAQiB,OAAR,CAAtC,CAAP;AACD;;AAlBoE","sourcesContent":["import { SchemaNode, Module } from '@teambit/semantics.entities.semantic-schema';\nimport { compact } from 'lodash';\nimport pMapSeries from 'p-map-series';\nimport ts, { Node, VariableStatement } from 'typescript';\nimport { SchemaTransformer } from '../schema-transformer';\nimport { SchemaExtractorContext } from '../schema-extractor-context';\nimport { ExportIdentifier } from '../export-identifier';\n\n/**\n * variable statement is a collection of variable declarations.\n * e.g. `export const a = 1, b = () => {}, c = {};`\n */\nexport class VariableStatementTransformer implements SchemaTransformer {\n  predicate(node: Node) {\n    return node.kind === ts.SyntaxKind.VariableStatement;\n  }\n\n  async getIdentifiers(node: VariableStatement) {\n    return node.declarationList.declarations.map((dec) => {\n      return new ExportIdentifier(dec.name.getText(), dec.getSourceFile().fileName);\n    });\n  }\n\n  async transform(node: VariableStatement, context: SchemaExtractorContext): Promise<SchemaNode> {\n    const schemas = await pMapSeries(node.declarationList.declarations, async (dec) => {\n      // this will get the schema from variable-declaration\n      const schema = await context.visitDefinition(dec.name);\n      return schema;\n    });\n    return new Module(context.getLocation(node), compact(schemas));\n  }\n}\n"]}
+{"version":3,"names":["VariableStatementTransformer","predicate","node","kind","ts","SyntaxKind","VariableStatement","getIdentifiers","declarationList","declarations","map","dec","ExportIdentifier","name","getText","getSourceFile","fileName","transform","context","schemas","pMapSeries","schema","visitDefinition","Module","getLocation","compact"],"sources":["variable-statement.ts"],"sourcesContent":["import { SchemaNode, Module } from '@teambit/semantics.entities.semantic-schema';\nimport { compact } from 'lodash';\nimport pMapSeries from 'p-map-series';\nimport ts, { Node, VariableStatement } from 'typescript';\nimport { SchemaTransformer } from '../schema-transformer';\nimport { SchemaExtractorContext } from '../schema-extractor-context';\nimport { ExportIdentifier } from '../export-identifier';\n\n/**\n * variable statement is a collection of variable declarations.\n * e.g. `export const a = 1, b = () => {}, c = {};`\n */\nexport class VariableStatementTransformer implements SchemaTransformer {\n  predicate(node: Node) {\n    return node.kind === ts.SyntaxKind.VariableStatement;\n  }\n\n  async getIdentifiers(node: VariableStatement) {\n    return node.declarationList.declarations.map((dec) => {\n      return new ExportIdentifier(dec.name.getText(), dec.getSourceFile().fileName);\n    });\n  }\n\n  async transform(node: VariableStatement, context: SchemaExtractorContext): Promise<SchemaNode> {\n    const schemas = await pMapSeries(node.declarationList.declarations, async (dec) => {\n      // this will get the schema from variable-declaration\n      const schema = await context.visitDefinition(dec.name);\n      return schema;\n    });\n    return new Module(context.getLocation(node), compact(schemas));\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;;AAGA;EAAA;;EAAA;IAAA;EAAA;;EAAA;AAAA;;AAEA;AACA;AACA;AACA;AACO,MAAMA,4BAAN,CAAgE;EACrEC,SAAS,CAACC,IAAD,EAAa;IACpB,OAAOA,IAAI,CAACC,IAAL,KAAcC,qBAAA,CAAGC,UAAH,CAAcC,iBAAnC;EACD;;EAEmB,MAAdC,cAAc,CAACL,IAAD,EAA0B;IAC5C,OAAOA,IAAI,CAACM,eAAL,CAAqBC,YAArB,CAAkCC,GAAlC,CAAuCC,GAAD,IAAS;MACpD,OAAO,KAAIC,oCAAJ,EAAqBD,GAAG,CAACE,IAAJ,CAASC,OAAT,EAArB,EAAyCH,GAAG,CAACI,aAAJ,GAAoBC,QAA7D,CAAP;IACD,CAFM,CAAP;EAGD;;EAEc,MAATC,SAAS,CAACf,IAAD,EAA0BgB,OAA1B,EAAgF;IAC7F,MAAMC,OAAO,GAAG,MAAM,IAAAC,qBAAA,EAAWlB,IAAI,CAACM,eAAL,CAAqBC,YAAhC,EAA8C,MAAOE,GAAP,IAAe;MACjF;MACA,MAAMU,MAAM,GAAG,MAAMH,OAAO,CAACI,eAAR,CAAwBX,GAAG,CAACE,IAA5B,CAArB;MACA,OAAOQ,MAAP;IACD,CAJqB,CAAtB;IAKA,OAAO,KAAIE,2BAAJ,EAAWL,OAAO,CAACM,WAAR,CAAoBtB,IAApB,CAAX,EAAsC,IAAAuB,iBAAA,EAAQN,OAAR,CAAtC,CAAP;EACD;;AAlBoE"}

package/dist/typescript.aspect.js.map

@@ -1 +1 @@
-{"version":3,"sources":["typescript.aspect.ts"],"names":["TypescriptAspect","Aspect","create","id"],"mappings":";;;;;;;AAAA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;;AAEO,MAAMA,gBAAgB,GAAGC,kBAAOC,MAAP,CAAc;AAC5CC,EAAAA,EAAE,EAAE;AADwC,CAAd,CAAzB","sourcesContent":["import { Aspect } from '@teambit/harmony';\n\nexport const TypescriptAspect = Aspect.create({\n  id: 'teambit.typescript/typescript',\n});\n"]}
+{"version":3,"names":["TypescriptAspect","Aspect","create","id"],"sources":["typescript.aspect.ts"],"sourcesContent":["import { Aspect } from '@teambit/harmony';\n\nexport const TypescriptAspect = Aspect.create({\n  id: 'teambit.typescript/typescript',\n});\n"],"mappings":";;;;;;;AAAA;EAAA;;EAAA;IAAA;EAAA;;EAAA;AAAA;;AAEO,MAAMA,gBAAgB,GAAGC,iBAAA,CAAOC,MAAP,CAAc;EAC5CC,EAAE,EAAE;AADwC,CAAd,CAAzB"}