@teambit/typescript 0.0.726 → 0.0.729

package/dist/transformers/property-declaration.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.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); // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+
+    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)(displaySig);
+    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,CAD0G,CAE1G;;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,sDAAuBH,UAAvB,CAAhB;AACA,UAAMI,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;;AAtB2D","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    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n    const info = await context.getQuickInfo(propertyDec.name!);\n    const displaySig = info?.body?.displayString;\n    const typeStr = parseTypeFromQuickInfo(displaySig);\n    const type = await context.resolveType(propertyDec, typeStr);\n\n    return new VariableSchema(name || '', displaySig || '', type);\n  }\n}\n"]}

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

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

package/dist/transformers/property-signature.js

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

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

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

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

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

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

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

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

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

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

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

package/dist/transformers/type-alias.js

@@ -19,6 +19,16 @@ function _typescript() {
   return data;
 }
 
+function _semanticsEntities() {
+  const data = require("@teambit/semantics.entities.semantic-schema");
+
+  _semanticsEntities = function () {
+    return data;
+  };
+
+  return data;
+}
+
 function _exportIdentifier() {
   const data = require("../export-identifier");
 
@@ -38,8 +48,18 @@ class TypeAliasTransformer {
     return [new (_exportIdentifier().ExportIdentifier)(node.name.getText(), node.getSourceFile().fileName)];
   }
 
-  async transform() {
-    return {};
+  getName(node) {
+    return node.name.getText();
+  }
+
+  async transform(typeAlias, context) {
+    var _info$body;
+
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    const info = await context.getQuickInfo(typeAlias.name);
+    const displaySig = info === null || info === void 0 ? void 0 : (_info$body = info.body) === null || _info$body === void 0 ? void 0 : _info$body.displayString;
+    const type = await context.computeSchema(typeAlias.type);
+    return new (_semanticsEntities().TypeSchema)(this.getName(typeAlias), type, displaySig);
   }
 
 }

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

@@ -1 +1 @@
-{"version":3,"sources":["type-alias.ts"],"names":["TypeAliasTransformer","predicate","node","kind","ts","SyntaxKind","TypeAliasDeclaration","getIdentifiers","ExportIdentifier","name","getText","getSourceFile","fileName","transform"],"mappings":";;;;;;;;;;;AAAA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;;AAEA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;;AAEO,MAAMA,oBAAN,CAAwD;AAC7DC,EAAAA,SAAS,CAACC,IAAD,EAAa;AACpB,WAAOA,IAAI,CAACC,IAAL,KAAcC,sBAAGC,UAAH,CAAcC,oBAAnC;AACD;;AAEmB,QAAdC,cAAc,CAACL,IAAD,EAA6B;AAC/C,WAAO,CAAC,KAAIM,oCAAJ,EAAqBN,IAAI,CAACO,IAAL,CAAUC,OAAV,EAArB,EAA0CR,IAAI,CAACS,aAAL,GAAqBC,QAA/D,CAAD,CAAP;AACD;;AAEc,QAATC,SAAS,GAAG;AAChB,WAAO,EAAP;AACD;;AAX4D","sourcesContent":["import ts, { Node, TypeAliasDeclaration } from 'typescript';\nimport { SchemaTransformer } from '../schema-transformer';\nimport { ExportIdentifier } from '../export-identifier';\n\nexport class TypeAliasTransformer implements SchemaTransformer {\n  predicate(node: Node) {\n    return node.kind === ts.SyntaxKind.TypeAliasDeclaration;\n  }\n\n  async getIdentifiers(node: TypeAliasDeclaration) {\n    return [new ExportIdentifier(node.name.getText(), node.getSourceFile().fileName)];\n  }\n\n  async transform() {\n    return {};\n  }\n}\n"]}
+{"version":3,"sources":["type-alias.ts"],"names":["TypeAliasTransformer","predicate","node","kind","ts","SyntaxKind","TypeAliasDeclaration","getIdentifiers","ExportIdentifier","name","getText","getSourceFile","fileName","getName","transform","typeAlias","context","info","getQuickInfo","displaySig","body","displayString","type","computeSchema","TypeSchema"],"mappings":";;;;;;;;;;;AAAA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;;AACA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;;AAGA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;;AAEO,MAAMA,oBAAN,CAAwD;AAC7DC,EAAAA,SAAS,CAACC,IAAD,EAAa;AACpB,WAAOA,IAAI,CAACC,IAAL,KAAcC,sBAAGC,UAAH,CAAcC,oBAAnC;AACD;;AAEmB,QAAdC,cAAc,CAACL,IAAD,EAA6B;AAC/C,WAAO,CAAC,KAAIM,oCAAJ,EAAqBN,IAAI,CAACO,IAAL,CAAUC,OAAV,EAArB,EAA0CR,IAAI,CAACS,aAAL,GAAqBC,QAA/D,CAAD,CAAP;AACD;;AAEOC,EAAAA,OAAO,CAACX,IAAD,EAAqC;AAClD,WAAOA,IAAI,CAACO,IAAL,CAAUC,OAAV,EAAP;AACD;;AAEc,QAATI,SAAS,CAACC,SAAD,EAAkCC,OAAlC,EAAmE;AAAA;;AAChF;AACA,UAAMC,IAAI,GAAG,MAAMD,OAAO,CAACE,YAAR,CAAqBH,SAAS,CAACN,IAA/B,CAAnB;AACA,UAAMU,UAAU,GAAGF,IAAH,aAAGA,IAAH,qCAAGA,IAAI,CAAEG,IAAT,+CAAG,WAAYC,aAA/B;AACA,UAAMC,IAAI,GAAG,MAAMN,OAAO,CAACO,aAAR,CAAsBR,SAAS,CAACO,IAAhC,CAAnB;AACA,WAAO,KAAIE,+BAAJ,EAAe,KAAKX,OAAL,CAAaE,SAAb,CAAf,EAAwCO,IAAxC,EAA8CH,UAA9C,CAAP;AACD;;AAnB4D","sourcesContent":["import ts, { Node, TypeAliasDeclaration } from 'typescript';\nimport { TypeSchema } from '@teambit/semantics.entities.semantic-schema';\nimport { SchemaTransformer } from '../schema-transformer';\nimport { SchemaExtractorContext } from '../schema-extractor-context';\nimport { ExportIdentifier } from '../export-identifier';\n\nexport class TypeAliasTransformer implements SchemaTransformer {\n  predicate(node: Node) {\n    return node.kind === ts.SyntaxKind.TypeAliasDeclaration;\n  }\n\n  async getIdentifiers(node: TypeAliasDeclaration) {\n    return [new ExportIdentifier(node.name.getText(), node.getSourceFile().fileName)];\n  }\n\n  private getName(node: TypeAliasDeclaration): string {\n    return node.name.getText();\n  }\n\n  async transform(typeAlias: TypeAliasDeclaration, context: SchemaExtractorContext) {\n    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n    const info = await context.getQuickInfo(typeAlias.name!);\n    const displaySig = info?.body?.displayString;\n    const type = await context.computeSchema(typeAlias.type);\n    return new TypeSchema(this.getName(typeAlias), type, displaySig as string);\n  }\n}\n"]}

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

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

package/dist/transformers/type-intersection.js

@@ -0,0 +1,63 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+require("core-js/modules/es.promise.js");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TypeIntersectionTransformer = 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;
+}
+
+class TypeIntersectionTransformer {
+  predicate(node) {
+    return node.kind === _typescript().default.SyntaxKind.IntersectionType;
+  }
+
+  async getIdentifiers() {
+    return [];
+  }
+
+  async transform(intersectionType, context) {
+    const types = await (0, _pMapSeries().default)(intersectionType.types, async type => {
+      const typeSchema = await context.computeSchema(type);
+      return typeSchema;
+    });
+    return new (_semanticsEntities().TypeIntersectionSchema)(types);
+  }
+
+}
+
+exports.TypeIntersectionTransformer = TypeIntersectionTransformer;
+
+//# sourceMappingURL=type-intersection.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["type-intersection.ts"],"names":["TypeIntersectionTransformer","predicate","node","kind","ts","SyntaxKind","IntersectionType","getIdentifiers","transform","intersectionType","context","types","type","typeSchema","computeSchema","TypeIntersectionSchema"],"mappings":";;;;;;;;;;;AAAA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;;AACA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;;AACA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;;AAIO,MAAMA,2BAAN,CAA+D;AACpEC,EAAAA,SAAS,CAACC,IAAD,EAAa;AACpB,WAAOA,IAAI,CAACC,IAAL,KAAcC,sBAAGC,UAAH,CAAcC,gBAAnC;AACD;;AAEmB,QAAdC,cAAc,GAAG;AACrB,WAAO,EAAP;AACD;;AAEc,QAATC,SAAS,CAACC,gBAAD,EAAyCC,OAAzC,EAA0E;AACvF,UAAMC,KAAK,GAAG,MAAM,2BAAWF,gBAAgB,CAACE,KAA5B,EAAmC,MAAOC,IAAP,IAAgB;AACrE,YAAMC,UAAU,GAAG,MAAMH,OAAO,CAACI,aAAR,CAAsBF,IAAtB,CAAzB;AACA,aAAOC,UAAP;AACD,KAHmB,CAApB;AAIA,WAAO,KAAIE,2CAAJ,EAA2BJ,KAA3B,CAAP;AACD;;AAfmE","sourcesContent":["import ts, { Node, IntersectionTypeNode } from 'typescript';\nimport pMapSeries from 'p-map-series';\nimport { TypeIntersectionSchema } from '@teambit/semantics.entities.semantic-schema';\nimport { SchemaTransformer } from '../schema-transformer';\nimport { SchemaExtractorContext } from '../schema-extractor-context';\n\nexport class TypeIntersectionTransformer implements SchemaTransformer {\n  predicate(node: Node) {\n    return node.kind === ts.SyntaxKind.IntersectionType;\n  }\n\n  async getIdentifiers() {\n    return [];\n  }\n\n  async transform(intersectionType: IntersectionTypeNode, context: SchemaExtractorContext) {\n    const types = await pMapSeries(intersectionType.types, async (type) => {\n      const typeSchema = await context.computeSchema(type);\n      return typeSchema;\n    });\n    return new TypeIntersectionSchema(types);\n  }\n}\n"]}

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

@@ -0,0 +1,14 @@
+import { Node, TypeLiteralNode } from 'typescript';
+import { TypeLiteralSchema } from '@teambit/semantics.entities.semantic-schema';
+import { SchemaTransformer } from '../schema-transformer';
+import { SchemaExtractorContext } from '../schema-extractor-context';
+import { ExportIdentifier } from '../export-identifier';
+/**
+ * not to be confused with "LiteralType", which is string/boolean/null.
+ * this "TypeLiteral" is an object with properties, such as: `{ a: string; b: number }`, similar to Interface.
+ */
+export declare class TypeLiteralTransformer implements SchemaTransformer {
+    predicate(node: Node): boolean;
+    getIdentifiers(): Promise<ExportIdentifier[]>;
+    transform(typeLiteral: TypeLiteralNode, context: SchemaExtractorContext): Promise<TypeLiteralSchema>;
+}

package/dist/transformers/type-literal.js

@@ -0,0 +1,67 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+require("core-js/modules/es.promise.js");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TypeLiteralTransformer = 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;
+}
+
+/**
+ * not to be confused with "LiteralType", which is string/boolean/null.
+ * this "TypeLiteral" is an object with properties, such as: `{ a: string; b: number }`, similar to Interface.
+ */
+class TypeLiteralTransformer {
+  predicate(node) {
+    return node.kind === _typescript().default.SyntaxKind.TypeLiteral;
+  }
+
+  async getIdentifiers() {
+    return [];
+  }
+
+  async transform(typeLiteral, context) {
+    const members = await (0, _pMapSeries().default)(typeLiteral.members, async member => {
+      const typeSchema = await context.computeSchema(member);
+      return typeSchema;
+    });
+    return new (_semanticsEntities().TypeLiteralSchema)(members);
+  }
+
+}
+
+exports.TypeLiteralTransformer = TypeLiteralTransformer;
+
+//# sourceMappingURL=type-literal.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["type-literal.ts"],"names":["TypeLiteralTransformer","predicate","node","kind","ts","SyntaxKind","TypeLiteral","getIdentifiers","transform","typeLiteral","context","members","member","typeSchema","computeSchema","TypeLiteralSchema"],"mappings":";;;;;;;;;;;AAAA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;;AACA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;;AACA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;;AAKA;AACA;AACA;AACA;AACO,MAAMA,sBAAN,CAA0D;AAC/DC,EAAAA,SAAS,CAACC,IAAD,EAAa;AACpB,WAAOA,IAAI,CAACC,IAAL,KAAcC,sBAAGC,UAAH,CAAcC,WAAnC;AACD;;AAEmB,QAAdC,cAAc,GAAgC;AAClD,WAAO,EAAP;AACD;;AAEc,QAATC,SAAS,CAACC,WAAD,EAA+BC,OAA/B,EAAgE;AAC7E,UAAMC,OAAO,GAAG,MAAM,2BAAWF,WAAW,CAACE,OAAvB,EAAgC,MAAOC,MAAP,IAAkB;AACtE,YAAMC,UAAU,GAAG,MAAMH,OAAO,CAACI,aAAR,CAAsBF,MAAtB,CAAzB;AACA,aAAOC,UAAP;AACD,KAHqB,CAAtB;AAIA,WAAO,KAAIE,sCAAJ,EAAsBJ,OAAtB,CAAP;AACD;;AAf8D","sourcesContent":["import ts, { Node, TypeLiteralNode } from 'typescript';\nimport pMapSeries from 'p-map-series';\nimport { TypeLiteralSchema } from '@teambit/semantics.entities.semantic-schema';\nimport { SchemaTransformer } from '../schema-transformer';\nimport { SchemaExtractorContext } from '../schema-extractor-context';\nimport { ExportIdentifier } from '../export-identifier';\n\n/**\n * not to be confused with \"LiteralType\", which is string/boolean/null.\n * this \"TypeLiteral\" is an object with properties, such as: `{ a: string; b: number }`, similar to Interface.\n */\nexport class TypeLiteralTransformer implements SchemaTransformer {\n  predicate(node: Node) {\n    return node.kind === ts.SyntaxKind.TypeLiteral;\n  }\n\n  async getIdentifiers(): Promise<ExportIdentifier[]> {\n    return [];\n  }\n\n  async transform(typeLiteral: TypeLiteralNode, context: SchemaExtractorContext) {\n    const members = await pMapSeries(typeLiteral.members, async (member) => {\n      const typeSchema = await context.computeSchema(member);\n      return typeSchema;\n    });\n    return new TypeLiteralSchema(members);\n  }\n}\n"]}

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

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

package/dist/transformers/type-reference.js

@@ -0,0 +1,41 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+require("core-js/modules/es.promise.js");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TypeReferenceTransformer = void 0;
+
+function _typescript() {
+  const data = _interopRequireDefault(require("typescript"));
+
+  _typescript = function () {
+    return data;
+  };
+
+  return data;
+}
+
+class TypeReferenceTransformer {
+  predicate(node) {
+    return node.kind === _typescript().default.SyntaxKind.TypeReference;
+  }
+
+  async getIdentifiers() {
+    return [];
+  }
+
+  async transform(typeReference, context) {
+    const name = typeReference.typeName.getText();
+    const type = await context.resolveType(typeReference, name);
+    return type;
+  }
+
+}
+
+exports.TypeReferenceTransformer = TypeReferenceTransformer;
+
+//# sourceMappingURL=type-reference.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["type-reference.ts"],"names":["TypeReferenceTransformer","predicate","node","kind","ts","SyntaxKind","TypeReference","getIdentifiers","transform","typeReference","context","name","typeName","getText","type","resolveType"],"mappings":";;;;;;;;;;;AAAA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;;AAIO,MAAMA,wBAAN,CAA4D;AACjEC,EAAAA,SAAS,CAACC,IAAD,EAAa;AACpB,WAAOA,IAAI,CAACC,IAAL,KAAcC,sBAAGC,UAAH,CAAcC,aAAnC;AACD;;AAEmB,QAAdC,cAAc,GAAG;AACrB,WAAO,EAAP;AACD;;AAEc,QAATC,SAAS,CAACC,aAAD,EAAmCC,OAAnC,EAAoE;AACjF,UAAMC,IAAI,GAAGF,aAAa,CAACG,QAAd,CAAuBC,OAAvB,EAAb;AACA,UAAMC,IAAI,GAAG,MAAMJ,OAAO,CAACK,WAAR,CAAoBN,aAApB,EAAmCE,IAAnC,CAAnB;AACA,WAAOG,IAAP;AACD;;AAbgE","sourcesContent":["import ts, { Node, TypeReferenceNode } from 'typescript';\nimport { SchemaTransformer } from '../schema-transformer';\nimport { SchemaExtractorContext } from '../schema-extractor-context';\n\nexport class TypeReferenceTransformer implements SchemaTransformer {\n  predicate(node: Node) {\n    return node.kind === ts.SyntaxKind.TypeReference;\n  }\n\n  async getIdentifiers() {\n    return [];\n  }\n\n  async transform(typeReference: TypeReferenceNode, context: SchemaExtractorContext) {\n    const name = typeReference.typeName.getText();\n    const type = await context.resolveType(typeReference, name);\n    return type;\n  }\n}\n"]}

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

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

package/dist/transformers/type-union.js

@@ -0,0 +1,63 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+require("core-js/modules/es.promise.js");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TypeUnionTransformer = 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;
+}
+
+class TypeUnionTransformer {
+  predicate(node) {
+    return node.kind === _typescript().default.SyntaxKind.UnionType;
+  }
+
+  async getIdentifiers() {
+    return [];
+  }
+
+  async transform(unionType, context) {
+    const types = await (0, _pMapSeries().default)(unionType.types, async type => {
+      const typeSchema = await context.computeSchema(type);
+      return typeSchema;
+    });
+    return new (_semanticsEntities().TypeUnionSchema)(types);
+  }
+
+}
+
+exports.TypeUnionTransformer = TypeUnionTransformer;
+
+//# sourceMappingURL=type-union.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["type-union.ts"],"names":["TypeUnionTransformer","predicate","node","kind","ts","SyntaxKind","UnionType","getIdentifiers","transform","unionType","context","types","type","typeSchema","computeSchema","TypeUnionSchema"],"mappings":";;;;;;;;;;;AAAA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;;AACA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;;AACA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;;AAIO,MAAMA,oBAAN,CAAwD;AAC7DC,EAAAA,SAAS,CAACC,IAAD,EAAa;AACpB,WAAOA,IAAI,CAACC,IAAL,KAAcC,sBAAGC,UAAH,CAAcC,SAAnC;AACD;;AAEmB,QAAdC,cAAc,GAAG;AACrB,WAAO,EAAP;AACD;;AAEc,QAATC,SAAS,CAACC,SAAD,EAA2BC,OAA3B,EAA4D;AACzE,UAAMC,KAAK,GAAG,MAAM,2BAAWF,SAAS,CAACE,KAArB,EAA4B,MAAOC,IAAP,IAAgB;AAC9D,YAAMC,UAAU,GAAG,MAAMH,OAAO,CAACI,aAAR,CAAsBF,IAAtB,CAAzB;AACA,aAAOC,UAAP;AACD,KAHmB,CAApB;AAIA,WAAO,KAAIE,oCAAJ,EAAoBJ,KAApB,CAAP;AACD;;AAf4D","sourcesContent":["import ts, { Node, UnionTypeNode } from 'typescript';\nimport pMapSeries from 'p-map-series';\nimport { TypeUnionSchema } from '@teambit/semantics.entities.semantic-schema';\nimport { SchemaTransformer } from '../schema-transformer';\nimport { SchemaExtractorContext } from '../schema-extractor-context';\n\nexport class TypeUnionTransformer implements SchemaTransformer {\n  predicate(node: Node) {\n    return node.kind === ts.SyntaxKind.UnionType;\n  }\n\n  async getIdentifiers() {\n    return [];\n  }\n\n  async transform(unionType: UnionTypeNode, context: SchemaExtractorContext) {\n    const types = await pMapSeries(unionType.types, async (type) => {\n      const typeSchema = await context.computeSchema(type);\n      return typeSchema;\n    });\n    return new TypeUnionSchema(types);\n  }\n}\n"]}