LCOV - code coverage report
Current view: top level - src/components/searchbox - NodeSearchBoxPopover.vue Coverage Total Hit
Test: ComfyUI E2E Coverage Lines: 93.1 % 144 134
Test Date: 2026-11-17 04:17:53

            Line data    Source code
       1              : <template>
       2         2580 :   <div>
       3              :     <Dialog v-model:open="visible">
       4              :       <DialogPortal>
       5              :         <DialogOverlay />
       6              :         <DialogContent
       7              :           :class="
       8              :             cn(
       9              :               'border-0 bg-transparent p-0 shadow-none duration-100',
      10              :               useSearchBoxV2
      11              :                 ? 'w-full max-w-4xl min-w-lg overflow-visible max-md:min-w-0 sm:max-w-4xl'
      12              :                 : 'w-3/5 max-w-3xl min-w-96 sm:max-w-3xl'
      13              :             )
      14              :           "
      15              :           @pointer-down-outside="
      16              :             (e) =>
      17              :               onRekaPointerDownOutside(
      18              :                 { dismissOnPointerDownOutside: dismissable },
      19              :                 e
      20              :               )
      21              :           "
      22              :           @escape-key-down="
      23              :             (filterVisible || $event.isComposing) && $event.preventDefault()
      24              :           "
      25              :         >
      26              :           <DialogTitle class="sr-only">{{ $t('g.searchNodes') }}</DialogTitle>
      27              :           <div v-if="useSearchBoxV2" role="search" class="relative">
      28              :             <NodeSearchContent
      29              :               :filters="nodeFilters"
      30              :               @add-filter="addFilter"
      31              :               @remove-filter="removeFilter"
      32              :               @add-node="addNode"
      33              :               @hover-node="hoveredNodeDef = $event"
      34              :             />
      35              :             <NodePreviewCard
      36              :               v-if="hoveredNodeDef && enableNodePreview"
      37              :               :key="hoveredNodeDef.name"
      38              :               :node-def="hoveredNodeDef"
      39              :               :scale-factor="0.625"
      40              :               show-category-path
      41              :               inert
      42              :               class="absolute top-0 left-full ml-3"
      43              :             />
      44              :           </div>
      45              :           <NodeSearchBox
      46              :             v-else
      47              :             v-model:filter-visible="filterVisible"
      48              :             :filters="nodeFilters"
      49              :             @keydown.escape="!$event.isComposing && closeDialog()"
      50              :             @add-filter="addFilter"
      51              :             @remove-filter="removeFilter"
      52              :             @add-node="addNode"
      53              :           />
      54              :         </DialogContent>
      55              :       </DialogPortal>
      56              :     </Dialog>
      57              :   </div>
      58              : </template>
      59              : 
      60              : <script setup lang="ts">
      61              : import { useEventListener, useWindowSize } from '@vueuse/core'
      62              : import { cn } from '@comfyorg/tailwind-utils'
      63              : import { storeToRefs } from 'pinia'
      64              : import { computed, ref, toRaw, watch, watchEffect } from 'vue'
      65              : 
      66              : import { revealDynamicInputSlot } from '@/core/graph/widgets/revealDynamicInputSlot'
      67              : import type { PointTuple as Point } from '@comfyorg/shared-frontend-utils/geometry'
      68              : import { onRekaPointerDownOutside } from '@/components/dialog/dialogDismissGuards'
      69              : import Dialog from '@comfyorg/design-system/dialog/Dialog'
      70              : import DialogContent from '@comfyorg/design-system/dialog/DialogContent'
      71              : import DialogOverlay from '@comfyorg/design-system/dialog/DialogOverlay'
      72              : import DialogPortal from '@comfyorg/design-system/dialog/DialogPortal'
      73              : import DialogTitle from '@comfyorg/design-system/dialog/DialogTitle'
      74              : import type { LiteGraphCanvasEvent } from '@/lib/litegraph/src/litegraph'
      75              : import { LGraphNode, LiteGraph } from '@/lib/litegraph/src/litegraph'
      76              : import type { CanvasPointerEvent } from '@comfyorg/graph-model/events'
      77              : import { useSettingStore } from '@/platform/settings/settingStore'
      78              : import { useSurveyFeatureTracking } from '@/platform/surveys/useSurveyFeatureTracking'
      79              : import { withNodeAddSource } from '@/platform/telemetry/nodeAdded/nodeAddSource'
      80              : import { useWorkflowStore } from '@/platform/workflow/management/stores/workflowStore'
      81              : import { useCanvasStore } from '@/renderer/core/canvas/canvasStore'
      82              : import { useLitegraphService } from '@/services/litegraphService'
      83              : import type { ComfyNodeDefImpl } from '@/core/graph/nodeDef/ComfyNodeDefImpl'
      84              : import { useNodeDefStore } from '@/stores/nodeDefStore'
      85              : import { useSearchBoxStore } from '@/stores/workspace/searchBoxStore'
      86              : import { LinkReleaseTriggerAction } from '@comfyorg/settings-core/searchBoxTypes'
      87              : import type { FuseFilterWithValue } from '@/utils/fuseUtil'
      88              : 
      89              : import NodePreviewCard from '@/components/node/NodePreviewCard.vue'
      90              : 
      91              : import NodeSearchContent from './v2/NodeSearchContent.vue'
      92              : import NodeSearchBox from './NodeSearchBox.vue'
      93              : 
      94         2355 : let triggerEvent: CanvasPointerEvent | null = null
      95         2355 : let listenerController: AbortController | null = null
      96         2355 : let disconnectOnReset = false
      97              : 
      98         2355 : const settingStore = useSettingStore()
      99         2355 : const searchBoxStore = useSearchBoxStore()
     100         2355 : const litegraphService = useLitegraphService()
     101         2355 : const { trackFeatureUsed } = useSurveyFeatureTracking('node-search')
     102              : 
     103         2355 : const { visible, newSearchBoxEnabled, useSearchBoxV2 } =
     104              :   storeToRefs(searchBoxStore)
     105         2355 : const dismissable = ref(true)
     106         2355 : const filterVisible = ref(false)
     107         2355 : const hoveredNodeDef = ref<ComfyNodeDefImpl | null>(null)
     108         2355 : const { width: windowWidth } = useWindowSize()
     109              : // Minimum viewport width for the preview panel to fit beside the dialog
     110         2355 : const MIN_WIDTH_FOR_PREVIEW = 1320
     111         2355 : const enableNodePreview = computed(
     112              :   () =>
     113              :     useSearchBoxV2.value &&
     114              :     settingStore.get('Comfy.NodeSearchBoxImpl.NodePreview') &&
     115              :     windowWidth.value >= MIN_WIDTH_FOR_PREVIEW
     116              : )
     117           77 : function getNewNodeLocation(): Point {
     118           77 :   return triggerEvent
     119              :     ? [triggerEvent.canvasX, triggerEvent.canvasY]
     120              :     : litegraphService.getCanvasCenter()
     121              : }
     122         2355 : const nodeFilters = ref<FuseFilterWithValue<ComfyNodeDefImpl, string>[]>([])
     123           40 : function addFilter(filter: FuseFilterWithValue<ComfyNodeDefImpl, string>) {
     124              :   const isDuplicate = nodeFilters.value.some(
     125              :     (f) => f.filterDef.id === filter.filterDef.id && f.value === filter.value
     126              :   )
     127           40 :   if (!isDuplicate) nodeFilters.value.push(filter)
     128              : }
     129            9 : function removeFilter(filter: FuseFilterWithValue<ComfyNodeDefImpl, string>) {
     130            9 :   nodeFilters.value = nodeFilters.value.filter(
     131              :     (f) => toRaw(f) !== toRaw(filter)
     132              :   )
     133              : }
     134           82 : function clearFilters() {
     135           82 :   nodeFilters.value = []
     136           82 :   filterVisible.value = false
     137           82 :   hoveredNodeDef.value = null
     138              : }
     139              : 
     140           79 : function closeDialog() {
     141           79 :   visible.value = false
     142              : }
     143         2355 : const canvasStore = useCanvasStore()
     144              : 
     145           77 : function addNode(nodeDef: ComfyNodeDefImpl, dragEvent?: MouseEvent) {
     146           77 :   const followCursor = settingStore.get('Comfy.NodeSearchBoxImpl.FollowCursor')
     147           77 :   const node = withNodeAddSource('search_modal', () =>
     148              :     litegraphService.addNodeOnGraph(
     149              :       nodeDef,
     150              :       { pos: getNewNodeLocation() },
     151              :       { ghost: useSearchBoxV2.value && followCursor, dragEvent }
     152              :     )
     153              :   )
     154           77 :   if (!node) return
     155              : 
     156           77 :   if (disconnectOnReset && triggerEvent) {
     157            9 :     revealSlotForDroppedLink(node)
     158            9 :     canvasStore.getCanvas().linkConnector.connectToNode(node, triggerEvent)
     159           68 :   } else if (!triggerEvent) {
     160            9 :     console.warn('The trigger event was undefined when addNode was called.')
     161              :   }
     162              : 
     163           77 :   disconnectOnReset = false
     164              : 
     165              :   // Notify changeTracker - new step should be added
     166           77 :   useWorkflowStore().activeWorkflow?.changeTracker?.captureCanvasState()
     167           77 :   window.requestAnimationFrame(closeDialog)
     168              : }
     169              : 
     170          100 : function showSearchBox(e: CanvasPointerEvent | null) {
     171          100 :   if (newSearchBoxEnabled.value) {
     172          100 :     if (e?.pointerType === 'touch') {
     173            0 :       setTimeout(() => {
     174            0 :         showNewSearchBox(e)
     175              :       }, 128)
     176              :     } else {
     177          100 :       showNewSearchBox(e)
     178              :     }
     179              :   } else {
     180            0 :     canvasStore.getCanvas().showSearchBox(e)
     181              :   }
     182              : }
     183              : 
     184          138 : function getFirstLink() {
     185          138 :   return canvasStore.getCanvas().linkConnector.renderLinks.at(0)
     186              : }
     187              : 
     188              : /**
     189              :  * Node search offers nodes whose socket for the dragged type only exists under
     190              :  * an unselected DynamicCombo option. Both link-release paths -- the search box
     191              :  * and the context menu -- must ask for that option before connecting, or the
     192              :  * link is dropped with only a console warning.
     193              :  */
     194           11 : function revealSlotForDroppedLink(node: LGraphNode) {
     195           11 :   const link = getFirstLink()
     196           11 :   const droppedType = link?.fromSlot.type?.toString()
     197           11 :   if (link?.toType === 'input' && droppedType) {
     198            8 :     revealDynamicInputSlot(node, droppedType)
     199              :   }
     200              : }
     201              : 
     202         2355 : const nodeDefStore = useNodeDefStore()
     203          100 : function showNewSearchBox(e: CanvasPointerEvent | null) {
     204          100 :   trackFeatureUsed()
     205          100 :   const firstLink = getFirstLink()
     206          100 :   if (firstLink) {
     207              :     const filter =
     208              :       firstLink.toType === 'input'
     209              :         ? nodeDefStore.nodeSearchService.inputTypeFilter
     210              :         : nodeDefStore.nodeSearchService.outputTypeFilter
     211              : 
     212              :     const dataType = firstLink.fromSlot.type?.toString() ?? ''
     213           14 :     addFilter({
     214              :       filterDef: filter,
     215              :       value: dataType
     216              :     })
     217              :   }
     218              : 
     219          100 :   visible.value = true
     220          100 :   triggerEvent = e
     221              : 
     222              :   // Prevent the dialog from being dismissed immediately
     223          100 :   dismissable.value = false
     224          100 :   setTimeout(() => {
     225           92 :     dismissable.value = true
     226              :   }, 300)
     227              : }
     228              : 
     229           27 : function showContextMenu(e: CanvasPointerEvent) {
     230           27 :   const firstLink = getFirstLink()
     231           27 :   if (!firstLink) return
     232              : 
     233           27 :   const { node, fromSlot, toType } = firstLink
     234           27 :   const commonOptions = {
     235              :     e,
     236              :     allow_searchbox: true,
     237              :     showSearchBox: () => {
     238            2 :       cancelResetOnContextClose()
     239            2 :       showSearchBox(e)
     240              :     }
     241              :   }
     242           27 :   const afterRerouteId = firstLink.fromReroute?.id
     243           27 :   const connectionOptions =
     244              :     toType === 'input'
     245              :       ? { nodeFrom: node, slotFrom: fromSlot, afterRerouteId }
     246              :       : { nodeTo: node, slotTo: fromSlot, afterRerouteId }
     247              : 
     248           27 :   const canvas = canvasStore.getCanvas()
     249           27 :   const menu = canvas.showConnectionMenu({
     250              :     ...connectionOptions,
     251              :     ...commonOptions
     252              :   })
     253              : 
     254           27 :   if (!menu) {
     255            0 :     console.warn('No menu was returned from showConnectionMenu')
     256            0 :     return
     257              :   }
     258              : 
     259           27 :   triggerEvent = e
     260           27 :   listenerController = new AbortController()
     261           27 :   const { signal } = listenerController
     262           27 :   const options = { once: true, signal }
     263              : 
     264              :   // Connect the node after it is created via context menu
     265           27 :   useEventListener(
     266              :     canvas.canvas,
     267              :     'connect-new-default-node',
     268              :     (createEvent) => {
     269            2 :       if (!(createEvent instanceof CustomEvent)) {
     270            0 :         console.error('Invalid event')
     271            0 :         return
     272              :       }
     273              : 
     274            2 :       const node: unknown = createEvent.detail?.node
     275            2 :       if (!(node instanceof LGraphNode)) {
     276            0 :         console.error('Invalid node')
     277            0 :         return
     278              :       }
     279              : 
     280            2 :       disconnectOnReset = false
     281            2 :       createEvent.preventDefault()
     282            2 :       revealSlotForDroppedLink(node)
     283            2 :       canvas.linkConnector.connectToNode(node, e)
     284              :     },
     285              :     options
     286              :   )
     287              : 
     288              :   // Reset when the context menu is closed
     289           27 :   const cancelResetOnContextClose = useEventListener(
     290              :     menu.controller.signal,
     291              :     'abort',
     292              :     reset,
     293              :     options
     294              :   )
     295              : }
     296              : 
     297              : // Disable litegraph's default behavior of release link and search box.
     298         2355 : watchEffect(() => {
     299         4710 :   const { canvas } = canvasStore
     300         4710 :   if (!canvas) return
     301              : 
     302         2355 :   LiteGraph.release_link_on_empty_shows_menu = false
     303         2355 :   canvas.allow_searchbox = false
     304              : 
     305         2355 :   useEventListener(
     306              :     canvas.linkConnector.events,
     307              :     'dropped-on-canvas',
     308              :     handleDroppedOnCanvas
     309              :   )
     310              : })
     311              : 
     312          818 : function canvasEventHandler(e: LiteGraphCanvasEvent) {
     313          818 :   if (e.detail.subType === 'empty-double-click') {
     314           86 :     showSearchBox(e.detail.originalEvent)
     315          732 :   } else if (e.detail.subType === 'group-double-click') {
     316            3 :     const group = e.detail.group
     317            3 :     const [_, y] = group.pos
     318              :     const relativeY = e.detail.originalEvent.canvasY - y
     319              :     // Show search box if the click is NOT on the title bar
     320            3 :     if (relativeY > group.titleHeight) {
     321            0 :       showSearchBox(e.detail.originalEvent)
     322              :     }
     323              :   }
     324              : }
     325              : 
     326         2355 : const linkReleaseAction = computed(() =>
     327              :   settingStore.get('Comfy.LinkRelease.Action')
     328              : )
     329              : 
     330         2355 : const linkReleaseActionShift = computed(() =>
     331              :   settingStore.get('Comfy.LinkRelease.ActionShift')
     332              : )
     333              : 
     334              : // Prevent normal LinkConnector reset (called by CanvasPointer.finally)
     335           39 : function preventDefault(e: Event) {
     336           39 :   return e.preventDefault()
     337              : }
     338           39 : function cancelNextReset(e: CustomEvent<CanvasPointerEvent>) {
     339           39 :   e.preventDefault()
     340              : 
     341           39 :   const canvas = canvasStore.getCanvas()
     342           39 :   canvas.linkConnector.state.snapLinksPos = [e.detail.canvasX, e.detail.canvasY]
     343           39 :   useEventListener(canvas.linkConnector.events, 'reset', preventDefault, {
     344              :     once: true
     345              :   })
     346              : }
     347              : 
     348           46 : function handleDroppedOnCanvas(e: CustomEvent<CanvasPointerEvent>) {
     349           46 :   disconnectOnReset = true
     350              :   const action = e.detail.shiftKey
     351              :     ? linkReleaseActionShift.value
     352              :     : linkReleaseAction.value
     353           46 :   switch (action) {
     354              :     case LinkReleaseTriggerAction.SEARCH_BOX:
     355           12 :       cancelNextReset(e)
     356           12 :       showSearchBox(e.detail)
     357           12 :       break
     358              :     case LinkReleaseTriggerAction.CONTEXT_MENU:
     359           27 :       cancelNextReset(e)
     360           27 :       showContextMenu(e.detail)
     361           27 :       break
     362              :     case LinkReleaseTriggerAction.NO_ACTION:
     363              :     default:
     364              :       break
     365              :   }
     366              : }
     367              : 
     368              : // Resets litegraph state
     369           94 : function reset() {
     370           94 :   listenerController?.abort()
     371           94 :   listenerController = null
     372           94 :   triggerEvent = null
     373              : 
     374           94 :   const canvas = canvasStore.getCanvas()
     375           94 :   canvas.linkConnector.events.removeEventListener('reset', preventDefault)
     376           94 :   if (disconnectOnReset) canvas.linkConnector.disconnectLinks()
     377              : 
     378           94 :   canvas.linkConnector.reset()
     379           94 :   canvas.setDirty(true, true)
     380              : }
     381              : 
     382              : // Reset connecting links when the search box is closed
     383         2355 : watch(visible, () => {
     384          225 :   if (visible.value) return
     385           82 :   clearFilters()
     386           82 :   reset()
     387              : })
     388              : 
     389         2355 : useEventListener(document, 'litegraph:canvas', canvasEventHandler)
     390         2355 : defineExpose({ showSearchBox })
     391              : </script>
        

Generated by: LCOV version 2.0-1