text: "use strict";
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.ValidationContext = exports.SDLValidationContext = exports.ASTValidationContext = void 0;
  
  var _visitor = require("../language/visitor");
  
  var _kinds = require("../language/kinds");
  
  var _TypeInfo = require("../utilities/TypeInfo");
  
  function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; subClass.__proto__ = superClass; }
  
  /**
   * An instance of this class is passed as the "this" context to all validators,
   * allowing access to commonly useful contextual information from within a
   * validation rule.
   */
  var ASTValidationContext =
  /*#__PURE__*/
  function () {
    function ASTValidationContext(ast) {
      this._ast = ast;
      this._errors = [];
      this._fragments = undefined;
      this._fragmentSpreads = new Map();
      this._recursivelyReferencedFragments = new Map();
    }
  
    var _proto = ASTValidationContext.prototype;
  
    _proto.reportError = function reportError(error) {
      this._errors.push(error);
    };
  
    _proto.getErrors = function getErrors() {
      return this._errors;
    };
  
    _proto.getDocument = function getDocument() {
      return this._ast;
    };
  
    _proto.getFragment = function getFragment(name) {
      var fragments = this._fragments;
  
      if (!fragments) {
        this._fragments = fragments = this.getDocument().definitions.reduce(function (frags, statement) {
          if (statement.kind === _kinds.Kind.FRAGMENT_DEFINITION) {
            frags[statement.name.value] = statement;
          }
  
          return frags;
        }, Object.create(null));
      }
  
      return fragments[name];
    };
  
    _proto.getFragmentSpreads = function getFragmentSpreads(node) {
      var spreads = this._fragmentSpreads.get(node);
  
      if (!spreads) {
        spreads = [];
        var setsToVisit = [node];
  
        while (setsToVisit.length !== 0) {
          var set = setsToVisit.pop();
  
          for (var i = 0; i < set.selections.length; i++) {
            var selection = set.selections[i];
  
            if (selection.kind === _kinds.Kind.FRAGMENT_SPREAD) {
              spreads.push(selection);
            } else if (selection.selectionSet) {
              setsToVisit.push(selection.selectionSet);
            }
          }
        }
  
        this._fragmentSpreads.set(node, spreads);
      }
  
      return spreads;
    };
  
    _proto.getRecursivelyReferencedFragments = function getRecursivelyReferencedFragments(operation) {
      var fragments = this._recursivelyReferencedFragments.get(operation);
  
      if (!fragments) {
        fragments = [];
        var collectedNames = Object.create(null);
        var nodesToVisit = [operation.selectionSet];
  
        while (nodesToVisit.length !== 0) {
          var node = nodesToVisit.pop();
          var spreads = this.getFragmentSpreads(node);
  
          for (var i = 0; i < spreads.length; i++) {
            var fragName = spreads[i].name.value;
  
            if (collectedNames[fragName] !== true) {
              collectedNames[fragName] = true;
              var fragment = this.getFragment(fragName);
  
              if (fragment) {
                fragments.push(fragment);
                nodesToVisit.push(fragment.selectionSet);
              }
            }
          }
        }
  
        this._recursivelyReferencedFragments.set(operation, fragments);
      }
  
      return fragments;
    };
  
    return ASTValidationContext;
  }();
  
  exports.ASTValidationContext = ASTValidationContext;
  
  var SDLValidationContext =
  /*#__PURE__*/
  function (_ASTValidationContext) {
    _inheritsLoose(SDLValidationContext, _ASTValidationContext);
  
    function SDLValidationContext(ast, schema) {
      var _this;
  
      _this = _ASTValidationContext.call(this, ast) || this;
      _this._schema = schema;
      return _this;
    }
  
    var _proto2 = SDLValidationContext.prototype;
  
    _proto2.getSchema = function getSchema() {
      return this._schema;
    };
  
    return SDLValidationContext;
  }(ASTValidationContext);
  
  exports.SDLValidationContext = SDLValidationContext;
  
  var ValidationContext =
  /*#__PURE__*/
  function (_ASTValidationContext2) {
    _inheritsLoose(ValidationContext, _ASTValidationContext2);
  
    function ValidationContext(schema, ast, typeInfo) {
      var _this2;
  
      _this2 = _ASTValidationContext2.call(this, ast) || this;
      _this2._schema = schema;
      _this2._typeInfo = typeInfo;
      _this2._variableUsages = new Map();
      _this2._recursiveVariableUsages = new Map();
      return _this2;
    }
  
    var _proto3 = ValidationContext.prototype;
  
    _proto3.getSchema = function getSchema() {
      return this._schema;
    };
  
    _proto3.getVariableUsages = function getVariableUsages(node) {
      var usages = this._variableUsages.get(node);
  
      if (!usages) {
        var newUsages = [];
        var typeInfo = new _TypeInfo.TypeInfo(this._schema);
        (0, _visitor.visit)(node, (0, _visitor.visitWithTypeInfo)(typeInfo, {
          VariableDefinition: function VariableDefinition() {
            return false;
          },
          Variable: function Variable(variable) {
            newUsages.push({
              node: variable,
              type: typeInfo.getInputType(),
              defaultValue: typeInfo.getDefaultValue()
            });
          }
        }));
        usages = newUsages;
  
        this._variableUsages.set(node, usages);
      }
  
      return usages;
    };
  
    _proto3.getRecursiveVariableUsages = function getRecursiveVariableUsages(operation) {
      var usages = this._recursiveVariableUsages.get(operation);
  
      if (!usages) {
        usages = this.getVariableUsages(operation);
        var fragments = this.getRecursivelyReferencedFragments(operation);
  
        for (var i = 0; i < fragments.length; i++) {
          Array.prototype.push.apply(usages, this.getVariableUsages(fragments[i]));
        }
  
        this._recursiveVariableUsages.set(operation, usages);
      }
  
      return usages;
    };
  
    _proto3.getType = function getType() {
      return this._typeInfo.getType();
    };
  
    _proto3.getParentType = function getParentType() {
      return this._typeInfo.getParentType();
    };
  
    _proto3.getInputType = function getInputType() {
      return this._typeInfo.getInputType();
    };
  
    _proto3.getParentInputType = function getParentInputType() {
      return this._typeInfo.getParentInputType();
    };
  
    _proto3.getFieldDef = function getFieldDef() {
      return this._typeInfo.getFieldDef();
    };
  
    _proto3.getDirective = function getDirective() {
      return this._typeInfo.getDirective();
    };
  
    _proto3.getArgument = function getArgument() {
      return this._typeInfo.getArgument();
    };
  
    return ValidationContext;
  }(ASTValidationContext);
  
  exports.ValidationContext = ValidationContext;