1 files changed, 241 insertions, 0 deletions
diff --git a/includes/external/school/node_modules/graphql/validation/ValidationContext.js b/includes/external/school/node_modules/graphql/validation/ValidationContext.js
new file mode 100644
index 0000000..c70da64
--- /dev/null
+++ b/includes/external/school/node_modules/graphql/validation/ValidationContext.js
@@ -0,0 +1,241 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ValidationContext = exports.SDLValidationContext = exports.ASTValidationContext = void 0;
+
+var _kinds = require("../language/kinds.js");
+
+var _visitor = require("../language/visitor.js");
+
+var _TypeInfo = require("../utilities/TypeInfo.js");
+
+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, onError) {
+    this._ast = ast;
+    this._fragments = undefined;
+    this._fragmentSpreads = new Map();
+    this._recursivelyReferencedFragments = new Map();
+    this._onError = onError;
+  }
+
+  var _proto = ASTValidationContext.prototype;
+
+  _proto.reportError = function reportError(error) {
+    this._onError(error);
+  };
+
+  _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 _i2 = 0, _set$selections2 = set.selections; _i2 < _set$selections2.length; _i2++) {
+          var selection = _set$selections2[_i2];
+
+          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();
+
+        for (var _i4 = 0, _this$getFragmentSpre2 = this.getFragmentSpreads(node); _i4 < _this$getFragmentSpre2.length; _i4++) {
+          var spread = _this$getFragmentSpre2[_i4];
+          var fragName = spread.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, onError) {
+    var _this;
+
+    _this = _ASTValidationContext.call(this, ast, onError) || 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, onError) {
+    var _this2;
+
+    _this2 = _ASTValidationContext2.call(this, ast, onError) || 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, _TypeInfo.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);
+
+      for (var _i6 = 0, _this$getRecursivelyR2 = this.getRecursivelyReferencedFragments(operation); _i6 < _this$getRecursivelyR2.length; _i6++) {
+        var frag = _this$getRecursivelyR2[_i6];
+        usages = usages.concat(this.getVariableUsages(frag));
+      }
+
+      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();
+  };
+
+  _proto3.getEnumValue = function getEnumValue() {
+    return this._typeInfo.getEnumValue();
+  };
+
+  return ValidationContext;
+}(ASTValidationContext);
+
+exports.ValidationContext = ValidationContext;