@2112-lab/central-plant 0.2.10 → 0.3.0

package/dist/esm/src/managers/cache/CacheManager.js

@@ -0,0 +1,1070 @@
+import { createClass as _createClass, objectSpread2 as _objectSpread2, classCallCheck as _classCallCheck, asyncToGenerator as _asyncToGenerator, regenerator as _regenerator, createForOfIteratorHelper as _createForOfIteratorHelper } from '../../../_virtual/_rollupPluginBabelHelpers.js';
+
+/**
+ * Generic Cache Management using Browser Cache API
+ * Framework-agnostic implementation of caching logic
+ */
+
+// Time constants
+var SECOND = 1000;
+var MINUTE = 60 * SECOND;
+var HOUR = 60 * MINUTE;
+var DAY = 24 * HOUR;
+var CACHE_EXPIRY = {
+  MODELS: 7 * DAY,
+  TEXTURES: 7 * DAY,
+  JSON: 24 * HOUR,
+  COMPONENT_DICTIONARY: 24 * HOUR,
+  SCENE_DATA: 12 * HOUR,
+  THUMBNAILS: Infinity,
+  SKYBOXES: 7 * DAY,
+  USER_CONTENT: 6 * HOUR,
+  TEMPORARY: 1 * HOUR,
+  DEFAULT: 24 * HOUR
+};
+var CACHE_NAME_PREFIX = 'central-plant-s3-cache-v1';
+var CacheManager = /*#__PURE__*/function () {
+  function CacheManager() {
+    _classCallCheck(this, CacheManager);
+    this.stats = {
+      hits: 0,
+      misses: 0,
+      errors: 0,
+      totalBytesServed: 0,
+      totalBytesCached: 0,
+      startTime: Date.now()
+    };
+    this.config = {
+      // Default user provider returns null (anonymous)
+      getUser: function () {
+        var _getUser = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee() {
+          return _regenerator().w(function (_context) {
+            while (1) switch (_context.n) {
+              case 0:
+                return _context.a(2, null);
+            }
+          }, _callee);
+        }));
+        function getUser() {
+          return _getUser.apply(this, arguments);
+        }
+        return getUser;
+      }(),
+      // Default error logger
+      onError: function onError(error) {
+        return console.error('CacheManager Error:', error);
+      }
+    };
+  }
+
+  /**
+   * Configure the cache manager
+   */
+  return _createClass(CacheManager, [{
+    key: "configure",
+    value: function configure() {
+      var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+      this.config = _objectSpread2(_objectSpread2({}, this.config), options);
+    }
+
+    /**
+     * Get cache expiry for a specific file path
+     */
+  }, {
+    key: "getExpiryForPath",
+    value: function getExpiryForPath(path) {
+      var assetType = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+      if (assetType && CACHE_EXPIRY[assetType.toUpperCase()]) {
+        return CACHE_EXPIRY[assetType.toUpperCase()];
+      }
+      var lowerPath = path ? path.toLowerCase() : '';
+      if (lowerPath.includes('/models/') || lowerPath.endsWith('.glb') || lowerPath.endsWith('.gltf')) {
+        return CACHE_EXPIRY.MODELS;
+      }
+      if (lowerPath.includes('/textures/') || lowerPath.endsWith('.jpg') || lowerPath.endsWith('.png') || lowerPath.endsWith('.webp')) {
+        return CACHE_EXPIRY.TEXTURES;
+      }
+      if (lowerPath.includes('/thumbnails/')) {
+        return CACHE_EXPIRY.THUMBNAILS;
+      }
+      if (lowerPath.includes('/skyboxes/') || lowerPath.endsWith('.hdr')) {
+        return CACHE_EXPIRY.SKYBOXES;
+      }
+      if (lowerPath.includes('component-dictionary')) {
+        return CACHE_EXPIRY.COMPONENT_DICTIONARY;
+      }
+      if (lowerPath.endsWith('.json')) {
+        return CACHE_EXPIRY.JSON;
+      }
+      return CACHE_EXPIRY.DEFAULT;
+    }
+
+    /**
+     * Get or open the cache handle efficiently
+     */
+  }, {
+    key: "_getCacheHandle",
+    value: (function () {
+      var _getCacheHandle2 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee2(cacheName) {
+        return _regenerator().w(function (_context2) {
+          while (1) switch (_context2.n) {
+            case 0:
+              if (!(this._activeCacheName === cacheName && this._activeCacheHandle)) {
+                _context2.n = 1;
+                break;
+              }
+              return _context2.a(2, this._activeCacheHandle);
+            case 1:
+              // If we are switching caches, close/drop reference to the old one (GC handles it, but good practice)
+              this._activeCacheName = cacheName;
+              _context2.n = 2;
+              return caches.open(cacheName);
+            case 2:
+              this._activeCacheHandle = _context2.v;
+              return _context2.a(2, this._activeCacheHandle);
+          }
+        }, _callee2, this);
+      }));
+      function _getCacheHandle(_x) {
+        return _getCacheHandle2.apply(this, arguments);
+      }
+      return _getCacheHandle;
+    }()
+    /**
+     * Resets the identity, forcing a re-fetch of the user/cache name on next access
+     */
+    )
+  }, {
+    key: "resetIdentity",
+    value: function resetIdentity() {
+      this._cachedCacheName = null;
+    }
+
+    /**
+     * Get the cache name for the current user
+     * Memoized indefinitely until resetIdentity() is called
+     */
+  }, {
+    key: "getCacheName",
+    value: (function () {
+      var _getCacheName = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee3() {
+        var user, cacheName, _user$attributes, userId, sanitizedUserId, _t;
+        return _regenerator().w(function (_context3) {
+          while (1) switch (_context3.n) {
+            case 0:
+              if (!this._cachedCacheName) {
+                _context3.n = 1;
+                break;
+              }
+              return _context3.a(2, this._cachedCacheName);
+            case 1:
+              _context3.p = 1;
+              _context3.n = 2;
+              return this.config.getUser();
+            case 2:
+              user = _context3.v;
+              if (!user) {
+                cacheName = "".concat(CACHE_NAME_PREFIX, "-anonymous");
+              } else {
+                userId = typeof user === 'string' ? user : user.username || ((_user$attributes = user.attributes) === null || _user$attributes === void 0 ? void 0 : _user$attributes.sub) || 'anonymous';
+                sanitizedUserId = userId.replace(/[^a-zA-Z0-9-]/g, '-');
+                cacheName = "".concat(CACHE_NAME_PREFIX, "-user-").concat(sanitizedUserId);
+              }
+              this._cachedCacheName = cacheName;
+              return _context3.a(2, cacheName);
+            case 3:
+              _context3.p = 3;
+              _t = _context3.v;
+              console.warn('Failed to get user for cache partition, using anonymous:', _t);
+              return _context3.a(2, "".concat(CACHE_NAME_PREFIX, "-anonymous"));
+          }
+        }, _callee3, this, [[1, 3]]);
+      }));
+      function getCacheName() {
+        return _getCacheName.apply(this, arguments);
+      }
+      return getCacheName;
+    }()
+    /**
+     * Execute a cache operation
+     */
+    )
+  }, {
+    key: "execute",
+    value: (function () {
+      var _execute = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee4(_ref) {
+        var cacheKey, sourceKey, expiryMs, fetcher, processor, _ref$metadata, metadata, cacheName, cache, cachedResponse, cachedTime, age, result, fetchResult, blobOrJson, contentType, contentSize, responseBody, headers, cacheResponse, fallbackResult, _t2;
+        return _regenerator().w(function (_context4) {
+          while (1) switch (_context4.n) {
+            case 0:
+              cacheKey = _ref.cacheKey, sourceKey = _ref.sourceKey, expiryMs = _ref.expiryMs, fetcher = _ref.fetcher, processor = _ref.processor, _ref$metadata = _ref.metadata, metadata = _ref$metadata === void 0 ? {} : _ref$metadata, _ref.logType;
+              _context4.p = 1;
+              _context4.n = 2;
+              return this.getCacheName();
+            case 2:
+              cacheName = _context4.v;
+              _context4.n = 3;
+              return this._getCacheHandle(cacheName);
+            case 3:
+              cache = _context4.v;
+              _context4.n = 4;
+              return cache.match(cacheKey);
+            case 4:
+              cachedResponse = _context4.v;
+              if (!cachedResponse) {
+                _context4.n = 7;
+                break;
+              }
+              cachedTime = cachedResponse.headers.get('x-cached-time');
+              age = Date.now() - parseInt(cachedTime || '0');
+              if (!(age < expiryMs)) {
+                _context4.n = 6;
+                break;
+              }
+              _context4.n = 5;
+              return processor(cachedResponse.clone());
+            case 5:
+              result = _context4.v;
+              this.stats.hits++;
+              if (result instanceof Blob) this.stats.totalBytesServed += result.size;
+              return _context4.a(2, result);
+            case 6:
+              _context4.n = 7;
+              return cache.delete(cacheKey);
+            case 7:
+              this.stats.misses++;
+              _context4.n = 8;
+              return fetcher();
+            case 8:
+              fetchResult = _context4.v;
+              blobOrJson = fetchResult;
+              if (!(fetchResult instanceof Response)) {
+                _context4.n = 11;
+                break;
+              }
+              if (fetchResult.ok) {
+                _context4.n = 9;
+                break;
+              }
+              throw new Error("Fetch failed: ".concat(fetchResult.status));
+            case 9:
+              _context4.n = 10;
+              return processor(fetchResult.clone());
+            case 10:
+              blobOrJson = _context4.v;
+            case 11:
+              contentType = 'application/octet-stream';
+              contentSize = 0;
+              responseBody = blobOrJson;
+              if (blobOrJson instanceof Blob) {
+                contentType = blobOrJson.type;
+                contentSize = blobOrJson.size;
+                this.stats.totalBytesCached += contentSize;
+                this.stats.totalBytesServed += contentSize;
+              } else {
+                contentType = 'application/json';
+                responseBody = JSON.stringify(blobOrJson);
+                contentSize = responseBody.length;
+              }
+              headers = new Headers(_objectSpread2({
+                'Content-Type': contentType,
+                'x-cached-time': Date.now().toString(),
+                'x-source-key': sourceKey || ''
+              }, metadata));
+              cacheResponse = new Response(responseBody, {
+                headers: headers
+              });
+              _context4.n = 12;
+              return cache.put(cacheKey, cacheResponse);
+            case 12:
+              return _context4.a(2, blobOrJson);
+            case 13:
+              _context4.p = 13;
+              _t2 = _context4.v;
+              this.stats.errors++;
+              this.config.onError(_t2);
+
+              // Fallback
+              _context4.p = 14;
+              _context4.n = 15;
+              return fetcher();
+            case 15:
+              fallbackResult = _context4.v;
+              if (!(fallbackResult instanceof Response)) {
+                _context4.n = 16;
+                break;
+              }
+              return _context4.a(2, processor(fallbackResult));
+            case 16:
+              return _context4.a(2, fallbackResult);
+            case 17:
+              _context4.p = 17;
+              _context4.v;
+              throw _t2;
+            case 18:
+              return _context4.a(2);
+          }
+        }, _callee4, this, [[14, 17], [1, 13]]);
+      }));
+      function execute(_x2) {
+        return _execute.apply(this, arguments);
+      }
+      return execute;
+    }())
+  }, {
+    key: "getGlobalStats",
+    value: function getGlobalStats() {
+      var uptime = Date.now() - this.stats.startTime;
+      return _objectSpread2(_objectSpread2({}, this.stats), {}, {
+        hitRate: this.stats.hits + this.stats.misses > 0 ? (this.stats.hits / (this.stats.hits + this.stats.misses) * 100).toFixed(1) + '%' : '0%',
+        totalMBServed: (this.stats.totalBytesServed / 1024 / 1024).toFixed(2),
+        totalMBCached: (this.stats.totalBytesCached / 1024 / 1024).toFixed(2),
+        uptimeMinutes: (uptime / 1000 / 60).toFixed(1)
+      });
+    }
+  }, {
+    key: "resetStats",
+    value: function resetStats() {
+      this.stats = {
+        hits: 0,
+        misses: 0,
+        errors: 0,
+        totalBytesServed: 0,
+        totalBytesCached: 0,
+        startTime: Date.now()
+      };
+    }
+  }, {
+    key: "clearCache",
+    value: function () {
+      var _clearCache = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee5() {
+        var specificKey,
+          clearAllUsers,
+          cacheName,
+          cache,
+          keys,
+          _iterator,
+          _step,
+          req,
+          cacheNames,
+          appCaches,
+          _iterator2,
+          _step2,
+          name,
+          _cacheName,
+          _args5 = arguments,
+          _t4,
+          _t5,
+          _t6;
+        return _regenerator().w(function (_context5) {
+          while (1) switch (_context5.n) {
+            case 0:
+              specificKey = _args5.length > 0 && _args5[0] !== undefined ? _args5[0] : null;
+              clearAllUsers = _args5.length > 1 && _args5[1] !== undefined ? _args5[1] : false;
+              _context5.p = 1;
+              if (!specificKey) {
+                _context5.n = 12;
+                break;
+              }
+              _context5.n = 2;
+              return this.getCacheName();
+            case 2:
+              cacheName = _context5.v;
+              _context5.n = 3;
+              return caches.open(cacheName);
+            case 3:
+              cache = _context5.v;
+              _context5.n = 4;
+              return cache.keys();
+            case 4:
+              keys = _context5.v;
+              _iterator = _createForOfIteratorHelper(keys);
+              _context5.p = 5;
+              _iterator.s();
+            case 6:
+              if ((_step = _iterator.n()).done) {
+                _context5.n = 8;
+                break;
+              }
+              req = _step.value;
+              if (!req.url.includes(specificKey)) {
+                _context5.n = 7;
+                break;
+              }
+              _context5.n = 7;
+              return cache.delete(req);
+            case 7:
+              _context5.n = 6;
+              break;
+            case 8:
+              _context5.n = 10;
+              break;
+            case 9:
+              _context5.p = 9;
+              _t4 = _context5.v;
+              _iterator.e(_t4);
+            case 10:
+              _context5.p = 10;
+              _iterator.f();
+              return _context5.f(10);
+            case 11:
+              _context5.n = 23;
+              break;
+            case 12:
+              if (!clearAllUsers) {
+                _context5.n = 21;
+                break;
+              }
+              _context5.n = 13;
+              return caches.keys();
+            case 13:
+              cacheNames = _context5.v;
+              appCaches = cacheNames.filter(function (name) {
+                return name.startsWith(CACHE_NAME_PREFIX);
+              });
+              _iterator2 = _createForOfIteratorHelper(appCaches);
+              _context5.p = 14;
+              _iterator2.s();
+            case 15:
+              if ((_step2 = _iterator2.n()).done) {
+                _context5.n = 17;
+                break;
+              }
+              name = _step2.value;
+              _context5.n = 16;
+              return caches.delete(name);
+            case 16:
+              _context5.n = 15;
+              break;
+            case 17:
+              _context5.n = 19;
+              break;
+            case 18:
+              _context5.p = 18;
+              _t5 = _context5.v;
+              _iterator2.e(_t5);
+            case 19:
+              _context5.p = 19;
+              _iterator2.f();
+              return _context5.f(19);
+            case 20:
+              _context5.n = 23;
+              break;
+            case 21:
+              _context5.n = 22;
+              return this.getCacheName();
+            case 22:
+              _cacheName = _context5.v;
+              _context5.n = 23;
+              return caches.delete(_cacheName);
+            case 23:
+              return _context5.a(2, true);
+            case 24:
+              _context5.p = 24;
+              _t6 = _context5.v;
+              this.config.onError(_t6);
+              return _context5.a(2, false);
+          }
+        }, _callee5, this, [[14, 18, 19, 20], [5, 9, 10, 11], [1, 24]]);
+      }));
+      function clearCache() {
+        return _clearCache.apply(this, arguments);
+      }
+      return clearCache;
+    }()
+  }, {
+    key: "cleanExpired",
+    value: function () {
+      var _cleanExpired = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee6() {
+        var cacheName, cache, keys, count, _iterator3, _step3, request, response, cachedTime, age, sourceKey, expiryMs, _t7, _t8;
+        return _regenerator().w(function (_context6) {
+          while (1) switch (_context6.n) {
+            case 0:
+              _context6.p = 0;
+              _context6.n = 1;
+              return this.getCacheName();
+            case 1:
+              cacheName = _context6.v;
+              _context6.n = 2;
+              return this._getCacheHandle(cacheName);
+            case 2:
+              cache = _context6.v;
+              _context6.n = 3;
+              return cache.keys();
+            case 3:
+              keys = _context6.v;
+              count = 0;
+              _iterator3 = _createForOfIteratorHelper(keys);
+              _context6.p = 4;
+              _iterator3.s();
+            case 5:
+              if ((_step3 = _iterator3.n()).done) {
+                _context6.n = 9;
+                break;
+              }
+              request = _step3.value;
+              _context6.n = 6;
+              return cache.match(request);
+            case 6:
+              response = _context6.v;
+              cachedTime = response.headers.get('x-cached-time');
+              age = Date.now() - parseInt(cachedTime || '0');
+              sourceKey = response.headers.get('x-source-key') || request.url;
+              expiryMs = this.getExpiryForPath(sourceKey);
+              if (!(age > expiryMs)) {
+                _context6.n = 8;
+                break;
+              }
+              _context6.n = 7;
+              return cache.delete(request);
+            case 7:
+              count++;
+            case 8:
+              _context6.n = 5;
+              break;
+            case 9:
+              _context6.n = 11;
+              break;
+            case 10:
+              _context6.p = 10;
+              _t7 = _context6.v;
+              _iterator3.e(_t7);
+            case 11:
+              _context6.p = 11;
+              _iterator3.f();
+              return _context6.f(11);
+            case 12:
+              return _context6.a(2, count);
+            case 13:
+              _context6.p = 13;
+              _t8 = _context6.v;
+              this.config.onError(_t8);
+              return _context6.a(2, 0);
+          }
+        }, _callee6, this, [[4, 10, 11, 12], [0, 13]]);
+      }));
+      function cleanExpired() {
+        return _cleanExpired.apply(this, arguments);
+      }
+      return cleanExpired;
+    }()
+  }, {
+    key: "cleanInvalid",
+    value: function () {
+      var _cleanInvalid = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee7() {
+        var cacheName, cache, keys, cleanedCount, _iterator4, _step4, request, url, _t9, _t0;
+        return _regenerator().w(function (_context7) {
+          while (1) switch (_context7.n) {
+            case 0:
+              _context7.p = 0;
+              _context7.n = 1;
+              return this.getCacheName();
+            case 1:
+              cacheName = _context7.v;
+              _context7.n = 2;
+              return this._getCacheHandle(cacheName);
+            case 2:
+              cache = _context7.v;
+              _context7.n = 3;
+              return cache.keys();
+            case 3:
+              keys = _context7.v;
+              cleanedCount = 0;
+              _iterator4 = _createForOfIteratorHelper(keys);
+              _context7.p = 4;
+              _iterator4.s();
+            case 5:
+              if ((_step4 = _iterator4.n()).done) {
+                _context7.n = 8;
+                break;
+              }
+              request = _step4.value;
+              url = request.url;
+              if (!(url.includes('undefined') || url.includes('null') || url.includes('/library/models//'))) {
+                _context7.n = 7;
+                break;
+              }
+              _context7.n = 6;
+              return cache.delete(request);
+            case 6:
+              cleanedCount++;
+            case 7:
+              _context7.n = 5;
+              break;
+            case 8:
+              _context7.n = 10;
+              break;
+            case 9:
+              _context7.p = 9;
+              _t9 = _context7.v;
+              _iterator4.e(_t9);
+            case 10:
+              _context7.p = 10;
+              _iterator4.f();
+              return _context7.f(10);
+            case 11:
+              return _context7.a(2, cleanedCount);
+            case 12:
+              _context7.p = 12;
+              _t0 = _context7.v;
+              this.config.onError(_t0);
+              return _context7.a(2, 0);
+          }
+        }, _callee7, this, [[4, 9, 10, 11], [0, 12]]);
+      }));
+      function cleanInvalid() {
+        return _cleanInvalid.apply(this, arguments);
+      }
+      return cleanInvalid;
+    }()
+    /**
+     * Check if a key exists in cache and is valid
+     */
+  }, {
+    key: "has",
+    value: (function () {
+      var _has = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee8(cacheKey) {
+        var expiryMs,
+          cacheName,
+          cache,
+          response,
+          cachedTime,
+          age,
+          expiry,
+          _args8 = arguments,
+          _t1;
+        return _regenerator().w(function (_context8) {
+          while (1) switch (_context8.n) {
+            case 0:
+              expiryMs = _args8.length > 1 && _args8[1] !== undefined ? _args8[1] : null;
+              _context8.p = 1;
+              _context8.n = 2;
+              return this.getCacheName();
+            case 2:
+              cacheName = _context8.v;
+              _context8.n = 3;
+              return this._getCacheHandle(cacheName);
+            case 3:
+              cache = _context8.v;
+              _context8.n = 4;
+              return cache.match(cacheKey);
+            case 4:
+              response = _context8.v;
+              if (response) {
+                _context8.n = 5;
+                break;
+              }
+              return _context8.a(2, false);
+            case 5:
+              cachedTime = response.headers.get('x-cached-time');
+              age = Date.now() - parseInt(cachedTime || '0');
+              expiry = expiryMs || this.getExpiryForPath(cacheKey);
+              if (!(age < expiry)) {
+                _context8.n = 6;
+                break;
+              }
+              return _context8.a(2, true);
+            case 6:
+              _context8.n = 7;
+              return cache.delete(cacheKey);
+            case 7:
+              return _context8.a(2, false);
+            case 8:
+              _context8.n = 10;
+              break;
+            case 9:
+              _context8.p = 9;
+              _t1 = _context8.v;
+              this.config.onError(_t1);
+              return _context8.a(2, false);
+            case 10:
+              return _context8.a(2);
+          }
+        }, _callee8, this, [[1, 9]]);
+      }));
+      function has(_x3) {
+        return _has.apply(this, arguments);
+      }
+      return has;
+    }()
+    /**
+     * Get a value from cache without fetching (returns null on miss/expiry)
+     */
+    )
+  }, {
+    key: "get",
+    value: (function () {
+      var _get = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee0(cacheKey) {
+        var expiryMs,
+          processor,
+          cacheName,
+          cache,
+          response,
+          cachedTime,
+          age,
+          expiry,
+          _args0 = arguments,
+          _t10;
+        return _regenerator().w(function (_context0) {
+          while (1) switch (_context0.n) {
+            case 0:
+              expiryMs = _args0.length > 1 && _args0[1] !== undefined ? _args0[1] : null;
+              processor = _args0.length > 2 && _args0[2] !== undefined ? _args0[2] : (/*#__PURE__*/function () {
+                var _ref2 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee9(r) {
+                  return _regenerator().w(function (_context9) {
+                    while (1) switch (_context9.n) {
+                      case 0:
+                        return _context9.a(2, r.json());
+                    }
+                  }, _callee9);
+                }));
+                return function (_x5) {
+                  return _ref2.apply(this, arguments);
+                };
+              }());
+              _context0.p = 1;
+              _context0.n = 2;
+              return this.getCacheName();
+            case 2:
+              cacheName = _context0.v;
+              _context0.n = 3;
+              return this._getCacheHandle(cacheName);
+            case 3:
+              cache = _context0.v;
+              _context0.n = 4;
+              return cache.match(cacheKey);
+            case 4:
+              response = _context0.v;
+              if (response) {
+                _context0.n = 5;
+                break;
+              }
+              return _context0.a(2, null);
+            case 5:
+              cachedTime = response.headers.get('x-cached-time');
+              age = Date.now() - parseInt(cachedTime || '0');
+              expiry = expiryMs || this.getExpiryForPath(cacheKey);
+              if (!(age < expiry)) {
+                _context0.n = 7;
+                break;
+              }
+              this.stats.hits++;
+              _context0.n = 6;
+              return processor(response);
+            case 6:
+              return _context0.a(2, _context0.v);
+            case 7:
+              _context0.n = 8;
+              return cache.delete(cacheKey);
+            case 8:
+              return _context0.a(2, null);
+            case 9:
+              _context0.n = 11;
+              break;
+            case 10:
+              _context0.p = 10;
+              _t10 = _context0.v;
+              this.config.onError(_t10);
+              return _context0.a(2, null);
+            case 11:
+              return _context0.a(2);
+          }
+        }, _callee0, this, [[1, 10]]);
+      }));
+      function get(_x4) {
+        return _get.apply(this, arguments);
+      }
+      return get;
+    }()
+    /**
+     * Delete a specific key from the cache
+     */
+    )
+  }, {
+    key: "delete",
+    value: (function () {
+      var _delete2 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee1(cacheKey) {
+        var cacheName, cache, _t11;
+        return _regenerator().w(function (_context1) {
+          while (1) switch (_context1.n) {
+            case 0:
+              _context1.p = 0;
+              _context1.n = 1;
+              return this.getCacheName();
+            case 1:
+              cacheName = _context1.v;
+              _context1.n = 2;
+              return this._getCacheHandle(cacheName);
+            case 2:
+              cache = _context1.v;
+              _context1.n = 3;
+              return cache.delete(cacheKey);
+            case 3:
+              return _context1.a(2, _context1.v);
+            case 4:
+              _context1.p = 4;
+              _t11 = _context1.v;
+              this.config.onError(_t11);
+              return _context1.a(2, false);
+          }
+        }, _callee1, this, [[0, 4]]);
+      }));
+      function _delete(_x6) {
+        return _delete2.apply(this, arguments);
+      }
+      return _delete;
+    }()
+    /**
+     * Delete a specific named cache (partition)
+     */
+    )
+  }, {
+    key: "deleteCache",
+    value: (function () {
+      var _deleteCache = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee10(cacheName) {
+        var _t12;
+        return _regenerator().w(function (_context10) {
+          while (1) switch (_context10.n) {
+            case 0:
+              _context10.p = 0;
+              _context10.n = 1;
+              return caches.delete(cacheName);
+            case 1:
+              return _context10.a(2, _context10.v);
+            case 2:
+              _context10.p = 2;
+              _t12 = _context10.v;
+              this.config.onError(_t12);
+              return _context10.a(2, false);
+          }
+        }, _callee10, this, [[0, 2]]);
+      }));
+      function deleteCache(_x7) {
+        return _deleteCache.apply(this, arguments);
+      }
+      return deleteCache;
+    }())
+  }, {
+    key: "getDetailedStats",
+    value: function () {
+      var _getDetailedStats = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee11() {
+        var allUsers,
+          cacheNames,
+          plantCaches,
+          allStats,
+          _iterator5,
+          _step5,
+          _cacheName2,
+          _cache,
+          _keys,
+          _totalSize,
+          _iterator6,
+          _step6,
+          request,
+          response,
+          blob,
+          grandTotal,
+          cacheName,
+          cache,
+          keys,
+          totalSize,
+          items,
+          _iterator7,
+          _step7,
+          _request,
+          _response,
+          _blob,
+          cachedTime,
+          sourceKey,
+          _args11 = arguments,
+          _t13,
+          _t14,
+          _t15,
+          _t16;
+        return _regenerator().w(function (_context11) {
+          while (1) switch (_context11.n) {
+            case 0:
+              allUsers = _args11.length > 0 && _args11[0] !== undefined ? _args11[0] : false;
+              _context11.p = 1;
+              if (!allUsers) {
+                _context11.n = 21;
+                break;
+              }
+              _context11.n = 2;
+              return caches.keys();
+            case 2:
+              cacheNames = _context11.v;
+              plantCaches = cacheNames.filter(function (name) {
+                return name.startsWith(CACHE_NAME_PREFIX);
+              });
+              allStats = [];
+              _iterator5 = _createForOfIteratorHelper(plantCaches);
+              _context11.p = 3;
+              _iterator5.s();
+            case 4:
+              if ((_step5 = _iterator5.n()).done) {
+                _context11.n = 17;
+                break;
+              }
+              _cacheName2 = _step5.value;
+              _context11.n = 5;
+              return caches.open(_cacheName2);
+            case 5:
+              _cache = _context11.v;
+              _context11.n = 6;
+              return _cache.keys();
+            case 6:
+              _keys = _context11.v;
+              _totalSize = 0;
+              _iterator6 = _createForOfIteratorHelper(_keys);
+              _context11.p = 7;
+              _iterator6.s();
+            case 8:
+              if ((_step6 = _iterator6.n()).done) {
+                _context11.n = 12;
+                break;
+              }
+              request = _step6.value;
+              _context11.n = 9;
+              return _cache.match(request);
+            case 9:
+              response = _context11.v;
+              _context11.n = 10;
+              return response.blob();
+            case 10:
+              blob = _context11.v;
+              _totalSize += blob.size;
+            case 11:
+              _context11.n = 8;
+              break;
+            case 12:
+              _context11.n = 14;
+              break;
+            case 13:
+              _context11.p = 13;
+              _t13 = _context11.v;
+              _iterator6.e(_t13);
+            case 14:
+              _context11.p = 14;
+              _iterator6.f();
+              return _context11.f(14);
+            case 15:
+              allStats.push({
+                cacheName: _cacheName2,
+                count: _keys.length,
+                totalSize: _totalSize,
+                totalSizeMB: (_totalSize / 1024 / 1024).toFixed(2)
+              });
+            case 16:
+              _context11.n = 4;
+              break;
+            case 17:
+              _context11.n = 19;
+              break;
+            case 18:
+              _context11.p = 18;
+              _t14 = _context11.v;
+              _iterator5.e(_t14);
+            case 19:
+              _context11.p = 19;
+              _iterator5.f();
+              return _context11.f(19);
+            case 20:
+              grandTotal = allStats.reduce(function (sum, stat) {
+                return sum + stat.totalSize;
+              }, 0);
+              return _context11.a(2, {
+                caches: allStats,
+                totalCaches: allStats.length,
+                grandTotalSizeMB: (grandTotal / 1024 / 1024).toFixed(2)
+              });
+            case 21:
+              _context11.n = 22;
+              return this.getCacheName();
+            case 22:
+              cacheName = _context11.v;
+              _context11.n = 23;
+              return caches.open(cacheName);
+            case 23:
+              cache = _context11.v;
+              _context11.n = 24;
+              return cache.keys();
+            case 24:
+              keys = _context11.v;
+              totalSize = 0;
+              items = [];
+              _iterator7 = _createForOfIteratorHelper(keys);
+              _context11.p = 25;
+              _iterator7.s();
+            case 26:
+              if ((_step7 = _iterator7.n()).done) {
+                _context11.n = 30;
+                break;
+              }
+              _request = _step7.value;
+              _context11.n = 27;
+              return cache.match(_request);
+            case 27:
+              _response = _context11.v;
+              _context11.n = 28;
+              return _response.blob();
+            case 28:
+              _blob = _context11.v;
+              cachedTime = _response.headers.get('x-cached-time');
+              sourceKey = _response.headers.get('x-source-key') || _response.headers.get('x-s3-key') || _response.headers.get('x-local-path') || _request.url;
+              totalSize += _blob.size;
+              items.push({
+                url: _request.url,
+                sourceKey: sourceKey,
+                size: _blob.size,
+                sizeMB: (_blob.size / 1024 / 1024).toFixed(2),
+                type: _blob.type,
+                cachedTime: parseInt(cachedTime || '0'),
+                age: Date.now() - parseInt(cachedTime || '0')
+              });
+            case 29:
+              _context11.n = 26;
+              break;
+            case 30:
+              _context11.n = 32;
+              break;
+            case 31:
+              _context11.p = 31;
+              _t15 = _context11.v;
+              _iterator7.e(_t15);
+            case 32:
+              _context11.p = 32;
+              _iterator7.f();
+              return _context11.f(32);
+            case 33:
+              return _context11.a(2, {
+                count: keys.length,
+                totalSize: totalSize,
+                totalSizeMB: (totalSize / 1024 / 1024).toFixed(2),
+                items: items.sort(function (a, b) {
+                  return b.size - a.size;
+                })
+              });
+            case 34:
+              _context11.p = 34;
+              _t16 = _context11.v;
+              this.config.onError(_t16);
+              return _context11.a(2, {
+                count: 0,
+                totalSize: 0,
+                totalSizeMB: '0',
+                items: []
+              });
+          }
+        }, _callee11, this, [[25, 31, 32, 33], [7, 13, 14, 15], [3, 18, 19, 20], [1, 34]]);
+      }));
+      function getDetailedStats() {
+        return _getDetailedStats.apply(this, arguments);
+      }
+      return getDetailedStats;
+    }()
+  }]);
+}();
+var cacheManager = new CacheManager();
+
+export { CACHE_EXPIRY, CACHE_NAME_PREFIX, CacheManager, cacheManager, cacheManager as default };