LCOV - code coverage report
Current view: top level - src/renderer/extensions/vueNodes/widgets/components/form/dropdown - FormDropdown.vue Coverage Total Hit
Test: ComfyUI E2E Coverage Lines: 84.7 % 124 105
Test Date: 2026-11-17 04:17:53

            Line data    Source code
       1           16 : <script setup lang="ts">
       2              : import {
       3              :   computedAsync,
       4              :   refDebounced,
       5              :   unrefElement,
       6              :   useEventListener
       7              : } from '@vueuse/core'
       8              : import { PopoverAnchor, PopoverRoot } from 'reka-ui'
       9              : import type { ComponentPublicInstance } from 'vue'
      10              : import { computed, ref, useTemplateRef } from 'vue'
      11              : import { useI18n } from 'vue-i18n'
      12              : 
      13              : import PopoverContent from '@comfyorg/design-system/popover/PopoverContent'
      14              : import { usePopoverViewportDismiss } from '@comfyorg/design-system/lib/popover/usePopoverViewportDismiss'
      15              : import { useToast } from '@/components/ui/toast/toastStore'
      16              : import { useDismissOnCanvasGesture } from '@/renderer/extensions/vueNodes/widgets/composables/useDismissOnCanvasGesture'
      17              : 
      18              : import type {
      19              :   FilterOption,
      20              :   OwnershipFilterOption,
      21              :   OwnershipOption
      22              : } from '@/platform/assets/types/filterTypes'
      23              : import { isPaged, pagedItems, WrappedList } from '@/utils/pagedList'
      24              : import type { MaybePaged } from '@/utils/pagedList'
      25              : 
      26              : import FormDropdownInput from './FormDropdownInput.vue'
      27              : import FormDropdownMenu from './FormDropdownMenu.vue'
      28              : import {
      29              :   DROPDOWN_PANEL_CLASS,
      30              :   defaultSearcher,
      31              :   getDefaultSortOptions
      32              : } from './shared'
      33              : import type { FormDropdownItem, LayoutMode, SortOption } from './types'
      34              : 
      35              : interface Props {
      36              :   inputId?: string
      37              :   items: MaybePaged<FormDropdownItem>
      38              :   placeholder?: string
      39              :   /**
      40              :    * If true, allows multiple selections. If a number is provided,
      41              :    * it specifies the maximum number of selections allowed.
      42              :    */
      43              :   multiple?: boolean | number
      44              : 
      45              :   uploadable?: boolean
      46              :   disabled?: boolean
      47              :   accept?: string
      48              :   filterOptions?: FilterOption[]
      49              :   sortOptions?: SortOption[]
      50              :   showOwnershipFilter?: boolean
      51              :   ownershipOptions?: OwnershipFilterOption[]
      52              :   showBaseModelFilter?: boolean
      53              :   baseModelOptions?: FilterOption[]
      54              :   isSelected?: (
      55              :     selected: Set<string>,
      56              :     item: FormDropdownItem,
      57              :     index: number
      58              :   ) => boolean
      59              :   isUploading?: boolean
      60              :   searcher?: (
      61              :     query: string,
      62              :     items: readonly FormDropdownItem[],
      63              :     onCleanup: (cleanupFn: () => void) => void
      64              :   ) => Promise<readonly FormDropdownItem[]>
      65              : }
      66              : 
      67          847 : const { t } = useI18n()
      68              : 
      69              : const {
      70              :   placeholder,
      71              :   multiple = false,
      72              :   uploadable = false,
      73              :   disabled = false,
      74              :   accept,
      75              :   filterOptions = [],
      76              :   sortOptions = getDefaultSortOptions(),
      77              :   showOwnershipFilter,
      78              :   ownershipOptions,
      79              :   showBaseModelFilter,
      80              :   baseModelOptions,
      81              :   isSelected = (selected, item, _index) => selected.has(item.id),
      82              :   searcher = defaultSearcher,
      83              :   items
      84              : } = defineProps<Props>()
      85              : 
      86          197 : const placeholderText = computed(
      87              :   () => placeholder ?? t('widgets.uploadSelect.placeholder')
      88              : )
      89              : 
      90          197 : const selected = defineModel<Set<string>>('selected', {
      91              :   default: () => new Set()
      92              : })
      93          197 : const filterSelected = defineModel<string>('filterSelected', { default: '' })
      94          197 : const sortSelected = defineModel<string>('sortSelected', {
      95              :   default: 'default'
      96              : })
      97          197 : const layoutMode = defineModel<LayoutMode>('layoutMode', {
      98              :   default: 'grid'
      99              : })
     100          197 : const files = defineModel<File[]>('files', { default: () => [] })
     101          197 : const searchQuery = defineModel<string>('searchQuery', { default: '' })
     102          197 : const ownershipSelected = defineModel<OwnershipOption>('ownershipSelected', {
     103              :   default: 'all'
     104              : })
     105          197 : const baseModelSelected = defineModel<Set<string>>('baseModelSelected', {
     106              :   default: () => new Set()
     107              : })
     108          197 : const isOpen = defineModel<boolean>('isOpen', { default: false })
     109              : 
     110          197 : const toast = useToast()
     111          197 : const triggerAnchorRef = useTemplateRef<HTMLElement>('triggerAnchorRef')
     112          197 : const menuRef = useTemplateRef<ComponentPublicInstance>('menuRef')
     113          197 : const triggerRef =
     114              :   useTemplateRef<InstanceType<typeof FormDropdownInput>>('triggerRef')
     115          197 : const displayedSearchQuery = ref('')
     116          197 : const isFiltering = ref(false)
     117              : 
     118          197 : const maxSelectable = computed(() => {
     119          197 :   if (multiple === true) return Infinity
     120          197 :   if (typeof multiple === 'number') return multiple
     121          197 :   return 1
     122              : })
     123          197 : const isSingleSelect = computed(() => maxSelectable.value === 1)
     124              : 
     125          197 : const debouncedSearchQuery = refDebounced(searchQuery, 250, { maxWait: 1000 })
     126              : 
     127          197 : const filteredItems = computedAsync(
     128              :   async (onCancel) => {
     129          548 :     if (!isOpen.value) {
     130          539 :       displayedSearchQuery.value = ''
     131          539 :       return pagedItems(items).slice()
     132              :     }
     133              : 
     134            9 :     const query = debouncedSearchQuery.value
     135            9 :     let cancelled = false
     136            9 :     let cleanupFn: (() => void) | undefined
     137            9 :     onCancel(() => {
     138            0 :       cancelled = true
     139            0 :       cleanupFn?.()
     140              :     })
     141              : 
     142            9 :     const result = await searcher(query, pagedItems(items).slice(), (cb) => {
     143            0 :       cleanupFn = cb
     144              :     })
     145            9 :     if (!cancelled) displayedSearchQuery.value = query
     146            9 :     return result
     147              :   },
     148              :   pagedItems(items).slice(),
     149              :   {
     150              :     evaluating: isFiltering
     151              :   }
     152              : )
     153              : 
     154          197 : const defaultSorter = computed<SortOption['sorter']>(() => {
     155              :   const sorter = sortOptions.find((option) => option.id === 'default')?.sorter
     156            8 :   return sorter || (({ items: i }) => i.slice())
     157              : })
     158          197 : const selectedSorter = computed<SortOption['sorter']>(() => {
     159            8 :   if (sortSelected.value === 'default') return defaultSorter.value
     160              :   const sorter = sortOptions.find(
     161              :     (option) => option.id === sortSelected.value
     162              :   )?.sorter
     163            8 :   return sorter || defaultSorter.value
     164              : })
     165          197 : const sortedItems = computed(() => {
     166           17 :   if (!isOpen.value) {
     167            0 :     return pagedItems(items).slice()
     168              :   }
     169              : 
     170           17 :   return selectedSorter.value({ items: filteredItems.value }) || []
     171              : })
     172          197 : const isShowingCurrentSearchResults = computed(
     173              :   () =>
     174              :     isOpen.value &&
     175              :     isSingleSelect.value &&
     176              :     !isFiltering.value &&
     177              :     searchQuery.value.trim() !== '' &&
     178              :     displayedSearchQuery.value === searchQuery.value &&
     179              :     sortedItems.value.length > 0
     180              : )
     181              : 
     182          197 : const candidateIndex = computed(() =>
     183              :   isShowingCurrentSearchResults.value ? 0 : -1
     184              : )
     185          197 : const candidateLabel = computed(() => {
     186           17 :   const candidate = sortedItems.value[candidateIndex.value]
     187           17 :   return candidate?.label ?? candidate?.name
     188              : })
     189              : 
     190         2365 : function internalIsSelected(item: FormDropdownItem, index: number): boolean {
     191         2365 :   return isSelected(selected.value, item, index)
     192              : }
     193              : 
     194          197 : const toggleDropdown = () => {
     195            8 :   if (disabled) return
     196            8 :   isOpen.value = !isOpen.value
     197              : }
     198              : 
     199           17 : function focusTrigger() {
     200           17 :   triggerRef.value?.focus()
     201              : }
     202              : 
     203          197 : const closeDropdown = ({ restoreFocus = false } = {}) => {
     204            5 :   isOpen.value = false
     205              : 
     206            5 :   if (restoreFocus) focusTrigger()
     207              : }
     208              : 
     209          197 : useEventListener(
     210              :   window,
     211              :   'pointerdown',
     212              :   (event) => {
     213          369 :     if (!isOpen.value) return
     214            5 :     const menuEl = unrefElement(menuRef)
     215            5 :     const triggerEl = triggerAnchorRef.value
     216            5 :     const path = event.composedPath()
     217          369 :     if (menuEl && path.includes(menuEl)) return
     218          369 :     if (triggerEl && path.includes(triggerEl)) return
     219            0 :     if (path.some(isInsideDropdownPanel)) return
     220            0 :     closeDropdown()
     221              :   },
     222              :   { capture: true }
     223              : )
     224              : 
     225            0 : function isInsideDropdownPanel(target: EventTarget): boolean {
     226            0 :   return (
     227              :     target instanceof HTMLElement &&
     228              :     target.classList.contains(DROPDOWN_PANEL_CLASS)
     229              :   )
     230              : }
     231              : 
     232          197 : useDismissOnCanvasGesture(isOpen, () => closeDropdown())
     233              : 
     234          197 : usePopoverViewportDismiss(isOpen, triggerAnchorRef)
     235              : 
     236           17 : function handleFileChange(event: Event) {
     237           17 :   if (disabled) return
     238           17 :   const target = event.target
     239           17 :   if (!(target instanceof HTMLInputElement)) return
     240           17 :   if (target.files) {
     241           17 :     files.value = Array.from(target.files)
     242              :   }
     243           17 :   target.value = ''
     244              : }
     245              : 
     246            5 : function handleSelection(item: FormDropdownItem, index: number) {
     247            5 :   if (disabled) return
     248            5 :   const itemIsSelected = internalIsSelected(item, index)
     249            5 :   if (isSingleSelect.value && itemIsSelected) {
     250            3 :     closeDropdown({ restoreFocus: true })
     251            3 :     return
     252              :   }
     253              : 
     254            2 :   const sel = selected.value
     255            2 :   if (itemIsSelected) {
     256            0 :     sel.delete(item.id)
     257              :   } else {
     258            2 :     if (sel.size < maxSelectable.value) {
     259            2 :       sel.add(item.id)
     260            0 :     } else if (maxSelectable.value === 1) {
     261            0 :       sel.clear()
     262            0 :       sel.add(item.id)
     263              :     } else {
     264            0 :       toast.warning(t('widgets.uploadSelect.maxSelectionReached'))
     265            0 :       return
     266              :     }
     267              :   }
     268            2 :   selected.value = new Set(sel)
     269              : 
     270            2 :   if (isSingleSelect.value) {
     271            2 :     closeDropdown({ restoreFocus: true })
     272              :   }
     273              : }
     274              : 
     275            1 : async function getTopSearchResult() {
     276            1 :   const query = searchQuery.value
     277            1 :   if (query.trim() === '') return
     278              : 
     279            1 :   const sourceItems = pagedItems(items)
     280            1 :   const matches =
     281              :     isShowingCurrentSearchResults.value && displayedSearchQuery.value === query
     282              :       ? filteredItems.value
     283              :       : await searcher(query, sourceItems.slice(), () => {})
     284              : 
     285            1 :   if (
     286              :     query !== searchQuery.value ||
     287              :     sourceItems !== pagedItems(items) ||
     288              :     !isOpen.value
     289              :   ) {
     290            0 :     return
     291              :   }
     292              : 
     293            1 :   return selectedSorter.value({ items: matches })[0]
     294              : }
     295              : 
     296            1 : async function selectTopSearchResult() {
     297            1 :   try {
     298            1 :     if (disabled || !isOpen.value || !isSingleSelect.value) return
     299            1 :     const topResult = await getTopSearchResult()
     300            1 :     if (!topResult) return
     301            1 :     handleSelection(topResult, 0)
     302              :   } catch (error) {
     303            0 :     console.error('[FormDropdown] search selection failed', error)
     304              :   }
     305              : }
     306              : 
     307            1 : function handleSearchEnter() {
     308            1 :   void selectTopSearchResult()
     309              : }
     310              : 
     311            0 : function showPicker() {
     312            0 :   triggerRef.value!.showPicker()
     313            0 :   closeDropdown()
     314              : }
     315          197 : const dropdownItems = computed(() =>
     316              :   isPaged(items)
     317              :     ? new WrappedList(items, () => sortedItems.value)
     318              :     : sortedItems.value
     319              : )
     320          197 : </script>
     321              : 
     322              : <template>
     323          608 :   <div ref="triggerAnchorRef">
     324              :     <PopoverRoot v-model:open="isOpen">
     325              :       <FormDropdownInput
     326              :         ref="triggerRef"
     327              :         :input-id
     328              :         :files
     329              :         :is-open
     330              :         :placeholder="placeholderText"
     331              :         :selected-items="pagedItems(items).filter(internalIsSelected)"
     332              :         :max-selectable
     333              :         :uploadable
     334              :         :disabled
     335              :         :accept
     336              :         :is-uploading
     337              :         @select-click="toggleDropdown"
     338              :         @file-change="handleFileChange"
     339              :       >
     340              :         <template #anchor="{ element }">
     341              :           <PopoverAnchor as="template" :reference="element" />
     342              :         </template>
     343              :       </FormDropdownInput>
     344              :       <PopoverContent
     345              :         align="end"
     346              :         class="pointer-events-auto w-auto rounded-lg border-none bg-transparent p-0 pt-2 shadow-lg data-[state=closed]:animate-none data-[state=open]:animate-none"
     347              :         @interact-outside.prevent
     348              :         @close-auto-focus.prevent="focusTrigger"
     349              :       >
     350              :         <FormDropdownMenu
     351              :           ref="menuRef"
     352              :           v-model:filter-selected="filterSelected"
     353              :           v-model:layout-mode="layoutMode"
     354              :           v-model:sort-selected="sortSelected"
     355              :           v-model:search-query="searchQuery"
     356              :           v-model:ownership-selected="ownershipSelected"
     357              :           v-model:base-model-selected="baseModelSelected"
     358              :           :uploadable
     359              :           :filter-options
     360              :           :sort-options
     361              :           :show-ownership-filter
     362              :           :ownership-options
     363              :           :show-base-model-filter
     364              :           :base-model-options
     365              :           :disabled
     366              :           :items="dropdownItems"
     367              :           :candidate-index
     368              :           :candidate-label
     369              :           :is-selected="internalIsSelected"
     370              :           :max-selectable
     371              :           @close="closeDropdown"
     372              :           @search-enter="handleSearchEnter"
     373              :           @item-click="handleSelection"
     374              :           @show-picker="showPicker"
     375              :         />
     376              :       </PopoverContent>
     377              :     </PopoverRoot>
     378              :   </div>
     379              : </template>
        

Generated by: LCOV version 2.0-1