[feat] DOM widget promotion for subgraph inputs (#4491)

src/components/graph/DomWidgets.vue

@@ -11,7 +11,6 @@
 </template>
 
 <script setup lang="ts">
-import type { LGraphNode } from '@comfyorg/litegraph'
 import { whenever } from '@vueuse/core'
 import { computed } from 'vue'
 
@@ -21,24 +20,35 @@ import { useDomWidgetStore } from '@/stores/domWidgetStore'
 import { useCanvasStore } from '@/stores/graphStore'
 
 const domWidgetStore = useDomWidgetStore()
-const widgetStates = computed(() => domWidgetStore.activeWidgetStates)
+
+const widgetStates = computed(() => [...domWidgetStore.widgetStates.values()])
 
 const updateWidgets = () => {
   const lgCanvas = canvasStore.canvas
   if (!lgCanvas) return
 
   const lowQuality = lgCanvas.low_quality
+  const currentGraph = lgCanvas.graph
+
   for (const widgetState of widgetStates.value) {
     const widget = widgetState.widget
-    const node = widget.node as LGraphNode
 
-    const visible =
+    // Early exit for non-visible widgets
+    if (!widget.isVisible()) {
+      widgetState.visible = false
+      continue
+    }
+
+    // Check if the widget's node is in the current graph
+    const node = widget.node
+    const isInCorrectGraph = currentGraph?.nodes.includes(node)
+
+    widgetState.visible =
+      !!isInCorrectGraph &&
       lgCanvas.isNodeVisible(node) &&
-      !(widget.options.hideOnZoom && lowQuality) &&
-      widget.isVisible()
+      !(widget.options.hideOnZoom && lowQuality)
 
-    widgetState.visible = visible
-    if (visible) {
+    if (widgetState.visible && node) {
       const margin = widget.margin
       widgetState.pos = [node.pos[0] + margin, node.pos[1] + margin + widget.y]
       widgetState.size = [

src/components/graph/widgets/DomWidget.vue

@@ -19,7 +19,7 @@
 
 <script setup lang="ts">
 import { useElementBounding, useEventListener } from '@vueuse/core'
-import { CSSProperties, computed, onMounted, ref, watch } from 'vue'
+import { CSSProperties, computed, nextTick, onMounted, ref, watch } from 'vue'
 
 import { useAbsolutePosition } from '@/composables/element/useAbsolutePosition'
 import { useDomClipping } from '@/composables/element/useDomClipping'
@@ -61,10 +61,13 @@ const updateDomClipping = () => {
   if (!lgCanvas || !widgetElement.value) return
 
   const selectedNode = Object.values(lgCanvas.selected_nodes ?? {})[0]
-  if (!selectedNode) return
+  if (!selectedNode) {
+    // Clear clipping when no node is selected
+    updateClipPath(widgetElement.value, lgCanvas.canvas, false, undefined)
+    return
+  }
 
-  const node = widget.node
-  const isSelected = selectedNode === node
+  const isSelected = selectedNode === widget.node
   const renderArea = selectedNode?.renderArea
   const offset = lgCanvas.ds.offset
   const scale = lgCanvas.ds.scale
@@ -122,7 +125,10 @@ watch(
   }
 )
 
-if (isDOMWidget(widget)) {
+// Set up event listeners only after the widget is mounted and visible
+const setupDOMEventListeners = () => {
+  if (!isDOMWidget(widget) || !widgetState.visible) return
+
   if (widget.element.blur) {
     useEventListener(document, 'mousedown', (event) => {
       if (!widget.element.contains(event.target as HTMLElement)) {
@@ -140,14 +146,46 @@ if (isDOMWidget(widget)) {
   }
 }
 
+// Set up event listeners when widget becomes visible
+watch(
+  () => widgetState.visible,
+  (visible) => {
+    if (visible) {
+      setupDOMEventListeners()
+    }
+  },
+  { immediate: true }
+)
+
 const inputSpec = widget.node.constructor.nodeData
 const tooltip = inputSpec?.inputs?.[widget.name]?.tooltip
 
-onMounted(() => {
-  if (isDOMWidget(widget) && widgetElement.value) {
-    widgetElement.value.appendChild(widget.element)
+// Mount DOM element when widget is or becomes visible
+const mountElementIfVisible = () => {
+  if (widgetState.visible && isDOMWidget(widget) && widgetElement.value) {
+    // Only append if not already a child
+    if (!widgetElement.value.contains(widget.element)) {
+      widgetElement.value.appendChild(widget.element)
+    }
   }
+}
+
+// Check on mount - but only after next tick to ensure visibility is calculated
+onMounted(() => {
+  nextTick(() => {
+    mountElementIfVisible()
+  }).catch((error) => {
+    console.error('Error mounting DOM widget element:', error)
+  })
 })
+
+// And watch for visibility changes
+watch(
+  () => widgetState.visible,
+  () => {
+    mountElementIfVisible()
+  }
+)
 </script>
 
 <style scoped>

src/composables/useRefreshableSelection.ts

@@ -1,5 +1,4 @@
 import type { LGraphNode } from '@comfyorg/litegraph'
-import type { IBaseWidget } from '@comfyorg/litegraph/dist/types/widgets'
 import { computed, ref, watchEffect } from 'vue'
 
 import { useCanvasStore } from '@/stores/graphStore'
@@ -9,12 +8,11 @@ interface RefreshableItem {
   refresh: () => Promise<void> | void
 }
 
-type RefreshableWidget = IBaseWidget & RefreshableItem
-
-const isRefreshableWidget = (
-  widget: IBaseWidget
-): widget is RefreshableWidget =>
-  'refresh' in widget && typeof widget.refresh === 'function'
+const isRefreshableWidget = (widget: unknown): widget is RefreshableItem =>
+  widget != null &&
+  typeof widget === 'object' &&
+  'refresh' in widget &&
+  typeof widget.refresh === 'function'
 
 /**
  * Tracks selected nodes and their refreshable widgets
@@ -27,10 +25,17 @@ export const useRefreshableSelection = () => {
     selectedNodes.value = graphStore.selectedItems.filter(isLGraphNode)
   })
 
-  const refreshableWidgets = computed(() =>
-    selectedNodes.value.flatMap(
-      (node) => node.widgets?.filter(isRefreshableWidget) ?? []
-    )
+  const refreshableWidgets = computed<RefreshableItem[]>(() =>
+    selectedNodes.value.flatMap((node) => {
+      if (!node.widgets) return []
+      const items: RefreshableItem[] = []
+      for (const widget of node.widgets) {
+        if (isRefreshableWidget(widget)) {
+          items.push(widget)
+        }
+      }
+      return items
+    })
   )
 
   const isRefreshable = computed(() => refreshableWidgets.value.length > 0)

src/scripts/domWidget.ts

@@ -158,6 +158,18 @@ abstract class BaseDOMWidgetImpl<V extends object | string>
   override onRemove(): void {
     useDomWidgetStore().unregisterWidget(this.id)
   }
+
+  override createCopyForNode(node: LGraphNode): this {
+    // @ts-expect-error
+    const cloned: this = new (this.constructor as typeof this)({
+      node: node,
+      name: this.name,
+      type: this.type,
+      options: this.options
+    })
+    cloned.value = this.value
+    return cloned
+  }
 }
 
 export class DOMWidgetImpl<T extends HTMLElement, V extends object | string>
@@ -177,6 +189,19 @@ export class DOMWidgetImpl<T extends HTMLElement, V extends object | string>
     this.element = obj.element
   }
 
+  override createCopyForNode(node: LGraphNode): this {
+    // @ts-expect-error
+    const cloned: this = new (this.constructor as typeof this)({
+      node: node,
+      name: this.name,
+      type: this.type,
+      element: this.element, // Include the element!
+      options: this.options
+    })
+    cloned.value = this.value
+    return cloned
+  }
+
   /** Extract DOM widget size info */
   override computeLayoutSize(node: LGraphNode) {
     if (this.type === 'hidden') {

src/services/litegraphService.ts

@@ -32,7 +32,9 @@ import type {
 } from '@/schemas/nodeDef/nodeDefSchemaV2'
 import type { ComfyNodeDef as ComfyNodeDefV1 } from '@/schemas/nodeDefSchema'
 import { ComfyApp, app } from '@/scripts/app'
+import { isComponentWidget, isDOMWidget } from '@/scripts/domWidget'
 import { $el } from '@/scripts/ui'
+import { useDomWidgetStore } from '@/stores/domWidgetStore'
 import { useCanvasStore } from '@/stores/graphStore'
 import { useNodeOutputStore } from '@/stores/imagePreviewStore'
 import { ComfyNodeDefImpl } from '@/stores/nodeDefStore'
@@ -87,6 +89,37 @@ export const useLitegraphService = () => {
       constructor() {
         super(app.graph, subgraph, instanceData)
 
+        // Set up event listener for promoted widget registration
+        subgraph.events.addEventListener('widget-promoted', (event) => {
+          const { widget } = event.detail
+          // Only handle DOM widgets
+          if (!isDOMWidget(widget) && !isComponentWidget(widget)) return
+
+          const domWidgetStore = useDomWidgetStore()
+          if (!domWidgetStore.widgetStates.has(widget.id)) {
+            domWidgetStore.registerWidget(widget)
+            // Set initial visibility based on whether the widget's node is in the current graph
+            const widgetState = domWidgetStore.widgetStates.get(widget.id)
+            if (widgetState) {
+              const currentGraph = canvasStore.getCanvas().graph
+              widgetState.visible =
+                currentGraph?.nodes.includes(widget.node) ?? false
+            }
+          }
+        })
+
+        // Set up event listener for promoted widget removal
+        subgraph.events.addEventListener('widget-unpromoted', (event) => {
+          const { widget } = event.detail
+          // Only handle DOM widgets
+          if (!isDOMWidget(widget) && !isComponentWidget(widget)) return
+
+          const domWidgetStore = useDomWidgetStore()
+          if (domWidgetStore.widgetStates.has(widget.id)) {
+            domWidgetStore.unregisterWidget(widget.id)
+          }
+        })
+
         this.#setupStrokeStyles()
         this.#addInputs(ComfyNode.nodeData.inputs)
         this.#addOutputs(ComfyNode.nodeData.outputs)