@khanacademy/wonder-blocks-data 2.3.0 → 2.3.4

package/dist/index.js

@@ -82,7 +82,7 @@ module.exports =
 /******/
 /******/
 /******/ 	// Load entry module and return exports
-/******/ 	return __webpack_require__(__webpack_require__.s = 2);
+/******/ 	return __webpack_require__(__webpack_require__.s = 14);
 /******/ })
 /************************************************************************/
 /******/ ([
@@ -93,272 +93,14 @@ module.exports = require("react");
 
 /***/ }),
 /* 1 */
-/***/ (function(module, exports) {
-
-module.exports = require("@khanacademy/wonder-blocks-core");
-
-/***/ }),
-/* 2 */
 /***/ (function(module, __webpack_exports__, __webpack_require__) {
 
 "use strict";
-// ESM COMPAT FLAG
-__webpack_require__.r(__webpack_exports__);
-
-// EXPORTS
-__webpack_require__.d(__webpack_exports__, "initializeCache", function() { return /* binding */ src_initializeCache; });
-__webpack_require__.d(__webpack_exports__, "fulfillAllDataRequests", function() { return /* binding */ src_fulfillAllDataRequests; });
-__webpack_require__.d(__webpack_exports__, "hasUnfulfilledRequests", function() { return /* binding */ src_hasUnfulfilledRequests; });
-__webpack_require__.d(__webpack_exports__, "removeFromCache", function() { return /* binding */ src_removeFromCache; });
-__webpack_require__.d(__webpack_exports__, "removeAllFromCache", function() { return /* binding */ src_removeAllFromCache; });
-__webpack_require__.d(__webpack_exports__, "RequestHandler", function() { return /* reexport */ RequestHandler; });
-__webpack_require__.d(__webpack_exports__, "TrackData", function() { return /* reexport */ track_data_TrackData; });
-__webpack_require__.d(__webpack_exports__, "Data", function() { return /* reexport */ data_Data; });
-__webpack_require__.d(__webpack_exports__, "InterceptData", function() { return /* reexport */ intercept_data_InterceptData; });
-__webpack_require__.d(__webpack_exports__, "InterceptCache", function() { return /* reexport */ intercept_cache_InterceptCache; });
-__webpack_require__.d(__webpack_exports__, "NoCache", function() { return /* reexport */ NoCache; });
-
-// EXTERNAL MODULE: external "@khanacademy/wonder-blocks-core"
-var wonder_blocks_core_ = __webpack_require__(1);
-
-// CONCATENATED MODULE: ./packages/wonder-blocks-data/src/util/memory-cache.js
-function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
-
-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."); }
-
-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 _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 _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
-
-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 deepClone(source) {
-  /**
-   * We want to deep clone the source cache to dodge mutations by external
-   * references. So we serialize the source cache to JSON and parse it
-   * back into a new object.
-   *
-   * NOTE: This doesn't work for get/set property accessors.
-   */
-  var serializedInitCache = JSON.stringify(source);
-  var cloneInitCache = JSON.parse(serializedInitCache);
-  return Object.freeze(cloneInitCache);
-}
-/**
- * INTERNAL USE ONLY
- *
- * Special case cache implementation for the memory cache.
- *
- * This is only used within our framework. Handlers don't need to
- * provide this as a custom cache as the framework will default to this in the
- * absence of a custom cache. We use this for SSR too (see ./response-cache.js).
- */
-
-
-var MemoryCache = /*#__PURE__*/function () {
-  function MemoryCache() {
-    var _this = this;
-
-    var source = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
-
-    _classCallCheck(this, MemoryCache);
-
-    _defineProperty(this, "_cache", void 0);
-
-    _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.
-
-      _this._cache[requestType] = _this._cache[requestType] || {}; // Cache the data.
-
-      var key = handler.getKey(options);
-      _this._cache[requestType][key] = frozenEntry;
-    });
-
-    _defineProperty(this, "retrieve", function (handler, options) {
-      var requestType = handler.type; // Get the internal subcache for the handler.
-
-      var handlerCache = _this._cache[requestType];
-
-      if (!handlerCache) {
-        return null;
-      } // Get the response.
-
-
-      var key = handler.getKey(options);
-      var 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
-      // 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];
-
-      if (!handlerCache) {
-        return false;
-      } // Get the entry.
-
-
-      var key = handler.getKey(options);
-      var internalEntry = handlerCache[key];
-
-      if (internalEntry == null) {
-        return false;
-      } // Delete the entry.
-
-
-      delete handlerCache[key];
-      return true;
-    });
-
-    _defineProperty(this, "removeAll", function (handler, predicate) {
-      var requestType = handler.type; // Get the internal subcache for the handler.
-
-      var handlerCache = _this._cache[requestType];
-
-      if (!handlerCache) {
-        return 0;
-      } // Apply the predicate to what we have cached.
-
-
-      var 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)) {
-          removedCount++;
-          delete handlerCache[_key];
-        }
-      }
-
-      return removedCount;
-    });
-
-    _defineProperty(this, "cloneData", function () {
-      try {
-        return deepClone(_this._cache);
-      } catch (e) {
-        throw new Error("An error occurred while trying to clone the cache: ".concat(e));
-      }
-    });
-
-    this._cache = {};
-
-    if (source != null) {
-      try {
-        /**
-         * Object.assign only performs a shallow clone.
-         * So we deep clone it and then assign the clone values to our
-         * internal cache.
-         */
-        var 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));
-      }
-    }
-  }
-
-  _createClass(MemoryCache, [{
-    key: "inUse",
-    get: function get() {
-      return Object.keys(this._cache).length > 0;
-    }
-  }]);
-
-  return MemoryCache;
-}();
-
-
-// CONCATENATED MODULE: ./packages/wonder-blocks-data/src/util/no-cache.js
-function no_cache_classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-function no_cache_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 no_cache_createClass(Constructor, protoProps, staticProps) { if (protoProps) no_cache_defineProperties(Constructor.prototype, protoProps); if (staticProps) no_cache_defineProperties(Constructor, staticProps); return Constructor; }
-
-function no_cache_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; }
-
-var defaultInstance = null;
-/**
- * This is a cache implementation to use when no caching is wanted.
- *
- * Use this with your request handler if you want to support server-side
- * rendering of your data requests, but want to ensure data is never cached
- * on the client-side.
- *
- * This is better than having `shouldRefreshCache` always return `true` in the
- * handler as this ensures that cache space and memory are never used for the
- * requested data after hydration has finished.
- */
-
-var NoCache = /*#__PURE__*/function () {
-  function NoCache() {
-    no_cache_classCallCheck(this, NoCache);
-
-    no_cache_defineProperty(this, "store", function (handler, options, entry) {
-      /* empty */
-    });
-
-    no_cache_defineProperty(this, "retrieve", function (handler, options) {
-      return null;
-    });
-
-    no_cache_defineProperty(this, "remove", function (handler, options) {
-      return false;
-    });
-
-    no_cache_defineProperty(this, "removeAll", function (handler, predicate) {
-      return 0;
-    });
-  }
-
-  no_cache_createClass(NoCache, null, [{
-    key: "Default",
-    get: function get() {
-      if (defaultInstance == null) {
-        defaultInstance = new NoCache();
-      }
-
-      return defaultInstance;
-    }
-  }]);
-
-  return NoCache;
-}();
-
-
-// CONCATENATED MODULE: ./packages/wonder-blocks-data/src/util/response-cache.js
-function response_cache_classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-function response_cache_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 response_cache_createClass(Constructor, protoProps, staticProps) { if (protoProps) response_cache_defineProperties(Constructor.prototype, protoProps); if (staticProps) response_cache_defineProperties(Constructor, staticProps); return Constructor; }
-
-function response_cache_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; }
-
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return ResponseCache; });
+/* harmony import */ var _khanacademy_wonder_blocks_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(2);
+/* harmony import */ var _khanacademy_wonder_blocks_core__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_khanacademy_wonder_blocks_core__WEBPACK_IMPORTED_MODULE_0__);
+/* harmony import */ var _memory_cache_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(7);
+/* harmony import */ var _no_cache_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(5);
 
 
 
@@ -367,7 +109,7 @@ function response_cache_defineProperty(obj, key, value) { if (key in obj) { Obje
  * The default instance is stored here.
  * It's created below in the Default() static property.
  */
-var _default;
+let _default;
 /**
  * Implements the response cache.
  *
@@ -375,60 +117,46 @@ var _default;
  */
 
 
-var response_cache_ResponseCache = /*#__PURE__*/function () {
-  response_cache_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;
 
-    response_cache_classCallCheck(this, ResponseCache);
-
-    response_cache_defineProperty(this, "_hydrationAndDefaultCache", void 0);
-
-    response_cache_defineProperty(this, "_ssrOnlyCache", void 0);
+    return _default;
+  }
 
-    response_cache_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 _memory_cache_js__WEBPACK_IMPORTED_MODULE_1__[/* default */ "a"](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}`);
       }
-    });
+    };
 
-    response_cache_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
       });
-    });
+    };
 
-    response_cache_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
       });
-    });
+    };
 
-    response_cache_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.
@@ -440,12 +168,12 @@ var response_cache_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.
@@ -454,208 +182,111 @@ var response_cache_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;
-    });
+    };
 
-    response_cache_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;
+    };
 
-    response_cache_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;
-    });
+    };
 
-    response_cache_defineProperty(this, "cloneHydratableData", function () {
+    this.cloneHydratableData = () => {
       // We return our hydration cache only.
-      return _this._hydrationAndDefaultCache.cloneData();
-    });
+      return this._hydrationAndDefaultCache.cloneData();
+    };
 
-    this._ssrOnlyCache = wonder_blocks_core_["Server"].isServerSide() ? ssrOnlyCache || new MemoryCache() : undefined;
-    this._hydrationAndDefaultCache = memoryCache || new MemoryCache();
+    this._ssrOnlyCache = _khanacademy_wonder_blocks_core__WEBPACK_IMPORTED_MODULE_0__["Server"].isServerSide() ? ssrOnlyCache || new _memory_cache_js__WEBPACK_IMPORTED_MODULE_1__[/* default */ "a"]() : undefined;
+    this._hydrationAndDefaultCache = memoryCache || new _memory_cache_js__WEBPACK_IMPORTED_MODULE_1__[/* default */ "a"]();
   }
   /**
    * Returns the default cache to use for the given handler.
    */
 
 
-  response_cache_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.
-
-
-      return this._ssrOnlyCache || NoCache.Default;
-    }
-  }, {
-    key: "_setCacheEntry",
-    value: function _setCacheEntry(handler, options, entry) {
-      var frozenEntry = Object.freeze(entry);
-
-      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);
-      }
-
-      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;
-}();
-// EXTERNAL MODULE: external "react"
-var external_react_ = __webpack_require__(0);
+  _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.
 
-// CONCATENATED MODULE: ./packages/wonder-blocks-data/src/util/request-fulfillment.js
-function request_fulfillment_classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 
-function request_fulfillment_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 request_fulfillment_createClass(Constructor, protoProps, staticProps) { if (protoProps) request_fulfillment_defineProperties(Constructor.prototype, protoProps); if (staticProps) request_fulfillment_defineProperties(Constructor, staticProps); return Constructor; }
-
-function request_fulfillment_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; }
-
-
-
-var request_fulfillment_default;
-
-var request_fulfillment_RequestFulfillment = /*#__PURE__*/function () {
-  request_fulfillment_createClass(RequestFulfillment, null, [{
-    key: "Default",
-    get: function get() {
-      if (!request_fulfillment_default) {
-        request_fulfillment_default = new RequestFulfillment();
-      }
+    return this._ssrOnlyCache || _no_cache_js__WEBPACK_IMPORTED_MODULE_2__[/* default */ "a"].Default;
+  }
 
-      return request_fulfillment_default;
+  _setCacheEntry(handler, options, entry) {
+    const frozenEntry = Object.freeze(entry);
+
+    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);
     }
-  }]);
-
-  function RequestFulfillment() {
-    var _this = this;
-
-    var responseCache = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : undefined;
-
-    request_fulfillment_classCallCheck(this, RequestFulfillment);
-
-    request_fulfillment_defineProperty(this, "_responseCache", void 0);
-
-    request_fulfillment_defineProperty(this, "_requests", {});
-
-    request_fulfillment_defineProperty(this, "_getHandlerSubcache", function (handler) {
-      if (!_this._requests[handler.type]) {
-        _this._requests[handler.type] = {};
-      }
-
-      return _this._requests[handler.type];
-    });
-
-    request_fulfillment_defineProperty(this, "fulfill", function (handler, options) {
-      var handlerRequests = _this._getHandlerSubcache(handler);
-
-      var key = handler.getKey(options);
-      /**
-       * If we have an inflight request, we'll provide that.
-       */
-
-      var inflight = handlerRequests[key];
-
-      if (inflight) {
-        return inflight;
-      }
-      /**
-       * We don't have an inflight request, so let's set one up.
-       */
-
-
-      var _this$_responseCache = _this._responseCache,
-          cacheData = _this$_responseCache.cacheData,
-          cacheError = _this$_responseCache.cacheError;
-
-      try {
-        var request = handler.fulfillRequest(options).then(function (data) {
-          delete handlerRequests[key];
-          /**
-           * Let's cache the data!
-           */
-
-          return cacheData(handler, options, data);
-        }).catch(function (error) {
-          delete handlerRequests[key];
-          /**
-           * Let's cache the error!
-           */
-
-          return cacheError(handler, options, error);
-        });
-        handlerRequests[key] = request;
-        return request;
-      } catch (e) {
-        /**
-         * In this case, we don't cache an inflight request, because there
-         * really isn't one.
-         */
-        return Promise.resolve(cacheError(handler, options, e));
-      }
-    });
 
-    this._responseCache = responseCache || response_cache_ResponseCache.Default;
+    return frozenEntry;
   }
+  /**
+   * Initialize the cache from a given cache state.
+   *
+   * This can only be called if the cache is not already in use.
+   */
 
-  return RequestFulfillment;
-}();
-// CONCATENATED MODULE: ./packages/wonder-blocks-data/src/util/request-tracking.js
-function request_tracking_classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 
-function request_tracking_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); } }
+}
+
+/***/ }),
+/* 2 */
+/***/ (function(module, exports) {
 
-function request_tracking_createClass(Constructor, protoProps, staticProps) { if (protoProps) request_tracking_defineProperties(Constructor.prototype, protoProps); if (staticProps) request_tracking_defineProperties(Constructor, staticProps); return Constructor; }
+module.exports = require("@khanacademy/wonder-blocks-core");
 
-function request_tracking_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; }
+/***/ }),
+/* 3 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
 
+"use strict";
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "b", function() { return TrackerContext; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return RequestTracker; });
+/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(0);
+/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(react__WEBPACK_IMPORTED_MODULE_0__);
+/* harmony import */ var _response_cache_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(1);
+/* harmony import */ var _request_fulfillment_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(6);
 
 
 
@@ -665,13 +296,13 @@ function request_tracking_defineProperty(obj, key, value) { if (key in obj) { Ob
  *
  * INTERNAL USE ONLY
  */
-var TrackerContext = new external_react_["createContext"](null);
+const TrackerContext = new react__WEBPACK_IMPORTED_MODULE_0__["createContext"](null);
 /**
  * The default instance is stored here.
  * It's created below in the Default() static property.
  */
 
-var request_tracking_default;
+let _default;
 /**
  * Implements request tracking and fulfillment.
  *
@@ -679,76 +310,59 @@ var request_tracking_default;
  */
 
 
-var request_tracking_RequestTracker = /*#__PURE__*/function () {
-  request_tracking_createClass(RequestTracker, null, [{
-    key: "Default",
-    get: function get() {
-      if (!request_tracking_default) {
-        request_tracking_default = new RequestTracker();
-      }
-
-      return request_tracking_default;
+class RequestTracker {
+  static get Default() {
+    if (!_default) {
+      _default = 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;
-
-    request_tracking_classCallCheck(this, RequestTracker);
 
-    request_tracking_defineProperty(this, "_trackedHandlers", {});
-
-    request_tracking_defineProperty(this, "_trackedRequests", {});
+    return _default;
+  }
+  /**
+   * These are the caches for tracked requests, their handlers, and responses.
+   */
 
-    request_tracking_defineProperty(this, "_responseCache", void 0);
 
-    request_tracking_defineProperty(this, "_requestFulfillment", void 0);
+  constructor(responseCache = undefined) {
+    this._trackedHandlers = {};
+    this._trackedRequests = {};
 
-    request_tracking_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;
       }
-    });
-
-    request_tracking_defineProperty(this, "reset", function () {
-      _this._trackedHandlers = {};
-      _this._trackedRequests = {};
-    });
+    };
 
-    request_tracking_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);
         }
@@ -772,19 +386,16 @@ var request_tracking_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(() => this._responseCache.cloneHydratableData());
+    };
 
-      return Promise.all(promises).then(function () {
-        return _this._responseCache.cloneHydratableData();
-      });
-    });
-
-    this._responseCache = responseCache || response_cache_ResponseCache.Default;
-    this._requestFulfillment = new request_fulfillment_RequestFulfillment(responseCache);
+    this._responseCache = responseCache || _response_cache_js__WEBPACK_IMPORTED_MODULE_1__[/* ResponseCache */ "a"].Default;
+    this._requestFulfillment = new _request_fulfillment_js__WEBPACK_IMPORTED_MODULE_2__[/* RequestFulfillment */ "a"](responseCache);
   }
   /**
    * Track a request.
@@ -794,578 +405,509 @@ var request_tracking_RequestTracker = /*#__PURE__*/function () {
    */
 
 
-  request_tracking_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;
-}();
-// CONCATENATED MODULE: ./packages/wonder-blocks-data/src/util/request-handler.js
-function request_handler_classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+}
 
-function request_handler_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); } }
+/***/ }),
+/* 4 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
 
-function request_handler_createClass(Constructor, protoProps, staticProps) { if (protoProps) request_handler_defineProperties(Constructor.prototype, protoProps); if (staticProps) request_handler_defineProperties(Constructor, staticProps); return Constructor; }
+"use strict";
+/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(0);
+/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(react__WEBPACK_IMPORTED_MODULE_0__);
 
-function request_handler_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; }
 
 /**
- * Base implementation for creating a request handler.
+ * InterceptContext defines a map from handler type to interception methods.
  *
- * Provides a base implementation of the `IRequestHandler` base class for
- * use with the Wonder Blocks Data framework.
+ * INTERNAL USE ONLY
  */
-var RequestHandler = /*#__PURE__*/function () {
-  function RequestHandler(type, cache) {
-    var hydrate = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
-
-    request_handler_classCallCheck(this, RequestHandler);
-
-    request_handler_defineProperty(this, "_type", void 0);
-
-    request_handler_defineProperty(this, "_cache", void 0);
-
-    request_handler_defineProperty(this, "_hydrate", void 0);
-
-    this._type = type;
-    this._cache = cache || null;
-    this._hydrate = !!hydrate;
-  }
-
-  request_handler_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;
-    }
-  }]);
-
-  return RequestHandler;
-}();
-
-
-// CONCATENATED MODULE: ./packages/wonder-blocks-data/src/components/track-data.js
-function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
-
-function track_data_classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-function track_data_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 track_data_createClass(Constructor, protoProps, staticProps) { if (protoProps) track_data_defineProperties(Constructor.prototype, protoProps); if (staticProps) track_data_defineProperties(Constructor, staticProps); return Constructor; }
-
-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 _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
-
-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 _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
-
-function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
-
-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 _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
-
-
-
+const InterceptContext = /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__["createContext"]({});
+/* harmony default export */ __webpack_exports__["a"] = (InterceptContext);
 
+/***/ }),
+/* 5 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
 
+"use strict";
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return NoCache; });
+let defaultInstance = null;
 /**
- * Component to enable data request tracking when server-side rendering.
+ * This is a cache implementation to use when no caching is wanted.
+ *
+ * Use this with your request handler if you want to support server-side
+ * rendering of your data requests, but want to ensure data is never cached
+ * on the client-side.
+ *
+ * This is better than having `shouldRefreshCache` always return `true` in the
+ * handler as this ensures that cache space and memory are never used for the
+ * requested data after hydration has finished.
  */
-var track_data_TrackData = /*#__PURE__*/function (_React$Component) {
-  _inherits(TrackData, _React$Component);
 
-  var _super = _createSuper(TrackData);
+class NoCache {
+  constructor() {
+    this.store = (handler, options, entry) => {
+      /* empty */
+    };
 
-  function TrackData() {
-    track_data_classCallCheck(this, TrackData);
+    this.retrieve = (handler, options) => null;
 
-    return _super.apply(this, arguments);
-  }
+    this.remove = (handler, options) => false;
 
-  track_data_createClass(TrackData, [{
-    key: "render",
-    value: function render() {
-      if (!wonder_blocks_core_["Server"].isServerSide()) {
-        throw new Error("This component is not for use during client-side rendering");
-      }
+    this.removeAll = (handler, predicate) => 0;
+  }
 
-      return /*#__PURE__*/external_react_["createElement"](TrackerContext.Provider, {
-        value: request_tracking_RequestTracker.Default.trackDataRequest
-      }, this.props.children);
+  static get Default() {
+    if (defaultInstance == null) {
+      defaultInstance = new NoCache();
     }
-  }]);
-
-  return TrackData;
-}(external_react_["Component"]);
-
-
-// CONCATENATED MODULE: ./packages/wonder-blocks-data/src/components/internal-data.js
-function internal_data_typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { internal_data_typeof = function _typeof(obj) { return typeof obj; }; } else { internal_data_typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return internal_data_typeof(obj); }
-
-function internal_data_classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-function internal_data_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 internal_data_createClass(Constructor, protoProps, staticProps) { if (protoProps) internal_data_defineProperties(Constructor.prototype, protoProps); if (staticProps) internal_data_defineProperties(Constructor, staticProps); return Constructor; }
-
-function internal_data_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) internal_data_setPrototypeOf(subClass, superClass); }
-
-function internal_data_setPrototypeOf(o, p) { internal_data_setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return internal_data_setPrototypeOf(o, p); }
-
-function internal_data_createSuper(Derived) { var hasNativeReflectConstruct = internal_data_isNativeReflectConstruct(); return function _createSuperInternal() { var Super = internal_data_getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = internal_data_getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return internal_data_possibleConstructorReturn(this, result); }; }
-
-function internal_data_possibleConstructorReturn(self, call) { if (call && (internal_data_typeof(call) === "object" || typeof call === "function")) { return call; } return internal_data_assertThisInitialized(self); }
-
-function internal_data_assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
-
-function internal_data_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 internal_data_getPrototypeOf(o) { internal_data_getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return internal_data_getPrototypeOf(o); }
-
-function internal_data_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; }
 
+    return defaultInstance;
+  }
 
+}
 
+/***/ }),
+/* 6 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
 
+"use strict";
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return RequestFulfillment; });
+/* harmony import */ var _response_cache_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(1);
 
 
-/**
- * This component is responsible for actually handling the data request.
- * It is wrapped by Data in order to support intercepts and be exported for use.
- *
- * INTERNAL USE ONLY
- */
-var internal_data_InternalData = /*#__PURE__*/function (_React$Component) {
-  internal_data_inherits(InternalData, _React$Component);
+let _default;
 
-  var _super = internal_data_createSuper(InternalData);
+class RequestFulfillment {
+  static get Default() {
+    if (!_default) {
+      _default = new RequestFulfillment();
+    }
 
-  function InternalData(props) {
-    var _this;
+    return _default;
+  }
 
-    internal_data_classCallCheck(this, InternalData);
+  constructor(responseCache = undefined) {
+    this._requests = {};
 
-    _this = _super.call(this, props);
+    this._getHandlerSubcache = handler => {
+      if (!this._requests[handler.type]) {
+        this._requests[handler.type] = {};
+      }
 
-    internal_data_defineProperty(internal_data_assertThisInitialized(_this), "_mounted", void 0);
+      return this._requests[handler.type];
+    };
 
-    _this.state = _this._buildStateAndfulfillNeeds(props);
-    return _this;
-  }
+    this.fulfill = (handler, options) => {
+      const handlerRequests = this._getHandlerSubcache(handler);
 
-  internal_data_createClass(InternalData, [{
-    key: "componentDidMount",
-    value: function componentDidMount() {
-      this._mounted = true;
-    }
-  }, {
-    key: "shouldComponentUpdate",
-    value: function shouldComponentUpdate(nextProps, nextState) {
+      const key = handler.getKey(options);
       /**
-       * We only bother updating if our state changed.
-       *
-       * And we only update the state if props changed
-       * or we got new data/error.
+       * If we have an inflight request, we'll provide that.
        */
-      if (!this._propsMatch(nextProps)) {
-        var newState = this._buildStateAndfulfillNeeds(nextProps);
 
-        this.setState(newState);
+      const inflight = handlerRequests[key];
+
+      if (inflight) {
+        return inflight;
       }
+      /**
+       * We don't have an inflight request, so let's set one up.
+       */
 
-      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);
-    }
-  }, {
-    key: "_buildStateAndfulfillNeeds",
-    value: function _buildStateAndfulfillNeeds(propsAtFulfillment) {
-      var _this2 = this;
 
-      var getEntry = propsAtFulfillment.getEntry,
-          handler = propsAtFulfillment.handler,
-          options = propsAtFulfillment.options;
-      var cachedData = getEntry(handler, options);
+      const {
+        cacheData,
+        cacheError
+      } = this._responseCache;
 
-      if (!wonder_blocks_core_["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.
-         */
-        request_fulfillment_RequestFulfillment.Default.fulfill(handler, options).then(function (cacheEntry) {
+      try {
+        const request = handler.fulfillRequest(options).then(data => {
+          delete handlerRequests[key];
           /**
-           * 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.
+           * Let's cache the data!
            */
-          if (_this2._mounted && _this2._propsMatch(propsAtFulfillment)) {
-            _this2.setState({
-              loading: false,
-              data: cacheEntry.data,
-              error: cacheEntry.error
-            });
-          }
-
-          return null;
-        }).catch(function (e) {
+
+          return cacheData(handler, options, data);
+        }).catch(error => {
+          delete handlerRequests[key];
           /**
-           * We should never get here, but if we do.
+           * Let's cache the error!
            */
-          // 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;
+
+          return cacheError(handler, options, error);
         });
+        handlerRequests[key] = request;
+        return request;
+      } catch (e) {
+        /**
+         * In this case, we don't cache an inflight request, because there
+         * really isn't one.
+         */
+        return Promise.resolve(cacheError(handler, options, e));
       }
-      /**
-       * 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.
-       */
+    };
+
+    this._responseCache = responseCache || _response_cache_js__WEBPACK_IMPORTED_MODULE_0__[/* ResponseCache */ "a"].Default;
+  }
+
+}
+
+/***/ }),
+/* 7 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return MemoryCache; });
+function deepClone(source) {
+  /**
+   * We want to deep clone the source cache to dodge mutations by external
+   * references. So we serialize the source cache to JSON and parse it
+   * back into a new object.
+   *
+   * NOTE: This doesn't work for get/set property accessors.
+   */
+  const serializedInitCache = JSON.stringify(source);
+  const cloneInitCache = JSON.parse(serializedInitCache);
+  return Object.freeze(cloneInitCache);
+}
+/**
+ * INTERNAL USE ONLY
+ *
+ * Special case cache implementation for the memory cache.
+ *
+ * This is only used within our framework. Handlers don't need to
+ * provide this as a custom cache as the framework will default to this in the
+ * absence of a custom cache. We use this for SSR too (see ./response-cache.js).
+ */
 
 
-      return {
-        loading: cachedData == null,
-        data: cachedData && cachedData.data,
-        error: cachedData && cachedData.error
-      };
-    }
-  }, {
-    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
-        };
-      }
+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.
 
-      if (data != null) {
-        return {
-          loading: false,
-          data: data
-        };
-      }
+      this._cache[requestType] = this._cache[requestType] || {}; // Cache the data.
 
-      if (error == null) {
-        // We should never get here ever.
-        throw new Error("Loaded result has invalid state where data and error are missing");
-      }
+      const key = handler.getKey(options);
+      this._cache[requestType][key] = frozenEntry;
+    };
 
-      return {
-        loading: false,
-        error: error
-      };
-    }
-  }, {
-    key: "_renderContent",
-    value: function _renderContent(result) {
-      var children = this.props.children;
-      return children(result);
-    }
-  }, {
-    key: "_renderWithTrackingContext",
-    value: function _renderWithTrackingContext(result) {
-      var _this3 = this;
+    this.retrieve = (handler, options) => {
+      const requestType = handler.type; // Get the internal subcache for the handler.
 
-      return /*#__PURE__*/external_react_["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);
-        }
+      const handlerCache = this._cache[requestType];
 
-        return _this3._renderContent(result);
-      });
-    }
-  }, {
-    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.
+      if (!handlerCache) {
+        return null;
+      } // Get the response.
 
 
-      if (result.loading && wonder_blocks_core_["Server"].isServerSide()) {
-        return this._renderWithTrackingContext(result);
+      const key = handler.getKey(options);
+      const internalEntry = handlerCache[key];
+
+      if (internalEntry == null) {
+        return null;
       }
 
-      return this._renderContent(result);
-    }
-  }]);
+      return internalEntry;
+    };
+
+    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.
 
-  return InternalData;
-}(external_react_["Component"]);
+      const handlerCache = this._cache[requestType];
 
+      if (!handlerCache) {
+        return false;
+      } // Get the entry.
 
-// CONCATENATED MODULE: ./packages/wonder-blocks-data/src/components/intercept-context.js
 
+      const key = handler.getKey(options);
+      const internalEntry = handlerCache[key];
 
-/**
- * InterceptContext defines a map from handler type to interception methods.
- *
- * INTERNAL USE ONLY
- */
-var InterceptContext = external_react_["createContext"]({});
-/* harmony default export */ var intercept_context = (InterceptContext);
-// CONCATENATED MODULE: ./packages/wonder-blocks-data/src/components/data.js
-function data_typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { data_typeof = function _typeof(obj) { return typeof obj; }; } else { data_typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return data_typeof(obj); }
+      if (internalEntry == null) {
+        return false;
+      } // Delete the entry.
 
-function data_classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 
-function data_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); } }
+      delete handlerCache[key];
+      return true;
+    };
 
-function data_createClass(Constructor, protoProps, staticProps) { if (protoProps) data_defineProperties(Constructor.prototype, protoProps); if (staticProps) data_defineProperties(Constructor, staticProps); return Constructor; }
+    this.removeAll = (handler, predicate) => {
+      const requestType = handler.type; // Get the internal subcache for the handler.
 
-function data_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) data_setPrototypeOf(subClass, superClass); }
+      const handlerCache = this._cache[requestType];
 
-function data_setPrototypeOf(o, p) { data_setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return data_setPrototypeOf(o, p); }
+      if (!handlerCache) {
+        return 0;
+      } // Apply the predicate to what we have cached.
 
-function data_createSuper(Derived) { var hasNativeReflectConstruct = data_isNativeReflectConstruct(); return function _createSuperInternal() { var Super = data_getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = data_getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return data_possibleConstructorReturn(this, result); }; }
 
-function data_possibleConstructorReturn(self, call) { if (call && (data_typeof(call) === "object" || typeof call === "function")) { return call; } return data_assertThisInitialized(self); }
+      let removedCount = 0;
 
-function data_assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+      for (const [key, entry] of Object.entries(handlerCache)) {
+        if (typeof predicate !== "function" || predicate(key, entry)) {
+          removedCount++;
+          delete handlerCache[key];
+        }
+      }
 
-function data_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; } }
+      return removedCount;
+    };
 
-function data_getPrototypeOf(o) { data_getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return data_getPrototypeOf(o); }
+    this.cloneData = () => {
+      try {
+        return deepClone(this._cache);
+      } catch (e) {
+        throw new Error(`An error occurred while trying to clone the cache: ${e}`);
+      }
+    };
 
+    this._cache = {};
 
+    if (source != null) {
+      try {
+        /**
+         * Object.assign only performs a shallow clone.
+         * So we deep clone it and then assign the clone values to our
+         * internal cache.
+         */
+        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: ${e}`);
+      }
+    }
+  }
 
+  get inUse() {
+    return Object.keys(this._cache).length > 0;
+  }
 
+}
 
+/***/ }),
+/* 8 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
 
+"use strict";
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return RequestHandler; });
 /**
- * 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.
+ * Base implementation for creating a request handler.
+ *
+ * Provides a base implementation of the `IRequestHandler` base class for
+ * use with the Wonder Blocks Data framework.
  */
-var data_Data = /*#__PURE__*/function (_React$Component) {
-  data_inherits(Data, _React$Component);
-
-  var _super = data_createSuper(Data);
+class RequestHandler {
+  constructor(type, cache, hydrate = true) {
+    this._type = type;
+    this._cache = cache || null;
+    this._hydrate = !!hydrate;
+  }
 
-  function Data() {
-    data_classCallCheck(this, Data);
+  get type() {
+    return this._type;
+  }
 
-    return _super.apply(this, arguments);
+  get cache() {
+    return this._cache;
   }
 
-  data_createClass(Data, [{
-    key: "_getHandlerFromInterceptor",
-    value: function _getHandlerFromInterceptor(interceptor) {
-      var handler = this.props.handler;
+  get hydrate() {
+    return this._hydrate;
+  }
 
-      if (!interceptor) {
-        return handler;
-      }
+  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;
+  }
 
-      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
-      };
+  getKey(options) {
+    try {
+      return options === undefined ? "undefined" : JSON.stringify(options);
+    } catch (e) {
+      throw new Error(`Failed to auto-generate key: ${e}`);
     }
-  }, {
-    key: "_getCacheLookupFnFromInterceptor",
-    value: function _getCacheLookupFnFromInterceptor(interceptor) {
-      var getEntry = interceptor && interceptor.getEntry;
+  }
 
-      if (!getEntry) {
-        return response_cache_ResponseCache.Default.getEntry;
-      }
+  fulfillRequest(options) {
+    throw new Error("Not implemented");
+  }
+
+}
+
+/***/ }),
+/* 9 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
 
-      return function (handler, options) {
-        // 1. Lookup the current cache value.
-        var cacheEntry = response_cache_ResponseCache.Default.getEntry(handler, options); // 2. See if our interceptor wants to override it.
+"use strict";
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return TrackData; });
+/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(0);
+/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(react__WEBPACK_IMPORTED_MODULE_0__);
+/* harmony import */ var _khanacademy_wonder_blocks_core__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(2);
+/* harmony import */ var _khanacademy_wonder_blocks_core__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_khanacademy_wonder_blocks_core__WEBPACK_IMPORTED_MODULE_1__);
+/* harmony import */ var _util_request_tracking_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(3);
 
-        var interceptedData = getEntry(options, cacheEntry); // 3. Return the appropriate response.
 
-        return interceptedData != null ? interceptedData : cacheEntry;
-      };
+
+
+/**
+ * Component to enable data request tracking when server-side rendering.
+ */
+class TrackData extends react__WEBPACK_IMPORTED_MODULE_0__["Component"] {
+  render() {
+    if (!_khanacademy_wonder_blocks_core__WEBPACK_IMPORTED_MODULE_1__["Server"].isServerSide()) {
+      throw new Error("This component is not for use during client-side rendering");
     }
-  }, {
-    key: "render",
-    value: function render() {
-      var _this = this;
 
-      return /*#__PURE__*/external_react_["createElement"](intercept_context.Consumer, null, function (value) {
-        var handlerType = _this.props.handler.type;
-        var interceptor = value[handlerType];
+    return /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__["createElement"](_util_request_tracking_js__WEBPACK_IMPORTED_MODULE_2__[/* TrackerContext */ "b"].Provider, {
+      value: _util_request_tracking_js__WEBPACK_IMPORTED_MODULE_2__[/* RequestTracker */ "a"].Default.trackDataRequest
+    }, this.props.children);
+  }
 
-        var 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.
-         */
+/***/ }),
+/* 10 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return Data; });
+/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(0);
+/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(react__WEBPACK_IMPORTED_MODULE_0__);
+/* harmony import */ var _util_response_cache_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(1);
+/* harmony import */ var _internal_data_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(13);
+/* harmony import */ var _intercept_context_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(4);
 
 
-        return /*#__PURE__*/external_react_["createElement"](internal_data_InternalData // $FlowIgnore[incompatible-type-arg]
-        , {
-          handler: handler,
-          options: _this.props.options,
-          getEntry: getEntry
-        }, function (result) {
-          return _this.props.children(result);
-        });
-      });
-    }
-  }]);
 
-  return Data;
-}(external_react_["Component"]);
 
 
-// CONCATENATED MODULE: ./packages/wonder-blocks-data/src/components/intercept-data.js
-function intercept_data_typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { intercept_data_typeof = function _typeof(obj) { return typeof obj; }; } else { intercept_data_typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return intercept_data_typeof(obj); }
+/**
+ * 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.
+ */
+class Data extends react__WEBPACK_IMPORTED_MODULE_0__["Component"] {
+  _getHandlerFromInterceptor(interceptor) {
+    const {
+      handler
+    } = this.props;
+
+    if (!interceptor) {
+      return handler;
+    }
 
-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; }
+    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
+    };
+  }
 
-function _objectSpread(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) { intercept_data_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; }
+  _getCacheLookupFnFromInterceptor(interceptor) {
+    const getEntry = interceptor && interceptor.getEntry;
 
-function intercept_data_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; }
+    if (!getEntry) {
+      return _util_response_cache_js__WEBPACK_IMPORTED_MODULE_1__[/* ResponseCache */ "a"].Default.getEntry;
+    }
 
-function intercept_data_classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+    return (handler, options) => {
+      // 1. Lookup the current cache value.
+      const cacheEntry = _util_response_cache_js__WEBPACK_IMPORTED_MODULE_1__[/* ResponseCache */ "a"].Default.getEntry(handler, options); // 2. See if our interceptor wants to override it.
 
-function intercept_data_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); } }
+      const interceptedData = getEntry(options, cacheEntry); // 3. Return the appropriate response.
 
-function intercept_data_createClass(Constructor, protoProps, staticProps) { if (protoProps) intercept_data_defineProperties(Constructor.prototype, protoProps); if (staticProps) intercept_data_defineProperties(Constructor, staticProps); return Constructor; }
+      return interceptedData != null ? interceptedData : cacheEntry;
+    };
+  }
 
-function intercept_data_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) intercept_data_setPrototypeOf(subClass, superClass); }
+  render() {
+    return /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__["createElement"](_intercept_context_js__WEBPACK_IMPORTED_MODULE_3__[/* default */ "a"].Consumer, null, value => {
+      const handlerType = this.props.handler.type;
+      const interceptor = value[handlerType];
 
-function intercept_data_setPrototypeOf(o, p) { intercept_data_setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return intercept_data_setPrototypeOf(o, p); }
+      const handler = this._getHandlerFromInterceptor(interceptor);
 
-function intercept_data_createSuper(Derived) { var hasNativeReflectConstruct = intercept_data_isNativeReflectConstruct(); return function _createSuperInternal() { var Super = intercept_data_getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = intercept_data_getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return intercept_data_possibleConstructorReturn(this, result); }; }
+      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.
+       */
 
-function intercept_data_possibleConstructorReturn(self, call) { if (call && (intercept_data_typeof(call) === "object" || typeof call === "function")) { return call; } return intercept_data_assertThisInitialized(self); }
 
-function intercept_data_assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+      return /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__["createElement"](_internal_data_js__WEBPACK_IMPORTED_MODULE_2__[/* default */ "a"] // $FlowIgnore[incompatible-type-arg]
+      , {
+        handler: handler,
+        options: this.props.options,
+        getEntry: getEntry
+      }, result => this.props.children(result));
+    });
+  }
 
-function intercept_data_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 intercept_data_getPrototypeOf(o) { intercept_data_getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return intercept_data_getPrototypeOf(o); }
+/***/ }),
+/* 11 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
 
+"use strict";
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return InterceptData; });
+/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(0);
+/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(react__WEBPACK_IMPORTED_MODULE_0__);
+/* harmony import */ var _intercept_context_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(4);
 
 
 
@@ -1388,153 +930,323 @@ function intercept_data_getPrototypeOf(o) { intercept_data_getPrototypeOf = Obje
  * new instance will replace this interceptor for its children. All methods
  * will be replaced.
  */
-var intercept_data_InterceptData = /*#__PURE__*/function (_React$Component) {
-  intercept_data_inherits(InterceptData, _React$Component);
+class InterceptData extends react__WEBPACK_IMPORTED_MODULE_0__["Component"] {
+  render() {
+    return /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__["createElement"](_intercept_context_js__WEBPACK_IMPORTED_MODULE_1__[/* default */ "a"].Consumer, null, value => {
+      const handlerType = this.props.handler.type;
+      const interceptor = { ...value[handlerType],
+        fulfillRequest: this.props.fulfillRequest || null,
+        shouldRefreshCache: this.props.shouldRefreshCache || null
+      };
+      const newValue = { ...value,
+        [handlerType]: interceptor
+      };
+      return /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__["createElement"](_intercept_context_js__WEBPACK_IMPORTED_MODULE_1__[/* default */ "a"].Provider, {
+        value: newValue
+      }, this.props.children);
+    });
+  }
 
-  var _super = intercept_data_createSuper(InterceptData);
+}
 
-  function InterceptData() {
-    intercept_data_classCallCheck(this, InterceptData);
+/***/ }),
+/* 12 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
 
-    return _super.apply(this, arguments);
-  }
+"use strict";
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return InterceptCache; });
+/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(0);
+/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(react__WEBPACK_IMPORTED_MODULE_0__);
+/* harmony import */ var _intercept_context_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(4);
 
-  intercept_data_createClass(InterceptData, [{
-    key: "render",
-    value: function render() {
-      var _this = this;
 
-      return /*#__PURE__*/external_react_["createElement"](intercept_context.Consumer, null, function (value) {
-        var handlerType = _this.props.handler.type;
 
-        var interceptor = _objectSpread(_objectSpread({}, value[handlerType]), {}, {
-          fulfillRequest: _this.props.fulfillRequest || null,
-          shouldRefreshCache: _this.props.shouldRefreshCache || null
-        });
+/**
+ * This component provides a mechanism to intercept cache lookups for the
+ * type of a given handler and provide alternative values. This is mostly
+ * useful for testing.
+ *
+ * This does not modify the cache in any way. If you want to intercept
+ * requests and cache based on the intercept, then use `InterceptData`.
+ *
+ * This component is generally not suitable for use in production code as it
+ * can prevent predictable functioning of the Wonder Blocks Data framework.
+ *
+ * These components do not chain. If a different `InterceptCache` instance is
+ * rendered within this one that intercepts the same handler type, then that
+ * new instance will replace this interceptor for its children.
+ */
+class InterceptCache extends react__WEBPACK_IMPORTED_MODULE_0__["Component"] {
+  render() {
+    return /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__["createElement"](_intercept_context_js__WEBPACK_IMPORTED_MODULE_1__[/* default */ "a"].Consumer, null, value => {
+      const handlerType = this.props.handler.type;
+      const interceptor = { ...value[handlerType],
+        getEntry: this.props.getEntry
+      };
+      const newValue = { ...value,
+        [handlerType]: interceptor
+      };
+      return /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__["createElement"](_intercept_context_js__WEBPACK_IMPORTED_MODULE_1__[/* default */ "a"].Provider, {
+        value: newValue
+      }, this.props.children);
+    });
+  }
 
-        var newValue = _objectSpread(_objectSpread({}, value), {}, intercept_data_defineProperty({}, handlerType, interceptor));
+}
 
-        return /*#__PURE__*/external_react_["createElement"](intercept_context.Provider, {
-          value: newValue
-        }, _this.props.children);
-      });
-    }
-  }]);
+/***/ }),
+/* 13 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return InternalData; });
+/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(0);
+/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(react__WEBPACK_IMPORTED_MODULE_0__);
+/* harmony import */ var _khanacademy_wonder_blocks_core__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(2);
+/* harmony import */ var _khanacademy_wonder_blocks_core__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_khanacademy_wonder_blocks_core__WEBPACK_IMPORTED_MODULE_1__);
+/* harmony import */ var _util_request_fulfillment_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(6);
+/* harmony import */ var _util_request_tracking_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(3);
 
-  return InterceptData;
-}(external_react_["Component"]);
 
 
-// CONCATENATED MODULE: ./packages/wonder-blocks-data/src/components/intercept-cache.js
-function intercept_cache_typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { intercept_cache_typeof = function _typeof(obj) { return typeof obj; }; } else { intercept_cache_typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return intercept_cache_typeof(obj); }
 
-function intercept_cache_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 intercept_cache_objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { intercept_cache_ownKeys(Object(source), true).forEach(function (key) { intercept_cache_defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { intercept_cache_ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+/**
+ * This component is responsible for actually handling the data request.
+ * It is wrapped by Data in order to support intercepts and be exported for use.
+ *
+ * INTERNAL USE ONLY
+ */
+class InternalData extends react__WEBPACK_IMPORTED_MODULE_0__["Component"] {
+  constructor(props) {
+    super(props);
+    this.state = this._buildStateAndfulfillNeeds(props);
+  }
 
-function intercept_cache_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; }
+  componentDidMount() {
+    this._mounted = true;
+  }
 
-function intercept_cache_classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+  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);
 
-function intercept_cache_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); } }
+      this.setState(newState);
+    }
 
-function intercept_cache_createClass(Constructor, protoProps, staticProps) { if (protoProps) intercept_cache_defineProperties(Constructor.prototype, protoProps); if (staticProps) intercept_cache_defineProperties(Constructor, staticProps); return Constructor; }
+    return this.state.loading !== nextState.loading || this.state.data !== nextState.data || this.state.error !== nextState.error;
+  }
 
-function intercept_cache_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) intercept_cache_setPrototypeOf(subClass, superClass); }
+  componentWillUnmount() {
+    this._mounted = false;
+  }
 
-function intercept_cache_setPrototypeOf(o, p) { intercept_cache_setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return intercept_cache_setPrototypeOf(o, p); }
+  _propsMatch(otherProps) {
+    const {
+      handler,
+      options
+    } = this.props;
+    const {
+      handler: prevHandler,
+      options: prevOptions
+    } = otherProps;
+    return handler === prevHandler && handler.getKey(options) === prevHandler.getKey(prevOptions);
+  }
 
-function intercept_cache_createSuper(Derived) { var hasNativeReflectConstruct = intercept_cache_isNativeReflectConstruct(); return function _createSuperInternal() { var Super = intercept_cache_getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = intercept_cache_getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return intercept_cache_possibleConstructorReturn(this, result); }; }
+  _buildStateAndfulfillNeeds(propsAtFulfillment) {
+    const {
+      getEntry,
+      handler,
+      options
+    } = propsAtFulfillment;
+    const cachedData = getEntry(handler, options);
 
-function intercept_cache_possibleConstructorReturn(self, call) { if (call && (intercept_cache_typeof(call) === "object" || typeof call === "function")) { return call; } return intercept_cache_assertThisInitialized(self); }
+    if (!_khanacademy_wonder_blocks_core__WEBPACK_IMPORTED_MODULE_1__["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.
+       */
+      _util_request_fulfillment_js__WEBPACK_IMPORTED_MODULE_2__[/* RequestFulfillment */ "a"].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
+          });
+        }
 
-function intercept_cache_assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+        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
+          });
+        }
 
-function intercept_cache_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; } }
+        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.
+     */
 
-function intercept_cache_getPrototypeOf(o) { intercept_cache_getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return intercept_cache_getPrototypeOf(o); }
 
+    return {
+      loading: cachedData == null,
+      data: cachedData && cachedData.data,
+      error: cachedData && cachedData.error
+    };
+  }
 
+  _resultFromState() {
+    const {
+      loading,
+      data,
+      error
+    } = this.state;
 
+    if (loading) {
+      return {
+        loading: true
+      };
+    }
 
-/**
- * This component provides a mechanism to intercept cache lookups for the
- * type of a given handler and provide alternative values. This is mostly
- * useful for testing.
- *
- * This does not modify the cache in any way. If you want to intercept
- * requests and cache based on the intercept, then use `InterceptData`.
- *
- * This component is generally not suitable for use in production code as it
- * can prevent predictable functioning of the Wonder Blocks Data framework.
- *
- * These components do not chain. If a different `InterceptCache` instance is
- * rendered within this one that intercepts the same handler type, then that
- * new instance will replace this interceptor for its children.
- */
-var intercept_cache_InterceptCache = /*#__PURE__*/function (_React$Component) {
-  intercept_cache_inherits(InterceptCache, _React$Component);
+    if (data != null) {
+      return {
+        loading: false,
+        data
+      };
+    }
 
-  var _super = intercept_cache_createSuper(InterceptCache);
+    if (error == null) {
+      // We should never get here ever.
+      throw new Error("Loaded result has invalid state where data and error are missing");
+    }
 
-  function InterceptCache() {
-    intercept_cache_classCallCheck(this, InterceptCache);
+    return {
+      loading: false,
+      error
+    };
+  }
 
-    return _super.apply(this, arguments);
+  _renderContent(result) {
+    const {
+      children
+    } = this.props;
+    return children(result);
   }
 
-  intercept_cache_createClass(InterceptCache, [{
-    key: "render",
-    value: function render() {
-      var _this = this;
+  _renderWithTrackingContext(result) {
+    return /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__["createElement"](_util_request_tracking_js__WEBPACK_IMPORTED_MODULE_3__[/* TrackerContext */ "b"].Consumer, null, track => {
+      /**
+       * If data tracking wasn't enabled, don't do it.
+       */
+      if (track != null) {
+        track(this.props.handler, this.props.options);
+      }
 
-      return /*#__PURE__*/external_react_["createElement"](intercept_context.Consumer, null, function (value) {
-        var handlerType = _this.props.handler.type;
+      return this._renderContent(result);
+    });
+  }
 
-        var interceptor = intercept_cache_objectSpread(intercept_cache_objectSpread({}, value[handlerType]), {}, {
-          getEntry: _this.props.getEntry
-        });
+  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.
 
-        var newValue = intercept_cache_objectSpread(intercept_cache_objectSpread({}, value), {}, intercept_cache_defineProperty({}, handlerType, interceptor));
 
-        return /*#__PURE__*/external_react_["createElement"](intercept_context.Provider, {
-          value: newValue
-        }, _this.props.children);
-      });
+    if (result.loading && _khanacademy_wonder_blocks_core__WEBPACK_IMPORTED_MODULE_1__["Server"].isServerSide()) {
+      return this._renderWithTrackingContext(result);
     }
-  }]);
 
-  return InterceptCache;
-}(external_react_["Component"]);
+    return this._renderContent(result);
+  }
+
+}
 
+/***/ }),
+/* 14 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
 
-// CONCATENATED MODULE: ./packages/wonder-blocks-data/src/index.js
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "initializeCache", function() { return initializeCache; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "fulfillAllDataRequests", function() { return fulfillAllDataRequests; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "hasUnfulfilledRequests", function() { return hasUnfulfilledRequests; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "removeFromCache", function() { return removeFromCache; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "removeAllFromCache", function() { return removeAllFromCache; });
+/* harmony import */ var _khanacademy_wonder_blocks_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(2);
+/* harmony import */ var _khanacademy_wonder_blocks_core__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_khanacademy_wonder_blocks_core__WEBPACK_IMPORTED_MODULE_0__);
+/* harmony import */ var _util_response_cache_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(1);
+/* harmony import */ var _util_request_tracking_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(3);
+/* harmony import */ var _util_request_handler_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(8);
+/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "RequestHandler", function() { return _util_request_handler_js__WEBPACK_IMPORTED_MODULE_3__["a"]; });
 
+/* harmony import */ var _components_track_data_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(9);
+/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "TrackData", function() { return _components_track_data_js__WEBPACK_IMPORTED_MODULE_4__["a"]; });
 
+/* harmony import */ var _components_data_js__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(10);
+/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "Data", function() { return _components_data_js__WEBPACK_IMPORTED_MODULE_5__["a"]; });
 
-var src_initializeCache = function initializeCache(source) {
-  return response_cache_ResponseCache.Default.initialize(source);
-};
-var src_fulfillAllDataRequests = function fulfillAllDataRequests() {
-  if (!wonder_blocks_core_["Server"].isServerSide()) {
+/* harmony import */ var _components_intercept_data_js__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(11);
+/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "InterceptData", function() { return _components_intercept_data_js__WEBPACK_IMPORTED_MODULE_6__["a"]; });
+
+/* harmony import */ var _components_intercept_cache_js__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(12);
+/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "InterceptCache", function() { return _components_intercept_cache_js__WEBPACK_IMPORTED_MODULE_7__["a"]; });
+
+/* harmony import */ var _util_no_cache_js__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(5);
+/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "NoCache", function() { return _util_no_cache_js__WEBPACK_IMPORTED_MODULE_8__["a"]; });
+
+
+
+
+const initializeCache = source => _util_response_cache_js__WEBPACK_IMPORTED_MODULE_1__[/* ResponseCache */ "a"].Default.initialize(source);
+const fulfillAllDataRequests = () => {
+  if (!_khanacademy_wonder_blocks_core__WEBPACK_IMPORTED_MODULE_0__["Server"].isServerSide()) {
     return Promise.reject(new Error("Data requests are not tracked when client-side"));
   }
 
-  return request_tracking_RequestTracker.Default.fulfillTrackedRequests();
+  return _util_request_tracking_js__WEBPACK_IMPORTED_MODULE_2__[/* RequestTracker */ "a"].Default.fulfillTrackedRequests();
 };
-var src_hasUnfulfilledRequests = function hasUnfulfilledRequests() {
-  if (!wonder_blocks_core_["Server"].isServerSide()) {
+const hasUnfulfilledRequests = () => {
+  if (!_khanacademy_wonder_blocks_core__WEBPACK_IMPORTED_MODULE_0__["Server"].isServerSide()) {
     throw new Error("Data requests are not tracked when client-side");
   }
 
-  return request_tracking_RequestTracker.Default.hasUnfulfilledRequests;
-};
-var src_removeFromCache = function removeFromCache(handler, options) {
-  return response_cache_ResponseCache.Default.remove(handler, options);
-};
-var src_removeAllFromCache = function removeAllFromCache(handler, predicate) {
-  return response_cache_ResponseCache.Default.removeAll(handler, predicate);
+  return _util_request_tracking_js__WEBPACK_IMPORTED_MODULE_2__[/* RequestTracker */ "a"].Default.hasUnfulfilledRequests;
 };
+const removeFromCache = (handler, options) => _util_response_cache_js__WEBPACK_IMPORTED_MODULE_1__[/* ResponseCache */ "a"].Default.remove(handler, options);
+const removeAllFromCache = (handler, predicate) => _util_response_cache_js__WEBPACK_IMPORTED_MODULE_1__[/* ResponseCache */ "a"].Default.removeAll(handler, predicate);
 /**
  * TODO(somewhatabstract): Export each cache type we implement.
  *