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

            Line data    Source code
       1              : <template>
       2        23836 :   <div v-if="renderError" class="node-error p-2 text-sm text-destructive">
       3              :     {{ st('nodeErrors.render', 'Node Render Error') }}
       4              :   </div>
       5              :   <div
       6              :     v-else
       7              :     tabindex="0"
       8              :     :data-node-id="nodeData.id"
       9              :     :data-collapsed="isCollapsed || undefined"
      10              :     :data-emphasized="isEmphasized || undefined"
      11              :     :data-ghost="nodeData.flags?.ghost || undefined"
      12              :     :class="
      13              :       cn(
      14              :         'group/node lg-node absolute isolate touch-none text-xs text-node-foreground',
      15              :         'flex flex-col contain-layout contain-style',
      16              :         'drop-shadow-lg outline-none',
      17              :         isRerouteNode
      18              :           ? 'h-(--node-height)'
      19              :           : 'min-h-(--node-height) min-w-(--min-node-width)',
      20              :         cursorClass,
      21              :         shouldHandleNodePointerEvents &&
      22              :           !nodeData.flags?.ghost &&
      23              :           !isGhostPlacing
      24              :           ? 'pointer-events-auto'
      25              :           : 'pointer-events-none'
      26              :       )
      27              :     "
      28              :     :style="{
      29              :       ...nodeSizeStyle,
      30              :       '--min-node-width': `${MIN_NODE_WIDTH}px`,
      31              :       transform: `translate(${position.x ?? 0}px, ${(position.y ?? 0) - LiteGraph.NODE_TITLE_HEIGHT}px)`,
      32              :       zIndex: zIndex,
      33              :       opacity: nodeOpacity
      34              :     }"
      35              :     :inert="isGhostPlacing"
      36              :     v-bind="pointerHandlers"
      37              :     @wheel="handleWheel"
      38              :     @contextmenu="handleContextMenu"
      39              :     @dragover.prevent="handleDragOver"
      40              :     @dragleave="handleDragLeave"
      41              :     @drop="handleDrop"
      42              :   >
      43              :     <NodeBadges
      44              :       v-if="!isRerouteNode && !isTransparentHeaderless"
      45              :       v-bind="badges"
      46              :       class="absolute right-0 bottom-full"
      47              :       :style="badgesStyle"
      48              :     />
      49              :     <AppOutput
      50              :       v-if="
      51              :         lgraphNode?.constructor?.nodeData?.output_node &&
      52              :         isSelectOutputsMode &&
      53              :         nodeData.mode === LGraphEventMode.ALWAYS &&
      54              :         !hasAnyError
      55              :       "
      56              :       :id="nodeId"
      57              :     />
      58              :     <div
      59              :       data-testid="node-state-outline-overlay"
      60              :       :class="
      61              :         cn(
      62              :           'pointer-events-none absolute z-0 outline-offset-2 group-focus-visible/node:block group-focus-visible/node:[outline-style:auto]',
      63              :           selectionShapeClass,
      64              :           hasAnyError ? '-inset-1.75' : '-inset-0.75',
      65              :           isEmphasized || executing ? 'block border-3' : 'hidden',
      66              :           isEmphasized ? 'border-foreground' : executing && 'border-primary'
      67              :         )
      68              :       "
      69              :     />
      70              :     <div
      71              :       :class="
      72              :         cn(
      73              :           'relative flex flex-1 flex-col',
      74              :           !isCollapsed &&
      75              :             '[contain-intrinsic-size:auto_var(--node-width)_auto_var(--node-height)] group-data-measured/node:[content-visibility:auto] group-data-measured/node:[overflow-clip-margin:16px]'
      76              :         )
      77              :       "
      78              :     >
      79              :       <div
      80              :         data-testid="node-inner-wrapper"
      81              :         :class="
      82              :           cn(
      83              :             'flex flex-1 flex-col bg-node-header',
      84              :             'w-(--node-width)',
      85              :             !isRerouteNode && 'min-w-(--min-node-width)',
      86              :             shapeClass,
      87              :             hasAnyError && 'ring-4',
      88              :             errorSeverity === 'missing' && 'ring-warning',
      89              :             errorSeverity === 'error' && 'ring-destructive',
      90              :             bypassed && bypassOverlayClass,
      91              :             muted && mutedOverlayClass,
      92              :             isDraggingOver && 'bg-primary/10 ring-4 ring-primary'
      93              :           )
      94              :         "
      95              :         :style="{
      96              :           '--node': applyLightThemeColor(nodeData.bgcolor),
      97              :           '--component-node-background': 'var(--node)',
      98              :           backgroundColor: applyLightThemeColor(nodeData?.color)
      99              :         }"
     100              :       >
     101              :         <div
     102              :           v-if="displayHeader"
     103              :           class="relative flex flex-col items-center justify-center"
     104              :         >
     105              :           <template v-if="isCollapsed">
     106              :             <SlotConnectionDot
     107              :               v-if="hasInputs"
     108              :               multi
     109              :               class="absolute left-0 -translate-x-1/2"
     110              :             />
     111              :             <SlotConnectionDot
     112              :               v-if="nodeData.outputs.length"
     113              :               multi
     114              :               class="absolute right-0 translate-x-1/2"
     115              :             />
     116              :             <NodeSlots :node-data unified />
     117              :           </template>
     118              :           <NodeHeader
     119              :             :node-data
     120              :             :collapsed="isCollapsed"
     121              :             :show-missing-warning="
     122              :               errorSeverity === 'missing' && !showErrorsTabEnabled
     123              :             "
     124              :             @collapse="handleCollapse"
     125              :             @update:title="handleHeaderTitleUpdate"
     126              :           />
     127              :         </div>
     128              : 
     129              :         <div
     130              :           v-if="isCollapsed && executing && progress !== undefined"
     131              :           :class="
     132              :             cn(
     133              :               'absolute inset-x-4 -bottom-px translate-y-1/2 rounded-full',
     134              :               progressClasses
     135              :             )
     136              :           "
     137              :           :style="{ width: `${Math.min(progress * 100, 100)}%` }"
     138              :         />
     139              : 
     140              :         <template v-if="!isCollapsed && isRerouteNode">
     141              :           <NodeSlots :node-data />
     142              :         </template>
     143              : 
     144              :         <template v-else-if="!isCollapsed">
     145              :           <div class="relative">
     146              :             <div
     147              :               v-if="executing && progress !== undefined"
     148              :               :class="
     149              :                 cn(
     150              :                   'absolute inset-x-0 top-1/2 -translate-y-1/2',
     151              :                   !!(progress < 1) && 'rounded-r-full',
     152              :                   progressClasses
     153              :                 )
     154              :               "
     155              :               :style="{ width: `${Math.min(progress * 100, 100)}%` }"
     156              :             />
     157              :           </div>
     158              : 
     159              :           <div
     160              :             :class="
     161              :               cn('flex flex-1 flex-col bg-node pt-1 pb-3', bodyRoundingClass)
     162              :             "
     163              :             :style="{ rowGap: `${NODE_CONTENT_GAP}px` }"
     164              :             :data-testid="`node-body-${nodeData.id}`"
     165              :           >
     166              :             <NodeSlots :node-data />
     167              : 
     168              :             <NodeWidgets
     169              :               v-if="hasRenderableWidgets"
     170              :               :node-data
     171              :               :processed-widget-model
     172              :             />
     173              : 
     174              :             <div
     175              :               v-if="hasCustomContent"
     176              :               :class="
     177              :                 cn(
     178              :                   'flex min-h-0 flex-col',
     179              :                   nodeMedia?.type === 'image' && hasExpandingWidget
     180              :                     ? 'shrink-0'
     181              :                     : 'flex-1'
     182              :                 )
     183              :               "
     184              :             >
     185              :               <NodeContent v-if="nodeMedia" :node-data :media="nodeMedia" />
     186              :               <template
     187              :                 v-for="preview in promotedPreviews"
     188           23 :                 :key="`${preview.sourceNodeId}-${preview.sourceWidgetName}`"
     189              :               >
     190              :                 <LivePreview
     191              :                   v-if="preview.type === 'preview'"
     192              :                   :image-url="preview.url"
     193              :                 />
     194              :                 <NodeContent v-else :node-data :media="preview" />
     195              :               </template>
     196              :             </div>
     197              :             <LivePreview
     198              :               v-if="shouldShowPreviewImg && !lgraphNode?.isSubgraphNode()"
     199              :               :image-url="latestPreviewUrl"
     200              :             />
     201              :           </div>
     202              :         </template>
     203              :       </div>
     204              :       <NodeFooter
     205              :         v-if="!isRerouteNode"
     206              :         :is-subgraph="!!lgraphNode?.isSubgraphNode()"
     207              :         :error-severity="errorSeverity"
     208              :         :show-errors-tab-enabled="showErrorsTabEnabled"
     209              :         :show-advanced-inputs-button="showAdvancedInputsButton"
     210              :         :show-advanced-state="!!nodeData.showAdvanced"
     211              :         :header-color="applyLightThemeColor(nodeData?.color)"
     212              :         :shape="nodeData.shape"
     213              :         @enter-subgraph="handleEnterSubgraph"
     214              :         @open-errors="handleOpenErrors"
     215              :         @toggle-advanced="handleToggleAdvanced"
     216              :       />
     217              :       <template
     218              :         v-if="
     219              :           !isCollapsed &&
     220              :           !isRerouteNode &&
     221              :           nodeData.resizable !== false &&
     222              :           !isSelectMode
     223              :         "
     224              :       >
     225        92332 :         <div
     226              :           v-for="handle in RESIZE_HANDLES"
     227              :           :key="handle.corner"
     228              :           role="button"
     229              :           :data-corner="handle.corner"
     230              :           :aria-label="t(handle.i18nKey)"
     231              :           :class="
     232              :             cn(
     233              :               baseResizeHandleClasses,
     234              :               handle.positionClasses,
     235              :               handle.cursorClass,
     236              :               'group-hover/node:opacity-100'
     237              :             )
     238              :           "
     239              :           @pointerdown.stop="handleResizePointerDown($event, handle.corner)"
     240              :         >
     241              :           <svg
     242              :             xmlns="http://www.w3.org/2000/svg"
     243              :             viewBox="0 0 12 12"
     244              :             :class="cn('absolute size-2/5', handle.svgPositionClasses)"
     245              :             :style="
     246              :               handle.svgTransform
     247              :                 ? { transform: handle.svgTransform }
     248              :                 : undefined
     249              :             "
     250              :           >
     251              :             <path
     252              :               d="M11 1L1 11M11 6L6 11"
     253              :               stroke="var(--color-muted-foreground)"
     254              :               stroke-width="2"
     255              :               stroke-linecap="round"
     256              :               stroke-linejoin="round"
     257              :             />
     258              :           </svg>
     259              :         </div>
     260              :       </template>
     261              :     </div>
     262              :   </div>
     263              : </template>
     264              : 
     265              : <script setup lang="ts">
     266              : import { storeToRefs } from 'pinia'
     267              : import { computed, onErrorCaptured, ref } from 'vue'
     268              : import { useI18n } from 'vue-i18n'
     269              : 
     270              : import type { NodeState } from '@comfyorg/graph-model/nodeState'
     271              : import { showNodeOptions } from '@/composables/graph/useMoreOptionsMenu'
     272              : import { useAppMode } from '@/composables/useAppMode'
     273              : import { useErrorHandling } from '@/composables/useErrorHandling'
     274              : import { hasUnpromotedWidgets } from '@/core/graph/subgraph/promotionUtils'
     275              : import { st } from '@/i18n'
     276              : import type { CompassCorners } from '@comfyorg/shared-frontend-utils/geometry'
     277              : import { LGraphEventMode, LiteGraph } from '@/lib/litegraph/src/litegraph'
     278              : import { SubgraphNode } from '@/lib/litegraph/src/subgraph/SubgraphNode'
     279              : import { TitleMode } from '@comfyorg/graph-model/globalEnums'
     280              : import { useSettingStore } from '@/platform/settings/settingStore'
     281              : import { useTelemetry } from '@comfyorg/telemetry'
     282              : import { useCanvasStore } from '@/renderer/core/canvas/canvasStore'
     283              : import { useCanvasInteractions } from '@/renderer/core/canvas/useCanvasInteractions'
     284              : import { layoutStore } from '@/renderer/core/layout/store/layoutStore'
     285              : import { useGLSLPreview } from '@/renderer/glsl/useGLSLPreview'
     286              : import { usePromotedPreviews } from '@/composables/node/usePromotedPreviews'
     287              : import NodeBadges from '@/renderer/extensions/vueNodes/components/NodeBadges.vue'
     288              : import { LayoutSource } from '@/renderer/core/layout/types'
     289              : import { removeNodeTitleHeight } from '@/renderer/core/layout/utils/nodeSizeUtil'
     290              : import AppOutput from '@/renderer/extensions/linearMode/AppOutput.vue'
     291              : import SlotConnectionDot from '@/renderer/extensions/vueNodes/components/SlotConnectionDot.vue'
     292              : import { useNodeEventHandlers } from '@/renderer/extensions/vueNodes/composables/useNodeEventHandlers'
     293              : import { useNodePointerInteractions } from '@/renderer/extensions/vueNodes/composables/useNodePointerInteractions'
     294              : import { usePartitionedBadges } from '@/renderer/extensions/vueNodes/composables/usePartitionedBadges'
     295              : import { useProcessedWidgets } from '@/renderer/extensions/vueNodes/composables/useProcessedWidgets'
     296              : import { useVueElementTracking } from '@/renderer/extensions/vueNodes/composables/useVueNodeResizeTracking'
     297              : import { useNodeExecutionState } from '@/renderer/extensions/vueNodes/execution/useNodeExecutionState'
     298              : import { useNodeLayout } from '@/renderer/extensions/vueNodes/layout/useNodeLayout'
     299              : import { useNodePreviewState } from '@/renderer/extensions/vueNodes/preview/useNodePreviewState'
     300              : import {
     301              :   shouldHideLinkedCoreLoadAudioPlayer,
     302              :   shouldHideLinkedCoreMediaInputPreview
     303              : } from '@/renderer/extensions/vueNodes/utils/linkedCoreMediaUtils'
     304              : import { nonWidgetedInputs } from '@/renderer/extensions/vueNodes/utils/nodeDataUtils'
     305              : import { getNodeErrorSeverity } from '@/renderer/extensions/vueNodes/utils/nodeErrorState'
     306              : import { shouldExpand } from '@/renderer/extensions/vueNodes/widgets/registry/widgetRegistry'
     307              : import {
     308              :   applyLightThemeColor,
     309              :   shapeVariantClass
     310              : } from '@/renderer/extensions/vueNodes/utils/nodeStyleUtils'
     311              : import { app } from '@/scripts/app'
     312              : import { useNodeOutputStore } from '@/stores/nodeOutputStore'
     313              : import { isVideoResult } from '@/utils/resultItem'
     314              : import {
     315              :   stripGraphPrefix,
     316              :   useWidgetValueStore
     317              : } from '@/stores/widgetValueStore'
     318              : import { usePropertiesPanelStore } from '@/renderer/extensions/propertiesPanel/propertiesPanelStore'
     319              : import { isNodeEmphasized } from '@/systems/nodeEmphasisSystem'
     320              : import { graphScopeOf } from '@comfyorg/graph-model/graphScopeId'
     321              : import { isVideoOutput } from '@/utils/litegraphUtil'
     322              : import {
     323              :   getNodeByLocatorId,
     324              :   locatorIdFromState
     325              : } from '@/utils/graphTraversalUtil'
     326              : import { cn } from '@comfyorg/tailwind-utils'
     327              : import { isTransparent } from '@comfyorg/shared-frontend-utils/colorUtil'
     328              : 
     329              : import { resizeNodeLayout } from '@/renderer/core/layout/operations/graphLayoutAttachment'
     330              : import { MIN_NODE_WIDTH } from '@/renderer/core/layout/transform/graphRenderTransform'
     331              : 
     332              : import { RESIZE_HANDLES } from '@/renderer/extensions/vueNodes/interactions/resize/resizeHandleConfig'
     333              : import { useNodeResize } from '@/renderer/extensions/vueNodes/interactions/resize/useNodeResize'
     334              : import LivePreview from './LivePreview.vue'
     335              : import NodeContent from './NodeContent.vue'
     336              : import NodeHeader from './NodeHeader.vue'
     337              : import NodeFooter from './NodeFooter.vue'
     338              : import NodeSlots from './NodeSlots.vue'
     339              : import NodeWidgets from './NodeWidgets.vue'
     340              : import {
     341              :   IMAGE_PREVIEW_HEIGHT_RESERVE,
     342              :   NODE_CONTENT_GAP
     343              : } from './imagePreviewLayout'
     344              : 
     345              : const { nodeData } = defineProps<{
     346              :   nodeData: NodeState
     347              : }>()
     348              : 
     349         8015 : const { t } = useI18n()
     350              : 
     351         8015 : const { isSelectMode, isSelectOutputsMode } = useAppMode()
     352         8015 : const settingStore = useSettingStore()
     353              : 
     354         8015 : const { handleNodeCollapse, handleNodeTitleUpdate, handleNodeRightClick } =
     355              :   useNodeEventHandlers()
     356              : 
     357         8015 : const nodeId = computed(() => nodeData.id)
     358              : 
     359         8015 : useVueElementTracking(nodeId.value, 'node')
     360              : 
     361         8015 : const canvasStore = useCanvasStore()
     362              : 
     363         8015 : const { isGhostPlacing } = storeToRefs(useCanvasStore())
     364         8015 : const isEmphasized = computed(() => {
     365        10421 :   const graph = canvasStore.currentGraph
     366        10421 :   return isNodeEmphasized(graph ? graphScopeOf(graph) : undefined, nodeId.value)
     367              : })
     368              : 
     369         8015 : const nodeLocatorId = computed(
     370              :   () => locatorIdFromState(nodeData, canvasStore.rootGraphId) ?? undefined
     371              : )
     372         8015 : const { executing, progress } = useNodeExecutionState(nodeLocatorId)
     373         8015 : const errorSeverity = computed(() =>
     374              :   getNodeErrorSeverity(nodeData, canvasStore.rootGraphId, lgraphNode.value)
     375              : )
     376              : 
     377         8015 : const hasAnyError = computed(() => errorSeverity.value !== 'none')
     378              : 
     379         8015 : const showErrorsTabEnabled = computed(() =>
     380              :   settingStore.get('Comfy.RightSidePanel.ShowErrorsTab')
     381              : )
     382              : 
     383         8015 : const displayHeader = computed(() => nodeData.titleMode !== TitleMode.NO_TITLE)
     384              : 
     385         8015 : const isRerouteNode = computed(() => nodeData.type === 'Reroute')
     386              : 
     387         8015 : const isCollapsed = computed(() => nodeData.flags?.collapsed ?? false)
     388         8015 : const bypassed = computed(
     389              :   (): boolean => nodeData.mode === LGraphEventMode.BYPASS
     390              : )
     391         8015 : const muted = computed((): boolean => nodeData.mode === LGraphEventMode.NEVER)
     392              : 
     393         8015 : const nodeOpacity = computed(() => {
     394         8257 :   const globalOpacity = settingStore.get('Comfy.Node.Opacity') ?? 1
     395              : 
     396         8257 :   if (nodeData.flags?.ghost) return globalOpacity * 0.6
     397              : 
     398              :   // For muted/bypassed nodes, apply the 0.5 multiplier on top of global opacity
     399         8257 :   if (bypassed.value || muted.value) {
     400           32 :     return globalOpacity * 0.5
     401              :   }
     402              : 
     403         8165 :   return globalOpacity
     404              : })
     405              : 
     406         8015 : const hasInputs = computed(() => nonWidgetedInputs(nodeData.inputs).length > 0)
     407              : 
     408              : // Use canvas interactions for proper wheel event handling and pointer event capture control
     409         8015 : const { handleWheel, shouldHandleNodePointerEvents } = useCanvasInteractions()
     410              : 
     411              : // Error boundary implementation
     412         8015 : const renderError = ref<string | null>(null)
     413         8015 : const { toastErrorHandler } = useErrorHandling()
     414              : 
     415         8015 : onErrorCaptured((error) => {
     416            0 :   renderError.value = error.message
     417            0 :   toastErrorHandler(error)
     418            0 :   return false // Prevent error propagation
     419              : })
     420              : 
     421         8015 : const { position, size, zIndex } = useNodeLayout(() => nodeData.id)
     422              : 
     423         8015 : const imagePreviewGrowth = computed(() =>
     424              :   nodeMedia.value?.type === 'image' && hasExpandingWidget.value
     425              :     ? IMAGE_PREVIEW_HEIGHT_RESERVE
     426              :     : 0
     427              : )
     428              : 
     429         8015 : const nodeSizeStyle = computed(() =>
     430              :   isCollapsed.value
     431              :     ? {}
     432              :     : {
     433              :         '--node-width': `${size.value.width}px`,
     434              :         '--node-height': `${size.value.height + LiteGraph.NODE_TITLE_HEIGHT + imagePreviewGrowth.value}px`
     435              :       }
     436              : )
     437              : 
     438         8015 : const { pointerHandlers } = useNodePointerInteractions(() => nodeData)
     439         8015 : const badges = usePartitionedBadges(nodeData)
     440              : 
     441              : // Handle right-click context menu
     442         8015 : const handleContextMenu = (event: MouseEvent) => {
     443          104 :   event.preventDefault()
     444          104 :   event.stopPropagation()
     445              : 
     446              :   // First handle the standard right-click behavior (selection)
     447          104 :   handleNodeRightClick(event, nodeData.id)
     448              : 
     449              :   // Show the node options menu at the cursor position
     450          104 :   showNodeOptions(event, { nodeId: nodeData.id })
     451              : }
     452              : 
     453         2355 : const baseResizeHandleClasses =
     454              :   'absolute h-5 w-5 opacity-0 pointer-events-auto focus-visible:outline focus-visible:outline-2 focus-visible:outline-white/40 touch-none'
     455              : 
     456         8015 : const { startResize } = useNodeResize((result) => {
     457          155 :   if (isCollapsed.value) return
     458          155 :   const node = resolveLGraphNode()
     459          155 :   if (!node) return
     460              : 
     461          155 :   resizeNodeLayout(
     462              :     node,
     463              :     {
     464              :       width: Math.max(result.size.width, MIN_NODE_WIDTH),
     465              :       height:
     466              :         removeNodeTitleHeight(result.size.height) - imagePreviewGrowth.value
     467              :     },
     468              :     {
     469              :       position: result.position,
     470              :       source: LayoutSource.Vue
     471              :     }
     472              :   )
     473              : })
     474              : 
     475         8015 : const handleResizePointerDown = (
     476              :   event: PointerEvent,
     477              :   corner: CompassCorners
     478              : ) => {
     479           25 :   if (event.button !== 0) return
     480           25 :   if (!shouldHandleNodePointerEvents.value) return
     481           25 :   if (nodeData.flags?.pinned) return
     482           25 :   if (nodeData.resizable === false) return
     483           25 :   startResize(event, corner)
     484              : }
     485              : 
     486              : // Check if node has custom content (like image/video outputs)
     487         8015 : const hasCustomContent = computed(() => {
     488         8300 :   if (promotedPreviews.value.length > 0) return true
     489         8300 :   return !!nodeMedia.value && nodeMedia.value.items.length > 0
     490              : })
     491              : 
     492              : // Computed classes and conditions for better reusability
     493         2355 : const progressClasses = 'h-2 bg-primary transition-all duration-300'
     494              : 
     495         8015 : const { latestPreviewUrl, shouldShowPreviewImg } = useNodePreviewState(
     496              :   () => nodeData.id,
     497              :   {
     498              :     isCollapsed
     499              :   }
     500              : )
     501              : 
     502         8015 : const cursorClass = computed(() => {
     503         8369 :   if (nodeData.flags?.pinned) return 'cursor-default'
     504         8369 :   return layoutStore.isDraggingVueNodes.value
     505              :     ? 'cursor-grabbing'
     506              :     : 'cursor-grab'
     507              : })
     508              : 
     509         8015 : const bodyRoundingClass = computed(() =>
     510              :   shapeVariantClass(nodeData.shape, {
     511              :     box: '',
     512              :     card: 'rounded-br-(--node-radius)',
     513              :     default: 'rounded-b-(--node-radius)'
     514              :   })
     515              : )
     516              : 
     517         8015 : const shapeClass = computed(() =>
     518              :   shapeVariantClass(nodeData.shape, {
     519              :     box: '',
     520              :     card: 'rounded-tl-(--node-radius) rounded-br-(--node-radius)',
     521              :     default: 'rounded-(--node-radius)'
     522              :   })
     523              : )
     524              : 
     525         8015 : const isTransparentHeaderless = computed(
     526              :   () =>
     527              :     !displayHeader.value &&
     528              :     !!nodeData.bgcolor &&
     529              :     isTransparent(nodeData.bgcolor)
     530              : )
     531              : 
     532         8015 : const selectionShapeClass = computed(() => {
     533         9163 :   if (isTransparentHeaderless.value) return 'border-0'
     534              : 
     535         9163 :   return shapeVariantClass(nodeData.shape, {
     536              :     box: '',
     537              :     card: hasAnyError.value
     538              :       ? 'rounded-tl-[calc(var(--node-radius)+11px)] rounded-br-[calc(var(--node-radius)+11px)]'
     539              :       : 'rounded-tl-[calc(var(--node-radius)+7px)] rounded-br-[calc(var(--node-radius)+7px)]',
     540              :     default: hasAnyError.value
     541              :       ? 'rounded-[calc(var(--node-radius)+7px)]'
     542              :       : 'rounded-[calc(var(--node-radius)+3px)]'
     543              :   })
     544              : })
     545              : 
     546         2355 : const BEFORE_OVERLAY_BASE =
     547              :   'before:pointer-events-none before:absolute before:inset-0'
     548              : 
     549         8015 : const bypassOverlayClass = computed(() =>
     550              :   shapeVariantClass(nodeData.shape, {
     551              :     box: `${BEFORE_OVERLAY_BASE} before:bg-bypass/60`,
     552              :     card: `before:rounded-tl-(--node-radius) before:rounded-br-(--node-radius) ${BEFORE_OVERLAY_BASE} before:bg-bypass/60`,
     553              :     default: `before:rounded-(--node-radius) ${BEFORE_OVERLAY_BASE} before:bg-bypass/60`
     554              :   })
     555              : )
     556              : 
     557         8015 : const mutedOverlayClass = computed(() =>
     558              :   shapeVariantClass(nodeData.shape, {
     559              :     box: BEFORE_OVERLAY_BASE,
     560              :     card: `before:rounded-tl-(--node-radius) before:rounded-br-(--node-radius) ${BEFORE_OVERLAY_BASE}`,
     561              :     default: `before:rounded-(--node-radius) ${BEFORE_OVERLAY_BASE}`
     562              :   })
     563              : )
     564              : 
     565              : // Event handlers
     566         8015 : const handleCollapse = () => {
     567           20 :   handleNodeCollapse(nodeData.id, !isCollapsed.value)
     568              : }
     569              : 
     570         8015 : const handleHeaderTitleUpdate = (newTitle: string) => {
     571            4 :   handleNodeTitleUpdate(nodeData.id, newTitle)
     572              : }
     573              : 
     574         8015 : const propertiesPanelStore = usePropertiesPanelStore()
     575              : 
     576         8015 : const handleOpenErrors = () => {
     577            0 :   propertiesPanelStore.openPanel('errors')
     578              : }
     579              : 
     580         8015 : const handleToggleAdvanced = () => {
     581            6 :   const node = resolveLGraphNode()
     582            6 :   if (!node) return
     583              : 
     584              :   // A subgraph node has no advanced section of its own; the side panel hosts it.
     585            6 :   if (node instanceof SubgraphNode) {
     586            0 :     if (propertiesPanelStore.isOpen) propertiesPanelStore.closePanel()
     587            0 :     else propertiesPanelStore.focusSection('advanced-inputs')
     588            0 :     return
     589              :   }
     590            6 :   node.showAdvanced = !node.showAdvanced
     591              : }
     592              : 
     593         8015 : const handleEnterSubgraph = () => {
     594           74 :   useTelemetry()?.trackUiButtonClicked({
     595              :     button_id: 'graph_node_open_subgraph_clicked',
     596              :     element_group: 'graph_node'
     597              :   })
     598           74 :   const graph = app.rootGraph
     599           74 :   if (!graph) {
     600            0 :     console.warn('LGraphNode: No graph available for subgraph navigation')
     601            0 :     return
     602              :   }
     603              : 
     604           74 :   const locatorId = nodeLocatorId.value
     605           74 :   if (!locatorId) return
     606              : 
     607           74 :   const litegraphNode = getNodeByLocatorId(graph, locatorId)
     608              : 
     609           74 :   if (!litegraphNode?.isSubgraphNode() || !('subgraph' in litegraphNode)) {
     610            0 :     console.warn('LGraphNode: Node is not a valid subgraph node', litegraphNode)
     611            0 :     return
     612              :   }
     613              : 
     614           74 :   const canvas = app.canvas
     615           74 :   if (!canvas || typeof canvas.openSubgraph !== 'function') {
     616            0 :     console.warn('LGraphNode: Canvas or openSubgraph method not available')
     617            0 :     return
     618              :   }
     619              : 
     620           74 :   canvas.openSubgraph(litegraphNode.subgraph, litegraphNode)
     621              : }
     622              : 
     623         8015 : const nodeOutputs = useNodeOutputStore()
     624              : 
     625         8192 : function resolveLGraphNode() {
     626         8192 :   const locatorId = nodeLocatorId.value
     627         8192 :   if (!locatorId) return null
     628              : 
     629         8192 :   return getNodeByLocatorId(app.rootGraph, locatorId)
     630              : }
     631              : 
     632         8015 : const lgraphNode = computed(resolveLGraphNode)
     633              : 
     634              : // TODO: Surface subgraph info more cleanly in NodeState instead of
     635              : // reaching through lgraphNode for promoted preview resolution.
     636         8015 : const { promotedPreviews } = usePromotedPreviews(lgraphNode)
     637              : 
     638         8015 : const { hideExecutedOutput } = useGLSLPreview(lgraphNode)
     639              : 
     640         8015 : const widgetValueStore = useWidgetValueStore()
     641         8015 : const widgetIds = computed(() => {
     642         8250 :   const graphId = canvasStore.rootGraphId
     643         8250 :   const bareNodeId = stripGraphPrefix(nodeData.id)
     644         8250 :   if (!graphId || !bareNodeId) return []
     645              : 
     646         8250 :   return widgetValueStore.getNodeWidgetIds(graphId, bareNodeId) ?? []
     647              : })
     648              : 
     649         8015 : const renderedWidgetIds = computed(() => {
     650         8271 :   const node = lgraphNode.value
     651         8271 :   if (!node || !shouldHideLinkedCoreLoadAudioPlayer(node))
     652         8265 :     return widgetIds.value
     653              : 
     654            6 :   return widgetIds.value.filter((id) => {
     655           18 :     const widget = widgetValueStore.getWidget(id)
     656           18 :     return widget?.name !== 'audioUI' || widget.type !== 'audioUI'
     657              :   })
     658              : })
     659              : 
     660         8015 : const hasRenderableWidgets = computed(() => renderedWidgetIds.value.length > 0)
     661         8015 : const { canSelectInputs, nodeType, processedWidgets } = useProcessedWidgets(
     662              :   () => nodeData,
     663              :   () => renderedWidgetIds.value
     664              : )
     665         8015 : const processedWidgetModel = computed(() => ({
     666              :   processedWidgets: processedWidgets.value,
     667              :   nodeType: nodeType.value,
     668              :   canSelectInputs: canSelectInputs.value
     669              : }))
     670         8015 : const hasExpandingWidget = computed(() =>
     671              :   processedWidgets.value.some(
     672              :     (widget) => widget.visible && shouldExpand(widget.simplified.type)
     673              :   )
     674              : )
     675              : 
     676         8015 : const showAdvancedInputsButton = computed(() => {
     677         8317 :   const node = lgraphNode.value
     678         8317 :   if (!node) return false
     679         8317 :   if (isCollapsed.value) return false
     680         8315 :   if (node instanceof SubgraphNode) {
     681          309 :     return hasUnpromotedWidgets(node)
     682              :   }
     683              : 
     684         7983 :   const hasAdvancedWidgets = widgetIds.value.some((id) => {
     685        17554 :     const visibility = widgetValueStore.getWidgetVisibility(id)
     686        17554 :     if (visibility) return visibility.surfaces.vueNode === 'advanced'
     687        17554 :     return widgetValueStore.getWidget(id)?.options?.advanced
     688              :   })
     689         7983 :   const alwaysShowAdvanced = settingStore.get(
     690              :     'Comfy.Node.AlwaysShowAdvancedWidgets'
     691              :   )
     692         8317 :   return hasAdvancedWidgets && !alwaysShowAdvanced
     693              : })
     694              : 
     695         8015 : const hasVideoInput = computed(() =>
     696              :   nodeData.inputs.some((input) => input.type === 'VIDEO')
     697              : )
     698              : 
     699         8015 : const VIDEO_PREVIEW_WIDGET_TYPES = new Set(['videoedit', 'videoconcat'])
     700              : 
     701         8015 : const hasVideoPreviewWidget = computed(() =>
     702              :   widgetIds.value.some((id) =>
     703              :     VIDEO_PREVIEW_WIDGET_TYPES.has(widgetValueStore.getWidget(id)?.type ?? '')
     704              :   )
     705              : )
     706              : 
     707         8015 : const nodeMedia = computed(() => {
     708         8671 :   const node = lgraphNode.value
     709         8671 :   if (!node || node.hideOutputImages || hideExecutedOutput.value)
     710           90 :     return undefined
     711         8671 :   if (node instanceof SubgraphNode) return undefined
     712              : 
     713         8310 :   const outputs = nodeOutputs.getNodeOutputs(node)
     714         8671 :   if (!outputs?.images?.length) return undefined
     715              : 
     716         2013 :   if (shouldHideLinkedCoreMediaInputPreview(node, outputs)) return undefined
     717              : 
     718         8671 :   const type =
     719              :     isVideoOutput(outputs) ||
     720              :     node.previewMediaType === 'video' ||
     721              :     (!node.previewMediaType && hasVideoInput.value)
     722              :       ? 'video'
     723              :       : 'image'
     724              : 
     725         8671 :   if (type === 'video' && hasVideoPreviewWidget.value) return undefined
     726              : 
     727          271 :   const items = nodeOutputs
     728              :     .getNodeOutputItems(node, outputs)
     729              :     .filter((item) =>
     730              :       type === 'video' ? isVideoResult(item) : item.mediaType === 'images'
     731              :     )
     732         1605 :   if (!items.length) return undefined
     733              : 
     734          270 :   return { type, items } as const
     735              : })
     736              : 
     737              : // Drag and drop support
     738         8015 : const isDraggingOver = ref(false)
     739              : 
     740         8015 : const badgesStyle = computed(() => ({
     741              :   marginBottom: `${4 + (hasAnyError.value || isDraggingOver.value ? 4 : 0) + (isEmphasized.value || executing.value ? 3 : 0)}px`
     742              : }))
     743              : 
     744            8 : function handleDragOver(event: DragEvent) {
     745            8 :   const node = resolveLGraphNode()
     746            8 :   if (!node || !node.onDragOver) {
     747            2 :     isDraggingOver.value = false
     748            2 :     return
     749              :   }
     750              : 
     751              :   // Call the litegraph node's onDragOver callback to check if files are valid
     752            6 :   const canDrop = node.onDragOver(event)
     753            6 :   isDraggingOver.value = canDrop
     754              : }
     755              : 
     756            0 : function handleDragLeave() {
     757            0 :   isDraggingOver.value = false
     758              : }
     759              : 
     760            8 : function handleDrop(event: DragEvent) {
     761            8 :   isDraggingOver.value = false
     762            8 :   app.dragOverNode = event.defaultPrevented ? null : resolveLGraphNode()
     763              : }
     764              : </script>
        

Generated by: LCOV version 2.0-1