@trops/dash-core 0.1.160 → 0.1.162

package/dist/electron/index.js

@@ -29,11 +29,12 @@ var require$$2$4 = require('os');
 var require$$4$1 = require('url');
 var require$$2$3 = require('vm');
 var require$$1$5 = require('croner');
+var require$$1$6 = require('node-vibrant/node');
+var require$$3$4 = require('http');
 var require$$0$c = require('events');
-var require$$2$5 = require('http');
-var require$$3$4 = require('net');
+var require$$3$5 = require('net');
 var require$$4$2 = require('tls');
-var require$$1$6 = require('crypto');
+var require$$1$7 = require('crypto');
 var require$$0$a = require('zlib');
 var require$$0$b = require('buffer');
 
@@ -3748,7 +3749,7 @@ const { getFileContents: getFileContents$5, writeToFile: writeToFile$2 } = file;
 const ObjectsToCsv = require$$5;
 const Transform = transform;
 const { extractColorsFromImageURL: extractColorsFromImageURL$1 } = color;
-const https$1 = require$$8;
+const https$2 = require$$8;
 const appName$5 = "Dashboard";
 
 const dataController$1 = {
@@ -3901,7 +3902,7 @@ const dataController$1 = {
 
       const writeStream = fs$8.createWriteStream(resolvedFilepath);
 
-      https$1
+      https$2
         .get(url, (resp) => {
           resp.on("data", (chunk) => {
             writeStream.write(chunk);
@@ -38774,10 +38775,14 @@ css$1.stringify = stringify;
  *
  * Color extraction pipeline for generating themes from a website URL.
  * Extracts brand colors from HTML meta tags, CSS custom properties,
- * and computed styles, then merges and ranks them into a palette.
+ * computed styles, and favicon/logo images (via node-vibrant).
  */
 
 const css = css$1;
+const { Vibrant } = require$$1$6;
+const https$1 = require$$8;
+const http$2 = require$$3$4;
+const { URL: URL$2 } = require$$4$1;
 
 // ─── Color conversion helpers ───────────────────────────────────────────────
 
@@ -39072,6 +39077,178 @@ function extractComputedColors(computedStyles) {
   return results;
 }
 
+// ─── Favicon extraction ──────────────────────────────────────────────────────
+
+/**
+ * Parse HTML to find favicon and apple-touch-icon URLs.
+ * Prefers apple-touch-icon (higher resolution) and largest available sizes.
+ * @param {string} htmlContent - Raw HTML string
+ * @returns {Array<{url: string, priority: number}>} Sorted by priority (highest first)
+ */
+function extractFaviconUrls(htmlContent) {
+  if (!htmlContent) return [];
+  const icons = [];
+
+  // apple-touch-icon (higher resolution, best for extraction)
+  const appleTouchPattern =
+    /<link[^>]*rel\s*=\s*["']apple-touch-icon(?:-precomposed)?["'][^>]*>/gi;
+  let match;
+  while ((match = appleTouchPattern.exec(htmlContent)) !== null) {
+    const hrefMatch = match[0].match(/href\s*=\s*["']([^"']+)["']/i);
+    if (hrefMatch) {
+      const sizesMatch = match[0].match(/sizes\s*=\s*["'](\d+)x(\d+)["']/i);
+      const size = sizesMatch ? parseInt(sizesMatch[1], 10) : 180; // apple-touch-icon defaults to 180
+      icons.push({ url: hrefMatch[1], priority: 100 + size });
+    }
+  }
+
+  // Standard favicon link tags (icon, shortcut icon)
+  const iconPattern =
+    /<link[^>]*rel\s*=\s*["'](?:shortcut\s+)?icon["'][^>]*>/gi;
+  while ((match = iconPattern.exec(htmlContent)) !== null) {
+    const hrefMatch = match[0].match(/href\s*=\s*["']([^"']+)["']/i);
+    if (hrefMatch) {
+      const sizesMatch = match[0].match(/sizes\s*=\s*["'](\d+)x(\d+)["']/i);
+      const size = sizesMatch ? parseInt(sizesMatch[1], 10) : 16;
+      icons.push({ url: hrefMatch[1], priority: size });
+    }
+  }
+
+  // Sort by priority descending (prefer largest / apple-touch-icon)
+  icons.sort((a, b) => b.priority - a.priority);
+  return icons;
+}
+
+/**
+ * Resolve a potentially relative URL against a base URL.
+ * @param {string} href - The href from the HTML (may be relative)
+ * @param {string} baseUrl - The page URL to resolve against
+ * @returns {string|null} Absolute URL or null if invalid
+ */
+function resolveUrl(href, baseUrl) {
+  try {
+    return new URL$2(href, baseUrl).href;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Fetch a URL and return the response as a Buffer.
+ * Follows redirects (up to 5). Times out after 10 seconds.
+ * @param {string} url - Absolute URL to fetch
+ * @returns {Promise<Buffer>}
+ */
+function fetchBuffer(url) {
+  return new Promise((resolve, reject) => {
+    const parsedUrl = new URL$2(url);
+    const client = parsedUrl.protocol === "https:" ? https$1 : http$2;
+    const request = client.get(
+      url,
+      { timeout: 10000, headers: { "User-Agent": "Dash/1.0" } },
+      (res) => {
+        // Follow redirects
+        if (
+          res.statusCode >= 300 &&
+          res.statusCode < 400 &&
+          res.headers.location
+        ) {
+          const redirectUrl = resolveUrl(res.headers.location, url);
+          if (redirectUrl) {
+            fetchBuffer(redirectUrl).then(resolve).catch(reject);
+            return;
+          }
+        }
+        if (res.statusCode !== 200) {
+          reject(new Error(`HTTP ${res.statusCode}`));
+          return;
+        }
+        const chunks = [];
+        res.on("data", (chunk) => chunks.push(chunk));
+        res.on("end", () => resolve(Buffer.concat(chunks)));
+        res.on("error", reject);
+      },
+    );
+    request.on("error", reject);
+    request.on("timeout", () => {
+      request.destroy();
+      reject(new Error("Timeout"));
+    });
+  });
+}
+
+/**
+ * Extract colors from favicon/logo images using node-vibrant.
+ * Tries icons in priority order (apple-touch-icon first, largest first).
+ * Returns on the first successful extraction.
+ *
+ * @param {string} htmlContent - Raw HTML to parse for icon URLs
+ * @param {string} baseUrl - Page URL for resolving relative icon paths
+ * @returns {Promise<Array<{hex: string, source: string, confidence: number}>>}
+ */
+async function extractFaviconColors(htmlContent, baseUrl) {
+  const iconEntries = extractFaviconUrls(htmlContent);
+  if (iconEntries.length === 0) {
+    // Fallback: try /favicon.ico at the domain root
+    try {
+      const rootFavicon = new URL$2("/favicon.ico", baseUrl).href;
+      iconEntries.push({ url: rootFavicon, priority: 1 });
+    } catch {
+      return [];
+    }
+  }
+
+  for (const entry of iconEntries) {
+    const absoluteUrl = resolveUrl(entry.url, baseUrl);
+    if (!absoluteUrl) continue;
+
+    try {
+      const buffer = await fetchBuffer(absoluteUrl);
+      const palette = await Vibrant.from(buffer).getPalette();
+
+      const results = [];
+      const swatchNames = [
+        "Vibrant",
+        "DarkVibrant",
+        "LightVibrant",
+        "Muted",
+        "DarkMuted",
+        "LightMuted",
+      ];
+
+      for (const name of swatchNames) {
+        const swatch = palette[name];
+        if (!swatch) continue;
+        const [r, g, b] = swatch.rgb;
+        const hex = rgbToHex({
+          r: Math.round(r),
+          g: Math.round(g),
+          b: Math.round(b),
+        });
+        results.push({
+          hex,
+          source: "favicon",
+          confidence: 0.7,
+        });
+      }
+
+      if (results.length > 0) {
+        console.log(
+          `[themeFromUrlController] Favicon vibrant: ${results.length} swatches from ${absoluteUrl}`,
+        );
+        return results;
+      }
+    } catch (err) {
+      console.warn(
+        `[themeFromUrlController] Favicon extraction failed for ${absoluteUrl}: ${err.message}`,
+      );
+      // Try next icon
+    }
+  }
+
+  return [];
+}
+
 // ─── Merge & rank ────────────────────────────────────────────────────────────
 
 /**
@@ -39198,13 +39375,23 @@ function mergeAndRank(allColors, maxColors = 6) {
 /**
  * Extract a ranked color palette from website content.
  *
+ * When `baseUrl` is provided, also extracts colors from favicon/logo images
+ * via node-vibrant (async). Without `baseUrl`, runs synchronously using only
+ * meta tags, CSS vars, and computed styles.
+ *
  * @param {Object} params
  * @param {string} params.htmlContent - Raw HTML of the page
  * @param {string} params.cssContent - Concatenated CSS content
  * @param {Object} params.computedStyles - Map of selector → { color, backgroundColor, borderColor }
- * @returns {{ palette: Array, rawCount: number }}
- */
-function extractColorsFromUrl({ htmlContent, cssContent, computedStyles }) {
+ * @param {string} [params.baseUrl] - Page URL for resolving favicon paths (enables image extraction)
+ * @returns {Promise<{ palette: Array, rawCount: number }>}
+ */
+async function extractColorsFromUrl({
+  htmlContent,
+  cssContent,
+  computedStyles,
+  baseUrl,
+}) {
   console.log("[themeFromUrlController] Starting color extraction pipeline");
 
   const metaColors = extractMetaColors(htmlContent);
@@ -39222,7 +39409,27 @@ function extractColorsFromUrl({ htmlContent, cssContent, computedStyles }) {
     `[themeFromUrlController] Computed styles: ${computedColors.length} colors`,
   );
 
-  const allColors = [...metaColors, ...cssVarColors, ...computedColors];
+  // Favicon extraction (async, requires baseUrl)
+  let faviconColors = [];
+  if (baseUrl) {
+    try {
+      faviconColors = await extractFaviconColors(htmlContent, baseUrl);
+      console.log(
+        `[themeFromUrlController] Favicon/logo: ${faviconColors.length} colors`,
+      );
+    } catch (err) {
+      console.warn(
+        `[themeFromUrlController] Favicon extraction failed: ${err.message}`,
+      );
+    }
+  }
+
+  const allColors = [
+    ...metaColors,
+    ...cssVarColors,
+    ...computedColors,
+    ...faviconColors,
+  ];
   console.log(`[themeFromUrlController] Total raw colors: ${allColors.length}`);
 
   const palette = mergeAndRank(allColors);
@@ -39238,6 +39445,8 @@ function extractColorsFromUrl({ htmlContent, cssContent, computedStyles }) {
 
 const themeFromUrlController$1 = {
   extractColorsFromUrl,
+  extractFaviconUrls,
+  extractFaviconColors,
 };
 
 var themeFromUrlController_1 = themeFromUrlController$1;
@@ -41465,7 +41674,7 @@ let Receiver$1 = class Receiver extends Writable {
 var receiver = Receiver$1;
 
 /* eslint no-unused-vars: ["error", { "varsIgnorePattern": "^Duplex" }] */
-const { randomFillSync } = require$$1$6;
+const { randomFillSync } = require$$1$7;
 
 const PerMessageDeflate$2 = permessageDeflate;
 const { EMPTY_BUFFER: EMPTY_BUFFER$1, kWebSocket: kWebSocket$2, NOOP: NOOP$1 } = constants;
@@ -42560,10 +42769,10 @@ var extension$1 = { format: format$1, parse: parse$2 };
 
 const EventEmitter$1 = require$$0$c;
 const https = require$$8;
-const http$1 = require$$2$5;
-const net = require$$3$4;
+const http$1 = require$$3$4;
+const net = require$$3$5;
 const tls = require$$4$2;
-const { randomBytes, createHash: createHash$1 } = require$$1$6;
+const { randomBytes, createHash: createHash$1 } = require$$1$7;
 const { URL: URL$1 } = require$$4$1;
 
 const PerMessageDeflate$1 = permessageDeflate;
@@ -44170,8 +44379,8 @@ var subprotocol$1 = { parse };
 /* eslint no-unused-vars: ["error", { "varsIgnorePattern": "^Duplex$", "caughtErrors": "none" }] */
 
 const EventEmitter = require$$0$c;
-const http = require$$2$5;
-const { createHash } = require$$1$6;
+const http = require$$3$4;
+const { createHash } = require$$1$7;
 
 const extension = extension$1;
 const PerMessageDeflate = permessageDeflate;