LCOV - code coverage report
Current view: top level - src/components/graph - DomWidgets.vue Coverage Total Hit
Test: ComfyUI E2E Coverage Lines: 100.0 % 50 50
Test Date: 2026-11-17 04:17:53

            Line data    Source code
       1              : <template>
       2              :   <!-- Create a new stacking context for widgets to avoid z-index issues -->
       3         4393 :   <div
       4              :     class="isolate"
       5              :     data-testid="dom-widgets"
       6              :     :inert="canvasStore.isPickingNodes"
       7              :   >
       8         4657 :     <DomWidget
       9              :       v-for="widgetState in widgetStates"
      10              :       :key="widgetState.widget.id"
      11              :       :widget-state="widgetState"
      12              :       @update:widget-value="widgetState.widget.value = $event"
      13              :     />
      14              :   </div>
      15              : </template>
      16              : 
      17              : <script setup lang="ts">
      18              : import { whenever } from '@vueuse/core'
      19              : import { computed } from 'vue'
      20              : 
      21              : import DomWidget from '@/components/graph/widgets/DomWidget.vue'
      22              : import { getDomWidgetZIndex } from '@/components/graph/widgets/domWidgetZIndex'
      23              : import { useChainCallback } from '@/composables/functional/useChainCallback'
      24              : import { findFirstNode } from '@/lib/litegraph/src/utils/collections'
      25              : import { useCanvasStore } from '@/renderer/core/canvas/canvasStore'
      26              : import { useDomWidgetStore } from '@/stores/domWidgetStore'
      27              : 
      28         1626 : const domWidgetStore = useDomWidgetStore()
      29              : 
      30         1626 : const widgetStates = computed(() => [...domWidgetStore.widgetStates.values()])
      31              : 
      32              : // Track canvas viewport and selected-node bounds between frames.
      33              : // lgCanvas.ds.offset, ds.scale, and node.renderArea are non-reactive plain
      34              : // values, so widgetState.pos needs a new identity to rerun downstream work.
      35         1626 : const lastViewport = {
      36              :   offsetX: Number.NaN,
      37              :   offsetY: Number.NaN,
      38              :   scale: Number.NaN
      39              : }
      40         1626 : const lastSelected = {
      41              :   id: undefined as string | number | undefined,
      42              :   x: 0,
      43              :   y: 0,
      44              :   width: 0,
      45              :   height: 0
      46              : }
      47              : 
      48         1626 : const updateWidgets = () => {
      49        14071 :   const lgCanvas = canvasStore.canvas
      50        14071 :   if (!lgCanvas) return
      51              : 
      52        14071 :   const lowQuality = lgCanvas.low_quality
      53        14071 :   const currentGraph = lgCanvas.graph
      54              : 
      55        14071 :   const viewportOffsetX = lgCanvas.ds.offset[0]
      56        14071 :   const viewportOffsetY = lgCanvas.ds.offset[1]
      57        14071 :   const viewportScale = lgCanvas.ds.scale
      58        14071 :   const viewportChanged =
      59              :     lastViewport.offsetX !== viewportOffsetX ||
      60              :     lastViewport.offsetY !== viewportOffsetY ||
      61              :     lastViewport.scale !== viewportScale
      62        14071 :   lastViewport.offsetX = viewportOffsetX
      63        14071 :   lastViewport.offsetY = viewportOffsetY
      64        14071 :   lastViewport.scale = viewportScale
      65              : 
      66        14071 :   const selectedNode = findFirstNode(lgCanvas.selectedItems)
      67        14071 :   const selectedNodeId = selectedNode?.id
      68        14071 :   const selectedArea = selectedNode?.renderArea
      69        14071 :   const selectionChanged =
      70              :     lastSelected.id !== selectedNodeId ||
      71              :     (!!selectedArea &&
      72              :       (lastSelected.x !== selectedArea[0] ||
      73              :         lastSelected.y !== selectedArea[1] ||
      74              :         lastSelected.width !== selectedArea[2] ||
      75              :         lastSelected.height !== selectedArea[3]))
      76        14071 :   lastSelected.id = selectedNodeId
      77        14071 :   lastSelected.x = selectedArea?.[0] ?? 0
      78        14071 :   lastSelected.y = selectedArea?.[1] ?? 0
      79        14071 :   lastSelected.width = selectedArea?.[2] ?? 0
      80        14071 :   lastSelected.height = selectedArea?.[3] ?? 0
      81              : 
      82        14071 :   for (const widgetState of widgetStates.value) {
      83        24203 :     const widget = widgetState.widget
      84              : 
      85        24203 :     if (!widget.isVisible() || !widgetState.active) {
      86         1091 :       widgetState.visible = false
      87         1091 :       continue
      88              :     }
      89              : 
      90        23112 :     const posNode = widget.node
      91              : 
      92        23112 :     const isInCorrectGraph = posNode.graph === currentGraph
      93        23112 :     const nodeVisible = lgCanvas.isNodeVisible(posNode)
      94              : 
      95        24203 :     widgetState.visible =
      96              :       isInCorrectGraph &&
      97              :       nodeVisible &&
      98              :       !(widget.options.hideOnZoom && lowQuality)
      99              : 
     100        24203 :     if (widgetState.visible) {
     101        22080 :       const margin = widget.margin
     102        22080 :       const newPosX = posNode.pos[0] + margin
     103        22080 :       const newPosY = posNode.pos[1] + margin + widget.y
     104        22080 :       if (
     105              :         viewportChanged ||
     106              :         selectionChanged ||
     107              :         widgetState.pos[0] !== newPosX ||
     108              :         widgetState.pos[1] !== newPosY
     109              :       ) {
     110         5848 :         widgetState.pos = [newPosX, newPosY]
     111              :       }
     112              : 
     113        22080 :       const newWidth = (widget.width ?? posNode.width) - margin * 2
     114        22080 :       const newHeight = (widget.computedHeight ?? 50) - margin * 2
     115        22080 :       if (
     116              :         widgetState.size[0] !== newWidth ||
     117              :         widgetState.size[1] !== newHeight
     118              :       ) {
     119         4228 :         widgetState.size = [newWidth, newHeight]
     120              :       }
     121              : 
     122        22080 :       widgetState.zIndex = getDomWidgetZIndex(posNode, currentGraph)
     123        22080 :       widgetState.readonly = lgCanvas.read_only
     124              :     }
     125              :   }
     126              : }
     127              : 
     128         1626 : const canvasStore = useCanvasStore()
     129         1626 : whenever(
     130              :   () => canvasStore.canvas,
     131              :   (canvas) =>
     132              :     (canvas.onDrawForeground = useChainCallback(
     133              :       canvas.onDrawForeground,
     134              :       updateWidgets
     135              :     )),
     136              :   { immediate: true }
     137              : )
     138              : </script>
        

Generated by: LCOV version 2.0-1