text: "use strict";
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.printSchema = printSchema;
  exports.printIntrospectionSchema = printIntrospectionSchema;
  exports.printType = printType;
  
  var _isNullish = _interopRequireDefault(require("../jsutils/isNullish"));
  
  var _isInvalid = _interopRequireDefault(require("../jsutils/isInvalid"));
  
  var _objectValues = _interopRequireDefault(require("../jsutils/objectValues"));
  
  var _astFromValue = require("../utilities/astFromValue");
  
  var _printer = require("../language/printer");
  
  var _definition = require("../type/definition");
  
  var _scalars = require("../type/scalars");
  
  var _directives = require("../type/directives");
  
  var _introspection = require("../type/introspection");
  
  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  
  /**
   * Copyright (c) 2015-present, Facebook, Inc.
   *
   * This source code is licensed under the MIT license found in the
   * LICENSE file in the root directory of this source tree.
   *
   *  strict
   */
  
  /**
   * Accepts options as a second argument:
   *
   *    - commentDescriptions:
   *        Provide true to use preceding comments as the description.
   *
   */
  function printSchema(schema, options) {
    return printFilteredSchema(schema, function (n) {
      return !(0, _directives.isSpecifiedDirective)(n);
    }, isDefinedType, options);
  }
  
  function printIntrospectionSchema(schema, options) {
    return printFilteredSchema(schema, _directives.isSpecifiedDirective, _introspection.isIntrospectionType, options);
  }
  
  function isDefinedType(type) {
    return !(0, _scalars.isSpecifiedScalarType)(type) && !(0, _introspection.isIntrospectionType)(type);
  }
  
  function printFilteredSchema(schema, directiveFilter, typeFilter, options) {
    var directives = schema.getDirectives().filter(directiveFilter);
    var typeMap = schema.getTypeMap();
    var types = (0, _objectValues.default)(typeMap).sort(function (type1, type2) {
      return type1.name.localeCompare(type2.name);
    }).filter(typeFilter);
    return [printSchemaDefinition(schema)].concat(directives.map(function (directive) {
      return printDirective(directive, options);
    }), types.map(function (type) {
      return printType(type, options);
    })).filter(Boolean).join('\n\n') + '\n';
  }
  
  function printSchemaDefinition(schema) {
    if (isSchemaOfCommonNames(schema)) {
      return;
    }
  
    var operationTypes = [];
    var queryType = schema.getQueryType();
  
    if (queryType) {
      operationTypes.push("  query: ".concat(queryType.name));
    }
  
    var mutationType = schema.getMutationType();
  
    if (mutationType) {
      operationTypes.push("  mutation: ".concat(mutationType.name));
    }
  
    var subscriptionType = schema.getSubscriptionType();
  
    if (subscriptionType) {
      operationTypes.push("  subscription: ".concat(subscriptionType.name));
    }
  
    return "schema {\n".concat(operationTypes.join('\n'), "\n}");
  }
  /**
   * GraphQL schema define root types for each type of operation. These types are
   * the same as any other type and can be named in any manner, however there is
   * a common naming convention:
   *
   *   schema {
   *     query: Query
   *     mutation: Mutation
   *   }
   *
   * When using this naming convention, the schema description can be omitted.
   */
  
  
  function isSchemaOfCommonNames(schema) {
    var queryType = schema.getQueryType();
  
    if (queryType && queryType.name !== 'Query') {
      return false;
    }
  
    var mutationType = schema.getMutationType();
  
    if (mutationType && mutationType.name !== 'Mutation') {
      return false;
    }
  
    var subscriptionType = schema.getSubscriptionType();
  
    if (subscriptionType && subscriptionType.name !== 'Subscription') {
      return false;
    }
  
    return true;
  }
  
  function printType(type, options) {
    if ((0, _definition.isScalarType)(type)) {
      return printScalar(type, options);
    } else if ((0, _definition.isObjectType)(type)) {
      return printObject(type, options);
    } else if ((0, _definition.isInterfaceType)(type)) {
      return printInterface(type, options);
    } else if ((0, _definition.isUnionType)(type)) {
      return printUnion(type, options);
    } else if ((0, _definition.isEnumType)(type)) {
      return printEnum(type, options);
    } else if ((0, _definition.isInputObjectType)(type)) {
      return printInputObject(type, options);
    }
    /* istanbul ignore next */
  
  
    throw new Error("Unknown type: ".concat(type, "."));
  }
  
  function printScalar(type, options) {
    return printDescription(options, type) + "scalar ".concat(type.name);
  }
  
  function printObject(type, options) {
    var interfaces = type.getInterfaces();
    var implementedInterfaces = interfaces.length ? ' implements ' + interfaces.map(function (i) {
      return i.name;
    }).join(' & ') : '';
    return printDescription(options, type) + "type ".concat(type.name).concat(implementedInterfaces, " {\n") + printFields(options, type) + '\n' + '}';
  }
  
  function printInterface(type, options) {
    return printDescription(options, type) + "interface ".concat(type.name, " {\n") + printFields(options, type) + '\n' + '}';
  }
  
  function printUnion(type, options) {
    return printDescription(options, type) + "union ".concat(type.name, " = ").concat(type.getTypes().join(' | '));
  }
  
  function printEnum(type, options) {
    return printDescription(options, type) + "enum ".concat(type.name, " {\n") + printEnumValues(type.getValues(), options) + '\n' + '}';
  }
  
  function printEnumValues(values, options) {
    return values.map(function (value, i) {
      return printDescription(options, value, '  ', !i) + '  ' + value.name + printDeprecated(value);
    }).join('\n');
  }
  
  function printInputObject(type, options) {
    var fields = (0, _objectValues.default)(type.getFields());
    return printDescription(options, type) + "input ".concat(type.name, " {\n") + fields.map(function (f, i) {
      return printDescription(options, f, '  ', !i) + '  ' + printInputValue(f);
    }).join('\n') + '\n' + '}';
  }
  
  function printFields(options, type) {
    var fields = (0, _objectValues.default)(type.getFields());
    return fields.map(function (f, i) {
      return printDescription(options, f, '  ', !i) + '  ' + f.name + printArgs(options, f.args, '  ') + ': ' + String(f.type) + printDeprecated(f);
    }).join('\n');
  }
  
  function printArgs(options, args) {
    var indentation = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '';
  
    if (args.length === 0) {
      return '';
    } // If every arg does not have a description, print them on one line.
  
  
    if (args.every(function (arg) {
      return !arg.description;
    })) {
      return '(' + args.map(printInputValue).join(', ') + ')';
    }
  
    return '(\n' + args.map(function (arg, i) {
      return printDescription(options, arg, '  ' + indentation, !i) + '  ' + indentation + printInputValue(arg);
    }).join('\n') + '\n' + indentation + ')';
  }
  
  function printInputValue(arg) {
    var argDecl = arg.name + ': ' + String(arg.type);
  
    if (!(0, _isInvalid.default)(arg.defaultValue)) {
      argDecl += " = ".concat((0, _printer.print)((0, _astFromValue.astFromValue)(arg.defaultValue, arg.type)));
    }
  
    return argDecl;
  }
  
  function printDirective(directive, options) {
    return printDescription(options, directive) + 'directive @' + directive.name + printArgs(options, directive.args) + ' on ' + directive.locations.join(' | ');
  }
  
  function printDeprecated(fieldOrEnumVal) {
    if (!fieldOrEnumVal.isDeprecated) {
      return '';
    }
  
    var reason = fieldOrEnumVal.deprecationReason;
  
    if ((0, _isNullish.default)(reason) || reason === '' || reason === _directives.DEFAULT_DEPRECATION_REASON) {
      return ' @deprecated';
    }
  
    return ' @deprecated(reason: ' + (0, _printer.print)((0, _astFromValue.astFromValue)(reason, _scalars.GraphQLString)) + ')';
  }
  
  function printDescription(options, def) {
    var indentation = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '';
    var firstInBlock = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : true;
  
    if (!def.description) {
      return '';
    }
  
    var lines = descriptionLines(def.description, 120 - indentation.length);
  
    if (options && options.commentDescriptions) {
      return printDescriptionWithComments(lines, indentation, firstInBlock);
    }
  
    var description = indentation && !firstInBlock ? '\n' + indentation + '"""' : indentation + '"""'; // In some circumstances, a single line can be used for the description.
  
    if (lines.length === 1 && lines[0].length < 70 && lines[0][lines[0].length - 1] !== '"') {
      return description + escapeQuote(lines[0]) + '"""\n';
    } // Format a multi-line block quote to account for leading space.
  
  
    var hasLeadingSpace = lines[0][0] === ' ' || lines[0][0] === '\t';
  
    if (!hasLeadingSpace) {
      description += '\n';
    }
  
    for (var i = 0; i < lines.length; i++) {
      if (i !== 0 || !hasLeadingSpace) {
        description += indentation;
      }
  
      description += escapeQuote(lines[i]) + '\n';
    }
  
    description += indentation + '"""\n';
    return description;
  }
  
  function escapeQuote(line) {
    return line.replace(/"""/g, '\\"""');
  }
  
  function printDescriptionWithComments(lines, indentation, firstInBlock) {
    var description = indentation && !firstInBlock ? '\n' : '';
  
    for (var i = 0; i < lines.length; i++) {
      if (lines[i] === '') {
        description += indentation + '#\n';
      } else {
        description += indentation + '# ' + lines[i] + '\n';
      }
    }
  
    return description;
  }
  
  function descriptionLines(description, maxLen) {
    var lines = [];
    var rawLines = description.split('\n');
  
    for (var i = 0; i < rawLines.length; i++) {
      if (rawLines[i] === '') {
        lines.push(rawLines[i]);
      } else {
        // For > 120 character long lines, cut at space boundaries into sublines
        // of ~80 chars.
        var sublines = breakLine(rawLines[i], maxLen);
  
        for (var j = 0; j < sublines.length; j++) {
          lines.push(sublines[j]);
        }
      }
    }
  
    return lines;
  }
  
  function breakLine(line, maxLen) {
    if (line.length < maxLen + 5) {
      return [line];
    }
  
    var parts = line.split(new RegExp("((?: |^).{15,".concat(maxLen - 40, "}(?= |$))")));
  
    if (parts.length < 4) {
      return [line];
    }
  
    var sublines = [parts[0] + parts[1] + parts[2]];
  
    for (var i = 3; i < parts.length; i += 2) {
      sublines.push(parts[i].slice(1) + parts[i + 1]);
    }
  
    return sublines;
  }