@teambit/typescript 0.0.728 → 0.0.731

package/dist/transformers/property-signature.d.ts

@@ -0,0 +1,10 @@
+import { SchemaNode } from '@teambit/semantics.entities.semantic-schema';
+import { Node, PropertySignature as PropertySignatureNode } from 'typescript';
+import { SchemaTransformer } from '../schema-transformer';
+import { SchemaExtractorContext } from '../schema-extractor-context';
+export declare class PropertySignature implements SchemaTransformer {
+    predicate(node: Node): boolean;
+    getName(node: PropertySignatureNode): string;
+    getIdentifiers(): Promise<never[]>;
+    transform(prop: PropertySignatureNode, context: SchemaExtractorContext): Promise<SchemaNode>;
+}

package/dist/transformers/property-signature.js

@@ -0,0 +1,90 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+require("core-js/modules/es.promise.js");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.PropertySignature = void 0;
+
+function _semanticsEntities() {
+  const data = require("@teambit/semantics.entities.semantic-schema");
+
+  _semanticsEntities = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _typescript() {
+  const data = _interopRequireDefault(require("typescript"));
+
+  _typescript = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _getParams() {
+  const data = require("./utils/get-params");
+
+  _getParams = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _parseTypeFromQuickInfo() {
+  const data = require("./utils/parse-type-from-quick-info");
+
+  _parseTypeFromQuickInfo = function () {
+    return data;
+  };
+
+  return data;
+}
+
+class PropertySignature {
+  predicate(node) {
+    return node.kind === _typescript().default.SyntaxKind.PropertySignature;
+  }
+
+  getName(node) {
+    return node.name.getText();
+  }
+
+  async getIdentifiers() {
+    return [];
+  }
+
+  async transform(prop, context) {
+    var _info$body, _prop$type;
+
+    const name = this.getName(prop);
+    const info = await context.getQuickInfo(prop.name);
+    const displaySig = (info === null || info === void 0 ? void 0 : (_info$body = info.body) === null || _info$body === void 0 ? void 0 : _info$body.displayString) || '';
+
+    if (((_prop$type = prop.type) === null || _prop$type === void 0 ? void 0 : _prop$type.kind) === _typescript().default.SyntaxKind.FunctionType) {
+      // e.g. `propertySig: () => void;` inside interface
+      const propType = prop.type;
+      const args = await (0, _getParams().getParams)(propType.parameters, context);
+      const typeStr = (0, _parseTypeFromQuickInfo().parseReturnTypeFromQuickInfo)(info);
+      const returnType = await context.resolveType(propType, typeStr);
+      return new (_semanticsEntities().FunctionSchema)(name, args, returnType, displaySig);
+    }
+
+    const typeStr = (0, _parseTypeFromQuickInfo().parseTypeFromQuickInfo)(info);
+    const type = await context.resolveType(prop, typeStr);
+    return new (_semanticsEntities().VariableSchema)(name, displaySig, type);
+  }
+
+}
+
+exports.PropertySignature = PropertySignature;
+
+//# sourceMappingURL=property-signature.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["property-signature.ts"],"names":["PropertySignature","predicate","node","kind","ts","SyntaxKind","getName","name","getText","getIdentifiers","transform","prop","context","info","getQuickInfo","displaySig","body","displayString","type","FunctionType","propType","args","parameters","typeStr","returnType","resolveType","FunctionSchema","VariableSchema"],"mappings":";;;;;;;;;;;AAAA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;;AACA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;;AACA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;;AAGA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;;AAEO,MAAMA,iBAAN,CAAqD;AAC1DC,EAAAA,SAAS,CAACC,IAAD,EAAa;AACpB,WAAOA,IAAI,CAACC,IAAL,KAAcC,sBAAGC,UAAH,CAAcL,iBAAnC;AACD;;AAEDM,EAAAA,OAAO,CAACJ,IAAD,EAA8B;AACnC,WAAOA,IAAI,CAACK,IAAL,CAAUC,OAAV,EAAP;AACD;;AAEmB,QAAdC,cAAc,GAAG;AACrB,WAAO,EAAP;AACD;;AAEc,QAATC,SAAS,CAACC,IAAD,EAA8BC,OAA9B,EAAoF;AAAA;;AACjG,UAAML,IAAI,GAAG,KAAKD,OAAL,CAAaK,IAAb,CAAb;AACA,UAAME,IAAI,GAAG,MAAMD,OAAO,CAACE,YAAR,CAAqBH,IAAI,CAACJ,IAA1B,CAAnB;AACA,UAAMQ,UAAU,GAAG,CAAAF,IAAI,SAAJ,IAAAA,IAAI,WAAJ,0BAAAA,IAAI,CAAEG,IAAN,0DAAYC,aAAZ,KAA6B,EAAhD;;AACA,QAAI,eAAAN,IAAI,CAACO,IAAL,0DAAWf,IAAX,MAAoBC,sBAAGC,UAAH,CAAcc,YAAtC,EAAoD;AAClD;AACA,YAAMC,QAAQ,GAAGT,IAAI,CAACO,IAAtB;AACA,YAAMG,IAAI,GAAG,MAAM,4BAAUD,QAAQ,CAACE,UAAnB,EAA+BV,OAA/B,CAAnB;AACA,YAAMW,OAAO,GAAG,4DAA6BV,IAA7B,CAAhB;AACA,YAAMW,UAAU,GAAG,MAAMZ,OAAO,CAACa,WAAR,CAAoBL,QAApB,EAA8BG,OAA9B,CAAzB;AACA,aAAO,KAAIG,mCAAJ,EAAmBnB,IAAnB,EAAyBc,IAAzB,EAA+BG,UAA/B,EAA2CT,UAA3C,CAAP;AACD;;AACD,UAAMQ,OAAO,GAAG,sDAAuBV,IAAvB,CAAhB;AACA,UAAMK,IAAI,GAAG,MAAMN,OAAO,CAACa,WAAR,CAAoBd,IAApB,EAA0BY,OAA1B,CAAnB;AACA,WAAO,KAAII,mCAAJ,EAAmBpB,IAAnB,EAAyBQ,UAAzB,EAAqCG,IAArC,CAAP;AACD;;AA5ByD","sourcesContent":["import { FunctionSchema, SchemaNode, VariableSchema } from '@teambit/semantics.entities.semantic-schema';\nimport ts, { FunctionTypeNode, Node, PropertySignature as PropertySignatureNode } from 'typescript';\nimport { getParams } from './utils/get-params';\nimport { SchemaTransformer } from '../schema-transformer';\nimport { SchemaExtractorContext } from '../schema-extractor-context';\nimport { parseReturnTypeFromQuickInfo, parseTypeFromQuickInfo } from './utils/parse-type-from-quick-info';\n\nexport class PropertySignature implements SchemaTransformer {\n  predicate(node: Node) {\n    return node.kind === ts.SyntaxKind.PropertySignature;\n  }\n\n  getName(node: PropertySignatureNode) {\n    return node.name.getText();\n  }\n\n  async getIdentifiers() {\n    return [];\n  }\n\n  async transform(prop: PropertySignatureNode, context: SchemaExtractorContext): Promise<SchemaNode> {\n    const name = this.getName(prop);\n    const info = await context.getQuickInfo(prop.name);\n    const displaySig = info?.body?.displayString || '';\n    if (prop.type?.kind === ts.SyntaxKind.FunctionType) {\n      // e.g. `propertySig: () => void;` inside interface\n      const propType = prop.type as FunctionTypeNode;\n      const args = await getParams(propType.parameters, context);\n      const typeStr = parseReturnTypeFromQuickInfo(info);\n      const returnType = await context.resolveType(propType, typeStr);\n      return new FunctionSchema(name, args, returnType, displaySig);\n    }\n    const typeStr = parseTypeFromQuickInfo(info);\n    const type = await context.resolveType(prop, typeStr);\n    return new VariableSchema(name, displaySig, type);\n  }\n}\n"]}

package/dist/transformers/source-file-transformer.d.ts

@@ -1,11 +1,12 @@
 import { Node, SourceFile } from 'typescript';
+import { Module } from '@teambit/semantics.entities.semantic-schema';
 import { SchemaTransformer } from '../schema-transformer';
 import { ExportIdentifier } from '../export-identifier';
 import { SchemaExtractorContext } from '../schema-extractor-context';
 export declare class SourceFileTransformer implements SchemaTransformer {
     predicate(node: Node): boolean;
     getIdentifiers(sourceFile: SourceFile, context: SchemaExtractorContext): Promise<ExportIdentifier[]>;
-    transform(node: SourceFile, context: SchemaExtractorContext): Promise<(import("@teambit/semantics.entities.semantic-schema").SchemaNode | undefined)[]>;
+    transform(node: SourceFile, context: SchemaExtractorContext): Promise<Module>;
     /**
      * list all exports of a source file.
      */

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

@@ -31,6 +31,26 @@ function _lodash() {
   return data;
 }
 
+function _pMapSeries() {
+  const data = _interopRequireDefault(require("p-map-series"));
+
+  _pMapSeries = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _semanticsEntities() {
+  const data = require("@teambit/semantics.entities.semantic-schema");
+
+  _semanticsEntities = function () {
+    return data;
+  };
+
+  return data;
+}
+
 class SourceFileTransformer {
   predicate(node) {
     return node.kind === _typescript().default.SyntaxKind.SourceFile;
@@ -51,10 +71,10 @@ class SourceFileTransformer {
 
   async transform(node, context) {
     const exports = this.listExports(node);
-    const schemas = await Promise.all(exports.map(exportNode => {
+    const schemas = await (0, _pMapSeries().default)(exports, exportNode => {
       return context.computeSchema(exportNode);
-    }));
-    return schemas;
+    });
+    return new (_semanticsEntities().Module)(schemas);
   }
   /**
    * list all exports of a source file.

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

@@ -1 +1 @@
-{"version":3,"sources":["source-file-transformer.ts"],"names":["SourceFileTransformer","predicate","node","kind","ts","SyntaxKind","SourceFile","getIdentifiers","sourceFile","context","exports","listExports","exportNames","Promise","all","map","getExportedIdentifiers","exportIds","reduce","acc","current","item","find","exportName","id","push","transform","schemas","exportNode","computeSchema","ast","statements","statement","ExportDeclaration","isExport","Boolean","modifiers","modifier","ExportKeyword"],"mappings":";;;;;;;;;;;;;AAAA;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,MAAMd,OAAO,CAACC,GAAR,CACpBJ,OAAO,CAACK,GAAR,CAAaa,UAAD,IAAgB;AAC1B,aAAOnB,OAAO,CAACoB,aAAR,CAAsBD,UAAtB,CAAP;AACD,KAFD,CADoB,CAAtB;AAMA,WAAOD,OAAP;AACD;AAED;AACF;AACA;;;AACUhB,EAAAA,WAAW,CAACmB,GAAD,EAA0B;AAC3C,WAAO,uBACLA,GAAG,CAACC,UAAJ,CAAehB,GAAf,CAAoBiB,SAAD,IAAe;AAAA;;AAChC,UAAIA,SAAS,CAAC7B,IAAV,KAAmBC,sBAAGC,UAAH,CAAc4B,iBAArC,EAAwD,OAAOD,SAAP;AACxD,YAAME,QAAQ,GAAGC,OAAO,yBACtBH,SAAS,CAACI,SADY,yDACtB,qBAAqBd,IAArB,CAA2Be,QAAD,IAAc;AACtC,eAAOA,QAAQ,CAAClC,IAAT,KAAkBC,sBAAGC,UAAH,CAAciC,aAAvC;AACD,OAFD,CADsB,CAAxB,CAFgC,CAQhC;;AACA,UAAI,CAACJ,QAAL,EAAe;AACf,aAAOF,SAAP;AACD,KAXD,CADK,CAAP;AAcD;;AApD6D","sourcesContent":["import ts, { Node, SourceFile } from 'typescript';\nimport { compact, flatten } from 'lodash';\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 Promise.all(\n      exports.map((exportNode) => {\n        return context.computeSchema(exportNode);\n      })\n    );\n\n    return 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,"sources":["source-file-transformer.ts"],"names":["SourceFileTransformer","predicate","node","kind","ts","SyntaxKind","SourceFile","getIdentifiers","sourceFile","context","exports","listExports","exportNames","Promise","all","map","getExportedIdentifiers","exportIds","reduce","acc","current","item","find","exportName","id","push","transform","schemas","exportNode","computeSchema","Module","ast","statements","statement","ExportDeclaration","isExport","Boolean","modifiers","modifier","ExportKeyword"],"mappings":";;;;;;;;;;;;;AAAA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;;AACA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;;AACA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;;AACA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;;AAKO,MAAMA,qBAAN,CAAyD;AAC9DC,EAAAA,SAAS,CAACC,IAAD,EAAa;AACpB,WAAOA,IAAI,CAACC,IAAL,KAAcC,sBAAGC,UAAH,CAAcC,UAAnC;AACD;;AAEmB,QAAdC,cAAc,CAACC,UAAD,EAAyBC,OAAzB,EAA0D;AAC5E,UAAMC,OAAO,GAAG,KAAKC,WAAL,CAAiBH,UAAjB,CAAhB;AAEA,UAAMI,WAAW,GAAG,MAAMC,OAAO,CAACC,GAAR,CACxBJ,OAAO,CAACK,GAAR,CAAab,IAAD,IAAgB;AAC1B,aAAOO,OAAO,CAACO,sBAAR,CAA+Bd,IAA/B,CAAP;AACD,KAFD,CADwB,CAA1B;AAMA,UAAMe,SAAS,GAAG,uBAAQL,WAAR,EAAqBM,MAArB,CAAgD,CAACC,GAAD,EAAMC,OAAN,KAAkB;AAClF,YAAMC,IAAI,GAAGF,GAAG,CAACG,IAAJ,CAAUC,UAAD,IAAgBA,UAAU,CAACC,EAAX,KAAkBJ,OAAO,CAACI,EAAnD,CAAb;AACA,UAAI,CAACH,IAAL,EAAWF,GAAG,CAACM,IAAJ,CAASL,OAAT;AACX,aAAOD,GAAP;AACD,KAJiB,EAIf,EAJe,CAAlB;AAMA,WAAOF,SAAP;AACD;;AAEc,QAATS,SAAS,CAACxB,IAAD,EAAmBO,OAAnB,EAAoD;AACjE,UAAMC,OAAO,GAAG,KAAKC,WAAL,CAAiBT,IAAjB,CAAhB;AACA,UAAMyB,OAAO,GAAG,MAAM,2BAAWjB,OAAX,EAAqBkB,UAAD,IAAgB;AACxD,aAAOnB,OAAO,CAACoB,aAAR,CAAsBD,UAAtB,CAAP;AACD,KAFqB,CAAtB;AAIA,WAAO,KAAIE,2BAAJ,EAAWH,OAAX,CAAP;AACD;AAED;AACF;AACA;;;AACUhB,EAAAA,WAAW,CAACoB,GAAD,EAA0B;AAC3C,WAAO,uBACLA,GAAG,CAACC,UAAJ,CAAejB,GAAf,CAAoBkB,SAAD,IAAe;AAAA;;AAChC,UAAIA,SAAS,CAAC9B,IAAV,KAAmBC,sBAAGC,UAAH,CAAc6B,iBAArC,EAAwD,OAAOD,SAAP;AACxD,YAAME,QAAQ,GAAGC,OAAO,yBACtBH,SAAS,CAACI,SADY,yDACtB,qBAAqBf,IAArB,CAA2BgB,QAAD,IAAc;AACtC,eAAOA,QAAQ,CAACnC,IAAT,KAAkBC,sBAAGC,UAAH,CAAckC,aAAvC;AACD,OAFD,CADsB,CAAxB,CAFgC,CAQhC;;AACA,UAAI,CAACJ,QAAL,EAAe;AACf,aAAOF,SAAP;AACD,KAXD,CADK,CAAP;AAcD;;AAlD6D","sourcesContent":["import ts, { Node, SourceFile } from 'typescript';\nimport { compact, flatten } from 'lodash';\nimport pMapSeries from 'p-map-series';\nimport { Module } from '@teambit/semantics.entities.semantic-schema';\nimport { SchemaTransformer } from '../schema-transformer';\nimport { ExportIdentifier } from '../export-identifier';\nimport { SchemaExtractorContext } from '../schema-extractor-context';\n\nexport class SourceFileTransformer implements SchemaTransformer {\n  predicate(node: Node) {\n    return node.kind === ts.SyntaxKind.SourceFile;\n  }\n\n  async getIdentifiers(sourceFile: SourceFile, context: SchemaExtractorContext) {\n    const exports = this.listExports(sourceFile);\n\n    const exportNames = await Promise.all(\n      exports.map((node: Node) => {\n        return context.getExportedIdentifiers(node);\n      })\n    );\n\n    const exportIds = flatten(exportNames).reduce<ExportIdentifier[]>((acc, current) => {\n      const item = acc.find((exportName) => exportName.id === current.id);\n      if (!item) acc.push(current);\n      return acc;\n    }, []);\n\n    return exportIds;\n  }\n\n  async transform(node: SourceFile, context: SchemaExtractorContext) {\n    const exports = this.listExports(node);\n    const schemas = await pMapSeries(exports, (exportNode) => {\n      return context.computeSchema(exportNode);\n    });\n\n    return new Module(schemas);\n  }\n\n  /**\n   * list all exports of a source file.\n   */\n  private listExports(ast: SourceFile): Node[] {\n    return compact(\n      ast.statements.map((statement) => {\n        if (statement.kind === ts.SyntaxKind.ExportDeclaration) return statement;\n        const isExport = Boolean(\n          statement.modifiers?.find((modifier) => {\n            return modifier.kind === ts.SyntaxKind.ExportKeyword;\n          })\n        );\n\n        // eslint-disable-next-line consistent-return\n        if (!isExport) return;\n        return statement;\n      })\n    );\n  }\n}\n"]}

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

@@ -1,8 +1,11 @@
 import { Node, TypeAliasDeclaration } from 'typescript';
+import { TypeSchema } from '@teambit/semantics.entities.semantic-schema';
 import { SchemaTransformer } from '../schema-transformer';
+import { SchemaExtractorContext } from '../schema-extractor-context';
 import { ExportIdentifier } from '../export-identifier';
 export declare class TypeAliasTransformer implements SchemaTransformer {
     predicate(node: Node): boolean;
     getIdentifiers(node: TypeAliasDeclaration): Promise<ExportIdentifier[]>;
-    transform(): Promise<{}>;
+    private getName;
+    transform(typeAlias: TypeAliasDeclaration, context: SchemaExtractorContext): Promise<TypeSchema>;
 }

package/dist/transformers/type-alias.js

@@ -19,6 +19,16 @@ function _typescript() {
   return data;
 }
 
+function _semanticsEntities() {
+  const data = require("@teambit/semantics.entities.semantic-schema");
+
+  _semanticsEntities = function () {
+    return data;
+  };
+
+  return data;
+}
+
 function _exportIdentifier() {
   const data = require("../export-identifier");
 
@@ -29,6 +39,16 @@ function _exportIdentifier() {
   return data;
 }
 
+function _typeNodeToSchema() {
+  const data = require("./utils/type-node-to-schema");
+
+  _typeNodeToSchema = function () {
+    return data;
+  };
+
+  return data;
+}
+
 class TypeAliasTransformer {
   predicate(node) {
     return node.kind === _typescript().default.SyntaxKind.TypeAliasDeclaration;
@@ -38,8 +58,17 @@ class TypeAliasTransformer {
     return [new (_exportIdentifier().ExportIdentifier)(node.name.getText(), node.getSourceFile().fileName)];
   }
 
-  async transform() {
-    return {};
+  getName(node) {
+    return node.name.getText();
+  }
+
+  async transform(typeAlias, context) {
+    var _info$body;
+
+    const type = await (0, _typeNodeToSchema().typeNodeToSchema)(typeAlias.type, context);
+    const info = await context.getQuickInfo(typeAlias.name);
+    const displaySig = info === null || info === void 0 ? void 0 : (_info$body = info.body) === null || _info$body === void 0 ? void 0 : _info$body.displayString;
+    return new (_semanticsEntities().TypeSchema)(this.getName(typeAlias), type, displaySig);
   }
 
 }

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

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

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

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

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

@@ -0,0 +1,69 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+require("core-js/modules/es.promise.js");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getParams = getParams;
+
+function _semanticsEntities() {
+  const data = require("@teambit/semantics.entities.semantic-schema");
+
+  _semanticsEntities = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _pMapSeries() {
+  const data = _interopRequireDefault(require("p-map-series"));
+
+  _pMapSeries = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _parseTypeFromQuickInfo() {
+  const data = require("./parse-type-from-quick-info");
+
+  _parseTypeFromQuickInfo = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _typeNodeToSchema() {
+  const data = require("./type-node-to-schema");
+
+  _typeNodeToSchema = function () {
+    return data;
+  };
+
+  return data;
+}
+
+async function getParams(parameterNodes, context) {
+  return (0, _pMapSeries().default)(parameterNodes, async param => {
+    return new (_semanticsEntities().ParameterSchema)(param.name.getText(), await getParamType(param, context), param.initializer ? param.initializer.getText() : undefined);
+  });
+}
+
+async function getParamType(param, context) {
+  if (param.type) {
+    const type = param.type;
+    return (0, _typeNodeToSchema().typeNodeToSchema)(type, context);
+  }
+
+  const info = await context.getQuickInfo(param.name);
+  const parsed = (0, _parseTypeFromQuickInfo().parseTypeFromQuickInfo)(info);
+  return new (_semanticsEntities().TypeRefSchema)(parsed || 'any');
+}
+
+//# sourceMappingURL=get-params.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["get-params.ts"],"names":["getParams","parameterNodes","context","param","ParameterSchema","name","getText","getParamType","initializer","undefined","type","info","getQuickInfo","parsed","TypeRefSchema"],"mappings":";;;;;;;;;;;AAAA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;;AACA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;;AAGA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;;AACA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;;AAEO,eAAeA,SAAf,CACLC,cADK,EAELC,OAFK,EAGuB;AAC5B,SAAO,2BAAWD,cAAX,EAA2B,MAAOE,KAAP,IAAiB;AACjD,WAAO,KAAIC,oCAAJ,EACLD,KAAK,CAACE,IAAN,CAAWC,OAAX,EADK,EAEL,MAAMC,YAAY,CAACJ,KAAD,EAAQD,OAAR,CAFb,EAGLC,KAAK,CAACK,WAAN,GAAoBL,KAAK,CAACK,WAAN,CAAkBF,OAAlB,EAApB,GAAkDG,SAH7C,CAAP;AAKD,GANM,CAAP;AAOD;;AAED,eAAeF,YAAf,CAA4BJ,KAA5B,EAAyDD,OAAzD,EAA+G;AAC7G,MAAIC,KAAK,CAACO,IAAV,EAAgB;AACd,UAAMA,IAAI,GAAGP,KAAK,CAACO,IAAnB;AACA,WAAO,0CAAiBA,IAAjB,EAAuBR,OAAvB,CAAP;AACD;;AACD,QAAMS,IAAI,GAAG,MAAMT,OAAO,CAACU,YAAR,CAAqBT,KAAK,CAACE,IAA3B,CAAnB;AACA,QAAMQ,MAAM,GAAG,sDAAuBF,IAAvB,CAAf;AACA,SAAO,KAAIG,kCAAJ,EAAkBD,MAAM,IAAI,KAA5B,CAAP;AACD","sourcesContent":["import { ParameterSchema, SchemaNode, TypeRefSchema } from '@teambit/semantics.entities.semantic-schema';\nimport pMapSeries from 'p-map-series';\nimport { ParameterDeclaration, NodeArray } from 'typescript';\nimport { SchemaExtractorContext } from '../../schema-extractor-context';\nimport { parseTypeFromQuickInfo } from './parse-type-from-quick-info';\nimport { typeNodeToSchema } from './type-node-to-schema';\n\nexport async function getParams(\n  parameterNodes: NodeArray<ParameterDeclaration>,\n  context: SchemaExtractorContext\n): Promise<ParameterSchema[]> {\n  return pMapSeries(parameterNodes, async (param) => {\n    return new ParameterSchema(\n      param.name.getText(),\n      await getParamType(param, context),\n      param.initializer ? param.initializer.getText() : undefined\n    );\n  });\n}\n\nasync function getParamType(param: ParameterDeclaration, context: SchemaExtractorContext): Promise<SchemaNode> {\n  if (param.type) {\n    const type = param.type;\n    return typeNodeToSchema(type, context);\n  }\n  const info = await context.getQuickInfo(param.name);\n  const parsed = parseTypeFromQuickInfo(info);\n  return new TypeRefSchema(parsed || 'any');\n}\n"]}

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

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

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

@@ -0,0 +1,112 @@
+"use strict";
+
+require("core-js/modules/es.array.iterator.js");
+
+require("core-js/modules/es.regexp.exec.js");
+
+require("core-js/modules/es.string.trim.js");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.parseReturnTypeFromQuickInfo = parseReturnTypeFromQuickInfo;
+exports.parseTypeFromQuickInfo = parseTypeFromQuickInfo;
+
+// eslint-disable-next-line import/no-unresolved
+
+/**
+ * try to parse the type from the quickinfo.
+ * this is an error-prone process, we do our best here.
+ *
+ * an example of a function with many ":"
+ * `export function getObj(a: string, func: (b: number) => {}) { return { a: 1, b: 2 } };`
+ * which produce the following quickinfo:
+ * ```ts
+ * function getObj(a: string, func: (b: number) => {}): {
+ *   a: number;
+ *   b: number;
+ * }
+ * ```
+ *
+ * some examples of quickinfo:
+ *
+ * function ts.signatureToDisplayParts(typechecker: TypeChecker, signature: Signature, enclosingDeclaration?: Node | undefined, flags?: TypeFormatFlags): SymbolDisplayPart[]
+ *
+ * const enum ts.TypeFormatFlags
+ *
+ * (method) ts.TypeChecker.writeSignature(signature: Signature, enclosingDeclaration?: Node | undefined, flags?: TypeFormatFlags | undefined, kind?: SignatureKind | undefined, writer?: EmitTextWriter | undefined): string
+ *
+ * const obj: {
+ *   a: number;
+ *   b: number;
+ *  }
+ *
+ * function getObj(a: string): {
+ *     a: number;
+ *     b: number;
+ * }
+ */
+function parseTypeFromQuickInfo(quickInfo) {
+  var _quickInfo$body;
+
+  if (!(quickInfo !== null && quickInfo !== void 0 && (_quickInfo$body = quickInfo.body) !== null && _quickInfo$body !== void 0 && _quickInfo$body.displayString)) return '';
+  const displayString = quickInfo.body.displayString;
+  const splitByColon = displayString.split(':');
+
+  switch (quickInfo.body.kind) {
+    case 'const':
+    case 'property':
+    case 'let':
+    case 'var':
+      {
+        const [, ...tail] = splitByColon;
+        return tail.join(':').trim();
+      }
+
+    case 'method':
+    case 'function':
+      {
+        const split = displayString.split('): ');
+
+        if (split.length !== 2) {
+          throw new Error(`quickinfo of a function below was not implemented.\n${displayString}`);
+        }
+
+        return split[1].trim();
+      }
+
+    case 'alias':
+      {
+        // e.g. (alias) class BuilderService\nimport BuilderService
+        // e.g. '(alias) type Serializable = {\n' +
+        // '    toString(): string;\n' +
+        // '}\n' +
+        // 'import Serializable'
+        const firstLine = displayString.split('\n')[0];
+        const splitBySpace = firstLine.trim().split(' '); // first two are alias keyword and alias type
+
+        const [,, typeName] = splitBySpace;
+        return typeName;
+      }
+
+    case 'type':
+      {
+        // e.g. `type TaskSlot = SlotRegistry<BuildTask[]>`
+        const splitByEqual = displayString.split('=');
+        const [, ...tail] = splitByEqual;
+        return tail.join('=').trim();
+      }
+
+    default:
+      return splitByColon[splitByColon.length - 1].trim();
+  }
+}
+
+function parseReturnTypeFromQuickInfo(quickInfo) {
+  if (!quickInfo) return '';
+  const typeStr = parseTypeFromQuickInfo(quickInfo);
+  const array = typeStr.split('=>');
+  return array[array.length - 1].trim();
+}
+
+//# sourceMappingURL=parse-type-from-quick-info.js.map

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

@@ -0,0 +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"]}

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

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