@trops/dash-core 0.1.166 → 0.1.168

package/dist/electron/index.js

@@ -38770,6 +38770,104 @@ var stringify = function(node, options){
 css$1.parse = parse$3;
 css$1.stringify = stringify;
 
+/**
+ * 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;
+  }
+}
+
+let UrlUnreachableError$1 = 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";
+  }
+}
+
+let ExtractionFailedError$1 = 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";
+  }
+};
+
+let NoColorsFoundError$1 = 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: UrlUnreachableError$1,
+  UrlTimeoutError,
+  ExtractionFailedError: ExtractionFailedError$1,
+  NoColorsFoundError: NoColorsFoundError$1,
+  FaviconFetchError,
+};
+
 /**
  * themeFromUrlController.js
  *
@@ -38783,6 +38881,11 @@ const { Vibrant } = require$$1$6;
 const https$1 = require$$8;
 const http$2 = require$$3$4;
 const { URL: URL$2 } = require$$4$1;
+const {
+  UrlUnreachableError,
+  ExtractionFailedError,
+  NoColorsFoundError,
+} = themeFromUrlErrors$1;
 
 // ─── Color conversion helpers ───────────────────────────────────────────────
 
@@ -38838,6 +38941,9 @@ function parseColor(str) {
     );
   }
 
+  console.warn(
+    `[themeFromUrlController] parseColor: unrecognized color format "${str}"`,
+  );
   return null;
 }
 
@@ -39135,12 +39241,22 @@ function resolveUrl(href, baseUrl) {
 
 /**
  * Fetch a URL and return the response as a Buffer.
- * Follows redirects (up to 5). Times out after 10 seconds.
+ * Follows redirects (up to maxRedirects). Times out after 10 seconds.
  * @param {string} url - Absolute URL to fetch
+ * @param {number} [maxRedirects=5] - Maximum number of redirects to follow
+ * @param {number} [_redirectCount=0] - Internal: current redirect count
  * @returns {Promise<Buffer>}
  */
-function fetchBuffer(url) {
+function fetchBuffer(url, maxRedirects = 5, _redirectCount = 0) {
   return new Promise((resolve, reject) => {
+    if (_redirectCount >= maxRedirects) {
+      reject(
+        new UrlUnreachableError(
+          `Too many redirects (${_redirectCount}) fetching ${url}`,
+        ),
+      );
+      return;
+    }
     const parsedUrl = new URL$2(url);
     const client = parsedUrl.protocol === "https:" ? https$1 : http$2;
     const request = client.get(
@@ -39155,7 +39271,9 @@ function fetchBuffer(url) {
         ) {
           const redirectUrl = resolveUrl(res.headers.location, url);
           if (redirectUrl) {
-            fetchBuffer(redirectUrl).then(resolve).catch(reject);
+            fetchBuffer(redirectUrl, maxRedirects, _redirectCount + 1)
+              .then(resolve)
+              .catch(reject);
             return;
           }
         }
@@ -39273,10 +39391,12 @@ function isBoringColor(hex) {
  * Merge colors from all sources, deduplicate via clustering, and rank.
  * @param {Array<{hex, source, confidence}>} allColors - Colors from all extraction stages
  * @param {number} maxColors - Maximum palette size (default: 6)
- * @returns {Array<{hex, rgb, hsl, confidence, sources}>}
+ * @returns {{ palette: Array<{hex, rgb, hsl, confidence, sources}>, reason: string }}
  */
 function mergeAndRank(allColors, maxColors = 6) {
-  if (!allColors || allColors.length === 0) return [];
+  if (!allColors || allColors.length === 0) {
+    return { palette: [], reason: "no_colors_extracted" };
+  }
 
   // Build clusters — group colors within deltaE < 10
   const clusters = [];
@@ -39320,6 +39440,11 @@ function mergeAndRank(allColors, maxColors = 6) {
   const interesting = clusters.filter((c) => !isBoringColor(c.hex));
   const boring = clusters.filter((c) => isBoringColor(c.hex));
 
+  // All colors were filtered as boring
+  if (interesting.length === 0 && boring.length === 0) {
+    return { palette: [], reason: "all_colors_filtered" };
+  }
+
   // Score: confidence * frequency weight * saturation bonus
   const scored = interesting.map((c) => {
     const hsl = rgbToHsl$1(c.rgb);
@@ -39367,7 +39492,11 @@ function mergeAndRank(allColors, maxColors = 6) {
     });
   }
 
-  return palette;
+  if (palette.length === 0) {
+    return { palette: [], reason: "all_colors_filtered" };
+  }
+
+  return { palette, reason: "success" };
 }
 
 // ─── Main export ─────────────────────────────────────────────────────────────
@@ -39404,6 +39533,11 @@ async function extractColorsFromUrl({
     `[themeFromUrlController] CSS vars: ${cssVarColors.length} colors`,
   );
 
+  // Null guard on computedStyles
+  if (computedStyles != null && typeof computedStyles !== "object") {
+    throw new ExtractionFailedError("computedStyles must be an object or null");
+  }
+
   const computedColors = extractComputedColors(computedStyles);
   console.log(
     `[themeFromUrlController] Computed styles: ${computedColors.length} colors`,
@@ -39429,17 +39563,32 @@ async function extractColorsFromUrl({
     ...cssVarColors,
     ...computedColors,
     ...faviconColors,
-  ];
+  ].filter((c) => {
+    if (!c.hex) {
+      console.warn(
+        `[themeFromUrlController] Skipping color with missing hex from source "${c.source}"`,
+      );
+      return false;
+    }
+    return true;
+  });
   console.log(`[themeFromUrlController] Total raw colors: ${allColors.length}`);
 
-  const palette = mergeAndRank(allColors);
+  const { palette, reason } = mergeAndRank(allColors);
   console.log(
-    `[themeFromUrlController] Final palette: ${palette.length} colors`,
+    `[themeFromUrlController] Final palette: ${palette.length} colors (reason: ${reason})`,
   );
 
+  if (palette.length === 0) {
+    throw new NoColorsFoundError(
+      `No usable colors extracted (reason: ${reason})`,
+    );
+  }
+
   return {
     palette,
     rawCount: allColors.length,
+    reason,
   };
 }
 
@@ -39727,6 +39876,8 @@ var require$$1 = /*@__PURE__*/getAugmentedNamespace(themeGenerator);
 
 const { TAILWIND_COLORS } = require$$0;
 
+const VALID_HEX_RE = /^#[0-9a-fA-F]{6}$/;
+
 // ─── Color conversion helpers ───────────────────────────────────────────────
 // These mirror the helpers in themeFromUrlController but are kept local
 // to avoid coupling the two modules.
@@ -39878,8 +40029,38 @@ function assignRoles$1(palette) {
     };
   }
 
+  // Validate and filter palette entries — each must have hex and confidence
+  const validPalette = palette.filter((c) => {
+    if (!c || typeof c !== "object") {
+      console.warn("[paletteToThemeMapper] Skipping non-object palette entry");
+      return false;
+    }
+    if (!c.hex || typeof c.hex !== "string") {
+      console.warn(
+        "[paletteToThemeMapper] Skipping palette entry with missing hex",
+      );
+      return false;
+    }
+    if (c.confidence == null || typeof c.confidence !== "number") {
+      console.warn(
+        `[paletteToThemeMapper] Skipping palette entry "${c.hex}" with missing confidence`,
+      );
+      return false;
+    }
+    return true;
+  });
+
+  if (validPalette.length === 0) {
+    return {
+      primary: "#6b7280",
+      secondary: "#3b82f6",
+      tertiary: "#6366f1",
+      neutral: "#64748b",
+    };
+  }
+
   // Ensure all entries have hsl
-  const colors = palette.map((c) => {
+  const colors = validPalette.map((c) => {
     const rgb = c.rgb || parseHex(c.hex);
     const hsl = c.hsl || (rgb ? rgbToHsl(rgb) : { h: 0, s: 0, l: 50 });
     return { ...c, rgb, hsl };
@@ -39982,11 +40163,18 @@ function generateThemeFromPalette$1(palette, overrides = {}) {
   // Step 1: Assign roles
   const roles = assignRoles$1(palette);
 
-  // Apply any user overrides
-  if (overrides.primary) roles.primary = overrides.primary;
-  if (overrides.secondary) roles.secondary = overrides.secondary;
-  if (overrides.tertiary) roles.tertiary = overrides.tertiary;
-  if (overrides.neutral) roles.neutral = overrides.neutral;
+  // Apply any user overrides (validate hex format)
+  for (const role of ["primary", "secondary", "tertiary", "neutral"]) {
+    if (overrides[role]) {
+      if (VALID_HEX_RE.test(overrides[role])) {
+        roles[role] = overrides[role];
+      } else {
+        console.warn(
+          `[paletteToThemeMapper] Skipping invalid override for ${role}: "${overrides[role]}"`,
+        );
+      }
+    }
+  }
 
   // Step 2: Match each role to nearest Tailwind family
   const primaryMatch = matchTailwindFamily$1(roles.primary);
@@ -48615,6 +48803,9 @@ const paletteToThemeMapper = paletteToThemeMapper_1;
 const webSocketController = webSocketController_1;
 const extractionCacheController = extractionCacheController_1;
 
+// --- Errors ---
+const themeFromUrlErrors = themeFromUrlErrors$1;
+
 // --- Utils ---
 const clientCache = requireClientCache();
  // auto-register built-in factories
@@ -48736,6 +48927,9 @@ var electron = {
   clientCache,
   responseCache,
 
+  // Errors
+  themeFromUrlErrors,
+
   // Schema
   dashboardConfigValidator,
   dashboardConfigUtils,