@teambit/typescript 0.0.726 → 0.0.729

package/dist/transformers/constructor.js

@@ -0,0 +1,70 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+require("core-js/modules/es.promise.js");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Constructor = 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 _exportIdentifier() {
+  const data = require("../export-identifier");
+
+  _exportIdentifier = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _getParams() {
+  const data = require("./utils/get-params");
+
+  _getParams = function () {
+    return data;
+  };
+
+  return data;
+}
+
+class Constructor {
+  predicate(node) {
+    return node.kind === _typescript().default.SyntaxKind.Constructor;
+  }
+
+  async getIdentifiers(node) {
+    return [new (_exportIdentifier().ExportIdentifier)('constructor', node.getSourceFile().fileName)];
+  }
+
+  async transform(constructorDec, context) {
+    const args = await (0, _getParams().getParams)(constructorDec.parameters, context);
+    return new (_semanticsEntities().ConstructorSchema)(args);
+  }
+
+}
+
+exports.Constructor = Constructor;
+
+//# sourceMappingURL=constructor.js.map

package/dist/transformers/constructor.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["constructor.ts"],"names":["Constructor","predicate","node","kind","ts","SyntaxKind","getIdentifiers","ExportIdentifier","getSourceFile","fileName","transform","constructorDec","context","args","parameters","ConstructorSchema"],"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,WAAN,CAA+C;AACpDC,EAAAA,SAAS,CAACC,IAAD,EAAa;AACpB,WAAOA,IAAI,CAACC,IAAL,KAAcC,sBAAGC,UAAH,CAAcL,WAAnC;AACD;;AAEmB,QAAdM,cAAc,CAACJ,IAAD,EAA+B;AACjD,WAAO,CAAC,KAAIK,oCAAJ,EAAqB,aAArB,EAAoCL,IAAI,CAACM,aAAL,GAAqBC,QAAzD,CAAD,CAAP;AACD;;AAEc,QAATC,SAAS,CAACC,cAAD,EAAyCC,OAAzC,EAA+F;AAC5G,UAAMC,IAAI,GAAG,MAAM,4BAAUF,cAAc,CAACG,UAAzB,EAAqCF,OAArC,CAAnB;AAEA,WAAO,KAAIG,sCAAJ,EAAsBF,IAAtB,CAAP;AACD;;AAbmD","sourcesContent":["import { SchemaNode, ConstructorSchema } from '@teambit/semantics.entities.semantic-schema';\nimport ts, { Node, ConstructorDeclaration } from 'typescript';\nimport { SchemaExtractorContext } from '../schema-extractor-context';\nimport { SchemaTransformer } from '../schema-transformer';\nimport { ExportIdentifier } from '../export-identifier';\nimport { getParams } from './utils/get-params';\n\nexport class Constructor implements SchemaTransformer {\n  predicate(node: Node) {\n    return node.kind === ts.SyntaxKind.Constructor;\n  }\n\n  async getIdentifiers(node: ConstructorDeclaration) {\n    return [new ExportIdentifier('constructor', node.getSourceFile().fileName)];\n  }\n\n  async transform(constructorDec: ConstructorDeclaration, context: SchemaExtractorContext): Promise<SchemaNode> {\n    const args = await getParams(constructorDec.parameters, context);\n\n    return new ConstructorSchema(args);\n  }\n}\n"]}

package/dist/transformers/export-declaration.d.ts

@@ -1,3 +1,4 @@
+import { SchemaNode } from '@teambit/semantics.entities.semantic-schema';
 import { Node, ExportDeclaration as ExportDeclarationNode } from 'typescript';
 import { SchemaExtractorContext } from '../schema-extractor-context';
 import { SchemaTransformer } from '../schema-transformer';
@@ -5,5 +6,5 @@ import { ExportIdentifier } from '../export-identifier';
 export declare class ExportDeclaration implements SchemaTransformer {
     predicate(node: Node): boolean;
     getIdentifiers(exportDec: ExportDeclarationNode, context: SchemaExtractorContext): Promise<ExportIdentifier[]>;
-    transform(node: Node, context: SchemaExtractorContext): Promise<{}>;
+    transform(node: Node, context: SchemaExtractorContext): Promise<SchemaNode>;
 }

package/dist/transformers/export-declaration.js

@@ -9,6 +9,26 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.ExportDeclaration = void 0;
 
+function _semanticsEntities() {
+  const data = require("@teambit/semantics.entities.semantic-schema");
+
+  _semanticsEntities = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _lodash() {
+  const data = require("lodash");
+
+  _lodash = function () {
+    return data;
+  };
+
+  return data;
+}
+
 function _typescript() {
   const data = _interopRequireWildcard(require("typescript"));
 
@@ -60,24 +80,55 @@ class ExportDeclaration {
   }
 
   async transform(node, context) {
-    const exportDec = node; // sourceFile.sear
-
-    const exportClause = exportDec.exportClause;
+    const exportDec = node;
+    const exportClause = exportDec.exportClause; // e.g. `export { button1, button2 } as Composition from './button';
 
     if ((exportClause === null || exportClause === void 0 ? void 0 : exportClause.kind) === _typescript().SyntaxKind.NamedExports) {
-      exportClause; // eslint-disable-next-line @typescript-eslint/no-unused-vars
-
-      const exports = await Promise.all(exportClause.elements.map(async element => {
-        // const sig = await context.visitDefinition(element.name);
-        await context.visitDefinition(element.name);
-        return element.name;
+      exportClause;
+      const schemas = await Promise.all(exportClause.elements.map(async element => {
+        return context.visitDefinition(element.name);
       }));
-      return []; // return exports.map((identifier) => {
-      //   // const type = context.resolveType(identifier);
-      // });
+      return new (_semanticsEntities().Module)((0, _lodash().compact)(schemas));
+    } // e.g. `export * as Composition from './button';
+
+
+    if ((exportClause === null || exportClause === void 0 ? void 0 : exportClause.kind) === _typescript().SyntaxKind.NamespaceExport) {
+      exportClause;
+      const namespace = exportClause.name.getText();
+      const sourceFile = await context.getSourceFileFromNode(exportClause.name);
+
+      if (!sourceFile) {
+        throw new Error(`unable to find the source-file for "${namespace}"`);
+      }
+
+      const result = await context.computeSchema(sourceFile);
+
+      if (!(result instanceof _semanticsEntities().Module)) {
+        throw new Error(`expect result to be instance of Module`);
+      }
+
+      result.namespace = namespace;
+      return result;
+    } // it's export-all, e.g. `export * from './button'`;
+
+
+    if (!exportClause) {
+      const specifier = exportDec.moduleSpecifier;
+
+      if (!specifier) {
+        throw new Error(`fatal: no specifier`);
+      }
+
+      const sourceFile = await context.getSourceFileFromNode(specifier);
+
+      if (!sourceFile) {
+        throw new Error(`unable to find the source-file`);
+      }
+
+      return context.computeSchema(sourceFile);
     }
 
-    return {};
+    throw new Error('unrecognized export type');
   }
 
 }

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

@@ -1 +1 @@
-{"version":3,"sources":["export-declaration.ts"],"names":["ExportDeclaration","predicate","node","kind","SyntaxKind","getIdentifiers","exportDec","context","exportClause","ts","NamedExports","elements","map","elm","ExportIdentifier","name","getText","getSourceFile","fileName","NamespaceExport","moduleSpecifier","getFileExports","transform","exports","Promise","all","element","visitDefinition"],"mappings":";;;;;;;;;;;AAAA;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,yBAAWJ,iBAAhC;AACD;;AAEmB,QAAdK,cAAc,CAACC,SAAD,EAAmCC,OAAnC,EAAoE;AAAA;;AACtF,QAAI,0BAAAD,SAAS,CAACE,YAAV,gFAAwBL,IAAxB,MAAiCM,sBAAGL,UAAH,CAAcM,YAAnD,EAAiE;AAC/DJ,MAAAA,SAAS,CAACE,YAAV;AACA,aAAOF,SAAS,CAACE,YAAV,CAAuBG,QAAvB,CAAgCC,GAAhC,CAAqCC,GAAD,IAAS;AAClD,eAAO,KAAIC,oCAAJ,EAAqBD,GAAG,CAACE,IAAJ,CAASC,OAAT,EAArB,EAAyCH,GAAG,CAACI,aAAJ,GAAoBC,QAA7D,CAAP;AACD,OAFM,CAAP;AAGD;;AAED,QAAI,2BAAAZ,SAAS,CAACE,YAAV,kFAAwBL,IAAxB,MAAiCM,sBAAGL,UAAH,CAAce,eAAnD,EAAoE;AAClE,aAAO,CAAC,KAAIL,oCAAJ,EAAqBR,SAAS,CAACE,YAAV,CAAuBO,IAAvB,CAA4BC,OAA5B,EAArB,EAA4DV,SAAS,CAACW,aAAV,GAA0BC,QAAtF,CAAD,CAAP;AACD;;AAED,QAAIZ,SAAS,CAACc,eAAd,EAA+B;AAC7B,aAAOb,OAAO,CAACc,cAAR,CAAuBf,SAAvB,CAAP;AACD;;AAED,WAAO,EAAP;AACD;;AAEc,QAATgB,SAAS,CAACpB,IAAD,EAAaK,OAAb,EAA8C;AAC3D,UAAMD,SAAS,GAAGJ,IAAlB,CAD2D,CAE3D;;AACA,UAAMM,YAAY,GAAGF,SAAS,CAACE,YAA/B;;AACA,QAAI,CAAAA,YAAY,SAAZ,IAAAA,YAAY,WAAZ,YAAAA,YAAY,CAAEL,IAAd,MAAuBC,yBAAWM,YAAtC,EAAoD;AAClDF,MAAAA,YAAY,CADsC,CAElD;;AACA,YAAMe,OAAO,GAAG,MAAMC,OAAO,CAACC,GAAR,CACpBjB,YAAY,CAACG,QAAb,CAAsBC,GAAtB,CAA0B,MAAOc,OAAP,IAAmB;AAC3C;AACA,cAAMnB,OAAO,CAACoB,eAAR,CAAwBD,OAAO,CAACX,IAAhC,CAAN;AACA,eAAOW,OAAO,CAACX,IAAf;AACD,OAJD,CADoB,CAAtB;AAQA,aAAO,EAAP,CAXkD,CAYlD;AACA;AACA;AACD;;AAED,WAAO,EAAP;AACD;;AA9CyD","sourcesContent":["import ts, { Node, SyntaxKind, ExportDeclaration as ExportDeclarationNode, NamedExports } from 'typescript';\nimport { SchemaExtractorContext } from '../schema-extractor-context';\nimport { SchemaTransformer } from '../schema-transformer';\nimport { ExportIdentifier } from '../export-identifier';\n\nexport class ExportDeclaration implements SchemaTransformer {\n  predicate(node: Node) {\n    return node.kind === SyntaxKind.ExportDeclaration;\n  }\n\n  async getIdentifiers(exportDec: ExportDeclarationNode, context: SchemaExtractorContext) {\n    if (exportDec.exportClause?.kind === ts.SyntaxKind.NamedExports) {\n      exportDec.exportClause as NamedExports;\n      return exportDec.exportClause.elements.map((elm) => {\n        return new ExportIdentifier(elm.name.getText(), elm.getSourceFile().fileName);\n      });\n    }\n\n    if (exportDec.exportClause?.kind === ts.SyntaxKind.NamespaceExport) {\n      return [new ExportIdentifier(exportDec.exportClause.name.getText(), exportDec.getSourceFile().fileName)];\n    }\n\n    if (exportDec.moduleSpecifier) {\n      return context.getFileExports(exportDec);\n    }\n\n    return [];\n  }\n\n  async transform(node: Node, context: SchemaExtractorContext) {\n    const exportDec = node as ExportDeclarationNode;\n    // sourceFile.sear\n    const exportClause = exportDec.exportClause;\n    if (exportClause?.kind === SyntaxKind.NamedExports) {\n      exportClause as NamedExports;\n      // eslint-disable-next-line @typescript-eslint/no-unused-vars\n      const exports = await Promise.all(\n        exportClause.elements.map(async (element) => {\n          // const sig = await context.visitDefinition(element.name);\n          await context.visitDefinition(element.name);\n          return element.name;\n        })\n      );\n\n      return [];\n      // return exports.map((identifier) => {\n      //   // const type = context.resolveType(identifier);\n      // });\n    }\n\n    return {};\n  }\n}\n"]}
+{"version":3,"sources":["export-declaration.ts"],"names":["ExportDeclaration","predicate","node","kind","SyntaxKind","getIdentifiers","exportDec","context","exportClause","ts","NamedExports","elements","map","elm","ExportIdentifier","name","getText","getSourceFile","fileName","NamespaceExport","moduleSpecifier","getFileExports","transform","schemas","Promise","all","element","visitDefinition","Module","namespace","sourceFile","getSourceFileFromNode","Error","result","computeSchema","specifier"],"mappings":"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","sourcesContent":["import { SchemaNode, Module } from '@teambit/semantics.entities.semantic-schema';\nimport { compact } from 'lodash';\nimport ts, {\n  Node,\n  SyntaxKind,\n  ExportDeclaration as ExportDeclarationNode,\n  NamedExports,\n  NamespaceExport,\n} from 'typescript';\nimport { SchemaExtractorContext } from '../schema-extractor-context';\nimport { SchemaTransformer } from '../schema-transformer';\nimport { ExportIdentifier } from '../export-identifier';\n\nexport class ExportDeclaration implements SchemaTransformer {\n  predicate(node: Node) {\n    return node.kind === SyntaxKind.ExportDeclaration;\n  }\n\n  async getIdentifiers(exportDec: ExportDeclarationNode, context: SchemaExtractorContext) {\n    if (exportDec.exportClause?.kind === ts.SyntaxKind.NamedExports) {\n      exportDec.exportClause as NamedExports;\n      return exportDec.exportClause.elements.map((elm) => {\n        return new ExportIdentifier(elm.name.getText(), elm.getSourceFile().fileName);\n      });\n    }\n\n    if (exportDec.exportClause?.kind === ts.SyntaxKind.NamespaceExport) {\n      return [new ExportIdentifier(exportDec.exportClause.name.getText(), exportDec.getSourceFile().fileName)];\n    }\n\n    if (exportDec.moduleSpecifier) {\n      return context.getFileExports(exportDec);\n    }\n\n    return [];\n  }\n\n  async transform(node: Node, context: SchemaExtractorContext): Promise<SchemaNode> {\n    const exportDec = node as ExportDeclarationNode;\n    const exportClause = exportDec.exportClause;\n    // e.g. `export { button1, button2 } as Composition from './button';\n    if (exportClause?.kind === SyntaxKind.NamedExports) {\n      exportClause as NamedExports;\n      const schemas = await Promise.all(\n        exportClause.elements.map(async (element) => {\n          return context.visitDefinition(element.name);\n        })\n      );\n\n      return new Module(compact(schemas));\n    }\n    // e.g. `export * as Composition from './button';\n    if (exportClause?.kind === SyntaxKind.NamespaceExport) {\n      exportClause as NamespaceExport;\n      const namespace = exportClause.name.getText();\n      const sourceFile = await context.getSourceFileFromNode(exportClause.name);\n      if (!sourceFile) {\n        throw new Error(`unable to find the source-file for \"${namespace}\"`);\n      }\n      const result = await context.computeSchema(sourceFile);\n      if (!(result instanceof Module)) {\n        throw new Error(`expect result to be instance of Module`);\n      }\n      result.namespace = namespace;\n      return result;\n    }\n    // it's export-all, e.g. `export * from './button'`;\n    if (!exportClause) {\n      const specifier = exportDec.moduleSpecifier;\n      if (!specifier) {\n        throw new Error(`fatal: no specifier`);\n      }\n      const sourceFile = await context.getSourceFileFromNode(specifier);\n      if (!sourceFile) {\n        throw new Error(`unable to find the source-file`);\n      }\n      return context.computeSchema(sourceFile);\n    }\n\n    throw new Error('unrecognized export type');\n  }\n}\n"]}

package/dist/transformers/function-declaration.d.ts

@@ -7,7 +7,5 @@ export declare class FunctionDeclaration implements SchemaTransformer {
     predicate(node: Node): boolean;
     getIdentifiers(funcDec: FunctionDeclarationNode): Promise<ExportIdentifier[]>;
     private getName;
-    private getArgs;
-    private parseReturnValue;
-    transform(node: Node, context: SchemaExtractorContext): Promise<SchemaNode>;
+    transform(funcDec: FunctionDeclarationNode, context: SchemaExtractorContext): Promise<SchemaNode>;
 }

package/dist/transformers/function-declaration.js

@@ -2,14 +2,8 @@
 
 var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 
-require("core-js/modules/es.array.iterator.js");
-
 require("core-js/modules/es.promise.js");
 
-require("core-js/modules/es.regexp.exec.js");
-
-require("core-js/modules/es.string.trim.js");
-
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
@@ -45,6 +39,26 @@ function _exportIdentifier() {
   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 FunctionDeclaration {
   predicate(node) {
     return node.kind === _typescript().default.SyntaxKind.FunctionDeclaration;
@@ -61,37 +75,17 @@ class FunctionDeclaration {
     return ((_funcDec$name = funcDec.name) === null || _funcDec$name === void 0 ? void 0 : _funcDec$name.getText()) || '';
   }
 
-  async getArgs(funcDec, context) {
-    return Promise.all(funcDec.parameters.map(async param => {
-      const type = param.type;
-      return {
-        name: param.name.getText(),
-        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-        type: await context.resolveType(type, (type === null || type === void 0 ? void 0 : type.getText()) || 'any')
-      };
-    }));
-  }
-
-  parseReturnValue(displayString) {
-    if (!displayString) return '';
-    const array = displayString.split(':');
-    return array[array.length - 1].trim();
-  }
-
-  async transform(node, context) {
+  async transform(funcDec, context) {
     var _info$body;
 
-    const funcDec = node;
     const name = this.getName(funcDec); // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
 
     const info = await context.getQuickInfo(funcDec.name);
     const displaySig = info === null || info === void 0 ? void 0 : (_info$body = info.body) === null || _info$body === void 0 ? void 0 : _info$body.displayString;
-    const returnTypeStr = this.parseReturnValue(displaySig); // eslint-disable-next-line @typescript-eslint/no-unused-vars
-
-    const args = await this.getArgs(funcDec, context); // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-
-    const returnType = await context.resolveType(funcDec.name, returnTypeStr);
-    return new (_semanticsEntities().FunctionSchema)(name || '', [], returnType);
+    const returnTypeStr = (0, _parseTypeFromQuickInfo().parseTypeFromQuickInfo)(displaySig);
+    const args = await (0, _getParams().getParams)(funcDec.parameters, context);
+    const returnType = await context.resolveType(funcDec, returnTypeStr);
+    return new (_semanticsEntities().FunctionSchema)(name || '', args, returnType, displaySig || '');
   }
 
 }

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

@@ -1 +1 @@
-{"version":3,"sources":["function-declaration.ts"],"names":["FunctionDeclaration","predicate","node","kind","ts","SyntaxKind","getIdentifiers","funcDec","ExportIdentifier","getName","getSourceFile","fileName","name","getText","getArgs","context","Promise","all","parameters","map","param","type","resolveType","parseReturnValue","displayString","array","split","length","trim","transform","info","getQuickInfo","displaySig","body","returnTypeStr","args","returnType","FunctionSchema"],"mappings":";;;;;;;;;;;;;;;;;AAAA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;;AACA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;;AAGA;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,GAH2D,CAK5D;;;AACoB,QAAdM,cAAc,CAACC,OAAD,EAAmC;AACrD,WAAO,CAAC,KAAIC,oCAAJ,EAAqB,KAAKC,OAAL,CAAaF,OAAb,CAArB,EAA4CA,OAAO,CAACG,aAAR,GAAwBC,QAApE,CAAD,CAAP;AACD;;AAEOF,EAAAA,OAAO,CAACF,OAAD,EAAmC;AAAA;;AAChD,WAAO,kBAAAA,OAAO,CAACK,IAAR,gEAAcC,OAAd,OAA2B,EAAlC;AACD;;AAEoB,QAAPC,OAAO,CAACP,OAAD,EAAmCQ,OAAnC,EAAoE;AACvF,WAAOC,OAAO,CAACC,GAAR,CACLV,OAAO,CAACW,UAAR,CAAmBC,GAAnB,CAAuB,MAAOC,KAAP,IAAiB;AACtC,YAAMC,IAAI,GAAGD,KAAK,CAACC,IAAnB;AACA,aAAO;AACLT,QAAAA,IAAI,EAAEQ,KAAK,CAACR,IAAN,CAAWC,OAAX,EADD;AAEL;AACAQ,QAAAA,IAAI,EAAE,MAAMN,OAAO,CAACO,WAAR,CAAoBD,IAApB,EAA2B,CAAAA,IAAI,SAAJ,IAAAA,IAAI,WAAJ,YAAAA,IAAI,CAAER,OAAN,OAAmB,KAA9C;AAHP,OAAP;AAKD,KAPD,CADK,CAAP;AAUD;;AAEOU,EAAAA,gBAAgB,CAACC,aAAD,EAAyB;AAC/C,QAAI,CAACA,aAAL,EAAoB,OAAO,EAAP;AACpB,UAAMC,KAAK,GAAGD,aAAa,CAACE,KAAd,CAAoB,GAApB,CAAd;AACA,WAAOD,KAAK,CAACA,KAAK,CAACE,MAAN,GAAe,CAAhB,CAAL,CAAwBC,IAAxB,EAAP;AACD;;AAEc,QAATC,SAAS,CAAC3B,IAAD,EAAaa,OAAb,EAAmE;AAAA;;AAChF,UAAMR,OAAO,GAAGL,IAAhB;AACA,UAAMU,IAAI,GAAG,KAAKH,OAAL,CAAaF,OAAb,CAAb,CAFgF,CAGhF;;AACA,UAAMuB,IAAI,GAAG,MAAMf,OAAO,CAACgB,YAAR,CAAqBxB,OAAO,CAACK,IAA7B,CAAnB;AACA,UAAMoB,UAAU,GAAGF,IAAH,aAAGA,IAAH,qCAAGA,IAAI,CAAEG,IAAT,+CAAG,WAAYT,aAA/B;AACA,UAAMU,aAAa,GAAG,KAAKX,gBAAL,CAAsBS,UAAtB,CAAtB,CANgF,CAOhF;;AACA,UAAMG,IAAI,GAAG,MAAM,KAAKrB,OAAL,CAAaP,OAAb,EAAsBQ,OAAtB,CAAnB,CARgF,CAShF;;AACA,UAAMqB,UAAU,GAAG,MAAMrB,OAAO,CAACO,WAAR,CAAoBf,OAAO,CAACK,IAA5B,EAAmCsB,aAAnC,CAAzB;AAEA,WAAO,KAAIG,mCAAJ,EAAmBzB,IAAI,IAAI,EAA3B,EAA+B,EAA/B,EAAmCwB,UAAnC,CAAP;AACD;;AA9C2D","sourcesContent":["import { SchemaNode, FunctionSchema } from '@teambit/semantics.entities.semantic-schema';\nimport ts, { Node, FunctionDeclaration as FunctionDeclarationNode } from 'typescript';\nimport { SchemaExtractorContext } from '../schema-extractor-context';\nimport { SchemaTransformer } from '../schema-transformer';\nimport { ExportIdentifier } from '../export-identifier';\n\nexport class FunctionDeclaration implements SchemaTransformer {\n  predicate(node: Node) {\n    return node.kind === ts.SyntaxKind.FunctionDeclaration;\n  }\n\n  // need to check for anonymous functions assigned for vars, const and let.\n  async getIdentifiers(funcDec: FunctionDeclarationNode) {\n    return [new ExportIdentifier(this.getName(funcDec), funcDec.getSourceFile().fileName)];\n  }\n\n  private getName(funcDec: FunctionDeclarationNode) {\n    return funcDec.name?.getText() || '';\n  }\n\n  private async getArgs(funcDec: FunctionDeclarationNode, context: SchemaExtractorContext) {\n    return Promise.all(\n      funcDec.parameters.map(async (param) => {\n        const type = param.type;\n        return {\n          name: param.name.getText(),\n          // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n          type: await context.resolveType(type!, type?.getText() || 'any'),\n        };\n      })\n    );\n  }\n\n  private parseReturnValue(displayString?: string) {\n    if (!displayString) return '';\n    const array = displayString.split(':');\n    return array[array.length - 1].trim();\n  }\n\n  async transform(node: Node, context: SchemaExtractorContext): Promise<SchemaNode> {\n    const funcDec = node as FunctionDeclarationNode;\n    const name = this.getName(funcDec);\n    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n    const info = await context.getQuickInfo(funcDec.name!);\n    const displaySig = info?.body?.displayString;\n    const returnTypeStr = this.parseReturnValue(displaySig);\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    const args = await this.getArgs(funcDec, context);\n    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n    const returnType = await context.resolveType(funcDec.name!, returnTypeStr);\n\n    return new FunctionSchema(name || '', [], returnType);\n  }\n}\n"]}
+{"version":3,"sources":["function-declaration.ts"],"names":["FunctionDeclaration","predicate","node","kind","ts","SyntaxKind","getIdentifiers","funcDec","ExportIdentifier","getName","getSourceFile","fileName","name","getText","transform","context","info","getQuickInfo","displaySig","body","displayString","returnTypeStr","args","parameters","returnType","resolveType","FunctionSchema"],"mappings":";;;;;;;;;;;AAAA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;;AACA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;;AAGA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;;AACA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;;AACA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;;AAEO,MAAMA,mBAAN,CAAuD;AAC5DC,EAAAA,SAAS,CAACC,IAAD,EAAa;AACpB,WAAOA,IAAI,CAACC,IAAL,KAAcC,sBAAGC,UAAH,CAAcL,mBAAnC;AACD,GAH2D,CAK5D;;;AACoB,QAAdM,cAAc,CAACC,OAAD,EAAmC;AACrD,WAAO,CAAC,KAAIC,oCAAJ,EAAqB,KAAKC,OAAL,CAAaF,OAAb,CAArB,EAA4CA,OAAO,CAACG,aAAR,GAAwBC,QAApE,CAAD,CAAP;AACD;;AAEOF,EAAAA,OAAO,CAACF,OAAD,EAAmC;AAAA;;AAChD,WAAO,kBAAAA,OAAO,CAACK,IAAR,gEAAcC,OAAd,OAA2B,EAAlC;AACD;;AAEc,QAATC,SAAS,CAACP,OAAD,EAAmCQ,OAAnC,EAAyF;AAAA;;AACtG,UAAMH,IAAI,GAAG,KAAKH,OAAL,CAAaF,OAAb,CAAb,CADsG,CAEtG;;AACA,UAAMS,IAAI,GAAG,MAAMD,OAAO,CAACE,YAAR,CAAqBV,OAAO,CAACK,IAA7B,CAAnB;AACA,UAAMM,UAAU,GAAGF,IAAH,aAAGA,IAAH,qCAAGA,IAAI,CAAEG,IAAT,+CAAG,WAAYC,aAA/B;AACA,UAAMC,aAAa,GAAG,sDAAuBH,UAAvB,CAAtB;AACA,UAAMI,IAAI,GAAG,MAAM,4BAAUf,OAAO,CAACgB,UAAlB,EAA8BR,OAA9B,CAAnB;AACA,UAAMS,UAAU,GAAG,MAAMT,OAAO,CAACU,WAAR,CAAoBlB,OAApB,EAA6Bc,aAA7B,CAAzB;AAEA,WAAO,KAAIK,mCAAJ,EAAmBd,IAAI,IAAI,EAA3B,EAA+BU,IAA/B,EAAqCE,UAArC,EAAiDN,UAAU,IAAI,EAA/D,CAAP;AACD;;AAxB2D","sourcesContent":["import { SchemaNode, FunctionSchema } from '@teambit/semantics.entities.semantic-schema';\nimport ts, { Node, FunctionDeclaration as FunctionDeclarationNode } from 'typescript';\nimport { SchemaExtractorContext } from '../schema-extractor-context';\nimport { SchemaTransformer } from '../schema-transformer';\nimport { ExportIdentifier } from '../export-identifier';\nimport { getParams } from './utils/get-params';\nimport { parseTypeFromQuickInfo } from './utils/parse-type-from-quick-info';\n\nexport class FunctionDeclaration implements SchemaTransformer {\n  predicate(node: Node) {\n    return node.kind === ts.SyntaxKind.FunctionDeclaration;\n  }\n\n  // need to check for anonymous functions assigned for vars, const and let.\n  async getIdentifiers(funcDec: FunctionDeclarationNode) {\n    return [new ExportIdentifier(this.getName(funcDec), funcDec.getSourceFile().fileName)];\n  }\n\n  private getName(funcDec: FunctionDeclarationNode) {\n    return funcDec.name?.getText() || '';\n  }\n\n  async transform(funcDec: FunctionDeclarationNode, context: SchemaExtractorContext): Promise<SchemaNode> {\n    const name = this.getName(funcDec);\n    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n    const info = await context.getQuickInfo(funcDec.name!);\n    const displaySig = info?.body?.displayString;\n    const returnTypeStr = parseTypeFromQuickInfo(displaySig);\n    const args = await getParams(funcDec.parameters, context);\n    const returnType = await context.resolveType(funcDec, returnTypeStr);\n\n    return new FunctionSchema(name || '', args, returnType, displaySig || '');\n  }\n}\n"]}

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

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

package/dist/transformers/index-signature.js

@@ -0,0 +1,61 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+require("core-js/modules/es.promise.js");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.IndexSignature = 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;
+}
+
+class IndexSignature {
+  predicate(node) {
+    return node.kind === _typescript().default.SyntaxKind.IndexSignature;
+  }
+
+  async getIdentifiers() {
+    return [];
+  }
+
+  async transform(indexSig, context) {
+    const params = await (0, _getParams().getParams)(indexSig.parameters, context);
+    const type = await context.resolveType(indexSig, indexSig.type.getText());
+    return new (_semanticsEntities().IndexSignatureSchema)(params, type);
+  }
+
+}
+
+exports.IndexSignature = IndexSignature;
+
+//# sourceMappingURL=index-signature.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["index-signature.ts"],"names":["IndexSignature","predicate","node","kind","ts","SyntaxKind","getIdentifiers","transform","indexSig","context","params","parameters","type","resolveType","getText","IndexSignatureSchema"],"mappings":";;;;;;;;;;;AAAA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;;AACA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;;AAGA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;;AAEO,MAAMA,cAAN,CAAkD;AACvDC,EAAAA,SAAS,CAACC,IAAD,EAAa;AACpB,WAAOA,IAAI,CAACC,IAAL,KAAcC,sBAAGC,UAAH,CAAcL,cAAnC;AACD;;AAEmB,QAAdM,cAAc,GAAG;AACrB,WAAO,EAAP;AACD;;AAEc,QAATC,SAAS,CAACC,QAAD,EAAsCC,OAAtC,EAA4F;AACzG,UAAMC,MAAM,GAAG,MAAM,4BAAUF,QAAQ,CAACG,UAAnB,EAA+BF,OAA/B,CAArB;AACA,UAAMG,IAAI,GAAG,MAAMH,OAAO,CAACI,WAAR,CAAoBL,QAApB,EAA8BA,QAAQ,CAACI,IAAT,CAAcE,OAAd,EAA9B,CAAnB;AACA,WAAO,KAAIC,yCAAJ,EAAyBL,MAAzB,EAAiCE,IAAjC,CAAP;AACD;;AAbsD","sourcesContent":["import { SchemaNode, IndexSignatureSchema } from '@teambit/semantics.entities.semantic-schema';\nimport ts, { Node, IndexSignatureDeclaration } from 'typescript';\nimport { SchemaTransformer } from '../schema-transformer';\nimport { SchemaExtractorContext } from '../schema-extractor-context';\nimport { getParams } from './utils/get-params';\n\nexport class IndexSignature implements SchemaTransformer {\n  predicate(node: Node) {\n    return node.kind === ts.SyntaxKind.IndexSignature;\n  }\n\n  async getIdentifiers() {\n    return [];\n  }\n\n  async transform(indexSig: IndexSignatureDeclaration, context: SchemaExtractorContext): Promise<SchemaNode> {\n    const params = await getParams(indexSig.parameters, context);\n    const type = await context.resolveType(indexSig, indexSig.type.getText());\n    return new IndexSignatureSchema(params, type);\n  }\n}\n"]}

package/dist/transformers/index.d.ts

@@ -1,5 +1,19 @@
 export { ExportDeclaration } from './export-declaration';
 export { FunctionDeclaration } from './function-declaration';
+export { MethodDeclaration } from './method-declaration';
+export { PropertyDeclaration } from './property-declaration';
 export { VariableStatementTransformer } from './variable-statement';
+export { VariableDeclaration } from './variable-declaration';
 export { SourceFileTransformer } from './source-file-transformer';
 export { TypeAliasTransformer } from './type-alias';
+export { ClassDecelerationTransformer } from './class-deceleration';
+export { TypeIntersectionTransformer } from './type-intersection';
+export { Constructor } from './constructor';
+export { TypeReferenceTransformer } from './type-reference';
+export { TypeLiteralTransformer } from './type-literal';
+export { PropertySignature } from './property-signature';
+export { TypeUnionTransformer } from './type-union';
+export { LiteralTypeTransformer } from './literal-type';
+export { IndexSignature } from './index-signature';
+export { InterfaceDeclarationTransformer } from './interface-declaration';
+export { MethodSignatureTransformer } from './method-signature';