@teambit/typescript 0.0.729 → 0.0.732

package/transformers/property-declaration.ts

@@ -20,10 +20,9 @@ export class PropertyDeclaration implements SchemaTransformer {
 
   async transform(propertyDec: PropertyDeclarationNode, context: SchemaExtractorContext): Promise<SchemaNode> {
     const name = this.getName(propertyDec);
-    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-    const info = await context.getQuickInfo(propertyDec.name!);
+    const info = await context.getQuickInfo(propertyDec.name);
     const displaySig = info?.body?.displayString;
-    const typeStr = parseTypeFromQuickInfo(displaySig);
+    const typeStr = parseTypeFromQuickInfo(info);
     const type = await context.resolveType(propertyDec, typeStr);
 
     return new VariableSchema(name || '', displaySig || '', type);

package/transformers/property-signature.ts

@@ -20,18 +20,17 @@ export class PropertySignature implements SchemaTransformer {
 
   async transform(prop: PropertySignatureNode, context: SchemaExtractorContext): Promise<SchemaNode> {
     const name = this.getName(prop);
-    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-    const info = await context.getQuickInfo(prop.name!);
+    const info = await context.getQuickInfo(prop.name);
     const displaySig = info?.body?.displayString || '';
     if (prop.type?.kind === ts.SyntaxKind.FunctionType) {
       // e.g. `propertySig: () => void;` inside interface
       const propType = prop.type as FunctionTypeNode;
       const args = await getParams(propType.parameters, context);
-      const typeStr = parseReturnTypeFromQuickInfo(displaySig);
+      const typeStr = parseReturnTypeFromQuickInfo(info);
       const returnType = await context.resolveType(propType, typeStr);
       return new FunctionSchema(name, args, returnType, displaySig);
     }
-    const typeStr = parseTypeFromQuickInfo(displaySig);
+    const typeStr = parseTypeFromQuickInfo(info);
     const type = await context.resolveType(prop, typeStr);
     return new VariableSchema(name, displaySig, type);
   }

package/transformers/type-alias.ts

@@ -3,6 +3,7 @@ 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 { typeNodeToSchema } from './utils/type-node-to-schema';
 
 export class TypeAliasTransformer implements SchemaTransformer {
   predicate(node: Node) {
@@ -18,10 +19,9 @@ export class TypeAliasTransformer implements SchemaTransformer {
   }
 
   async transform(typeAlias: TypeAliasDeclaration, context: SchemaExtractorContext) {
-    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-    const info = await context.getQuickInfo(typeAlias.name!);
+    const type = await typeNodeToSchema(typeAlias.type, context);
+    const info = await context.getQuickInfo(typeAlias.name);
     const displaySig = info?.body?.displayString;
-    const type = await context.computeSchema(typeAlias.type);
     return new TypeSchema(this.getName(typeAlias), type, displaySig as string);
   }
 }

package/transformers/utils/get-params.ts

@@ -1,30 +1,29 @@
-import { Parameter, TypeRefSchema } from '@teambit/semantics.entities.semantic-schema';
+import { ParameterSchema, SchemaNode, TypeRefSchema } from '@teambit/semantics.entities.semantic-schema';
 import pMapSeries from 'p-map-series';
 import { ParameterDeclaration, NodeArray } from 'typescript';
 import { SchemaExtractorContext } from '../../schema-extractor-context';
 import { parseTypeFromQuickInfo } from './parse-type-from-quick-info';
+import { typeNodeToSchema } from './type-node-to-schema';
 
 export async function getParams(
   parameterNodes: NodeArray<ParameterDeclaration>,
   context: SchemaExtractorContext
-): Promise<Parameter[]> {
+): Promise<ParameterSchema[]> {
   return pMapSeries(parameterNodes, async (param) => {
-    return {
-      name: param.name.getText(),
-      type: await getParamType(param, context),
-      defaultValue: param.initializer ? param.initializer.getText() : undefined,
-    };
+    return new ParameterSchema(
+      param.name.getText(),
+      await getParamType(param, context),
+      param.initializer ? param.initializer.getText() : undefined
+    );
   });
 }
 
-async function getParamType(param: ParameterDeclaration, context: SchemaExtractorContext): Promise<TypeRefSchema> {
+async function getParamType(param: ParameterDeclaration, context: SchemaExtractorContext): Promise<SchemaNode> {
   if (param.type) {
     const type = param.type;
-    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-    return context.resolveType(type!, type?.getText() || 'any');
+    return typeNodeToSchema(type, context);
   }
   const info = await context.getQuickInfo(param.name);
-  const displaySig = info?.body?.displayString;
-  const parsed = parseTypeFromQuickInfo(displaySig);
+  const parsed = parseTypeFromQuickInfo(info);
   return new TypeRefSchema(parsed || 'any');
 }

package/transformers/utils/parse-type-from-quick-info.ts

@@ -1,12 +1,84 @@
-export function parseTypeFromQuickInfo(displayString?: string) {
-  if (!displayString) return '';
-  const array = displayString.split(':');
-  return array[array.length - 1].trim();
+// eslint-disable-next-line import/no-unresolved
+import protocol from 'typescript/lib/protocol';
+
+/**
+ * try to parse the type from the quickinfo.
+ * this is an error-prone process, we do our best here.
+ *
+ * an example of a function with many ":"
+ * `export function getObj(a: string, func: (b: number) => {}) { return { a: 1, b: 2 } };`
+ * which produce the following quickinfo:
+ * ```ts
+ * function getObj(a: string, func: (b: number) => {}): {
+ *   a: number;
+ *   b: number;
+ * }
+ * ```
+ *
+ * some examples of quickinfo:
+ *
+ * function ts.signatureToDisplayParts(typechecker: TypeChecker, signature: Signature, enclosingDeclaration?: Node | undefined, flags?: TypeFormatFlags): SymbolDisplayPart[]
+ *
+ * const enum ts.TypeFormatFlags
+ *
+ * (method) ts.TypeChecker.writeSignature(signature: Signature, enclosingDeclaration?: Node | undefined, flags?: TypeFormatFlags | undefined, kind?: SignatureKind | undefined, writer?: EmitTextWriter | undefined): string
+ *
+ * const obj: {
+ *   a: number;
+ *   b: number;
+ *  }
+ *
+ * function getObj(a: string): {
+ *     a: number;
+ *     b: number;
+ * }
+ */
+export function parseTypeFromQuickInfo(quickInfo: protocol.QuickInfoResponse | undefined): string {
+  if (!quickInfo?.body?.displayString) return '';
+  const displayString = quickInfo.body.displayString;
+  const splitByColon = displayString.split(':');
+  switch (quickInfo.body.kind) {
+    case 'const':
+    case 'property':
+    case 'let':
+    case 'var': {
+      const [, ...tail] = splitByColon;
+      return tail.join(':').trim();
+    }
+    case 'method':
+    case 'function': {
+      const split = displayString.split('): ');
+      if (split.length !== 2) {
+        throw new Error(`quickinfo of a function below was not implemented.\n${displayString}`);
+      }
+      return split[1].trim();
+    }
+    case 'alias': {
+      // e.g. (alias) class BuilderService\nimport BuilderService
+      // e.g. '(alias) type Serializable = {\n' +
+      // '    toString(): string;\n' +
+      // '}\n' +
+      // 'import Serializable'
+      const firstLine = displayString.split('\n')[0];
+      const splitBySpace = firstLine.trim().split(' ');
+      // first two are alias keyword and alias type
+      const [, , typeName] = splitBySpace;
+      return typeName;
+    }
+    case 'type': {
+      // e.g. `type TaskSlot = SlotRegistry<BuildTask[]>`
+      const splitByEqual = displayString.split('=');
+      const [, ...tail] = splitByEqual;
+      return tail.join('=').trim();
+    }
+    default:
+      return splitByColon[splitByColon.length - 1].trim();
+  }
 }
 
-export function parseReturnTypeFromQuickInfo(displayString?: string) {
-  if (!displayString) return '';
-  const typeStr = parseTypeFromQuickInfo(displayString);
+export function parseReturnTypeFromQuickInfo(quickInfo: protocol.QuickInfoResponse | undefined): string {
+  if (!quickInfo) return '';
+  const typeStr = parseTypeFromQuickInfo(quickInfo);
   const array = typeStr.split('=>');
   return array[array.length - 1].trim();
 }

package/transformers/utils/type-node-to-schema.ts

@@ -0,0 +1,205 @@
+import {
+  TypeNode,
+  SyntaxKind,
+  KeywordTypeNode,
+  FunctionTypeNode,
+  TypeQueryNode,
+  TypeReferenceNode,
+  ArrayTypeNode,
+  TypeOperatorNode,
+  TupleTypeNode,
+  IntersectionTypeNode,
+  UnionTypeNode,
+  TypeLiteralNode,
+} from 'typescript';
+import {
+  SchemaNode,
+  TypeIntersectionSchema,
+  TypeUnionSchema,
+  TypeLiteralSchema,
+  FunctionSchema,
+  TypeQuerySchema,
+  LiteralTypeSchema,
+  KeywordTypeSchema,
+  TypeArraySchema,
+  TypeOperatorSchema,
+  TupleTypeSchema,
+} from '@teambit/semantics.entities.semantic-schema';
+import pMapSeries from 'p-map-series';
+import { SchemaExtractorContext } from '../../schema-extractor-context';
+import { getParams } from './get-params';
+
+// eslint-disable-next-line complexity
+export async function typeNodeToSchema(node: TypeNode, context: SchemaExtractorContext): Promise<SchemaNode> {
+  if (isKeywordType(node)) {
+    return new KeywordTypeSchema(node.getText());
+  }
+  switch (node.kind) {
+    case SyntaxKind.IntersectionType:
+      return intersectionType(node as IntersectionTypeNode, context);
+    case SyntaxKind.UnionType:
+      return unionType(node as UnionTypeNode, context);
+    case SyntaxKind.TypeReference:
+      return typeReference(node as TypeReferenceNode, context);
+    case SyntaxKind.TypeLiteral:
+      return typeLiteral(node as TypeLiteralNode, context);
+    case SyntaxKind.LiteralType: // e.g. string/boolean
+      return new LiteralTypeSchema(node.getText());
+    case SyntaxKind.FunctionType:
+      return functionType(node as FunctionTypeNode, context);
+    case SyntaxKind.TypeQuery:
+      return typeQuery(node as TypeQueryNode, context);
+    case SyntaxKind.ArrayType:
+      return arrayType(node as ArrayTypeNode, context);
+    case SyntaxKind.TypeOperator:
+      return typeOperator(node as TypeOperatorNode, context);
+    case SyntaxKind.TupleType:
+      return tupleType(node as TupleTypeNode, context);
+    case SyntaxKind.TypePredicate:
+    case SyntaxKind.ConstructorType:
+    case SyntaxKind.NamedTupleMember:
+    case SyntaxKind.OptionalType:
+    case SyntaxKind.RestType:
+    case SyntaxKind.ConditionalType:
+    case SyntaxKind.InferType:
+    case SyntaxKind.ParenthesizedType:
+    case SyntaxKind.ThisType:
+    case SyntaxKind.IndexedAccessType:
+    case SyntaxKind.MappedType:
+    case SyntaxKind.TemplateLiteralType:
+    case SyntaxKind.TemplateLiteralTypeSpan:
+    case SyntaxKind.ImportType:
+    case SyntaxKind.ExpressionWithTypeArguments:
+    case SyntaxKind.JSDocTypeExpression:
+    case SyntaxKind.JSDocAllType:
+    case SyntaxKind.JSDocUnknownType:
+    case SyntaxKind.JSDocNonNullableType:
+    case SyntaxKind.JSDocNullableType:
+    case SyntaxKind.JSDocOptionalType:
+    case SyntaxKind.JSDocFunctionType:
+    case SyntaxKind.JSDocVariadicType:
+    case SyntaxKind.JSDocNamepathType:
+    case SyntaxKind.JSDocSignature:
+    case SyntaxKind.JSDocTypeLiteral:
+      throw new Error(`TypeNode "${SyntaxKind[node.kind]}" was not implemented yet.
+context: ${node.getText()}`);
+    default:
+      throw new Error(`Node "${SyntaxKind[node.kind]}" is not a TypeNode.
+context: ${node.getText()}`);
+  }
+}
+
+/**
+ * whether it's kind of `ts.KeywordTypeSyntaxKind`
+ */
+function isKeywordType(node: TypeNode): node is KeywordTypeNode {
+  switch (node.kind) {
+    case SyntaxKind.AnyKeyword:
+    case SyntaxKind.BigIntKeyword:
+    case SyntaxKind.BooleanKeyword:
+    case SyntaxKind.IntrinsicKeyword:
+    case SyntaxKind.NeverKeyword:
+    case SyntaxKind.NumberKeyword:
+    case SyntaxKind.ObjectKeyword:
+    case SyntaxKind.StringKeyword:
+    case SyntaxKind.SymbolKeyword:
+    case SyntaxKind.UndefinedKeyword:
+    case SyntaxKind.UnknownKeyword:
+    case SyntaxKind.VoidKeyword:
+      return true;
+    default:
+      return false;
+  }
+}
+
+async function intersectionType(node: IntersectionTypeNode, context: SchemaExtractorContext) {
+  const types = await pMapSeries(node.types, async (type) => {
+    const typeSchema = await typeNodeToSchema(type, context);
+    return typeSchema;
+  });
+  return new TypeIntersectionSchema(types);
+}
+
+async function unionType(node: UnionTypeNode, context: SchemaExtractorContext) {
+  const types = await pMapSeries(node.types, async (type) => {
+    const typeSchema = await typeNodeToSchema(type, context);
+    return typeSchema;
+  });
+  return new TypeUnionSchema(types);
+}
+
+/**
+ * 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.
+ */
+async function typeLiteral(node: TypeLiteralNode, context: SchemaExtractorContext) {
+  const members = await pMapSeries(node.members, async (member) => {
+    const typeSchema = await context.computeSchema(member);
+    return typeSchema;
+  });
+  return new TypeLiteralSchema(members);
+}
+
+/**
+ * In the following example, `AriaButtonProps` is a type reference
+ * ```ts
+ * import type { AriaButtonProps } from '@react-types/button';
+ * export type ButtonProps = AriaButtonProps & { a: string };
+ * ```
+ */
+async function typeReference(node: TypeReferenceNode, context: SchemaExtractorContext) {
+  const name = node.typeName.getText();
+  const type = await context.resolveType(node, name, false);
+  return type;
+}
+
+async function functionType(node: FunctionTypeNode, context: SchemaExtractorContext): Promise<SchemaNode> {
+  const name = node.name?.getText() || '';
+  const params = await getParams(node.parameters, context);
+  const returnType = await typeNodeToSchema(node.type, context);
+  return new FunctionSchema(name, params, returnType, '');
+}
+
+/**
+ * e.g. `typeof Foo`
+ */
+async function typeQuery(node: TypeQueryNode, context: SchemaExtractorContext) {
+  const displaySig = await context.getQuickInfoDisplayString(node.exprName);
+  const type = await context.resolveType(node.exprName, node.exprName.getText(), false);
+  return new TypeQuerySchema(type, displaySig);
+}
+
+async function arrayType(node: ArrayTypeNode, context: SchemaExtractorContext) {
+  const type = await typeNodeToSchema(node.elementType, context);
+  return new TypeArraySchema(type);
+}
+
+/**
+ * e.g. keyof typeof Foo
+ */
+async function typeOperator(node: TypeOperatorNode, context: SchemaExtractorContext) {
+  const operatorName = getOperatorName(node.operator);
+  const type = await typeNodeToSchema(node.type, context);
+  return new TypeOperatorSchema(operatorName, type);
+}
+
+function getOperatorName(operator: SyntaxKind.KeyOfKeyword | SyntaxKind.UniqueKeyword | SyntaxKind.ReadonlyKeyword) {
+  switch (operator) {
+    case SyntaxKind.KeyOfKeyword:
+      return 'keyof';
+    case SyntaxKind.UniqueKeyword:
+      return 'unique';
+    case SyntaxKind.ReadonlyKeyword:
+      return 'readonly';
+    default:
+      throw new Error(`getOperatorName: unable to find operator name for ${operator}`);
+  }
+}
+
+async function tupleType(node: TupleTypeNode, context: SchemaExtractorContext) {
+  const elements = await pMapSeries(node.elements, async (elem) => {
+    const typeSchema = await typeNodeToSchema(elem, context);
+    return typeSchema;
+  });
+  return new TupleTypeSchema(elements);
+}

package/transformers/variable-declaration.ts

@@ -25,11 +25,11 @@ export class VariableDeclaration implements SchemaTransformer {
     const displaySig = info?.body?.displayString || '';
     if (varDec.initializer?.kind === ts.SyntaxKind.ArrowFunction) {
       const args = await getParams((varDec.initializer as ArrowFunction).parameters, context);
-      const typeStr = parseReturnTypeFromQuickInfo(displaySig);
+      const typeStr = parseReturnTypeFromQuickInfo(info);
       const returnType = await context.resolveType(varDec, typeStr);
       return new FunctionSchema(name, args, returnType, displaySig);
     }
-    const typeStr = parseTypeFromQuickInfo(displaySig);
+    const typeStr = parseTypeFromQuickInfo(info);
     const type = await context.resolveType(varDec, typeStr);
     return new VariableSchema(name, displaySig, type);
   }

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

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

package/dist/transformers/type-intersection.js

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

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

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

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

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

package/dist/transformers/type-literal.js

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

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

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

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

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

package/dist/transformers/type-reference.js

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

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

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

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

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