You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
664 lines
16 KiB
664 lines
16 KiB
"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, true);
|
|
this.tokenChar(91);
|
|
this.tokenChar(93);
|
|
}
|
|
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.tokenChar(37);
|
|
this.word("checks");
|
|
}
|
|
function DeclaredPredicate(node) {
|
|
this.tokenChar(37);
|
|
this.word("checks");
|
|
this.tokenChar(40);
|
|
this.print(node.value, node);
|
|
this.tokenChar(41);
|
|
}
|
|
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.tokenChar(46);
|
|
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.call(this, node);
|
|
}
|
|
function DeclareExportAllDeclaration(node) {
|
|
this.word("declare");
|
|
this.space();
|
|
_modules.ExportAllDeclaration.call(this, node);
|
|
}
|
|
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.tokenChar(44);
|
|
}
|
|
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.tokenChar(123);
|
|
if (node.specifiers.length) {
|
|
this.space();
|
|
this.printList(node.specifiers, node);
|
|
this.space();
|
|
}
|
|
this.tokenChar(125);
|
|
if (node.source) {
|
|
this.space();
|
|
this.word("from");
|
|
this.space();
|
|
this.print(node.source, node);
|
|
}
|
|
this.semicolon();
|
|
}
|
|
}
|
|
function ExistsTypeAnnotation() {
|
|
this.tokenChar(42);
|
|
}
|
|
function FunctionTypeAnnotation(node, parent) {
|
|
this.print(node.typeParameters, node);
|
|
this.tokenChar(40);
|
|
if (node.this) {
|
|
this.word("this");
|
|
this.tokenChar(58);
|
|
this.space();
|
|
this.print(node.this.typeAnnotation, node);
|
|
if (node.params.length || node.rest) {
|
|
this.tokenChar(44);
|
|
this.space();
|
|
}
|
|
}
|
|
this.printList(node.params, node);
|
|
if (node.rest) {
|
|
if (node.params.length) {
|
|
this.tokenChar(44);
|
|
this.space();
|
|
}
|
|
this.token("...");
|
|
this.print(node.rest, node);
|
|
}
|
|
this.tokenChar(41);
|
|
|
|
if (parent && (parent.type === "ObjectTypeCallProperty" || parent.type === "ObjectTypeInternalSlot" || parent.type === "DeclareFunction" || parent.type === "ObjectTypeProperty" && parent.method)) {
|
|
this.tokenChar(58);
|
|
} else {
|
|
this.space();
|
|
this.token("=>");
|
|
}
|
|
this.space();
|
|
this.print(node.returnType, node);
|
|
}
|
|
function FunctionTypeParam(node) {
|
|
this.print(node.name, node);
|
|
if (node.optional) this.tokenChar(63);
|
|
if (node.name) {
|
|
this.tokenChar(58);
|
|
this.space();
|
|
}
|
|
this.print(node.typeAnnotation, node);
|
|
}
|
|
function InterfaceExtends(node) {
|
|
this.print(node.id, node);
|
|
this.print(node.typeParameters, node, true);
|
|
}
|
|
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.tokenChar(43);
|
|
} else if (node.variance.kind === "minus") {
|
|
this.tokenChar(45);
|
|
}
|
|
}
|
|
}
|
|
function InterfaceDeclaration(node) {
|
|
this.word("interface");
|
|
this.space();
|
|
this._interfaceish(node);
|
|
}
|
|
function andSeparator() {
|
|
this.space();
|
|
this.tokenChar(38);
|
|
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.tokenChar(63);
|
|
this.print(node.typeAnnotation, node);
|
|
}
|
|
function NumberTypeAnnotation() {
|
|
this.word("number");
|
|
}
|
|
function StringTypeAnnotation() {
|
|
this.word("string");
|
|
}
|
|
function ThisTypeAnnotation() {
|
|
this.word("this");
|
|
}
|
|
function TupleTypeAnnotation(node) {
|
|
this.tokenChar(91);
|
|
this.printList(node.types, node);
|
|
this.tokenChar(93);
|
|
}
|
|
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.tokenChar(61);
|
|
this.space();
|
|
this.print(node.right, node);
|
|
this.semicolon();
|
|
}
|
|
function TypeAnnotation(node) {
|
|
this.tokenChar(58);
|
|
this.space();
|
|
if (node.optional) this.tokenChar(63);
|
|
this.print(node.typeAnnotation, node);
|
|
}
|
|
function TypeParameterInstantiation(node) {
|
|
this.tokenChar(60);
|
|
this.printList(node.params, node, {});
|
|
this.tokenChar(62);
|
|
}
|
|
function TypeParameter(node) {
|
|
this._variance(node);
|
|
this.word(node.name);
|
|
if (node.bound) {
|
|
this.print(node.bound, node);
|
|
}
|
|
if (node.default) {
|
|
this.space();
|
|
this.tokenChar(61);
|
|
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.tokenChar(58);
|
|
this.space();
|
|
this.print(node.supertype, node);
|
|
}
|
|
if (node.impltype) {
|
|
this.space();
|
|
this.tokenChar(61);
|
|
this.space();
|
|
this.print(node.impltype, node);
|
|
}
|
|
this.semicolon();
|
|
}
|
|
function ObjectTypeAnnotation(node) {
|
|
if (node.exact) {
|
|
this.token("{|");
|
|
} else {
|
|
this.tokenChar(123);
|
|
}
|
|
|
|
const props = [...node.properties, ...(node.callProperties || []), ...(node.indexers || []), ...(node.internalSlots || [])];
|
|
if (props.length) {
|
|
this.newline();
|
|
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.tokenChar(44);
|
|
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.tokenChar(125);
|
|
}
|
|
}
|
|
function ObjectTypeInternalSlot(node) {
|
|
if (node.static) {
|
|
this.word("static");
|
|
this.space();
|
|
}
|
|
this.tokenChar(91);
|
|
this.tokenChar(91);
|
|
this.print(node.id, node);
|
|
this.tokenChar(93);
|
|
this.tokenChar(93);
|
|
if (node.optional) this.tokenChar(63);
|
|
if (!node.method) {
|
|
this.tokenChar(58);
|
|
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.tokenChar(91);
|
|
if (node.id) {
|
|
this.print(node.id, node);
|
|
this.tokenChar(58);
|
|
this.space();
|
|
}
|
|
this.print(node.key, node);
|
|
this.tokenChar(93);
|
|
this.tokenChar(58);
|
|
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.tokenChar(63);
|
|
if (!node.method) {
|
|
this.tokenChar(58);
|
|
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.tokenChar(46);
|
|
this.print(node.id, node);
|
|
}
|
|
function SymbolTypeAnnotation() {
|
|
this.word("symbol");
|
|
}
|
|
function orSeparator() {
|
|
this.space();
|
|
this.tokenChar(124);
|
|
this.space();
|
|
}
|
|
function UnionTypeAnnotation(node) {
|
|
this.printJoin(node.types, node, {
|
|
separator: orSeparator
|
|
});
|
|
}
|
|
function TypeCastExpression(node) {
|
|
this.tokenChar(40);
|
|
this.print(node.expression, node);
|
|
this.print(node.typeAnnotation, node);
|
|
this.tokenChar(41);
|
|
}
|
|
function Variance(node) {
|
|
if (node.kind === "plus") {
|
|
this.tokenChar(43);
|
|
} else {
|
|
this.tokenChar(45);
|
|
}
|
|
}
|
|
function VoidTypeAnnotation() {
|
|
this.word("void");
|
|
}
|
|
function IndexedAccessType(node) {
|
|
this.print(node.objectType, node, true);
|
|
this.tokenChar(91);
|
|
this.print(node.indexType, node);
|
|
this.tokenChar(93);
|
|
}
|
|
function OptionalIndexedAccessType(node) {
|
|
this.print(node.objectType, node);
|
|
if (node.optional) {
|
|
this.token("?.");
|
|
}
|
|
this.tokenChar(91);
|
|
this.print(node.indexType, node);
|
|
this.tokenChar(93);
|
|
}
|
|
|
|
//# sourceMappingURL=flow.js.map
|