@trops/dash-core 0.1.179 → 0.1.180

package/dist/electron/index.js

@@ -39234,6 +39234,28 @@ function extractComputedColors(computedStyles) {
   return results;
 }
 
+/**
+ * Extract colors from broad DOM color scan (frequency-based).
+ * @param {Array<{color: string, count: number}>} domColors - Sorted by frequency
+ * @returns {Array<{hex: string, source: string, confidence: number, count: number}>}
+ */
+function extractDomColors(domColors) {
+  if (!Array.isArray(domColors) || domColors.length === 0) return [];
+  const results = [];
+  for (const entry of domColors) {
+    if (!entry.color || !entry.count) continue;
+    const rgb = parseColor(entry.color);
+    if (!rgb) continue;
+    results.push({
+      hex: rgbToHex(rgb),
+      source: "dom",
+      confidence: 0.7,
+      count: entry.count,
+    });
+  }
+  return results;
+}
+
 // ─── Favicon extraction ──────────────────────────────────────────────────────
 
 /**
@@ -39462,7 +39484,7 @@ function mergeAndRank(allColors, maxColors = 6) {
     for (const cluster of clusters) {
       if (deltaE$1(cluster.lab, lab) < THRESHOLD) {
         // Merge into existing cluster — keep the highest-confidence color as representative
-        cluster.count++;
+        cluster.count += color.count || 1;
         cluster.sources.add(color.source);
         if (color.confidence > cluster.confidence) {
           cluster.hex = color.hex;
@@ -39481,7 +39503,7 @@ function mergeAndRank(allColors, maxColors = 6) {
         rgb,
         lab,
         confidence: color.confidence,
-        count: 1,
+        count: color.count || 1,
         sources: new Set([color.source]),
       });
     }
@@ -39563,6 +39585,7 @@ function mergeAndRank(allColors, maxColors = 6) {
  * @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 }
+ * @param {Array<{color: string, count: number}>} [params.domColors] - Frequency-sorted DOM colors from broad scan
  * @param {string} [params.baseUrl] - Page URL for resolving favicon paths (enables image extraction)
  * @returns {Promise<{ palette: Array, rawCount: number }>}
  */
@@ -39570,6 +39593,7 @@ async function extractColorsFromUrl({
   htmlContent,
   cssContent,
   computedStyles,
+  domColors,
   baseUrl,
 }) {
   console.log("[themeFromUrlController] Starting color extraction pipeline");
@@ -39594,6 +39618,11 @@ async function extractColorsFromUrl({
     `[themeFromUrlController] Computed styles: ${computedColors.length} colors`,
   );
 
+  const domColorResults = extractDomColors(domColors);
+  console.log(
+    `[themeFromUrlController] DOM scan: ${domColorResults.length} colors`,
+  );
+
   // Favicon extraction (async, requires baseUrl)
   let faviconColors = [];
   if (baseUrl) {
@@ -39613,6 +39642,7 @@ async function extractColorsFromUrl({
     ...metaColors,
     ...cssVarColors,
     ...computedColors,
+    ...domColorResults,
     ...faviconColors,
   ].filter((c) => {
     if (!c.hex) {
@@ -70426,30 +70456,54 @@ async function handleCreateThemeFromUrl$1({ url, name }) {
           const extracted = await scanWindow.webContents.executeJavaScript(`
             (function() {
               try {
-                const htmlContent = document.documentElement.outerHTML;
-                let cssContent = '';
+                var htmlContent = document.documentElement.outerHTML;
+                var cssContent = '';
                 try {
-                  for (const sheet of document.styleSheets) {
+                  for (var s = 0; s < document.styleSheets.length; s++) {
                     try {
-                      for (const rule of sheet.cssRules) {
-                        cssContent += rule.cssText + '\\n';
+                      var rules = document.styleSheets[s].cssRules;
+                      for (var r = 0; r < rules.length; r++) {
+                        cssContent += rules[r].cssText + '\\n';
                       }
-                    } catch (e) { /* cross-origin stylesheet */ }
+                    } catch (e) {}
                   }
                 } catch (e) {}
-                const selectors = ['body', 'header', 'nav', 'main', 'footer', 'a', 'button', 'h1', 'h2'];
-                const computedStyles = {};
-                for (const sel of selectors) {
-                  const el = document.querySelector(sel);
-                  if (!el) continue;
-                  const cs = window.getComputedStyle(el);
-                  computedStyles[sel] = {
-                    color: cs.color,
-                    backgroundColor: cs.backgroundColor,
-                    borderColor: cs.borderColor,
-                  };
+
+                var DEFAULT_COLORS = {
+                  'rgba(0, 0, 0, 0)': 1, 'transparent': 1,
+                  'rgb(0, 0, 0)': 1, 'rgb(255, 255, 255)': 1
+                };
+                var colorFreq = {};
+                var elements = document.body ? document.body.querySelectorAll('*') : [];
+                var limit = Math.min(elements.length, 500);
+                for (var i = 0; i < limit; i++) {
+                  var el = elements[i];
+                  if (el.offsetWidth === 0 && el.offsetHeight === 0) continue;
+                  var cs = window.getComputedStyle(el);
+                  var props = ['color', 'backgroundColor', 'borderColor'];
+                  for (var p = 0; p < props.length; p++) {
+                    var val = cs[props[p]];
+                    if (val && !DEFAULT_COLORS[val]) {
+                      colorFreq[val] = (colorFreq[val] || 0) + 1;
+                    }
+                  }
+                  if (el instanceof SVGElement) {
+                    var fill = cs.fill;
+                    var stroke = cs.stroke;
+                    if (fill && fill !== 'none' && !DEFAULT_COLORS[fill]) {
+                      colorFreq[fill] = (colorFreq[fill] || 0) + 1;
+                    }
+                    if (stroke && stroke !== 'none' && !DEFAULT_COLORS[stroke]) {
+                      colorFreq[stroke] = (colorFreq[stroke] || 0) + 1;
+                    }
+                  }
                 }
-                return { success: true, htmlContent, cssContent, computedStyles };
+                var domColors = Object.keys(colorFreq)
+                  .map(function(key) { return { color: key, count: colorFreq[key] }; })
+                  .sort(function(a, b) { return b.count - a.count; })
+                  .slice(0, 50);
+
+                return { success: true, htmlContent: htmlContent, cssContent: cssContent, domColors: domColors };
               } catch (e) {
                 return { success: false, error: { type: 'EXTRACTION_FAILED', message: e.message } };
               }
@@ -70465,7 +70519,7 @@ async function handleCreateThemeFromUrl$1({ url, name }) {
           return themeFromUrlController$1.extractColorsFromUrl({
             htmlContent: extracted.htmlContent,
             cssContent: extracted.cssContent,
-            computedStyles: extracted.computedStyles,
+            domColors: extracted.domColors,
             baseUrl: trimmedUrl,
           });
         } finally {