LCOV - code coverage report
Current view: top level - src/renderer/extensions/vueNodes/components - WidgetGrid.vue Coverage Total Hit
Test: ComfyUI E2E Coverage Lines: 100.0 % 52 52
Test Date: 2026-11-17 04:17:53

            Line data    Source code
       1              : <template>
       2        19507 :   <div
       3              :     ref="grid"
       4              :     data-testid="node-widgets"
       5              :     class="lg-node-widgets grid grid-cols-[min-content_minmax(0,1fr)] gap-y-(--node-widget-gap) pr-3 text-xs text-node-foreground"
       6              :     :style="{
       7              :       'grid-template-rows': gridTemplateRows,
       8              :       flex: gridTemplateRows.includes('auto') ? 1 : undefined
       9              :     }"
      10              :   >
      11        42800 :     <div
      12              :       v-for="section in sections"
      13              :       :key="section.key"
      14              :       :role="section.role"
      15              :       :aria-label="section.label"
      16              :       class="col-span-full grid grid-cols-subgrid grid-rows-subgrid"
      17              :       :style="{ gridRow: `span ${section.rows.length}` }"
      18              :     >
      19              :       <template v-for="row in section.rows" :key="row.widget.renderKey">
      20        43397 :         <div
      21              :           :data-testid="row.testId"
      22              :           :data-widget-name="row.widget.simplified.name"
      23              :           :class="
      24              :             cn(
      25              :               'group col-span-full grid grid-cols-subgrid items-stretch',
      26              :               row.showsControl && 'lg-node-widget'
      27              :             )
      28              :           "
      29              :         >
      30              :           <div :class="row.slotClass">
      31              :             <InputSlot
      32              :               v-if="row.widget.slotMetadata"
      33              :               :key="`widget-slot-${row.widget.simplified.name}-${row.widget.slotMetadata.index}`"
      34              :               :slot-data="{
      35              :                 name: row.widget.simplified.name,
      36              :                 label: row.widget.simplified.label,
      37              :                 type: row.widget.slotMetadata.type,
      38              :                 boundingRect: [0, 0, 0, 0]
      39              :               }"
      40              :               :node-id
      41              :               :has-error="row.widget.hasError"
      42              :               :index="row.widget.slotMetadata.index"
      43              :               :socketless="row.widget.simplified.spec?.socketless"
      44              :               :standalone="row.standalone"
      45              :               :dot-only="row.showsControl"
      46              :             />
      47              :           </div>
      48              :           <AppInput
      49              :             v-if="row.showsControl"
      50              :             :widget-id="row.widget.widgetId"
      51              :             :name="row.widget.simplified.name"
      52              :             :enable="
      53              :               canSelectInputs && !row.widget.simplified.options?.disabled
      54              :             "
      55              :           >
      56              :             <Tooltip :disabled="!row.widget.tooltipText">
      57              :               <TooltipTrigger as-child>
      58              :                 <div
      59              :                   :class="
      60              :                     cn(
      61              :                       'grid min-w-0 grid-cols-1',
      62              :                       row.rowSize === 'min-content' && 'self-center'
      63              :                     )
      64              :                   "
      65              :                 >
      66              :                   <component
      67              :                     :is="row.widget.vueComponent"
      68              :                     :model-value="row.widget.simplified.value"
      69              :                     :widget="row.widget.simplified"
      70              :                     :node-id
      71              :                     :node-type
      72              :                     :node-title
      73              :                     :invalid="row.widget.hasError"
      74              :                     :aria-invalid="row.widget.hasError || undefined"
      75              :                     :class="
      76              :                       cn('col-span-full', row.widget.hasError && 'font-bold')
      77              :                     "
      78              :                     @update:model-value="row.widget.updateHandler"
      79              :                     @contextmenu="row.widget.handleContextMenu"
      80              :                     @removed="restoreRowFocus"
      81              :                   />
      82              :                 </div>
      83              :               </TooltipTrigger>
      84              :               <TooltipContent side="left">{{
      85              :                 row.widget.tooltipText
      86              :               }}</TooltipContent>
      87              :             </Tooltip>
      88              :           </AppInput>
      89              :         </div>
      90              :       </template>
      91              :     </div>
      92              :   </div>
      93              : </template>
      94              : 
      95              : <script setup lang="ts">
      96              : import {
      97              :   computed,
      98              :   nextTick,
      99              :   onMounted,
     100              :   shallowRef,
     101              :   useTemplateRef,
     102              :   watch
     103              : } from 'vue'
     104              : 
     105              : import { useResizeObserver } from '@vueuse/core'
     106              : 
     107              : import Tooltip from '@comfyorg/design-system/tooltip/Tooltip'
     108              : import TooltipContent from '@comfyorg/design-system/tooltip/TooltipContent'
     109              : import TooltipTrigger from '@comfyorg/design-system/tooltip/TooltipTrigger'
     110              : import { useCanvasStore } from '@/renderer/core/canvas/canvasStore'
     111              : import { syncSlotOffsets } from '@/renderer/core/layout/slots/syncSlotOffsets'
     112              : import AppInput from '@/renderer/extensions/linearMode/AppInput.vue'
     113              : import { useVueElementTracking } from '@/renderer/extensions/vueNodes/composables/useVueNodeResizeTracking'
     114              : import type { WidgetGridItem } from '@/renderer/extensions/vueNodes/types/widgetGrid'
     115              : import { shouldExpand } from '@/renderer/extensions/vueNodes/widgets/registry/widgetRegistry'
     116              : import type { NodeId } from '@comfyorg/graph-model/nodeId'
     117              : import { cn } from '@comfyorg/tailwind-utils'
     118              : 
     119              : import InputSlot from './InputSlot.vue'
     120              : 
     121         6910 : const grid = useTemplateRef<HTMLElement>('grid')
     122              : 
     123         6910 : const isConvertedWidgetType = (type: string) =>
     124              :   type === 'converted-widget' || type.startsWith('converted-widget:')
     125              : 
     126              : const {
     127              :   processedWidgets,
     128              :   nodeType,
     129              :   canSelectInputs = false,
     130              :   nodeId,
     131              :   nodeTitle,
     132              :   syncLayout = true
     133              : } = defineProps<{
     134              :   processedWidgets: WidgetGridItem[]
     135              :   nodeType: string
     136              :   canSelectInputs?: boolean
     137              :   nodeId?: NodeId
     138              :   nodeTitle?: string
     139              :   syncLayout?: boolean
     140              : }>()
     141              : 
     142         6910 : useVueElementTracking(syncLayout ? String(nodeId ?? '') : '', 'widgets-grid')
     143         6910 : const canvasStore = useCanvasStore()
     144         6910 : const renderedRows = computed(() =>
     145              :   processedWidgets.flatMap((widget) => {
     146        46614 :     const isConverted = isConvertedWidgetType(widget.simplified.type)
     147        46614 :     const showsControl = !isConverted && widget.visible
     148              :     const shouldRender = isConverted
     149              :       ? !!widget.slotMetadata
     150              :       : widget.visible ||
     151              :         (!!widget.suppressedByConnection && !!widget.slotMetadata)
     152        46614 :     if (!shouldRender) return []
     153              : 
     154        46614 :     return [
     155              :       {
     156              :         widget,
     157              :         showsControl,
     158              :         slotClass: cn(
     159              :           'z-10 flex items-stretch',
     160              :           showsControl
     161              :             ? 'w-3 opacity-0 transition-opacity duration-150 group-hover:opacity-100'
     162              :             : 'col-span-full',
     163              :           widget.slotMetadata?.linked && 'opacity-100'
     164              :         ),
     165              :         standalone: !showsControl && !!widget.suppressedByConnection,
     166              :         testId: showsControl ? 'node-widget' : undefined,
     167              :         rowSize:
     168              :           showsControl &&
     169              :           (shouldExpand(widget.simplified.type) || widget.hasLayoutSize)
     170              :             ? 'auto'
     171              :             : 'min-content'
     172              :       }
     173              :     ]
     174              :   })
     175              : )
     176              : 
     177          597 : function withShortFieldLabel(
     178              :   widget: WidgetGridItem,
     179              :   groupName: string,
     180              :   groupLabel?: string
     181              : ) {
     182          597 :   const field =
     183              :     widget.simplified.spec?.display_name ??
     184              :     widget.simplified.name.slice(groupName.length + 1)
     185          597 :   return widget.simplified.label === `${groupLabel} ${field}`
     186              :     ? {
     187              :         ...widget,
     188              :         simplified: { ...widget.simplified, displayLabel: field }
     189              :       }
     190              :     : widget
     191              : }
     192              : 
     193         6910 : const sections = computed(() => {
     194        18956 :   const result: {
     195              :     key: string
     196              :     name?: string
     197              :     label?: string
     198              :     role?: 'group'
     199              :     rows: typeof renderedRows.value
     200              :   }[] = []
     201        18956 :   for (const row of renderedRows.value) {
     202        42198 :     const { name, type, label } = row.widget.simplified
     203        42198 :     if (type === 'dynamic_group_row') {
     204          199 :       result.push({
     205              :         key: row.widget.renderKey,
     206              :         name,
     207              :         label,
     208              :         role: label ? 'group' : undefined,
     209              :         rows: [row]
     210              :       })
     211          199 :       continue
     212              :     }
     213        41999 :     const section = result.at(-1)
     214        42198 :     if (!section?.name || !name.startsWith(`${section.name}.`)) {
     215        41402 :       result.push({ key: row.widget.renderKey, rows: [row] })
     216        41402 :       continue
     217              :     }
     218          597 :     section.rows.push({
     219              :       ...row,
     220              :       widget: withShortFieldLabel(row.widget, section.name, section.label)
     221              :     })
     222              :   }
     223        18956 :   return result
     224              : })
     225              : 
     226            6 : async function restoreRowFocus(name: string) {
     227            6 :   const group = name.slice(0, name.lastIndexOf('.'))
     228            6 :   await nextTick()
     229              :   const remaining = sections.value.filter((section) =>
     230              :     section.name?.startsWith(`${group}.`)
     231              :   )
     232            6 :   const candidates = [
     233              :     name,
     234              :     ...remaining.map((section) => section.name).reverse(),
     235              :     `${group}.$add`
     236              :   ]
     237            6 :   for (const candidate of candidates) {
     238            7 :     if (!candidate) continue
     239            7 :     const button = grid.value?.querySelector<HTMLButtonElement>(
     240              :       `[data-widget-name="${CSS.escape(candidate)}"] button:not(:disabled)`
     241              :     )
     242            7 :     if (button) {
     243            6 :       button.focus()
     244            6 :       return
     245              :     }
     246              :   }
     247              : }
     248              : 
     249         6910 : const gridTemplateRows = computed(() =>
     250              :   renderedRows.value.map((row) => row.rowSize).join(' ')
     251              : )
     252              : 
     253         6910 : const layoutKey = computed(() =>
     254              :   renderedRows.value
     255              :     .map(
     256              :       ({ widget, showsControl }) =>
     257              :         `${widget.renderKey}:${widget.slotMetadata?.index ?? ''}:${showsControl}`
     258              :     )
     259              :     .join('|')
     260              : )
     261              : 
     262         8769 : function syncOffsets() {
     263         8769 :   const rootGraphId = canvasStore.rootGraphId
     264         8769 :   if (syncLayout && grid.value && rootGraphId && nodeId) {
     265         8769 :     syncSlotOffsets(grid.value, rootGraphId, nodeId)
     266              :   }
     267              : }
     268              : 
     269         6910 : const rows = shallowRef<HTMLElement[]>([])
     270         6910 : useResizeObserver(rows, syncOffsets)
     271              : 
     272         7098 : function trackRows() {
     273         7098 :   rows.value =
     274              :     syncLayout && nodeId && grid.value
     275              :       ? [...grid.value.querySelectorAll<HTMLElement>('[data-widget-name]')]
     276              :       : []
     277              : }
     278              : 
     279         6910 : onMounted(trackRows)
     280         6910 : watch(
     281              :   layoutKey,
     282              :   () => {
     283          188 :     trackRows()
     284          188 :     syncOffsets()
     285              :   },
     286              :   { flush: 'post' }
     287              : )
     288              : </script>
        

Generated by: LCOV version 2.0-1