LCOV - code coverage report
Current view: top level - src/composables/graph - useSelectionState.ts Coverage Total Hit
Test: ComfyUI E2E Coverage Lines: 100.0 % 37 37
Test Date: 2026-11-17 04:17:53

            Line data    Source code
       1              : import { storeToRefs } from 'pinia'
       2              : import { computed } from 'vue'
       3              : 
       4              : import type { LGraphNode } from '@/lib/litegraph/src/litegraph'
       5              : import { SubgraphNode } from '@/lib/litegraph/src/litegraph'
       6              : import { useSettingStore } from '@/platform/settings/settingStore'
       7              : import { useCanvasStore } from '@/renderer/core/canvas/canvasStore'
       8              : import { useNodeDefStore } from '@/stores/nodeDefStore'
       9              : import { usePropertiesPanelStore } from '@/renderer/extensions/propertiesPanel/propertiesPanelStore'
      10              : import {
      11              :   isImageNode,
      12              :   isLGraphGroup,
      13              :   isLGraphNode,
      14              :   isLoad3dNode
      15              : } from '@/utils/litegraphUtil'
      16              : import { filterOutputNodes } from '@/utils/nodeFilterUtil'
      17              : 
      18              : export interface NodeSelectionState {
      19              :   collapsed: boolean
      20              :   pinned: boolean
      21              : }
      22              : 
      23              : /**
      24              :  * Centralized computed selection state + shared helper actions to avoid duplication
      25              :  * between selection toolbox, context menus, and other UI affordances.
      26              :  */
      27         4961 : export function useSelectionState() {
      28         4961 :   const canvasStore = useCanvasStore()
      29         4961 :   const nodeDefStore = useNodeDefStore()
      30         4961 :   const settingStore = useSettingStore()
      31         4961 :   const propertiesPanelStore = usePropertiesPanelStore()
      32              : 
      33         4961 :   const { selectedItems } = storeToRefs(canvasStore)
      34              : 
      35         4961 :   const selectedNodes = computed(() => {
      36        11725 :     return selectedItems.value.filter((i: unknown) => isLGraphNode(i))
      37              :   })
      38              : 
      39         4961 :   const nodeDef = computed(() => {
      40        11724 :     if (selectedNodes.value.length !== 1) return null
      41          969 :     return nodeDefStore.fromLGraphNode(selectedNodes.value[0])
      42              :   })
      43              : 
      44         4961 :   const hasAnySelection = computed(() => selectedItems.value.length > 0)
      45         4961 :   const hasSingleSelection = computed(() => selectedItems.value.length === 1)
      46         4961 :   const hasMultipleSelection = computed(() => selectedItems.value.length > 1)
      47         4961 :   const hasGroupedNodesSelection = computed(() =>
      48              :     selectedItems.value.some(
      49              :       (item) => isLGraphGroup(item) && [...item.children].some(isLGraphNode)
      50              :     )
      51              :   )
      52              : 
      53         4961 :   const isSingleNode = computed(
      54              :     () => hasSingleSelection.value && isLGraphNode(selectedItems.value[0])
      55              :   )
      56         4961 :   const isSingleSubgraph = computed(() => {
      57          171 :     const predicate: (() => boolean) | undefined =
      58              :       selectedNodes.value.at(0)?.isSubgraphNode
      59          171 :     return isSingleNode.value && (predicate?.() ?? false)
      60              :   })
      61         4961 :   const isSingleImageNode = computed(
      62              :     () =>
      63              :       isSingleNode.value && isImageNode(selectedItems.value[0] as LGraphNode)
      64              :   )
      65              : 
      66         4961 :   const hasSubgraphs = computed(() =>
      67              :     selectedItems.value.some((i: unknown) => i instanceof SubgraphNode)
      68              :   )
      69              : 
      70         4961 :   const hasAny3DNodeSelected = computed(() => {
      71          171 :     const enable3DViewer = settingStore.get('Comfy.Load3D.3DViewerEnable')
      72          171 :     return (
      73              :       selectedNodes.value.length === 1 &&
      74              :       selectedNodes.value.some(isLoad3dNode) &&
      75              :       enable3DViewer
      76              :     )
      77              :   })
      78              : 
      79         4961 :   const hasImageNode = computed(() => isSingleImageNode.value)
      80         4961 :   const hasOutputNodesSelected = computed(
      81              :     () => filterOutputNodes(selectedNodes.value).length > 0
      82              :   )
      83              : 
      84              :   // Helper function to compute selection flags (reused by both computed and function)
      85         4961 :   const computeSelectionStatesFromNodes = (
      86              :     nodes: LGraphNode[]
      87              :   ): NodeSelectionState => {
      88        13397 :     if (!nodes.length) return { collapsed: false, pinned: false }
      89         2546 :     return {
      90              :       collapsed: nodes.some((n) => n.flags.collapsed),
      91              :       pinned: nodes.some((n) => n.pinned)
      92              :     }
      93              :   }
      94              : 
      95         4961 :   const selectedNodesStates = computed<NodeSelectionState>(() =>
      96              :     computeSelectionStatesFromNodes(selectedNodes.value)
      97              :   )
      98              : 
      99              :   // On-demand computation (non-reactive) so callers can fetch fresh flags
     100         4961 :   const computeSelectionFlags = (): NodeSelectionState =>
     101              :     computeSelectionStatesFromNodes(selectedNodes.value)
     102              : 
     103         4961 :   const canOpenNodeInfo = computed(
     104              :     () => Boolean(nodeDef.value) && propertiesPanelStore.isAvailable
     105              :   )
     106              : 
     107         4961 :   const openNodeInfo = () => {
     108           11 :     if (!canOpenNodeInfo.value) return false
     109           11 :     propertiesPanelStore.openPanel('info')
     110           11 :     return true
     111              :   }
     112              : 
     113         4961 :   return {
     114              :     selectedItems,
     115              :     selectedNodes,
     116              :     nodeDef,
     117              :     canOpenNodeInfo,
     118              :     openNodeInfo,
     119              :     hasAny3DNodeSelected,
     120              :     hasAnySelection,
     121              :     hasGroupedNodesSelection,
     122              :     hasSingleSelection,
     123              :     hasMultipleSelection,
     124              :     isSingleNode,
     125              :     isSingleSubgraph,
     126              :     isSingleImageNode,
     127              :     hasSubgraphs,
     128              :     hasImageNode,
     129              :     hasOutputNodesSelected,
     130              :     selectedNodesStates,
     131              :     computeSelectionFlags
     132              :   }
     133              : }
        

Generated by: LCOV version 2.0-1