ani-client 2.2.1 → 2.3.0

package/dist/index.mjs

@@ -115,8 +115,17 @@ function validateIds(ids, label = "id") {
 function sortObjectKeys(obj) {
   if (obj === null || typeof obj !== "object") return obj;
   if (Array.isArray(obj)) return obj.map(sortObjectKeys);
+  const keys = Object.keys(obj);
+  if (keys.length === 0) return obj;
+  if (keys.length === 1) {
+    const key = keys[0];
+    const val = obj[key];
+    const sortedVal = sortObjectKeys(val);
+    if (val === sortedVal) return obj;
+    return { [key]: sortedVal };
+  }
   const sorted = {};
-  for (const key of Object.keys(obj).sort()) {
+  for (const key of keys.sort()) {
     sorted[key] = sortObjectKeys(obj[key]);
   }
   return sorted;
@@ -130,10 +139,10 @@ var NormalizedCache = class {
   swrMs;
   queryStore = /* @__PURE__ */ new Map();
   entityStore = /* @__PURE__ */ new Map();
+  refCount = /* @__PURE__ */ new Map();
   _hits = 0;
   _misses = 0;
   _stales = 0;
-  gcTimeout;
   constructor(options = {}) {
     this.ttl = options.ttl ?? 24 * 60 * 60 * 1e3;
     this.maxSize = options.maxSize ?? 500;
@@ -145,11 +154,11 @@ var NormalizedCache = class {
     return `${normalized}|${JSON.stringify(sortObjectKeys(variables))}`;
   }
   /** Normalizes a GraphQL response, extracting entities and returning a tree of references. */
-  normalize(data, seen = /* @__PURE__ */ new WeakSet()) {
+  normalize(data, refsOut, seen = /* @__PURE__ */ new WeakSet()) {
     if (Array.isArray(data)) {
       if (seen.has(data)) return null;
       seen.add(data);
-      return data.map((item) => this.normalize(item, seen));
+      return data.map((item) => this.normalize(item, refsOut, seen));
     }
     if (data !== null && typeof data === "object") {
       if (seen.has(data)) return null;
@@ -157,17 +166,22 @@ var NormalizedCache = class {
       const obj = data;
       if (typeof obj.__typename === "string" && (typeof obj.id === "number" || typeof obj.id === "string")) {
         const ref = `${obj.__typename}:${obj.id}`;
+        refsOut.add(ref);
         const normalizedObj = {};
-        for (const [k, v] of Object.entries(obj)) {
-          normalizedObj[k] = this.normalize(v, seen);
+        for (const k in obj) {
+          if (Object.hasOwn(obj, k)) {
+            normalizedObj[k] = this.normalize(obj[k], refsOut, seen);
+          }
         }
         const existing = this.entityStore.get(ref) || {};
         this.entityStore.set(ref, { ...existing, ...normalizedObj });
         return { __ref: ref };
       }
       const result = {};
-      for (const [k, v] of Object.entries(obj)) {
-        result[k] = this.normalize(v, seen);
+      for (const k in obj) {
+        if (Object.hasOwn(obj, k)) {
+          result[k] = this.normalize(obj[k], refsOut, seen);
+        }
       }
       return result;
     }
@@ -193,10 +207,12 @@ var NormalizedCache = class {
         return result2;
       }
       const result = {};
-      for (const [k, v] of Object.entries(obj)) {
-        const denormalized = this.denormalize(v, seen);
-        if (denormalized === void 0) return void 0;
-        result[k] = denormalized;
+      for (const k in obj) {
+        if (Object.hasOwn(obj, k)) {
+          const denormalized = this.denormalize(obj[k], seen);
+          if (denormalized === void 0) return void 0;
+          result[k] = denormalized;
+        }
       }
       return result;
     }
@@ -215,14 +231,14 @@ var NormalizedCache = class {
       if (this.swrMs > 0 && now <= entry.expiresAt + this.swrMs) {
         isStale = true;
       } else {
-        this.queryStore.delete(key);
+        this.deleteQueryEntry(key, entry);
         this._misses++;
         return void 0;
       }
     }
     const denormalized = this.denormalize(entry.data);
     if (denormalized === void 0) {
-      this.queryStore.delete(key);
+      this.deleteQueryEntry(key, entry);
       this._misses++;
       return void 0;
     }
@@ -241,27 +257,46 @@ var NormalizedCache = class {
   }
   set(key, data) {
     if (!this.enabled) return;
-    const normalizedData = this.normalize(data);
-    this.queryStore.delete(key);
+    const refs = /* @__PURE__ */ new Set();
+    const normalizedData = this.normalize(data, refs);
+    const existing = this.queryStore.get(key);
+    if (existing) {
+      this.deleteQueryEntry(key, existing);
+    }
     if (this.maxSize > 0 && this.queryStore.size >= this.maxSize) {
       const firstKey = this.queryStore.keys().next().value;
       if (firstKey !== void 0) {
-        this.queryStore.delete(firstKey);
+        const firstEntry = this.queryStore.get(firstKey);
+        if (firstEntry) this.deleteQueryEntry(firstKey, firstEntry);
+      }
+    }
+    for (const ref of refs) {
+      this.refCount.set(ref, (this.refCount.get(ref) ?? 0) + 1);
+    }
+    this.queryStore.set(key, { data: normalizedData, refs, expiresAt: Date.now() + this.ttl });
+  }
+  deleteQueryEntry(key, entry) {
+    this.queryStore.delete(key);
+    for (const ref of entry.refs) {
+      const count = (this.refCount.get(ref) ?? 0) - 1;
+      if (count <= 0) {
+        this.refCount.delete(ref);
+        this.entityStore.delete(ref);
+      } else {
+        this.refCount.set(ref, count);
       }
-      this.scheduleGc();
     }
-    this.queryStore.set(key, { data: normalizedData, expiresAt: Date.now() + this.ttl });
   }
   delete(key) {
-    return this.queryStore.delete(key);
+    const entry = this.queryStore.get(key);
+    if (!entry) return false;
+    this.deleteQueryEntry(key, entry);
+    return true;
   }
   clear() {
-    if (this.gcTimeout) {
-      clearTimeout(this.gcTimeout);
-      this.gcTimeout = void 0;
-    }
     this.queryStore.clear();
     this.entityStore.clear();
+    this.refCount.clear();
     this._hits = 0;
     this._misses = 0;
     this._stales = 0;
@@ -278,7 +313,9 @@ var NormalizedCache = class {
     for (const key of this.queryStore.keys()) {
       if (test(key)) toDelete.push(key);
     }
-    for (const key of toDelete) this.queryStore.delete(key);
+    for (const key of toDelete) {
+      this.delete(key);
+    }
     return toDelete.length;
   }
   get stats() {
@@ -296,53 +333,6 @@ var NormalizedCache = class {
     this._misses = 0;
     this._stales = 0;
   }
-  scheduleGc() {
-    if (this.gcTimeout) return;
-    this.gcTimeout = setTimeout(() => {
-      this.gc();
-      this.gcTimeout = void 0;
-    }, 500);
-    if (typeof this.gcTimeout.unref === "function") {
-      this.gcTimeout.unref();
-    }
-  }
-  /**
-   * Garbage-collect orphaned entities that are no longer referenced by any query.
-   * Called automatically on LRU eviction to prevent unbounded entity store growth.
-   */
-  gc() {
-    const referencedRefs = /* @__PURE__ */ new Set();
-    const collectRefs = (data) => {
-      if (Array.isArray(data)) {
-        for (const item of data) collectRefs(item);
-        return;
-      }
-      if (data !== null && typeof data === "object") {
-        const obj = data;
-        if (typeof obj.__ref === "string") {
-          referencedRefs.add(obj.__ref);
-          const entity = this.entityStore.get(obj.__ref);
-          if (entity && !referencedRefs.has(`_visited:${obj.__ref}`)) {
-            referencedRefs.add(`_visited:${obj.__ref}`);
-            collectRefs(entity);
-          }
-          return;
-        }
-        for (const v of Object.values(obj)) collectRefs(v);
-      }
-    };
-    for (const entry of this.queryStore.values()) {
-      collectRefs(entry.data);
-    }
-    let removed = 0;
-    for (const ref of this.entityStore.keys()) {
-      if (!referencedRefs.has(ref)) {
-        this.entityStore.delete(ref);
-        removed++;
-      }
-    }
-    return removed;
-  }
 };
 
 // src/cache/index.ts
@@ -2539,7 +2529,7 @@ function mapFavorites(fav) {
 
 // src/client/index.ts
 var DEFAULT_API_URL = "https://graphql.anilist.co";
-var LIB_VERSION = "2.2.1" ;
+var LIB_VERSION = "2.3.0" ;
 var AniListClient = class {
   apiUrl;
   headers;