@trops/dash-core 0.1.165 → 0.1.167

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,208 @@ 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;
+
+/**
+ * themeFromUrlErrors.js
+ *
+ * Typed error classes for the Theme from URL extraction pipeline.
+ * Used across dash-core (controller), dash-electron (IPC handler),
+ * and dash-react (UI error mapping).
+ */
+
+const ERROR_TYPES = {
+  URL_UNREACHABLE: "URL_UNREACHABLE",
+  URL_TIMEOUT: "URL_TIMEOUT",
+  EXTRACTION_FAILED: "EXTRACTION_FAILED",
+  NO_COLORS_FOUND: "NO_COLORS_FOUND",
+  FAVICON_FETCH_FAILED: "FAVICON_FETCH_FAILED",
+};
+
+class ThemeExtractionError extends Error {
+  /**
+   * @param {string} message - Developer-facing error message
+   * @param {Object} options
+   * @param {string} options.type - Machine-readable error type (from ERROR_TYPES)
+   * @param {string} options.userMessage - User-facing message for UI display
+   * @param {Error} [options.cause] - Original error that triggered this one
+   */
+  constructor(message, { type, userMessage, cause } = {}) {
+    super(message);
+    this.name = "ThemeExtractionError";
+    this.type = type;
+    this.userMessage = userMessage || "Something went wrong extracting colors.";
+    this.cause = cause || null;
+  }
+}
+
+class UrlUnreachableError extends ThemeExtractionError {
+  constructor(message, { cause } = {}) {
+    super(message || "URL is unreachable", {
+      type: ERROR_TYPES.URL_UNREACHABLE,
+      userMessage: "Couldn't reach that URL. Check the address.",
+      cause,
+    });
+    this.name = "UrlUnreachableError";
+  }
+}
+
+class UrlTimeoutError extends ThemeExtractionError {
+  constructor(message, { cause } = {}) {
+    super(message || "URL load timed out", {
+      type: ERROR_TYPES.URL_TIMEOUT,
+      userMessage: "The site took too long to load. Try a simpler page.",
+      cause,
+    });
+    this.name = "UrlTimeoutError";
+  }
+}
+
+class ExtractionFailedError extends ThemeExtractionError {
+  constructor(message, { cause } = {}) {
+    super(message || "Color extraction failed", {
+      type: ERROR_TYPES.EXTRACTION_FAILED,
+      userMessage: "Failed to extract colors from this site.",
+      cause,
+    });
+    this.name = "ExtractionFailedError";
+  }
+}
+
+class NoColorsFoundError extends ThemeExtractionError {
+  constructor(message, { cause } = {}) {
+    super(message || "No usable colors found", {
+      type: ERROR_TYPES.NO_COLORS_FOUND,
+      userMessage: "No usable colors found. Try a more styled page.",
+      cause,
+    });
+    this.name = "NoColorsFoundError";
+  }
+}
+
+class FaviconFetchError extends ThemeExtractionError {
+  constructor(message, { cause } = {}) {
+    super(message || "Favicon fetch failed", {
+      type: ERROR_TYPES.FAVICON_FETCH_FAILED,
+      userMessage: "Couldn't fetch the site's favicon.",
+      cause,
+    });
+    this.name = "FaviconFetchError";
+  }
+}
+
+var themeFromUrlErrors$1 = {
+  ERROR_TYPES,
+  ThemeExtractionError,
+  UrlUnreachableError,
+  UrlTimeoutError,
+  ExtractionFailedError,
+  NoColorsFoundError,
+  FaviconFetchError,
+};
+
 /**
  * clientFactories.js
  *
@@ -48126,7 +48328,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 +48711,10 @@ const themeRegistryController = themeRegistryController$1;
 const themeFromUrlController = themeFromUrlController_1;
 const paletteToThemeMapper = paletteToThemeMapper_1;
 const webSocketController = webSocketController_1;
+const extractionCacheController = extractionCacheController_1;
+
+// --- Errors ---
+const themeFromUrlErrors = themeFromUrlErrors$1;
 
 // --- Utils ---
 const clientCache = requireClientCache();
@@ -48584,6 +48791,7 @@ var electron = {
   themeFromUrlController,
   paletteToThemeMapper,
   webSocketController,
+  extractionCacheController,
 
   // Controller functions (flat) — spread for convenient destructuring
   ...controllers,
@@ -48629,6 +48837,9 @@ var electron = {
   clientCache,
   responseCache,
 
+  // Errors
+  themeFromUrlErrors,
+
   // Schema
   dashboardConfigValidator,
   dashboardConfigUtils,