@teambit/typescript 0.0.965 → 0.0.967

package/dist/transformers/index.js

@@ -3,6 +3,12 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+Object.defineProperty(exports, "ArrayTypeTransformer", {
+  enumerable: true,
+  get: function () {
+    return _arrayType().ArrayTypeTransformer;
+  }
+});
 Object.defineProperty(exports, "BindingElementTransformer", {
   enumerable: true,
   get: function () {
@@ -15,28 +21,64 @@ Object.defineProperty(exports, "ClassDeclarationTransformer", {
     return _classDeclaration().ClassDeclarationTransformer;
   }
 });
+Object.defineProperty(exports, "ConditionalTypeTransformer", {
+  enumerable: true,
+  get: function () {
+    return _conditionalType().ConditionalTypeTransformer;
+  }
+});
+Object.defineProperty(exports, "ConstructorTransformer", {
+  enumerable: true,
+  get: function () {
+    return _constructor().ConstructorTransformer;
+  }
+});
 Object.defineProperty(exports, "EnumDeclarationTransformer", {
   enumerable: true,
   get: function () {
     return _enumDeclaration().EnumDeclarationTransformer;
   }
 });
-Object.defineProperty(exports, "ExportAssignmentDeclaration", {
+Object.defineProperty(exports, "ExportAssignmentTransformer", {
+  enumerable: true,
+  get: function () {
+    return _exportAssignment().ExportAssignmentTransformer;
+  }
+});
+Object.defineProperty(exports, "ExportDeclarationTransformer", {
+  enumerable: true,
+  get: function () {
+    return _exportDeclaration().ExportDeclarationTransformer;
+  }
+});
+Object.defineProperty(exports, "FunctionLikeTransformer", {
+  enumerable: true,
+  get: function () {
+    return _functionLike().FunctionLikeTransformer;
+  }
+});
+Object.defineProperty(exports, "GetAccessorTransformer", {
+  enumerable: true,
+  get: function () {
+    return _getAccessor().GetAccessorTransformer;
+  }
+});
+Object.defineProperty(exports, "ImportDeclarationTransformer", {
   enumerable: true,
   get: function () {
-    return _exportAssignmentDeclaration().ExportAssignmentDeclaration;
+    return _importDeclaration().ImportDeclarationTransformer;
   }
 });
-Object.defineProperty(exports, "ExportDeclaration", {
+Object.defineProperty(exports, "IndexSignatureTransformer", {
   enumerable: true,
   get: function () {
-    return _exportDeclaration().ExportDeclaration;
+    return _indexSignature().IndexSignatureTransformer;
   }
 });
-Object.defineProperty(exports, "FunctionDeclaration", {
+Object.defineProperty(exports, "IndexedAccessTypeTransformer", {
   enumerable: true,
   get: function () {
-    return _functionDeclaration().FunctionDeclaration;
+    return _indexedAccessType().IndexedAccessTypeTransformer;
   }
 });
 Object.defineProperty(exports, "InterfaceDeclarationTransformer", {
@@ -45,18 +87,126 @@ Object.defineProperty(exports, "InterfaceDeclarationTransformer", {
     return _interfaceDeclaration().InterfaceDeclarationTransformer;
   }
 });
+Object.defineProperty(exports, "IntersectionTypeTransformer", {
+  enumerable: true,
+  get: function () {
+    return _intersectionType().IntersectionTypeTransformer;
+  }
+});
+Object.defineProperty(exports, "KeywordTypeTransformer", {
+  enumerable: true,
+  get: function () {
+    return _keywordType().KeywordTypeTransformer;
+  }
+});
+Object.defineProperty(exports, "LiteralTypeTransformer", {
+  enumerable: true,
+  get: function () {
+    return _literalType().LiteralTypeTransformer;
+  }
+});
+Object.defineProperty(exports, "NamedTupleTransformer", {
+  enumerable: true,
+  get: function () {
+    return _namedTuple().NamedTupleTransformer;
+  }
+});
+Object.defineProperty(exports, "ParameterTransformer", {
+  enumerable: true,
+  get: function () {
+    return _parameter().ParameterTransformer;
+  }
+});
+Object.defineProperty(exports, "ParenthesizedTypeTransformer", {
+  enumerable: true,
+  get: function () {
+    return _parenthesizedType().ParenthesizedTypeTransformer;
+  }
+});
+Object.defineProperty(exports, "PropertyDeclarationTransformer", {
+  enumerable: true,
+  get: function () {
+    return _propertyDeclaration().PropertyDeclarationTransformer;
+  }
+});
+Object.defineProperty(exports, "SetAccessorTransformer", {
+  enumerable: true,
+  get: function () {
+    return _setAccessor().SetAccessorTransformer;
+  }
+});
 Object.defineProperty(exports, "SourceFileTransformer", {
   enumerable: true,
   get: function () {
     return _sourceFileTransformer().SourceFileTransformer;
   }
 });
+Object.defineProperty(exports, "TemplateLiteralTypeSpanTransformer", {
+  enumerable: true,
+  get: function () {
+    return _templateLiteralTypeSpan().TemplateLiteralTypeSpanTransformer;
+  }
+});
+Object.defineProperty(exports, "TemplateLiteralTypeTransformer", {
+  enumerable: true,
+  get: function () {
+    return _templateLiteralType().TemplateLiteralTypeTransformer;
+  }
+});
+Object.defineProperty(exports, "ThisTypeTransformer", {
+  enumerable: true,
+  get: function () {
+    return _thisType().ThisTypeTransformer;
+  }
+});
+Object.defineProperty(exports, "TupleTypeTransformer", {
+  enumerable: true,
+  get: function () {
+    return _tupleType().TupleTypeTransformer;
+  }
+});
 Object.defineProperty(exports, "TypeAliasTransformer", {
   enumerable: true,
   get: function () {
     return _typeAlias().TypeAliasTransformer;
   }
 });
+Object.defineProperty(exports, "TypeLiteralTransformer", {
+  enumerable: true,
+  get: function () {
+    return _typeLiteral().TypeLiteralTransformer;
+  }
+});
+Object.defineProperty(exports, "TypeOperatorTransformer", {
+  enumerable: true,
+  get: function () {
+    return _typeOperator().TypeOperatorTransformer;
+  }
+});
+Object.defineProperty(exports, "TypePredicateTransformer", {
+  enumerable: true,
+  get: function () {
+    return _typePredicate().TypePredicateTransformer;
+  }
+});
+Object.defineProperty(exports, "TypeQueryTransformer", {
+  enumerable: true,
+  get: function () {
+    return _typeQuery().TypeQueryTransformer;
+  }
+});
+Object.defineProperty(exports, "TypeReferenceTransformer", {
+  enumerable: true,
+  get: function () {
+    return _typeReference().TypeReferenceTransformer;
+  }
+});
+Object.defineProperty(exports, "UnionTypeTransformer", {
+  enumerable: true,
+  get: function () {
+    return _unionType().UnionTypeTransformer;
+  }
+});
 Object.defineProperty(exports, "VariableDeclaration", {
   enumerable: true,
   get: function () {
@@ -76,9 +226,16 @@ function _exportDeclaration() {
   };
   return data;
 }
-function _functionDeclaration() {
-  const data = require("./function-declaration");
-  _functionDeclaration = function () {
+function _functionLike() {
+  const data = require("./function-like");
+  _functionLike = function () {
+    return data;
+  };
+  return data;
+}
+function _parameter() {
+  const data = require("./parameter");
+  _parameter = function () {
     return data;
   };
   return data;
@@ -111,6 +268,132 @@ function _typeAlias() {
   };
   return data;
 }
+function _intersectionType() {
+  const data = require("./intersection-type");
+  _intersectionType = function () {
+    return data;
+  };
+  return data;
+}
+function _unionType() {
+  const data = require("./union-type");
+  _unionType = function () {
+    return data;
+  };
+  return data;
+}
+function _typeReference() {
+  const data = require("./type-reference");
+  _typeReference = function () {
+    return data;
+  };
+  return data;
+}
+function _typeLiteral() {
+  const data = require("./type-literal");
+  _typeLiteral = function () {
+    return data;
+  };
+  return data;
+}
+function _literalType() {
+  const data = require("./literal-type");
+  _literalType = function () {
+    return data;
+  };
+  return data;
+}
+function _typeQuery() {
+  const data = require("./type-query");
+  _typeQuery = function () {
+    return data;
+  };
+  return data;
+}
+function _typeOperator() {
+  const data = require("./type-operator");
+  _typeOperator = function () {
+    return data;
+  };
+  return data;
+}
+function _keywordType() {
+  const data = require("./keyword-type");
+  _keywordType = function () {
+    return data;
+  };
+  return data;
+}
+function _tupleType() {
+  const data = require("./tuple-type");
+  _tupleType = function () {
+    return data;
+  };
+  return data;
+}
+function _parenthesizedType() {
+  const data = require("./parenthesized-type");
+  _parenthesizedType = function () {
+    return data;
+  };
+  return data;
+}
+function _typePredicate() {
+  const data = require("./type-predicate");
+  _typePredicate = function () {
+    return data;
+  };
+  return data;
+}
+function _indexedAccessType() {
+  const data = require("./indexed-access-type");
+  _indexedAccessType = function () {
+    return data;
+  };
+  return data;
+}
+function _templateLiteralTypeSpan() {
+  const data = require("./template-literal-type-span");
+  _templateLiteralTypeSpan = function () {
+    return data;
+  };
+  return data;
+}
+function _templateLiteralType() {
+  const data = require("./template-literal-type");
+  _templateLiteralType = function () {
+    return data;
+  };
+  return data;
+}
+function _thisType() {
+  const data = require("./this-type");
+  _thisType = function () {
+    return data;
+  };
+  return data;
+}
+function _conditionalType() {
+  const data = require("./conditional-type");
+  _conditionalType = function () {
+    return data;
+  };
+  return data;
+}
+function _namedTuple() {
+  const data = require("./named-tuple");
+  _namedTuple = function () {
+    return data;
+  };
+  return data;
+}
+function _arrayType() {
+  const data = require("./array-type");
+  _arrayType = function () {
+    return data;
+  };
+  return data;
+}
 function _classDeclaration() {
   const data = require("./class-declaration");
   _classDeclaration = function () {
@@ -118,6 +401,41 @@ function _classDeclaration() {
   };
   return data;
 }
+function _constructor() {
+  const data = require("./constructor");
+  _constructor = function () {
+    return data;
+  };
+  return data;
+}
+function _propertyDeclaration() {
+  const data = require("./property-declaration");
+  _propertyDeclaration = function () {
+    return data;
+  };
+  return data;
+}
+function _setAccessor() {
+  const data = require("./set-accessor");
+  _setAccessor = function () {
+    return data;
+  };
+  return data;
+}
+function _getAccessor() {
+  const data = require("./get-accessor");
+  _getAccessor = function () {
+    return data;
+  };
+  return data;
+}
+function _indexSignature() {
+  const data = require("./index-signature");
+  _indexSignature = function () {
+    return data;
+  };
+  return data;
+}
 function _interfaceDeclaration() {
   const data = require("./interface-declaration");
   _interfaceDeclaration = function () {
@@ -139,9 +457,16 @@ function _bindingElement() {
   };
   return data;
 }
-function _exportAssignmentDeclaration() {
-  const data = require("./export-assignment-declaration");
-  _exportAssignmentDeclaration = function () {
+function _exportAssignment() {
+  const data = require("./export-assignment");
+  _exportAssignment = function () {
+    return data;
+  };
+  return data;
+}
+function _importDeclaration() {
+  const data = require("./import-declaration");
+  _importDeclaration = function () {
     return data;
   };
   return data;

package/dist/transformers/index.js.map

@@ -1 +1 @@
-{"version":3,"names":[],"sources":["index.ts"],"sourcesContent":["export { ExportDeclaration } from './export-declaration';\nexport { FunctionDeclaration } from './function-declaration';\nexport { VariableStatementTransformer } from './variable-statement';\nexport { VariableDeclaration } from './variable-declaration';\nexport { SourceFileTransformer } from './source-file-transformer';\nexport { TypeAliasTransformer } from './type-alias';\nexport { ClassDeclarationTransformer } from './class-declaration';\nexport { InterfaceDeclarationTransformer } from './interface-declaration';\nexport { EnumDeclarationTransformer } from './enum-declaration';\nexport { BindingElementTransformer } from './binding-element';\nexport { ExportAssignmentDeclaration } from './export-assignment-declaration';\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;AACA;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;AACA;EAAA;EAAA;IAAA;EAAA;EAAA;AAAA;AACA;EAAA;EAAA;IAAA;EAAA;EAAA;AAAA;AACA;EAAA;EAAA;IAAA;EAAA;EAAA;AAAA"}
+{"version":3,"names":[],"sources":["index.ts"],"sourcesContent":["export { ExportDeclarationTransformer } from './export-declaration';\nexport { FunctionLikeTransformer } from './function-like';\nexport { ParameterTransformer } from './parameter';\nexport { VariableStatementTransformer } from './variable-statement';\nexport { VariableDeclaration } from './variable-declaration';\nexport { SourceFileTransformer } from './source-file-transformer';\nexport { TypeAliasTransformer } from './type-alias';\nexport { IntersectionTypeTransformer } from './intersection-type';\nexport { UnionTypeTransformer } from './union-type';\nexport { TypeReferenceTransformer } from './type-reference';\nexport { TypeLiteralTransformer } from './type-literal';\nexport { LiteralTypeTransformer } from './literal-type';\nexport { TypeQueryTransformer } from './type-query';\nexport { TypeOperatorTransformer } from './type-operator';\nexport { KeywordTypeTransformer } from './keyword-type';\nexport { TupleTypeTransformer } from './tuple-type';\nexport { ParenthesizedTypeTransformer } from './parenthesized-type';\nexport { TypePredicateTransformer } from './type-predicate';\nexport { IndexedAccessTypeTransformer } from './indexed-access-type';\nexport { TemplateLiteralTypeSpanTransformer } from './template-literal-type-span';\nexport { TemplateLiteralTypeTransformer } from './template-literal-type';\nexport { ThisTypeTransformer } from './this-type';\nexport { ConditionalTypeTransformer } from './conditional-type';\nexport { NamedTupleTransformer } from './named-tuple';\nexport { ArrayTypeTransformer } from './array-type';\nexport { ClassDeclarationTransformer } from './class-declaration';\nexport { ConstructorTransformer } from './constructor';\nexport { PropertyDeclarationTransformer } from './property-declaration';\nexport { SetAccessorTransformer } from './set-accessor';\nexport { GetAccessorTransformer } from './get-accessor';\nexport { IndexSignatureTransformer } from './index-signature';\nexport { InterfaceDeclarationTransformer } from './interface-declaration';\nexport { EnumDeclarationTransformer } from './enum-declaration';\nexport { BindingElementTransformer } from './binding-element';\nexport { ExportAssignmentTransformer } from './export-assignment';\nexport { ImportDeclarationTransformer } from './import-declaration';\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;AACA;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;AACA;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;AACA;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;AACA;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;AACA;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;AACA;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;AACA;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;AACA;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"}

package/dist/transformers/indexed-access-type.d.ts

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

package/dist/transformers/indexed-access-type.js

@@ -0,0 +1,37 @@
+"use strict";
+
+require("core-js/modules/es.promise.js");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.IndexedAccessTypeTransformer = 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 IndexedAccessTypeTransformer {
+  predicate(node) {
+    return node.kind === _typescript().SyntaxKind.IndexedAccessType;
+  }
+  async getIdentifiers() {
+    return [];
+  }
+  async transform(node, context) {
+    const objectType = await context.computeSchema(node.objectType);
+    const indexType = await context.computeSchema(node.indexType);
+    return new (_semanticsEntities().IndexedAccessSchema)(context.getLocation(node), objectType, indexType);
+  }
+}
+exports.IndexedAccessTypeTransformer = IndexedAccessTypeTransformer;
+
+//# sourceMappingURL=indexed-access-type.js.map

package/dist/transformers/indexed-access-type.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["IndexedAccessTypeTransformer","predicate","node","kind","SyntaxKind","IndexedAccessType","getIdentifiers","transform","context","objectType","computeSchema","indexType","IndexedAccessSchema","getLocation"],"sources":["indexed-access-type.ts"],"sourcesContent":["import { IndexedAccessTypeNode, Node, SyntaxKind } from 'typescript';\nimport { IndexedAccessSchema } from '@teambit/semantics.entities.semantic-schema';\nimport { SchemaTransformer } from '../schema-transformer';\nimport { SchemaExtractorContext } from '../schema-extractor-context';\nimport { Identifier } from '../identifier';\n\nexport class IndexedAccessTypeTransformer implements SchemaTransformer {\n  predicate(node: Node) {\n    return node.kind === SyntaxKind.IndexedAccessType;\n  }\n\n  async getIdentifiers(): Promise<Identifier[]> {\n    return [];\n  }\n\n  async transform(node: IndexedAccessTypeNode, context: SchemaExtractorContext) {\n    const objectType = await context.computeSchema(node.objectType);\n    const indexType = await context.computeSchema(node.indexType);\n    return new IndexedAccessSchema(context.getLocation(node), objectType, indexType);\n  }\n}\n"],"mappings":";;;;;;;AAAA;EAAA;EAAA;IAAA;EAAA;EAAA;AAAA;AACA;EAAA;EAAA;IAAA;EAAA;EAAA;AAAA;AAKO,MAAMA,4BAA4B,CAA8B;EACrEC,SAAS,CAACC,IAAU,EAAE;IACpB,OAAOA,IAAI,CAACC,IAAI,KAAKC,wBAAU,CAACC,iBAAiB;EACnD;EAEA,MAAMC,cAAc,GAA0B;IAC5C,OAAO,EAAE;EACX;EAEA,MAAMC,SAAS,CAACL,IAA2B,EAAEM,OAA+B,EAAE;IAC5E,MAAMC,UAAU,GAAG,MAAMD,OAAO,CAACE,aAAa,CAACR,IAAI,CAACO,UAAU,CAAC;IAC/D,MAAME,SAAS,GAAG,MAAMH,OAAO,CAACE,aAAa,CAACR,IAAI,CAACS,SAAS,CAAC;IAC7D,OAAO,KAAIC,wCAAmB,EAACJ,OAAO,CAACK,WAAW,CAACX,IAAI,CAAC,EAAEO,UAAU,EAAEE,SAAS,CAAC;EAClF;AACF;AAAC"}

package/dist/transformers/interface-declaration.d.ts

@@ -2,10 +2,10 @@ import { Node, InterfaceDeclaration } from 'typescript';
 import { InterfaceSchema } 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 InterfaceDeclarationTransformer implements SchemaTransformer {
     predicate(node: Node): boolean;
-    getIdentifiers(node: InterfaceDeclaration): Promise<ExportIdentifier[]>;
+    getIdentifiers(node: InterfaceDeclaration): Promise<Identifier[]>;
     private getExpressionWithTypeArgs;
     transform(interfaceDec: InterfaceDeclaration, context: SchemaExtractorContext): Promise<InterfaceSchema>;
 }

package/dist/transformers/interface-declaration.js

@@ -36,23 +36,9 @@ function _semanticsEntities() {
   };
   return data;
 }
-function _exportIdentifier() {
-  const data = require("../export-identifier");
-  _exportIdentifier = function () {
-    return data;
-  };
-  return data;
-}
-function _typeElementToSchema() {
-  const data = require("./utils/type-element-to-schema");
-  _typeElementToSchema = 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;
@@ -64,7 +50,7 @@ class InterfaceDeclarationTransformer {
     return node.kind === _typescript().SyntaxKind.InterfaceDeclaration;
   }
   async getIdentifiers(node) {
-    return [new (_exportIdentifier().ExportIdentifier)(node.name.getText(), node.getSourceFile().fileName)];
+    return [new (_identifier().Identifier)(node.name.getText(), node.getSourceFile().fileName)];
   }
   async getExpressionWithTypeArgs(node, context) {
     if (!node.heritageClauses) return [];
@@ -82,7 +68,7 @@ class InterfaceDeclarationTransformer {
         expression,
         name
       } = expressionWithTypeArgs;
-      const typeArgsNodes = typeArguments ? await (0, _pMapSeries().default)(typeArguments, t => (0, _typeNodeToSchema().typeNodeToSchema)(t, context)) : [];
+      const typeArgsNodes = typeArguments ? await (0, _pMapSeries().default)(typeArguments, t => context.computeSchema(t)) : [];
       const location = context.getLocation(expression);
       const expressionNode = (await context.visitDefinition(expression)) || new (_semanticsEntities().UnresolvedSchema)(location, expression.getText());
       return new (_semanticsEntities().ExpressionWithTypeArgumentsSchema)(typeArgsNodes, expressionNode, name, location);
@@ -90,7 +76,7 @@ class InterfaceDeclarationTransformer {
   }
   async transform(interfaceDec, context) {
     var _interfaceDec$typePar;
-    const members = await (0, _pMapSeries().default)(interfaceDec.members, member => (0, _typeElementToSchema().typeElementToSchema)(member, context));
+    const members = await (0, _pMapSeries().default)(interfaceDec.members, member => context.computeSchema(member));
     const doc = await context.jsDocToDocSchema(interfaceDec);
     const signature = interfaceDec.name ? await context.getQuickInfoDisplayString(interfaceDec.name) : undefined;
     const extendsNodes = await this.getExpressionWithTypeArgs(interfaceDec, context);

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

@@ -1 +1 @@
-{"version":3,"names":["InterfaceDeclarationTransformer","predicate","node","kind","SyntaxKind","InterfaceDeclaration","getIdentifiers","ExportIdentifier","name","getText","getSourceFile","fileName","getExpressionWithTypeArgs","context","heritageClauses","pMapSeries","filter","heritageClause","token","ExtendsKeyword","flatMap","h","types","map","type","expressionWithTypeArgs","typeArguments","expression","typeArgsNodes","t","typeNodeToSchema","location","getLocation","expressionNode","visitDefinition","UnresolvedSchema","ExpressionWithTypeArgumentsSchema","transform","interfaceDec","members","member","typeElementToSchema","doc","jsDocToDocSchema","signature","getQuickInfoDisplayString","undefined","extendsNodes","typeParameters","typeParam","Error","InterfaceSchema"],"sources":["interface-declaration.ts"],"sourcesContent":["import ts, { Node, InterfaceDeclaration, SyntaxKind } from 'typescript';\nimport pMapSeries from 'p-map-series';\nimport {\n  ExpressionWithTypeArgumentsSchema,\n  InterfaceSchema,\n  UnresolvedSchema,\n} from '@teambit/semantics.entities.semantic-schema';\nimport { SchemaTransformer } from '../schema-transformer';\nimport { SchemaExtractorContext } from '../schema-extractor-context';\nimport { ExportIdentifier } from '../export-identifier';\nimport { typeElementToSchema } from './utils/type-element-to-schema';\nimport { typeNodeToSchema } from './utils/type-node-to-schema';\n\nexport class InterfaceDeclarationTransformer implements SchemaTransformer {\n  predicate(node: Node) {\n    return node.kind === SyntaxKind.InterfaceDeclaration;\n  }\n\n  async getIdentifiers(node: InterfaceDeclaration): Promise<ExportIdentifier[]> {\n    return [new ExportIdentifier(node.name.getText(), node.getSourceFile().fileName)];\n  }\n\n  private async getExpressionWithTypeArgs(node: InterfaceDeclaration, context: SchemaExtractorContext) {\n    if (!node.heritageClauses) return [];\n\n    return pMapSeries(\n      node.heritageClauses\n        .filter((heritageClause: ts.HeritageClause) => heritageClause.token === SyntaxKind.ExtendsKeyword)\n        .flatMap((h: ts.HeritageClause) => {\n          const { types } = h;\n          const name = h.getText();\n          return types.map((type) => ({ ...type, name }));\n        }),\n      async (expressionWithTypeArgs: ts.ExpressionWithTypeArguments & { name: string }) => {\n        const { typeArguments, expression, name } = expressionWithTypeArgs;\n        const typeArgsNodes = typeArguments ? await pMapSeries(typeArguments, (t) => typeNodeToSchema(t, context)) : [];\n        const location = context.getLocation(expression);\n        const expressionNode =\n          (await context.visitDefinition(expression)) || new UnresolvedSchema(location, expression.getText());\n        return new ExpressionWithTypeArgumentsSchema(typeArgsNodes, expressionNode, name, location);\n      }\n    );\n  }\n\n  async transform(interfaceDec: InterfaceDeclaration, context: SchemaExtractorContext) {\n    const members = await pMapSeries(interfaceDec.members, (member) => typeElementToSchema(member, context));\n    const doc = await context.jsDocToDocSchema(interfaceDec);\n    const signature = interfaceDec.name ? await context.getQuickInfoDisplayString(interfaceDec.name) : undefined;\n    const extendsNodes = await this.getExpressionWithTypeArgs(interfaceDec, context);\n    const typeParameters = interfaceDec.typeParameters?.map((typeParam) => {\n      return typeParam.name.getText();\n    });\n\n    if (!signature) {\n      throw Error(`Missing signature for interface ${interfaceDec.name.getText()} declaration`);\n    }\n\n    return new InterfaceSchema(\n      context.getLocation(interfaceDec),\n      interfaceDec.name.getText(),\n      signature,\n      extendsNodes,\n      members,\n      doc,\n      typeParameters\n    );\n  }\n}\n"],"mappings":"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"}
+{"version":3,"names":["InterfaceDeclarationTransformer","predicate","node","kind","SyntaxKind","InterfaceDeclaration","getIdentifiers","Identifier","name","getText","getSourceFile","fileName","getExpressionWithTypeArgs","context","heritageClauses","pMapSeries","filter","heritageClause","token","ExtendsKeyword","flatMap","h","types","map","type","expressionWithTypeArgs","typeArguments","expression","typeArgsNodes","t","computeSchema","location","getLocation","expressionNode","visitDefinition","UnresolvedSchema","ExpressionWithTypeArgumentsSchema","transform","interfaceDec","members","member","doc","jsDocToDocSchema","signature","getQuickInfoDisplayString","undefined","extendsNodes","typeParameters","typeParam","Error","InterfaceSchema"],"sources":["interface-declaration.ts"],"sourcesContent":["import ts, { Node, InterfaceDeclaration, SyntaxKind } from 'typescript';\nimport pMapSeries from 'p-map-series';\nimport {\n  ExpressionWithTypeArgumentsSchema,\n  InterfaceSchema,\n  UnresolvedSchema,\n} from '@teambit/semantics.entities.semantic-schema';\nimport { SchemaTransformer } from '../schema-transformer';\nimport { SchemaExtractorContext } from '../schema-extractor-context';\nimport { Identifier } from '../identifier';\n\nexport class InterfaceDeclarationTransformer implements SchemaTransformer {\n  predicate(node: Node) {\n    return node.kind === SyntaxKind.InterfaceDeclaration;\n  }\n\n  async getIdentifiers(node: InterfaceDeclaration): Promise<Identifier[]> {\n    return [new Identifier(node.name.getText(), node.getSourceFile().fileName)];\n  }\n\n  private async getExpressionWithTypeArgs(node: InterfaceDeclaration, context: SchemaExtractorContext) {\n    if (!node.heritageClauses) return [];\n\n    return pMapSeries(\n      node.heritageClauses\n        .filter((heritageClause: ts.HeritageClause) => heritageClause.token === SyntaxKind.ExtendsKeyword)\n        .flatMap((h: ts.HeritageClause) => {\n          const { types } = h;\n          const name = h.getText();\n          return types.map((type) => ({ ...type, name }));\n        }),\n      async (expressionWithTypeArgs: ts.ExpressionWithTypeArguments & { name: string }) => {\n        const { typeArguments, expression, name } = expressionWithTypeArgs;\n        const typeArgsNodes = typeArguments ? await pMapSeries(typeArguments, (t) => context.computeSchema(t)) : [];\n        const location = context.getLocation(expression);\n        const expressionNode =\n          (await context.visitDefinition(expression)) || new UnresolvedSchema(location, expression.getText());\n        return new ExpressionWithTypeArgumentsSchema(typeArgsNodes, expressionNode, name, location);\n      }\n    );\n  }\n\n  async transform(interfaceDec: InterfaceDeclaration, context: SchemaExtractorContext) {\n    const members = await pMapSeries(interfaceDec.members, (member) => context.computeSchema(member));\n    const doc = await context.jsDocToDocSchema(interfaceDec);\n    const signature = interfaceDec.name ? await context.getQuickInfoDisplayString(interfaceDec.name) : undefined;\n    const extendsNodes = await this.getExpressionWithTypeArgs(interfaceDec, context);\n    const typeParameters = interfaceDec.typeParameters?.map((typeParam) => {\n      return typeParam.name.getText();\n    });\n\n    if (!signature) {\n      throw Error(`Missing signature for interface ${interfaceDec.name.getText()} declaration`);\n    }\n\n    return new InterfaceSchema(\n      context.getLocation(interfaceDec),\n      interfaceDec.name.getText(),\n      signature,\n      extendsNodes,\n      members,\n      doc,\n      typeParameters\n    );\n  }\n}\n"],"mappings":"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"}

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

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

package/dist/transformers/intersection-type.js

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

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

@@ -0,0 +1 @@
+{"version":3,"names":["IntersectionTypeTransformer","predicate","node","kind","ts","SyntaxKind","IntersectionType","getIdentifiers","transform","context","types","pMapSeries","type","typeSchema","computeSchema","location","getLocation","TypeIntersectionSchema"],"sources":["intersection-type.ts"],"sourcesContent":["import ts, { Node, IntersectionTypeNode } from 'typescript';\nimport { TypeIntersectionSchema } 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\nexport class IntersectionTypeTransformer implements SchemaTransformer {\n  predicate(node: Node) {\n    return node.kind === ts.SyntaxKind.IntersectionType;\n  }\n\n  async getIdentifiers(): Promise<Identifier[]> {\n    return [];\n  }\n\n  async transform(node: IntersectionTypeNode, context: SchemaExtractorContext) {\n    const types = await pMapSeries(node.types, async (type) => {\n      const typeSchema = context.computeSchema(type);\n      return typeSchema;\n    });\n    const location = context.getLocation(node);\n    return new TypeIntersectionSchema(location, types);\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,2BAA2B,CAA8B;EACpEC,SAAS,CAACC,IAAU,EAAE;IACpB,OAAOA,IAAI,CAACC,IAAI,KAAKC,qBAAE,CAACC,UAAU,CAACC,gBAAgB;EACrD;EAEA,MAAMC,cAAc,GAA0B;IAC5C,OAAO,EAAE;EACX;EAEA,MAAMC,SAAS,CAACN,IAA0B,EAAEO,OAA+B,EAAE;IAC3E,MAAMC,KAAK,GAAG,MAAM,IAAAC,qBAAU,EAACT,IAAI,CAACQ,KAAK,EAAE,MAAOE,IAAI,IAAK;MACzD,MAAMC,UAAU,GAAGJ,OAAO,CAACK,aAAa,CAACF,IAAI,CAAC;MAC9C,OAAOC,UAAU;IACnB,CAAC,CAAC;IACF,MAAME,QAAQ,GAAGN,OAAO,CAACO,WAAW,CAACd,IAAI,CAAC;IAC1C,OAAO,KAAIe,2CAAsB,EAACF,QAAQ,EAAEL,KAAK,CAAC;EACpD;AACF;AAAC"}

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

@@ -0,0 +1,13 @@
+import { Node } from 'typescript';
+import { KeywordTypeSchema } from '@teambit/semantics.entities.semantic-schema';
+import { SchemaTransformer } from '../schema-transformer';
+import { SchemaExtractorContext } from '../schema-extractor-context';
+import { Identifier } from '../identifier';
+/**
+ * whether it's kind of `ts.KeywordTypeSyntaxKind`
+ */
+export declare class KeywordTypeTransformer implements SchemaTransformer {
+    predicate(node: Node): boolean;
+    getIdentifiers(): Promise<Identifier[]>;
+    transform(node: Node, context: SchemaExtractorContext): Promise<KeywordTypeSchema>;
+}