From d1e97eecc7ccbb5227186a5045853a12e4a5fa8c Mon Sep 17 00:00:00 2001 From: Chris Dumas Date: Thu, 22 Oct 2026 13:07:45 +0000 Subject: [PATCH] Port Pixaroma resolution editor interactions --- js/dumas_resolution.js | 1746 +++++++++++++++++++++++++++++++++++----- 1 file changed, 1563 insertions(+), 183 deletions(-) diff --git a/js/dumas_resolution.js b/js/dumas_resolution.js index 4598aba..c9f788a 100644 --- a/js/dumas_resolution.js +++ b/js/dumas_resolution.js @@ -1,209 +1,1589 @@ import { app } from "/scripts/app.js"; -const CLASS = "DumasResolution"; +// DUMAS-local compatibility helpers. The resolution editor is ported from +// Pixaroma's maintained implementation, while this repo keeps its own node +// namespace and avoids a runtime dependency on Pixaroma shared modules. +const BRAND = {}; +const pixAsset = () => ""; +const hideJsonWidget = (widgets, name) => { for (const w of widgets || []) if (w?.name === name) w.hidden = true; }; +const applyAdaptiveCanvasOnly = () => {}; +const installCanvasZoomPassthrough = () => {}; +const installNodeAccent = () => {}; +const registerNodeAccent = () => {}; +const isComfyTextShortcut = () => false; +const installLatentBatch = () => ({ mount: () => {} }); + +// Node dimensions are LOCKED — width and height. The original "make it +// resizable" attempt was a workaround for the default height being too small +// to show all 8 preset rows; once that's fixed, there's no real reason to +// resize, and a resizable node just produces an awkward dark empty band when +// dragged taller. Locking matches the canvas-side res-node pattern and is +// honest: the node draws exactly what fits its content. +// +// NODE_H is EXACT (Classic px): every height below is fixed in the CSS, none +// depends on a font, so no safety margin is needed. The old 5-px margin and the +// root's 8-px top / bottom padding showed as extra space under the output dots +// and below the list (the root is the same colour as the node body). +// chip grid (4 rows × CHIP_H 28 + 3 × 5 gap) ...... 127 +// ├─ row 1: 1:1 / 16:9 / 9:16 +// ├─ row 2: 2:1 / 3:2 / 2:3 +// ├─ row 3: 4:3 / 3:4 / 4:5 +// └─ row 4: Custom Ratio / Custom Resolution (half-width chips) +// gap between chips and list ..................... 8 +// size list ..................................... 226 +// ├─ borders (1 top + 1 bottom) ........ 2 +// └─ rows (8 × 28, border-box: each row's 1-px divider is inside it) 224 +// DOM widget `margin: 4` (top + bottom) ........... 8 +// ---- +// WIDGET_H ..................................... 369 +// chrome: 3 output rows (width, height, latent) .. 66 +// ---- +// NODE_H ....................................... 435 +// Add or remove an output and the chrome moves by 20 (one slot row). +const NODE_W = 240; +const CHIP_H = 28; +const WIDGET_H = 4 * CHIP_H + 3 * 5 + 8 + (8 * 28 + 2) + 8; // 369 +const NODE_H = WIDGET_H + 66; // 435 + +function injectCSS() { + if (document.getElementById("pixaroma-resolution-css")) return; + const css = ` + .pix-res-root { + width: 100%; + box-sizing: border-box; + /* No top / bottom padding: the root is the same colour as the node body, + so padding there only showed as extra space under the output dots and + below the list. The chips now start where Sizes Pixaroma's panel does. */ + padding: 0 8px; + background: #2a2a2a; + border-radius: 4px; + color: #ddd; + font-family: ui-sans-serif, system-ui, sans-serif; + font-size: 11px; + display: flex; + flex-direction: column; + gap: 8px; + } + /* 6-col grid lets us mix 1/3-width ratio chips (span 2) with 1/2-width + custom chips (span 3) on the same row. */ + .pix-res-chips { + display: grid; + grid-template-columns: repeat(6, 1fr); + gap: 5px; + } + .pix-res-chip { + grid-column: span 2; /* default = 1/3 width (3 chips per row) */ + background: #1d1d1d; + border: 1px solid #444; + border-radius: 4px; + /* A FIXED height, not padding around the text: the text height differs + per font and renderer (measured 28 in Classic, 27.3 in Nodes 2.0), and + the node height (WIDGET_H) is computed from this number. */ + box-sizing: border-box; + height: ${CHIP_H}px; + padding: 0 4px; + font-size: 10px; + color: #ccc; + cursor: pointer; + user-select: none; + transition: background 0.08s, border-color 0.08s; + /* flex layout so a small visual AR rectangle can sit next to the label + on ratio chips. Custom Ratio / Custom Resolution chips skip the shape + and just render the label, which centers naturally via justify-content. */ + display: flex; + align-items: center; + justify-content: center; + gap: 5px; + } + .pix-res-chip:hover { border-color: #666; } + .pix-res-chip.active { + background: var(--pix-acc,#f66744); + color: #fff; + border-color: var(--pix-acc,#f66744); + } + .pix-res-chip.span-half { grid-column: span 3; } /* 1/2 width — used by Custom Ratio + Custom Resolution */ + /* Tiny ratio-shape preview rendered inside each ratio chip. Width and + height are set inline by JS to match the actual W:H, so the user can + recognize the shape of every preset at a glance, not just the picked one. + Bounding box (14 x 11) is tuned for the ~66 px ratio chip width — leaves + enough room next to the label "16:9" without clipping at NODE_W = 240. */ + .pix-res-chip-shape { + display: inline-block; + background: rgba(180, 180, 180, 0.25); + border: 1px solid #888; + border-radius: 1px; + box-sizing: border-box; + flex-shrink: 0; + } + .pix-res-chip.active .pix-res-chip-shape { + background: rgba(255, 255, 255, 0.4); + border-color: rgba(255, 255, 255, 0.85); + } + .pix-res-list { + background: #1d1d1d; + border: 1px solid #444; + border-radius: 4px; + /* x clipped (active-row orange tint stays inside rounded border); + y scrolls if at large browser zoom the rows still wouldn't fit + (node height is locked, so this is a defensive fallback only). */ + overflow-x: hidden; + overflow-y: auto; + /* Preset list takes its natural size (8 fixed-height rows + borders); + since the widget is sized to exactly accommodate that, no extra space + appears in either direction. It never shrinks: the widget has no + safety margin any more, and a sub-pixel shortfall would otherwise + squeeze it into a scrollbar. Custom panel overrides to flex:1 so its + preview rect can absorb the panel's vertical space. */ + flex: 0 0 auto; + display: flex; + flex-direction: column; + } + .pix-res-list.pix-res-custom { + flex: 1; + min-height: 160px; + } + /* Slim, theme-matched scrollbar so the list doesn't get a fat default bar. */ + .pix-res-list::-webkit-scrollbar { width: 6px; } + .pix-res-list::-webkit-scrollbar-thumb { background: #555; border-radius: 3px; } + .pix-res-list::-webkit-scrollbar-track { background: transparent; } + /* Subtle focus indicator: brand-tinted border (no outline ring overflow). */ + .pix-res-list:focus { outline: none; border-color: var(--pix-acc,#f66744); } + .pix-res-row { + /* Fixed row height — must NOT grow with the node, otherwise resizing + taller bloats every row to a giant cell. flex-shrink: 0 + the parent + list's overflow-y: auto means rows stay readable and the list scrolls + instead when the widget is too short to fit all 8. */ + flex: 0 0 28px; + box-sizing: border-box; + padding: 4px 8px; + border-bottom: 1px solid #2f2f2f; + font-size: 11px; + text-align: center; + cursor: pointer; + display: flex; + align-items: center; + justify-content: center; + font-family: inherit; + color: #ccc; + } + .pix-res-row:last-child { border-bottom: none; } + .pix-res-row.active { + background: color-mix(in srgb, var(--pix-acc,#f66744) 15%, transparent); + color: var(--pix-acc,#f66744); + font-weight: 600; + } + .pix-res-row.empty { + cursor: default; + color: #2a2a2a; + } + .pix-res-custom { + padding: 12px 10px; + display: flex; + flex-direction: column; + gap: 10px; + } + .pix-res-custom-row { + display: grid; + grid-template-columns: 1fr auto 1fr; + gap: 6px; + align-items: end; /* push the swap icon down so it sits next to the input boxes, not the labels */ + } + .pix-res-custom-field { display: flex; flex-direction: column; gap: 3px; } + .pix-res-custom-field label { + font-size: 9px; + color: #888; + text-transform: uppercase; + letter-spacing: 0.5px; + text-align: center; + } + .pix-res-custom-field input { + background: #2a2a2a; + border: 1px solid #444; + border-radius: 4px; + padding: 2px 6px; + color: var(--pix-acc,#f66744); + font-size: 11px; + font-weight: 600; + text-align: center; + font-family: inherit; + box-sizing: border-box; + width: 100%; + } + .pix-res-custom-field input:focus { + outline: none; + border-color: var(--pix-acc,#f66744); + } + /* Square icon button placed BETWEEN the W and H inputs (Figma/Photoshop pattern). + Uses CSS mask-image so the SVG inherits color via the button's color property + — same technique Note Pixaroma uses for toolbar mask-icons. */ + .pix-res-swap { + width: 26px; + height: 22px; + background: #2a2a2a; + border: 1px solid #444; + border-radius: 4px; + color: #aaa; + cursor: pointer; + padding: 0; + position: relative; + display: inline-block; + } + .pix-res-swap::before { + content: ""; + position: absolute; + inset: 0; + background-color: currentColor; + -webkit-mask: url("${pixAsset("icons/ui/swap.svg")}") center / 12px 12px no-repeat; + mask: url("${pixAsset("icons/ui/swap.svg")}") center / 12px 12px no-repeat; + pointer-events: none; + } + .pix-res-swap:hover { color: var(--pix-acc,#f66744); border-color: var(--pix-acc,#f66744); } + .pix-res-readout { + display: flex; + align-items: center; + /* snap-group pinned left, ratio/MP pinned right — text length changes + on the right side then can't push the snap chips around. */ + justify-content: space-between; + gap: 6px; + padding: 0 2px; + font-size: 10px; + color: #777; + } + .pix-res-readout .accent { color: var(--pix-acc,#f66744); } + /* Aspect-ratio visual preview — fills the remaining custom-panel space. + The inner rect is scaled to the chosen W:H ratio so the user sees the + shape they'll get at a glance. Label below shows the exact W × H. */ + .pix-res-preview { + flex: 1; + display: flex; + flex-direction: column; + align-items: center; + justify-content: center; + gap: 5px; + padding-top: 4px; + min-height: 0; + } + .pix-res-preview-rect { + background: color-mix(in srgb, var(--pix-acc,#f66744) 18%, transparent); + border: 1px solid var(--pix-acc,#f66744); + border-radius: 2px; + /* Sized by sizePreviewRect: aspect-ratio + max-width + a flex basis it + may shrink from. min-height 0 lets it shrink below that basis (a flex + item's automatic minimum would block it); the width follows. */ + min-height: 0; + transition: flex-basis 0.15s ease, max-width 0.15s ease; + } + .pix-res-preview-label { + font-family: inherit; + font-size: 10px; + color: #999; + } + .pix-res-preview-label .accent { color: var(--pix-acc,#f66744); } + /* Snap-step picker — magnet label + 4 small chip buttons (8/16/32/64). */ + .pix-res-snap-group { + display: inline-flex; + align-items: center; + gap: 4px; + } + .pix-res-snap-icon { + display: inline-block; + width: 11px; + height: 11px; + background-color: #888; + -webkit-mask: url("${pixAsset("icons/ui/magnet.svg")}") center / 11px 11px no-repeat; + mask: url("${pixAsset("icons/ui/magnet.svg")}") center / 11px 11px no-repeat; + pointer-events: none; + } + .pix-res-snap-btns { + display: inline-flex; + gap: 2px; + } + .pix-res-snap-btn { + background: #1d1d1d; + border: 1px solid #444; + border-radius: 3px; + color: #aaa; + font-size: 9px; + padding: 2px 5px; + min-width: 18px; + cursor: pointer; + font-family: inherit; + line-height: 1; + } + .pix-res-snap-btn:hover { color: #ddd; border-color: #666; } + .pix-res-snap-btn.active { + background: var(--pix-acc,#f66744); + color: #fff; + border-color: var(--pix-acc,#f66744); + } + + /* Custom Ratio panel — Photoshop "lock-aspect" pattern. Sections top to + bottom: (1) ratio inputs (W:H typed once), (2) quick-pick width chips + (S/M/L/XL), (3) W and H math-aware inputs side-by-side (edit either, + counterpart auto-computes from ratio), (4) aspect preview, (5) footer + (snap picker + ratio·MP). Reuses .pix-res-custom-* layout for fields — + the wrap element gets both classes so it inherits the custom-mode shell + (padding, gap, flex column) without needing a duplicate rule here. */ + .pix-res-ratio-input-row { + display: flex; + align-items: center; + justify-content: center; + gap: 6px; + } + .pix-res-ratio-input-row .pix-res-ratio-label { + font-size: 9px; + color: #888; + text-transform: uppercase; + letter-spacing: 0.5px; + } + .pix-res-ratio-input-row input { + width: 42px; + background: #2a2a2a; + border: 1px solid #444; + border-radius: 3px; + padding: 2px 6px; + color: var(--pix-acc,#f66744); + font-size: 11px; + font-weight: 600; + text-align: center; + font-family: inherit; + box-sizing: border-box; + } + .pix-res-ratio-input-row input:focus { outline: none; border-color: var(--pix-acc,#f66744); } + .pix-res-ratio-swap { + width: 22px; + height: 22px; + background: #2a2a2a; + border: 1px solid #444; + border-radius: 3px; + color: #aaa; + cursor: pointer; + position: relative; + padding: 0; + display: inline-block; + } + .pix-res-ratio-swap::before { + content: ""; + position: absolute; + inset: 0; + background-color: currentColor; + -webkit-mask: url("${pixAsset("icons/ui/swap.svg")}") center / 12px 12px no-repeat; + mask: url("${pixAsset("icons/ui/swap.svg")}") center / 12px 12px no-repeat; + pointer-events: none; + } + .pix-res-ratio-swap:hover { color: var(--pix-acc,#f66744); border-color: var(--pix-acc,#f66744); } + /* Quick-pick width chips — 4 evenly-spaced buttons under the ratio row. */ + .pix-res-quickpicks { + display: grid; + grid-template-columns: repeat(4, 1fr); + gap: 4px; + } + .pix-res-quickpick { + background: #1d1d1d; + border: 1px solid #444; + border-radius: 3px; + color: #ccc; + padding: 5px 0; + font-size: 10px; + font-family: inherit; + cursor: pointer; + transition: background 0.08s, border-color 0.08s; + } + .pix-res-quickpick:hover { border-color: #666; color: #fff; } + .pix-res-quickpick.active { + background: var(--pix-acc,#f66744); + color: #fff; + border-color: var(--pix-acc,#f66744); + } + `; + const style = document.createElement("style"); + style.id = "pixaroma-resolution-css"; + style.textContent = css; + document.head.appendChild(style); +} +injectCSS(); + +// Python uses `hidden` inputs (no widget, no slot dot). State lives on +// node.properties[STATE_PROP] which LiteGraph serializes natively in the +// workflow JSON. The JS-side hook (app.graphToPrompt) injects the state +// into the API prompt as the `ResolutionState` hidden input at run time. const STATE_PROP = "dumasResolutionState"; -const HIDDEN = "ResolutionState"; -const DEFAULT = { - mode: "preset", ratio: "1:1", w: 1024, h: 1024, - custom_w: 1024, custom_h: 1024, custom_ratio_w: 4, custom_ratio_h: 3, - snap: 16, batch: 1, +const HIDDEN_INPUT_NAME = "ResolutionState"; // matches Python INPUT_TYPES key + +const DEFAULT_STATE = { + mode: "preset", // "preset" | "custom" | "custom_ratio" + ratio: "1:1", + w: 1024, + h: 1024, + custom_w: 1024, + custom_h: 1024, + // Custom Ratio mode — user types a ratio (e.g. 4:3) and picks from + // generated sizes. Defaults to a popular non-preset ratio so the panel + // shows useful sizes the moment the user clicks the chip. + custom_ratio_w: 4, + custom_ratio_h: 3, + snap: 16, // px step for Custom mode commit + arrow-key nudge (8 / 16 / 32 / 64) }; + +const SNAP_OPTIONS = [8, 16, 32, 64]; + +function readState(node) { + // Primary: node.properties (current architecture). + const v = node.properties?.[STATE_PROP]; + if (typeof v === "string" && v) { + try { return { ...DEFAULT_STATE, ...JSON.parse(v) }; } + catch { /* fall through to migration */ } + } + // Migration: workflows saved with the old widget-based architecture have + // their state in node.widgets_values[0] as a JSON string. Detect, migrate, + // and persist into node.properties so the next save is in the new format. + const wv = node.widgets_values; + if (Array.isArray(wv)) { + for (const x of wv) { + if (typeof x === "string" && x.includes('"mode"')) { + try { + const parsed = JSON.parse(x); + if (parsed && typeof parsed === "object" && "ratio" in parsed) { + writeState(node, { ...DEFAULT_STATE, ...parsed }); + return { ...DEFAULT_STATE, ...parsed }; + } + } catch { /* not our JSON, keep looking */ } + } + } + } + return { ...DEFAULT_STATE }; +} + +function writeState(node, state) { + if (!node.properties) node.properties = {}; + node.properties[STATE_PROP] = JSON.stringify(state); +} + +// Chip layout — order matches design spec +const CHIPS = [ + { id: "1:1", label: "1:1" }, + { id: "16:9", label: "16:9" }, + { id: "9:16", label: "9:16" }, + { id: "2:1", label: "2:1" }, + { id: "3:2", label: "3:2" }, + { id: "2:3", label: "2:3" }, + { id: "4:3", label: "4:3" }, + { id: "3:4", label: "3:4" }, + { id: "4:5", label: "4:5" }, + { id: "custom_ratio", label: "Custom Ratio", spanHalf: true }, + { id: "custom", label: "Custom Resolution", spanHalf: true }, +]; + +// Sizes per ratio — 8 entries each. The first two of 16:9/9:16/2:1 are the +// de facto AI-video standards (Wan 2.2, CogVideoX, AnimateDiff) and aren't +// mathematically exact for the ratio (e.g. 832×480 ≈ 1.733 vs 16:9 = 1.778). +// 4:3, 3:4, 4:5 use strict ratios with /16-aligned dimensions (SDXL-friendly). +// 4:5 includes 1152×1440 — the AI-friendly equivalent of Instagram portrait +// (native 1080×1350), a frequent ask for social-media workflows. const SIZES = { - "1:1": [[512,512],[768,768],[1024,1024],[1280,1280],[1328,1328],[1408,1408],[1536,1536],[2048,2048]], - "16:9": [[832,480],[1280,720],[1344,768],[1536,864],[1600,896],[1664,928],[1792,1008],[1920,1088]], - "9:16": [[480,832],[720,1280],[768,1344],[864,1536],[896,1600],[928,1664],[1008,1792],[1088,1920]], - "2:1": [[512,256],[1024,512],[1280,640],[1536,768],[1600,800],[1792,896],[1920,960],[2048,1024]], - "3:2": [[768,512],[1024,680],[1152,768],[1344,896],[1536,1024],[1632,1088],[1728,1152],[1920,1280]], - "2:3": [[512,768],[680,1024],[768,1152],[896,1344],[1024,1536],[1088,1632],[1152,1728],[1280,1920]], - "4:3": [[512,384],[640,480],[768,576],[1024,768],[1280,960],[1408,1056],[1600,1200],[1920,1440]], - "3:4": [[384,512],[480,640],[576,768],[768,1024],[960,1280],[1056,1408],[1200,1600],[1440,1920]], - "4:5": [[512,640],[640,800],[768,960],[832,1040],[1024,1280],[1152,1440],[1280,1600],[1536,1920]], + "1:1": [[512,512],[768,768],[1024,1024],[1280,1280],[1328,1328],[1408,1408],[1536,1536],[2048,2048]], + "16:9": [[832,480],[1280,720],[1344,768],[1536,864],[1600,896],[1664,928],[1792,1008],[1920,1088]], + "9:16": [[480,832],[720,1280],[768,1344],[864,1536],[896,1600],[928,1664],[1008,1792],[1088,1920]], + "2:1": [[512,256],[1024,512],[1280,640],[1536,768],[1600,800],[1792,896],[1920,960],[2048,1024]], + "3:2": [[768,512],[1024,680],[1152,768],[1344,896],[1536,1024],[1632,1088],[1728,1152],[1920,1280]], + "2:3": [[512,768],[680,1024],[768,1152],[896,1344],[1024,1536],[1088,1632],[1152,1728],[1280,1920]], + "4:3": [[512,384],[640,480],[768,576],[1024,768],[1280,960],[1408,1056],[1600,1200],[1920,1440]], + "3:4": [[384,512],[480,640],[576,768],[768,1024],[960,1280],[1056,1408],[1200,1600],[1440,1920]], + "4:5": [[512,640],[640,800],[768,960],[832,1040],[1024,1280],[1152,1440],[1280,1600],[1536,1920]], }; -const DEFAULT_SIZE = {"1:1":[1024,1024],"16:9":[1280,720],"9:16":[720,1280],"2:1":[1280,640],"3:2":[1152,768],"2:3":[768,1152],"4:3":[1024,768],"3:4":[768,1024],"4:5":[1024,1280]}; -const RATIOS = Object.keys(SIZES); -const clamp = (n) => Math.max(64, Math.min(4096, Number(n) || 1024)); -const snap = (n, step) => Math.round(n / step) * step; -const gcd = (a, b) => { while (b) [a, b] = [b, a % b]; return a || 1; }; -function read(node) { - const raw = node.properties?.[STATE_PROP]; - if (raw) { try { return {...DEFAULT, ...JSON.parse(raw)}; } catch {} } - return {...DEFAULT}; +// Default size auto-selected when the user clicks a ratio chip. Picked to be +// the most common/useful starting point per ratio — not the smallest entry. +const DEFAULT_PER_RATIO = { + "1:1": [1024, 1024], + "16:9": [1280, 720], + "9:16": [720, 1280], + "2:1": [1280, 640], + "3:2": [1152, 768], + "2:3": [768, 1152], + "4:3": [1024, 768], + "3:4": [768, 1024], + "4:5": [1024, 1280], // SDXL-friendly portrait + Instagram-portrait equivalent +}; + +function gcd(a, b) { + a = Math.abs(a); b = Math.abs(b); + while (b) { const t = b; b = a % b; a = t; } + return a || 1; } -function write(node, value) { - node.properties ||= {}; - node.properties[STATE_PROP] = JSON.stringify({...DEFAULT, ...value}); - node.setDirtyCanvas?.(true, true); + +function ratioLabel(w, h) { + const g = gcd(w, h); + const rw = w / g, rh = h / g; + const known = ["1:1","16:9","9:16","2:1","1:2","3:2","2:3","4:3","3:4","4:5","5:4"]; + const simple = `${rw}:${rh}`; + if (known.includes(simple)) return simple; + const r = w / h; + return r >= 1 ? `~${r.toFixed(2)}:1` : `~1:${(1 / r).toFixed(2)}`; } -function ratioPair(raw, rw, rh, step) { - let w = snap(clamp(raw), step); - let h = snap(w * rh / rw, step); - if (h > 4096) { h = 4096 - (4096 % step); w = snap(h * rw / rh, step); } - if (h < 64) { h = step; w = snap(h * rw / rh, step); } - return [clamp(w), clamp(h)]; + +function megapixels(w, h) { + return ((w * h) / 1_000_000).toFixed(2); } -function stateText(node) { return JSON.stringify(read(node)); } -function collectNodes(graph, output = []) { - if (!graph) return output; - for (const node of graph._nodes || graph.nodes || []) { - if (node) output.push(node); - const inner = node?.subgraph || node?.graph || node?._graph; - if (inner && inner !== graph) collectNodes(inner, output); + +function snapTo(n, step) { return Math.round(n / step) * step; } +// The custom modes' size range. 64 is the node's real floor (Python clamps to +// 64..16384); it was 256, which broke Custom Ratio's small sizes (#5). 4096 stays +// as a typo guard. Both are multiples of every snap step (8 / 16 / 32 / 64). +const MIN_DIM = 64; +const MAX_DIM = 4096; +function clampDim(n) { return Math.max(MIN_DIM, Math.min(MAX_DIM, n)); } + +// Custom Ratio: the DRIVING side (the one typed or clicked) snapped, the other +// side from the ratio, and when either leaves MIN_DIM..MAX_DIM the PAIR is +// scaled to fit, so the typed ratio always holds. Clamping one side alone gave +// 512 x 256 for 21:9 + the 512 button and 4096 x 4096 for 16:9 + H 4096, both +// under a "21:9" / "16:9" label (resolution.md #5). In range it is exactly the +// old maths (snap the driver, derive and snap the other side). +function ratioPair(raw, fromW, rW, rH, step) { + const other = (v) => (fromW ? (v * rH) / rW : (v * rW) / rH); + const make = (v) => { const a = snapTo(v, step); const b = snapTo(other(a), step); return fromW ? [a, b] : [b, a]; }; + let [w, h] = make(raw); + if (Math.max(w, h) > MAX_DIM) [w, h] = make((raw * MAX_DIM) / Math.max(raw, other(raw))); + else if (Math.min(w, h) < MIN_DIM) [w, h] = make((raw * MIN_DIM) / Math.min(raw, other(raw))); + // a ratio beyond 64:1 cannot fit both limits: the clamp is the last word + return [clampDim(w), clampDim(h)]; +} + +// Return v if it's a finite positive integer, otherwise fallback. Used for +// `custom_ratio_w` / `custom_ratio_h` reads — a corrupted/malicious workflow +// JSON could supply a string ("0", ""), 0, or a negative number, all +// of which slip past `?? 4` (nullish only). Coercing here closes both the +// XSS vector (string into innerHTML) and the divide-by-zero / negative path. +function safePositiveInt(v, fallback) { + const n = +v; + return Number.isInteger(n) && n > 0 ? n : fallback; +} + +// Quick-pick width values for Custom Ratio mode — common AI-friendly widths. +// 512 (low-VRAM/draft), 768 (SD1.5 native), 1024 (SDXL native), 1536 (high-res). +// Click sets W to this value; H auto-computes from the typed ratio + snap. +const QUICK_PICK_WIDTHS = [512, 768, 1024, 1536]; + +// Tiny safe math evaluator for the W/H inputs — supports `+ - * / ( )` and +// decimals only. Hand-rolled recursive descent. NEVER use dynamic evaluation (JS eval or the Function constructor) +// here: even though the field is per-node, accepting arbitrary JS would let a +// shared workflow execute code on import. Returns NaN for any invalid input. +// Examples: "1024", "1024+128", "512*2", "(1024+128)/2", "1024 + 128". +function safeMathEval(str) { + if (typeof str !== "string") return NaN; + const s = str.trim(); + if (!s) return NaN; + // Whitelist all chars up front so the parser never sees a stray identifier. + if (!/^[0-9+\-*/().\s]+$/.test(s)) return NaN; + // Hard length cap — defends against pathological inputs reaching the parser. + if (s.length > 256) return NaN; + + let pos = 0; + // Recursion depth cap — prevents stack overflow from deeply-nested parens + // like "((((...1...))))". Threshold 64 is well above any realistic + // expression and safely below browser stack limits. + const MAX_DEPTH = 64; + let depth = 0; + // Any whitespace the whitelist lets in (\s): a pasted no-break space or a + // tab used to stop the parse, and the field silently kept its old value. + const skipWs = () => { while (pos < s.length && /\s/.test(s[pos])) pos++; }; + const eat = (ch) => { skipWs(); if (s[pos] === ch) { pos++; return true; } return false; }; + + function parseExpr() { + let v = parseTerm(); + for (;;) { + skipWs(); + if (eat("+")) v += parseTerm(); + else if (eat("-")) v -= parseTerm(); + else break; } - return output; -} -function injectState(result, nodes) { - for (const id in result?.output || {}) { - const entry = result.output[id]; - if (entry?.class_type !== CLASS) continue; - const node = nodes.find((n) => String(n.id) === String(id) || String(n.id) === String(id).split(":").pop()); - entry.inputs ||= {}; - entry.inputs[HIDDEN] = stateText(node || {properties: {}}); + return v; + } + function parseTerm() { + let v = parseFactor(); + for (;;) { + skipWs(); + if (eat("*")) v *= parseFactor(); + else if (eat("/")) { + const d = parseFactor(); + if (d === 0) return NaN; + v /= d; + } else break; } + return v; + } + function parseFactor() { + if (++depth > MAX_DEPTH) return NaN; + skipWs(); + if (eat("+")) { const r = parseFactor(); depth--; return r; } + if (eat("-")) { const r = -parseFactor(); depth--; return r; } + if (eat("(")) { + const v = parseExpr(); + if (!eat(")")) { depth--; return NaN; } + depth--; + return v; + } + let num = ""; + while (pos < s.length && /[0-9.]/.test(s[pos])) num += s[pos++]; + depth--; + if (!num) return NaN; + // Reject malformed numbers like "1.2.3" — parseFloat would silently + // truncate to 1.2 and the trailing-garbage check below wouldn't catch it. + if ((num.match(/\./g) || []).length > 1) return NaN; + return parseFloat(num); + } + + const v = parseExpr(); + skipWs(); + if (pos !== s.length) return NaN; // trailing garbage + return v; } -const style = document.createElement("style"); -style.textContent = ` -.dumas-res { box-sizing:border-box; width:100%; padding:6px; background:#292929; color:#ddd; font:11px system-ui; } -.dumas-res .section { margin-top:6px; padding-top:5px; border-top:1px solid #444; } -.dumas-res .section:first-child { margin-top:0; padding-top:0; border-top:0; } -.dumas-res .section-title { margin-bottom:4px; color:#aaa; font-size:10px; font-weight:600; letter-spacing:.02em; text-transform:uppercase; } -.dumas-res .chips { display:grid; grid-template-columns:repeat(3,minmax(0,1fr)); gap:3px; } -.dumas-res button { min-height:25px; padding:2px 4px; border:1px solid #555; border-radius:4px; background:#1d1d1d; color:#ddd; cursor:pointer; font:inherit; } -.dumas-res button.active { background:#b9573d; color:white; border-color:#ef8c6d; } -.dumas-res .ratio-button { display:flex; align-items:center; justify-content:center; gap:5px; } -.dumas-res .ratio-icon { display:inline-block; width:10px; height:10px; border:1px solid currentColor; border-radius:1px; opacity:.9; flex:0 0 auto; } -.dumas-res .ratio-icon.tall { height:12px; width:8px; } -.dumas-res .ratio-icon.wide { height:8px; width:13px; } -.dumas-res .sizes { display:grid; grid-template-columns:repeat(2,minmax(0,1fr)); gap:3px; max-height:154px; overflow:auto; } -.dumas-res .size { min-height:31px; text-align:left; font-family:ui-monospace,monospace; line-height:1.15; } -.dumas-res .size small { display:block; color:#999; font-size:9px; } -.dumas-res .batch { display:grid; grid-template-columns:26px 1fr 26px; gap:3px; align-items:center; } -.dumas-res .batch button { min-height:24px; font-size:15px; line-height:1; } -.dumas-res .batch input { text-align:center; } -.dumas-res .custom { display:grid; grid-template-columns:1fr 1fr; gap:4px; margin-top:6px; } -.dumas-res .custom-row { display:grid; grid-template-columns:1fr 28px 1fr; gap:4px; grid-column:1/-1; } -.dumas-res .custom-row button { min-height:28px; } -.dumas-res .custom-row input { min-width:0; } -.dumas-res .target-row { display:grid; grid-template-columns:repeat(4,1fr); gap:3px; grid-column:1/-1; } -.dumas-res .target-row button { min-height:25px; } -.dumas-res .dimension-row { display:grid; grid-template-columns:1fr 1fr; gap:4px; grid-column:1/-1; } -.dumas-res .dimension-row input { color:#9dd8a5; text-align:center; } -.dumas-res .preview { grid-column:1/-1; display:flex; justify-content:center; align-items:center; min-height:38px; margin-top:2px; } -.dumas-res .preview-shape { border:1px solid #8cc63f; background:#273b1c; max-width:100%; max-height:42px; } -.dumas-res input { width:100%; box-sizing:border-box; background:#181818; color:#eee; border:1px solid #555; border-radius:3px; padding:4px; } -.dumas-res .label { grid-column:1/-1; color:#aaa; } -.dumas-res .meta { margin-top:6px; padding-top:5px; border-top:1px solid #444; color:#9dd8a5; font-family:ui-monospace,monospace; } -`; -document.head.appendChild(style); +// Parse a chip id like "16:9" into [16, 9]. Returns null for "custom" / +// "custom_ratio" so the shape-render path skips them. +function parseRatioId(id) { + const m = /^(\d+):(\d+)$/.exec(id); + if (!m) return null; + return [parseInt(m[1], 10), parseInt(m[2], 10)]; +} -function render(node, root) { - const s = read(node), ratio = s.ratio || "1:1"; - root.replaceChildren(); - const ratioSection = document.createElement("div"); ratioSection.className = "section"; - const ratioTitle = document.createElement("div"); ratioTitle.className = "section-title"; ratioTitle.textContent = "Aspect ratio"; - ratioSection.append(ratioTitle); - const chips = document.createElement("div"); chips.className = "chips"; - [...RATIOS, "custom_ratio", "custom"].forEach((id) => { - const button = document.createElement("button"); - button.className = `ratio-button ${(s.mode === "preset" && id === ratio) || (s.mode === id) ? "active" : ""}`; - if (RATIOS.includes(id)) { - const icon = document.createElement("span"); icon.className = "ratio-icon"; - const [rw, rh] = id.split(":").map(Number); - if (rw / rh > 1.25) icon.classList.add("wide"); - else if (rw / rh < 0.8) icon.classList.add("tall"); - button.append(icon, document.createTextNode(id)); - } else button.textContent = id === "custom_ratio" ? "Custom Ratio" : "Custom Resolution"; - button.dataset.id = id; chips.append(button); +// Scale a W:H pair to fit inside maxW × maxH, preserving aspect. Returns +// rounded integer px so the rendered rectangle has crisp 1 px borders. +function fitRectToBox(rw, rh, maxW, maxH) { + const aspect = rw / rh; + let w, h; + if (aspect >= maxW / maxH) { w = maxW; h = maxW / aspect; } + else { h = maxH; w = maxH * aspect; } + return { w: Math.max(1, Math.round(w)), h: Math.max(1, Math.round(h)) }; +} + +// Size the custom panels' aspect preview so it keeps its SHAPE when the panel +// is short. Its height is a flex basis it may shrink from and its width follows +// through aspect-ratio. A fixed width + height let the preview's flex column +// shrink only the height: in Classic (fixed node height) the Custom Ratio panel +// gets 226 px of the ~245 it wants, and a 4:3 was drawn 80 x 38 (resolution.md #2). +function sizePreviewRect(el, pw, ph) { + el.style.aspectRatio = `${pw} / ${ph}`; + el.style.maxWidth = `${pw}px`; + el.style.flex = `0 1 ${ph}px`; +} + +// The "W × H" line under the custom panels' preview, built from TEXT nodes. +// w / h come from the saved state, which a shared workflow controls: written +// into innerHTML, a w of "" ran as soon as the workflow opened +// (resolution.md #3). textContent can never be markup. +function setSizeLabel(el, w, h) { + const part = (v) => { const s = document.createElement("span"); s.className = "accent"; s.textContent = String(v); return s; }; + el.replaceChildren(part(w), " × ", part(h)); +} + +// Ctrl/Cmd+S (save) and Ctrl/Cmd+Enter (run) are ComfyUI's own keys, and its +// keybindings listen on window. Our fields stop every keydown so a typed letter +// can never fire a canvas shortcut, which also swallowed these two (Ctrl+S then +// opened the browser's "Save page as", Ctrl+Enter ran nothing). Commit the field +// FIRST (they commit on blur, so the save / run sees the typed size), then let +// the key go on. Ctrl+Arrows stay ours: they step the number (resolution.md #4). +function passComfyShortcut(e, inp) { + if (!isComfyTextShortcut(e) || e.key === "ArrowUp" || e.key === "ArrowDown") return false; + inp.blur(); + return true; +} + +// Bounding box for the in-chip ratio rectangle. 14 × 11 fits comfortably next +// to the longest label ("16:9", ~24 px) inside the ~66 px ratio chip. +const CHIP_SHAPE_MAX_W = 14; +const CHIP_SHAPE_MAX_H = 11; + +function renderChipGrid(state) { + const wrap = document.createElement("div"); + wrap.className = "pix-res-chips"; + for (const c of CHIPS) { + const el = document.createElement("div"); + el.className = "pix-res-chip" + (c.spanHalf ? " span-half" : ""); + el.dataset.chipId = c.id; + const isActive = + (c.id === "custom" && state.mode === "custom") || + (c.id === "custom_ratio" && state.mode === "custom_ratio") || + (c.id !== "custom" && c.id !== "custom_ratio" && + state.mode === "preset" && state.ratio === c.id); + if (isActive) el.classList.add("active"); + + // Visual AR rectangle for ratio chips only; custom chips stay text-only + // because they're half-width (more horizontal space for the longer label) + // and don't have a fixed shape to preview here. + const ratio = parseRatioId(c.id); + if (ratio) { + const shape = document.createElement("span"); + shape.className = "pix-res-chip-shape"; + const { w, h } = fitRectToBox(ratio[0], ratio[1], CHIP_SHAPE_MAX_W, CHIP_SHAPE_MAX_H); + shape.style.width = `${w}px`; + shape.style.height = `${h}px`; + el.appendChild(shape); + } + + const labelEl = document.createElement("span"); + labelEl.textContent = c.label; + el.appendChild(labelEl); + + wrap.appendChild(el); + } + return wrap; +} + +function renderSizeList(state) { + const wrap = document.createElement("div"); + wrap.className = "pix-res-list"; + // Make the list focusable so ArrowUp/Down/Home/End change the active row. + // Custom mode renders its own .pix-res-list (with .pix-res-custom) and + // doesn't need this — its W/H inputs own keyboard input. + wrap.tabIndex = 0; + if (state.mode !== "preset") return wrap; // Custom mode handled in Task 5 + const sizes = SIZES[state.ratio] || []; + // Render 8 rows; pad with .empty rows if the ratio has fewer than 8 + for (let i = 0; i < 8; i++) { + const row = document.createElement("div"); + row.className = "pix-res-row"; + if (i >= sizes.length) { + row.classList.add("empty"); + row.textContent = ""; + wrap.appendChild(row); + continue; + } + const [w, h] = sizes[i]; + row.textContent = `${w} × ${h}`; + row.dataset.w = String(w); + row.dataset.h = String(h); + if (state.w === w && state.h === h) row.classList.add("active"); + wrap.appendChild(row); + } + return wrap; +} + +function renderCustomPanel(node, state) { + const wrap = document.createElement("div"); + wrap.className = "pix-res-list pix-res-custom"; + + const row = document.createElement("div"); + row.className = "pix-res-custom-row"; + + // Inputs are `type="text"` (not `number`) so users can type math expressions + // like `1024+128` or `512*2`. We evaluate via safeMathEval on commit and on + // ArrowUp/Down (custom snap-stepping). `inputmode="decimal"` keeps mobile + // keypads numeric; the visible spinner buttons are gone but Up/Down arrows + // step by snap (replacing the native HTML5 number-input stepper). + const wField = document.createElement("div"); + wField.className = "pix-res-custom-field"; + const wLabel = document.createElement("label"); + wLabel.textContent = "Width"; + const wInput = document.createElement("input"); + wInput.type = "text"; + wInput.inputMode = "decimal"; + wInput.spellcheck = false; + wInput.autocomplete = "off"; + wInput.title = "Math allowed: 1024+128, 512*2, (1024+128)/2"; + wInput.value = String(state.w); + + const hField = document.createElement("div"); + hField.className = "pix-res-custom-field"; + const hLabel = document.createElement("label"); + hLabel.textContent = "Height"; + const hInput = document.createElement("input"); + hInput.type = "text"; + hInput.inputMode = "decimal"; + hInput.spellcheck = false; + hInput.autocomplete = "off"; + hInput.title = "Math allowed: 1024+128, 512*2, (1024+128)/2"; + hInput.value = String(state.h); + + wField.append(wLabel, wInput); + hField.append(hLabel, hInput); + + const swap = document.createElement("button"); + swap.type = "button"; + swap.className = "pix-res-swap"; + swap.title = "Swap Width ↔ Height"; + swap.setAttribute("aria-label", "Swap Width and Height"); + + // Place the swap icon BETWEEN the two input fields (Figma/Photoshop pattern). + row.append(wField, swap, hField); + + const readout = document.createElement("div"); + readout.className = "pix-res-readout"; + + // Snap-step picker: magnet icon + 4 small chip buttons (8/16/32/64). + // Click to set; the active value is highlighted in brand orange. + const snapGroup = document.createElement("div"); + snapGroup.className = "pix-res-snap-group"; + snapGroup.title = "Snap step (also drives Up/Down arrow nudge)"; + const snapIcon = document.createElement("span"); + snapIcon.className = "pix-res-snap-icon"; + const snapBtns = document.createElement("div"); + snapBtns.className = "pix-res-snap-btns"; + const snapBtnEls = []; + for (const v of SNAP_OPTIONS) { + const btn = document.createElement("button"); + btn.type = "button"; + btn.className = "pix-res-snap-btn" + (v === (state.snap || 16) ? " active" : ""); + btn.textContent = String(v); + btn.dataset.v = String(v); + btn.addEventListener("click", (e) => { + e.stopPropagation(); + applySnap(v); }); - ratioSection.append(chips); root.append(ratioSection); - const batchSection = document.createElement("div"); batchSection.className = "section"; - const batchTitle = document.createElement("div"); batchTitle.className = "section-title"; batchTitle.textContent = "Batch"; - const batch = document.createElement("div"); batch.className = "batch"; - for (const [text, delta] of [["−", -1], ["+", 1]]) { - const button = document.createElement("button"); button.textContent = text; button.dataset.batchDelta = delta; batch.append(button); - if (delta < 0) batch.prepend(button); + snapBtns.appendChild(btn); + snapBtnEls.push(btn); + } + snapGroup.append(snapIcon, snapBtns); + + function applySnap(v) { + for (const b of snapBtnEls) { + b.classList.toggle("active", parseInt(b.dataset.v, 10) === v); } - const batchInput = document.createElement("input"); batchInput.type = "number"; batchInput.min = "1"; batchInput.max = "64"; batchInput.step = "1"; batchInput.value = Math.max(1, Math.min(64, Number(s.batch) || 1)); batchInput.dataset.key = "batch"; - batch.insertBefore(batchInput, batch.lastChild); - batchSection.append(batchTitle, batch); root.append(batchSection); - if (s.mode === "custom" || s.mode === "custom_ratio") { - const customSection = document.createElement("div"); customSection.className = "section"; - const customTitle = document.createElement("div"); customTitle.className = "section-title"; customTitle.textContent = s.mode === "custom" ? "Custom resolution" : "Custom ratio"; - const panel = document.createElement("div"); panel.className = "custom"; - const label = document.createElement("div"); label.className = "label"; label.textContent = s.mode === "custom" ? "Width · height · snap" : "Ratio · target width · snap"; panel.append(label); - if (s.mode === "custom_ratio") { - const ratioRow = document.createElement("div"); ratioRow.className = "custom-row"; - for (const key of ["custom_ratio_w", "custom_ratio_h"]) { const input=document.createElement("input"); input.dataset.key=key; input.type="number"; input.min="1"; input.value=s[key]; ratioRow.append(input); if (key === "custom_ratio_w") { const swap=document.createElement("button"); swap.textContent="⇄"; swap.title="Swap ratio"; swap.dataset.swapRatio="1"; ratioRow.append(swap); } } - panel.append(ratioRow); - const targetLabel=document.createElement("div"); targetLabel.className="label"; targetLabel.textContent="Target width"; panel.append(targetLabel); - const targets=document.createElement("div"); targets.className="target-row"; - for (const width of [512,768,1024,1536]) { const b=document.createElement("button"); b.textContent=width; b.dataset.widthTarget=width; if(Number(s.w)===width) b.classList.add("active"); targets.append(b); } - panel.append(targets); - const dimensionLabel=document.createElement("div"); dimensionLabel.className="label"; dimensionLabel.textContent="Output dimensions"; panel.append(dimensionLabel); - const dimensions=document.createElement("div"); dimensions.className="dimension-row"; - const widthInput=document.createElement("input"); widthInput.type="number"; widthInput.dataset.key="w"; widthInput.value=s.w; widthInput.title="Width"; - const heightInput=document.createElement("input"); heightInput.type="number"; heightInput.value=s.h; heightInput.title="Height"; heightInput.readOnly=true; - dimensions.append(widthInput,heightInput); panel.append(dimensions); - const preview=document.createElement("div"); preview.className="preview"; - const shape=document.createElement("div"); shape.className="preview-shape"; - const shapeWidth=Math.min(90, Math.max(34, 90 * Number(s.w) / Math.max(Number(s.h), Number(s.w)))); - shape.style.width=`${shapeWidth}px`; shape.style.height="42px"; - preview.append(shape); panel.append(preview); - } else { - const fields = [["custom_w", "Width"],["custom_h", "Height"]]; - for (const [key, text] of fields) { const input=document.createElement("input"); input.dataset.key=key; input.type="number"; input.title=text; input.value=s[key]; input.placeholder=text; panel.append(input); } - } - const snapLabel=document.createElement("div"); snapLabel.className="label"; snapLabel.textContent="Snap step"; panel.append(snapLabel); - for (const step of [8,16,32,64]) { const b=document.createElement("button"); b.textContent=`${step}px`; b.dataset.snap=step; b.className=Number(s.snap)===step?"active":""; panel.append(b); } - customSection.append(customTitle, panel); root.append(customSection); + // Inputs are type="text" now (math support); no native step attr to update. + // Arrow-key stepping reads the snap value at keypress time, so this just + // needs to land in state and re-commit so the W/H snap to the new step. + const cur = readState(node); + writeState(node, { ...cur, snap: v }); + commit(); + } + + const ratioMP = document.createElement("span"); + + readout.append(snapGroup, ratioMP); + + // Aspect-ratio visual preview — orange-tinted rectangle scaled to the + // chosen W:H, with the exact W × H labeled below it. + const preview = document.createElement("div"); + preview.className = "pix-res-preview"; + const previewRect = document.createElement("div"); + previewRect.className = "pix-res-preview-rect"; + const previewLabel = document.createElement("div"); + previewLabel.className = "pix-res-preview-label"; + preview.append(previewRect, previewLabel); + + // Maximum bounding box for the rectangle. Tuned so a 1:1 fits comfortably + // inside the empty space below the readout in the locked node. + const PREVIEW_MAX_W = 90; + const PREVIEW_MAX_H = 60; + + function refreshPreview(w, h) { + const aspect = w / h; + let pw, ph; + if (aspect >= PREVIEW_MAX_W / PREVIEW_MAX_H) { + pw = PREVIEW_MAX_W; + ph = PREVIEW_MAX_W / aspect; } else { - const sizeSection = document.createElement("div"); sizeSection.className = "section"; - const sizeTitle = document.createElement("div"); sizeTitle.className = "section-title"; sizeTitle.textContent = `Resolution presets · ${ratio}`; - const sizes = document.createElement("div"); sizes.className="sizes"; - for (const [w,h] of (SIZES[ratio] || [])) { const b=document.createElement("button"); b.className="size"; b.dataset.w=w; b.dataset.h=h; b.innerHTML=`${w} × ${h}${(w*h/1e6).toFixed(2)} MP`; if (w===Number(s.w)&&h===Number(s.h)) b.classList.add("active"); sizes.append(b); } - sizeSection.append(sizeTitle, sizes); root.append(sizeSection); + ph = PREVIEW_MAX_H; + pw = PREVIEW_MAX_H * aspect; } - const meta=document.createElement("div"); meta.className="meta"; meta.textContent=`Output ${s.w} × ${s.h} · ${(s.w*s.h/1e6).toFixed(2)} MP · batch ${Math.max(1,Math.min(64,Number(s.batch)||1))}`; root.append(meta); -} + sizePreviewRect(previewRect, pw, ph); + setSizeLabel(previewLabel, w, h); + } + refreshPreview(state.w, state.h); -function setup(node) { - node.resizable = false; - const root=document.createElement("div"); root.className="dumas-res"; - const widget=node.addDOMWidget("dumas_resolution_ui", "custom", root, {serialize:false, getValue:()=>read(node), setValue:()=>{}, getMinHeight:()=>570}); - // Keep the LiteGraph frame at least as tall as the rendered controls. - // The DOM widget otherwise keeps its old compact minimum and overhangs - // the node even when the node itself is marked non-resizable. - widget.computeLayoutSize=()=>({minHeight:570,minWidth:1}); - root.addEventListener("click", (event) => { - const button=event.target.closest("button"); if (!button) return; - const s=read(node), id=button.dataset.id; - if (button.dataset.batchDelta) { s.batch=Math.max(1,Math.min(64,(Number(s.batch)||1)+Number(button.dataset.batchDelta))); write(node,s); render(node,root); return; } - if (button.dataset.swapRatio) { [s.custom_ratio_w,s.custom_ratio_h]=[s.custom_ratio_h,s.custom_ratio_w]; [s.w,s.h]=ratioPair(s.w,s.custom_ratio_w,s.custom_ratio_h,s.snap); write(node,s); render(node,root); return; } - if (button.dataset.widthTarget) { s.w=snap(clamp(Number(button.dataset.widthTarget)),s.snap); [s.w,s.h]=ratioPair(s.w,s.custom_ratio_w,s.custom_ratio_h,s.snap); write(node,s); render(node,root); return; } - if (id && SIZES[id]) { const [w,h]=DEFAULT_SIZE[id]; write(node,{...s,mode:"preset",ratio:id,w,h}); } - else if (id === "custom") write(node,{...s,mode:"custom",w:s.custom_w,h:s.custom_h}); - else if (id === "custom_ratio") write(node,{...s,mode:"custom_ratio",w:ratioPair(s.w,s.custom_ratio_w,s.custom_ratio_h,s.snap)[0],h:ratioPair(s.w,s.custom_ratio_w,s.custom_ratio_h,s.snap)[1]}); - else if (button.dataset.w) write(node,{...s,w:Number(button.dataset.w),h:Number(button.dataset.h)}); - else if (button.dataset.snap) { const step=Number(button.dataset.snap); const next={...s,snap:step}; if(s.mode==="custom") { next.w=snap(clamp(s.custom_w),step); next.h=snap(clamp(s.custom_h),step); } else if(s.mode==="custom_ratio") [next.w,next.h]=ratioPair(s.w,s.custom_ratio_w,s.custom_ratio_h,step); write(node,next); return; } - render(node,root); + function refreshReadout(w, h) { + ratioMP.innerHTML = + `${ratioLabel(w, h)} · ${megapixels(w, h)} MP`; + refreshPreview(w, h); + } + refreshReadout(state.w, state.h); + + function commit() { + const cur = readState(node); + const step = cur.snap || 16; + const wRaw = safeMathEval(wInput.value); + const hRaw = safeMathEval(hInput.value); + // Invalid expression / empty → fall back to the LAST committed value so a + // typo doesn't replace the user's working state with a default. + const wNew = clampDim(snapTo(Number.isFinite(wRaw) && wRaw > 0 ? wRaw : cur.w, step)); + const hNew = clampDim(snapTo(Number.isFinite(hRaw) && hRaw > 0 ? hRaw : cur.h, step)); + wInput.value = String(wNew); + hInput.value = String(hNew); + refreshReadout(wNew, hNew); + writeState(node, { ...cur, w: wNew, h: hNew, custom_w: wNew, custom_h: hNew }); + } + + + function liveUpdate() { + const wLive = safeMathEval(wInput.value); + const hLive = safeMathEval(hInput.value); + // Only refresh the readout/preview when BOTH expressions evaluate cleanly. + // Otherwise the preview rectangle would jitter between valid keystrokes. + if (Number.isFinite(wLive) && Number.isFinite(hLive) && wLive > 0 && hLive > 0) { + refreshReadout(wLive, hLive); + } + } + wInput.addEventListener("input", liveUpdate); + hInput.addEventListener("input", liveUpdate); + + wInput.addEventListener("blur", commit); + hInput.addEventListener("blur", commit); + + // Replace native HTML5 number-input stepping with snap-aware arrow stepping. + // Up/Down increments by the current snap value (8/16/32/64); Shift+Up/Down + // by 4× for coarse jumps. Evaluates the current expression first so users + // can do "1024+8" then ArrowUp without losing the math. + function stepInput(input, dir, multiplier) { + const cur = readState(node); + const step = (cur.snap || 16) * multiplier; + const v = safeMathEval(input.value); + const base = Number.isFinite(v) && v > 0 ? v : (input === wInput ? cur.w : cur.h); + const next = clampDim(snapTo(base + dir * step, cur.snap || 16)); + input.value = String(next); + liveUpdate(); + } + + for (const inp of [wInput, hInput]) { + inp.addEventListener("keydown", (e) => { + if (passComfyShortcut(e, inp)) return; + // Always block ComfyUI canvas shortcuts from firing while typing. + e.stopPropagation(); + if (e.key === "Enter") { + e.preventDefault(); + inp.blur(); + return; + } + if (e.key === "ArrowUp" || e.key === "ArrowDown") { + e.preventDefault(); + const dir = e.key === "ArrowUp" ? 1 : -1; + const mult = e.shiftKey ? 4 : 1; + stepInput(inp, dir, mult); + } }); - root.addEventListener("change", (event) => { const key=event.target.dataset.key; if(!key)return; const s=read(node), value=key==="batch" ? Math.max(1,Math.min(64,Number(event.target.value)||1)) : Math.max(1,Math.min(16384,Number(event.target.value)||1)); s[key]=value; if(s.mode==="custom") { s.w=snap(clamp(s.custom_w),s.snap); s.h=snap(clamp(s.custom_h),s.snap); } else if(s.mode==="custom_ratio") { [s.w,s.h]=ratioPair(key==="w" ? value : s.w,s.custom_ratio_w,s.custom_ratio_h,s.snap); } write(node,s); render(node,root); }); - node._dumasResolutionRoot=root; node.size=[300,640]; queueMicrotask(()=>render(node,root)); + } + + swap.addEventListener("click", () => { + // Use safeMathEval too — the user may have typed math in either field. + const w = safeMathEval(wInput.value); + const h = safeMathEval(hInput.value); + const wOk = Number.isFinite(w) && w > 0 ? w : state.w; + const hOk = Number.isFinite(h) && h > 0 ? h : state.h; + wInput.value = String(hOk); + hInput.value = String(wOk); + commit(); + }); + + // swap is already inside `row` (between W and H fields), don't append again. + wrap.append(row, readout, preview); + return wrap; } -const originalGraphToPrompt=app.graphToPrompt?.bind(app); -if (originalGraphToPrompt && !app.__dumasResolutionPromptHook) { - app.__dumasResolutionPromptHook=true; - app.graphToPrompt=async (...args)=>{ const result=await originalGraphToPrompt(...args); injectState(result,collectNodes(app.graph)); return result; }; +function renderCustomRatioPanel(node, state) { + // Photoshop "lock-aspect" pattern: user types W:H ratio once, then either + // (a) clicks a quick-pick width chip, or (b) types into the W or H input + // (math expressions allowed). The other dimension auto-computes from the + // ratio and is snapped to /8/16/32/64 for AI alignment. + const wrap = document.createElement("div"); + wrap.className = "pix-res-list pix-res-custom pix-res-ratio"; + + // ── ratio inputs row (W : H, swap between) ────────────────── + const ratioRow = document.createElement("div"); + ratioRow.className = "pix-res-ratio-input-row"; + + const lbl = document.createElement("span"); + lbl.className = "pix-res-ratio-label"; + lbl.textContent = "Ratio"; + + const rwInput = document.createElement("input"); + rwInput.type = "text"; + rwInput.inputMode = "numeric"; + rwInput.spellcheck = false; + rwInput.autocomplete = "off"; + rwInput.value = String(safePositiveInt(state.custom_ratio_w, 4)); + rwInput.title = "Ratio width (positive integer)"; + + const rhInput = document.createElement("input"); + rhInput.type = "text"; + rhInput.inputMode = "numeric"; + rhInput.spellcheck = false; + rhInput.autocomplete = "off"; + rhInput.value = String(safePositiveInt(state.custom_ratio_h, 3)); + rhInput.title = "Ratio height (positive integer)"; + + const ratioSwap = document.createElement("button"); + ratioSwap.type = "button"; + ratioSwap.className = "pix-res-ratio-swap"; + ratioSwap.title = "Swap ratio W ↔ H"; + ratioSwap.setAttribute("aria-label", "Swap ratio width and height"); + + ratioRow.append(lbl, rwInput, ratioSwap, rhInput); + + // ── quick-pick width chips ────────────────────────────────── + const quickRow = document.createElement("div"); + quickRow.className = "pix-res-quickpicks"; + const quickBtnEls = []; + for (const w of QUICK_PICK_WIDTHS) { + const btn = document.createElement("button"); + btn.type = "button"; + btn.className = "pix-res-quickpick"; + btn.textContent = String(w); + btn.dataset.w = String(w); + quickRow.appendChild(btn); + quickBtnEls.push(btn); + } + + // ── W and H math-aware inputs (side-by-side, no swap between — ratio swap + // above already handles orientation flip) ──────────────────────────── + const fieldsRow = document.createElement("div"); + fieldsRow.className = "pix-res-custom-row"; + fieldsRow.style.gridTemplateColumns = "1fr 1fr"; // override 1fr auto 1fr (no swap col) + + const wField = document.createElement("div"); + wField.className = "pix-res-custom-field"; + const wLabel = document.createElement("label"); + wLabel.textContent = "Width"; + const wInput = document.createElement("input"); + wInput.type = "text"; + wInput.inputMode = "decimal"; + wInput.spellcheck = false; + wInput.autocomplete = "off"; + wInput.title = "Math allowed: 1024+128, 512*2 — height auto-computes from ratio"; + wInput.value = String(state.w); + wField.append(wLabel, wInput); + + const hField = document.createElement("div"); + hField.className = "pix-res-custom-field"; + const hLabel = document.createElement("label"); + hLabel.textContent = "Height"; + const hInput = document.createElement("input"); + hInput.type = "text"; + hInput.inputMode = "decimal"; + hInput.spellcheck = false; + hInput.autocomplete = "off"; + hInput.title = "Math allowed: 1024+128, 512*2 — width auto-computes from ratio"; + hInput.value = String(state.h); + hField.append(hLabel, hInput); + + fieldsRow.append(wField, hField); + + // ── readout (snap picker + ratio·MP) + aspect preview ───────── + const readout = document.createElement("div"); + readout.className = "pix-res-readout"; + + const snapGroup = document.createElement("div"); + snapGroup.className = "pix-res-snap-group"; + snapGroup.title = "Snap step (also drives Up/Down arrow nudge)"; + const snapIcon = document.createElement("span"); + snapIcon.className = "pix-res-snap-icon"; + const snapBtns = document.createElement("div"); + snapBtns.className = "pix-res-snap-btns"; + const snapBtnEls = []; + for (const v of SNAP_OPTIONS) { + const btn = document.createElement("button"); + btn.type = "button"; + btn.className = "pix-res-snap-btn" + (v === (state.snap || 16) ? " active" : ""); + btn.textContent = String(v); + btn.dataset.v = String(v); + btn.addEventListener("click", (e) => { + e.stopPropagation(); + const cur = readState(node); + writeState(node, { ...cur, snap: v }); + for (const b of snapBtnEls) b.classList.toggle("active", parseInt(b.dataset.v, 10) === v); + // Re-snap current W and recompute H so visible values reflect new step. + const w = safeMathEval(wInput.value); + if (Number.isFinite(w) && w > 0) { + commitFromW(w); + } + }); + snapBtns.appendChild(btn); + snapBtnEls.push(btn); + } + snapGroup.append(snapIcon, snapBtns); + + const ratioMP = document.createElement("span"); + readout.append(snapGroup, ratioMP); + + const preview = document.createElement("div"); + preview.className = "pix-res-preview"; + const previewRect = document.createElement("div"); + previewRect.className = "pix-res-preview-rect"; + const previewLabel = document.createElement("div"); + previewLabel.className = "pix-res-preview-label"; + preview.append(previewRect, previewLabel); + + const PREVIEW_MAX_W = 90; + const PREVIEW_MAX_H = 60; + + function refreshPreview(w, h) { + const aspect = w / h; + let pw, ph; + if (aspect >= PREVIEW_MAX_W / PREVIEW_MAX_H) { + pw = PREVIEW_MAX_W; + ph = PREVIEW_MAX_W / aspect; + } else { + ph = PREVIEW_MAX_H; + pw = PREVIEW_MAX_H * aspect; + } + sizePreviewRect(previewRect, pw, ph); + setSizeLabel(previewLabel, w, h); + } + + function refreshReadout(w, h) { + // In Custom Ratio mode the user's TYPED ratio is the source of truth, so + // show that label even when /16 snap drifts the actual W:H slightly. + const cur = readState(node); + const rW = safePositiveInt(cur.custom_ratio_w, 4); + const rH = safePositiveInt(cur.custom_ratio_h, 3); + ratioMP.innerHTML = + `${rW}:${rH} · ${megapixels(w, h)} MP`; + refreshPreview(w, h); + // Reflect quick-pick "active" chip if W matches an exact preset. + for (const b of quickBtnEls) { + b.classList.toggle("active", parseInt(b.dataset.w, 10) === w); + } + } + refreshReadout(state.w, state.h); + + // ── core commit helpers ────────────────────────────────────────── + // Given a Width value, snap it and derive Height from current ratio. + // Writes both to state and updates the inputs / readout. + function commitFromW(rawW) { + const cur = readState(node); + const step = cur.snap || 16; + const rW = safePositiveInt(cur.custom_ratio_w, 4); + const rH = safePositiveInt(cur.custom_ratio_h, 3); + const [w, h] = ratioPair(rawW, true, rW, rH, step); + wInput.value = String(w); + hInput.value = String(h); + refreshReadout(w, h); + writeState(node, { ...cur, w, h }); + } + + // Given a Height value, snap it and derive Width from current ratio. + function commitFromH(rawH) { + const cur = readState(node); + const step = cur.snap || 16; + const rW = safePositiveInt(cur.custom_ratio_w, 4); + const rH = safePositiveInt(cur.custom_ratio_h, 3); + const [w, h] = ratioPair(rawH, false, rW, rH, step); + wInput.value = String(w); + hInput.value = String(h); + refreshReadout(w, h); + writeState(node, { ...cur, w, h }); + } + + // ── live preview while typing (no commit until blur) ───────────── + function liveUpdate(input, isWidth) { + const v = safeMathEval(input.value); + if (!Number.isFinite(v) || v <= 0) return; + const cur = readState(node); + const rW = safePositiveInt(cur.custom_ratio_w, 4); + const rH = safePositiveInt(cur.custom_ratio_h, 3); + if (isWidth) { + refreshReadout(Math.round(v), Math.round((v * rH) / rW)); + } else { + refreshReadout(Math.round((v * rW) / rH), Math.round(v)); + } + } + wInput.addEventListener("input", () => liveUpdate(wInput, true)); + hInput.addEventListener("input", () => liveUpdate(hInput, false)); + + // ── input commit on blur ───────────────────────────────────────── + wInput.addEventListener("blur", () => { + const v = safeMathEval(wInput.value); + const cur = readState(node); + commitFromW(Number.isFinite(v) && v > 0 ? v : cur.w); + }); + hInput.addEventListener("blur", () => { + const v = safeMathEval(hInput.value); + const cur = readState(node); + commitFromH(Number.isFinite(v) && v > 0 ? v : cur.h); + }); + + // ── arrow-key stepping (same pattern as Custom Resolution) ───── + function stepInput(input, dir, multiplier, isWidth) { + const cur = readState(node); + const step = (cur.snap || 16) * multiplier; + const v = safeMathEval(input.value); + const base = Number.isFinite(v) && v > 0 ? v : (isWidth ? cur.w : cur.h); + const next = base + dir * step; + if (isWidth) commitFromW(next); else commitFromH(next); + } + + for (const [inp, isW] of [[wInput, true], [hInput, false]]) { + inp.addEventListener("keydown", (e) => { + if (passComfyShortcut(e, inp)) return; + e.stopPropagation(); + if (e.key === "Enter") { + e.preventDefault(); + inp.blur(); + return; + } + if (e.key === "ArrowUp" || e.key === "ArrowDown") { + e.preventDefault(); + const dir = e.key === "ArrowUp" ? 1 : -1; + const mult = e.shiftKey ? 4 : 1; + stepInput(inp, dir, mult, isW); + } + }); + } + + // ── quick-pick chip clicks set W and recompute H ───────────────── + quickRow.addEventListener("click", (e) => { + const btn = e.target.closest(".pix-res-quickpick"); + if (!btn) return; + e.stopPropagation(); + commitFromW(parseInt(btn.dataset.w, 10)); + }); + + // ── ratio input commit + validation ────────────────────────────── + function commitRatio() { + const rWraw = parseInt(rwInput.value, 10); + const rHraw = parseInt(rhInput.value, 10); + const cur = readState(node); + const rW = Number.isFinite(rWraw) && rWraw > 0 ? rWraw : safePositiveInt(cur.custom_ratio_w, 4); + const rH = Number.isFinite(rHraw) && rHraw > 0 ? rHraw : safePositiveInt(cur.custom_ratio_h, 3); + rwInput.value = String(rW); + rhInput.value = String(rH); + const ratioChanged = rW !== cur.custom_ratio_w || rH !== cur.custom_ratio_h; + if (ratioChanged) { + // Recompute H from current W at the new ratio so the visible image + // matches what the workflow will receive. Single combined write so + // the workflow can never observe a half-updated state mid-blur. + const step = cur.snap || 16; + const [w, h] = ratioPair(cur.w, true, rW, rH, step); + wInput.value = String(w); + hInput.value = String(h); + writeState(node, { ...cur, custom_ratio_w: rW, custom_ratio_h: rH, w, h }); + refreshReadout(w, h); + } + } + + for (const inp of [rwInput, rhInput]) { + inp.addEventListener("blur", commitRatio); + inp.addEventListener("keydown", (e) => { + if (passComfyShortcut(e, inp)) return; + e.stopPropagation(); + if (e.key === "Enter") { + e.preventDefault(); + inp.blur(); + } + }); + } + + ratioSwap.addEventListener("click", () => { + const a = rwInput.value; + rwInput.value = rhInput.value; + rhInput.value = a; + commitRatio(); + }); + + wrap.append(ratioRow, quickRow, fieldsRow, readout, preview); + return wrap; } + +function renderUI(node) { + const state = readState(node); + let root = node._pixResRoot; + if (!root || !root.isConnected) { + // Vue may have detached the original element. Re-find via the DOM widget. + const w = (node.widgets || []).find((x) => x.name === "resolution_ui"); + if (w?.element?.isConnected) { + const found = w.element.querySelector(".pix-res-root"); + if (found) { + node._pixResRoot = found; + root = found; + } else { + // Container exists but our root is gone — append a new one. + root = document.createElement("div"); + root.className = "pix-res-root"; + w.element.appendChild(root); + node._pixResRoot = root; + } + } else { + return; // nothing to render into + } + } + + root.innerHTML = ""; + root.appendChild(renderChipGrid(state)); + if (state.mode === "custom") { + root.appendChild(renderCustomPanel(node, state)); + } else if (state.mode === "custom_ratio") { + root.appendChild(renderCustomRatioPanel(node, state)); + } else { + root.appendChild(renderSizeList(state)); + } + // The innerHTML wipe above took the Classic batch band with it: put it back. + node._pixLb?.mount(); +} + +function setupResolutionNode(node) { + // Defensive: if a widget for ResolutionState somehow exists (stale Python + // not yet restarted, or a workflow loaded under the old architecture), + // hide it. With the current Python (hidden input), no widget is created + // and this is a no-op. + hideJsonWidget(node.widgets, HIDDEN_INPUT_NAME); + + // Brand default colors are applied globally by js/brand/index.js — no + // per-node guard needed. Title bar matches the chip surface (#1d1d1d), + // body matches the root surface (#2a2a2a) so the whole node reads as + // one cohesive dark panel. + + // Lock both dimensions. The chip grid is tuned for 240px wide, and the + // height is sized to fit all 8 preset rows + chips with no scrollbar (see + // NODE_H comment block). Resize would only ever produce empty space — see + // also onResize below which re-clamps if LiteGraph attempts a resize. + node.resizable = false; + node.size = [NODE_W, NODE_H]; + + // Empty root — we do NOT populate it synchronously. In Vue's new frontend, + // nodeCreated fires BEFORE configure restores widget values from saved + // workflows. If we render now, we'd render with default state and flash to + // the restored state when onConfigure re-renders milliseconds later. Defer + // the initial render (see queueMicrotask at the bottom) so configure has + // a chance to land the saved value first. + const root = document.createElement("div"); + root.className = "pix-res-root"; + + // DOM widget gets a constant slot of space (WIDGET_H, top of the file); + // chrome (the output rows) takes the rest. Both callbacks return the same + // value so the widget exactly fills the area between the slots and the node + // bottom. + installCanvasZoomPassthrough(root); + installNodeAccent(node, root); // the face follows this node's accent colour + const _widget = node.addDOMWidget("resolution_ui", "custom", root, { + // canvasOnly set adaptively below (CLAUDE.md Nodes 2.0): true in legacy + // (out of the Parameters tab), false in Nodes 2.0 (renders in Vue body). + getValue: () => readState(node), + setValue: (_v) => {}, + getMinHeight: () => WIDGET_H, + getMaxHeight: () => WIDGET_H, + margin: 4, + serialize: false, // DOM widget itself does not serialize; the hidden STRING widget owns the state + }); + applyAdaptiveCanvasOnly(_widget); + + const _onClick = (e) => { + const chip = e.target.closest(".pix-res-chip"); + if (chip) { + const id = chip.dataset.chipId; + const cur = readState(node); + if (id === "custom") { + writeState(node, { + ...cur, + mode: "custom", + w: cur.custom_w ?? 1024, + h: cur.custom_h ?? 1024, + }); + } else if (id === "custom_ratio") { + // Preserve current W if it's reasonable (>= 256); otherwise default + // to 1024 (SDXL native). Height auto-computes from the saved ratio + // and snaps to the current step so the panel opens with valid dims. + const rW = safePositiveInt(cur.custom_ratio_w, 4); + const rH = safePositiveInt(cur.custom_ratio_h, 3); + const step = cur.snap || 16; + const [w, h] = ratioPair(cur.w >= 256 ? cur.w : 1024, true, rW, rH, step); + writeState(node, { ...cur, mode: "custom_ratio", w, h }); + } else { + const sizes = SIZES[id]; + if (!sizes) return; + const [w, h] = DEFAULT_PER_RATIO[id] || sizes[0]; + writeState(node, { ...cur, mode: "preset", ratio: id, w, h }); + } + renderUI(node); + return; + } + const row = e.target.closest(".pix-res-row"); + if (row && !row.classList.contains("empty") && row.dataset.w) { + const w = parseInt(row.dataset.w, 10); + const h = parseInt(row.dataset.h, 10); + const cur = readState(node); + writeState(node, { ...cur, w, h }); + renderUI(node); + // Focus the freshly-rendered list so the next ArrowUp/Down keystroke is + // captured by the list — without this, the click moves focus to the + // overlay/canvas and arrows don't reach us. + const list = root.querySelector(".pix-res-list:not(.pix-res-custom)"); + list?.focus(); + list?.querySelector(".pix-res-row.active")?.scrollIntoView({ block: "nearest" }); + } + }; + + // Arrow-key navigation in preset mode (size list). The list is `tabindex=0` + // so it can receive focus; we delegate at root level so the listener + // survives every re-render. `stopPropagation` prevents ComfyUI's canvas + // from interpreting the arrow keys as graph pan. Custom modes have their + // own per-input arrow handlers (snap-step), not list-row navigation. + const _onKeydown = (e) => { + if (e.target instanceof HTMLInputElement) return; + const list = e.target.closest(".pix-res-list"); + if (!list || list.classList.contains("pix-res-custom")) return; + if (!["ArrowUp", "ArrowDown", "Home", "End"].includes(e.key)) return; + const cur = readState(node); + if (cur.mode !== "preset") return; + const sizes = SIZES[cur.ratio] || []; + if (sizes.length === 0) return; + e.preventDefault(); + e.stopPropagation(); + let idx = sizes.findIndex(([w, h]) => w === cur.w && h === cur.h); + if (idx < 0) idx = 0; + if (e.key === "ArrowUp") idx = Math.max(0, idx - 1); + else if (e.key === "ArrowDown") idx = Math.min(sizes.length - 1, idx + 1); + else if (e.key === "Home") idx = 0; + else if (e.key === "End") idx = sizes.length - 1; + const [w, h] = sizes[idx]; + if (w === cur.w && h === cur.h) return; + writeState(node, { ...cur, w, h }); + renderUI(node); + const newList = root.querySelector(".pix-res-list:not(.pix-res-custom)"); + newList?.focus(); + newList?.querySelector(".pix-res-row.active")?.scrollIntoView({ block: "nearest" }); + }; + + // Attach to both root and the widget container so a Vue rebuild still routes events. + root.addEventListener("click", _onClick); + root.addEventListener("keydown", _onKeydown); + if (_widget?.element) { + _widget.element.addEventListener("click", _onClick); + _widget.element.addEventListener("keydown", _onKeydown); + } + + node._pixResRoot = root; + + // The latent's batch size: a small stepper on the level of the `latent` + // output dot (output 2), in the empty space left of the labels, so the + // locked node size does not change. Stored as state.batch (absent = 1). + node._pixLb = installLatentBatch(node, { + outputIndex: 2, + getRoot: () => node._pixResRoot, + read: () => readState(node).batch ?? 1, + write: (n) => writeState(node, { ...readState(node), batch: n }), + }); + + // Deferred initial render. By the time the microtask fires, Vue will have + // called configure() on this node (if it's being restored from a saved + // workflow) so widget.value reflects the saved state and we render it + // correctly on the first paint — no flash from defaults. + queueMicrotask(() => { + const state = readState(node); + root.innerHTML = ""; + root.appendChild(renderChipGrid(state)); + if (state.mode === "custom") { + root.appendChild(renderCustomPanel(node, state)); + } else if (state.mode === "custom_ratio") { + root.appendChild(renderCustomRatioPanel(node, state)); + } else { + root.appendChild(renderSizeList(state)); + } + node._pixLb?.mount(); + }); +} + app.registerExtension({ - name:"Dumas.Resolution", - beforeRegisterNodeDef(nodeType,nodeData) { - if(nodeData?.name!==CLASS)return; - const oldConfigure=nodeType.prototype.onConfigure; - nodeType.prototype.onConfigure=function(...args){const result=oldConfigure?.apply(this,args); if(this._dumasResolutionRoot)render(this,this._dumasResolutionRoot); return result;}; - nodeType.prototype.onResize=function(){this.size=[300,640];}; - }, - nodeCreated(node){if(node.comfyClass===CLASS)setup(node);}, + name: "Dumas.Resolution", + + beforeRegisterNodeDef(nodeType, nodeData) { + if (nodeData.name !== "DumasResolution") return; + + // onConfigure fires whenever configure() is called — catches the case + // where a user opens a different workflow into an already-constructed + // node. Re-render so the UI matches the freshly-applied widget value. + const _origConfigure = nodeType.prototype.onConfigure; + nodeType.prototype.onConfigure = function (info) { + const r = _origConfigure?.apply(this, arguments); + if (this._pixResRoot) renderUI(this); + return r; + }; + + // Re-clamp on every resize attempt so the node can never grow / shrink. + // (Belt-and-braces with `node.resizable = false` — Vue/LiteGraph still + // emit onResize during workflow load with the saved size, which may not + // match our locked dimensions if the lock value was bumped between + // versions.) + const _origResize = nodeType.prototype.onResize; + nodeType.prototype.onResize = function (size) { + this.size[0] = NODE_W; + this.size[1] = NODE_H; + if (_origResize) return _origResize.call(this, size); + }; + }, + + // nodeCreated fires DURING node construction, BEFORE configure() is called + // to restore saved widget values (CLAUDE.md Pattern #8). The initial + // populate of the DOM widget is therefore deferred to queueMicrotask + // inside setupResolutionNode so configure has a chance to land the saved + // value first — without that defer, the panel renders defaults and flashes + // to the saved state milliseconds later. + nodeCreated(node) { + if (node.comfyClass !== "DumasResolution") return; + setupResolutionNode(node); + }, }); + +// Inject the per-node state into the API prompt at execution time. Python's +// `hidden` ResolutionState input expects a STRING value but doesn't get one +// from the workflow JSON (no widget exists). Patch app.graphToPrompt so each +// DumasResolution node's prompt entry gets its `inputs.ResolutionState` +// populated from node.properties[STATE_PROP] right before submission. +// +// Subgraph-safe lookup: ComfyUI's new subgraph system flattens contained nodes +// into the API prompt with composite string IDs (e.g. "5:12"), and `app.graph` +// only exposes top-level nodes — so the previous `parseInt(id) + getNodeById` +// path silently missed any DumasResolution placed inside a subgraph and +// the user got a TypeError at execution. Identify pixaroma entries directly +// by `class_type` in the API prompt, and resolve their state via a recursive +// walk over every nested subgraph. Falls back to DEFAULT_STATE if a node +// can't be found so the workflow never crashes — worst case the user sees the +// 1024×1024 default instead of their pick. +function buildPixaromaNodeIndex() { + const index = new Map(); // String(node.id) → node + const visit = (graph) => { + if (!graph) return; + const nodes = graph._nodes || graph.nodes || []; + for (const n of nodes) { + if (!n) continue; + if (n.comfyClass === "DumasResolution" || n.type === "DumasResolution") { + index.set(String(n.id), n); + } + // ComfyUI subgraph instances expose their inner graph at one of these + // keys depending on frontend version; check all known shapes. + const inner = n.subgraph || n.graph || n._graph; + if (inner && inner !== graph) visit(inner); + } + }; + visit(app.graph); + return index; +} + +function findPixaromaNode(index, promptId) { + // Try exact match first; then strip any subgraph prefix ("5:12" → "12") so + // we still hit the inner node when ComfyUI prefixes IDs in the API prompt. + const sId = String(promptId); + if (index.has(sId)) return index.get(sId); + const tail = sId.includes(":") ? sId.slice(sId.lastIndexOf(":") + 1) : null; + if (tail && index.has(tail)) return index.get(tail); + return null; +} + +const _origGraphToPrompt_fn = app.graphToPrompt; +const _origGraphToPrompt = (...a) => _origGraphToPrompt_fn.apply(app, a); +app.graphToPrompt = async function (...args) { + const result = await _origGraphToPrompt(...args); + // FAIL OPEN - see the note in pause_image: a throw here rejects ComfyUI's + // own graphToPrompt and breaks Run for the whole workflow. Never wrap the + // `await _origGraphToPrompt` above; a failure in CORE must propagate. + try { + const out = result?.output; + if (out) { + let index = null; + for (const id in out) { + const entry = out[id]; + if (!entry || entry.class_type !== "DumasResolution") continue; + if (!index) index = buildPixaromaNodeIndex(); + const node = findPixaromaNode(index, id); + const state = node?.properties?.[STATE_PROP] || JSON.stringify(DEFAULT_STATE); + entry.inputs = entry.inputs || {}; + entry.inputs[HIDDEN_INPUT_NAME] = state; + } + } + } catch (e) { + console.error("[DUMAS] Resolution prompt injection failed; prompt sent unchanged", e); + } + return result; +}; + +// The colour option: gives this node a right-click "Resolution settings" entry, the +// gear in the selection toolbar, and the shared colour panel behind both. +registerNodeAccent("DumasResolution", { title: "Resolution" });