@teambit/typescript 0.0.0-004aea01bc027e428dfd0f6583f49a1b8286bdd0

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

@@ -0,0 +1,44 @@
+"use strict";
+
+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;
+}
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+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":["_typescript","data","require","_pMapSeries","_interopRequireDefault","_semanticsEntities","e","__esModule","default","TemplateLiteralTypeTransformer","predicate","node","kind","SyntaxKind","TemplateLiteralType","getIdentifiers","transform","context","templateSpans","pMapSeries","span","computeSchema","head","text","TemplateLiteralTypeSchema","getLocation","exports"],"sources":["template-literal-type.ts"],"sourcesContent":["import type { Node, TemplateLiteralTypeNode } from 'typescript';\nimport { SyntaxKind } from 'typescript';\nimport pMapSeries from 'p-map-series';\nimport type { TemplateLiteralTypeSpanSchema } from '@teambit/semantics.entities.semantic-schema';\nimport { TemplateLiteralTypeSchema } from '@teambit/semantics.entities.semantic-schema';\nimport type { SchemaTransformer } from '../schema-transformer';\nimport type { SchemaExtractorContext } from '../schema-extractor-context';\nimport type { 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":";;;;;;AACA,SAAAA,YAAA;EAAA,MAAAC,IAAA,GAAAC,OAAA;EAAAF,WAAA,YAAAA,CAAA;IAAA,OAAAC,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AACA,SAAAE,YAAA;EAAA,MAAAF,IAAA,GAAAG,sBAAA,CAAAF,OAAA;EAAAC,WAAA,YAAAA,CAAA;IAAA,OAAAF,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AAEA,SAAAI,mBAAA;EAAA,MAAAJ,IAAA,GAAAC,OAAA;EAAAG,kBAAA,YAAAA,CAAA;IAAA,OAAAJ,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AAAwF,SAAAG,uBAAAE,CAAA,WAAAA,CAAA,IAAAA,CAAA,CAAAC,UAAA,GAAAD,CAAA,KAAAE,OAAA,EAAAF,CAAA;AAKjF,MAAMG,8BAA8B,CAA8B;EACvEC,SAASA,CAACC,IAAU,EAAE;IACpB,OAAOA,IAAI,CAACC,IAAI,KAAKC,wBAAU,CAACC,mBAAmB;EACrD;EAEA,MAAMC,cAAcA,CAAA,EAA0B;IAC5C,OAAO,EAAE;EACX;EAEA,MAAMC,SAASA,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,CAC5B,CAAqC;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;AAACQ,OAAA,CAAAjB,8BAAA,GAAAA,8BAAA","ignoreList":[]}

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

@@ -0,0 +1,10 @@
+import type { Node, ThisTypeNode } from 'typescript';
+import { ThisTypeSchema } from '@teambit/semantics.entities.semantic-schema';
+import type { SchemaTransformer } from '../schema-transformer';
+import type { SchemaExtractorContext } from '../schema-extractor-context';
+import type { 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,34 @@
+"use strict";
+
+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), 'this');
+  }
+}
+exports.ThisTypeTransformer = ThisTypeTransformer;
+
+//# sourceMappingURL=this-type.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["_typescript","data","require","_semanticsEntities","ThisTypeTransformer","predicate","node","kind","SyntaxKind","ThisType","getIdentifiers","transform","context","ThisTypeSchema","getLocation","exports"],"sources":["this-type.ts"],"sourcesContent":["import type { Node, ThisTypeNode } from 'typescript';\nimport { SyntaxKind } from 'typescript';\nimport { ThisTypeSchema } from '@teambit/semantics.entities.semantic-schema';\nimport type { SchemaTransformer } from '../schema-transformer';\nimport type { SchemaExtractorContext } from '../schema-extractor-context';\nimport type { 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), 'this');\n  }\n}\n"],"mappings":";;;;;;AACA,SAAAA,YAAA;EAAA,MAAAC,IAAA,GAAAC,OAAA;EAAAF,WAAA,YAAAA,CAAA;IAAA,OAAAC,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AACA,SAAAE,mBAAA;EAAA,MAAAF,IAAA,GAAAC,OAAA;EAAAC,kBAAA,YAAAA,CAAA;IAAA,OAAAF,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AAKO,MAAMG,mBAAmB,CAA8B;EAC5DC,SAASA,CAACC,IAAU,EAAE;IACpB,OAAOA,IAAI,CAACC,IAAI,KAAKC,wBAAU,CAACC,QAAQ;EAC1C;EAEA,MAAMC,cAAcA,CAAA,EAA0B;IAC5C,OAAO,EAAE;EACX;EAEA,MAAMC,SAASA,CAACL,IAAkB,EAAEM,OAA+B,EAAE;IACnE,OAAO,KAAIC,mCAAc,EAACD,OAAO,CAACE,WAAW,CAACR,IAAI,CAAC,EAAE,MAAM,CAAC;EAC9D;AACF;AAACS,OAAA,CAAAX,mBAAA,GAAAA,mBAAA","ignoreList":[]}

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

@@ -0,0 +1,10 @@
+import type { Node, TupleTypeNode } from 'typescript';
+import { TupleTypeSchema } from '@teambit/semantics.entities.semantic-schema';
+import type { SchemaTransformer } from '../schema-transformer';
+import type { SchemaExtractorContext } from '../schema-extractor-context';
+import type { 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,46 @@
+"use strict";
+
+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;
+}
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+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":["_typescript","data","require","_pMapSeries","_interopRequireDefault","_semanticsEntities","e","__esModule","default","TupleTypeTransformer","predicate","node","kind","SyntaxKind","TupleType","getIdentifiers","transform","context","elements","pMapSeries","elem","typeSchema","computeSchema","TupleTypeSchema","getLocation","exports"],"sources":["tuple-type.ts"],"sourcesContent":["import type { Node, TupleTypeNode } from 'typescript';\nimport { SyntaxKind } from 'typescript';\nimport pMapSeries from 'p-map-series';\nimport { TupleTypeSchema } from '@teambit/semantics.entities.semantic-schema';\nimport type { SchemaTransformer } from '../schema-transformer';\nimport type { SchemaExtractorContext } from '../schema-extractor-context';\nimport type { 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":";;;;;;AACA,SAAAA,YAAA;EAAA,MAAAC,IAAA,GAAAC,OAAA;EAAAF,WAAA,YAAAA,CAAA;IAAA,OAAAC,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AACA,SAAAE,YAAA;EAAA,MAAAF,IAAA,GAAAG,sBAAA,CAAAF,OAAA;EAAAC,WAAA,YAAAA,CAAA;IAAA,OAAAF,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AACA,SAAAI,mBAAA;EAAA,MAAAJ,IAAA,GAAAC,OAAA;EAAAG,kBAAA,YAAAA,CAAA;IAAA,OAAAJ,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AAA8E,SAAAG,uBAAAE,CAAA,WAAAA,CAAA,IAAAA,CAAA,CAAAC,UAAA,GAAAD,CAAA,KAAAE,OAAA,EAAAF,CAAA;AAKvE,MAAMG,oBAAoB,CAA8B;EAC7DC,SAASA,CAACC,IAAU,EAAE;IACpB,OAAOA,IAAI,CAACC,IAAI,KAAKC,wBAAU,CAACC,SAAS;EAC3C;EAEA,MAAMC,cAAcA,CAAA,EAA0B;IAC5C,OAAO,EAAE;EACX;EAEA,MAAMC,SAASA,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;AAACO,OAAA,CAAAhB,oBAAA,GAAAA,oBAAA","ignoreList":[]}

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

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

package/dist/transformers/type-alias.js

@@ -0,0 +1,48 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TypeAliasTransformer = 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 _identifier() {
+  const data = require("../identifier");
+  _identifier = function () {
+    return data;
+  };
+  return data;
+}
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+class TypeAliasTransformer {
+  predicate(node) {
+    return node.kind === _typescript().default.SyntaxKind.TypeAliasDeclaration;
+  }
+  async getIdentifiers(node) {
+    return [new (_identifier().Identifier)(node.name.getText(), node.getSourceFile().fileName)];
+  }
+  getName(node) {
+    return node.name.getText();
+  }
+  async transform(typeAlias, 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);
+  }
+}
+exports.TypeAliasTransformer = TypeAliasTransformer;
+
+//# sourceMappingURL=type-alias.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["_typescript","data","_interopRequireDefault","require","_semanticsEntities","_identifier","e","__esModule","default","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","exports"],"sources":["type-alias.ts"],"sourcesContent":["import type { Node, TypeAliasDeclaration } from 'typescript';\nimport ts from 'typescript';\nimport { TypeSchema } from '@teambit/semantics.entities.semantic-schema';\nimport type { SchemaTransformer } from '../schema-transformer';\nimport type { 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":";;;;;;AACA,SAAAA,YAAA;EAAA,MAAAC,IAAA,GAAAC,sBAAA,CAAAC,OAAA;EAAAH,WAAA,YAAAA,CAAA;IAAA,OAAAC,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AACA,SAAAG,mBAAA;EAAA,MAAAH,IAAA,GAAAE,OAAA;EAAAC,kBAAA,YAAAA,CAAA;IAAA,OAAAH,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AAGA,SAAAI,YAAA;EAAA,MAAAJ,IAAA,GAAAE,OAAA;EAAAE,WAAA,YAAAA,CAAA;IAAA,OAAAJ,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AAA2C,SAAAC,uBAAAI,CAAA,WAAAA,CAAA,IAAAA,CAAA,CAAAC,UAAA,GAAAD,CAAA,KAAAE,OAAA,EAAAF,CAAA;AAEpC,MAAMG,oBAAoB,CAA8B;EAC7DC,SAASA,CAACC,IAAU,EAAE;IACpB,OAAOA,IAAI,CAACC,IAAI,KAAKC,qBAAE,CAACC,UAAU,CAACC,oBAAoB;EACzD;EAEA,MAAMC,cAAcA,CAACL,IAA0B,EAAE;IAC/C,OAAO,CAAC,KAAIM,wBAAU,EAACN,IAAI,CAACO,IAAI,CAACC,OAAO,CAAC,CAAC,EAAER,IAAI,CAACS,aAAa,CAAC,CAAC,CAACC,QAAQ,CAAC,CAAC;EAC7E;EAEQC,OAAOA,CAACX,IAA0B,EAAU;IAClD,OAAOA,IAAI,CAACO,IAAI,CAACC,OAAO,CAAC,CAAC;EAC5B;EAEA,MAAMI,SAASA,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;AAACI,OAAA,CAAAzB,oBAAA,GAAAA,oBAAA","ignoreList":[]}

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

@@ -0,0 +1,14 @@
+import type { Node, TypeLiteralNode } from 'typescript';
+import { TypeLiteralSchema } from '@teambit/semantics.entities.semantic-schema';
+import type { SchemaTransformer } from '../schema-transformer';
+import type { SchemaExtractorContext } from '../schema-extractor-context';
+import type { 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,48 @@
+"use strict";
+
+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;
+}
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/**
+ * 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":["_typescript","data","_interopRequireDefault","require","_semanticsEntities","_pMapSeries","e","__esModule","default","TypeLiteralTransformer","predicate","node","kind","ts","SyntaxKind","TypeLiteral","getIdentifiers","transform","context","members","pMapSeries","member","computeSchema","location","getLocation","TypeLiteralSchema","exports"],"sources":["type-literal.ts"],"sourcesContent":["import type { Node, TypeLiteralNode } from 'typescript';\nimport ts from 'typescript';\nimport { TypeLiteralSchema } from '@teambit/semantics.entities.semantic-schema';\nimport pMapSeries from 'p-map-series';\nimport type { SchemaTransformer } from '../schema-transformer';\nimport type { SchemaExtractorContext } from '../schema-extractor-context';\nimport type { 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":";;;;;;AACA,SAAAA,YAAA;EAAA,MAAAC,IAAA,GAAAC,sBAAA,CAAAC,OAAA;EAAAH,WAAA,YAAAA,CAAA;IAAA,OAAAC,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AACA,SAAAG,mBAAA;EAAA,MAAAH,IAAA,GAAAE,OAAA;EAAAC,kBAAA,YAAAA,CAAA;IAAA,OAAAH,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AACA,SAAAI,YAAA;EAAA,MAAAJ,IAAA,GAAAC,sBAAA,CAAAC,OAAA;EAAAE,WAAA,YAAAA,CAAA;IAAA,OAAAJ,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AAAsC,SAAAC,uBAAAI,CAAA,WAAAA,CAAA,IAAAA,CAAA,CAAAC,UAAA,GAAAD,CAAA,KAAAE,OAAA,EAAAF,CAAA;AAKtC;AACA;AACA;AACA;AACO,MAAMG,sBAAsB,CAA8B;EAC/DC,SAASA,CAACC,IAAU,EAAE;IACpB,OAAOA,IAAI,CAACC,IAAI,KAAKC,qBAAE,CAACC,UAAU,CAACC,WAAW;EAChD;EAEA,MAAMC,cAAcA,CAAA,EAA0B;IAC5C,OAAO,EAAE;EACX;EAEA,MAAMC,SAASA,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;AAACO,OAAA,CAAAjB,sBAAA,GAAAA,sBAAA","ignoreList":[]}

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

@@ -0,0 +1,15 @@
+import type { Node, TypeOperatorNode } from 'typescript';
+import { SyntaxKind } from 'typescript';
+import { TypeOperatorSchema } from '@teambit/semantics.entities.semantic-schema';
+import type { SchemaTransformer } from '../schema-transformer';
+import type { SchemaExtractorContext } from '../schema-extractor-context';
+import type { 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,51 @@
+"use strict";
+
+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":["_typescript","data","require","_semanticsEntities","TypeOperatorTransformer","predicate","node","kind","SyntaxKind","TypeOperator","getIdentifiers","transform","context","operatorName","getOperatorName","operator","type","computeSchema","TypeOperatorSchema","getLocation","KeyOfKeyword","UniqueKeyword","ReadonlyKeyword","Error","exports"],"sources":["type-operator.ts"],"sourcesContent":["import type { Node, TypeOperatorNode } from 'typescript';\nimport { SyntaxKind } from 'typescript';\nimport { TypeOperatorSchema } from '@teambit/semantics.entities.semantic-schema';\nimport type { SchemaTransformer } from '../schema-transformer';\nimport type { SchemaExtractorContext } from '../schema-extractor-context';\nimport type { 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":";;;;;;AACA,SAAAA,YAAA;EAAA,MAAAC,IAAA,GAAAC,OAAA;EAAAF,WAAA,YAAAA,CAAA;IAAA,OAAAC,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AACA,SAAAE,mBAAA;EAAA,MAAAF,IAAA,GAAAC,OAAA;EAAAC,kBAAA,YAAAA,CAAA;IAAA,OAAAF,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AAKA;AACA;AACA;AACO,MAAMG,uBAAuB,CAA8B;EAChEC,SAASA,CAACC,IAAU,EAAE;IACpB,OAAOA,IAAI,CAACC,IAAI,KAAKC,wBAAU,CAACC,YAAY;EAC9C;EAEA,MAAMC,cAAcA,CAAA,EAA0B;IAC5C,OAAO,EAAE;EACX;EAEA,MAAMC,SAASA,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,eAAeA,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,CAAC,qDAAqDR,QAAQ,EAAE,CAAC;IACpF;EACF;AACF;AAACS,OAAA,CAAApB,uBAAA,GAAAA,uBAAA","ignoreList":[]}

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

@@ -0,0 +1,10 @@
+import type { Node, TypePredicateNode } from 'typescript';
+import { TypePredicateSchema } from '@teambit/semantics.entities.semantic-schema';
+import type { SchemaTransformer } from '../schema-transformer';
+import type { SchemaExtractorContext } from '../schema-extractor-context';
+import type { 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,37 @@
+"use strict";
+
+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":["_typescript","data","require","_semanticsEntities","TypePredicateTransformer","predicate","node","kind","SyntaxKind","TypePredicate","getIdentifiers","transform","context","parameterName","isIdentifier","getText","type","computeSchema","undefined","hasAssertsModifier","Boolean","assertsModifier","TypePredicateSchema","getLocation","exports"],"sources":["type-predicate.ts"],"sourcesContent":["import type { Node, TypePredicateNode } from 'typescript';\nimport { isIdentifier, SyntaxKind } from 'typescript';\nimport { TypePredicateSchema } from '@teambit/semantics.entities.semantic-schema';\nimport type { SchemaTransformer } from '../schema-transformer';\nimport type { SchemaExtractorContext } from '../schema-extractor-context';\nimport type { 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":";;;;;;AACA,SAAAA,YAAA;EAAA,MAAAC,IAAA,GAAAC,OAAA;EAAAF,WAAA,YAAAA,CAAA;IAAA,OAAAC,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AACA,SAAAE,mBAAA;EAAA,MAAAF,IAAA,GAAAC,OAAA;EAAAC,kBAAA,YAAAA,CAAA;IAAA,OAAAF,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AAKO,MAAMG,wBAAwB,CAA8B;EACjEC,SAASA,CAACC,IAAU,EAAE;IACpB,OAAOA,IAAI,CAACC,IAAI,KAAKC,wBAAU,CAACC,aAAa;EAC/C;EAEA,MAAMC,cAAcA,CAAA,EAA0B;IAC5C,OAAO,EAAE;EACX;EAEA,MAAMC,SAASA,CAACL,IAAuB,EAAEM,OAA+B,EAAE;IACxE,MAAMC,aAAa,GAAG,IAAAC,0BAAY,EAACR,IAAI,CAACO,aAAa,CAAC,GAAGP,IAAI,CAACO,aAAa,CAACE,OAAO,CAAC,CAAC,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;AAACK,OAAA,CAAApB,wBAAA,GAAAA,wBAAA","ignoreList":[]}

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

@@ -0,0 +1,13 @@
+import type { Node, TypeQueryNode } from 'typescript';
+import { TypeQuerySchema } from '@teambit/semantics.entities.semantic-schema';
+import type { SchemaTransformer } from '../schema-transformer';
+import type { SchemaExtractorContext } from '../schema-extractor-context';
+import type { 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,41 @@
+"use strict";
+
+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;
+}
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/**
+ * 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());
+    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":["_typescript","data","_interopRequireDefault","require","_semanticsEntities","e","__esModule","default","TypeQueryTransformer","predicate","node","kind","ts","SyntaxKind","TypeQuery","getIdentifiers","transform","context","displaySig","getQuickInfoDisplayString","exprName","type","resolveType","getText","location","getLocation","TypeQuerySchema","exports"],"sources":["type-query.ts"],"sourcesContent":["import type { Node, TypeQueryNode } from 'typescript';\nimport ts from 'typescript';\nimport { TypeQuerySchema } from '@teambit/semantics.entities.semantic-schema';\nimport type { SchemaTransformer } from '../schema-transformer';\nimport type { SchemaExtractorContext } from '../schema-extractor-context';\nimport type { 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());\n    const location = context.getLocation(node);\n    return new TypeQuerySchema(location, type, displaySig);\n  }\n}\n"],"mappings":";;;;;;AACA,SAAAA,YAAA;EAAA,MAAAC,IAAA,GAAAC,sBAAA,CAAAC,OAAA;EAAAH,WAAA,YAAAA,CAAA;IAAA,OAAAC,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AACA,SAAAG,mBAAA;EAAA,MAAAH,IAAA,GAAAE,OAAA;EAAAC,kBAAA,YAAAA,CAAA;IAAA,OAAAH,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AAA8E,SAAAC,uBAAAG,CAAA,WAAAA,CAAA,IAAAA,CAAA,CAAAC,UAAA,GAAAD,CAAA,KAAAE,OAAA,EAAAF,CAAA;AAK9E;AACA;AACA;AACO,MAAMG,oBAAoB,CAA8B;EAC7DC,SAASA,CAACC,IAAU,EAAE;IACpB,OAAOA,IAAI,CAACC,IAAI,KAAKC,qBAAE,CAACC,UAAU,CAACC,SAAS;EAC9C;EAEA,MAAMC,cAAcA,CAAA,EAA0B;IAC5C,OAAO,EAAE;EACX;EAEA,MAAMC,SAASA,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,CAAC,CAAC,CAAC;IAC9E,MAAMC,QAAQ,GAAGP,OAAO,CAACQ,WAAW,CAACf,IAAI,CAAC;IAC1C,OAAO,KAAIgB,oCAAe,EAACF,QAAQ,EAAEH,IAAI,EAAEH,UAAU,CAAC;EACxD;AACF;AAACS,OAAA,CAAAnB,oBAAA,GAAAA,oBAAA","ignoreList":[]}

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

@@ -0,0 +1,17 @@
+import type { Node, TypeReferenceNode } from 'typescript';
+import { TypeRefSchema } from '@teambit/semantics.entities.semantic-schema';
+import type { SchemaTransformer } from '../schema-transformer';
+import type { SchemaExtractorContext } from '../schema-extractor-context';
+import type { 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 | TypeRefSchema>;
+}

package/dist/transformers/type-reference.js

@@ -0,0 +1,58 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TypeReferenceTransformer = 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;
+}
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/**
+ * In the following example, `AriaButtonProps` is a type reference
+ * ```ts
+ * import type { AriaButtonProps } from '@react-types/button';
+ * export type ButtonProps = AriaButtonProps & { a: string };
+ * ```
+ */
+class TypeReferenceTransformer {
+  predicate(node) {
+    return node.kind === _typescript().default.SyntaxKind.TypeReference;
+  }
+  async getIdentifiers() {
+    return [];
+  }
+  async transform(node, context) {
+    const name = node.typeName.getText();
+    let type = await context.resolveType(node, name);
+    if (!(type instanceof _semanticsEntities().TypeRefSchema)) {
+      type = new (_semanticsEntities().TypeRefSchema)(context.getLocation(node), name);
+    }
+    if (node.typeArguments && type instanceof _semanticsEntities().TypeRefSchema) {
+      const args = await (0, _pMapSeries().default)(node.typeArguments, arg => context.computeSchema(arg));
+      type.withTypeArgs(args);
+    }
+    return type;
+  }
+}
+exports.TypeReferenceTransformer = TypeReferenceTransformer;
+
+//# sourceMappingURL=type-reference.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["_typescript","data","_interopRequireDefault","require","_semanticsEntities","_pMapSeries","e","__esModule","default","TypeReferenceTransformer","predicate","node","kind","ts","SyntaxKind","TypeReference","getIdentifiers","transform","context","name","typeName","getText","type","resolveType","TypeRefSchema","getLocation","typeArguments","args","pMapSeries","arg","computeSchema","withTypeArgs","exports"],"sources":["type-reference.ts"],"sourcesContent":["import type { Node, TypeReferenceNode } from 'typescript';\nimport ts from 'typescript';\nimport { TypeRefSchema } from '@teambit/semantics.entities.semantic-schema';\nimport pMapSeries from 'p-map-series';\nimport type { SchemaTransformer } from '../schema-transformer';\nimport type { SchemaExtractorContext } from '../schema-extractor-context';\nimport type { Identifier } from '../identifier';\n\n/**\n * In the following example, `AriaButtonProps` is a type reference\n * ```ts\n * import type { AriaButtonProps } from '@react-types/button';\n * export type ButtonProps = AriaButtonProps & { a: string };\n * ```\n */\nexport class TypeReferenceTransformer implements SchemaTransformer {\n  predicate(node: Node) {\n    return node.kind === ts.SyntaxKind.TypeReference;\n  }\n\n  async getIdentifiers(): Promise<Identifier[]> {\n    return [];\n  }\n\n  async transform(node: TypeReferenceNode, context: SchemaExtractorContext) {\n    const name = node.typeName.getText();\n    let type = await context.resolveType(node, name);\n    if (!(type instanceof TypeRefSchema)) {\n      type = new TypeRefSchema(context.getLocation(node), name);\n    }\n    if (node.typeArguments && type instanceof TypeRefSchema) {\n      const args = await pMapSeries(node.typeArguments, (arg) => context.computeSchema(arg));\n      type.withTypeArgs(args);\n    }\n    return type;\n  }\n}\n"],"mappings":";;;;;;AACA,SAAAA,YAAA;EAAA,MAAAC,IAAA,GAAAC,sBAAA,CAAAC,OAAA;EAAAH,WAAA,YAAAA,CAAA;IAAA,OAAAC,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AACA,SAAAG,mBAAA;EAAA,MAAAH,IAAA,GAAAE,OAAA;EAAAC,kBAAA,YAAAA,CAAA;IAAA,OAAAH,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AACA,SAAAI,YAAA;EAAA,MAAAJ,IAAA,GAAAC,sBAAA,CAAAC,OAAA;EAAAE,WAAA,YAAAA,CAAA;IAAA,OAAAJ,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AAAsC,SAAAC,uBAAAI,CAAA,WAAAA,CAAA,IAAAA,CAAA,CAAAC,UAAA,GAAAD,CAAA,KAAAE,OAAA,EAAAF,CAAA;AAKtC;AACA;AACA;AACA;AACA;AACA;AACA;AACO,MAAMG,wBAAwB,CAA8B;EACjEC,SAASA,CAACC,IAAU,EAAE;IACpB,OAAOA,IAAI,CAACC,IAAI,KAAKC,qBAAE,CAACC,UAAU,CAACC,aAAa;EAClD;EAEA,MAAMC,cAAcA,CAAA,EAA0B;IAC5C,OAAO,EAAE;EACX;EAEA,MAAMC,SAASA,CAACN,IAAuB,EAAEO,OAA+B,EAAE;IACxE,MAAMC,IAAI,GAAGR,IAAI,CAACS,QAAQ,CAACC,OAAO,CAAC,CAAC;IACpC,IAAIC,IAAI,GAAG,MAAMJ,OAAO,CAACK,WAAW,CAACZ,IAAI,EAAEQ,IAAI,CAAC;IAChD,IAAI,EAAEG,IAAI,YAAYE,kCAAa,CAAC,EAAE;MACpCF,IAAI,GAAG,KAAIE,kCAAa,EAACN,OAAO,CAACO,WAAW,CAACd,IAAI,CAAC,EAAEQ,IAAI,CAAC;IAC3D;IACA,IAAIR,IAAI,CAACe,aAAa,IAAIJ,IAAI,YAAYE,kCAAa,EAAE;MACvD,MAAMG,IAAI,GAAG,MAAM,IAAAC,qBAAU,EAACjB,IAAI,CAACe,aAAa,EAAGG,GAAG,IAAKX,OAAO,CAACY,aAAa,CAACD,GAAG,CAAC,CAAC;MACtFP,IAAI,CAACS,YAAY,CAACJ,IAAI,CAAC;IACzB;IACA,OAAOL,IAAI;EACb;AACF;AAACU,OAAA,CAAAvB,wBAAA,GAAAA,wBAAA","ignoreList":[]}

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

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