@teambit/typescript 0.0.728 → 0.0.731

package/dist/transformers/index.js

@@ -3,6 +3,18 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+Object.defineProperty(exports, "ClassDecelerationTransformer", {
+  enumerable: true,
+  get: function () {
+    return _classDeceleration().ClassDecelerationTransformer;
+  }
+});
+Object.defineProperty(exports, "Constructor", {
+  enumerable: true,
+  get: function () {
+    return _constructor().Constructor;
+  }
+});
 Object.defineProperty(exports, "ExportDeclaration", {
   enumerable: true,
   get: function () {
@@ -15,6 +27,48 @@ Object.defineProperty(exports, "FunctionDeclaration", {
     return _functionDeclaration().FunctionDeclaration;
   }
 });
+Object.defineProperty(exports, "IndexSignature", {
+  enumerable: true,
+  get: function () {
+    return _indexSignature().IndexSignature;
+  }
+});
+Object.defineProperty(exports, "InterfaceDeclarationTransformer", {
+  enumerable: true,
+  get: function () {
+    return _interfaceDeclaration().InterfaceDeclarationTransformer;
+  }
+});
+Object.defineProperty(exports, "LiteralTypeTransformer", {
+  enumerable: true,
+  get: function () {
+    return _literalType().LiteralTypeTransformer;
+  }
+});
+Object.defineProperty(exports, "MethodDeclaration", {
+  enumerable: true,
+  get: function () {
+    return _methodDeclaration().MethodDeclaration;
+  }
+});
+Object.defineProperty(exports, "MethodSignatureTransformer", {
+  enumerable: true,
+  get: function () {
+    return _methodSignature().MethodSignatureTransformer;
+  }
+});
+Object.defineProperty(exports, "PropertyDeclaration", {
+  enumerable: true,
+  get: function () {
+    return _propertyDeclaration().PropertyDeclaration;
+  }
+});
+Object.defineProperty(exports, "PropertySignature", {
+  enumerable: true,
+  get: function () {
+    return _propertySignature().PropertySignature;
+  }
+});
 Object.defineProperty(exports, "SourceFileTransformer", {
   enumerable: true,
   get: function () {
@@ -27,6 +81,12 @@ Object.defineProperty(exports, "TypeAliasTransformer", {
     return _typeAlias().TypeAliasTransformer;
   }
 });
+Object.defineProperty(exports, "VariableDeclaration", {
+  enumerable: true,
+  get: function () {
+    return _variableDeclaration().VariableDeclaration;
+  }
+});
 Object.defineProperty(exports, "VariableStatementTransformer", {
   enumerable: true,
   get: function () {
@@ -54,6 +114,26 @@ function _functionDeclaration() {
   return data;
 }
 
+function _methodDeclaration() {
+  const data = require("./method-declaration");
+
+  _methodDeclaration = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _propertyDeclaration() {
+  const data = require("./property-declaration");
+
+  _propertyDeclaration = function () {
+    return data;
+  };
+
+  return data;
+}
+
 function _variableStatement() {
   const data = require("./variable-statement");
 
@@ -64,6 +144,16 @@ function _variableStatement() {
   return data;
 }
 
+function _variableDeclaration() {
+  const data = require("./variable-declaration");
+
+  _variableDeclaration = function () {
+    return data;
+  };
+
+  return data;
+}
+
 function _sourceFileTransformer() {
   const data = require("./source-file-transformer");
 
@@ -84,4 +174,74 @@ function _typeAlias() {
   return data;
 }
 
+function _classDeceleration() {
+  const data = require("./class-deceleration");
+
+  _classDeceleration = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _constructor() {
+  const data = require("./constructor");
+
+  _constructor = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _propertySignature() {
+  const data = require("./property-signature");
+
+  _propertySignature = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _literalType() {
+  const data = require("./literal-type");
+
+  _literalType = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _indexSignature() {
+  const data = require("./index-signature");
+
+  _indexSignature = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _interfaceDeclaration() {
+  const data = require("./interface-declaration");
+
+  _interfaceDeclaration = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _methodSignature() {
+  const data = require("./method-signature");
+
+  _methodSignature = function () {
+    return data;
+  };
+
+  return data;
+}
+
 //# sourceMappingURL=index.js.map

package/dist/transformers/index.js.map

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

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

@@ -0,0 +1,10 @@
+import { Node, InterfaceDeclaration } from 'typescript';
+import { InterfaceSchema } 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 InterfaceDeclarationTransformer implements SchemaTransformer {
+    predicate(node: Node): boolean;
+    getIdentifiers(node: InterfaceDeclaration): Promise<ExportIdentifier[]>;
+    transform(interfaceDec: InterfaceDeclaration, context: SchemaExtractorContext): Promise<InterfaceSchema>;
+}

package/dist/transformers/interface-declaration.js

@@ -0,0 +1,73 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+require("core-js/modules/es.promise.js");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.InterfaceDeclarationTransformer = void 0;
+
+function _typescript() {
+  const data = _interopRequireDefault(require("typescript"));
+
+  _typescript = function () {
+    return data;
+  };
+
+  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;
+}
+
+function _exportIdentifier() {
+  const data = require("../export-identifier");
+
+  _exportIdentifier = function () {
+    return data;
+  };
+
+  return data;
+}
+
+class InterfaceDeclarationTransformer {
+  predicate(node) {
+    return node.kind === _typescript().default.SyntaxKind.InterfaceDeclaration;
+  }
+
+  async getIdentifiers(node) {
+    return [new (_exportIdentifier().ExportIdentifier)(node.name.getText(), node.getSourceFile().fileName)];
+  }
+
+  async transform(interfaceDec, context) {
+    const members = await (0, _pMapSeries().default)(interfaceDec.members, async member => {
+      const typeSchema = await context.computeSchema(member);
+      return typeSchema;
+    });
+    return new (_semanticsEntities().InterfaceSchema)(interfaceDec.name.getText(), members);
+  }
+
+}
+
+exports.InterfaceDeclarationTransformer = InterfaceDeclarationTransformer;
+
+//# sourceMappingURL=interface-declaration.js.map

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

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

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

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

package/dist/transformers/literal-type.js

@@ -0,0 +1,50 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+require("core-js/modules/es.promise.js");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.LiteralTypeTransformer = void 0;
+
+function _typescript() {
+  const data = _interopRequireDefault(require("typescript"));
+
+  _typescript = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _semanticsEntities() {
+  const data = require("@teambit/semantics.entities.semantic-schema");
+
+  _semanticsEntities = function () {
+    return data;
+  };
+
+  return data;
+}
+
+class LiteralTypeTransformer {
+  predicate(node) {
+    return node.kind === _typescript().default.SyntaxKind.LiteralType;
+  }
+
+  async getIdentifiers() {
+    return [];
+  }
+
+  async transform(literalType) {
+    const type = literalType.literal.getText();
+    return new (_semanticsEntities().TypeRefSchema)(type);
+  }
+
+}
+
+exports.LiteralTypeTransformer = LiteralTypeTransformer;
+
+//# sourceMappingURL=literal-type.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["literal-type.ts"],"names":["LiteralTypeTransformer","predicate","node","kind","ts","SyntaxKind","LiteralType","getIdentifiers","transform","literalType","type","literal","getText","TypeRefSchema"],"mappings":";;;;;;;;;;;AAAA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;;AACA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;;AAGO,MAAMA,sBAAN,CAA0D;AAC/DC,EAAAA,SAAS,CAACC,IAAD,EAAa;AACpB,WAAOA,IAAI,CAACC,IAAL,KAAcC,sBAAGC,UAAH,CAAcC,WAAnC;AACD;;AAEmB,QAAdC,cAAc,GAAG;AACrB,WAAO,EAAP;AACD;;AAEc,QAATC,SAAS,CAACC,WAAD,EAA+B;AAC5C,UAAMC,IAAI,GAAGD,WAAW,CAACE,OAAZ,CAAoBC,OAApB,EAAb;AACA,WAAO,KAAIC,kCAAJ,EAAkBH,IAAlB,CAAP;AACD;;AAZ8D","sourcesContent":["import ts, { LiteralTypeNode, Node } from 'typescript';\nimport { TypeRefSchema } from '@teambit/semantics.entities.semantic-schema';\nimport { SchemaTransformer } from '../schema-transformer';\n\nexport class LiteralTypeTransformer implements SchemaTransformer {\n  predicate(node: Node) {\n    return node.kind === ts.SyntaxKind.LiteralType;\n  }\n\n  async getIdentifiers() {\n    return [];\n  }\n\n  async transform(literalType: LiteralTypeNode) {\n    const type = literalType.literal.getText();\n    return new TypeRefSchema(type);\n  }\n}\n"]}

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

@@ -0,0 +1,11 @@
+import { SchemaNode } from '@teambit/semantics.entities.semantic-schema';
+import { Node, MethodDeclaration as MethodDeclarationNode } from 'typescript';
+import { SchemaExtractorContext } from '../schema-extractor-context';
+import { SchemaTransformer } from '../schema-transformer';
+import { ExportIdentifier } from '../export-identifier';
+export declare class MethodDeclaration implements SchemaTransformer {
+    predicate(node: Node): boolean;
+    getIdentifiers(funcDec: MethodDeclarationNode): Promise<ExportIdentifier[]>;
+    private getName;
+    transform(methodDec: MethodDeclarationNode, context: SchemaExtractorContext): Promise<SchemaNode>;
+}

package/dist/transformers/method-declaration.js

@@ -0,0 +1,94 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+require("core-js/modules/es.promise.js");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.MethodDeclaration = 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 _parseTypeFromQuickInfo() {
+  const data = require("./utils/parse-type-from-quick-info");
+
+  _parseTypeFromQuickInfo = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _getParams() {
+  const data = require("./utils/get-params");
+
+  _getParams = function () {
+    return data;
+  };
+
+  return data;
+}
+
+class MethodDeclaration {
+  predicate(node) {
+    return node.kind === _typescript().default.SyntaxKind.MethodDeclaration;
+  }
+
+  async getIdentifiers(funcDec) {
+    return [new (_exportIdentifier().ExportIdentifier)(this.getName(funcDec), funcDec.getSourceFile().fileName)];
+  }
+
+  getName(funcDec) {
+    var _funcDec$name;
+
+    return ((_funcDec$name = funcDec.name) === null || _funcDec$name === void 0 ? void 0 : _funcDec$name.getText()) || '';
+  }
+
+  async transform(methodDec, context) {
+    var _info$body, _methodDec$modifiers;
+
+    const name = this.getName(methodDec);
+    const info = await context.getQuickInfo(methodDec.name);
+    const displaySig = info === null || info === void 0 ? void 0 : (_info$body = info.body) === null || _info$body === void 0 ? void 0 : _info$body.displayString;
+    const returnTypeStr = (0, _parseTypeFromQuickInfo().parseTypeFromQuickInfo)(info);
+    const params = await (0, _getParams().getParams)(methodDec.parameters, context);
+    const modifiers = ((_methodDec$modifiers = methodDec.modifiers) === null || _methodDec$modifiers === void 0 ? void 0 : _methodDec$modifiers.map(modifier => modifier.getText())) || [];
+    const returnType = await context.resolveType(methodDec, returnTypeStr);
+    return new (_semanticsEntities().FunctionSchema)(name, params, returnType, displaySig || '', modifiers);
+  }
+
+}
+
+exports.MethodDeclaration = MethodDeclaration;
+
+//# sourceMappingURL=method-declaration.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["method-declaration.ts"],"names":["MethodDeclaration","predicate","node","kind","ts","SyntaxKind","getIdentifiers","funcDec","ExportIdentifier","getName","getSourceFile","fileName","name","getText","transform","methodDec","context","info","getQuickInfo","displaySig","body","displayString","returnTypeStr","params","parameters","modifiers","map","modifier","returnType","resolveType","FunctionSchema"],"mappings":";;;;;;;;;;;AAAA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;;AACA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;;AAGA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;;AACA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;;AACA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;;AAEO,MAAMA,iBAAN,CAAqD;AAC1DC,EAAAA,SAAS,CAACC,IAAD,EAAa;AACpB,WAAOA,IAAI,CAACC,IAAL,KAAcC,sBAAGC,UAAH,CAAcL,iBAAnC;AACD;;AAEmB,QAAdM,cAAc,CAACC,OAAD,EAAiC;AACnD,WAAO,CAAC,KAAIC,oCAAJ,EAAqB,KAAKC,OAAL,CAAaF,OAAb,CAArB,EAA4CA,OAAO,CAACG,aAAR,GAAwBC,QAApE,CAAD,CAAP;AACD;;AAEOF,EAAAA,OAAO,CAACF,OAAD,EAAiC;AAAA;;AAC9C,WAAO,kBAAAA,OAAO,CAACK,IAAR,gEAAcC,OAAd,OAA2B,EAAlC;AACD;;AAEc,QAATC,SAAS,CAACC,SAAD,EAAmCC,OAAnC,EAAyF;AAAA;;AACtG,UAAMJ,IAAI,GAAG,KAAKH,OAAL,CAAaM,SAAb,CAAb;AACA,UAAME,IAAI,GAAG,MAAMD,OAAO,CAACE,YAAR,CAAqBH,SAAS,CAACH,IAA/B,CAAnB;AACA,UAAMO,UAAU,GAAGF,IAAH,aAAGA,IAAH,qCAAGA,IAAI,CAAEG,IAAT,+CAAG,WAAYC,aAA/B;AACA,UAAMC,aAAa,GAAG,sDAAuBL,IAAvB,CAAtB;AACA,UAAMM,MAAM,GAAG,MAAM,4BAAUR,SAAS,CAACS,UAApB,EAAgCR,OAAhC,CAArB;AACA,UAAMS,SAAS,GAAG,yBAAAV,SAAS,CAACU,SAAV,8EAAqBC,GAArB,CAA0BC,QAAD,IAAcA,QAAQ,CAACd,OAAT,EAAvC,MAA8D,EAAhF;AACA,UAAMe,UAAU,GAAG,MAAMZ,OAAO,CAACa,WAAR,CAAoBd,SAApB,EAA+BO,aAA/B,CAAzB;AACA,WAAO,KAAIQ,mCAAJ,EAAmBlB,IAAnB,EAAyBW,MAAzB,EAAiCK,UAAjC,EAA6CT,UAAU,IAAI,EAA3D,EAA+DM,SAA/D,CAAP;AACD;;AAtByD","sourcesContent":["import { SchemaNode, FunctionSchema, Modifier } from '@teambit/semantics.entities.semantic-schema';\nimport ts, { Node, MethodDeclaration as MethodDeclarationNode } from 'typescript';\nimport { SchemaExtractorContext } from '../schema-extractor-context';\nimport { SchemaTransformer } from '../schema-transformer';\nimport { ExportIdentifier } from '../export-identifier';\nimport { parseTypeFromQuickInfo } from './utils/parse-type-from-quick-info';\nimport { getParams } from './utils/get-params';\n\nexport class MethodDeclaration implements SchemaTransformer {\n  predicate(node: Node) {\n    return node.kind === ts.SyntaxKind.MethodDeclaration;\n  }\n\n  async getIdentifiers(funcDec: MethodDeclarationNode) {\n    return [new ExportIdentifier(this.getName(funcDec), funcDec.getSourceFile().fileName)];\n  }\n\n  private getName(funcDec: MethodDeclarationNode) {\n    return funcDec.name?.getText() || '';\n  }\n\n  async transform(methodDec: MethodDeclarationNode, context: SchemaExtractorContext): Promise<SchemaNode> {\n    const name = this.getName(methodDec);\n    const info = await context.getQuickInfo(methodDec.name);\n    const displaySig = info?.body?.displayString;\n    const returnTypeStr = parseTypeFromQuickInfo(info);\n    const params = await getParams(methodDec.parameters, context);\n    const modifiers = methodDec.modifiers?.map((modifier) => modifier.getText()) || [];\n    const returnType = await context.resolveType(methodDec, returnTypeStr);\n    return new FunctionSchema(name, params, returnType, displaySig || '', modifiers as Modifier[]);\n  }\n}\n"]}

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

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

package/dist/transformers/method-signature.js

@@ -0,0 +1,81 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+require("core-js/modules/es.promise.js");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.MethodSignatureTransformer = 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 _parseTypeFromQuickInfo() {
+  const data = require("./utils/parse-type-from-quick-info");
+
+  _parseTypeFromQuickInfo = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _getParams() {
+  const data = require("./utils/get-params");
+
+  _getParams = function () {
+    return data;
+  };
+
+  return data;
+}
+
+class MethodSignatureTransformer {
+  predicate(node) {
+    return node.kind === _typescript().default.SyntaxKind.MethodSignature;
+  }
+
+  getName(node) {
+    return node.name.getText();
+  }
+
+  async getIdentifiers() {
+    return [];
+  }
+
+  async transform(methodSig, context) {
+    var _info$body;
+
+    const name = this.getName(methodSig);
+    const info = await context.getQuickInfo(methodSig.name);
+    const displaySig = info === null || info === void 0 ? void 0 : (_info$body = info.body) === null || _info$body === void 0 ? void 0 : _info$body.displayString;
+    const returnTypeStr = (0, _parseTypeFromQuickInfo().parseTypeFromQuickInfo)(info);
+    const args = await (0, _getParams().getParams)(methodSig.parameters, context);
+    const returnType = await context.resolveType(methodSig, returnTypeStr);
+    return new (_semanticsEntities().FunctionSchema)(name, args, returnType, displaySig || '');
+  }
+
+}
+
+exports.MethodSignatureTransformer = MethodSignatureTransformer;
+
+//# sourceMappingURL=method-signature.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["method-signature.ts"],"names":["MethodSignatureTransformer","predicate","node","kind","ts","SyntaxKind","MethodSignature","getName","name","getText","getIdentifiers","transform","methodSig","context","info","getQuickInfo","displaySig","body","displayString","returnTypeStr","args","parameters","returnType","resolveType","FunctionSchema"],"mappings":";;;;;;;;;;;AAAA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;;AACA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;;AAGA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;;AACA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;;AAEO,MAAMA,0BAAN,CAA8D;AACnEC,EAAAA,SAAS,CAACC,IAAD,EAAa;AACpB,WAAOA,IAAI,CAACC,IAAL,KAAcC,sBAAGC,UAAH,CAAcC,eAAnC;AACD;;AAEDC,EAAAA,OAAO,CAACL,IAAD,EAA4B;AACjC,WAAOA,IAAI,CAACM,IAAL,CAAUC,OAAV,EAAP;AACD;;AAEmB,QAAdC,cAAc,GAAG;AACrB,WAAO,EAAP;AACD;;AAEc,QAATC,SAAS,CAACC,SAAD,EAAiCC,OAAjC,EAAuF;AAAA;;AACpG,UAAML,IAAI,GAAG,KAAKD,OAAL,CAAaK,SAAb,CAAb;AACA,UAAME,IAAI,GAAG,MAAMD,OAAO,CAACE,YAAR,CAAqBH,SAAS,CAACJ,IAA/B,CAAnB;AACA,UAAMQ,UAAU,GAAGF,IAAH,aAAGA,IAAH,qCAAGA,IAAI,CAAEG,IAAT,+CAAG,WAAYC,aAA/B;AACA,UAAMC,aAAa,GAAG,sDAAuBL,IAAvB,CAAtB;AACA,UAAMM,IAAI,GAAG,MAAM,4BAAUR,SAAS,CAACS,UAApB,EAAgCR,OAAhC,CAAnB;AACA,UAAMS,UAAU,GAAG,MAAMT,OAAO,CAACU,WAAR,CAAoBX,SAApB,EAA+BO,aAA/B,CAAzB;AACA,WAAO,KAAIK,mCAAJ,EAAmBhB,IAAnB,EAAyBY,IAAzB,EAA+BE,UAA/B,EAA2CN,UAAU,IAAI,EAAzD,CAAP;AACD;;AArBkE","sourcesContent":["import { SchemaNode, FunctionSchema } from '@teambit/semantics.entities.semantic-schema';\nimport ts, { Node, MethodSignature as MethodSignatureNode } from 'typescript';\nimport { SchemaTransformer } from '../schema-transformer';\nimport { SchemaExtractorContext } from '../schema-extractor-context';\nimport { parseTypeFromQuickInfo } from './utils/parse-type-from-quick-info';\nimport { getParams } from './utils/get-params';\n\nexport class MethodSignatureTransformer implements SchemaTransformer {\n  predicate(node: Node) {\n    return node.kind === ts.SyntaxKind.MethodSignature;\n  }\n\n  getName(node: MethodSignatureNode) {\n    return node.name.getText();\n  }\n\n  async getIdentifiers() {\n    return [];\n  }\n\n  async transform(methodSig: MethodSignatureNode, context: SchemaExtractorContext): Promise<SchemaNode> {\n    const name = this.getName(methodSig);\n    const info = await context.getQuickInfo(methodSig.name);\n    const displaySig = info?.body?.displayString;\n    const returnTypeStr = parseTypeFromQuickInfo(info);\n    const args = await getParams(methodSig.parameters, context);\n    const returnType = await context.resolveType(methodSig, returnTypeStr);\n    return new FunctionSchema(name, args, returnType, displaySig || '');\n  }\n}\n"]}

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

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

package/dist/transformers/property-declaration.js

@@ -0,0 +1,80 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+require("core-js/modules/es.promise.js");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.PropertyDeclaration = 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 _parseTypeFromQuickInfo() {
+  const data = require("./utils/parse-type-from-quick-info");
+
+  _parseTypeFromQuickInfo = function () {
+    return data;
+  };
+
+  return data;
+}
+
+class PropertyDeclaration {
+  predicate(node) {
+    return node.kind === _typescript().default.SyntaxKind.PropertyDeclaration;
+  }
+
+  getName(node) {
+    return node.name.getText();
+  }
+
+  async getIdentifiers(node) {
+    return [new (_exportIdentifier().ExportIdentifier)(node.name.getText(), node.getSourceFile().fileName)];
+  }
+
+  async transform(propertyDec, context) {
+    var _info$body;
+
+    const name = this.getName(propertyDec);
+    const info = await context.getQuickInfo(propertyDec.name);
+    const displaySig = info === null || info === void 0 ? void 0 : (_info$body = info.body) === null || _info$body === void 0 ? void 0 : _info$body.displayString;
+    const typeStr = (0, _parseTypeFromQuickInfo().parseTypeFromQuickInfo)(info);
+    const type = await context.resolveType(propertyDec, typeStr);
+    return new (_semanticsEntities().VariableSchema)(name || '', displaySig || '', type);
+  }
+
+}
+
+exports.PropertyDeclaration = PropertyDeclaration;
+
+//# sourceMappingURL=property-declaration.js.map

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

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