@teambit/typescript 0.0.0-004aea01bc027e428dfd0f6583f49a1b8286bdd0

package/dist/transformers/index.js

@@ -0,0 +1,566 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "ArrayLiteralExpressionTransformer", {
+  enumerable: true,
+  get: function () {
+    return _arrayLiteralExpression().ArrayLiteralExpressionTransformer;
+  }
+});
+Object.defineProperty(exports, "ArrayTypeTransformer", {
+  enumerable: true,
+  get: function () {
+    return _arrayType().ArrayTypeTransformer;
+  }
+});
+Object.defineProperty(exports, "BindingElementTransformer", {
+  enumerable: true,
+  get: function () {
+    return _bindingElement().BindingElementTransformer;
+  }
+});
+Object.defineProperty(exports, "ClassDeclarationTransformer", {
+  enumerable: true,
+  get: function () {
+    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, "DecoratorTransformer", {
+  enumerable: true,
+  get: function () {
+    return _decorator().DecoratorTransformer;
+  }
+});
+Object.defineProperty(exports, "EnumDeclarationTransformer", {
+  enumerable: true,
+  get: function () {
+    return _enumDeclaration().EnumDeclarationTransformer;
+  }
+});
+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, "ExpressionStatementTransformer", {
+  enumerable: true,
+  get: function () {
+    return _expressionStatement().ExpressionStatementTransformer;
+  }
+});
+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 _importDeclaration().ImportDeclarationTransformer;
+  }
+});
+Object.defineProperty(exports, "IndexSignatureTransformer", {
+  enumerable: true,
+  get: function () {
+    return _indexSignature().IndexSignatureTransformer;
+  }
+});
+Object.defineProperty(exports, "IndexedAccessTypeTransformer", {
+  enumerable: true,
+  get: function () {
+    return _indexedAccessType().IndexedAccessTypeTransformer;
+  }
+});
+Object.defineProperty(exports, "InterfaceDeclarationTransformer", {
+  enumerable: true,
+  get: function () {
+    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, "LiteralValueTransformer", {
+  enumerable: true,
+  get: function () {
+    return _literalValue().LiteralValueTransformer;
+  }
+});
+Object.defineProperty(exports, "ModuleDeclarationTransformer", {
+  enumerable: true,
+  get: function () {
+    return _moduleDeclaration().ModuleDeclarationTransformer;
+  }
+});
+Object.defineProperty(exports, "NamedTupleTransformer", {
+  enumerable: true,
+  get: function () {
+    return _namedTuple().NamedTupleTransformer;
+  }
+});
+Object.defineProperty(exports, "ObjectLiteralExpressionTransformer", {
+  enumerable: true,
+  get: function () {
+    return _objectLiteralExpression().ObjectLiteralExpressionTransformer;
+  }
+});
+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, "PropertyAssignmentTransformer", {
+  enumerable: true,
+  get: function () {
+    return _propertyAssignment().PropertyAssignmentTransformer;
+  }
+});
+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 () {
+    return _variableDeclaration().VariableDeclaration;
+  }
+});
+Object.defineProperty(exports, "VariableStatementTransformer", {
+  enumerable: true,
+  get: function () {
+    return _variableStatement().VariableStatementTransformer;
+  }
+});
+function _exportDeclaration() {
+  const data = require("./export-declaration");
+  _exportDeclaration = function () {
+    return data;
+  };
+  return data;
+}
+function _functionLike() {
+  const data = require("./function-like");
+  _functionLike = function () {
+    return data;
+  };
+  return data;
+}
+function _parameter() {
+  const data = require("./parameter");
+  _parameter = function () {
+    return data;
+  };
+  return data;
+}
+function _variableStatement() {
+  const data = require("./variable-statement");
+  _variableStatement = function () {
+    return data;
+  };
+  return data;
+}
+function _variableDeclaration() {
+  const data = require("./variable-declaration");
+  _variableDeclaration = function () {
+    return data;
+  };
+  return data;
+}
+function _sourceFileTransformer() {
+  const data = require("./source-file-transformer");
+  _sourceFileTransformer = function () {
+    return data;
+  };
+  return data;
+}
+function _typeAlias() {
+  const data = require("./type-alias");
+  _typeAlias = function () {
+    return data;
+  };
+  return data;
+}
+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 () {
+    return data;
+  };
+  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 () {
+    return data;
+  };
+  return data;
+}
+function _enumDeclaration() {
+  const data = require("./enum-declaration");
+  _enumDeclaration = function () {
+    return data;
+  };
+  return data;
+}
+function _bindingElement() {
+  const data = require("./binding-element");
+  _bindingElement = function () {
+    return data;
+  };
+  return data;
+}
+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;
+}
+function _expressionStatement() {
+  const data = require("./expression-statement");
+  _expressionStatement = function () {
+    return data;
+  };
+  return data;
+}
+function _moduleDeclaration() {
+  const data = require("./module-declaration");
+  _moduleDeclaration = function () {
+    return data;
+  };
+  return data;
+}
+function _decorator() {
+  const data = require("./decorator");
+  _decorator = function () {
+    return data;
+  };
+  return data;
+}
+function _arrayLiteralExpression() {
+  const data = require("./array-literal-expression");
+  _arrayLiteralExpression = function () {
+    return data;
+  };
+  return data;
+}
+function _objectLiteralExpression() {
+  const data = require("./object-literal-expression");
+  _objectLiteralExpression = function () {
+    return data;
+  };
+  return data;
+}
+function _propertyAssignment() {
+  const data = require("./property-assignment");
+  _propertyAssignment = function () {
+    return data;
+  };
+  return data;
+}
+function _literalValue() {
+  const data = require("./literal-value");
+  _literalValue = function () {
+    return data;
+  };
+  return data;
+}
+
+//# sourceMappingURL=index.js.map

package/dist/transformers/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_exportDeclaration","data","require","_functionLike","_parameter","_variableStatement","_variableDeclaration","_sourceFileTransformer","_typeAlias","_intersectionType","_unionType","_typeReference","_typeLiteral","_literalType","_typeQuery","_typeOperator","_keywordType","_tupleType","_parenthesizedType","_typePredicate","_indexedAccessType","_templateLiteralTypeSpan","_templateLiteralType","_thisType","_conditionalType","_namedTuple","_arrayType","_classDeclaration","_constructor","_propertyDeclaration","_setAccessor","_getAccessor","_indexSignature","_interfaceDeclaration","_enumDeclaration","_bindingElement","_exportAssignment","_importDeclaration","_expressionStatement","_moduleDeclaration","_decorator","_arrayLiteralExpression","_objectLiteralExpression","_propertyAssignment","_literalValue"],"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';\nexport { ExpressionStatementTransformer } from './expression-statement';\nexport { ModuleDeclarationTransformer } from './module-declaration';\nexport { DecoratorTransformer } from './decorator';\nexport { ArrayLiteralExpressionTransformer } from './array-literal-expression';\nexport { ObjectLiteralExpressionTransformer } from './object-literal-expression';\nexport { PropertyAssignmentTransformer } from './property-assignment';\nexport { LiteralValueTransformer } from './literal-value';\n"],"mappings":"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","ignoreList":[]}

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

@@ -0,0 +1,10 @@
+import type { IndexedAccessTypeNode, Node } from 'typescript';
+import { IndexedAccessSchema } 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 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,36 @@
+"use strict";
+
+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":["_typescript","data","require","_semanticsEntities","IndexedAccessTypeTransformer","predicate","node","kind","SyntaxKind","IndexedAccessType","getIdentifiers","transform","context","objectType","computeSchema","indexType","IndexedAccessSchema","getLocation","exports"],"sources":["indexed-access-type.ts"],"sourcesContent":["import type { IndexedAccessTypeNode, Node } from 'typescript';\nimport { SyntaxKind } from 'typescript';\nimport { IndexedAccessSchema } 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 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":";;;;;;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,4BAA4B,CAA8B;EACrEC,SAASA,CAACC,IAAU,EAAE;IACpB,OAAOA,IAAI,CAACC,IAAI,KAAKC,wBAAU,CAACC,iBAAiB;EACnD;EAEA,MAAMC,cAAcA,CAAA,EAA0B;IAC5C,OAAO,EAAE;EACX;EAEA,MAAMC,SAASA,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;AAACG,OAAA,CAAAd,4BAAA,GAAAA,4BAAA","ignoreList":[]}

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

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