@teambit/typescript 0.0.741 → 0.0.744

package/dist/transformers/class-deceleration.js

@@ -40,7 +40,7 @@ function _semanticsEntities() {
 }
 
 function _typescript() {
-  const data = _interopRequireWildcard(require("typescript"));
+  const data = _interopRequireDefault(require("typescript"));
 
   _typescript = function () {
     return data;
@@ -59,30 +59,26 @@ function _exportIdentifier() {
   return data;
 }
 
-function _parseTypeFromQuickInfo() {
-  const data = require("./utils/parse-type-from-quick-info");
+function _jsdocToDocSchema() {
+  const data = require("./utils/jsdoc-to-doc-schema");
 
-  _parseTypeFromQuickInfo = function () {
+  _jsdocToDocSchema = function () {
     return data;
   };
 
   return data;
 }
 
-function _getParams() {
-  const data = require("./utils/get-params");
+function _classElementToSchema() {
+  const data = require("./utils/class-element-to-schema");
 
-  _getParams = function () {
+  _classElementToSchema = function () {
     return data;
   };
 
   return data;
 }
 
-function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
-
-function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
-
 class ClassDecelerationTransformer {
   predicate(node) {
     return node.kind === _typescript().default.SyntaxKind.ClassDeclaration;
@@ -110,36 +106,10 @@ class ClassDecelerationTransformer {
         return null;
       }
 
-      if ((0, _typescript().isSemicolonClassElement)(member)) {
-        return null;
-      }
-
-      switch (member.kind) {
-        case _typescript().default.SyntaxKind.GetAccessor:
-          {
-            var _info$body;
-
-            const getter = member;
-            const info = await context.getQuickInfo(getter.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(getter, typeStr);
-            return new (_semanticsEntities().GetAccessorSchema)(context.getLocation(getter), getter.name.getText(), type, displaySig);
-          }
-
-        case _typescript().default.SyntaxKind.SetAccessor:
-          {
-            const setter = member;
-            const params = await (0, _getParams().getParams)(setter.parameters, context);
-            const displaySig = await context.getQuickInfoDisplayString(setter.name);
-            return new (_semanticsEntities().SetAccessorSchema)(context.getLocation(setter), setter.name.getText(), params[0], displaySig);
-          }
-
-        default:
-          return context.computeSchema(member);
-      }
+      return (0, _classElementToSchema().classElementToSchema)(member, context);
     });
-    return new (_semanticsEntities().ClassSchema)(className, (0, _lodash().compact)(members), context.getLocation(node));
+    const doc = await (0, _jsdocToDocSchema().jsDocToDocSchema)(node, context);
+    return new (_semanticsEntities().ClassSchema)(className, (0, _lodash().compact)(members), context.getLocation(node), doc);
   }
 
 }

package/dist/transformers/class-deceleration.js.map

@@ -1 +1 @@
-{"version":3,"names":["ClassDecelerationTransformer","predicate","node","kind","ts","SyntaxKind","ClassDeclaration","getName","name","getText","getIdentifiers","ExportIdentifier","getSourceFile","fileName","transform","context","className","members","pMapSeries","member","isPrivate","modifiers","some","modifier","PrivateKeyword","isSemicolonClassElement","GetAccessor","getter","info","getQuickInfo","displaySig","body","displayString","typeStr","parseTypeFromQuickInfo","type","resolveType","GetAccessorSchema","getLocation","SetAccessor","setter","params","getParams","parameters","getQuickInfoDisplayString","SetAccessorSchema","computeSchema","ClassSchema","compact"],"sources":["class-deceleration.ts"],"sourcesContent":["import pMapSeries from 'p-map-series';\nimport { compact } from 'lodash';\nimport { ClassSchema, GetAccessorSchema, SetAccessorSchema } from '@teambit/semantics.entities.semantic-schema';\nimport ts, { Node, ClassDeclaration, isSemicolonClassElement } 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';\nimport { getParams } from './utils/get-params';\n\nexport class ClassDecelerationTransformer implements SchemaTransformer {\n  predicate(node: Node) {\n    return node.kind === ts.SyntaxKind.ClassDeclaration;\n  }\n\n  // @todo: in case of `export default class` the class has no name.\n  private getName(node: ClassDeclaration) {\n    return node.name?.getText() || 'default';\n  }\n\n  async getIdentifiers(node: ClassDeclaration) {\n    return [new ExportIdentifier(this.getName(node), node.getSourceFile().fileName)];\n  }\n\n  async transform(node: ClassDeclaration, context: SchemaExtractorContext) {\n    const className = this.getName(node);\n    const members = await pMapSeries(node.members, async (member) => {\n      const isPrivate = member.modifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.PrivateKeyword);\n      if (isPrivate) {\n        return null;\n      }\n      if (isSemicolonClassElement(member)) {\n        return null;\n      }\n      switch (member.kind) {\n        case ts.SyntaxKind.GetAccessor: {\n          const getter = member as ts.GetAccessorDeclaration;\n          const info = await context.getQuickInfo(getter.name);\n          const displaySig = info?.body?.displayString || '';\n          const typeStr = parseTypeFromQuickInfo(info);\n          const type = await context.resolveType(getter, typeStr);\n          return new GetAccessorSchema(context.getLocation(getter), getter.name.getText(), type, displaySig);\n        }\n        case ts.SyntaxKind.SetAccessor: {\n          const setter = member as ts.SetAccessorDeclaration;\n          const params = await getParams(setter.parameters, context);\n          const displaySig = await context.getQuickInfoDisplayString(setter.name);\n          return new SetAccessorSchema(context.getLocation(setter), setter.name.getText(), params[0], displaySig);\n        }\n        default:\n          return context.computeSchema(member);\n      }\n    });\n    return new ClassSchema(className, compact(members), context.getLocation(node));\n  }\n}\n"],"mappings":"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"}
+{"version":3,"names":["ClassDecelerationTransformer","predicate","node","kind","ts","SyntaxKind","ClassDeclaration","getName","name","getText","getIdentifiers","ExportIdentifier","getSourceFile","fileName","transform","context","className","members","pMapSeries","member","isPrivate","modifiers","some","modifier","PrivateKeyword","classElementToSchema","doc","jsDocToDocSchema","ClassSchema","compact","getLocation"],"sources":["class-deceleration.ts"],"sourcesContent":["import pMapSeries from 'p-map-series';\nimport { compact } from 'lodash';\nimport { ClassSchema } from '@teambit/semantics.entities.semantic-schema';\nimport ts, { Node, ClassDeclaration } from 'typescript';\nimport { SchemaTransformer } from '../schema-transformer';\nimport { SchemaExtractorContext } from '../schema-extractor-context';\nimport { ExportIdentifier } from '../export-identifier';\nimport { jsDocToDocSchema } from './utils/jsdoc-to-doc-schema';\nimport { classElementToSchema } from './utils/class-element-to-schema';\n\nexport class ClassDecelerationTransformer implements SchemaTransformer {\n  predicate(node: Node) {\n    return node.kind === ts.SyntaxKind.ClassDeclaration;\n  }\n\n  // @todo: in case of `export default class` the class has no name.\n  private getName(node: ClassDeclaration) {\n    return node.name?.getText() || 'default';\n  }\n\n  async getIdentifiers(node: ClassDeclaration) {\n    return [new ExportIdentifier(this.getName(node), node.getSourceFile().fileName)];\n  }\n\n  async transform(node: ClassDeclaration, context: SchemaExtractorContext) {\n    const className = this.getName(node);\n    const members = await pMapSeries(node.members, async (member) => {\n      const isPrivate = member.modifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.PrivateKeyword);\n      if (isPrivate) {\n        return null;\n      }\n      return classElementToSchema(member, context);\n    });\n    const doc = await jsDocToDocSchema(node, context);\n    return new ClassSchema(className, compact(members), context.getLocation(node), doc);\n  }\n}\n"],"mappings":";;;;;;;;;;;AAAA;EAAA;;EAAA;IAAA;EAAA;;EAAA;AAAA;;AACA;EAAA;;EAAA;IAAA;EAAA;;EAAA;AAAA;;AACA;EAAA;;EAAA;IAAA;EAAA;;EAAA;AAAA;;AACA;EAAA;;EAAA;IAAA;EAAA;;EAAA;AAAA;;AAGA;EAAA;;EAAA;IAAA;EAAA;;EAAA;AAAA;;AACA;EAAA;;EAAA;IAAA;EAAA;;EAAA;AAAA;;AACA;EAAA;;EAAA;IAAA;EAAA;;EAAA;AAAA;;AAEO,MAAMA,4BAAN,CAAgE;EACrEC,SAAS,CAACC,IAAD,EAAa;IACpB,OAAOA,IAAI,CAACC,IAAL,KAAcC,qBAAA,CAAGC,UAAH,CAAcC,gBAAnC;EACD,CAHoE,CAKrE;;;EACQC,OAAO,CAACL,IAAD,EAAyB;IAAA;;IACtC,OAAO,eAAAA,IAAI,CAACM,IAAL,0DAAWC,OAAX,OAAwB,SAA/B;EACD;;EAEmB,MAAdC,cAAc,CAACR,IAAD,EAAyB;IAC3C,OAAO,CAAC,KAAIS,oCAAJ,EAAqB,KAAKJ,OAAL,CAAaL,IAAb,CAArB,EAAyCA,IAAI,CAACU,aAAL,GAAqBC,QAA9D,CAAD,CAAP;EACD;;EAEc,MAATC,SAAS,CAACZ,IAAD,EAAyBa,OAAzB,EAA0D;IACvE,MAAMC,SAAS,GAAG,KAAKT,OAAL,CAAaL,IAAb,CAAlB;IACA,MAAMe,OAAO,GAAG,MAAM,IAAAC,qBAAA,EAAWhB,IAAI,CAACe,OAAhB,EAAyB,MAAOE,MAAP,IAAkB;MAAA;;MAC/D,MAAMC,SAAS,wBAAGD,MAAM,CAACE,SAAV,sDAAG,kBAAkBC,IAAlB,CAAwBC,QAAD,IAAcA,QAAQ,CAACpB,IAAT,KAAkBC,qBAAA,CAAGC,UAAH,CAAcmB,cAArE,CAAlB;;MACA,IAAIJ,SAAJ,EAAe;QACb,OAAO,IAAP;MACD;;MACD,OAAO,IAAAK,4CAAA,EAAqBN,MAArB,EAA6BJ,OAA7B,CAAP;IACD,CANqB,CAAtB;IAOA,MAAMW,GAAG,GAAG,MAAM,IAAAC,oCAAA,EAAiBzB,IAAjB,EAAuBa,OAAvB,CAAlB;IACA,OAAO,KAAIa,gCAAJ,EAAgBZ,SAAhB,EAA2B,IAAAa,iBAAA,EAAQZ,OAAR,CAA3B,EAA6CF,OAAO,CAACe,WAAR,CAAoB5B,IAApB,CAA7C,EAAwEwB,GAAxE,CAAP;EACD;;AAzBoE"}

package/dist/transformers/index.d.ts

@@ -1,16 +1,10 @@
 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 { Constructor } from './constructor';
-export { PropertySignature } from './property-signature';
 export { LiteralTypeTransformer } from './literal-type';
-export { IndexSignature } from './index-signature';
 export { InterfaceDeclarationTransformer } from './interface-declaration';
-export { MethodSignatureTransformer } from './method-signature';
 export { EnumDeclarationTransformer } from './enum-declaration';

package/dist/transformers/index.js

@@ -9,12 +9,6 @@ Object.defineProperty(exports, "ClassDecelerationTransformer", {
     return _classDeceleration().ClassDecelerationTransformer;
   }
 });
-Object.defineProperty(exports, "Constructor", {
-  enumerable: true,
-  get: function () {
-    return _constructor().Constructor;
-  }
-});
 Object.defineProperty(exports, "EnumDeclarationTransformer", {
   enumerable: true,
   get: function () {
@@ -33,12 +27,6 @@ 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 () {
@@ -51,30 +39,6 @@ Object.defineProperty(exports, "LiteralTypeTransformer", {
     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 () {
@@ -120,26 +84,6 @@ 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");
 
@@ -190,26 +134,6 @@ function _classDeceleration() {
   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");
 
@@ -220,16 +144,6 @@ function _literalType() {
   return data;
 }
 
-function _indexSignature() {
-  const data = require("./index-signature");
-
-  _indexSignature = function () {
-    return data;
-  };
-
-  return data;
-}
-
 function _interfaceDeclaration() {
   const data = require("./interface-declaration");
 
@@ -240,16 +154,6 @@ function _interfaceDeclaration() {
   return data;
 }
 
-function _methodSignature() {
-  const data = require("./method-signature");
-
-  _methodSignature = function () {
-    return data;
-  };
-
-  return data;
-}
-
 function _enumDeclaration() {
   const data = require("./enum-declaration");
 

package/dist/transformers/index.js.map

@@ -1 +1 @@
-{"version":3,"names":[],"sources":["index.ts"],"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';\nexport { EnumDeclarationTransformer } from './enum-declaration';\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;EAAA;;EAAA;IAAA;EAAA;;EAAA;AAAA;;AACA;EAAA;;EAAA;IAAA;EAAA;;EAAA;AAAA;;AACA;EAAA;;EAAA;IAAA;EAAA;;EAAA;AAAA;;AACA;EAAA;;EAAA;IAAA;EAAA;;EAAA;AAAA;;AACA;EAAA;;EAAA;IAAA;EAAA;;EAAA;AAAA;;AACA;EAAA;;EAAA;IAAA;EAAA;;EAAA;AAAA;;AACA;EAAA;;EAAA;IAAA;EAAA;;EAAA;AAAA;;AACA;EAAA;;EAAA;IAAA;EAAA;;EAAA;AAAA;;AACA;EAAA;;EAAA;IAAA;EAAA;;EAAA;AAAA;;AACA;EAAA;;EAAA;IAAA;EAAA;;EAAA;AAAA;;AACA;EAAA;;EAAA;IAAA;EAAA;;EAAA;AAAA;;AACA;EAAA;;EAAA;IAAA;EAAA;;EAAA;AAAA;;AACA;EAAA;;EAAA;IAAA;EAAA;;EAAA;AAAA;;AACA;EAAA;;EAAA;IAAA;EAAA;;EAAA;AAAA;;AACA;EAAA;;EAAA;IAAA;EAAA;;EAAA;AAAA;;AACA;EAAA;;EAAA;IAAA;EAAA;;EAAA;AAAA"}
+{"version":3,"names":[],"sources":["index.ts"],"sourcesContent":["export { ExportDeclaration } from './export-declaration';\nexport { FunctionDeclaration } from './function-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 { LiteralTypeTransformer } from './literal-type';\nexport { InterfaceDeclarationTransformer } from './interface-declaration';\nexport { EnumDeclarationTransformer } from './enum-declaration';\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;EAAA;;EAAA;IAAA;EAAA;;EAAA;AAAA;;AACA;EAAA;;EAAA;IAAA;EAAA;;EAAA;AAAA;;AACA;EAAA;;EAAA;IAAA;EAAA;;EAAA;AAAA;;AACA;EAAA;;EAAA;IAAA;EAAA;;EAAA;AAAA;;AACA;EAAA;;EAAA;IAAA;EAAA;;EAAA;AAAA;;AACA;EAAA;;EAAA;IAAA;EAAA;;EAAA;AAAA;;AACA;EAAA;;EAAA;IAAA;EAAA;;EAAA;AAAA;;AACA;EAAA;;EAAA;IAAA;EAAA;;EAAA;AAAA;;AACA;EAAA;;EAAA;IAAA;EAAA;;EAAA;AAAA;;AACA;EAAA;;EAAA;IAAA;EAAA;;EAAA;AAAA"}

package/dist/transformers/interface-declaration.js

@@ -10,7 +10,7 @@ Object.defineProperty(exports, "__esModule", {
 exports.InterfaceDeclarationTransformer = void 0;
 
 function _typescript() {
-  const data = _interopRequireDefault(require("typescript"));
+  const data = require("typescript");
 
   _typescript = function () {
     return data;
@@ -49,9 +49,19 @@ function _exportIdentifier() {
   return data;
 }
 
+function _typeElementToSchema() {
+  const data = require("./utils/type-element-to-schema");
+
+  _typeElementToSchema = function () {
+    return data;
+  };
+
+  return data;
+}
+
 class InterfaceDeclarationTransformer {
   predicate(node) {
-    return node.kind === _typescript().default.SyntaxKind.InterfaceDeclaration;
+    return node.kind === _typescript().SyntaxKind.InterfaceDeclaration;
   }
 
   async getIdentifiers(node) {
@@ -59,10 +69,7 @@ class InterfaceDeclarationTransformer {
   }
 
   async transform(interfaceDec, context) {
-    const members = await (0, _pMapSeries().default)(interfaceDec.members, async member => {
-      const typeSchema = await context.computeSchema(member);
-      return typeSchema;
-    });
+    const members = await (0, _pMapSeries().default)(interfaceDec.members, member => (0, _typeElementToSchema().typeElementToSchema)(member, context));
     return new (_semanticsEntities().InterfaceSchema)(context.getLocation(interfaceDec), interfaceDec.name.getText(), members);
   }
 

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

@@ -1 +1 @@
-{"version":3,"names":["InterfaceDeclarationTransformer","predicate","node","kind","ts","SyntaxKind","InterfaceDeclaration","getIdentifiers","ExportIdentifier","name","getText","getSourceFile","fileName","transform","interfaceDec","context","members","pMapSeries","member","typeSchema","computeSchema","InterfaceSchema","getLocation"],"sources":["interface-declaration.ts"],"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(context.getLocation(interfaceDec), interfaceDec.name.getText(), members);\n  }\n}\n"],"mappings":";;;;;;;;;;;AAAA;EAAA;;EAAA;IAAA;EAAA;;EAAA;AAAA;;AACA;EAAA;;EAAA;IAAA;EAAA;;EAAA;AAAA;;AACA;EAAA;;EAAA;IAAA;EAAA;;EAAA;AAAA;;AAGA;EAAA;;EAAA;IAAA;EAAA;;EAAA;AAAA;;AAEO,MAAMA,+BAAN,CAAmE;EACxEC,SAAS,CAACC,IAAD,EAAa;IACpB,OAAOA,IAAI,CAACC,IAAL,KAAcC,qBAAA,CAAGC,UAAH,CAAcC,oBAAnC;EACD;;EAEmB,MAAdC,cAAc,CAACL,IAAD,EAA0D;IAC5E,OAAO,CAAC,KAAIM,oCAAJ,EAAqBN,IAAI,CAACO,IAAL,CAAUC,OAAV,EAArB,EAA0CR,IAAI,CAACS,aAAL,GAAqBC,QAA/D,CAAD,CAAP;EACD;;EAEc,MAATC,SAAS,CAACC,YAAD,EAAqCC,OAArC,EAAsE;IACnF,MAAMC,OAAO,GAAG,MAAM,IAAAC,qBAAA,EAAWH,YAAY,CAACE,OAAxB,EAAiC,MAAOE,MAAP,IAAkB;MACvE,MAAMC,UAAU,GAAG,MAAMJ,OAAO,CAACK,aAAR,CAAsBF,MAAtB,CAAzB;MACA,OAAOC,UAAP;IACD,CAHqB,CAAtB;IAIA,OAAO,KAAIE,oCAAJ,EAAoBN,OAAO,CAACO,WAAR,CAAoBR,YAApB,CAApB,EAAuDA,YAAY,CAACL,IAAb,CAAkBC,OAAlB,EAAvD,EAAoFM,OAApF,CAAP;EACD;;AAfuE"}
+{"version":3,"names":["InterfaceDeclarationTransformer","predicate","node","kind","SyntaxKind","InterfaceDeclaration","getIdentifiers","ExportIdentifier","name","getText","getSourceFile","fileName","transform","interfaceDec","context","members","pMapSeries","member","typeElementToSchema","InterfaceSchema","getLocation"],"sources":["interface-declaration.ts"],"sourcesContent":["import { Node, InterfaceDeclaration, SyntaxKind } 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';\nimport { typeElementToSchema } from './utils/type-element-to-schema';\n\nexport class InterfaceDeclarationTransformer implements SchemaTransformer {\n  predicate(node: Node) {\n    return node.kind === 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, (member) => typeElementToSchema(member, context));\n    return new InterfaceSchema(context.getLocation(interfaceDec), interfaceDec.name.getText(), members);\n  }\n}\n"],"mappings":";;;;;;;;;;;AAAA;EAAA;;EAAA;IAAA;EAAA;;EAAA;AAAA;;AACA;EAAA;;EAAA;IAAA;EAAA;;EAAA;AAAA;;AACA;EAAA;;EAAA;IAAA;EAAA;;EAAA;AAAA;;AAGA;EAAA;;EAAA;IAAA;EAAA;;EAAA;AAAA;;AACA;EAAA;;EAAA;IAAA;EAAA;;EAAA;AAAA;;AAEO,MAAMA,+BAAN,CAAmE;EACxEC,SAAS,CAACC,IAAD,EAAa;IACpB,OAAOA,IAAI,CAACC,IAAL,KAAcC,wBAAA,CAAWC,oBAAhC;EACD;;EAEmB,MAAdC,cAAc,CAACJ,IAAD,EAA0D;IAC5E,OAAO,CAAC,KAAIK,oCAAJ,EAAqBL,IAAI,CAACM,IAAL,CAAUC,OAAV,EAArB,EAA0CP,IAAI,CAACQ,aAAL,GAAqBC,QAA/D,CAAD,CAAP;EACD;;EAEc,MAATC,SAAS,CAACC,YAAD,EAAqCC,OAArC,EAAsE;IACnF,MAAMC,OAAO,GAAG,MAAM,IAAAC,qBAAA,EAAWH,YAAY,CAACE,OAAxB,EAAkCE,MAAD,IAAY,IAAAC,0CAAA,EAAoBD,MAApB,EAA4BH,OAA5B,CAA7C,CAAtB;IACA,OAAO,KAAIK,oCAAJ,EAAoBL,OAAO,CAACM,WAAR,CAAoBP,YAApB,CAApB,EAAuDA,YAAY,CAACL,IAAb,CAAkBC,OAAlB,EAAvD,EAAoFM,OAApF,CAAP;EACD;;AAZuE"}

package/dist/transformers/utils/class-element-to-schema.d.ts

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

package/dist/transformers/utils/class-element-to-schema.js

@@ -0,0 +1,122 @@
+"use strict";
+
+require("core-js/modules/es.promise.js");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.classElementToSchema = classElementToSchema;
+
+function _typescript() {
+  const data = require("typescript");
+
+  _typescript = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _semanticsEntities() {
+  const data = require("@teambit/semantics.entities.semantic-schema");
+
+  _semanticsEntities = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _getParams() {
+  const data = require("./get-params");
+
+  _getParams = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _typeElementToSchema() {
+  const data = require("./type-element-to-schema");
+
+  _typeElementToSchema = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _parseTypeFromQuickInfo() {
+  const data = require("./parse-type-from-quick-info");
+
+  _parseTypeFromQuickInfo = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _toFunctionSchema() {
+  const data = require("./to-function-schema");
+
+  _toFunctionSchema = function () {
+    return data;
+  };
+
+  return data;
+}
+
+async function classElementToSchema(node, context) {
+  switch (node.kind) {
+    case _typescript().SyntaxKind.Constructor:
+      return constructor(node, context);
+
+    case _typescript().SyntaxKind.PropertyDeclaration:
+      return propertyDeclaration(node, context);
+
+    case _typescript().SyntaxKind.MethodDeclaration:
+      return methodDeclaration(node, context);
+
+    case _typescript().SyntaxKind.GetAccessor:
+      return (0, _typeElementToSchema().getAccessor)(node, context);
+
+    case _typescript().SyntaxKind.SetAccessor:
+      return (0, _typeElementToSchema().setAccessor)(node, context);
+
+    case _typescript().SyntaxKind.IndexSignature:
+      return (0, _typeElementToSchema().indexSignature)(node, context);
+
+    case _typescript().SyntaxKind.ClassStaticBlockDeclaration: // not sure what is it, but the name sounds like not something we need
+
+    case _typescript().SyntaxKind.SemicolonClassElement:
+      // seems to be just a semicolon
+      return null;
+
+    default:
+      // should never be here unless typescript added new class elements
+      throw new Error(`unrecognized ClassElement type. got ${node.kind}`);
+  }
+}
+
+async function constructor(node, context) {
+  const args = await (0, _getParams().getParams)(node.parameters, context);
+  return new (_semanticsEntities().ConstructorSchema)(context.getLocation(node), args);
+}
+
+async function propertyDeclaration(node, context) {
+  var _info$body;
+
+  const name = node.name.getText();
+  const info = await context.getQuickInfo(node.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(node, typeStr);
+  return new (_semanticsEntities().VariableSchema)(context.getLocation(node), name, displaySig || '', type);
+}
+
+async function methodDeclaration(node, context) {
+  return (0, _toFunctionSchema().toFunctionLikeSchema)(node, context);
+}
+
+//# sourceMappingURL=class-element-to-schema.js.map

package/dist/transformers/utils/class-element-to-schema.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["classElementToSchema","node","context","kind","SyntaxKind","Constructor","constructor","PropertyDeclaration","propertyDeclaration","MethodDeclaration","methodDeclaration","GetAccessor","getAccessor","SetAccessor","setAccessor","IndexSignature","indexSignature","ClassStaticBlockDeclaration","SemicolonClassElement","Error","args","getParams","parameters","ConstructorSchema","getLocation","name","getText","info","getQuickInfo","displaySig","body","displayString","typeStr","parseTypeFromQuickInfo","type","resolveType","VariableSchema","toFunctionLikeSchema"],"sources":["class-element-to-schema.ts"],"sourcesContent":["import {\n  ClassElement,\n  ConstructorDeclaration,\n  GetAccessorDeclaration,\n  IndexSignatureDeclaration,\n  MethodDeclaration,\n  PropertyDeclaration,\n  SetAccessorDeclaration,\n  SyntaxKind,\n} from 'typescript';\nimport { ConstructorSchema, SchemaNode, VariableSchema } from '@teambit/semantics.entities.semantic-schema';\nimport { SchemaExtractorContext } from '../../schema-extractor-context';\nimport { getParams } from './get-params';\nimport { getAccessor, indexSignature, setAccessor } from './type-element-to-schema';\nimport { parseTypeFromQuickInfo } from './parse-type-from-quick-info';\nimport { toFunctionLikeSchema } from './to-function-schema';\n\nexport async function classElementToSchema(\n  node: ClassElement,\n  context: SchemaExtractorContext\n): Promise<SchemaNode | null> {\n  switch (node.kind) {\n    case SyntaxKind.Constructor:\n      return constructor(node as ConstructorDeclaration, context);\n    case SyntaxKind.PropertyDeclaration:\n      return propertyDeclaration(node as PropertyDeclaration, context);\n    case SyntaxKind.MethodDeclaration:\n      return methodDeclaration(node as MethodDeclaration, context);\n    case SyntaxKind.GetAccessor:\n      return getAccessor(node as GetAccessorDeclaration, context);\n    case SyntaxKind.SetAccessor:\n      return setAccessor(node as SetAccessorDeclaration, context);\n    case SyntaxKind.IndexSignature:\n      return indexSignature(node as IndexSignatureDeclaration, context);\n    case SyntaxKind.ClassStaticBlockDeclaration: // not sure what is it, but the name sounds like not something we need\n    case SyntaxKind.SemicolonClassElement: // seems to be just a semicolon\n      return null;\n    default:\n      // should never be here unless typescript added new class elements\n      throw new Error(`unrecognized ClassElement type. got ${node.kind}`);\n  }\n}\n\nasync function constructor(node: ConstructorDeclaration, context: SchemaExtractorContext) {\n  const args = await getParams(node.parameters, context);\n  return new ConstructorSchema(context.getLocation(node), args);\n}\n\nasync function propertyDeclaration(node: PropertyDeclaration, context: SchemaExtractorContext) {\n  const name = node.name.getText();\n  const info = await context.getQuickInfo(node.name);\n  const displaySig = info?.body?.displayString;\n  const typeStr = parseTypeFromQuickInfo(info);\n  const type = await context.resolveType(node, typeStr);\n\n  return new VariableSchema(context.getLocation(node), name, displaySig || '', type);\n}\n\nasync function methodDeclaration(node: MethodDeclaration, context: SchemaExtractorContext) {\n  return toFunctionLikeSchema(node, context);\n}\n"],"mappings":";;;;;;;;;AAAA;EAAA;;EAAA;IAAA;EAAA;;EAAA;AAAA;;AAUA;EAAA;;EAAA;IAAA;EAAA;;EAAA;AAAA;;AAEA;EAAA;;EAAA;IAAA;EAAA;;EAAA;AAAA;;AACA;EAAA;;EAAA;IAAA;EAAA;;EAAA;AAAA;;AACA;EAAA;;EAAA;IAAA;EAAA;;EAAA;AAAA;;AACA;EAAA;;EAAA;IAAA;EAAA;;EAAA;AAAA;;AAEO,eAAeA,oBAAf,CACLC,IADK,EAELC,OAFK,EAGuB;EAC5B,QAAQD,IAAI,CAACE,IAAb;IACE,KAAKC,wBAAA,CAAWC,WAAhB;MACE,OAAOC,WAAW,CAACL,IAAD,EAAiCC,OAAjC,CAAlB;;IACF,KAAKE,wBAAA,CAAWG,mBAAhB;MACE,OAAOC,mBAAmB,CAACP,IAAD,EAA8BC,OAA9B,CAA1B;;IACF,KAAKE,wBAAA,CAAWK,iBAAhB;MACE,OAAOC,iBAAiB,CAACT,IAAD,EAA4BC,OAA5B,CAAxB;;IACF,KAAKE,wBAAA,CAAWO,WAAhB;MACE,OAAO,IAAAC,kCAAA,EAAYX,IAAZ,EAA4CC,OAA5C,CAAP;;IACF,KAAKE,wBAAA,CAAWS,WAAhB;MACE,OAAO,IAAAC,kCAAA,EAAYb,IAAZ,EAA4CC,OAA5C,CAAP;;IACF,KAAKE,wBAAA,CAAWW,cAAhB;MACE,OAAO,IAAAC,qCAAA,EAAef,IAAf,EAAkDC,OAAlD,CAAP;;IACF,KAAKE,wBAAA,CAAWa,2BAAhB,CAbF,CAa+C;;IAC7C,KAAKb,wBAAA,CAAWc,qBAAhB;MAAuC;MACrC,OAAO,IAAP;;IACF;MACE;MACA,MAAM,IAAIC,KAAJ,CAAW,uCAAsClB,IAAI,CAACE,IAAK,EAA3D,CAAN;EAlBJ;AAoBD;;AAED,eAAeG,WAAf,CAA2BL,IAA3B,EAAyDC,OAAzD,EAA0F;EACxF,MAAMkB,IAAI,GAAG,MAAM,IAAAC,sBAAA,EAAUpB,IAAI,CAACqB,UAAf,EAA2BpB,OAA3B,CAAnB;EACA,OAAO,KAAIqB,sCAAJ,EAAsBrB,OAAO,CAACsB,WAAR,CAAoBvB,IAApB,CAAtB,EAAiDmB,IAAjD,CAAP;AACD;;AAED,eAAeZ,mBAAf,CAAmCP,IAAnC,EAA8DC,OAA9D,EAA+F;EAAA;;EAC7F,MAAMuB,IAAI,GAAGxB,IAAI,CAACwB,IAAL,CAAUC,OAAV,EAAb;EACA,MAAMC,IAAI,GAAG,MAAMzB,OAAO,CAAC0B,YAAR,CAAqB3B,IAAI,CAACwB,IAA1B,CAAnB;EACA,MAAMI,UAAU,GAAGF,IAAH,aAAGA,IAAH,qCAAGA,IAAI,CAAEG,IAAT,+CAAG,WAAYC,aAA/B;EACA,MAAMC,OAAO,GAAG,IAAAC,gDAAA,EAAuBN,IAAvB,CAAhB;EACA,MAAMO,IAAI,GAAG,MAAMhC,OAAO,CAACiC,WAAR,CAAoBlC,IAApB,EAA0B+B,OAA1B,CAAnB;EAEA,OAAO,KAAII,mCAAJ,EAAmBlC,OAAO,CAACsB,WAAR,CAAoBvB,IAApB,CAAnB,EAA8CwB,IAA9C,EAAoDI,UAAU,IAAI,EAAlE,EAAsEK,IAAtE,CAAP;AACD;;AAED,eAAexB,iBAAf,CAAiCT,IAAjC,EAA0DC,OAA1D,EAA2F;EACzF,OAAO,IAAAmC,wCAAA,EAAqBpC,IAArB,EAA2BC,OAA3B,CAAP;AACD"}

package/dist/transformers/utils/jsdoc-to-doc-schema.d.ts

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

package/dist/transformers/utils/jsdoc-to-doc-schema.js

@@ -0,0 +1,163 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+require("core-js/modules/es.promise.js");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.jsDocToDocSchema = jsDocToDocSchema;
+
+function _typescript() {
+  const data = require("typescript");
+
+  _typescript = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _tsutils() {
+  const data = require("tsutils");
+
+  _tsutils = 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 _typeNodeToSchema() {
+  const data = require("./type-node-to-schema");
+
+  _typeNodeToSchema = function () {
+    return data;
+  };
+
+  return data;
+}
+
+/* eslint-disable no-fallthrough */
+async function jsDocToDocSchema(node, context) {
+  if (!(0, _tsutils().canHaveJsDoc)(node)) {
+    return undefined;
+  }
+
+  const jsDocs = (0, _tsutils().getJsDoc)(node);
+
+  if (!jsDocs.length) {
+    return undefined;
+  } // not sure how common it is to have multiple JSDocs. never seen it before.
+  // regardless, in typescript implementation of methods like `getJSDocDeprecatedTag()`, they use the first one. (`getFirstJSDocTag()`)
+
+
+  const jsDoc = jsDocs[0];
+  const location = context.getLocation(jsDoc);
+  const comment = (0, _typescript().getTextOfJSDocComment)(jsDoc.comment);
+  const tags = jsDoc.tags ? await (0, _pMapSeries().default)(jsDoc.tags, tag => tagParser(tag, context)) : undefined;
+  return new (_semanticsEntities().DocSchema)(location, comment, tags);
+}
+
+async function tagParser(tag, context) {
+  let tagName = tag.tagName.getText();
+
+  switch (tag.kind) {
+    case _typescript().SyntaxKind.JSDocReturnTag:
+      return returnTag(tag, context);
+
+    case _typescript().SyntaxKind.JSDocAugmentsTag:
+      tagName = _semanticsEntities().TagName.augments;
+
+    case _typescript().SyntaxKind.JSDocAuthorTag:
+      tagName = _semanticsEntities().TagName.author;
+
+    case _typescript().SyntaxKind.JSDocClassTag:
+      tagName = _semanticsEntities().TagName.class;
+
+    case _typescript().SyntaxKind.JSDocCallbackTag:
+      tagName = _semanticsEntities().TagName.callback;
+
+    case _typescript().SyntaxKind.JSDocPublicTag:
+      tagName = _semanticsEntities().TagName.public;
+
+    case _typescript().SyntaxKind.JSDocPrivateTag:
+      tagName = _semanticsEntities().TagName.private;
+
+    case _typescript().SyntaxKind.JSDocProtectedTag:
+      tagName = _semanticsEntities().TagName.protected;
+
+    case _typescript().SyntaxKind.JSDocReadonlyTag:
+      tagName = _semanticsEntities().TagName.readonly;
+
+    case _typescript().SyntaxKind.JSDocOverrideTag:
+      tagName = _semanticsEntities().TagName.override;
+
+    case _typescript().SyntaxKind.JSDocDeprecatedTag:
+      tagName = _semanticsEntities().TagName.deprecated;
+
+    case _typescript().SyntaxKind.JSDocSeeTag:
+      tagName = _semanticsEntities().TagName.see;
+
+    case _typescript().SyntaxKind.JSDocEnumTag:
+      tagName = _semanticsEntities().TagName.enum;
+
+    case _typescript().SyntaxKind.JSDocParameterTag:
+      tagName = _semanticsEntities().TagName.parameter;
+
+    case _typescript().SyntaxKind.JSDocThisTag:
+      tagName = _semanticsEntities().TagName.this;
+
+    case _typescript().SyntaxKind.JSDocTypeTag:
+      tagName = _semanticsEntities().TagName.type;
+
+    case _typescript().SyntaxKind.JSDocTemplateTag:
+      tagName = _semanticsEntities().TagName.template;
+
+    case _typescript().SyntaxKind.JSDocTypedefTag:
+      tagName = _semanticsEntities().TagName.typedef;
+
+    case _typescript().SyntaxKind.JSDocPropertyTag:
+      tagName = _semanticsEntities().TagName.property;
+
+    case _typescript().SyntaxKind.JSDocImplementsTag:
+      tagName = _semanticsEntities().TagName.implements;
+
+    default:
+      return simpleTag(tag, tagName, context);
+  }
+}
+
+function simpleTag(tag, tagName, context) {
+  return new (_semanticsEntities().TagSchema)(context.getLocation(tag), tagName, (0, _typescript().getTextOfJSDocComment)(tag.comment));
+}
+
+async function returnTag(tag, context) {
+  var _tag$typeExpression, _tag$typeExpression2;
+
+  const type = (_tag$typeExpression = tag.typeExpression) !== null && _tag$typeExpression !== void 0 && _tag$typeExpression.type ? await (0, _typeNodeToSchema().typeNodeToSchema)((_tag$typeExpression2 = tag.typeExpression) === null || _tag$typeExpression2 === void 0 ? void 0 : _tag$typeExpression2.type, context) : undefined;
+  return new (_semanticsEntities().ReturnTagSchema)(context.getLocation(tag), _semanticsEntities().TagName.return, (0, _typescript().getTextOfJSDocComment)(tag.comment), type);
+}
+
+//# sourceMappingURL=jsdoc-to-doc-schema.js.map