| "use strict"; |
| |
| Object.defineProperty(exports, "__esModule", { |
| value: true |
| }); |
| exports.AnyTypeAnnotation = AnyTypeAnnotation; |
| exports.ArrayTypeAnnotation = ArrayTypeAnnotation; |
| exports.BooleanLiteralTypeAnnotation = BooleanLiteralTypeAnnotation; |
| exports.BooleanTypeAnnotation = BooleanTypeAnnotation; |
| exports.DeclareClass = DeclareClass; |
| exports.DeclareExportAllDeclaration = DeclareExportAllDeclaration; |
| exports.DeclareExportDeclaration = DeclareExportDeclaration; |
| exports.DeclareFunction = DeclareFunction; |
| exports.DeclareInterface = DeclareInterface; |
| exports.DeclareModule = DeclareModule; |
| exports.DeclareModuleExports = DeclareModuleExports; |
| exports.DeclareOpaqueType = DeclareOpaqueType; |
| exports.DeclareTypeAlias = DeclareTypeAlias; |
| exports.DeclareVariable = DeclareVariable; |
| exports.DeclaredPredicate = DeclaredPredicate; |
| exports.EmptyTypeAnnotation = EmptyTypeAnnotation; |
| exports.EnumBooleanBody = EnumBooleanBody; |
| exports.EnumBooleanMember = EnumBooleanMember; |
| exports.EnumDeclaration = EnumDeclaration; |
| exports.EnumDefaultedMember = EnumDefaultedMember; |
| exports.EnumNumberBody = EnumNumberBody; |
| exports.EnumNumberMember = EnumNumberMember; |
| exports.EnumStringBody = EnumStringBody; |
| exports.EnumStringMember = EnumStringMember; |
| exports.EnumSymbolBody = EnumSymbolBody; |
| exports.ExistsTypeAnnotation = ExistsTypeAnnotation; |
| exports.FunctionTypeAnnotation = FunctionTypeAnnotation; |
| exports.FunctionTypeParam = FunctionTypeParam; |
| exports.IndexedAccessType = IndexedAccessType; |
| exports.InferredPredicate = InferredPredicate; |
| exports.InterfaceDeclaration = InterfaceDeclaration; |
| exports.GenericTypeAnnotation = exports.ClassImplements = exports.InterfaceExtends = InterfaceExtends; |
| exports.InterfaceTypeAnnotation = InterfaceTypeAnnotation; |
| exports.IntersectionTypeAnnotation = IntersectionTypeAnnotation; |
| exports.MixedTypeAnnotation = MixedTypeAnnotation; |
| exports.NullLiteralTypeAnnotation = NullLiteralTypeAnnotation; |
| exports.NullableTypeAnnotation = NullableTypeAnnotation; |
| Object.defineProperty(exports, "NumberLiteralTypeAnnotation", { |
| enumerable: true, |
| get: function () { |
| return _types2.NumericLiteral; |
| } |
| }); |
| exports.NumberTypeAnnotation = NumberTypeAnnotation; |
| exports.ObjectTypeAnnotation = ObjectTypeAnnotation; |
| exports.ObjectTypeCallProperty = ObjectTypeCallProperty; |
| exports.ObjectTypeIndexer = ObjectTypeIndexer; |
| exports.ObjectTypeInternalSlot = ObjectTypeInternalSlot; |
| exports.ObjectTypeProperty = ObjectTypeProperty; |
| exports.ObjectTypeSpreadProperty = ObjectTypeSpreadProperty; |
| exports.OpaqueType = OpaqueType; |
| exports.OptionalIndexedAccessType = OptionalIndexedAccessType; |
| exports.QualifiedTypeIdentifier = QualifiedTypeIdentifier; |
| Object.defineProperty(exports, "StringLiteralTypeAnnotation", { |
| enumerable: true, |
| get: function () { |
| return _types2.StringLiteral; |
| } |
| }); |
| exports.StringTypeAnnotation = StringTypeAnnotation; |
| exports.SymbolTypeAnnotation = SymbolTypeAnnotation; |
| exports.ThisTypeAnnotation = ThisTypeAnnotation; |
| exports.TupleTypeAnnotation = TupleTypeAnnotation; |
| exports.TypeAlias = TypeAlias; |
| exports.TypeAnnotation = TypeAnnotation; |
| exports.TypeCastExpression = TypeCastExpression; |
| exports.TypeParameter = TypeParameter; |
| exports.TypeParameterDeclaration = exports.TypeParameterInstantiation = TypeParameterInstantiation; |
| exports.TypeofTypeAnnotation = TypeofTypeAnnotation; |
| exports.UnionTypeAnnotation = UnionTypeAnnotation; |
| exports.Variance = Variance; |
| exports.VoidTypeAnnotation = VoidTypeAnnotation; |
| exports._interfaceish = _interfaceish; |
| exports._variance = _variance; |
| |
| var _t = require("@babel/types"); |
| |
| var _modules = require("./modules"); |
| |
| var _types2 = require("./types"); |
| |
| const { |
| isDeclareExportDeclaration, |
| isStatement |
| } = _t; |
| |
| function AnyTypeAnnotation() { |
| this.word("any"); |
| } |
| |
| function ArrayTypeAnnotation(node) { |
| this.print(node.elementType, node); |
| this.token("["); |
| this.token("]"); |
| } |
| |
| function BooleanTypeAnnotation() { |
| this.word("boolean"); |
| } |
| |
| function BooleanLiteralTypeAnnotation(node) { |
| this.word(node.value ? "true" : "false"); |
| } |
| |
| function NullLiteralTypeAnnotation() { |
| this.word("null"); |
| } |
| |
| function DeclareClass(node, parent) { |
| if (!isDeclareExportDeclaration(parent)) { |
| this.word("declare"); |
| this.space(); |
| } |
| |
| this.word("class"); |
| this.space(); |
| |
| this._interfaceish(node); |
| } |
| |
| function DeclareFunction(node, parent) { |
| if (!isDeclareExportDeclaration(parent)) { |
| this.word("declare"); |
| this.space(); |
| } |
| |
| this.word("function"); |
| this.space(); |
| this.print(node.id, node); |
| this.print(node.id.typeAnnotation.typeAnnotation, node); |
| |
| if (node.predicate) { |
| this.space(); |
| this.print(node.predicate, node); |
| } |
| |
| this.semicolon(); |
| } |
| |
| function InferredPredicate() { |
| this.token("%"); |
| this.word("checks"); |
| } |
| |
| function DeclaredPredicate(node) { |
| this.token("%"); |
| this.word("checks"); |
| this.token("("); |
| this.print(node.value, node); |
| this.token(")"); |
| } |
| |
| function DeclareInterface(node) { |
| this.word("declare"); |
| this.space(); |
| this.InterfaceDeclaration(node); |
| } |
| |
| function DeclareModule(node) { |
| this.word("declare"); |
| this.space(); |
| this.word("module"); |
| this.space(); |
| this.print(node.id, node); |
| this.space(); |
| this.print(node.body, node); |
| } |
| |
| function DeclareModuleExports(node) { |
| this.word("declare"); |
| this.space(); |
| this.word("module"); |
| this.token("."); |
| this.word("exports"); |
| this.print(node.typeAnnotation, node); |
| } |
| |
| function DeclareTypeAlias(node) { |
| this.word("declare"); |
| this.space(); |
| this.TypeAlias(node); |
| } |
| |
| function DeclareOpaqueType(node, parent) { |
| if (!isDeclareExportDeclaration(parent)) { |
| this.word("declare"); |
| this.space(); |
| } |
| |
| this.OpaqueType(node); |
| } |
| |
| function DeclareVariable(node, parent) { |
| if (!isDeclareExportDeclaration(parent)) { |
| this.word("declare"); |
| this.space(); |
| } |
| |
| this.word("var"); |
| this.space(); |
| this.print(node.id, node); |
| this.print(node.id.typeAnnotation, node); |
| this.semicolon(); |
| } |
| |
| function DeclareExportDeclaration(node) { |
| this.word("declare"); |
| this.space(); |
| this.word("export"); |
| this.space(); |
| |
| if (node.default) { |
| this.word("default"); |
| this.space(); |
| } |
| |
| FlowExportDeclaration.apply(this, arguments); |
| } |
| |
| function DeclareExportAllDeclaration() { |
| this.word("declare"); |
| this.space(); |
| |
| _modules.ExportAllDeclaration.apply(this, arguments); |
| } |
| |
| function EnumDeclaration(node) { |
| const { |
| id, |
| body |
| } = node; |
| this.word("enum"); |
| this.space(); |
| this.print(id, node); |
| this.print(body, node); |
| } |
| |
| function enumExplicitType(context, name, hasExplicitType) { |
| if (hasExplicitType) { |
| context.space(); |
| context.word("of"); |
| context.space(); |
| context.word(name); |
| } |
| |
| context.space(); |
| } |
| |
| function enumBody(context, node) { |
| const { |
| members |
| } = node; |
| context.token("{"); |
| context.indent(); |
| context.newline(); |
| |
| for (const member of members) { |
| context.print(member, node); |
| context.newline(); |
| } |
| |
| if (node.hasUnknownMembers) { |
| context.token("..."); |
| context.newline(); |
| } |
| |
| context.dedent(); |
| context.token("}"); |
| } |
| |
| function EnumBooleanBody(node) { |
| const { |
| explicitType |
| } = node; |
| enumExplicitType(this, "boolean", explicitType); |
| enumBody(this, node); |
| } |
| |
| function EnumNumberBody(node) { |
| const { |
| explicitType |
| } = node; |
| enumExplicitType(this, "number", explicitType); |
| enumBody(this, node); |
| } |
| |
| function EnumStringBody(node) { |
| const { |
| explicitType |
| } = node; |
| enumExplicitType(this, "string", explicitType); |
| enumBody(this, node); |
| } |
| |
| function EnumSymbolBody(node) { |
| enumExplicitType(this, "symbol", true); |
| enumBody(this, node); |
| } |
| |
| function EnumDefaultedMember(node) { |
| const { |
| id |
| } = node; |
| this.print(id, node); |
| this.token(","); |
| } |
| |
| function enumInitializedMember(context, node) { |
| const { |
| id, |
| init |
| } = node; |
| context.print(id, node); |
| context.space(); |
| context.token("="); |
| context.space(); |
| context.print(init, node); |
| context.token(","); |
| } |
| |
| function EnumBooleanMember(node) { |
| enumInitializedMember(this, node); |
| } |
| |
| function EnumNumberMember(node) { |
| enumInitializedMember(this, node); |
| } |
| |
| function EnumStringMember(node) { |
| enumInitializedMember(this, node); |
| } |
| |
| function FlowExportDeclaration(node) { |
| if (node.declaration) { |
| const declar = node.declaration; |
| this.print(declar, node); |
| if (!isStatement(declar)) this.semicolon(); |
| } else { |
| this.token("{"); |
| |
| if (node.specifiers.length) { |
| this.space(); |
| this.printList(node.specifiers, node); |
| this.space(); |
| } |
| |
| this.token("}"); |
| |
| if (node.source) { |
| this.space(); |
| this.word("from"); |
| this.space(); |
| this.print(node.source, node); |
| } |
| |
| this.semicolon(); |
| } |
| } |
| |
| function ExistsTypeAnnotation() { |
| this.token("*"); |
| } |
| |
| function FunctionTypeAnnotation(node, parent) { |
| this.print(node.typeParameters, node); |
| this.token("("); |
| |
| if (node.this) { |
| this.word("this"); |
| this.token(":"); |
| this.space(); |
| this.print(node.this.typeAnnotation, node); |
| |
| if (node.params.length || node.rest) { |
| this.token(","); |
| this.space(); |
| } |
| } |
| |
| this.printList(node.params, node); |
| |
| if (node.rest) { |
| if (node.params.length) { |
| this.token(","); |
| this.space(); |
| } |
| |
| this.token("..."); |
| this.print(node.rest, node); |
| } |
| |
| this.token(")"); |
| |
| if (parent && (parent.type === "ObjectTypeCallProperty" || parent.type === "DeclareFunction" || parent.type === "ObjectTypeProperty" && parent.method)) { |
| this.token(":"); |
| } else { |
| this.space(); |
| this.token("=>"); |
| } |
| |
| this.space(); |
| this.print(node.returnType, node); |
| } |
| |
| function FunctionTypeParam(node) { |
| this.print(node.name, node); |
| if (node.optional) this.token("?"); |
| |
| if (node.name) { |
| this.token(":"); |
| this.space(); |
| } |
| |
| this.print(node.typeAnnotation, node); |
| } |
| |
| function InterfaceExtends(node) { |
| this.print(node.id, node); |
| this.print(node.typeParameters, node); |
| } |
| |
| function _interfaceish(node) { |
| var _node$extends; |
| |
| this.print(node.id, node); |
| this.print(node.typeParameters, node); |
| |
| if ((_node$extends = node.extends) != null && _node$extends.length) { |
| this.space(); |
| this.word("extends"); |
| this.space(); |
| this.printList(node.extends, node); |
| } |
| |
| if (node.mixins && node.mixins.length) { |
| this.space(); |
| this.word("mixins"); |
| this.space(); |
| this.printList(node.mixins, node); |
| } |
| |
| if (node.implements && node.implements.length) { |
| this.space(); |
| this.word("implements"); |
| this.space(); |
| this.printList(node.implements, node); |
| } |
| |
| this.space(); |
| this.print(node.body, node); |
| } |
| |
| function _variance(node) { |
| if (node.variance) { |
| if (node.variance.kind === "plus") { |
| this.token("+"); |
| } else if (node.variance.kind === "minus") { |
| this.token("-"); |
| } |
| } |
| } |
| |
| function InterfaceDeclaration(node) { |
| this.word("interface"); |
| this.space(); |
| |
| this._interfaceish(node); |
| } |
| |
| function andSeparator() { |
| this.space(); |
| this.token("&"); |
| this.space(); |
| } |
| |
| function InterfaceTypeAnnotation(node) { |
| this.word("interface"); |
| |
| if (node.extends && node.extends.length) { |
| this.space(); |
| this.word("extends"); |
| this.space(); |
| this.printList(node.extends, node); |
| } |
| |
| this.space(); |
| this.print(node.body, node); |
| } |
| |
| function IntersectionTypeAnnotation(node) { |
| this.printJoin(node.types, node, { |
| separator: andSeparator |
| }); |
| } |
| |
| function MixedTypeAnnotation() { |
| this.word("mixed"); |
| } |
| |
| function EmptyTypeAnnotation() { |
| this.word("empty"); |
| } |
| |
| function NullableTypeAnnotation(node) { |
| this.token("?"); |
| this.print(node.typeAnnotation, node); |
| } |
| |
| function NumberTypeAnnotation() { |
| this.word("number"); |
| } |
| |
| function StringTypeAnnotation() { |
| this.word("string"); |
| } |
| |
| function ThisTypeAnnotation() { |
| this.word("this"); |
| } |
| |
| function TupleTypeAnnotation(node) { |
| this.token("["); |
| this.printList(node.types, node); |
| this.token("]"); |
| } |
| |
| function TypeofTypeAnnotation(node) { |
| this.word("typeof"); |
| this.space(); |
| this.print(node.argument, node); |
| } |
| |
| function TypeAlias(node) { |
| this.word("type"); |
| this.space(); |
| this.print(node.id, node); |
| this.print(node.typeParameters, node); |
| this.space(); |
| this.token("="); |
| this.space(); |
| this.print(node.right, node); |
| this.semicolon(); |
| } |
| |
| function TypeAnnotation(node) { |
| this.token(":"); |
| this.space(); |
| if (node.optional) this.token("?"); |
| this.print(node.typeAnnotation, node); |
| } |
| |
| function TypeParameterInstantiation(node) { |
| this.token("<"); |
| this.printList(node.params, node, {}); |
| this.token(">"); |
| } |
| |
| function TypeParameter(node) { |
| this._variance(node); |
| |
| this.word(node.name); |
| |
| if (node.bound) { |
| this.print(node.bound, node); |
| } |
| |
| if (node.default) { |
| this.space(); |
| this.token("="); |
| this.space(); |
| this.print(node.default, node); |
| } |
| } |
| |
| function OpaqueType(node) { |
| this.word("opaque"); |
| this.space(); |
| this.word("type"); |
| this.space(); |
| this.print(node.id, node); |
| this.print(node.typeParameters, node); |
| |
| if (node.supertype) { |
| this.token(":"); |
| this.space(); |
| this.print(node.supertype, node); |
| } |
| |
| if (node.impltype) { |
| this.space(); |
| this.token("="); |
| this.space(); |
| this.print(node.impltype, node); |
| } |
| |
| this.semicolon(); |
| } |
| |
| function ObjectTypeAnnotation(node) { |
| if (node.exact) { |
| this.token("{|"); |
| } else { |
| this.token("{"); |
| } |
| |
| const props = [...node.properties, ...(node.callProperties || []), ...(node.indexers || []), ...(node.internalSlots || [])]; |
| |
| if (props.length) { |
| this.space(); |
| this.printJoin(props, node, { |
| addNewlines(leading) { |
| if (leading && !props[0]) return 1; |
| }, |
| |
| indent: true, |
| statement: true, |
| iterator: () => { |
| if (props.length !== 1 || node.inexact) { |
| this.token(","); |
| this.space(); |
| } |
| } |
| }); |
| this.space(); |
| } |
| |
| if (node.inexact) { |
| this.indent(); |
| this.token("..."); |
| |
| if (props.length) { |
| this.newline(); |
| } |
| |
| this.dedent(); |
| } |
| |
| if (node.exact) { |
| this.token("|}"); |
| } else { |
| this.token("}"); |
| } |
| } |
| |
| function ObjectTypeInternalSlot(node) { |
| if (node.static) { |
| this.word("static"); |
| this.space(); |
| } |
| |
| this.token("["); |
| this.token("["); |
| this.print(node.id, node); |
| this.token("]"); |
| this.token("]"); |
| if (node.optional) this.token("?"); |
| |
| if (!node.method) { |
| this.token(":"); |
| this.space(); |
| } |
| |
| this.print(node.value, node); |
| } |
| |
| function ObjectTypeCallProperty(node) { |
| if (node.static) { |
| this.word("static"); |
| this.space(); |
| } |
| |
| this.print(node.value, node); |
| } |
| |
| function ObjectTypeIndexer(node) { |
| if (node.static) { |
| this.word("static"); |
| this.space(); |
| } |
| |
| this._variance(node); |
| |
| this.token("["); |
| |
| if (node.id) { |
| this.print(node.id, node); |
| this.token(":"); |
| this.space(); |
| } |
| |
| this.print(node.key, node); |
| this.token("]"); |
| this.token(":"); |
| this.space(); |
| this.print(node.value, node); |
| } |
| |
| function ObjectTypeProperty(node) { |
| if (node.proto) { |
| this.word("proto"); |
| this.space(); |
| } |
| |
| if (node.static) { |
| this.word("static"); |
| this.space(); |
| } |
| |
| if (node.kind === "get" || node.kind === "set") { |
| this.word(node.kind); |
| this.space(); |
| } |
| |
| this._variance(node); |
| |
| this.print(node.key, node); |
| if (node.optional) this.token("?"); |
| |
| if (!node.method) { |
| this.token(":"); |
| this.space(); |
| } |
| |
| this.print(node.value, node); |
| } |
| |
| function ObjectTypeSpreadProperty(node) { |
| this.token("..."); |
| this.print(node.argument, node); |
| } |
| |
| function QualifiedTypeIdentifier(node) { |
| this.print(node.qualification, node); |
| this.token("."); |
| this.print(node.id, node); |
| } |
| |
| function SymbolTypeAnnotation() { |
| this.word("symbol"); |
| } |
| |
| function orSeparator() { |
| this.space(); |
| this.token("|"); |
| this.space(); |
| } |
| |
| function UnionTypeAnnotation(node) { |
| this.printJoin(node.types, node, { |
| separator: orSeparator |
| }); |
| } |
| |
| function TypeCastExpression(node) { |
| this.token("("); |
| this.print(node.expression, node); |
| this.print(node.typeAnnotation, node); |
| this.token(")"); |
| } |
| |
| function Variance(node) { |
| if (node.kind === "plus") { |
| this.token("+"); |
| } else { |
| this.token("-"); |
| } |
| } |
| |
| function VoidTypeAnnotation() { |
| this.word("void"); |
| } |
| |
| function IndexedAccessType(node) { |
| this.print(node.objectType, node); |
| this.token("["); |
| this.print(node.indexType, node); |
| this.token("]"); |
| } |
| |
| function OptionalIndexedAccessType(node) { |
| this.print(node.objectType, node); |
| |
| if (node.optional) { |
| this.token("?."); |
| } |
| |
| this.token("["); |
| this.print(node.indexType, node); |
| this.token("]"); |
| } |