@teambit/typescript 0.0.965 → 0.0.967

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

@@ -1 +1 @@
-{"version":3,"names":["SourceFileTransformer","predicate","node","kind","ts","SyntaxKind","SourceFile","getIdentifiers","sourceFile","context","exports","listExports","exportNames","Promise","all","map","getExportedIdentifiers","exportIds","flatten","reduce","acc","current","item","find","exportName","id","push","transform","schemas","pMapSeries","exportNode","computeSchema","ModuleSchema","getLocation","ast","compact","statements","statement","ExportDeclaration","isExport","Boolean","modifiers","modifier","ExportKeyword"],"sources":["source-file-transformer.ts"],"sourcesContent":["import ts, { Node, SourceFile } from 'typescript';\nimport { compact, flatten } from 'lodash';\nimport pMapSeries from 'p-map-series';\nimport { ModuleSchema } 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 ModuleSchema(context.getLocation(node), 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"],"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;AAKO,MAAMA,qBAAqB,CAA8B;EAC9DC,SAAS,CAACC,IAAU,EAAE;IACpB,OAAOA,IAAI,CAACC,IAAI,KAAKC,qBAAE,CAACC,UAAU,CAACC,UAAU;EAC/C;EAEA,MAAMC,cAAc,CAACC,UAAsB,EAAEC,OAA+B,EAAE;IAC5E,MAAMC,OAAO,GAAG,IAAI,CAACC,WAAW,CAACH,UAAU,CAAC;IAE5C,MAAMI,WAAW,GAAG,MAAMC,OAAO,CAACC,GAAG,CACnCJ,OAAO,CAACK,GAAG,CAAEb,IAAU,IAAK;MAC1B,OAAOO,OAAO,CAACO,sBAAsB,CAACd,IAAI,CAAC;IAC7C,CAAC,CAAC,CACH;IAED,MAAMe,SAAS,GAAG,IAAAC,iBAAO,EAACN,WAAW,CAAC,CAACO,MAAM,CAAqB,CAACC,GAAG,EAAEC,OAAO,KAAK;MAClF,MAAMC,IAAI,GAAGF,GAAG,CAACG,IAAI,CAAEC,UAAU,IAAKA,UAAU,CAACC,EAAE,KAAKJ,OAAO,CAACI,EAAE,CAAC;MACnE,IAAI,CAACH,IAAI,EAAEF,GAAG,CAACM,IAAI,CAACL,OAAO,CAAC;MAC5B,OAAOD,GAAG;IACZ,CAAC,EAAE,EAAE,CAAC;IAEN,OAAOH,SAAS;EAClB;EAEA,MAAMU,SAAS,CAACzB,IAAgB,EAAEO,OAA+B,EAAE;IACjE,MAAMC,OAAO,GAAG,IAAI,CAACC,WAAW,CAACT,IAAI,CAAC;IACtC,MAAM0B,OAAO,GAAG,MAAM,IAAAC,qBAAU,EAACnB,OAAO,EAAGoB,UAAU,IAAK;MACxD,OAAOrB,OAAO,CAACsB,aAAa,CAACD,UAAU,CAAC;IAC1C,CAAC,CAAC;IAEF,OAAO,KAAIE,iCAAY,EAACvB,OAAO,CAACwB,WAAW,CAAC/B,IAAI,CAAC,EAAE0B,OAAO,CAAC;EAC7D;;EAEA;AACF;AACA;EACUjB,WAAW,CAACuB,GAAe,EAAU;IAC3C,OAAO,IAAAC,iBAAO,EACZD,GAAG,CAACE,UAAU,CAACrB,GAAG,CAAEsB,SAAS,IAAK;MAAA;MAChC,IAAIA,SAAS,CAAClC,IAAI,KAAKC,qBAAE,CAACC,UAAU,CAACiC,iBAAiB,EAAE,OAAOD,SAAS;MACxE,MAAME,QAAQ,GAAGC,OAAO,yBACtBH,SAAS,CAACI,SAAS,yDAAnB,qBAAqBlB,IAAI,CAAEmB,QAAQ,IAAK;QACtC,OAAOA,QAAQ,CAACvC,IAAI,KAAKC,qBAAE,CAACC,UAAU,CAACsC,aAAa;MACtD,CAAC,CAAC,CACH;;MAED;MACA,IAAI,CAACJ,QAAQ,EAAE;MACf,OAAOF,SAAS;IAClB,CAAC,CAAC,CACH;EACH;AACF;AAAC"}
+{"version":3,"names":["SourceFileTransformer","predicate","node","kind","ts","SyntaxKind","SourceFile","getIdentifiers","sourceFile","context","exports","listExports","internals","listInternalNodes","exportIdentifiers","flatten","pMapSeries","reduce","acc","current","item","find","exportIdentifier","isEqual","push","ExportIdentifier","id","filePath","aliasId","sourceFilePath","internalIdentifiers","internalIdentifier","identifiers","transform","filter","internal","ImportDeclaration","exportDeclarations","exportNode","computeSchema","internalDeclarations","internalNode","ModuleSchema","getLocation","ast","statements","statement","ExportDeclaration","ExportAssignment","isExport","Boolean","modifiers","modifier","ExportKeyword"],"sources":["source-file-transformer.ts"],"sourcesContent":["import ts, { Node, SourceFile } from 'typescript';\nimport { flatten } from 'lodash';\nimport pMapSeries from 'p-map-series';\nimport { ModuleSchema } from '@teambit/semantics.entities.semantic-schema';\nimport { SchemaTransformer } from '../schema-transformer';\nimport { ExportIdentifier } from '../export-identifier';\nimport { SchemaExtractorContext } from '../schema-extractor-context';\nimport { Identifier } from '../identifier';\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    const internals = this.listInternalNodes(sourceFile);\n\n    // change to pMap series\n    const exportIdentifiers = flatten(\n      await pMapSeries(exports, (node) => {\n        return context.getIdentifiers(node);\n      })\n    ).reduce<ExportIdentifier[]>((acc, current) => {\n      const item = acc.find((exportIdentifier) => exportIdentifier.isEqual(current));\n      if (!item) acc.push(new ExportIdentifier(current.id, current.filePath, current.aliasId, current.sourceFilePath));\n      return acc;\n    }, []);\n\n    const internalIdentifiers = flatten(\n      await pMapSeries(internals, (node) => {\n        return context.getIdentifiers(node);\n      })\n    ).reduce<Identifier[]>((acc, current) => {\n      const item = acc.find((internalIdentifier) => internalIdentifier.isEqual(current));\n      if (!item) acc.push(current);\n      return acc;\n    }, []);\n\n    const identifiers = [...exportIdentifiers, ...internalIdentifiers];\n\n    return identifiers;\n  }\n\n  async transform(node: SourceFile, context: SchemaExtractorContext) {\n    const exports = this.listExports(node);\n    const internals = this.listInternalNodes(node).filter(\n      (internal) => internal.kind !== ts.SyntaxKind.ImportDeclaration\n    );\n\n    const exportDeclarations = await pMapSeries(exports, (exportNode) => {\n      return context.computeSchema(exportNode);\n    });\n\n    const internalDeclarations = await pMapSeries(internals, (internalNode) => {\n      return context.computeSchema(internalNode);\n    });\n\n    return new ModuleSchema(context.getLocation(node), exportDeclarations, internalDeclarations);\n  }\n\n  /**\n   * list all exports of a source file.\n   */\n  private listExports(ast: SourceFile): Node[] {\n    return ast.statements.filter((statement) => {\n      if (statement.kind === ts.SyntaxKind.ExportDeclaration || statement.kind === ts.SyntaxKind.ExportAssignment)\n        return true;\n      const isExport = Boolean(\n        statement.modifiers?.find((modifier) => {\n          return modifier.kind === ts.SyntaxKind.ExportKeyword;\n        })\n      );\n      return isExport;\n    });\n  }\n\n  private listInternalNodes(ast: SourceFile): Node[] {\n    return ast.statements.filter((statement) => {\n      if (\n        !(statement.kind === ts.SyntaxKind.ExportDeclaration || statement.kind === ts.SyntaxKind.ExportAssignment) &&\n        !statement.modifiers?.find((modifier) => {\n          return modifier.kind === ts.SyntaxKind.ExportKeyword;\n        })\n      ) {\n        return true;\n      }\n\n      return false;\n    });\n  }\n}\n"],"mappings":"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"}

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

@@ -0,0 +1,10 @@
+import { Node, TemplateLiteralTypeSpan } from 'typescript';
+import { TemplateLiteralTypeSpanSchema } from '@teambit/semantics.entities.semantic-schema';
+import { SchemaTransformer } from '../schema-transformer';
+import { SchemaExtractorContext } from '../schema-extractor-context';
+import { Identifier } from '../identifier';
+export declare class TemplateLiteralTypeSpanTransformer implements SchemaTransformer {
+    predicate(node: Node): boolean;
+    getIdentifiers(): Promise<Identifier[]>;
+    transform(node: TemplateLiteralTypeSpan, context: SchemaExtractorContext): Promise<TemplateLiteralTypeSpanSchema>;
+}

package/dist/transformers/template-literal-type-span.js

@@ -0,0 +1,37 @@
+"use strict";
+
+require("core-js/modules/es.promise.js");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TemplateLiteralTypeSpanTransformer = void 0;
+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;
+}
+class TemplateLiteralTypeSpanTransformer {
+  predicate(node) {
+    return node.kind === _typescript().SyntaxKind.TemplateLiteralTypeSpan;
+  }
+  async getIdentifiers() {
+    return [];
+  }
+  async transform(node, context) {
+    const type = await context.computeSchema(node.type);
+    const literal = node.literal.text;
+    return new (_semanticsEntities().TemplateLiteralTypeSpanSchema)(context.getLocation(node), literal, type);
+  }
+}
+exports.TemplateLiteralTypeSpanTransformer = TemplateLiteralTypeSpanTransformer;
+
+//# sourceMappingURL=template-literal-type-span.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["TemplateLiteralTypeSpanTransformer","predicate","node","kind","SyntaxKind","TemplateLiteralTypeSpan","getIdentifiers","transform","context","type","computeSchema","literal","text","TemplateLiteralTypeSpanSchema","getLocation"],"sources":["template-literal-type-span.ts"],"sourcesContent":["import { Node, SyntaxKind, TemplateLiteralTypeSpan } from 'typescript';\nimport { TemplateLiteralTypeSpanSchema } from '@teambit/semantics.entities.semantic-schema';\nimport { SchemaTransformer } from '../schema-transformer';\nimport { SchemaExtractorContext } from '../schema-extractor-context';\nimport { Identifier } from '../identifier';\n\nexport class TemplateLiteralTypeSpanTransformer implements SchemaTransformer {\n  predicate(node: Node) {\n    return node.kind === SyntaxKind.TemplateLiteralTypeSpan;\n  }\n\n  async getIdentifiers(): Promise<Identifier[]> {\n    return [];\n  }\n\n  async transform(node: TemplateLiteralTypeSpan, context: SchemaExtractorContext) {\n    const type = await context.computeSchema(node.type);\n    const literal = node.literal.text;\n    return new TemplateLiteralTypeSpanSchema(context.getLocation(node), literal, type);\n  }\n}\n"],"mappings":";;;;;;;AAAA;EAAA;EAAA;IAAA;EAAA;EAAA;AAAA;AACA;EAAA;EAAA;IAAA;EAAA;EAAA;AAAA;AAKO,MAAMA,kCAAkC,CAA8B;EAC3EC,SAAS,CAACC,IAAU,EAAE;IACpB,OAAOA,IAAI,CAACC,IAAI,KAAKC,wBAAU,CAACC,uBAAuB;EACzD;EAEA,MAAMC,cAAc,GAA0B;IAC5C,OAAO,EAAE;EACX;EAEA,MAAMC,SAAS,CAACL,IAA6B,EAAEM,OAA+B,EAAE;IAC9E,MAAMC,IAAI,GAAG,MAAMD,OAAO,CAACE,aAAa,CAACR,IAAI,CAACO,IAAI,CAAC;IACnD,MAAME,OAAO,GAAGT,IAAI,CAACS,OAAO,CAACC,IAAI;IACjC,OAAO,KAAIC,kDAA6B,EAACL,OAAO,CAACM,WAAW,CAACZ,IAAI,CAAC,EAAES,OAAO,EAAEF,IAAI,CAAC;EACpF;AACF;AAAC"}

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

@@ -0,0 +1,10 @@
+import { Node, TemplateLiteralTypeNode } from 'typescript';
+import { TemplateLiteralTypeSchema } from '@teambit/semantics.entities.semantic-schema';
+import { SchemaTransformer } from '../schema-transformer';
+import { SchemaExtractorContext } from '../schema-extractor-context';
+import { Identifier } from '../identifier';
+export declare class TemplateLiteralTypeTransformer implements SchemaTransformer {
+    predicate(node: Node): boolean;
+    getIdentifiers(): Promise<Identifier[]>;
+    transform(node: TemplateLiteralTypeNode, context: SchemaExtractorContext): Promise<TemplateLiteralTypeSchema>;
+}

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

@@ -0,0 +1,45 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+require("core-js/modules/es.promise.js");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TemplateLiteralTypeTransformer = void 0;
+function _typescript() {
+  const data = 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 TemplateLiteralTypeTransformer {
+  predicate(node) {
+    return node.kind === _typescript().SyntaxKind.TemplateLiteralType;
+  }
+  async getIdentifiers() {
+    return [];
+  }
+  async transform(node, context) {
+    const templateSpans = await (0, _pMapSeries().default)(node.templateSpans, span => context.computeSchema(span));
+    const head = node.head.text;
+    return new (_semanticsEntities().TemplateLiteralTypeSchema)(context.getLocation(node), head, templateSpans);
+  }
+}
+exports.TemplateLiteralTypeTransformer = TemplateLiteralTypeTransformer;
+
+//# sourceMappingURL=template-literal-type.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["TemplateLiteralTypeTransformer","predicate","node","kind","SyntaxKind","TemplateLiteralType","getIdentifiers","transform","context","templateSpans","pMapSeries","span","computeSchema","head","text","TemplateLiteralTypeSchema","getLocation"],"sources":["template-literal-type.ts"],"sourcesContent":["import { Node, SyntaxKind, TemplateLiteralTypeNode } from 'typescript';\nimport pMapSeries from 'p-map-series';\nimport { TemplateLiteralTypeSchema, TemplateLiteralTypeSpanSchema } from '@teambit/semantics.entities.semantic-schema';\nimport { SchemaTransformer } from '../schema-transformer';\nimport { SchemaExtractorContext } from '../schema-extractor-context';\nimport { Identifier } from '../identifier';\n\nexport class TemplateLiteralTypeTransformer implements SchemaTransformer {\n  predicate(node: Node) {\n    return node.kind === SyntaxKind.TemplateLiteralType;\n  }\n\n  async getIdentifiers(): Promise<Identifier[]> {\n    return [];\n  }\n\n  async transform(node: TemplateLiteralTypeNode, context: SchemaExtractorContext) {\n    const templateSpans = (await pMapSeries(node.templateSpans, (span) =>\n      context.computeSchema(span)\n    )) as TemplateLiteralTypeSpanSchema[];\n    const head = node.head.text;\n    return new TemplateLiteralTypeSchema(context.getLocation(node), head, templateSpans);\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;AAKO,MAAMA,8BAA8B,CAA8B;EACvEC,SAAS,CAACC,IAAU,EAAE;IACpB,OAAOA,IAAI,CAACC,IAAI,KAAKC,wBAAU,CAACC,mBAAmB;EACrD;EAEA,MAAMC,cAAc,GAA0B;IAC5C,OAAO,EAAE;EACX;EAEA,MAAMC,SAAS,CAACL,IAA6B,EAAEM,OAA+B,EAAE;IAC9E,MAAMC,aAAa,GAAI,MAAM,IAAAC,qBAAU,EAACR,IAAI,CAACO,aAAa,EAAGE,IAAI,IAC/DH,OAAO,CAACI,aAAa,CAACD,IAAI,CAAC,CACQ;IACrC,MAAME,IAAI,GAAGX,IAAI,CAACW,IAAI,CAACC,IAAI;IAC3B,OAAO,KAAIC,8CAAyB,EAACP,OAAO,CAACQ,WAAW,CAACd,IAAI,CAAC,EAAEW,IAAI,EAAEJ,aAAa,CAAC;EACtF;AACF;AAAC"}

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

@@ -0,0 +1,10 @@
+import { Node, ThisTypeNode } from 'typescript';
+import { ThisTypeSchema } from '@teambit/semantics.entities.semantic-schema';
+import { SchemaTransformer } from '../schema-transformer';
+import { SchemaExtractorContext } from '../schema-extractor-context';
+import { Identifier } from '../identifier';
+export declare class ThisTypeTransformer implements SchemaTransformer {
+    predicate(node: Node): boolean;
+    getIdentifiers(): Promise<Identifier[]>;
+    transform(node: ThisTypeNode, context: SchemaExtractorContext): Promise<ThisTypeSchema>;
+}

package/dist/transformers/this-type.js

@@ -0,0 +1,35 @@
+"use strict";
+
+require("core-js/modules/es.promise.js");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ThisTypeTransformer = void 0;
+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;
+}
+class ThisTypeTransformer {
+  predicate(node) {
+    return node.kind === _typescript().SyntaxKind.ThisType;
+  }
+  async getIdentifiers() {
+    return [];
+  }
+  async transform(node, context) {
+    return new (_semanticsEntities().ThisTypeSchema)(context.getLocation(node));
+  }
+}
+exports.ThisTypeTransformer = ThisTypeTransformer;
+
+//# sourceMappingURL=this-type.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["ThisTypeTransformer","predicate","node","kind","SyntaxKind","ThisType","getIdentifiers","transform","context","ThisTypeSchema","getLocation"],"sources":["this-type.ts"],"sourcesContent":["import { Node, SyntaxKind, ThisTypeNode } from 'typescript';\nimport { ThisTypeSchema } from '@teambit/semantics.entities.semantic-schema';\nimport { SchemaTransformer } from '../schema-transformer';\nimport { SchemaExtractorContext } from '../schema-extractor-context';\nimport { Identifier } from '../identifier';\n\nexport class ThisTypeTransformer implements SchemaTransformer {\n  predicate(node: Node) {\n    return node.kind === SyntaxKind.ThisType;\n  }\n\n  async getIdentifiers(): Promise<Identifier[]> {\n    return [];\n  }\n\n  async transform(node: ThisTypeNode, context: SchemaExtractorContext) {\n    return new ThisTypeSchema(context.getLocation(node));\n  }\n}\n"],"mappings":";;;;;;;AAAA;EAAA;EAAA;IAAA;EAAA;EAAA;AAAA;AACA;EAAA;EAAA;IAAA;EAAA;EAAA;AAAA;AAKO,MAAMA,mBAAmB,CAA8B;EAC5DC,SAAS,CAACC,IAAU,EAAE;IACpB,OAAOA,IAAI,CAACC,IAAI,KAAKC,wBAAU,CAACC,QAAQ;EAC1C;EAEA,MAAMC,cAAc,GAA0B;IAC5C,OAAO,EAAE;EACX;EAEA,MAAMC,SAAS,CAACL,IAAkB,EAAEM,OAA+B,EAAE;IACnE,OAAO,KAAIC,mCAAc,EAACD,OAAO,CAACE,WAAW,CAACR,IAAI,CAAC,CAAC;EACtD;AACF;AAAC"}

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

@@ -0,0 +1,10 @@
+import { Node, TupleTypeNode } from 'typescript';
+import { TupleTypeSchema } from '@teambit/semantics.entities.semantic-schema';
+import { SchemaTransformer } from '../schema-transformer';
+import { SchemaExtractorContext } from '../schema-extractor-context';
+import { Identifier } from '../identifier';
+export declare class TupleTypeTransformer implements SchemaTransformer {
+    predicate(node: Node): boolean;
+    getIdentifiers(): Promise<Identifier[]>;
+    transform(node: TupleTypeNode, context: SchemaExtractorContext): Promise<TupleTypeSchema>;
+}

package/dist/transformers/tuple-type.js

@@ -0,0 +1,47 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+require("core-js/modules/es.promise.js");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TupleTypeTransformer = void 0;
+function _typescript() {
+  const data = 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 TupleTypeTransformer {
+  predicate(node) {
+    return node.kind === _typescript().SyntaxKind.TupleType;
+  }
+  async getIdentifiers() {
+    return [];
+  }
+  async transform(node, context) {
+    const elements = await (0, _pMapSeries().default)(node.elements, async elem => {
+      const typeSchema = await context.computeSchema(elem);
+      return typeSchema;
+    });
+    return new (_semanticsEntities().TupleTypeSchema)(context.getLocation(node), elements);
+  }
+}
+exports.TupleTypeTransformer = TupleTypeTransformer;
+
+//# sourceMappingURL=tuple-type.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["TupleTypeTransformer","predicate","node","kind","SyntaxKind","TupleType","getIdentifiers","transform","context","elements","pMapSeries","elem","typeSchema","computeSchema","TupleTypeSchema","getLocation"],"sources":["tuple-type.ts"],"sourcesContent":["import { Node, SyntaxKind, TupleTypeNode } from 'typescript';\nimport pMapSeries from 'p-map-series';\nimport { TupleTypeSchema } from '@teambit/semantics.entities.semantic-schema';\nimport { SchemaTransformer } from '../schema-transformer';\nimport { SchemaExtractorContext } from '../schema-extractor-context';\nimport { Identifier } from '../identifier';\n\nexport class TupleTypeTransformer implements SchemaTransformer {\n  predicate(node: Node) {\n    return node.kind === SyntaxKind.TupleType;\n  }\n\n  async getIdentifiers(): Promise<Identifier[]> {\n    return [];\n  }\n\n  async transform(node: TupleTypeNode, context: SchemaExtractorContext) {\n    const elements = await pMapSeries(node.elements, async (elem) => {\n      const typeSchema = await context.computeSchema(elem);\n      return typeSchema;\n    });\n    return new TupleTypeSchema(context.getLocation(node), elements);\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;AAKO,MAAMA,oBAAoB,CAA8B;EAC7DC,SAAS,CAACC,IAAU,EAAE;IACpB,OAAOA,IAAI,CAACC,IAAI,KAAKC,wBAAU,CAACC,SAAS;EAC3C;EAEA,MAAMC,cAAc,GAA0B;IAC5C,OAAO,EAAE;EACX;EAEA,MAAMC,SAAS,CAACL,IAAmB,EAAEM,OAA+B,EAAE;IACpE,MAAMC,QAAQ,GAAG,MAAM,IAAAC,qBAAU,EAACR,IAAI,CAACO,QAAQ,EAAE,MAAOE,IAAI,IAAK;MAC/D,MAAMC,UAAU,GAAG,MAAMJ,OAAO,CAACK,aAAa,CAACF,IAAI,CAAC;MACpD,OAAOC,UAAU;IACnB,CAAC,CAAC;IACF,OAAO,KAAIE,oCAAe,EAACN,OAAO,CAACO,WAAW,CAACb,IAAI,CAAC,EAAEO,QAAQ,CAAC;EACjE;AACF;AAAC"}

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

@@ -2,10 +2,10 @@ 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';
+import { Identifier } from '../identifier';
 export declare class TypeAliasTransformer implements SchemaTransformer {
     predicate(node: Node): boolean;
-    getIdentifiers(node: TypeAliasDeclaration): Promise<ExportIdentifier[]>;
+    getIdentifiers(node: TypeAliasDeclaration): Promise<Identifier[]>;
     private getName;
     transform(typeAlias: TypeAliasDeclaration, context: SchemaExtractorContext): Promise<TypeSchema>;
 }

package/dist/transformers/type-alias.js

@@ -20,16 +20,9 @@ function _semanticsEntities() {
   };
   return data;
 }
-function _exportIdentifier() {
-  const data = require("../export-identifier");
-  _exportIdentifier = function () {
-    return data;
-  };
-  return data;
-}
-function _typeNodeToSchema() {
-  const data = require("./utils/type-node-to-schema");
-  _typeNodeToSchema = function () {
+function _identifier() {
+  const data = require("../identifier");
+  _identifier = function () {
     return data;
   };
   return data;
@@ -39,13 +32,13 @@ class TypeAliasTransformer {
     return node.kind === _typescript().default.SyntaxKind.TypeAliasDeclaration;
   }
   async getIdentifiers(node) {
-    return [new (_exportIdentifier().ExportIdentifier)(node.name.getText(), node.getSourceFile().fileName)];
+    return [new (_identifier().Identifier)(node.name.getText(), node.getSourceFile().fileName)];
   }
   getName(node) {
     return node.name.getText();
   }
   async transform(typeAlias, context) {
-    const type = await (0, _typeNodeToSchema().typeNodeToSchema)(typeAlias.type, context);
+    const type = await context.computeSchema(typeAlias.type);
     const displaySig = await context.getQuickInfoDisplayString(typeAlias.name);
     const doc = await context.jsDocToDocSchema(typeAlias);
     return new (_semanticsEntities().TypeSchema)(context.getLocation(typeAlias), this.getName(typeAlias), type, displaySig, doc);

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

@@ -1 +1 @@
-{"version":3,"names":["TypeAliasTransformer","predicate","node","kind","ts","SyntaxKind","TypeAliasDeclaration","getIdentifiers","ExportIdentifier","name","getText","getSourceFile","fileName","getName","transform","typeAlias","context","type","typeNodeToSchema","displaySig","getQuickInfoDisplayString","doc","jsDocToDocSchema","TypeSchema","getLocation"],"sources":["type-alias.ts"],"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';\nimport { typeNodeToSchema } from './utils/type-node-to-schema';\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    const type = await typeNodeToSchema(typeAlias.type, context);\n    const displaySig = await context.getQuickInfoDisplayString(typeAlias.name);\n    const doc = await context.jsDocToDocSchema(typeAlias);\n    return new TypeSchema(context.getLocation(typeAlias), this.getName(typeAlias), type, displaySig, doc);\n  }\n}\n"],"mappings":";;;;;;;;AAAA;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,oBAAoB,CAA8B;EAC7DC,SAAS,CAACC,IAAU,EAAE;IACpB,OAAOA,IAAI,CAACC,IAAI,KAAKC,qBAAE,CAACC,UAAU,CAACC,oBAAoB;EACzD;EAEA,MAAMC,cAAc,CAACL,IAA0B,EAAE;IAC/C,OAAO,CAAC,KAAIM,oCAAgB,EAACN,IAAI,CAACO,IAAI,CAACC,OAAO,EAAE,EAAER,IAAI,CAACS,aAAa,EAAE,CAACC,QAAQ,CAAC,CAAC;EACnF;EAEQC,OAAO,CAACX,IAA0B,EAAU;IAClD,OAAOA,IAAI,CAACO,IAAI,CAACC,OAAO,EAAE;EAC5B;EAEA,MAAMI,SAAS,CAACC,SAA+B,EAAEC,OAA+B,EAAE;IAChF,MAAMC,IAAI,GAAG,MAAM,IAAAC,oCAAgB,EAACH,SAAS,CAACE,IAAI,EAAED,OAAO,CAAC;IAC5D,MAAMG,UAAU,GAAG,MAAMH,OAAO,CAACI,yBAAyB,CAACL,SAAS,CAACN,IAAI,CAAC;IAC1E,MAAMY,GAAG,GAAG,MAAML,OAAO,CAACM,gBAAgB,CAACP,SAAS,CAAC;IACrD,OAAO,KAAIQ,+BAAU,EAACP,OAAO,CAACQ,WAAW,CAACT,SAAS,CAAC,EAAE,IAAI,CAACF,OAAO,CAACE,SAAS,CAAC,EAAEE,IAAI,EAAEE,UAAU,EAAEE,GAAG,CAAC;EACvG;AACF;AAAC"}
+{"version":3,"names":["TypeAliasTransformer","predicate","node","kind","ts","SyntaxKind","TypeAliasDeclaration","getIdentifiers","Identifier","name","getText","getSourceFile","fileName","getName","transform","typeAlias","context","type","computeSchema","displaySig","getQuickInfoDisplayString","doc","jsDocToDocSchema","TypeSchema","getLocation"],"sources":["type-alias.ts"],"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 { Identifier } from '../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 Identifier(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    const type = await context.computeSchema(typeAlias.type);\n    const displaySig = await context.getQuickInfoDisplayString(typeAlias.name);\n    const doc = await context.jsDocToDocSchema(typeAlias);\n    return new TypeSchema(context.getLocation(typeAlias), this.getName(typeAlias), type, displaySig, doc);\n  }\n}\n"],"mappings":";;;;;;;;AAAA;EAAA;EAAA;IAAA;EAAA;EAAA;AAAA;AACA;EAAA;EAAA;IAAA;EAAA;EAAA;AAAA;AAGA;EAAA;EAAA;IAAA;EAAA;EAAA;AAAA;AAEO,MAAMA,oBAAoB,CAA8B;EAC7DC,SAAS,CAACC,IAAU,EAAE;IACpB,OAAOA,IAAI,CAACC,IAAI,KAAKC,qBAAE,CAACC,UAAU,CAACC,oBAAoB;EACzD;EAEA,MAAMC,cAAc,CAACL,IAA0B,EAAE;IAC/C,OAAO,CAAC,KAAIM,wBAAU,EAACN,IAAI,CAACO,IAAI,CAACC,OAAO,EAAE,EAAER,IAAI,CAACS,aAAa,EAAE,CAACC,QAAQ,CAAC,CAAC;EAC7E;EAEQC,OAAO,CAACX,IAA0B,EAAU;IAClD,OAAOA,IAAI,CAACO,IAAI,CAACC,OAAO,EAAE;EAC5B;EAEA,MAAMI,SAAS,CAACC,SAA+B,EAAEC,OAA+B,EAAE;IAChF,MAAMC,IAAI,GAAG,MAAMD,OAAO,CAACE,aAAa,CAACH,SAAS,CAACE,IAAI,CAAC;IACxD,MAAME,UAAU,GAAG,MAAMH,OAAO,CAACI,yBAAyB,CAACL,SAAS,CAACN,IAAI,CAAC;IAC1E,MAAMY,GAAG,GAAG,MAAML,OAAO,CAACM,gBAAgB,CAACP,SAAS,CAAC;IACrD,OAAO,KAAIQ,+BAAU,EAACP,OAAO,CAACQ,WAAW,CAACT,SAAS,CAAC,EAAE,IAAI,CAACF,OAAO,CAACE,SAAS,CAAC,EAAEE,IAAI,EAAEE,UAAU,EAAEE,GAAG,CAAC;EACvG;AACF;AAAC"}

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 { Identifier } from '../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<Identifier[]>;
+    transform(node: TypeLiteralNode, context: SchemaExtractorContext): Promise<TypeLiteralSchema>;
+}

package/dist/transformers/type-literal.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.TypeLiteralTransformer = void 0;
+function _typescript() {
+  const data = _interopRequireDefault(require("typescript"));
+  _typescript = function () {
+    return data;
+  };
+  return data;
+}
+function _semanticsEntities() {
+  const data = require("@teambit/semantics.entities.semantic-schema");
+  _semanticsEntities = function () {
+    return data;
+  };
+  return data;
+}
+function _pMapSeries() {
+  const data = _interopRequireDefault(require("p-map-series"));
+  _pMapSeries = 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(node, context) {
+    const members = await (0, _pMapSeries().default)(node.members, member => context.computeSchema(member));
+    const location = context.getLocation(node);
+    return new (_semanticsEntities().TypeLiteralSchema)(location, members);
+  }
+}
+exports.TypeLiteralTransformer = TypeLiteralTransformer;
+
+//# sourceMappingURL=type-literal.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["TypeLiteralTransformer","predicate","node","kind","ts","SyntaxKind","TypeLiteral","getIdentifiers","transform","context","members","pMapSeries","member","computeSchema","location","getLocation","TypeLiteralSchema"],"sources":["type-literal.ts"],"sourcesContent":["import ts, { Node, TypeLiteralNode } from 'typescript';\nimport { TypeLiteralSchema } from '@teambit/semantics.entities.semantic-schema';\nimport pMapSeries from 'p-map-series';\nimport { SchemaTransformer } from '../schema-transformer';\nimport { SchemaExtractorContext } from '../schema-extractor-context';\nimport { Identifier } from '../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<Identifier[]> {\n    return [];\n  }\n\n  async transform(node: TypeLiteralNode, context: SchemaExtractorContext) {\n    const members = await pMapSeries(node.members, (member) => context.computeSchema(member));\n    const location = context.getLocation(node);\n    return new TypeLiteralSchema(location, 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;AAKA;AACA;AACA;AACA;AACO,MAAMA,sBAAsB,CAA8B;EAC/DC,SAAS,CAACC,IAAU,EAAE;IACpB,OAAOA,IAAI,CAACC,IAAI,KAAKC,qBAAE,CAACC,UAAU,CAACC,WAAW;EAChD;EAEA,MAAMC,cAAc,GAA0B;IAC5C,OAAO,EAAE;EACX;EAEA,MAAMC,SAAS,CAACN,IAAqB,EAAEO,OAA+B,EAAE;IACtE,MAAMC,OAAO,GAAG,MAAM,IAAAC,qBAAU,EAACT,IAAI,CAACQ,OAAO,EAAGE,MAAM,IAAKH,OAAO,CAACI,aAAa,CAACD,MAAM,CAAC,CAAC;IACzF,MAAME,QAAQ,GAAGL,OAAO,CAACM,WAAW,CAACb,IAAI,CAAC;IAC1C,OAAO,KAAIc,sCAAiB,EAACF,QAAQ,EAAEJ,OAAO,CAAC;EACjD;AACF;AAAC"}

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

@@ -0,0 +1,14 @@
+import { Node, TypeOperatorNode, SyntaxKind } from 'typescript';
+import { TypeOperatorSchema } from '@teambit/semantics.entities.semantic-schema';
+import { SchemaTransformer } from '../schema-transformer';
+import { SchemaExtractorContext } from '../schema-extractor-context';
+import { Identifier } from '../identifier';
+/**
+ * e.g. keyof typeof Foo
+ */
+export declare class TypeOperatorTransformer implements SchemaTransformer {
+    predicate(node: Node): boolean;
+    getIdentifiers(): Promise<Identifier[]>;
+    transform(node: TypeOperatorNode, context: SchemaExtractorContext): Promise<TypeOperatorSchema>;
+    getOperatorName(operator: SyntaxKind.KeyOfKeyword | SyntaxKind.UniqueKeyword | SyntaxKind.ReadonlyKeyword): "readonly" | "keyof" | "unique";
+}

package/dist/transformers/type-operator.js

@@ -0,0 +1,52 @@
+"use strict";
+
+require("core-js/modules/es.promise.js");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TypeOperatorTransformer = void 0;
+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;
+}
+/**
+ * e.g. keyof typeof Foo
+ */
+class TypeOperatorTransformer {
+  predicate(node) {
+    return node.kind === _typescript().SyntaxKind.TypeOperator;
+  }
+  async getIdentifiers() {
+    return [];
+  }
+  async transform(node, context) {
+    const operatorName = this.getOperatorName(node.operator);
+    const type = await context.computeSchema(node.type);
+    return new (_semanticsEntities().TypeOperatorSchema)(context.getLocation(node), operatorName, type);
+  }
+  getOperatorName(operator) {
+    switch (operator) {
+      case _typescript().SyntaxKind.KeyOfKeyword:
+        return 'keyof';
+      case _typescript().SyntaxKind.UniqueKeyword:
+        return 'unique';
+      case _typescript().SyntaxKind.ReadonlyKeyword:
+        return 'readonly';
+      default:
+        throw new Error(`getOperatorName: unable to find operator name for ${operator}`);
+    }
+  }
+}
+exports.TypeOperatorTransformer = TypeOperatorTransformer;
+
+//# sourceMappingURL=type-operator.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["TypeOperatorTransformer","predicate","node","kind","SyntaxKind","TypeOperator","getIdentifiers","transform","context","operatorName","getOperatorName","operator","type","computeSchema","TypeOperatorSchema","getLocation","KeyOfKeyword","UniqueKeyword","ReadonlyKeyword","Error"],"sources":["type-operator.ts"],"sourcesContent":["import { Node, TypeOperatorNode, SyntaxKind } from 'typescript';\nimport { TypeOperatorSchema } from '@teambit/semantics.entities.semantic-schema';\nimport { SchemaTransformer } from '../schema-transformer';\nimport { SchemaExtractorContext } from '../schema-extractor-context';\nimport { Identifier } from '../identifier';\n\n/**\n * e.g. keyof typeof Foo\n */\nexport class TypeOperatorTransformer implements SchemaTransformer {\n  predicate(node: Node) {\n    return node.kind === SyntaxKind.TypeOperator;\n  }\n\n  async getIdentifiers(): Promise<Identifier[]> {\n    return [];\n  }\n\n  async transform(node: TypeOperatorNode, context: SchemaExtractorContext) {\n    const operatorName = this.getOperatorName(node.operator);\n    const type = await context.computeSchema(node.type);\n    return new TypeOperatorSchema(context.getLocation(node), operatorName, type);\n  }\n\n  getOperatorName(operator: SyntaxKind.KeyOfKeyword | SyntaxKind.UniqueKeyword | SyntaxKind.ReadonlyKeyword) {\n    switch (operator) {\n      case SyntaxKind.KeyOfKeyword:\n        return 'keyof';\n      case SyntaxKind.UniqueKeyword:\n        return 'unique';\n      case SyntaxKind.ReadonlyKeyword:\n        return 'readonly';\n      default:\n        throw new Error(`getOperatorName: unable to find operator name for ${operator}`);\n    }\n  }\n}\n"],"mappings":";;;;;;;AAAA;EAAA;EAAA;IAAA;EAAA;EAAA;AAAA;AACA;EAAA;EAAA;IAAA;EAAA;EAAA;AAAA;AAKA;AACA;AACA;AACO,MAAMA,uBAAuB,CAA8B;EAChEC,SAAS,CAACC,IAAU,EAAE;IACpB,OAAOA,IAAI,CAACC,IAAI,KAAKC,wBAAU,CAACC,YAAY;EAC9C;EAEA,MAAMC,cAAc,GAA0B;IAC5C,OAAO,EAAE;EACX;EAEA,MAAMC,SAAS,CAACL,IAAsB,EAAEM,OAA+B,EAAE;IACvE,MAAMC,YAAY,GAAG,IAAI,CAACC,eAAe,CAACR,IAAI,CAACS,QAAQ,CAAC;IACxD,MAAMC,IAAI,GAAG,MAAMJ,OAAO,CAACK,aAAa,CAACX,IAAI,CAACU,IAAI,CAAC;IACnD,OAAO,KAAIE,uCAAkB,EAACN,OAAO,CAACO,WAAW,CAACb,IAAI,CAAC,EAAEO,YAAY,EAAEG,IAAI,CAAC;EAC9E;EAEAF,eAAe,CAACC,QAAyF,EAAE;IACzG,QAAQA,QAAQ;MACd,KAAKP,wBAAU,CAACY,YAAY;QAC1B,OAAO,OAAO;MAChB,KAAKZ,wBAAU,CAACa,aAAa;QAC3B,OAAO,QAAQ;MACjB,KAAKb,wBAAU,CAACc,eAAe;QAC7B,OAAO,UAAU;MACnB;QACE,MAAM,IAAIC,KAAK,CAAE,qDAAoDR,QAAS,EAAC,CAAC;IAAC;EAEvF;AACF;AAAC"}

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

@@ -0,0 +1,10 @@
+import { Node, TypePredicateNode } from 'typescript';
+import { TypePredicateSchema } from '@teambit/semantics.entities.semantic-schema';
+import { SchemaTransformer } from '../schema-transformer';
+import { SchemaExtractorContext } from '../schema-extractor-context';
+import { Identifier } from '../identifier';
+export declare class TypePredicateTransformer implements SchemaTransformer {
+    predicate(node: Node): boolean;
+    getIdentifiers(): Promise<Identifier[]>;
+    transform(node: TypePredicateNode, context: SchemaExtractorContext): Promise<TypePredicateSchema>;
+}

package/dist/transformers/type-predicate.js

@@ -0,0 +1,38 @@
+"use strict";
+
+require("core-js/modules/es.promise.js");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TypePredicateTransformer = void 0;
+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;
+}
+class TypePredicateTransformer {
+  predicate(node) {
+    return node.kind === _typescript().SyntaxKind.TypePredicate;
+  }
+  async getIdentifiers() {
+    return [];
+  }
+  async transform(node, context) {
+    const parameterName = (0, _typescript().isIdentifier)(node.parameterName) ? node.parameterName.getText() : 'this';
+    const type = node.type ? await context.computeSchema(node.type) : undefined;
+    const hasAssertsModifier = Boolean(node.assertsModifier);
+    return new (_semanticsEntities().TypePredicateSchema)(context.getLocation(node), parameterName, type, hasAssertsModifier);
+  }
+}
+exports.TypePredicateTransformer = TypePredicateTransformer;
+
+//# sourceMappingURL=type-predicate.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["TypePredicateTransformer","predicate","node","kind","SyntaxKind","TypePredicate","getIdentifiers","transform","context","parameterName","isIdentifier","getText","type","computeSchema","undefined","hasAssertsModifier","Boolean","assertsModifier","TypePredicateSchema","getLocation"],"sources":["type-predicate.ts"],"sourcesContent":["import { isIdentifier, Node, SyntaxKind, TypePredicateNode } from 'typescript';\nimport { TypePredicateSchema } from '@teambit/semantics.entities.semantic-schema';\nimport { SchemaTransformer } from '../schema-transformer';\nimport { SchemaExtractorContext } from '../schema-extractor-context';\nimport { Identifier } from '../identifier';\n\nexport class TypePredicateTransformer implements SchemaTransformer {\n  predicate(node: Node) {\n    return node.kind === SyntaxKind.TypePredicate;\n  }\n\n  async getIdentifiers(): Promise<Identifier[]> {\n    return [];\n  }\n\n  async transform(node: TypePredicateNode, context: SchemaExtractorContext) {\n    const parameterName = isIdentifier(node.parameterName) ? node.parameterName.getText() : 'this';\n    const type = node.type ? await context.computeSchema(node.type) : undefined;\n    const hasAssertsModifier = Boolean(node.assertsModifier);\n    return new TypePredicateSchema(context.getLocation(node), parameterName, type, hasAssertsModifier);\n  }\n}\n"],"mappings":";;;;;;;AAAA;EAAA;EAAA;IAAA;EAAA;EAAA;AAAA;AACA;EAAA;EAAA;IAAA;EAAA;EAAA;AAAA;AAKO,MAAMA,wBAAwB,CAA8B;EACjEC,SAAS,CAACC,IAAU,EAAE;IACpB,OAAOA,IAAI,CAACC,IAAI,KAAKC,wBAAU,CAACC,aAAa;EAC/C;EAEA,MAAMC,cAAc,GAA0B;IAC5C,OAAO,EAAE;EACX;EAEA,MAAMC,SAAS,CAACL,IAAuB,EAAEM,OAA+B,EAAE;IACxE,MAAMC,aAAa,GAAG,IAAAC,0BAAY,EAACR,IAAI,CAACO,aAAa,CAAC,GAAGP,IAAI,CAACO,aAAa,CAACE,OAAO,EAAE,GAAG,MAAM;IAC9F,MAAMC,IAAI,GAAGV,IAAI,CAACU,IAAI,GAAG,MAAMJ,OAAO,CAACK,aAAa,CAACX,IAAI,CAACU,IAAI,CAAC,GAAGE,SAAS;IAC3E,MAAMC,kBAAkB,GAAGC,OAAO,CAACd,IAAI,CAACe,eAAe,CAAC;IACxD,OAAO,KAAIC,wCAAmB,EAACV,OAAO,CAACW,WAAW,CAACjB,IAAI,CAAC,EAAEO,aAAa,EAAEG,IAAI,EAAEG,kBAAkB,CAAC;EACpG;AACF;AAAC"}

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

@@ -0,0 +1,13 @@
+import { Node, TypeQueryNode } from 'typescript';
+import { TypeQuerySchema } from '@teambit/semantics.entities.semantic-schema';
+import { SchemaTransformer } from '../schema-transformer';
+import { SchemaExtractorContext } from '../schema-extractor-context';
+import { Identifier } from '../identifier';
+/**
+ * e.g. `typeof Foo`
+ */
+export declare class TypeQueryTransformer implements SchemaTransformer {
+    predicate(node: Node): boolean;
+    getIdentifiers(): Promise<Identifier[]>;
+    transform(node: TypeQueryNode, context: SchemaExtractorContext): Promise<TypeQuerySchema>;
+}

package/dist/transformers/type-query.js

@@ -0,0 +1,42 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+require("core-js/modules/es.promise.js");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TypeQueryTransformer = void 0;
+function _typescript() {
+  const data = _interopRequireDefault(require("typescript"));
+  _typescript = function () {
+    return data;
+  };
+  return data;
+}
+function _semanticsEntities() {
+  const data = require("@teambit/semantics.entities.semantic-schema");
+  _semanticsEntities = function () {
+    return data;
+  };
+  return data;
+}
+/**
+ * e.g. `typeof Foo`
+ */
+class TypeQueryTransformer {
+  predicate(node) {
+    return node.kind === _typescript().default.SyntaxKind.TypeQuery;
+  }
+  async getIdentifiers() {
+    return [];
+  }
+  async transform(node, context) {
+    const displaySig = await context.getQuickInfoDisplayString(node.exprName);
+    const type = await context.resolveType(node.exprName, node.exprName.getText(), false);
+    const location = context.getLocation(node);
+    return new (_semanticsEntities().TypeQuerySchema)(location, type, displaySig);
+  }
+}
+exports.TypeQueryTransformer = TypeQueryTransformer;
+
+//# sourceMappingURL=type-query.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["TypeQueryTransformer","predicate","node","kind","ts","SyntaxKind","TypeQuery","getIdentifiers","transform","context","displaySig","getQuickInfoDisplayString","exprName","type","resolveType","getText","location","getLocation","TypeQuerySchema"],"sources":["type-query.ts"],"sourcesContent":["import ts, { Node, TypeQueryNode } from 'typescript';\nimport { TypeQuerySchema } from '@teambit/semantics.entities.semantic-schema';\nimport { SchemaTransformer } from '../schema-transformer';\nimport { SchemaExtractorContext } from '../schema-extractor-context';\nimport { Identifier } from '../identifier';\n\n/**\n * e.g. `typeof Foo`\n */\nexport class TypeQueryTransformer implements SchemaTransformer {\n  predicate(node: Node) {\n    return node.kind === ts.SyntaxKind.TypeQuery;\n  }\n\n  async getIdentifiers(): Promise<Identifier[]> {\n    return [];\n  }\n\n  async transform(node: TypeQueryNode, context: SchemaExtractorContext) {\n    const displaySig = await context.getQuickInfoDisplayString(node.exprName);\n    const type = await context.resolveType(node.exprName, node.exprName.getText(), false);\n    const location = context.getLocation(node);\n    return new TypeQuerySchema(location, type, displaySig);\n  }\n}\n"],"mappings":";;;;;;;;AAAA;EAAA;EAAA;IAAA;EAAA;EAAA;AAAA;AACA;EAAA;EAAA;IAAA;EAAA;EAAA;AAAA;AAKA;AACA;AACA;AACO,MAAMA,oBAAoB,CAA8B;EAC7DC,SAAS,CAACC,IAAU,EAAE;IACpB,OAAOA,IAAI,CAACC,IAAI,KAAKC,qBAAE,CAACC,UAAU,CAACC,SAAS;EAC9C;EAEA,MAAMC,cAAc,GAA0B;IAC5C,OAAO,EAAE;EACX;EAEA,MAAMC,SAAS,CAACN,IAAmB,EAAEO,OAA+B,EAAE;IACpE,MAAMC,UAAU,GAAG,MAAMD,OAAO,CAACE,yBAAyB,CAACT,IAAI,CAACU,QAAQ,CAAC;IACzE,MAAMC,IAAI,GAAG,MAAMJ,OAAO,CAACK,WAAW,CAACZ,IAAI,CAACU,QAAQ,EAAEV,IAAI,CAACU,QAAQ,CAACG,OAAO,EAAE,EAAE,KAAK,CAAC;IACrF,MAAMC,QAAQ,GAAGP,OAAO,CAACQ,WAAW,CAACf,IAAI,CAAC;IAC1C,OAAO,KAAIgB,oCAAe,EAACF,QAAQ,EAAEH,IAAI,EAAEH,UAAU,CAAC;EACxD;AACF;AAAC"}

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

@@ -0,0 +1,16 @@
+import { Node, TypeReferenceNode } from 'typescript';
+import { SchemaTransformer } from '../schema-transformer';
+import { SchemaExtractorContext } from '../schema-extractor-context';
+import { Identifier } from '../identifier';
+/**
+ * In the following example, `AriaButtonProps` is a type reference
+ * ```ts
+ * import type { AriaButtonProps } from '@react-types/button';
+ * export type ButtonProps = AriaButtonProps & { a: string };
+ * ```
+ */
+export declare class TypeReferenceTransformer implements SchemaTransformer {
+    predicate(node: Node): boolean;
+    getIdentifiers(): Promise<Identifier[]>;
+    transform(node: TypeReferenceNode, context: SchemaExtractorContext): Promise<import("@teambit/semantics.entities.semantic-schema").SchemaNode>;
+}