@teambit/typescript 0.0.587 → 0.0.591

package/dist/transformers/function-declaration.js

@@ -0,0 +1,101 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+require("core-js/modules/es.array.iterator.js");
+
+require("core-js/modules/es.promise.js");
+
+require("core-js/modules/es.regexp.exec.js");
+
+require("core-js/modules/es.string.trim.js");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.FunctionDeclaration = 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;
+}
+
+class FunctionDeclaration {
+  predicate(node) {
+    return node.kind === _typescript().default.SyntaxKind.FunctionDeclaration;
+  } // need to check for anonymous functions assigned for vars, const and let.
+
+
+  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 getArgs(funcDec, context) {
+    return Promise.all(funcDec.parameters.map(async param => {
+      const type = param.type;
+      return {
+        name: param.name.getText(),
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        type: await context.resolveType(type, (type === null || type === void 0 ? void 0 : type.getText()) || 'any')
+      };
+    }));
+  }
+
+  parseReturnValue(displayString) {
+    if (!displayString) return '';
+    const array = displayString.split(':');
+    return array[array.length - 1].trim();
+  }
+
+  async transform(node, context) {
+    var _info$body;
+
+    const funcDec = node;
+    const name = this.getName(funcDec); // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+
+    const info = await context.getQuickInfo(funcDec.name);
+    const displaySig = info === null || info === void 0 ? void 0 : (_info$body = info.body) === null || _info$body === void 0 ? void 0 : _info$body.displayString;
+    const returnTypeStr = this.parseReturnValue(displaySig); // eslint-disable-next-line @typescript-eslint/no-unused-vars
+
+    const args = await this.getArgs(funcDec, context); // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+
+    const returnType = await context.resolveType(funcDec.name, returnTypeStr);
+    return new (_semanticsEntities().FunctionSchema)(name || '', [], returnType);
+  }
+
+}
+
+exports.FunctionDeclaration = FunctionDeclaration;
+
+//# sourceMappingURL=function-declaration.js.map

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

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

package/dist/transformers/index.d.ts

@@ -0,0 +1,5 @@
+export { ExportDeclaration } from './export-declaration';
+export { FunctionDeclaration } from './function-declaration';
+export { VariableStatementTransformer } from './variable-statement';
+export { SourceFileTransformer } from './source-file-transformer';
+export { TypeAliasTransformer } from './type-alias';

package/dist/transformers/index.js

@@ -0,0 +1,87 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "ExportDeclaration", {
+  enumerable: true,
+  get: function () {
+    return _exportDeclaration().ExportDeclaration;
+  }
+});
+Object.defineProperty(exports, "FunctionDeclaration", {
+  enumerable: true,
+  get: function () {
+    return _functionDeclaration().FunctionDeclaration;
+  }
+});
+Object.defineProperty(exports, "SourceFileTransformer", {
+  enumerable: true,
+  get: function () {
+    return _sourceFileTransformer().SourceFileTransformer;
+  }
+});
+Object.defineProperty(exports, "TypeAliasTransformer", {
+  enumerable: true,
+  get: function () {
+    return _typeAlias().TypeAliasTransformer;
+  }
+});
+Object.defineProperty(exports, "VariableStatementTransformer", {
+  enumerable: true,
+  get: function () {
+    return _variableStatement().VariableStatementTransformer;
+  }
+});
+
+function _exportDeclaration() {
+  const data = require("./export-declaration");
+
+  _exportDeclaration = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _functionDeclaration() {
+  const data = require("./function-declaration");
+
+  _functionDeclaration = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _variableStatement() {
+  const data = require("./variable-statement");
+
+  _variableStatement = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _sourceFileTransformer() {
+  const data = require("./source-file-transformer");
+
+  _sourceFileTransformer = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _typeAlias() {
+  const data = require("./type-alias");
+
+  _typeAlias = function () {
+    return data;
+  };
+
+  return data;
+}
+
+//# sourceMappingURL=index.js.map

package/dist/transformers/index.js.map

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

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

@@ -0,0 +1,13 @@
+import { Node, SourceFile } from 'typescript';
+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)[]>;
+    /**
+     * list all exports of a source file.
+     */
+    private listExports;
+}

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

@@ -0,0 +1,82 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+require("core-js/modules/es.array.iterator.js");
+
+require("core-js/modules/es.promise.js");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SourceFileTransformer = void 0;
+
+function _typescript() {
+  const data = _interopRequireDefault(require("typescript"));
+
+  _typescript = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _lodash() {
+  const data = require("lodash");
+
+  _lodash = function () {
+    return data;
+  };
+
+  return data;
+}
+
+class SourceFileTransformer {
+  predicate(node) {
+    return node.kind === _typescript().default.SyntaxKind.SourceFile;
+  }
+
+  async getIdentifiers(sourceFile, context) {
+    const exports = this.listExports(sourceFile);
+    const exportNames = await Promise.all(exports.map(node => {
+      return context.getExportedIdentifiers(node);
+    }));
+    const exportIds = (0, _lodash().flatten)(exportNames).reduce((acc, current) => {
+      const item = acc.find(exportName => exportName.id === current.id);
+      if (!item) acc.push(current);
+      return acc;
+    }, []);
+    return exportIds;
+  }
+
+  async transform(node, context) {
+    const exports = this.listExports(node);
+    const schemas = await Promise.all(exports.map(exportNode => {
+      return context.computeSchema(exportNode);
+    }));
+    return schemas;
+  }
+  /**
+   * list all exports of a source file.
+   */
+
+
+  listExports(ast) {
+    return (0, _lodash().compact)(ast.statements.map(statement => {
+      var _statement$modifiers;
+
+      if (statement.kind === _typescript().default.SyntaxKind.ExportDeclaration) return statement;
+      const isExport = Boolean((_statement$modifiers = statement.modifiers) === null || _statement$modifiers === void 0 ? void 0 : _statement$modifiers.find(modifier => {
+        return modifier.kind === _typescript().default.SyntaxKind.ExportKeyword;
+      })); // eslint-disable-next-line consistent-return
+
+      if (!isExport) return;
+      return statement;
+    }));
+  }
+
+}
+
+exports.SourceFileTransformer = SourceFileTransformer;
+
+//# sourceMappingURL=source-file-transformer.js.map

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

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

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

@@ -0,0 +1,8 @@
+import { Node, TypeAliasDeclaration } from 'typescript';
+import { SchemaTransformer } from '../schema-transformer';
+import { ExportIdentifier } from '../export-identifier';
+export declare class TypeAliasTransformer implements SchemaTransformer {
+    predicate(node: Node): boolean;
+    getIdentifiers(node: TypeAliasDeclaration): Promise<ExportIdentifier[]>;
+    transform(): Promise<{}>;
+}

package/dist/transformers/type-alias.js

@@ -0,0 +1,49 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+require("core-js/modules/es.promise.js");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TypeAliasTransformer = void 0;
+
+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;
+}
+
+class TypeAliasTransformer {
+  predicate(node) {
+    return node.kind === _typescript().default.SyntaxKind.TypeAliasDeclaration;
+  }
+
+  async getIdentifiers(node) {
+    return [new (_exportIdentifier().ExportIdentifier)(node.name.getText(), node.getSourceFile().fileName)];
+  }
+
+  async transform() {
+    return {};
+  }
+
+}
+
+exports.TypeAliasTransformer = TypeAliasTransformer;
+
+//# sourceMappingURL=type-alias.js.map

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

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

package/dist/transformers/variable-statement.d.ts

@@ -0,0 +1,8 @@
+import { Node, VariableStatement } from 'typescript';
+import { SchemaTransformer } from '../schema-transformer';
+import { ExportIdentifier } from '../export-identifier';
+export declare class VariableStatementTransformer implements SchemaTransformer {
+    predicate(node: Node): boolean;
+    getIdentifiers(node: VariableStatement): Promise<ExportIdentifier[]>;
+    transform(): Promise<{}>;
+}

package/dist/transformers/variable-statement.js

@@ -0,0 +1,51 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+require("core-js/modules/es.promise.js");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.VariableStatementTransformer = void 0;
+
+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;
+}
+
+class VariableStatementTransformer {
+  predicate(node) {
+    return node.kind === _typescript().default.SyntaxKind.VariableStatement;
+  }
+
+  async getIdentifiers(node) {
+    return node.declarationList.declarations.map(dec => {
+      return new (_exportIdentifier().ExportIdentifier)(dec.name.getText(), dec.getSourceFile().fileName);
+    });
+  }
+
+  async transform() {
+    return {};
+  }
+
+}
+
+exports.VariableStatementTransformer = VariableStatementTransformer;
+
+//# sourceMappingURL=variable-statement.js.map

package/dist/transformers/variable-statement.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["variable-statement.ts"],"names":["VariableStatementTransformer","predicate","node","kind","ts","SyntaxKind","VariableStatement","getIdentifiers","declarationList","declarations","map","dec","ExportIdentifier","name","getText","getSourceFile","fileName","transform"],"mappings":";;;;;;;;;;;AAAA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;;AAEA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;;AAEO,MAAMA,4BAAN,CAAgE;AACrEC,EAAAA,SAAS,CAACC,IAAD,EAAa;AACpB,WAAOA,IAAI,CAACC,IAAL,KAAcC,sBAAGC,UAAH,CAAcC,iBAAnC;AACD;;AAEmB,QAAdC,cAAc,CAACL,IAAD,EAA0B;AAC5C,WAAOA,IAAI,CAACM,eAAL,CAAqBC,YAArB,CAAkCC,GAAlC,CAAuCC,GAAD,IAAS;AACpD,aAAO,KAAIC,oCAAJ,EAAqBD,GAAG,CAACE,IAAJ,CAASC,OAAT,EAArB,EAAyCH,GAAG,CAACI,aAAJ,GAAoBC,QAA7D,CAAP;AACD,KAFM,CAAP;AAGD;;AAEc,QAATC,SAAS,GAAG;AAChB,WAAO,EAAP;AACD;;AAboE","sourcesContent":["import ts, { Node, VariableStatement } from 'typescript';\nimport { SchemaTransformer } from '../schema-transformer';\nimport { ExportIdentifier } from '../export-identifier';\n\nexport class VariableStatementTransformer implements SchemaTransformer {\n  predicate(node: Node) {\n    return node.kind === ts.SyntaxKind.VariableStatement;\n  }\n\n  async getIdentifiers(node: VariableStatement) {\n    return node.declarationList.declarations.map((dec) => {\n      return new ExportIdentifier(dec.name.getText(), dec.getSourceFile().fileName);\n    });\n  }\n\n  async transform() {\n    return {};\n  }\n}\n"]}

package/dist/typescript.compiler.js

@@ -67,9 +67,9 @@ function _packageJsonFile() {
   return data;
 }
 
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
 
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2().default)(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { (0, _defineProperty2().default)(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
 
 class TypescriptCompiler {
   constructor(id, logger, options, tsModule) {

package/dist/typescript.compiler.spec.js

@@ -72,9 +72,9 @@ function _typescript3() {
   return data;
 }
 
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
 
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2().default)(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { (0, _defineProperty2().default)(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
 
 const defaultOpts = {
   tsconfig: {},

package/dist/typescript.extractor.d.ts

@@ -1,8 +1,28 @@
-import { TsConfigSourceFile } from 'typescript';
-import { Module, SchemaExtractor } from '@teambit/schema';
+import ts, { Node } from 'typescript';
+import { SchemaExtractor } from '@teambit/schema';
+import { SchemaNode, SemanticSchema } from '@teambit/semantics.entities.semantic-schema';
 import { Component } from '@teambit/component';
+import { AbstractVinyl } from '@teambit/legacy/dist/consumer/component/sources';
+import { TypescriptMain, SchemaTransformerSlot } from './typescript.main.runtime';
+import { SchemaExtractorContext } from './schema-extractor-context';
 export declare class TypeScriptExtractor implements SchemaExtractor {
     private tsconfig;
-    constructor(tsconfig: TsConfigSourceFile);
-    extract(component: Component): Promise<Module>;
+    private schemaTransformerSlot;
+    private tsMain;
+    private rootPath;
+    constructor(tsconfig: any, schemaTransformerSlot: SchemaTransformerSlot, tsMain: TypescriptMain, rootPath: string);
+    parseSourceFile(file: AbstractVinyl): ts.SourceFile;
+    /**
+     * extract a component schema.
+     */
+    extract(component: Component): Promise<SemanticSchema>;
+    computeExportedIdentifiers(node: Node, context: SchemaExtractorContext): Promise<import("./export-identifier").ExportIdentifier[]>;
+    private createContext;
+    private tsserver;
+    private getTsServer;
+    computeSchema(node: Node, context: SchemaExtractorContext): Promise<SchemaNode | undefined>;
+    /**
+     * select the correct transformer for a node.
+     */
+    private getTransformer;
 }