codtracker-js/node_modules/@babel/generator/lib/generators/flow.js

'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(']');
}