@trops/dash-core 0.1.165 → 0.1.166

package/dist/electron/index.js

@@ -4512,7 +4512,7 @@ var settingsController_1 = settingsController$1;
  *   window.mainApi.myService.getData({ ...pc, cache: true, forceRefresh: true }); // bypass
  */
 
-const cache = new Map(); // key → { data, timestamp, ttl }
+const cache$1 = new Map(); // key → { data, timestamp, ttl }
 const inflight = new Map(); // key → Promise
 
 function stableHash(obj) {
@@ -4528,13 +4528,13 @@ const responseCache$1 = {
   async get(key, fetcher, options = {}) {
     const { ttl = 30000, forceRefresh = false } = options;
 
-    if (!forceRefresh && cache.has(key)) {
-      const entry = cache.get(key);
+    if (!forceRefresh && cache$1.has(key)) {
+      const entry = cache$1.get(key);
       if (Date.now() - entry.timestamp < entry.ttl) {
         console.log(`[responseCache] HIT ${key}`);
         return entry.data;
       }
-      cache.delete(key);
+      cache$1.delete(key);
     }
 
     if (!forceRefresh && inflight.has(key)) {
@@ -4548,7 +4548,7 @@ const responseCache$1 = {
     try {
       const data = await promise;
       if (data && !data.error) {
-        cache.set(key, { data, timestamp: Date.now(), ttl });
+        cache$1.set(key, { data, timestamp: Date.now(), ttl });
       }
       return data;
     } finally {
@@ -4586,25 +4586,25 @@ const responseCache$1 = {
   },
 
   invalidate(key) {
-    cache.delete(key);
+    cache$1.delete(key);
   },
 
   invalidatePrefix(prefix) {
-    for (const k of cache.keys()) {
-      if (k.startsWith(prefix)) cache.delete(k);
+    for (const k of cache$1.keys()) {
+      if (k.startsWith(prefix)) cache$1.delete(k);
     }
   },
 
   clear() {
-    cache.clear();
+    cache$1.clear();
     inflight.clear();
   },
 
   stats() {
     return {
-      entries: cache.size,
+      entries: cache$1.size,
       inflight: inflight.size,
-      keys: [...cache.keys()],
+      keys: [...cache$1.keys()],
     };
   },
 };
@@ -45758,6 +45758,110 @@ const webSocketController$1 = {
 
 var webSocketController_1 = webSocketController$1;
 
+/**
+ * extractionCacheController.js
+ *
+ * LRU cache with TTL for theme-from-URL extraction results.
+ * Caches palette results keyed by URL to avoid re-scanning recently visited sites.
+ *
+ * - Default TTL: 24 hours
+ * - Max entries: 50 (LRU eviction)
+ * - In-memory only — cleared on app restart
+ * - Supports force refresh to bypass cache
+ */
+
+const DEFAULT_TTL = 24 * 60 * 60 * 1000; // 24 hours
+const MAX_ENTRIES = 50;
+
+// Map preserves insertion order — we use this for LRU tracking
+const cache = new Map(); // url → { data, timestamp, ttl }
+
+/**
+ * Get a cached result for the given URL, or run the fetcher and cache the result.
+ * @param {string} url - The URL key
+ * @param {Function} fetcher - Async function that produces the extraction result
+ * @param {Object} [options]
+ * @param {number} [options.ttl=86400000] - Time-to-live in milliseconds
+ * @param {boolean} [options.forceRefresh=false] - Bypass cache and re-extract
+ * @returns {Promise<any>} The extraction result
+ */
+async function get(url, fetcher, options = {}) {
+  const { ttl = DEFAULT_TTL, forceRefresh = false } = options;
+  const key = url.toLowerCase().replace(/\/+$/, ""); // normalize
+
+  if (!forceRefresh && cache.has(key)) {
+    const entry = cache.get(key);
+    if (Date.now() - entry.timestamp < entry.ttl) {
+      // Move to end (most recently used)
+      cache.delete(key);
+      cache.set(key, entry);
+      console.log(`[extractionCache] HIT ${key}`);
+      return entry.data;
+    }
+    // Expired
+    cache.delete(key);
+  }
+
+  console.log(`[extractionCache] ${forceRefresh ? "REFRESH" : "MISS"} ${key}`);
+  const data = await fetcher();
+
+  // Store result
+  cache.set(key, { data, timestamp: Date.now(), ttl });
+
+  // LRU eviction — remove oldest entries if over limit
+  while (cache.size > MAX_ENTRIES) {
+    const oldestKey = cache.keys().next().value;
+    cache.delete(oldestKey);
+    console.log(`[extractionCache] EVICT ${oldestKey}`);
+  }
+
+  return data;
+}
+
+/**
+ * Check if a URL has a valid (non-expired) cache entry.
+ * @param {string} url
+ * @returns {boolean}
+ */
+function has(url) {
+  const key = url.toLowerCase().replace(/\/+$/, "");
+  if (!cache.has(key)) return false;
+  const entry = cache.get(key);
+  if (Date.now() - entry.timestamp >= entry.ttl) {
+    cache.delete(key);
+    return false;
+  }
+  return true;
+}
+
+/** Clear all cached entries. */
+function clear() {
+  cache.clear();
+  console.log("[extractionCache] CLEARED");
+}
+
+/**
+ * Remove a single URL from the cache.
+ * @param {string} url
+ */
+function invalidate(url) {
+  const key = url.toLowerCase().replace(/\/+$/, "");
+  cache.delete(key);
+}
+
+/** Get cache statistics. */
+function stats() {
+  return {
+    entries: cache.size,
+    maxEntries: MAX_ENTRIES,
+    keys: [...cache.keys()],
+  };
+}
+
+const extractionCacheController$1 = { get, has, clear, invalidate, stats };
+
+var extractionCacheController_1 = extractionCacheController$1;
+
 /**
  * clientFactories.js
  *
@@ -48126,7 +48230,8 @@ const {
 } = events$8;
 
 const themeFromUrlApi$2 = {
-  extractFromUrl: (url) => ipcRenderer$4.invoke(THEME_EXTRACT_FROM_URL, { url }),
+  extractFromUrl: (url, { forceRefresh = false } = {}) =>
+    ipcRenderer$4.invoke(THEME_EXTRACT_FROM_URL, { url, forceRefresh }),
   mapPaletteToTheme: (palette, overrides) =>
     ipcRenderer$4.invoke(THEME_MAP_PALETTE_TO_THEME, { palette, overrides }),
 };
@@ -48508,6 +48613,7 @@ const themeRegistryController = themeRegistryController$1;
 const themeFromUrlController = themeFromUrlController_1;
 const paletteToThemeMapper = paletteToThemeMapper_1;
 const webSocketController = webSocketController_1;
+const extractionCacheController = extractionCacheController_1;
 
 // --- Utils ---
 const clientCache = requireClientCache();
@@ -48584,6 +48690,7 @@ var electron = {
   themeFromUrlController,
   paletteToThemeMapper,
   webSocketController,
+  extractionCacheController,
 
   // Controller functions (flat) — spread for convenient destructuring
   ...controllers,