@asaidimu/utils-cache 1.0.0

package/index.mjs

@@ -0,0 +1,650 @@
+// node_modules/uuid/dist/esm/stringify.js
+var byteToHex = [];
+for (let i = 0; i < 256; ++i) {
+  byteToHex.push((i + 256).toString(16).slice(1));
+}
+function unsafeStringify(arr, offset = 0) {
+  return (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + "-" + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + "-" + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + "-" + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + "-" + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]).toLowerCase();
+}
+
+// node_modules/uuid/dist/esm/rng.js
+import { randomFillSync } from "crypto";
+var rnds8Pool = new Uint8Array(256);
+var poolPtr = rnds8Pool.length;
+function rng() {
+  if (poolPtr > rnds8Pool.length - 16) {
+    randomFillSync(rnds8Pool);
+    poolPtr = 0;
+  }
+  return rnds8Pool.slice(poolPtr, poolPtr += 16);
+}
+
+// node_modules/uuid/dist/esm/native.js
+import { randomUUID } from "crypto";
+var native_default = { randomUUID };
+
+// node_modules/uuid/dist/esm/v4.js
+function v4(options, buf, offset) {
+  if (native_default.randomUUID && !buf && !options) {
+    return native_default.randomUUID();
+  }
+  options = options || {};
+  const rnds = options.random ?? options.rng?.() ?? rng();
+  if (rnds.length < 16) {
+    throw new Error("Random bytes length must be >= 16");
+  }
+  rnds[6] = rnds[6] & 15 | 64;
+  rnds[8] = rnds[8] & 63 | 128;
+  if (buf) {
+    offset = offset || 0;
+    if (offset < 0 || offset + 16 > buf.length) {
+      throw new RangeError(`UUID byte range ${offset}:${offset + 15} is out of buffer bounds`);
+    }
+    for (let i = 0; i < 16; ++i) {
+      buf[offset + i] = rnds[i];
+    }
+    return buf;
+  }
+  return unsafeStringify(rnds);
+}
+var v4_default = v4;
+
+// src/cache/cache.ts
+var Cache = class {
+  cache = /* @__PURE__ */ new Map();
+  queries = /* @__PURE__ */ new Map();
+  fetching = /* @__PURE__ */ new Map();
+  defaultOptions;
+  metrics;
+  eventListeners = /* @__PURE__ */ new Map();
+  gcTimer;
+  // Persistence-related properties
+  persistenceId;
+  persistenceUnsubscribe;
+  persistenceDebounceTimer;
+  isHandlingRemoteUpdate = false;
+  constructor(defaultOptions = {}) {
+    if (defaultOptions.staleTime !== void 0 && defaultOptions.staleTime < 0) {
+      console.warn("CacheOptions: staleTime should be non-negative. Using 0.");
+      defaultOptions.staleTime = 0;
+    }
+    if (defaultOptions.cacheTime !== void 0 && defaultOptions.cacheTime < 0) {
+      console.warn("CacheOptions: cacheTime should be non-negative. Using 0.");
+      defaultOptions.cacheTime = 0;
+    }
+    if (defaultOptions.retryAttempts !== void 0 && defaultOptions.retryAttempts < 0) {
+      console.warn("CacheOptions: retryAttempts should be non-negative. Using 0.");
+      defaultOptions.retryAttempts = 0;
+    }
+    if (defaultOptions.retryDelay !== void 0 && defaultOptions.retryDelay < 0) {
+      console.warn("CacheOptions: retryDelay should be non-negative. Using 0.");
+      defaultOptions.retryDelay = 0;
+    }
+    if (defaultOptions.maxSize !== void 0 && defaultOptions.maxSize < 0) {
+      console.warn("CacheOptions: maxSize should be non-negative. Using 0.");
+      defaultOptions.maxSize = 0;
+    }
+    this.defaultOptions = {
+      staleTime: 5 * 60 * 1e3,
+      cacheTime: 30 * 60 * 1e3,
+      retryAttempts: 3,
+      retryDelay: 1e3,
+      maxSize: 1e3,
+      enableMetrics: true,
+      persistence: void 0,
+      persistenceId: void 0,
+      serializeValue: (value) => value,
+      deserializeValue: (value) => value,
+      persistenceDebounceTime: 500,
+      ...defaultOptions
+    };
+    this.metrics = { hits: 0, misses: 0, fetches: 0, errors: 0, evictions: 0, staleHits: 0 };
+    this.persistenceId = this.defaultOptions.persistenceId || v4_default();
+    this.startGarbageCollection();
+    this.initializePersistence();
+  }
+  async initializePersistence() {
+    const { persistence } = this.defaultOptions;
+    if (!persistence)
+      return;
+    try {
+      const persistedState = await persistence.get();
+      if (persistedState) {
+        this.deserializeAndLoadCache(persistedState);
+        this.emitEvent({ type: "persistence", key: this.persistenceId, timestamp: Date.now(), event: "load_success", message: `Cache loaded for ID: ${this.persistenceId}` });
+      }
+    } catch (error) {
+      console.error(`Cache (${this.persistenceId}): Failed to load state from persistence:`, error);
+      this.emitEvent({ type: "persistence", key: this.persistenceId, timestamp: Date.now(), event: "load_fail", error, message: `Failed to load cache for ID: ${this.persistenceId}` });
+    }
+    if (typeof persistence.subscribe === "function") {
+      try {
+        this.persistenceUnsubscribe = persistence.subscribe(
+          this.persistenceId,
+          (remoteState) => {
+            this.handleRemoteStateChange(remoteState);
+          }
+        );
+      } catch (error) {
+        console.error(`Cache (${this.persistenceId}): Failed to subscribe to persistence:`, error);
+      }
+    }
+  }
+  serializeCache() {
+    const serializableEntries = [];
+    const { serializeValue } = this.defaultOptions;
+    for (const [key, entry] of this.cache) {
+      if (entry.isLoading && entry.data === void 0 && entry.lastUpdated === 0)
+        continue;
+      serializableEntries.push([
+        key,
+        {
+          data: serializeValue(entry.data),
+          lastUpdated: entry.lastUpdated,
+          lastAccessed: entry.lastAccessed,
+          accessCount: entry.accessCount,
+          error: entry.error ? { name: entry.error.name, message: entry.error.message, stack: entry.error.stack } : void 0
+        }
+      ]);
+    }
+    return serializableEntries;
+  }
+  deserializeAndLoadCache(persistedState) {
+    this.isHandlingRemoteUpdate = true;
+    const tempCache = /* @__PURE__ */ new Map();
+    const { deserializeValue } = this.defaultOptions;
+    for (const [key, sEntry] of persistedState) {
+      let errorInstance;
+      if (sEntry.error) {
+        errorInstance = new Error(sEntry.error.message);
+        errorInstance.name = sEntry.error.name;
+        errorInstance.stack = sEntry.error.stack;
+      }
+      tempCache.set(key, {
+        data: deserializeValue(sEntry.data),
+        lastUpdated: sEntry.lastUpdated,
+        lastAccessed: sEntry.lastAccessed,
+        accessCount: sEntry.accessCount,
+        error: errorInstance,
+        isLoading: false
+      });
+    }
+    this.cache = tempCache;
+    this.enforceSizeLimit(false);
+    this.isHandlingRemoteUpdate = false;
+  }
+  schedulePersistState() {
+    if (!this.defaultOptions.persistence || this.isHandlingRemoteUpdate) {
+      return;
+    }
+    if (this.persistenceDebounceTimer) {
+      clearTimeout(this.persistenceDebounceTimer);
+    }
+    this.persistenceDebounceTimer = setTimeout(async () => {
+      try {
+        const stateToPersist = this.serializeCache();
+        await this.defaultOptions.persistence.set(this.persistenceId, stateToPersist);
+        this.emitEvent({ type: "persistence", key: this.persistenceId, timestamp: Date.now(), event: "save_success" });
+      } catch (error) {
+        console.error(`Cache (${this.persistenceId}): Failed to persist state:`, error);
+        this.emitEvent({ type: "persistence", key: this.persistenceId, timestamp: Date.now(), event: "save_fail", error });
+      }
+    }, this.defaultOptions.persistenceDebounceTime);
+  }
+  handleRemoteStateChange(remoteState) {
+    if (this.isHandlingRemoteUpdate || !remoteState)
+      return;
+    this.isHandlingRemoteUpdate = true;
+    const { deserializeValue } = this.defaultOptions;
+    const newCache = /* @__PURE__ */ new Map();
+    let changed = false;
+    for (const [key, sEntry] of remoteState) {
+      let errorInstance;
+      if (sEntry.error) {
+        errorInstance = new Error(sEntry.error.message);
+        errorInstance.name = sEntry.error.name;
+        errorInstance.stack = sEntry.error.stack;
+      }
+      const newEntry = {
+        data: deserializeValue(sEntry.data),
+        lastUpdated: sEntry.lastUpdated,
+        lastAccessed: sEntry.lastAccessed,
+        accessCount: sEntry.accessCount,
+        error: errorInstance,
+        isLoading: false
+      };
+      newCache.set(key, newEntry);
+      const localEntry = this.cache.get(key);
+      if (!localEntry || localEntry.lastUpdated < newEntry.lastUpdated || JSON.stringify(localEntry.data) !== JSON.stringify(newEntry.data)) {
+        changed = true;
+      }
+    }
+    if (this.cache.size !== newCache.size)
+      changed = true;
+    if (changed) {
+      this.cache = newCache;
+      this.enforceSizeLimit(false);
+      this.emitEvent({ type: "persistence", key: this.persistenceId, timestamp: Date.now(), event: "remote_update", message: "Cache updated from remote state." });
+    }
+    this.isHandlingRemoteUpdate = false;
+  }
+  registerQuery(key, fetchFunction, options = {}) {
+    if (options.staleTime !== void 0 && options.staleTime < 0)
+      options.staleTime = 0;
+    if (options.cacheTime !== void 0 && options.cacheTime < 0)
+      options.cacheTime = 0;
+    this.queries.set(key, {
+      fetchFunction,
+      options: { ...this.defaultOptions, ...options }
+    });
+  }
+  async get(key, options) {
+    const query = this.queries.get(key);
+    if (!query) {
+      throw new Error(`No query registered for key: ${key}`);
+    }
+    let cacheEntry = this.cache.get(key);
+    const isEntryStale = this.isStale(cacheEntry, query.options);
+    let placeholderCreated = false;
+    if (cacheEntry) {
+      cacheEntry.lastAccessed = Date.now();
+      cacheEntry.accessCount++;
+      this.updateMetrics("hits");
+      if (isEntryStale)
+        this.updateMetrics("staleHits");
+      this.emitEvent({ type: "hit", key, timestamp: Date.now(), data: cacheEntry.data, isStale: isEntryStale });
+    } else {
+      this.updateMetrics("misses");
+      this.emitEvent({ type: "miss", key, timestamp: Date.now() });
+      if (!options?.waitForFresh || isEntryStale) {
+        const newPlaceholder = {
+          data: void 0,
+          lastUpdated: 0,
+          lastAccessed: Date.now(),
+          accessCount: 1,
+          isLoading: true,
+          error: void 0
+        };
+        this.cache.set(key, newPlaceholder);
+        cacheEntry = newPlaceholder;
+        placeholderCreated = true;
+      }
+    }
+    if (options?.waitForFresh && (!cacheEntry || isEntryStale || cacheEntry.isLoading)) {
+      try {
+        const freshData = await this.fetchAndWait(key, query);
+        if (placeholderCreated && this.cache.get(key) === cacheEntry)
+          this.schedulePersistState();
+        return freshData;
+      } catch (error) {
+        if (options.throwOnError)
+          throw error;
+        return this.cache.get(key)?.data;
+      }
+    }
+    if (!cacheEntry || isEntryStale || cacheEntry && !cacheEntry.isLoading && cacheEntry.lastUpdated === 0 && !cacheEntry.error) {
+      if (cacheEntry && !cacheEntry.isLoading) {
+        cacheEntry.isLoading = true;
+      } else if (!cacheEntry) {
+        const tempEntry = { data: void 0, lastUpdated: 0, lastAccessed: Date.now(), accessCount: 0, isLoading: true, error: void 0 };
+        this.cache.set(key, tempEntry);
+        cacheEntry = tempEntry;
+        placeholderCreated = true;
+      }
+      this.fetch(key, query).catch(() => {
+      });
+    }
+    if (placeholderCreated) {
+      this.schedulePersistState();
+    }
+    if (cacheEntry?.error && options?.throwOnError) {
+      throw cacheEntry.error;
+    }
+    return cacheEntry?.data;
+  }
+  peek(key) {
+    const cacheEntry = this.cache.get(key);
+    if (cacheEntry) {
+      cacheEntry.lastAccessed = Date.now();
+      cacheEntry.accessCount++;
+    }
+    return cacheEntry?.data;
+  }
+  has(key) {
+    const cacheEntry = this.cache.get(key);
+    const query = this.queries.get(key);
+    if (!cacheEntry || !query)
+      return false;
+    return !this.isStale(cacheEntry, query.options) && !cacheEntry.isLoading;
+  }
+  async fetch(key, query) {
+    if (this.fetching.has(key)) {
+      return this.fetching.get(key);
+    }
+    let cacheEntry = this.cache.get(key);
+    if (!cacheEntry) {
+      cacheEntry = { data: void 0, lastUpdated: 0, lastAccessed: Date.now(), accessCount: 0, isLoading: true, error: void 0 };
+      this.cache.set(key, cacheEntry);
+      this.schedulePersistState();
+    } else if (!cacheEntry.isLoading) {
+      cacheEntry.isLoading = true;
+      cacheEntry.error = void 0;
+    }
+    const fetchPromise = this.performFetchWithRetry(key, query, cacheEntry);
+    this.fetching.set(key, fetchPromise);
+    try {
+      return await fetchPromise;
+    } finally {
+      this.fetching.delete(key);
+    }
+  }
+  async fetchAndWait(key, query) {
+    const existingFetch = this.fetching.get(key);
+    if (existingFetch) {
+      return existingFetch;
+    }
+    const result = await this.fetch(key, query);
+    if (result === void 0) {
+      const currentEntry = this.cache.get(key);
+      if (currentEntry?.error)
+        throw currentEntry.error;
+      throw new Error(`Failed to fetch data for key: ${key} after retries.`);
+    }
+    return result;
+  }
+  async performFetchWithRetry(key, query, entry) {
+    const { retryAttempts, retryDelay } = query.options;
+    let lastError;
+    entry.isLoading = true;
+    for (let attempt = 0; attempt <= retryAttempts; attempt++) {
+      try {
+        this.emitEvent({ type: "fetch", key, timestamp: Date.now(), attempt });
+        this.updateMetrics("fetches");
+        const data = await query.fetchFunction();
+        entry.data = data;
+        entry.lastUpdated = Date.now();
+        entry.isLoading = false;
+        entry.error = void 0;
+        this.cache.set(key, entry);
+        this.schedulePersistState();
+        this.enforceSizeLimit();
+        return data;
+      } catch (error) {
+        lastError = error;
+        this.emitEvent({ type: "error", key, timestamp: Date.now(), error: lastError, attempt });
+        if (attempt < retryAttempts) {
+          await this.delay(retryDelay * Math.pow(2, attempt));
+        }
+      }
+    }
+    this.updateMetrics("errors");
+    entry.error = lastError;
+    entry.isLoading = false;
+    this.cache.set(key, entry);
+    this.schedulePersistState();
+    return void 0;
+  }
+  isStale(cacheEntry, options) {
+    if (!cacheEntry || cacheEntry.error)
+      return true;
+    if (cacheEntry.isLoading && !cacheEntry.data)
+      return true;
+    const { staleTime } = options;
+    if (staleTime === 0 || staleTime === Infinity)
+      return false;
+    return Date.now() - cacheEntry.lastUpdated > staleTime;
+  }
+  async invalidate(key, refetch = true) {
+    const cacheEntry = this.cache.get(key);
+    const query = this.queries.get(key);
+    let changed = false;
+    if (cacheEntry) {
+      changed = cacheEntry.lastUpdated !== 0 || cacheEntry.error !== void 0;
+      cacheEntry.lastUpdated = 0;
+      cacheEntry.error = void 0;
+      this.emitEvent({ type: "invalidation", key, timestamp: Date.now() });
+      if (changed)
+        this.schedulePersistState();
+      if (refetch && query) {
+        this.fetch(key, query).catch(() => {
+        });
+      }
+    }
+  }
+  async invalidatePattern(pattern, refetch = true) {
+    const keysToInvalidate = [];
+    let anyChanged = false;
+    for (const key of this.cache.keys()) {
+      if (pattern.test(key))
+        keysToInvalidate.push(key);
+    }
+    keysToInvalidate.forEach((key) => {
+      const cacheEntry = this.cache.get(key);
+      if (cacheEntry) {
+        if (cacheEntry.lastUpdated !== 0 || cacheEntry.error !== void 0)
+          anyChanged = true;
+        cacheEntry.lastUpdated = 0;
+        cacheEntry.error = void 0;
+        this.emitEvent({ type: "invalidation", key, timestamp: Date.now() });
+      }
+    });
+    if (anyChanged)
+      this.schedulePersistState();
+    if (refetch && keysToInvalidate.length > 0) {
+      await Promise.all(keysToInvalidate.map((key) => {
+        const query = this.queries.get(key);
+        return query ? this.fetch(key, query).catch(() => {
+        }) : Promise.resolve();
+      }));
+    }
+  }
+  async prefetch(key) {
+    const query = this.queries.get(key);
+    if (!query) {
+      console.warn(`Cannot prefetch: No query registered for key: ${key}`);
+      return;
+    }
+    const cacheEntry = this.cache.get(key);
+    if (!cacheEntry || this.isStale(cacheEntry, query.options)) {
+      this.fetch(key, query).catch(() => {
+      });
+    }
+  }
+  async refresh(key) {
+    const query = this.queries.get(key);
+    if (!query) {
+      console.warn(`Cannot refresh: No query registered for key: ${key}`);
+      return void 0;
+    }
+    this.fetching.delete(key);
+    let entry = this.cache.get(key);
+    if (!entry) {
+      entry = { data: void 0, lastUpdated: 0, lastAccessed: Date.now(), accessCount: 0, isLoading: true, error: void 0 };
+      this.cache.set(key, entry);
+      this.schedulePersistState();
+    } else {
+      entry.isLoading = true;
+      entry.error = void 0;
+    }
+    const fetchPromise = this.performFetchWithRetry(key, query, entry);
+    this.fetching.set(key, fetchPromise);
+    try {
+      return await fetchPromise;
+    } finally {
+      this.fetching.delete(key);
+    }
+  }
+  setData(key, data) {
+    const existingEntry = this.cache.get(key);
+    const oldData = existingEntry?.data;
+    const newEntry = {
+      data,
+      lastUpdated: Date.now(),
+      lastAccessed: Date.now(),
+      accessCount: (existingEntry?.accessCount || 0) + 1,
+      isLoading: false,
+      error: void 0
+    };
+    this.cache.set(key, newEntry);
+    this.schedulePersistState();
+    this.enforceSizeLimit();
+    this.emitEvent({ type: "set_data", key, timestamp: Date.now(), newData: data, oldData });
+  }
+  remove(key) {
+    this.fetching.delete(key);
+    const existed = this.cache.has(key);
+    const deleted = this.cache.delete(key);
+    if (deleted && existed) {
+      this.schedulePersistState();
+    }
+    return deleted;
+  }
+  enforceSizeLimit(schedulePersist = true) {
+    const { maxSize } = this.defaultOptions;
+    if (maxSize === Infinity || this.cache.size <= maxSize)
+      return;
+    let evictedCount = 0;
+    if (maxSize === 0) {
+      evictedCount = this.cache.size;
+      for (const key of this.cache.keys()) {
+        this.cache.delete(key);
+        this.emitEvent({ type: "eviction", key, timestamp: Date.now(), reason: "size_limit_zero" });
+        this.updateMetrics("evictions");
+      }
+    } else {
+      const entries = Array.from(this.cache.entries()).sort(([, a], [, b]) => a.lastAccessed - b.lastAccessed);
+      const numToEvict = this.cache.size - maxSize;
+      if (numToEvict > 0) {
+        const toEvict = entries.slice(0, numToEvict);
+        toEvict.forEach(([key]) => {
+          if (this.cache.delete(key)) {
+            evictedCount++;
+            this.emitEvent({ type: "eviction", key, timestamp: Date.now(), reason: "size_limit_lru" });
+            this.updateMetrics("evictions");
+          }
+        });
+      }
+    }
+    if (evictedCount > 0 && schedulePersist) {
+      this.schedulePersistState();
+    }
+  }
+  startGarbageCollection() {
+    const { cacheTime } = this.defaultOptions;
+    if (cacheTime === Infinity || cacheTime <= 0)
+      return;
+    const interval = Math.max(1e3, Math.min(cacheTime / 4, 5 * 60 * 1e3));
+    this.gcTimer = setInterval(() => this.garbageCollect(), interval);
+  }
+  garbageCollect() {
+    const now = Date.now();
+    let collected = 0;
+    const keysToDelete = [];
+    for (const [key, entry] of this.cache) {
+      if (entry.isLoading)
+        continue;
+      const query = this.queries.get(key);
+      const itemCacheTime = query?.options.cacheTime ?? this.defaultOptions.cacheTime;
+      if (itemCacheTime === Infinity || itemCacheTime <= 0)
+        continue;
+      if (now - entry.lastAccessed > itemCacheTime) {
+        keysToDelete.push(key);
+      }
+    }
+    if (keysToDelete.length > 0) {
+      keysToDelete.forEach((key) => {
+        if (this.cache.delete(key)) {
+          this.fetching.delete(key);
+          this.emitEvent({ type: "eviction", key, timestamp: Date.now(), reason: "garbage_collected_idle" });
+          this.updateMetrics("evictions");
+          collected++;
+        }
+      });
+      this.schedulePersistState();
+    }
+    return collected;
+  }
+  getStats() {
+    const totalRequests = this.metrics.hits + this.metrics.misses;
+    const hitRate = totalRequests > 0 ? this.metrics.hits / totalRequests : 0;
+    const staleHitRate = this.metrics.hits > 0 ? this.metrics.staleHits / this.metrics.hits : 0;
+    const entries = Array.from(this.cache.entries()).map(([key, entry]) => {
+      const query = this.queries.get(key);
+      const isStale = query ? this.isStale(entry, query.options) : true;
+      return { key, lastAccessed: entry.lastAccessed, lastUpdated: entry.lastUpdated, accessCount: entry.accessCount, isStale, isLoading: entry.isLoading, error: !!entry.error };
+    });
+    return { size: this.cache.size, metrics: { ...this.metrics }, hitRate, staleHitRate, entries };
+  }
+  on(event, listener) {
+    if (!this.eventListeners.has(event)) {
+      this.eventListeners.set(event, /* @__PURE__ */ new Set());
+    }
+    this.eventListeners.get(event).add(listener);
+  }
+  off(event, listener) {
+    this.eventListeners.get(event)?.delete(listener);
+  }
+  emitEvent(event) {
+    const listeners = this.eventListeners.get(event.type);
+    if (!listeners)
+      return;
+    listeners.forEach((listener) => {
+      try {
+        listener(event);
+      } catch (error) {
+        const idInfo = event.type === "persistence" ? `for ID ${event.key}` : `for key ${event.key}`;
+        console.error(`Cache event listener error during ${event.type} ${idInfo}:`, error);
+      }
+    });
+  }
+  updateMetrics(type, amount = 1) {
+    if (this.defaultOptions.enableMetrics) {
+      this.metrics[type] = (this.metrics[type] || 0) + amount;
+    }
+  }
+  delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  async clear() {
+    const hadItems = this.cache.size > 0;
+    this.cache.clear();
+    this.fetching.clear();
+    if (this.defaultOptions.enableMetrics) {
+      this.metrics = { hits: 0, misses: 0, fetches: 0, errors: 0, evictions: 0, staleHits: 0 };
+    }
+    if (this.defaultOptions.persistence) {
+      try {
+        await this.defaultOptions.persistence.clear();
+        this.emitEvent({ type: "persistence", key: this.persistenceId, timestamp: Date.now(), event: "clear_success" });
+      } catch (error) {
+        console.error(`Cache (${this.persistenceId}): Failed to clear persisted state:`, error);
+        this.emitEvent({ type: "persistence", key: this.persistenceId, timestamp: Date.now(), event: "clear_fail", error });
+      }
+    } else if (hadItems) {
+      this.schedulePersistState();
+    }
+  }
+  destroy() {
+    if (this.gcTimer) {
+      clearInterval(this.gcTimer);
+      this.gcTimer = void 0;
+    }
+    if (this.persistenceDebounceTimer)
+      clearTimeout(this.persistenceDebounceTimer);
+    if (this.persistenceUnsubscribe) {
+      try {
+        this.persistenceUnsubscribe();
+      } catch (error) {
+        console.error(`Cache (${this.persistenceId}): Error unsubscribing persistence:`, error);
+      }
+    }
+    this.cache.clear();
+    this.fetching.clear();
+    this.queries.clear();
+    this.eventListeners.clear();
+    this.metrics = { hits: 0, misses: 0, fetches: 0, errors: 0, evictions: 0, staleHits: 0 };
+  }
+};
+export {
+  Cache
+};