@khanacademy/wonder-blocks-data 10.0.5 → 10.1.1

package/dist/es/index.js

@@ -1,10 +1,72 @@
 import { Server, useForceUpdate } from '@khanacademy/wonder-blocks-core';
 import { KindError, clone, entries } from '@khanacademy/wonder-stuff-core';
-import _extends from '@babel/runtime/helpers/extends';
 import * as React from 'react';
 import { useContext, useRef, useMemo, useCallback } from 'react';
 
-const FetchPolicy = require("flow-enums-runtime").Mirrored(["CacheBeforeNetwork", "CacheAndNetwork", "CacheOnly", "NetworkOnly"]);
+const FetchPolicy = {
+  CacheBeforeNetwork: "CacheBeforeNetwork",
+  CacheAndNetwork: "CacheAndNetwork",
+  CacheOnly: "CacheOnly",
+  NetworkOnly: "NetworkOnly"
+};
+
+function _typeof(obj) {
+  "@babel/helpers - typeof";
+
+  return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) {
+    return typeof obj;
+  } : function (obj) {
+    return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
+  }, _typeof(obj);
+}
+
+function _toPrimitive(input, hint) {
+  if (_typeof(input) !== "object" || input === null) return input;
+  var prim = input[Symbol.toPrimitive];
+  if (prim !== undefined) {
+    var res = prim.call(input, hint || "default");
+    if (_typeof(res) !== "object") return res;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return (hint === "string" ? String : Number)(input);
+}
+
+function _toPropertyKey(arg) {
+  var key = _toPrimitive(arg, "string");
+  return _typeof(key) === "symbol" ? key : String(key);
+}
+
+function _defineProperties(target, props) {
+  for (var i = 0; i < props.length; i++) {
+    var descriptor = props[i];
+    descriptor.enumerable = descriptor.enumerable || false;
+    descriptor.configurable = true;
+    if ("value" in descriptor) descriptor.writable = true;
+    Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor);
+  }
+}
+function _createClass(Constructor, protoProps, staticProps) {
+  if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+  if (staticProps) _defineProperties(Constructor, staticProps);
+  Object.defineProperty(Constructor, "prototype", {
+    writable: false
+  });
+  return Constructor;
+}
+
+function _setPrototypeOf(o, p) {
+  _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
+    o.__proto__ = p;
+    return o;
+  };
+  return _setPrototypeOf(o, p);
+}
+
+function _inheritsLoose(subClass, superClass) {
+  subClass.prototype = Object.create(superClass.prototype);
+  subClass.prototype.constructor = subClass;
+  _setPrototypeOf(subClass, superClass);
+}
 
 const DataErrors = Object.freeze({
   Unknown: "Unknown",
@@ -15,116 +77,106 @@ const DataErrors = Object.freeze({
   Parse: "Parse",
   Hydrated: "Hydrated"
 });
-class DataError extends KindError {
-  constructor(message, kind, {
+let DataError = function (_KindError) {
+  _inheritsLoose(DataError, _KindError);
+  function DataError(message, kind, {
     metadata,
     cause
   } = {}) {
-    super(message, kind, {
+    return _KindError.call(this, message, kind, {
       metadata,
       cause,
       name: "Data"
-    });
+    }) || this;
   }
+  return DataError;
+}(KindError);
 
-}
-
-class ScopedInMemoryCache {
-  constructor(initialCache = {}) {
+let ScopedInMemoryCache = function () {
+  function ScopedInMemoryCache(initialCache = {}) {
+    this._cache = void 0;
     this._cache = initialCache;
   }
-
-  get inUse() {
-    return Object.keys(this._cache).length > 0;
-  }
-
-  set(scope, id, value) {
+  var _proto = ScopedInMemoryCache.prototype;
+  _proto.set = function set(scope, id, value) {
     var _this$_cache$scope;
-
     if (!id || typeof id !== "string") {
       throw new DataError("id must be non-empty string", DataErrors.InvalidInput);
     }
-
     if (!scope || typeof scope !== "string") {
       throw new DataError("scope must be non-empty string", DataErrors.InvalidInput);
     }
-
     if (typeof value === "function") {
       throw new DataError("value must be a non-function value", DataErrors.InvalidInput);
     }
-
     this._cache[scope] = (_this$_cache$scope = this._cache[scope]) != null ? _this$_cache$scope : {};
     this._cache[scope][id] = value;
-  }
-
-  get(scope, id) {
+  };
+  _proto.get = function get(scope, id) {
     var _this$_cache$scope$id, _this$_cache$scope2;
-
     return (_this$_cache$scope$id = (_this$_cache$scope2 = this._cache[scope]) == null ? void 0 : _this$_cache$scope2[id]) != null ? _this$_cache$scope$id : null;
-  }
-
-  purge(scope, id) {
+  };
+  _proto.purge = function purge(scope, id) {
     var _this$_cache$scope3;
-
     if (!((_this$_cache$scope3 = this._cache[scope]) != null && _this$_cache$scope3[id])) {
       return;
     }
-
     delete this._cache[scope][id];
-
     if (Object.keys(this._cache[scope]).length === 0) {
       delete this._cache[scope];
     }
-  }
-
-  purgeScope(scope, predicate) {
+  };
+  _proto.purgeScope = function purgeScope(scope, predicate) {
     if (!this._cache[scope]) {
       return;
     }
-
     if (predicate == null) {
       delete this._cache[scope];
       return;
     }
-
     for (const key of Object.keys(this._cache[scope])) {
       if (predicate(key, this._cache[scope][key])) {
         delete this._cache[scope][key];
       }
     }
-
     if (Object.keys(this._cache[scope]).length === 0) {
       delete this._cache[scope];
     }
-  }
-
-  purgeAll(predicate) {
+  };
+  _proto.purgeAll = function purgeAll(predicate) {
     if (predicate == null) {
       this._cache = {};
       return;
     }
-
     for (const scope of Object.keys(this._cache)) {
       this.purgeScope(scope, (id, value) => predicate(scope, id, value));
     }
-  }
-
-}
-
-class SerializableInMemoryCache extends ScopedInMemoryCache {
-  constructor(initialCache = {}) {
+  };
+  _createClass(ScopedInMemoryCache, [{
+    key: "inUse",
+    get: function () {
+      return Object.keys(this._cache).length > 0;
+    }
+  }]);
+  return ScopedInMemoryCache;
+}();
+
+let SerializableInMemoryCache = function (_ScopedInMemoryCache) {
+  _inheritsLoose(SerializableInMemoryCache, _ScopedInMemoryCache);
+  function SerializableInMemoryCache(initialCache = {}) {
+    var _this;
     try {
-      super(clone(initialCache));
+      _this = _ScopedInMemoryCache.call(this, clone(initialCache)) || this;
     } catch (e) {
       throw new DataError(`An error occurred trying to initialize from a response cache snapshot: ${e}`, DataErrors.InvalidInput);
     }
+    return _this;
   }
-
-  set(scope, id, value) {
-    super.set(scope, id, Object.freeze(clone(value)));
-  }
-
-  clone() {
+  var _proto = SerializableInMemoryCache.prototype;
+  _proto.set = function set(scope, id, value) {
+    _ScopedInMemoryCache.prototype.set.call(this, scope, id, Object.freeze(clone(value)));
+  };
+  _proto.clone = function clone$1() {
     try {
       return clone(this._cache);
     } catch (e) {
@@ -132,79 +184,57 @@ class SerializableInMemoryCache extends ScopedInMemoryCache {
         cause: e
       });
     }
-  }
-
-}
+  };
+  return SerializableInMemoryCache;
+}(ScopedInMemoryCache);
 
 const DefaultScope$2 = "default";
-
 let _default$2;
-
-class SsrCache {
-  static get Default() {
-    if (!_default$2) {
-      _default$2 = new SsrCache();
-    }
-
-    return _default$2;
-  }
-
-  constructor(hydrationCache = null, ssrOnlyCache = null) {
+let SsrCache = function () {
+  function SsrCache(hydrationCache = null, ssrOnlyCache = null) {
+    this._hydrationCache = void 0;
+    this._ssrOnlyCache = void 0;
     this.initialize = source => {
       if (this._hydrationCache.inUse) {
         throw new Error("Cannot initialize data response cache more than once");
       }
-
       this._hydrationCache = new SerializableInMemoryCache({
         [DefaultScope$2]: source
       });
     };
-
     this.cacheData = (id, data, hydrate) => this._setCachedResponse(id, {
       data
     }, hydrate);
-
     this.cacheError = (id, error, hydrate) => {
       const errorMessage = typeof error === "string" ? error : error.message;
       return this._setCachedResponse(id, {
         error: errorMessage
       }, hydrate);
     };
-
     this.getEntry = id => {
       const ssrEntry = Server.isServerSide() ? this._ssrOnlyCache.get(DefaultScope$2, id) : null;
       const internalEntry = ssrEntry != null ? ssrEntry : this._hydrationCache.get(DefaultScope$2, id);
-
       if (!Server.isServerSide() && internalEntry != null) {
         this._hydrationCache.purge(DefaultScope$2, id);
       }
-
       return internalEntry;
     };
-
     this.purgeData = predicate => {
       const realPredicate = predicate ? (_, key, cachedEntry) => predicate(key, cachedEntry) : undefined;
-
       this._hydrationCache.purgeAll(realPredicate);
-
       this._ssrOnlyCache.purgeAll(realPredicate);
     };
-
     this.cloneHydratableData = () => {
       var _cache$DefaultScope;
-
       const cache = this._hydrationCache.clone();
-
       return (_cache$DefaultScope = cache[DefaultScope$2]) != null ? _cache$DefaultScope : {};
     };
-
     this._ssrOnlyCache = ssrOnlyCache || new SerializableInMemoryCache();
     this._hydrationCache = hydrationCache || new SerializableInMemoryCache();
   }
-
-  _setCachedResponse(id, entry, hydrate) {
+  var _proto = SsrCache.prototype;
+  _proto._setCachedResponse = function _setCachedResponse(id, entry, hydrate) {
     const frozenEntry = Object.freeze(entry);
-
     if (Server.isServerSide()) {
       if (hydrate) {
         this._hydrationCache.set(DefaultScope$2, id, frozenEntry);
@@ -212,31 +242,50 @@ class SsrCache {
         this._ssrOnlyCache.set(DefaultScope$2, id, frozenEntry);
       }
     }
-
     return frozenEntry;
-  }
-
-}
+  };
+  _createClass(SsrCache, null, [{
+    key: "Default",
+    get: function () {
+      if (!_default$2) {
+        _default$2 = new SsrCache();
+      }
+      return _default$2;
+    }
+  }]);
+  return SsrCache;
+}();
 
 const initializeHydrationCache = source => SsrCache.Default.initialize(source);
 const purgeHydrationCache = predicate => SsrCache.Default.purgeData(predicate);
 
-let _default$1;
+function _extends() {
+  _extends = Object.assign ? Object.assign.bind() : function (target) {
+    for (var i = 1; i < arguments.length; i++) {
+      var source = arguments[i];
+      for (var key in source) {
+        if (Object.prototype.hasOwnProperty.call(source, key)) {
+          target[key] = source[key];
+        }
+      }
+    }
+    return target;
+  };
+  return _extends.apply(this, arguments);
+}
 
-class RequestFulfillment {
-  constructor() {
+let _default$1;
+let RequestFulfillment = function () {
+  function RequestFulfillment() {
     this._requests = {};
-
     this.fulfill = (id, {
       handler,
       hydrate: _hydrate = true
     }) => {
       const inflight = this._requests[id];
-
       if (inflight) {
         return inflight;
       }
-
       const request = handler().then(data => ({
         status: "success",
         data
@@ -246,13 +295,11 @@ class RequestFulfillment {
             unexpectedError: error
           }
         }) : error;
-
         if (actualError.name === "AbortError") {
           return {
             status: "aborted"
           };
         }
-
         return {
           status: "error",
           error: actualError
@@ -263,42 +310,32 @@ class RequestFulfillment {
       this._requests[id] = request;
       return request;
     };
-
     this.abort = id => {
       delete this._requests[id];
     };
-
     this.abortAll = () => {
       Object.keys(this._requests).forEach(id => this.abort(id));
     };
   }
-
-  static get Default() {
-    if (!_default$1) {
-      _default$1 = new RequestFulfillment();
+  _createClass(RequestFulfillment, null, [{
+    key: "Default",
+    get: function () {
+      if (!_default$1) {
+        _default$1 = new RequestFulfillment();
+      }
+      return _default$1;
     }
-
-    return _default$1;
-  }
-
-}
+  }]);
+  return RequestFulfillment;
+}();
 
 const TrackerContext = React.createContext(null);
-
 let _default;
-
-class RequestTracker {
-  static get Default() {
-    if (!_default) {
-      _default = new RequestTracker();
-    }
-
-    return _default;
-  }
-
-  constructor(responseCache = undefined) {
+let RequestTracker = function () {
+  function RequestTracker(responseCache = undefined) {
     this._trackedRequests = {};
-
+    this._responseCache = void 0;
+    this._requestFulfillment = void 0;
     this.trackDataRequest = (id, handler, hydrate) => {
       if (this._trackedRequests[id] == null) {
         this._trackedRequests[id] = {
@@ -307,82 +344,78 @@ class RequestTracker {
         };
       }
     };
-
     this.reset = () => {
       this._trackedRequests = {};
     };
-
     this.fulfillTrackedRequests = () => {
       const promises = [];
       const {
         cacheData,
         cacheError
       } = this._responseCache;
-
       for (const requestKey of Object.keys(this._trackedRequests)) {
         const options = this._trackedRequests[requestKey];
-
         try {
           promises.push(this._requestFulfillment.fulfill(requestKey, _extends({}, options)).then(result => {
             switch (result.status) {
               case "success":
                 cacheData(requestKey, result.data, options.hydrate);
                 break;
-
               case "error":
                 cacheError(requestKey, result.error, options.hydrate);
                 break;
             }
-
             return;
           }));
         } catch (e) {
           promises.push(Promise.resolve(cacheError(requestKey, e, options.hydrate)));
         }
       }
-
       this.reset();
       return Promise.all(promises).then(() => this._responseCache.cloneHydratableData());
     };
-
     this._responseCache = responseCache || SsrCache.Default;
     this._requestFulfillment = new RequestFulfillment();
   }
-
-  get hasUnfulfilledRequests() {
-    return Object.keys(this._trackedRequests).length > 0;
-  }
-
-}
+  _createClass(RequestTracker, [{
+    key: "hasUnfulfilledRequests",
+    get: function () {
+      return Object.keys(this._trackedRequests).length > 0;
+    }
+  }], [{
+    key: "Default",
+    get: function () {
+      if (!_default) {
+        _default = new RequestTracker();
+      }
+      return _default;
+    }
+  }]);
+  return RequestTracker;
+}();
 
 const SSRCheck = () => {
   if (Server.isServerSide()) {
     return null;
   }
-
   if (process.env.NODE_ENV === "production") {
     return new DataError("No CSR tracking", DataErrors.NotAllowed);
   } else {
     return new DataError("Data requests are not tracked for fulfillment when when client-side", DataErrors.NotAllowed);
   }
 };
-
 const fetchTrackedRequests = () => {
   const ssrCheck = SSRCheck();
-
   if (ssrCheck != null) {
     return Promise.reject(ssrCheck);
   }
-
   return RequestTracker.Default.fulfillTrackedRequests();
 };
 const hasTrackedRequestsToBeFetched = () => {
   const ssrCheck = SSRCheck();
-
   if (ssrCheck != null) {
     throw ssrCheck;
   }
-
   return RequestTracker.Default.hasUnfulfilledRequests;
 };
 const abortInflightRequests = () => {
@@ -395,23 +428,18 @@ const useSharedCache = (id, scope, initialValue) => {
   if (!id || typeof id !== "string") {
     throw new DataError("id must be a non-empty string", DataErrors.InvalidInput);
   }
-
   if (!scope || typeof scope !== "string") {
     throw new DataError("scope must be a non-empty string", DataErrors.InvalidInput);
   }
-
   const cacheValue = React.useCallback(value => value == null ? cache$1.purge(scope, id) : cache$1.set(scope, id, value), [id, scope]);
   let currentValue = cache$1.get(scope, id);
-
   if (currentValue == null && initialValue !== undefined) {
     const value = typeof initialValue === "function" ? initialValue() : initialValue;
-
     if (value != null) {
       cacheValue(value);
       currentValue = value;
     }
   }
-
   return [currentValue, cacheValue];
 };
 
@@ -420,18 +448,22 @@ const purgeCaches = () => {
   purgeHydrationCache();
 };
 
-class TrackData extends React.Component {
-  render() {
+let TrackData = function (_React$Component) {
+  _inheritsLoose(TrackData, _React$Component);
+  function TrackData() {
+    return _React$Component.apply(this, arguments) || this;
+  }
+  var _proto = TrackData.prototype;
+  _proto.render = function render() {
     if (!Server.isServerSide()) {
       throw new Error("This component is not for use during client-side rendering");
     }
-
     return React.createElement(TrackerContext.Provider, {
       value: RequestTracker.Default.trackDataRequest
     }, this.props.children);
-  }
-
-}
+  };
+  return TrackData;
+}(React.Component);
 
 const loadingStatus = Object.freeze({
   status: "loading"
@@ -456,20 +488,16 @@ const resultFromCachedResponse = cacheEntry => {
   if (cacheEntry == null) {
     return null;
   }
-
   const {
     data,
     error
   } = cacheEntry;
-
   if (error != null) {
     return Status.error(new DataError(error, DataErrors.Hydrated));
   }
-
   if (data != null) {
     return Status.success(data);
   }
-
   return Status.aborted();
 };
 
@@ -482,7 +510,6 @@ const useRequestInterception = (requestId, handler) => {
       if (prev != null) {
         return prev;
       }
-
       return interceptor(requestId);
     }, null);
     return interceptResponse != null ? interceptResponse : handler();
@@ -498,18 +525,15 @@ const useServerEffect = (requestId, handler, options = {}) => {
   const interceptedHandler = useRequestInterception(requestId, handler);
   const cachedResult = SsrCache.Default.getEntry(requestId);
   const maybeTrack = useContext(TrackerContext);
-
   if (!skip && cachedResult == null && Server.isServerSide()) {
     maybeTrack == null ? void 0 : maybeTrack(requestId, interceptedHandler, hydrate);
   }
-
   return cachedResult == null ? null : resultFromCachedResponse(cachedResult);
 };
 
 const DefaultScope$1 = "useCachedEffect";
 const useCachedEffect = (requestId, handler, options = {}) => {
   var _ref;
-
   const {
     fetchPolicy = FetchPolicy.CacheBeforeNetwork,
     skip: hardSkip = false,
@@ -524,73 +548,57 @@ const useCachedEffect = (requestId, handler, options = {}) => {
   const currentRequestRef = React.useRef();
   const fetchRequest = React.useMemo(() => {
     var _currentRequestRef$cu;
-
     (_currentRequestRef$cu = currentRequestRef.current) == null ? void 0 : _currentRequestRef$cu.cancel();
     currentRequestRef.current = null;
     networkResultRef.current = null;
-
     const fetchFn = () => {
       var _currentRequestRef$cu2, _currentRequestRef$cu3;
-
       if (fetchPolicy === FetchPolicy.CacheOnly) {
         throw new DataError("Cannot fetch with CacheOnly policy", DataErrors.NotAllowed);
       }
-
       const request = RequestFulfillment.Default.fulfill(`${requestId}|${scope}`, {
         handler: interceptedHandler
       });
-
       if (request === ((_currentRequestRef$cu2 = currentRequestRef.current) == null ? void 0 : _currentRequestRef$cu2.request)) {
         return;
       }
-
       networkResultRef.current = null;
       (_currentRequestRef$cu3 = currentRequestRef.current) == null ? void 0 : _currentRequestRef$cu3.cancel();
       let cancel = false;
       request.then(result => {
         currentRequestRef.current = null;
-
         if (cancel) {
           return;
         }
-
         setMostRecentResult(result);
         networkResultRef.current = result;
-
         if (onResultChanged != null) {
           onResultChanged(result);
         } else {
           forceUpdate();
         }
-
         return;
       });
       currentRequestRef.current = {
         requestId,
         request,
-
         cancel() {
           cancel = true;
           RequestFulfillment.Default.abort(requestId);
         }
-
       };
     };
-
     return fetchFn;
   }, [requestId, onResultChanged, forceUpdate, setMostRecentResult, fetchPolicy]);
   const shouldFetch = React.useMemo(() => {
     if (hardSkip) {
       return false;
     }
-
     switch (fetchPolicy) {
       case FetchPolicy.CacheOnly:
         return false;
-
       case FetchPolicy.CacheBeforeNetwork:
         return mostRecentResult == null;
-
       case FetchPolicy.CacheAndNetwork:
       case FetchPolicy.NetworkOnly:
         return networkResultRef.current == null;
@@ -600,11 +608,9 @@ const useCachedEffect = (requestId, handler, options = {}) => {
     if (!shouldFetch) {
       return;
     }
-
     fetchRequest();
     return () => {
       var _currentRequestRef$cu4;
-
       (_currentRequestRef$cu4 = currentRequestRef.current) == null ? void 0 : _currentRequestRef$cu4.cancel();
       currentRequestRef.current = null;
     };
@@ -616,7 +622,12 @@ const useCachedEffect = (requestId, handler, options = {}) => {
   return [result, fetchRequest];
 };
 
-const WhenClientSide = require("flow-enums-runtime").Mirrored(["DoNotHydrate", "ExecuteWhenNoResult", "ExecuteWhenNoSuccessResult", "AlwaysExecute"]);
+const WhenClientSide = {
+  DoNotHydrate: "DoNotHydrate",
+  ExecuteWhenNoResult: "ExecuteWhenNoResult",
+  ExecuteWhenNoSuccessResult: "ExecuteWhenNoSuccessResult",
+  AlwaysExecute: "AlwaysExecute"
+};
 const DefaultScope = "useHydratableEffect";
 const useHydratableEffect = (requestId, handler, options = {}) => {
   const {
@@ -635,15 +646,12 @@ const useHydratableEffect = (requestId, handler, options = {}) => {
       case WhenClientSide.DoNotHydrate:
       case WhenClientSide.AlwaysExecute:
         return null;
-
       case WhenClientSide.ExecuteWhenNoResult:
         return serverResult;
-
       case WhenClientSide.ExecuteWhenNoSuccessResult:
         if ((serverResult == null ? void 0 : serverResult.status) === "success") {
           return serverResult;
         }
-
         return null;
     }
   }, [serverResult]);
@@ -685,11 +693,9 @@ const InterceptRequests = ({
 
 const toString = value => {
   var _JSON$stringify;
-
   if (typeof value === "string") {
     return value;
   }
-
   if (typeof value === "object" && value != null) {
     if (value instanceof Date) {
       return value.toISOString();
@@ -697,14 +703,11 @@ const toString = value => {
       return value.toString();
     }
   }
-
   return (_JSON$stringify = JSON.stringify(value)) != null ? _JSON$stringify : "";
 };
-
 const toStringifiedVariables = (acc, key, value) => {
   if (typeof value === "object" && value !== null) {
     const subValues = entries(value);
-
     if (subValues.length !== 0) {
       return subValues.reduce((innerAcc, [i, v]) => {
         const subKey = `${key}.${i}`;
@@ -712,18 +715,15 @@ const toStringifiedVariables = (acc, key, value) => {
       }, acc);
     }
   }
-
   acc[key] = toString(value);
   return acc;
 };
-
 const getGqlRequestId = (operation, variables, context) => {
   const parts = [];
   const sortableContext = new URLSearchParams(context);
   sortableContext.sort();
   parts.push(sortableContext.toString());
   parts.push(operation.id);
-
   if (variables != null) {
     const stringifiedVariables = Object.keys(variables).reduce((acc, key) => {
       const value = variables[key];
@@ -733,7 +733,6 @@ const getGqlRequestId = (operation, variables, context) => {
     sortableVariables.sort();
     parts.push(sortableVariables.toString());
   }
-
   return parts.join("|");
 };
 
@@ -742,24 +741,24 @@ const GqlErrors = Object.freeze({
   BadResponse: "BadResponse",
   ErrorResult: "ErrorResult"
 });
-class GqlError extends KindError {
-  constructor(message, kind, {
+let GqlError = function (_KindError) {
+  _inheritsLoose(GqlError, _KindError);
+  function GqlError(message, kind, {
     metadata,
     cause
   } = {}) {
-    super(message, kind, {
+    return _KindError.call(this, message, kind, {
       metadata,
       cause,
       name: "Gql"
-    });
+    }) || this;
   }
-
-}
+  return GqlError;
+}(KindError);
 
 const getGqlDataFromResponse = async response => {
   const bodyText = await response.text();
   let result;
-
   try {
     result = JSON.parse(bodyText);
   } catch (e) {
@@ -771,7 +770,6 @@ const getGqlDataFromResponse = async response => {
       cause: e
     });
   }
-
   if (response.status >= 300) {
     throw new DataError("Response unsuccessful", DataErrors.Network, {
       metadata: {
@@ -780,7 +778,6 @@ const getGqlDataFromResponse = async response => {
       }
     });
   }
-
   if (!Object.prototype.hasOwnProperty.call(result, "data") && !Object.prototype.hasOwnProperty.call(result, "errors")) {
     throw new GqlError("Server response missing", GqlErrors.BadResponse, {
       metadata: {
@@ -789,7 +786,6 @@ const getGqlDataFromResponse = async response => {
       }
     });
   }
-
   if (result.errors != null && Array.isArray(result.errors) && result.errors.length > 0) {
     throw new GqlError("GraphQL errors", GqlErrors.ErrorResult, {
       metadata: {
@@ -798,7 +794,6 @@ const getGqlDataFromResponse = async response => {
       }
     });
   }
-
   return result.data;
 };
 
@@ -809,13 +804,10 @@ const DocumentTypes = Object.freeze({
 const cache = new Map();
 function graphQLDocumentNodeParser(document) {
   var _definition$name;
-
   const cached = cache.get(document);
-
   if (cached) {
     return cached;
   }
-
   if (!(document != null && document.kind)) {
     if (process.env.NODE_ENV === "production") {
       throw new DataError("Bad DocumentNode", DataErrors.InvalidInput);
@@ -823,12 +815,10 @@ function graphQLDocumentNodeParser(document) {
       throw new DataError(`Argument of ${JSON.stringify(document)} passed to parser was not a valid GraphQL ` + `DocumentNode. You may need to use 'graphql-tag' or another method ` + `to convert your operation into a document`, DataErrors.InvalidInput);
     }
   }
-
   const fragments = document.definitions.filter(x => x.kind === "FragmentDefinition");
   const queries = document.definitions.filter(x => x.kind === "OperationDefinition" && x.operation === "query");
   const mutations = document.definitions.filter(x => x.kind === "OperationDefinition" && x.operation === "mutation");
   const subscriptions = document.definitions.filter(x => x.kind === "OperationDefinition" && x.operation === "subscription");
-
   if (fragments.length && !queries.length && !mutations.length) {
     if (process.env.NODE_ENV === "production") {
       throw new DataError("Fragment only", DataErrors.InvalidInput);
@@ -836,7 +826,6 @@ function graphQLDocumentNodeParser(document) {
       throw new DataError(`Passing only a fragment to 'graphql' is not supported. ` + `You must include a query or mutation as well`, DataErrors.InvalidInput);
     }
   }
-
   if (subscriptions.length) {
     if (process.env.NODE_ENV === "production") {
       throw new DataError("No subscriptions", DataErrors.InvalidInput);
@@ -844,7 +833,6 @@ function graphQLDocumentNodeParser(document) {
       throw new DataError(`We do not support subscriptions. ` + `${JSON.stringify(document)} had ${subscriptions.length} subscriptions`, DataErrors.InvalidInput);
     }
   }
-
   if (queries.length + mutations.length > 1) {
     if (process.env.NODE_ENV === "production") {
       throw new DataError("Too many ops", DataErrors.InvalidInput);
@@ -852,7 +840,6 @@ function graphQLDocumentNodeParser(document) {
       throw new DataError(`We only support one query or mutation per component. ` + `${JSON.stringify(document)} had ${queries.length} queries and ` + `${mutations.length} mutations. `, DataErrors.InvalidInput);
     }
   }
-
   const type = queries.length ? DocumentTypes.query : DocumentTypes.mutation;
   const definitions = queries.length ? queries : mutations;
   const definition = definitions[0];
@@ -901,18 +888,15 @@ const mergeGqlContext = (defaultContext, overrides) => {
         acc[key] = overrides[key];
       }
     }
-
     return acc;
   }, _extends({}, defaultContext));
 };
 
 const useGqlRouterContext = (contextOverrides = {}) => {
   const gqlRouterContext = useContext(GqlRouterContext);
-
   if (gqlRouterContext == null) {
     throw new GqlError("No GqlRouter", GqlErrors.Internal);
   }
-
   const {
     fetch,
     defaultContext
@@ -922,11 +906,9 @@ const useGqlRouterContext = (contextOverrides = {}) => {
   const refKeys = Object.keys(contextRef.current);
   const mergedKeys = Object.keys(mergedContext);
   const shouldWeUpdateRef = refKeys.length !== mergedKeys.length || mergedKeys.every(key => contextRef.current[key] !== mergedContext[key]);
-
   if (shouldWeUpdateRef) {
     contextRef.current = mergedContext;
   }
-
   const finalContext = contextRef.current;
   const finalRouterContext = useMemo(() => ({
     fetch,