@widgetic/design-system 0.5.10 → 0.5.12

package/dist/stores/pdfCache.js

@@ -1,4 +1,6 @@
 import { writable } from 'svelte/store';
+// Max number of PDFs in memory simultaneously
+const MAX_CACHE_SIZE = 5;
 // Create a cache store with a Map to hold PDF documents by URL
 function createPDFCache() {
     const cache = new Map();
@@ -8,7 +10,32 @@ function createPDFCache() {
     // Utility function for logging only when enabled
     const log = (message, ...args) => {
         if (showLogs) {
-            console.log(message, ...args);
+            // console.log(message, ...args);
+        }
+    };
+    const evictOldestIfNeeded = (cacheMap) => {
+        if (cacheMap.size < MAX_CACHE_SIZE)
+            return;
+        let oldestUrl = null;
+        let oldestTime = Infinity;
+        for (const [key, entry] of cacheMap.entries()) {
+            if (entry.lastAccessed < oldestTime) {
+                oldestTime = entry.lastAccessed;
+                oldestUrl = key;
+            }
+        }
+        if (oldestUrl) {
+            const entry = cacheMap.get(oldestUrl);
+            if (entry?.document) {
+                try {
+                    entry.document.destroy();
+                }
+                catch (err) {
+                    console.error(`Error destroying evicted cached PDF: ${oldestUrl}`, err);
+                }
+            }
+            cacheMap.delete(oldestUrl);
+            log(`Evicted oldest cached PDF: ${oldestUrl}`);
         }
     };
     return {
@@ -19,52 +46,45 @@ function createPDFCache() {
         },
         // Add or update a PDF document in the cache
         set: (url, document, pageNumber = 1) => {
-            update(cache => {
-                cache.set(url, {
+            update(cacheMap => {
+                if (!cacheMap.has(url)) {
+                    evictOldestIfNeeded(cacheMap);
+                }
+                cacheMap.set(url, {
                     document,
                     lastAccessed: Date.now(),
                     pageNumber
                 });
-                log(`PDF cached: ${url}, total cached: ${cache.size}`);
-                return cache;
+                log(`PDF cached: ${url}, total cached: ${cacheMap.size}`);
+                return cacheMap;
             });
         },
-        // Get a PDF document from the cache
+        // Get a PDF document from the cache without triggering reactive store churn
         get: (url) => {
-            let entry;
-            update(cache => {
-                entry = cache.get(url);
-                // Update last accessed time if found
-                if (entry) {
-                    entry.lastAccessed = Date.now();
-                    cache.set(url, entry);
-                    log(`PDF cache hit: ${url}`);
-                }
-                else {
-                    log(`PDF cache miss: ${url}`);
-                }
-                return cache;
-            });
+            const entry = cache.get(url);
+            if (entry) {
+                entry.lastAccessed = Date.now();
+                log(`PDF cache hit: ${url}`);
+            }
+            else {
+                log(`PDF cache miss: ${url}`);
+            }
             return entry;
         },
         // Update the page number for a cached PDF
         updatePageNumber: (url, pageNumber) => {
-            update(cache => {
-                const entry = cache.get(url);
-                if (entry) {
-                    entry.pageNumber = pageNumber;
-                    entry.lastAccessed = Date.now();
-                    cache.set(url, entry);
-                    log(`PDF page number updated: ${url}, page: ${pageNumber}`);
-                }
-                return cache;
-            });
+            const entry = cache.get(url);
+            if (entry) {
+                entry.pageNumber = pageNumber;
+                entry.lastAccessed = Date.now();
+                log(`PDF page number updated: ${url}, page: ${pageNumber}`);
+            }
         },
         // Remove a PDF document from the cache
         remove: (url) => {
-            update(cache => {
+            update(cacheMap => {
                 // Get the document to destroy it properly
-                const entry = cache.get(url);
+                const entry = cacheMap.get(url);
                 if (entry?.document) {
                     try {
                         entry.document.destroy();
@@ -74,15 +94,15 @@ function createPDFCache() {
                         console.error(`Error destroying cached PDF: ${url}`, err);
                     }
                 }
-                cache.delete(url);
-                return cache;
+                cacheMap.delete(url);
+                return cacheMap;
             });
         },
         // Clear the entire cache
         clear: () => {
-            update(cache => {
+            update(cacheMap => {
                 // Properly destroy all cached documents
-                for (const [url, entry] of cache.entries()) {
+                for (const [url, entry] of cacheMap.entries()) {
                     try {
                         entry.document.destroy();
                     }
@@ -90,9 +110,9 @@ function createPDFCache() {
                         console.error(`Error destroying cached PDF: ${url}`, err);
                     }
                 }
-                cache.clear();
+                cacheMap.clear();
                 log('PDF cache cleared');
-                return cache;
+                return cacheMap;
             });
         }
     };