@khanacademy/wonder-blocks-data 2.3.0 → 2.3.4

package/dist/es/index.js

@@ -1,211 +1,6 @@
 import { Server } from '@khanacademy/wonder-blocks-core';
-import { createContext, createElement, Component } from 'react';
-
-function _classCallCheck(instance, Constructor) {
-  if (!(instance instanceof Constructor)) {
-    throw new TypeError("Cannot call a class as a function");
-  }
-}
-
-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, descriptor.key, descriptor);
-  }
-}
-
-function _createClass(Constructor, protoProps, staticProps) {
-  if (protoProps) _defineProperties(Constructor.prototype, protoProps);
-  if (staticProps) _defineProperties(Constructor, staticProps);
-  return Constructor;
-}
-
-function _defineProperty(obj, key, value) {
-  if (key in obj) {
-    Object.defineProperty(obj, key, {
-      value: value,
-      enumerable: true,
-      configurable: true,
-      writable: true
-    });
-  } else {
-    obj[key] = value;
-  }
-
-  return obj;
-}
-
-function ownKeys(object, enumerableOnly) {
-  var keys = Object.keys(object);
-
-  if (Object.getOwnPropertySymbols) {
-    var symbols = Object.getOwnPropertySymbols(object);
-    if (enumerableOnly) symbols = symbols.filter(function (sym) {
-      return Object.getOwnPropertyDescriptor(object, sym).enumerable;
-    });
-    keys.push.apply(keys, symbols);
-  }
-
-  return keys;
-}
-
-function _objectSpread2(target) {
-  for (var i = 1; i < arguments.length; i++) {
-    var source = arguments[i] != null ? arguments[i] : {};
-
-    if (i % 2) {
-      ownKeys(Object(source), true).forEach(function (key) {
-        _defineProperty(target, key, source[key]);
-      });
-    } else if (Object.getOwnPropertyDescriptors) {
-      Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
-    } else {
-      ownKeys(Object(source)).forEach(function (key) {
-        Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
-      });
-    }
-  }
-
-  return target;
-}
-
-function _inherits(subClass, superClass) {
-  if (typeof superClass !== "function" && superClass !== null) {
-    throw new TypeError("Super expression must either be null or a function");
-  }
-
-  subClass.prototype = Object.create(superClass && superClass.prototype, {
-    constructor: {
-      value: subClass,
-      writable: true,
-      configurable: true
-    }
-  });
-  if (superClass) _setPrototypeOf(subClass, superClass);
-}
-
-function _getPrototypeOf(o) {
-  _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {
-    return o.__proto__ || Object.getPrototypeOf(o);
-  };
-  return _getPrototypeOf(o);
-}
-
-function _setPrototypeOf(o, p) {
-  _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
-    o.__proto__ = p;
-    return o;
-  };
-
-  return _setPrototypeOf(o, p);
-}
-
-function _isNativeReflectConstruct() {
-  if (typeof Reflect === "undefined" || !Reflect.construct) return false;
-  if (Reflect.construct.sham) return false;
-  if (typeof Proxy === "function") return true;
-
-  try {
-    Date.prototype.toString.call(Reflect.construct(Date, [], function () {}));
-    return true;
-  } catch (e) {
-    return false;
-  }
-}
-
-function _assertThisInitialized(self) {
-  if (self === void 0) {
-    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
-  }
-
-  return self;
-}
-
-function _possibleConstructorReturn(self, call) {
-  if (call && (typeof call === "object" || typeof call === "function")) {
-    return call;
-  }
-
-  return _assertThisInitialized(self);
-}
-
-function _createSuper(Derived) {
-  var hasNativeReflectConstruct = _isNativeReflectConstruct();
-
-  return function _createSuperInternal() {
-    var Super = _getPrototypeOf(Derived),
-        result;
-
-    if (hasNativeReflectConstruct) {
-      var NewTarget = _getPrototypeOf(this).constructor;
-
-      result = Reflect.construct(Super, arguments, NewTarget);
-    } else {
-      result = Super.apply(this, arguments);
-    }
-
-    return _possibleConstructorReturn(this, result);
-  };
-}
-
-function _slicedToArray(arr, i) {
-  return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
-}
-
-function _arrayWithHoles(arr) {
-  if (Array.isArray(arr)) return arr;
-}
-
-function _iterableToArrayLimit(arr, i) {
-  if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return;
-  var _arr = [];
-  var _n = true;
-  var _d = false;
-  var _e = undefined;
-
-  try {
-    for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {
-      _arr.push(_s.value);
-
-      if (i && _arr.length === i) break;
-    }
-  } catch (err) {
-    _d = true;
-    _e = err;
-  } finally {
-    try {
-      if (!_n && _i["return"] != null) _i["return"]();
-    } finally {
-      if (_d) throw _e;
-    }
-  }
-
-  return _arr;
-}
-
-function _unsupportedIterableToArray(o, minLen) {
-  if (!o) return;
-  if (typeof o === "string") return _arrayLikeToArray(o, minLen);
-  var n = Object.prototype.toString.call(o).slice(8, -1);
-  if (n === "Object" && o.constructor) n = o.constructor.name;
-  if (n === "Map" || n === "Set") return Array.from(o);
-  if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
-}
-
-function _arrayLikeToArray(arr, len) {
-  if (len == null || len > arr.length) len = arr.length;
-
-  for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
-
-  return arr2;
-}
-
-function _nonIterableRest() {
-  throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
-}
+import { createContext, Component, createElement } from 'react';
+import _extends from '@babel/runtime/helpers/extends';
 
 function deepClone(source) {
   /**
@@ -215,8 +10,8 @@ function deepClone(source) {
    *
    * NOTE: This doesn't work for get/set property accessors.
    */
-  var serializedInitCache = JSON.stringify(source);
-  var cloneInitCache = JSON.parse(serializedInitCache);
+  const serializedInitCache = JSON.stringify(source);
+  const cloneInitCache = JSON.parse(serializedInitCache);
   return Object.freeze(cloneInitCache);
 }
 /**
@@ -230,61 +25,53 @@ function deepClone(source) {
  */
 
 
-var MemoryCache = /*#__PURE__*/function () {
-  function MemoryCache() {
-    var _this = this;
-
-    var source = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
-
-    _classCallCheck(this, MemoryCache);
+class MemoryCache {
+  constructor(source = null) {
+    this.store = (handler, options, entry) => {
+      const requestType = handler.type;
+      const frozenEntry = Object.isFrozen(entry) ? entry : Object.freeze(entry); // Ensure we have a cache location for this handler type.
 
-    _defineProperty(this, "_cache", void 0);
+      this._cache[requestType] = this._cache[requestType] || {}; // Cache the data.
 
-    _defineProperty(this, "store", function (handler, options, entry) {
-      var requestType = handler.type;
-      var frozenEntry = Object.isFrozen(entry) ? entry : Object.freeze(entry); // Ensure we have a cache location for this handler type.
+      const key = handler.getKey(options);
+      this._cache[requestType][key] = frozenEntry;
+    };
 
-      _this._cache[requestType] = _this._cache[requestType] || {}; // Cache the data.
-
-      var key = handler.getKey(options);
-      _this._cache[requestType][key] = frozenEntry;
-    });
+    this.retrieve = (handler, options) => {
+      const requestType = handler.type; // Get the internal subcache for the handler.
 
-    _defineProperty(this, "retrieve", function (handler, options) {
-      var requestType = handler.type; // Get the internal subcache for the handler.
-
-      var handlerCache = _this._cache[requestType];
+      const handlerCache = this._cache[requestType];
 
       if (!handlerCache) {
         return null;
       } // Get the response.
 
 
-      var key = handler.getKey(options);
-      var internalEntry = handlerCache[key];
+      const key = handler.getKey(options);
+      const internalEntry = handlerCache[key];
 
       if (internalEntry == null) {
         return null;
       }
 
       return internalEntry;
-    });
+    };
 
-    _defineProperty(this, "remove", function (handler, options) {
-      var requestType = handler.type; // NOTE(somewhatabstract): We could invoke removeAll with a predicate
+    this.remove = (handler, options) => {
+      const requestType = handler.type; // NOTE(somewhatabstract): We could invoke removeAll with a predicate
       // to match the key of the entry we're removing, but that's an
       // inefficient way to remove a single item, so let's not do that.
       // Get the internal subcache for the handler.
 
-      var handlerCache = _this._cache[requestType];
+      const handlerCache = this._cache[requestType];
 
       if (!handlerCache) {
         return false;
       } // Get the entry.
 
 
-      var key = handler.getKey(options);
-      var internalEntry = handlerCache[key];
+      const key = handler.getKey(options);
+      const internalEntry = handlerCache[key];
 
       if (internalEntry == null) {
         return false;
@@ -293,41 +80,37 @@ var MemoryCache = /*#__PURE__*/function () {
 
       delete handlerCache[key];
       return true;
-    });
+    };
 
-    _defineProperty(this, "removeAll", function (handler, predicate) {
-      var requestType = handler.type; // Get the internal subcache for the handler.
+    this.removeAll = (handler, predicate) => {
+      const requestType = handler.type; // Get the internal subcache for the handler.
 
-      var handlerCache = _this._cache[requestType];
+      const handlerCache = this._cache[requestType];
 
       if (!handlerCache) {
         return 0;
       } // Apply the predicate to what we have cached.
 
 
-      var removedCount = 0;
+      let removedCount = 0;
 
-      for (var _i = 0, _Object$entries = Object.entries(handlerCache); _i < _Object$entries.length; _i++) {
-        var _Object$entries$_i = _slicedToArray(_Object$entries[_i], 2),
-            _key = _Object$entries$_i[0],
-            _entry = _Object$entries$_i[1];
-
-        if (typeof predicate !== "function" || predicate(_key, _entry)) {
+      for (const [key, entry] of Object.entries(handlerCache)) {
+        if (typeof predicate !== "function" || predicate(key, entry)) {
           removedCount++;
-          delete handlerCache[_key];
+          delete handlerCache[key];
         }
       }
 
       return removedCount;
-    });
+    };
 
-    _defineProperty(this, "cloneData", function () {
+    this.cloneData = () => {
       try {
-        return deepClone(_this._cache);
+        return deepClone(this._cache);
       } catch (e) {
-        throw new Error("An error occurred while trying to clone the cache: ".concat(e));
+        throw new Error(`An error occurred while trying to clone the cache: ${e}`);
       }
-    });
+    };
 
     this._cache = {};
 
@@ -338,25 +121,21 @@ var MemoryCache = /*#__PURE__*/function () {
          * So we deep clone it and then assign the clone values to our
          * internal cache.
          */
-        var cloneInitCache = deepClone(source);
+        const cloneInitCache = deepClone(source);
         Object.assign(this._cache, cloneInitCache);
       } catch (e) {
-        throw new Error("An error occurred trying to initialize from a response cache snapshot: ".concat(e));
+        throw new Error(`An error occurred trying to initialize from a response cache snapshot: ${e}`);
       }
     }
   }
 
-  _createClass(MemoryCache, [{
-    key: "inUse",
-    get: function get() {
-      return Object.keys(this._cache).length > 0;
-    }
-  }]);
+  get inUse() {
+    return Object.keys(this._cache).length > 0;
+  }
 
-  return MemoryCache;
-}();
+}
 
-var defaultInstance = null;
+let defaultInstance = null;
 /**
  * This is a cache implementation to use when no caching is wanted.
  *
@@ -369,46 +148,34 @@ var defaultInstance = null;
  * requested data after hydration has finished.
  */
 
-var NoCache = /*#__PURE__*/function () {
-  function NoCache() {
-    _classCallCheck(this, NoCache);
-
-    _defineProperty(this, "store", function (handler, options, entry) {
+class NoCache {
+  constructor() {
+    this.store = (handler, options, entry) => {
       /* empty */
-    });
+    };
 
-    _defineProperty(this, "retrieve", function (handler, options) {
-      return null;
-    });
+    this.retrieve = (handler, options) => null;
 
-    _defineProperty(this, "remove", function (handler, options) {
-      return false;
-    });
+    this.remove = (handler, options) => false;
 
-    _defineProperty(this, "removeAll", function (handler, predicate) {
-      return 0;
-    });
+    this.removeAll = (handler, predicate) => 0;
   }
 
-  _createClass(NoCache, null, [{
-    key: "Default",
-    get: function get() {
-      if (defaultInstance == null) {
-        defaultInstance = new NoCache();
-      }
-
-      return defaultInstance;
+  static get Default() {
+    if (defaultInstance == null) {
+      defaultInstance = new NoCache();
     }
-  }]);
 
-  return NoCache;
-}();
+    return defaultInstance;
+  }
+
+}
 
 /**
  * The default instance is stored here.
  * It's created below in the Default() static property.
  */
-var _default;
+let _default;
 /**
  * Implements the response cache.
  *
@@ -416,60 +183,46 @@ var _default;
  */
 
 
-var ResponseCache = /*#__PURE__*/function () {
-  _createClass(ResponseCache, null, [{
-    key: "Default",
-    get: function get() {
-      if (!_default) {
-        _default = new ResponseCache();
-      }
-
-      return _default;
+class ResponseCache {
+  static get Default() {
+    if (!_default) {
+      _default = new ResponseCache();
     }
-  }]);
 
-  function ResponseCache() {
-    var _this = this;
-
-    var memoryCache = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
-    var ssrOnlyCache = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
-
-    _classCallCheck(this, ResponseCache);
-
-    _defineProperty(this, "_hydrationAndDefaultCache", void 0);
-
-    _defineProperty(this, "_ssrOnlyCache", void 0);
+    return _default;
+  }
 
-    _defineProperty(this, "initialize", function (source) {
-      if (_this._hydrationAndDefaultCache.inUse) {
+  constructor(memoryCache = null, ssrOnlyCache = null) {
+    this.initialize = source => {
+      if (this._hydrationAndDefaultCache.inUse) {
         throw new Error("Cannot initialize data response cache more than once");
       }
 
       try {
-        _this._hydrationAndDefaultCache = new MemoryCache(source);
+        this._hydrationAndDefaultCache = new MemoryCache(source);
       } catch (e) {
-        throw new Error("An error occurred trying to initialize the data response cache: ".concat(e));
+        throw new Error(`An error occurred trying to initialize the data response cache: ${e}`);
       }
-    });
+    };
 
-    _defineProperty(this, "cacheData", function (handler, options, data) {
-      return _this._setCacheEntry(handler, options, {
-        data: data
+    this.cacheData = (handler, options, data) => {
+      return this._setCacheEntry(handler, options, {
+        data
       });
-    });
+    };
 
-    _defineProperty(this, "cacheError", function (handler, options, error) {
-      var errorMessage = typeof error === "string" ? error : error.message;
-      return _this._setCacheEntry(handler, options, {
+    this.cacheError = (handler, options, error) => {
+      const errorMessage = typeof error === "string" ? error : error.message;
+      return this._setCacheEntry(handler, options, {
         error: errorMessage
       });
-    });
+    };
 
-    _defineProperty(this, "getEntry", function (handler, options) {
+    this.getEntry = (handler, options) => {
       // If we're not server-side, and the handler has a custom cache
       // let's try to use it.
-      if (_this._ssrOnlyCache == null && handler.cache != null) {
-        var entry = handler.cache.retrieve(handler, options);
+      if (this._ssrOnlyCache == null && handler.cache != null) {
+        const entry = handler.cache.retrieve(handler, options);
 
         if (entry != null) {
           // Custom cache has an entry, so use it.
@@ -481,12 +234,12 @@ var ResponseCache = /*#__PURE__*/function () {
       // we would never hydrate properly.
 
 
-      var internalEntry = _this._defaultCache(handler).retrieve(handler, options); // If we are not server-side and we hydrated something that the custom
+      const internalEntry = this._defaultCache(handler).retrieve(handler, options); // If we are not server-side and we hydrated something that the custom
       // cache didn't have, we need to make sure the custom cache contains
       // that value.
 
 
-      if (_this._ssrOnlyCache == null && handler.cache != null && internalEntry != null) {
+      if (this._ssrOnlyCache == null && handler.cache != null && internalEntry != null) {
         // Yes, if this throws, we will have a problem. We want that.
         // Bad cache implementations should be overt.
         handler.cache.store(handler, options, internalEntry); // We now delete this from our in-memory cache as we don't need it.
@@ -495,51 +248,51 @@ var ResponseCache = /*#__PURE__*/function () {
         // expected valid usage of this framework - two handlers with
         // different caching options shouldn't be using the same type name.
 
-        _this._hydrationAndDefaultCache.remove(handler, options);
+        this._hydrationAndDefaultCache.remove(handler, options);
       }
 
       return internalEntry;
-    });
+    };
 
-    _defineProperty(this, "remove", function (handler, options) {
+    this.remove = (handler, options) => {
       // NOTE(somewhatabstract): We could invoke removeAll with a predicate
       // to match the key of the entry we're removing, but that's an
       // inefficient way to remove a single item, so let's not do that.
       // If we're not server-side, and the handler has a custom cache
       // let's try to use it.
-      var customCache = _this._ssrOnlyCache == null ? handler.cache : null;
-      var removedCustom = !!(customCache === null || customCache === void 0 ? void 0 : customCache.remove(handler, options)); // Delete the entry from our internal cache.
+      const customCache = this._ssrOnlyCache == null ? handler.cache : null;
+      const removedCustom = !!(customCache != null && customCache.remove(handler, options)); // Delete the entry from our internal cache.
       // Even if we have a custom cache, we want to make sure we still
       // removed the same value from internal cache since this could be
       // getting called before hydration for some complex advanced usage
       // reason.
 
-      return _this._defaultCache(handler).remove(handler, options) || removedCustom;
-    });
+      return this._defaultCache(handler).remove(handler, options) || removedCustom;
+    };
 
-    _defineProperty(this, "removeAll", function (handler, predicate) {
+    this.removeAll = (handler, predicate) => {
       // If we're not server-side, and the handler has a custom cache
       // let's try to use it.
-      var customCache = _this._ssrOnlyCache == null ? handler.cache : null;
-      var removedCountCustom = (customCache === null || customCache === void 0 ? void 0 : customCache.removeAll(handler, predicate)) || 0; // Apply the predicate to what we have in our internal cached.
+      const customCache = this._ssrOnlyCache == null ? handler.cache : null;
+      const removedCountCustom = (customCache == null ? void 0 : customCache.removeAll(handler, predicate)) || 0; // Apply the predicate to what we have in our internal cached.
       // Even if we have a custom cache, we want to make sure we still
       // removed the same value from internal cache since this could be
       // getting called before hydration for some complex advanced usage
       // reason.
 
-      var removedCount = _this._defaultCache(handler).removeAll(handler, predicate); // We have no idea which keys were removed from which caches,
+      const removedCount = this._defaultCache(handler).removeAll(handler, predicate); // We have no idea which keys were removed from which caches,
       // so we can't dedupe the remove counts based on keys.
       // That's why we return the total records deleted rather than the
       // total keys deleted.
 
 
       return removedCount + removedCountCustom;
-    });
+    };
 
-    _defineProperty(this, "cloneHydratableData", function () {
+    this.cloneHydratableData = () => {
       // We return our hydration cache only.
-      return _this._hydrationAndDefaultCache.cloneData();
-    });
+      return this._hydrationAndDefaultCache.cloneData();
+    };
 
     this._ssrOnlyCache = Server.isServerSide() ? ssrOnlyCache || new MemoryCache() : undefined;
     this._hydrationAndDefaultCache = memoryCache || new MemoryCache();
@@ -549,87 +302,71 @@ var ResponseCache = /*#__PURE__*/function () {
    */
 
 
-  _createClass(ResponseCache, [{
-    key: "_defaultCache",
-    value: function _defaultCache(handler) {
-      if (handler.hydrate) {
-        return this._hydrationAndDefaultCache;
-      } // If the handler doesn't want to hydrate, we return the SSR-only cache.
-      // If we are client-side, we return our non-caching implementation.
+  _defaultCache(handler) {
+    if (handler.hydrate) {
+      return this._hydrationAndDefaultCache;
+    } // If the handler doesn't want to hydrate, we return the SSR-only cache.
+    // If we are client-side, we return our non-caching implementation.
 
 
-      return this._ssrOnlyCache || NoCache.Default;
-    }
-  }, {
-    key: "_setCacheEntry",
-    value: function _setCacheEntry(handler, options, entry) {
-      var frozenEntry = Object.freeze(entry);
+    return this._ssrOnlyCache || NoCache.Default;
+  }
 
-      if (this._ssrOnlyCache == null && handler.cache != null) {
-        // We are not server-side, and our handler has its own cache,
-        // so we use that to store values.
-        handler.cache.store(handler, options, frozenEntry);
-      } else {
-        // We are either server-side, or our handler doesn't provide
-        // a caching override.
-        this._defaultCache(handler).store(handler, options, frozenEntry);
-      }
+  _setCacheEntry(handler, options, entry) {
+    const frozenEntry = Object.freeze(entry);
 
-      return frozenEntry;
+    if (this._ssrOnlyCache == null && handler.cache != null) {
+      // We are not server-side, and our handler has its own cache,
+      // so we use that to store values.
+      handler.cache.store(handler, options, frozenEntry);
+    } else {
+      // We are either server-side, or our handler doesn't provide
+      // a caching override.
+      this._defaultCache(handler).store(handler, options, frozenEntry);
     }
-    /**
-     * Initialize the cache from a given cache state.
-     *
-     * This can only be called if the cache is not already in use.
-     */
 
-  }]);
+    return frozenEntry;
+  }
+  /**
+   * Initialize the cache from a given cache state.
+   *
+   * This can only be called if the cache is not already in use.
+   */
 
-  return ResponseCache;
-}();
 
-var _default$1;
+}
 
-var RequestFulfillment = /*#__PURE__*/function () {
-  _createClass(RequestFulfillment, null, [{
-    key: "Default",
-    get: function get() {
-      if (!_default$1) {
-        _default$1 = new RequestFulfillment();
-      }
+let _default$1;
 
-      return _default$1;
+class RequestFulfillment {
+  static get Default() {
+    if (!_default$1) {
+      _default$1 = new RequestFulfillment();
     }
-  }]);
-
-  function RequestFulfillment() {
-    var _this = this;
-
-    var responseCache = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : undefined;
 
-    _classCallCheck(this, RequestFulfillment);
-
-    _defineProperty(this, "_responseCache", void 0);
+    return _default$1;
+  }
 
-    _defineProperty(this, "_requests", {});
+  constructor(responseCache = undefined) {
+    this._requests = {};
 
-    _defineProperty(this, "_getHandlerSubcache", function (handler) {
-      if (!_this._requests[handler.type]) {
-        _this._requests[handler.type] = {};
+    this._getHandlerSubcache = handler => {
+      if (!this._requests[handler.type]) {
+        this._requests[handler.type] = {};
       }
 
-      return _this._requests[handler.type];
-    });
+      return this._requests[handler.type];
+    };
 
-    _defineProperty(this, "fulfill", function (handler, options) {
-      var handlerRequests = _this._getHandlerSubcache(handler);
+    this.fulfill = (handler, options) => {
+      const handlerRequests = this._getHandlerSubcache(handler);
 
-      var key = handler.getKey(options);
+      const key = handler.getKey(options);
       /**
        * If we have an inflight request, we'll provide that.
        */
 
-      var inflight = handlerRequests[key];
+      const inflight = handlerRequests[key];
 
       if (inflight) {
         return inflight;
@@ -639,19 +376,20 @@ var RequestFulfillment = /*#__PURE__*/function () {
        */
 
 
-      var _this$_responseCache = _this._responseCache,
-          cacheData = _this$_responseCache.cacheData,
-          cacheError = _this$_responseCache.cacheError;
+      const {
+        cacheData,
+        cacheError
+      } = this._responseCache;
 
       try {
-        var request = handler.fulfillRequest(options).then(function (data) {
+        const request = handler.fulfillRequest(options).then(data => {
           delete handlerRequests[key];
           /**
            * Let's cache the data!
            */
 
           return cacheData(handler, options, data);
-        }).catch(function (error) {
+        }).catch(error => {
           delete handlerRequests[key];
           /**
            * Let's cache the error!
@@ -668,26 +406,25 @@ var RequestFulfillment = /*#__PURE__*/function () {
          */
         return Promise.resolve(cacheError(handler, options, e));
       }
-    });
+    };
 
     this._responseCache = responseCache || ResponseCache.Default;
   }
 
-  return RequestFulfillment;
-}();
+}
 
 /**
  * Used to inject our tracking function into the render framework.
  *
  * INTERNAL USE ONLY
  */
-var TrackerContext = new createContext(null);
+const TrackerContext = new createContext(null);
 /**
  * The default instance is stored here.
  * It's created below in the Default() static property.
  */
 
-var _default$2;
+let _default$2;
 /**
  * Implements request tracking and fulfillment.
  *
@@ -695,76 +432,59 @@ var _default$2;
  */
 
 
-var RequestTracker = /*#__PURE__*/function () {
-  _createClass(RequestTracker, null, [{
-    key: "Default",
-    get: function get() {
-      if (!_default$2) {
-        _default$2 = new RequestTracker();
-      }
-
-      return _default$2;
+class RequestTracker {
+  static get Default() {
+    if (!_default$2) {
+      _default$2 = new RequestTracker();
     }
-    /**
-     * These are the caches for tracked requests, their handlers, and responses.
-     */
-
-  }]);
-
-  function RequestTracker() {
-    var _this = this;
-
-    var responseCache = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : undefined;
 
-    _classCallCheck(this, RequestTracker);
-
-    _defineProperty(this, "_trackedHandlers", {});
-
-    _defineProperty(this, "_trackedRequests", {});
+    return _default$2;
+  }
+  /**
+   * These are the caches for tracked requests, their handlers, and responses.
+   */
 
-    _defineProperty(this, "_responseCache", void 0);
 
-    _defineProperty(this, "_requestFulfillment", void 0);
+  constructor(responseCache = undefined) {
+    this._trackedHandlers = {};
+    this._trackedRequests = {};
 
-    _defineProperty(this, "trackDataRequest", function (handler, options) {
-      var key = handler.getKey(options);
-      var type = handler.type;
+    this.trackDataRequest = (handler, options) => {
+      const key = handler.getKey(options);
+      const type = handler.type;
       /**
        * Make sure we have stored the handler for use when fulfilling requests.
        */
 
-      if (_this._trackedHandlers[type] == null) {
-        _this._trackedHandlers[type] = handler;
-        _this._trackedRequests[type] = {};
+      if (this._trackedHandlers[type] == null) {
+        this._trackedHandlers[type] = handler;
+        this._trackedRequests[type] = {};
       }
       /**
        * If we don't already have this tracked, then let's track it.
        */
 
 
-      if (_this._trackedRequests[type][key] == null) {
-        _this._trackedRequests[type][key] = options;
+      if (this._trackedRequests[type][key] == null) {
+        this._trackedRequests[type][key] = options;
       }
-    });
-
-    _defineProperty(this, "reset", function () {
-      _this._trackedHandlers = {};
-      _this._trackedRequests = {};
-    });
+    };
 
-    _defineProperty(this, "fulfillTrackedRequests", function () {
-      var promises = [];
+    this.reset = () => {
+      this._trackedHandlers = {};
+      this._trackedRequests = {};
+    };
 
-      for (var _i = 0, _Object$keys = Object.keys(_this._trackedHandlers); _i < _Object$keys.length; _i++) {
-        var _handlerType = _Object$keys[_i];
-        var _handler = _this._trackedHandlers[_handlerType]; // For each handler, we will perform the request fulfillments!
+    this.fulfillTrackedRequests = () => {
+      const promises = [];
 
-        var requests = _this._trackedRequests[_handlerType];
+      for (const handlerType of Object.keys(this._trackedHandlers)) {
+        const handler = this._trackedHandlers[handlerType]; // For each handler, we will perform the request fulfillments!
 
-        for (var _i2 = 0, _Object$keys2 = Object.keys(requests); _i2 < _Object$keys2.length; _i2++) {
-          var requestKey = _Object$keys2[_i2];
+        const requests = this._trackedRequests[handlerType];
 
-          var promise = _this._requestFulfillment.fulfill(_handler, requests[requestKey]);
+        for (const requestKey of Object.keys(requests)) {
+          const promise = this._requestFulfillment.fulfill(handler, requests[requestKey]);
 
           promises.push(promise);
         }
@@ -788,16 +508,13 @@ var RequestTracker = /*#__PURE__*/function () {
        */
 
 
-      _this.reset();
+      this.reset();
       /**
        * Let's wait for everything to fulfill, and then clone the cached data.
        */
 
-
-      return Promise.all(promises).then(function () {
-        return _this._responseCache.cloneHydratableData();
-      });
-    });
+      return Promise.all(promises).then(() => this._responseCache.cloneHydratableData());
+    };
 
     this._responseCache = responseCache || ResponseCache.Default;
     this._requestFulfillment = new RequestFulfillment(responseCache);
@@ -810,33 +527,28 @@ var RequestTracker = /*#__PURE__*/function () {
    */
 
 
-  _createClass(RequestTracker, [{
-    key: "hasUnfulfilledRequests",
-
-    /**
-     * Indicates if we have requests waiting to be fulfilled.
-     */
-    get: function get() {
-      return Object.keys(this._trackedRequests).length > 0;
-    }
-    /**
-     * Initiate fulfillment of all tracked requests.
-     *
-     * This loops over the requests that were tracked using TrackData, and asks
-     * the respective handlers to fulfill those requests in the order they were
-     * tracked.
-     *
-     * Calling this method marks tracked requests as fulfilled; requests are
-     * removed from the list of tracked requests by calling this method.
-     *
-     * @returns {Promise<Cache>} A frozen cache of the data that was cached
-     * as a result of fulfilling the tracked requests.
-     */
+  /**
+   * Indicates if we have requests waiting to be fulfilled.
+   */
+  get hasUnfulfilledRequests() {
+    return Object.keys(this._trackedRequests).length > 0;
+  }
+  /**
+   * Initiate fulfillment of all tracked requests.
+   *
+   * This loops over the requests that were tracked using TrackData, and asks
+   * the respective handlers to fulfill those requests in the order they were
+   * tracked.
+   *
+   * Calling this method marks tracked requests as fulfilled; requests are
+   * removed from the list of tracked requests by calling this method.
+   *
+   * @returns {Promise<Cache>} A frozen cache of the data that was cached
+   * as a result of fulfilling the tracked requests.
+   */
 
-  }]);
 
-  return RequestTracker;
-}();
+}
 
 /**
  * Base implementation for creating a request handler.
@@ -844,99 +556,66 @@ var RequestTracker = /*#__PURE__*/function () {
  * Provides a base implementation of the `IRequestHandler` base class for
  * use with the Wonder Blocks Data framework.
  */
-var RequestHandler = /*#__PURE__*/function () {
-  function RequestHandler(type, cache) {
-    var hydrate = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
-
-    _classCallCheck(this, RequestHandler);
-
-    _defineProperty(this, "_type", void 0);
-
-    _defineProperty(this, "_cache", void 0);
-
-    _defineProperty(this, "_hydrate", void 0);
-
+class RequestHandler {
+  constructor(type, cache, hydrate = true) {
     this._type = type;
     this._cache = cache || null;
     this._hydrate = !!hydrate;
   }
 
-  _createClass(RequestHandler, [{
-    key: "shouldRefreshCache",
-    value: function shouldRefreshCache(options, cachedEntry) {
-      /**
-       * By default, the cache needs a refresh if the current entry is an
-       * error.
-       *
-       * This means that an error will cause a re-request on render.
-       * Useful if the server rendered an error, as it means the client
-       * will update after rehydration.
-       */
-      return cachedEntry == null || cachedEntry.error != null;
-    }
-  }, {
-    key: "getKey",
-    value: function getKey(options) {
-      try {
-        return options === undefined ? "undefined" : JSON.stringify(options);
-      } catch (e) {
-        throw new Error("Failed to auto-generate key: ".concat(e));
-      }
-    }
-  }, {
-    key: "fulfillRequest",
-    value: function fulfillRequest(options) {
-      throw new Error("Not implemented");
-    }
-  }, {
-    key: "type",
-    get: function get() {
-      return this._type;
-    }
-  }, {
-    key: "cache",
-    get: function get() {
-      return this._cache;
-    }
-  }, {
-    key: "hydrate",
-    get: function get() {
-      return this._hydrate;
-    }
-  }]);
+  get type() {
+    return this._type;
+  }
 
-  return RequestHandler;
-}();
+  get cache() {
+    return this._cache;
+  }
 
-/**
- * Component to enable data request tracking when server-side rendering.
- */
-var TrackData = /*#__PURE__*/function (_React$Component) {
-  _inherits(TrackData, _React$Component);
+  get hydrate() {
+    return this._hydrate;
+  }
 
-  var _super = _createSuper(TrackData);
+  shouldRefreshCache(options, cachedEntry) {
+    /**
+     * By default, the cache needs a refresh if the current entry is an
+     * error.
+     *
+     * This means that an error will cause a re-request on render.
+     * Useful if the server rendered an error, as it means the client
+     * will update after rehydration.
+     */
+    return cachedEntry == null || cachedEntry.error != null;
+  }
 
-  function TrackData() {
-    _classCallCheck(this, TrackData);
+  getKey(options) {
+    try {
+      return options === undefined ? "undefined" : JSON.stringify(options);
+    } catch (e) {
+      throw new Error(`Failed to auto-generate key: ${e}`);
+    }
+  }
 
-    return _super.apply(this, arguments);
+  fulfillRequest(options) {
+    throw new Error("Not implemented");
   }
 
-  _createClass(TrackData, [{
-    key: "render",
-    value: function render() {
-      if (!Server.isServerSide()) {
-        throw new Error("This component is not for use during client-side rendering");
-      }
+}
 
-      return /*#__PURE__*/createElement(TrackerContext.Provider, {
-        value: RequestTracker.Default.trackDataRequest
-      }, this.props.children);
+/**
+ * Component to enable data request tracking when server-side rendering.
+ */
+class TrackData extends Component {
+  render() {
+    if (!Server.isServerSide()) {
+      throw new Error("This component is not for use during client-side rendering");
     }
-  }]);
 
-  return TrackData;
-}(Component);
+    return /*#__PURE__*/createElement(TrackerContext.Provider, {
+      value: RequestTracker.Default.trackDataRequest
+    }, this.props.children);
+  }
+
+}
 
 /**
  * This component is responsible for actually handling the data request.
@@ -944,314 +623,272 @@ var TrackData = /*#__PURE__*/function (_React$Component) {
  *
  * INTERNAL USE ONLY
  */
-var InternalData = /*#__PURE__*/function (_React$Component) {
-  _inherits(InternalData, _React$Component);
+class InternalData extends Component {
+  constructor(props) {
+    super(props);
+    this.state = this._buildStateAndfulfillNeeds(props);
+  }
 
-  var _super = _createSuper(InternalData);
+  componentDidMount() {
+    this._mounted = true;
+  }
 
-  function InternalData(props) {
-    var _this;
+  shouldComponentUpdate(nextProps, nextState) {
+    /**
+     * We only bother updating if our state changed.
+     *
+     * And we only update the state if props changed
+     * or we got new data/error.
+     */
+    if (!this._propsMatch(nextProps)) {
+      const newState = this._buildStateAndfulfillNeeds(nextProps);
 
-    _classCallCheck(this, InternalData);
+      this.setState(newState);
+    }
 
-    _this = _super.call(this, props);
+    return this.state.loading !== nextState.loading || this.state.data !== nextState.data || this.state.error !== nextState.error;
+  }
 
-    _defineProperty(_assertThisInitialized(_this), "_mounted", void 0);
+  componentWillUnmount() {
+    this._mounted = false;
+  }
 
-    _this.state = _this._buildStateAndfulfillNeeds(props);
-    return _this;
+  _propsMatch(otherProps) {
+    const {
+      handler,
+      options
+    } = this.props;
+    const {
+      handler: prevHandler,
+      options: prevOptions
+    } = otherProps;
+    return handler === prevHandler && handler.getKey(options) === prevHandler.getKey(prevOptions);
   }
 
-  _createClass(InternalData, [{
-    key: "componentDidMount",
-    value: function componentDidMount() {
-      this._mounted = true;
-    }
-  }, {
-    key: "shouldComponentUpdate",
-    value: function shouldComponentUpdate(nextProps, nextState) {
+  _buildStateAndfulfillNeeds(propsAtFulfillment) {
+    const {
+      getEntry,
+      handler,
+      options
+    } = propsAtFulfillment;
+    const cachedData = getEntry(handler, options);
+
+    if (!Server.isServerSide() && (cachedData == null || handler.shouldRefreshCache(options, cachedData))) {
       /**
-       * We only bother updating if our state changed.
+       * We're not on the server, the cache missed, or our handler says
+       * we should refresh the cache.
+       *
+       * Therefore, we need to request data.
        *
-       * And we only update the state if props changed
-       * or we got new data/error.
+       * We have to do this here from the constructor so that this
+       * data request is tracked when performing server-side rendering.
        */
-      if (!this._propsMatch(nextProps)) {
-        var newState = this._buildStateAndfulfillNeeds(nextProps);
+      RequestFulfillment.Default.fulfill(handler, options).then(cacheEntry => {
+        /**
+         * We get here, we should have updated the cache.
+         * However, we need to update the component, but we
+         * should only do that if the props are the same as they
+         * were when this was called.
+         */
+        if (this._mounted && this._propsMatch(propsAtFulfillment)) {
+          this.setState({
+            loading: false,
+            data: cacheEntry.data,
+            error: cacheEntry.error
+          });
+        }
 
-        this.setState(newState);
-      }
+        return null;
+      }).catch(e => {
+        /**
+         * We should never get here, but if we do.
+         */
+        // eslint-disable-next-line no-console
+        console.error(`Unexpected error occurred during data fulfillment: ${e}`);
+
+        if (this._mounted && this._propsMatch(propsAtFulfillment)) {
+          this.setState({
+            loading: false,
+            data: null,
+            error: typeof e === "string" ? e : e.message
+          });
+        }
 
-      return this.state.loading !== nextState.loading || this.state.data !== nextState.data || this.state.error !== nextState.error;
-    }
-  }, {
-    key: "componentWillUnmount",
-    value: function componentWillUnmount() {
-      this._mounted = false;
-    }
-  }, {
-    key: "_propsMatch",
-    value: function _propsMatch(otherProps) {
-      var _this$props = this.props,
-          handler = _this$props.handler,
-          options = _this$props.options;
-      var prevHandler = otherProps.handler,
-          prevOptions = otherProps.options;
-      return handler === prevHandler && handler.getKey(options) === prevHandler.getKey(prevOptions);
+        return null;
+      });
     }
-  }, {
-    key: "_buildStateAndfulfillNeeds",
-    value: function _buildStateAndfulfillNeeds(propsAtFulfillment) {
-      var _this2 = this;
+    /**
+     * This is the default response for the server and for the initial
+     * client-side render if we have cachedData.
+     *
+     * This ensures we don't make promises we don't want when doing
+     * server-side rendering. Instead, we either have data from the cache
+     * or we don't.
+     */
 
-      var getEntry = propsAtFulfillment.getEntry,
-          handler = propsAtFulfillment.handler,
-          options = propsAtFulfillment.options;
-      var cachedData = getEntry(handler, options);
 
-      if (!Server.isServerSide() && (cachedData == null || handler.shouldRefreshCache(options, cachedData))) {
-        /**
-         * We're not on the server, the cache missed, or our handler says
-         * we should refresh the cache.
-         *
-         * Therefore, we need to request data.
-         *
-         * We have to do this here from the constructor so that this
-         * data request is tracked when performing server-side rendering.
-         */
-        RequestFulfillment.Default.fulfill(handler, options).then(function (cacheEntry) {
-          /**
-           * We get here, we should have updated the cache.
-           * However, we need to update the component, but we
-           * should only do that if the props are the same as they
-           * were when this was called.
-           */
-          if (_this2._mounted && _this2._propsMatch(propsAtFulfillment)) {
-            _this2.setState({
-              loading: false,
-              data: cacheEntry.data,
-              error: cacheEntry.error
-            });
-          }
-
-          return null;
-        }).catch(function (e) {
-          /**
-           * We should never get here, but if we do.
-           */
-          // eslint-disable-next-line no-console
-          console.error("Unexpected error occurred during data fulfillment: ".concat(e));
-
-          if (_this2._mounted && _this2._propsMatch(propsAtFulfillment)) {
-            _this2.setState({
-              loading: false,
-              data: null,
-              error: typeof e === "string" ? e : e.message
-            });
-          }
-
-          return null;
-        });
-      }
-      /**
-       * This is the default response for the server and for the initial
-       * client-side render if we have cachedData.
-       *
-       * This ensures we don't make promises we don't want when doing
-       * server-side rendering. Instead, we either have data from the cache
-       * or we don't.
-       */
+    return {
+      loading: cachedData == null,
+      data: cachedData && cachedData.data,
+      error: cachedData && cachedData.error
+    };
+  }
 
+  _resultFromState() {
+    const {
+      loading,
+      data,
+      error
+    } = this.state;
 
+    if (loading) {
       return {
-        loading: cachedData == null,
-        data: cachedData && cachedData.data,
-        error: cachedData && cachedData.error
+        loading: true
       };
     }
-  }, {
-    key: "_resultFromState",
-    value: function _resultFromState() {
-      var _this$state = this.state,
-          loading = _this$state.loading,
-          data = _this$state.data,
-          error = _this$state.error;
-
-      if (loading) {
-        return {
-          loading: true
-        };
-      }
-
-      if (data != null) {
-        return {
-          loading: false,
-          data: data
-        };
-      }
-
-      if (error == null) {
-        // We should never get here ever.
-        throw new Error("Loaded result has invalid state where data and error are missing");
-      }
 
+    if (data != null) {
       return {
         loading: false,
-        error: error
+        data
       };
     }
-  }, {
-    key: "_renderContent",
-    value: function _renderContent(result) {
-      var children = this.props.children;
-      return children(result);
-    }
-  }, {
-    key: "_renderWithTrackingContext",
-    value: function _renderWithTrackingContext(result) {
-      var _this3 = this;
 
-      return /*#__PURE__*/createElement(TrackerContext.Consumer, null, function (track) {
-        /**
-         * If data tracking wasn't enabled, don't do it.
-         */
-        if (track != null) {
-          track(_this3.props.handler, _this3.props.options);
-        }
-
-        return _this3._renderContent(result);
-      });
+    if (error == null) {
+      // We should never get here ever.
+      throw new Error("Loaded result has invalid state where data and error are missing");
     }
-  }, {
-    key: "render",
-    value: function render() {
-      var result = this._resultFromState(); // We only track data requests when we are server-side and we don't
-      // already have a result. The existence of a result is indicated by the
-      // loading flag being false.
 
+    return {
+      loading: false,
+      error
+    };
+  }
+
+  _renderContent(result) {
+    const {
+      children
+    } = this.props;
+    return children(result);
+  }
 
-      if (result.loading && Server.isServerSide()) {
-        return this._renderWithTrackingContext(result);
+  _renderWithTrackingContext(result) {
+    return /*#__PURE__*/createElement(TrackerContext.Consumer, null, track => {
+      /**
+       * If data tracking wasn't enabled, don't do it.
+       */
+      if (track != null) {
+        track(this.props.handler, this.props.options);
       }
 
       return this._renderContent(result);
+    });
+  }
+
+  render() {
+    const result = this._resultFromState(); // We only track data requests when we are server-side and we don't
+    // already have a result. The existence of a result is indicated by the
+    // loading flag being false.
+
+
+    if (result.loading && Server.isServerSide()) {
+      return this._renderWithTrackingContext(result);
     }
-  }]);
 
-  return InternalData;
-}(Component);
+    return this._renderContent(result);
+  }
+
+}
 
 /**
  * InterceptContext defines a map from handler type to interception methods.
  *
  * INTERNAL USE ONLY
  */
-var InterceptContext = createContext({});
+const InterceptContext = /*#__PURE__*/createContext({});
 
 /**
  * This component is the main component of Wonder Blocks Data. With this, data
  * requirements can be placed in a React application in a manner that will
  * support server-side rendering and efficient caching.
  */
-var Data = /*#__PURE__*/function (_React$Component) {
-  _inherits(Data, _React$Component);
-
-  var _super = _createSuper(Data);
-
-  function Data() {
-    _classCallCheck(this, Data);
-
-    return _super.apply(this, arguments);
+class Data extends Component {
+  _getHandlerFromInterceptor(interceptor) {
+    const {
+      handler
+    } = this.props;
+
+    if (!interceptor) {
+      return handler;
+    }
+
+    const {
+      fulfillRequest,
+      shouldRefreshCache
+    } = interceptor;
+    const fulfillRequestFn = fulfillRequest ? options => {
+      const interceptedResult = fulfillRequest(options);
+      return interceptedResult != null ? interceptedResult : handler.fulfillRequest(options);
+    } : options => handler.fulfillRequest(options);
+    const shouldRefreshCacheFn = shouldRefreshCache ? (options, cacheEntry) => {
+      const interceptedResult = shouldRefreshCache(options, cacheEntry);
+      return interceptedResult != null ? interceptedResult : handler.shouldRefreshCache(options, cacheEntry);
+    } : (options, cacheEntry) => handler.shouldRefreshCache(options, cacheEntry);
+    return {
+      fulfillRequest: fulfillRequestFn,
+      shouldRefreshCache: shouldRefreshCacheFn,
+      getKey: options => handler.getKey(options),
+      type: handler.type,
+      cache: handler.cache,
+      hydrate: handler.hydrate
+    };
   }
 
-  _createClass(Data, [{
-    key: "_getHandlerFromInterceptor",
-    value: function _getHandlerFromInterceptor(interceptor) {
-      var handler = this.props.handler;
+  _getCacheLookupFnFromInterceptor(interceptor) {
+    const getEntry = interceptor && interceptor.getEntry;
 
-      if (!interceptor) {
-        return handler;
-      }
-
-      var fulfillRequest = interceptor.fulfillRequest,
-          shouldRefreshCache = interceptor.shouldRefreshCache;
-      var fulfillRequestFn = fulfillRequest ? function (options) {
-        var interceptedResult = fulfillRequest(options);
-        return interceptedResult != null ? interceptedResult : handler.fulfillRequest(options);
-      } : function (options) {
-        return handler.fulfillRequest(options);
-      };
-      var shouldRefreshCacheFn = shouldRefreshCache ? function (options, cacheEntry) {
-        var interceptedResult = shouldRefreshCache(options, cacheEntry);
-        return interceptedResult != null ? interceptedResult : handler.shouldRefreshCache(options, cacheEntry);
-      } : function (options, cacheEntry) {
-        return handler.shouldRefreshCache(options, cacheEntry);
-      };
-      return {
-        fulfillRequest: fulfillRequestFn,
-        shouldRefreshCache: shouldRefreshCacheFn,
-        getKey: function getKey(options) {
-          return handler.getKey(options);
-        },
-        type: handler.type,
-        cache: handler.cache,
-        hydrate: handler.hydrate
-      };
+    if (!getEntry) {
+      return ResponseCache.Default.getEntry;
     }
-  }, {
-    key: "_getCacheLookupFnFromInterceptor",
-    value: function _getCacheLookupFnFromInterceptor(interceptor) {
-      var getEntry = interceptor && interceptor.getEntry;
-
-      if (!getEntry) {
-        return ResponseCache.Default.getEntry;
-      }
 
-      return function (handler, options) {
-        // 1. Lookup the current cache value.
-        var cacheEntry = ResponseCache.Default.getEntry(handler, options); // 2. See if our interceptor wants to override it.
+    return (handler, options) => {
+      // 1. Lookup the current cache value.
+      const cacheEntry = ResponseCache.Default.getEntry(handler, options); // 2. See if our interceptor wants to override it.
 
-        var interceptedData = getEntry(options, cacheEntry); // 3. Return the appropriate response.
+      const interceptedData = getEntry(options, cacheEntry); // 3. Return the appropriate response.
 
-        return interceptedData != null ? interceptedData : cacheEntry;
-      };
-    }
-  }, {
-    key: "render",
-    value: function render() {
-      var _this = this;
+      return interceptedData != null ? interceptedData : cacheEntry;
+    };
+  }
 
-      return /*#__PURE__*/createElement(InterceptContext.Consumer, null, function (value) {
-        var handlerType = _this.props.handler.type;
-        var interceptor = value[handlerType];
+  render() {
+    return /*#__PURE__*/createElement(InterceptContext.Consumer, null, value => {
+      const handlerType = this.props.handler.type;
+      const interceptor = value[handlerType];
 
-        var handler = _this._getHandlerFromInterceptor(interceptor);
+      const handler = this._getHandlerFromInterceptor(interceptor);
 
-        var getEntry = _this._getCacheLookupFnFromInterceptor(interceptor);
-        /**
-         * Need to share our types with InternalData so Flow
-         * doesn't need to infer them and find mismatches.
-         * However, just deriving a new component creates issues
-         * where InternalData starts rerendering too often.
-         * Couldn't track down why, so suppressing the error
-         * instead.
-         */
+      const getEntry = this._getCacheLookupFnFromInterceptor(interceptor);
+      /**
+       * Need to share our types with InternalData so Flow
+       * doesn't need to infer them and find mismatches.
+       * However, just deriving a new component creates issues
+       * where InternalData starts rerendering too often.
+       * Couldn't track down why, so suppressing the error
+       * instead.
+       */
 
 
-        return /*#__PURE__*/createElement(InternalData // $FlowIgnore[incompatible-type-arg]
-        , {
-          handler: handler,
-          options: _this.props.options,
-          getEntry: getEntry
-        }, function (result) {
-          return _this.props.children(result);
-        });
-      });
-    }
-  }]);
+      return /*#__PURE__*/createElement(InternalData // $FlowIgnore[incompatible-type-arg]
+      , {
+        handler: handler,
+        options: this.props.options,
+        getEntry: getEntry
+      }, result => this.props.children(result));
+    });
+  }
 
-  return Data;
-}(Component);
+}
 
 /**
  * This component provides a mechanism to intercept the data requests for the
@@ -1272,41 +909,27 @@ var Data = /*#__PURE__*/function (_React$Component) {
  * new instance will replace this interceptor for its children. All methods
  * will be replaced.
  */
-var InterceptData = /*#__PURE__*/function (_React$Component) {
-  _inherits(InterceptData, _React$Component);
-
-  var _super = _createSuper(InterceptData);
+class InterceptData extends Component {
+  render() {
+    return /*#__PURE__*/createElement(InterceptContext.Consumer, null, value => {
+      const handlerType = this.props.handler.type;
+
+      const interceptor = _extends({}, value[handlerType], {
+        fulfillRequest: this.props.fulfillRequest || null,
+        shouldRefreshCache: this.props.shouldRefreshCache || null
+      });
 
-  function InterceptData() {
-    _classCallCheck(this, InterceptData);
+      const newValue = _extends({}, value, {
+        [handlerType]: interceptor
+      });
 
-    return _super.apply(this, arguments);
+      return /*#__PURE__*/createElement(InterceptContext.Provider, {
+        value: newValue
+      }, this.props.children);
+    });
   }
 
-  _createClass(InterceptData, [{
-    key: "render",
-    value: function render() {
-      var _this = this;
-
-      return /*#__PURE__*/createElement(InterceptContext.Consumer, null, function (value) {
-        var handlerType = _this.props.handler.type;
-
-        var interceptor = _objectSpread2(_objectSpread2({}, value[handlerType]), {}, {
-          fulfillRequest: _this.props.fulfillRequest || null,
-          shouldRefreshCache: _this.props.shouldRefreshCache || null
-        });
-
-        var newValue = _objectSpread2(_objectSpread2({}, value), {}, _defineProperty({}, handlerType, interceptor));
-
-        return /*#__PURE__*/createElement(InterceptContext.Provider, {
-          value: newValue
-        }, _this.props.children);
-      });
-    }
-  }]);
-
-  return InterceptData;
-}(Component);
+}
 
 /**
  * This component provides a mechanism to intercept cache lookups for the
@@ -1323,63 +946,43 @@ var InterceptData = /*#__PURE__*/function (_React$Component) {
  * rendered within this one that intercepts the same handler type, then that
  * new instance will replace this interceptor for its children.
  */
-var InterceptCache = /*#__PURE__*/function (_React$Component) {
-  _inherits(InterceptCache, _React$Component);
+class InterceptCache extends Component {
+  render() {
+    return /*#__PURE__*/createElement(InterceptContext.Consumer, null, value => {
+      const handlerType = this.props.handler.type;
 
-  var _super = _createSuper(InterceptCache);
+      const interceptor = _extends({}, value[handlerType], {
+        getEntry: this.props.getEntry
+      });
 
-  function InterceptCache() {
-    _classCallCheck(this, InterceptCache);
+      const newValue = _extends({}, value, {
+        [handlerType]: interceptor
+      });
 
-    return _super.apply(this, arguments);
+      return /*#__PURE__*/createElement(InterceptContext.Provider, {
+        value: newValue
+      }, this.props.children);
+    });
   }
 
-  _createClass(InterceptCache, [{
-    key: "render",
-    value: function render() {
-      var _this = this;
-
-      return /*#__PURE__*/createElement(InterceptContext.Consumer, null, function (value) {
-        var handlerType = _this.props.handler.type;
-
-        var interceptor = _objectSpread2(_objectSpread2({}, value[handlerType]), {}, {
-          getEntry: _this.props.getEntry
-        });
-
-        var newValue = _objectSpread2(_objectSpread2({}, value), {}, _defineProperty({}, handlerType, interceptor));
-
-        return /*#__PURE__*/createElement(InterceptContext.Provider, {
-          value: newValue
-        }, _this.props.children);
-      });
-    }
-  }]);
-
-  return InterceptCache;
-}(Component);
+}
 
-var initializeCache = function initializeCache(source) {
-  return ResponseCache.Default.initialize(source);
-};
-var fulfillAllDataRequests = function fulfillAllDataRequests() {
+const initializeCache = source => ResponseCache.Default.initialize(source);
+const fulfillAllDataRequests = () => {
   if (!Server.isServerSide()) {
     return Promise.reject(new Error("Data requests are not tracked when client-side"));
   }
 
   return RequestTracker.Default.fulfillTrackedRequests();
 };
-var hasUnfulfilledRequests = function hasUnfulfilledRequests() {
+const hasUnfulfilledRequests = () => {
   if (!Server.isServerSide()) {
     throw new Error("Data requests are not tracked when client-side");
   }
 
   return RequestTracker.Default.hasUnfulfilledRequests;
 };
-var removeFromCache = function removeFromCache(handler, options) {
-  return ResponseCache.Default.remove(handler, options);
-};
-var removeAllFromCache = function removeAllFromCache(handler, predicate) {
-  return ResponseCache.Default.removeAll(handler, predicate);
-};
+const removeFromCache = (handler, options) => ResponseCache.Default.remove(handler, options);
+const removeAllFromCache = (handler, predicate) => ResponseCache.Default.removeAll(handler, predicate);
 
 export { Data, InterceptCache, InterceptData, NoCache, RequestHandler, TrackData, fulfillAllDataRequests, hasUnfulfilledRequests, initializeCache, removeAllFromCache, removeFromCache };