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>
|