Line data Source code
1 : <template>
2 5024 : <ContextMenu :model="menuItems" @close-auto-focus.prevent>
3 : <UiTree
4 : v-bind="$attrs"
5 : v-model:expanded="expandedNodeKeys"
6 : v-model:selected="selectedNode"
7 : :class="cn('tree-explorer px-2', className)"
8 : :items="renderedRoot.children ?? []"
9 : :get-key="(node) => node.key"
10 : :get-children="(node) => (node.leaf ? undefined : (node.children ?? []))"
11 : @pointerdown.capture="menuTargetNode = null"
12 : @contextmenu.capture="menuTargetNode = null"
13 : >
14 : <template #default="{ flattenItems }">
15 22404 : <UiTreeItem
16 : v-for="item in flattenItems"
17 : v-slot="{ isHovered }"
18 : :key="item._id"
19 : class="tree-explorer-item"
20 : :value="item.value"
21 : :level="item.level"
22 : :aria-label="item.value.label"
23 : :data-parent-label="item.parentItem?.label"
24 : :data-tree-node-type="item.value.type"
25 : @select="preventUnboundSelection"
26 : @click="onNodeContentClick($event, item.value)"
27 : @contextmenu="handleContextMenu($event, item.value)"
28 : >
29 : <span class="relative size-4 shrink-0">
30 : <i
31 : :class="
32 : cn(
33 : item.value.icon,
34 : 'tree-explorer-node-icon text-muted-foreground'
35 : )
36 : "
37 : :style="{ color: item.value.iconColor }"
38 : />
39 : <span
40 : v-if="item.value.iconImage"
41 : data-testid="tree-node-icon-image"
42 : class="absolute inset-0 rounded-xs bg-cover bg-center"
43 : :style="{ backgroundImage: `url(${item.value.iconImage})` }"
44 : />
45 : </span>
46 : <div class="flex min-w-0 flex-1 items-center">
47 : <slot
48 : v-if="item.value.type === 'folder'"
49 : name="folder"
50 : :node="item.value"
51 : >
52 : <TreeExplorerTreeNode :node="item.value" />
53 : </slot>
54 : <slot v-else name="node" :node="item.value">
55 : <TreeExplorerTreeNode :node="item.value" />
56 : </slot>
57 : </div>
58 : <div
59 : v-if="isHovered && item.value.leaf && $slots.preview"
60 : ref="preview"
61 : data-testid="tree-item-preview"
62 : class="pointer-events-none fixed z-1"
63 : :style="previewStyle"
64 : >
65 : <slot name="preview" :node="item.value" />
66 : </div>
67 : </UiTreeItem>
68 : </template>
69 : </UiTree>
70 : </ContextMenu>
71 : </template>
72 : <script setup lang="ts" generic="T">
73 : import { useElementBounding, useElementSize, useWindowSize } from '@vueuse/core'
74 : import { computed, provide, shallowRef, useTemplateRef } from 'vue'
75 : import { useI18n } from 'vue-i18n'
76 :
77 : import TreeExplorerTreeNode from '@/components/common/TreeExplorerTreeNode.vue'
78 : import ContextMenu from '@comfyorg/design-system/menu/ContextMenu'
79 : import type {
80 : MenuItem,
81 : MenuItemCommandEvent
82 : } from '@comfyorg/design-system/lib/menu/types'
83 : import UiTree from '@comfyorg/design-system/tree/Tree'
84 : import UiTreeItem from '@comfyorg/design-system/tree/TreeItem'
85 : import { useTreeFolderOperations } from '@/composables/tree/useTreeFolderOperations'
86 : import { useErrorHandling } from '@/composables/useErrorHandling'
87 : import { useSettingStore } from '@/platform/settings/settingStore'
88 : import {
89 : InjectKeyExpandedKeys,
90 : InjectKeyHandleEditLabelFunction
91 : } from '@/types/treeExplorerTypes'
92 : import type {
93 : RenderedTreeExplorerNode,
94 : TreeExplorerNode
95 : } from '@/types/treeExplorerTypes'
96 : import { combineTrees, findNodeByKey } from '@/utils/treeUtil'
97 : import { cn } from '@comfyorg/tailwind-utils'
98 :
99 : defineOptions({
100 : inheritAttrs: false
101 : })
102 :
103 369 : const expandedKeys = defineModel<Record<string, boolean>>('expandedKeys', {
104 : required: true
105 : })
106 369 : provide(InjectKeyExpandedKeys, expandedKeys)
107 369 : const selectionKeys = defineModel<Record<string, boolean>>('selectionKeys')
108 : // Tracks whether the caller has set the selectionKeys model.
109 369 : const storeSelectionKeys = selectionKeys.value !== undefined
110 :
111 140 : function preventUnboundSelection(event: Event) {
112 140 : if (!storeSelectionKeys) event.preventDefault()
113 : }
114 :
115 : const { root, class: className } = defineProps<{
116 : root: TreeExplorerNode<T>
117 : class?: string
118 : }>()
119 369 : const emit = defineEmits<{
120 : (e: 'nodeClick', node: RenderedTreeExplorerNode<T>, event: MouseEvent): void
121 : (e: 'nodeDelete', node: RenderedTreeExplorerNode<T>): void
122 : (e: 'contextMenu', node: RenderedTreeExplorerNode<T>, event: MouseEvent): void
123 : }>()
124 :
125 369 : const {
126 : newFolderNode,
127 : getAddFolderMenuItem,
128 : handleFolderCreation,
129 : addFolderCommand
130 : } = useTreeFolderOperations<T>(
131 : /* expandNode */ (node: TreeExplorerNode<T>) => {
132 2 : expandedKeys.value = { ...expandedKeys.value, [node.key]: true }
133 : }
134 : )
135 :
136 369 : const renderedRoot = computed<RenderedTreeExplorerNode<T>>(() => {
137 5043 : const renderedRoot = fillNodeInfo(root)
138 5043 : return newFolderNode.value
139 : ? combineTrees(renderedRoot, newFolderNode.value)
140 : : renderedRoot
141 : })
142 369 : const expandedNodeKeys = computed({
143 : get: () =>
144 : Object.entries(expandedKeys.value)
145 : .filter(([, expanded]) => expanded)
146 : .map(([key]) => key),
147 : set: (keys: string[]) => {
148 0 : expandedKeys.value = Object.fromEntries(keys.map((key) => [key, true]))
149 : }
150 : })
151 369 : const selectedNode = computed({
152 : get: () => {
153 4454 : const key = Object.keys(selectionKeys.value ?? {}).find(
154 : (key) => selectionKeys.value?.[key]
155 : )
156 4454 : return key
157 : ? (findNodeByKey(renderedRoot.value, key) ?? undefined)
158 : : undefined
159 : },
160 : set: (node: RenderedTreeExplorerNode<T> | undefined) => {
161 354 : selectionKeys.value = node ? { [node.key]: true } : {}
162 : }
163 : })
164 369 : const getTreeNodeIcon = (node: TreeExplorerNode<T>) => {
165 1144256 : if (node.getIcon) {
166 1136610 : const icon = node.getIcon()
167 1136610 : if (icon) {
168 914226 : return icon
169 : }
170 7646 : } else if (node.icon) {
171 0 : return node.icon
172 : }
173 :
174 1143662 : if (node.leaf) {
175 3676 : return 'icon-[lucide--file]'
176 : }
177 : const isExpanded = expandedKeys.value?.[node.key] ?? false
178 1144256 : return isExpanded ? 'icon-[lucide--folder-open]' : 'icon-[lucide--folder]'
179 : }
180 369 : const fillNodeInfo = (
181 : node: TreeExplorerNode<T>
182 : ): RenderedTreeExplorerNode<T> => {
183 1144256 : const children = node.children?.map(fillNodeInfo) ?? []
184 1144256 : const totalLeaves = node.leaf
185 : ? 1
186 : : children.reduce((acc, child) => acc + child.totalLeaves, 0)
187 1144256 : return {
188 : ...node,
189 : icon: getTreeNodeIcon(node),
190 : iconColor: node.getIconColor?.(),
191 : iconImage: node.getIconImage?.(),
192 : children,
193 : type: node.leaf ? 'node' : 'folder',
194 : totalLeaves,
195 : badgeText: node.getBadgeText ? node.getBadgeText() : undefined,
196 : isEditingLabel: node.key === renameEditingNode.value?.key
197 : }
198 : }
199 369 : const onNodeContentClick = async (
200 : e: MouseEvent,
201 : node: RenderedTreeExplorerNode<T>
202 : ) => {
203 140 : await node.handleClick?.(e)
204 140 : emit('nodeClick', node, e)
205 : }
206 369 : const menuTargetNode = shallowRef<RenderedTreeExplorerNode<T> | null>(null)
207 369 : const extraMenuItems = computed(() => {
208 400 : const node = menuTargetNode.value
209 400 : return node?.contextMenuItems
210 : ? typeof node.contextMenuItems === 'function'
211 : ? node.contextMenuItems(node)
212 : : node.contextMenuItems
213 : : []
214 : })
215 369 : const renameEditingNode = shallowRef<RenderedTreeExplorerNode<T> | null>(null)
216 369 : const errorHandling = useErrorHandling()
217 369 : const handleNodeLabelEdit = async (
218 : n: RenderedTreeExplorerNode,
219 : newName: string
220 : ) => {
221 6 : const node = n as RenderedTreeExplorerNode<T>
222 6 : await errorHandling.wrapWithErrorHandlingAsync(
223 : async () => {
224 6 : if (node.key === newFolderNode.value?.key) {
225 2 : await handleFolderCreation(newName)
226 : } else {
227 4 : await node.handleRename?.(newName)
228 : }
229 : },
230 : node.handleError,
231 : () => {
232 6 : renameEditingNode.value = null
233 : }
234 : )()
235 : }
236 369 : provide(InjectKeyHandleEditLabelFunction, handleNodeLabelEdit)
237 :
238 369 : const { t } = useI18n()
239 369 : const renameCommand = (node: RenderedTreeExplorerNode<T>) => {
240 4 : renameEditingNode.value = node
241 : }
242 369 : const deleteCommand = async (node: RenderedTreeExplorerNode<T>) => {
243 18 : await node.handleDelete?.()
244 17 : emit('nodeDelete', node)
245 : }
246 :
247 369 : const menuItems = computed<MenuItem[]>(() => {
248 406 : const node = menuTargetNode.value
249 406 : return [
250 : getAddFolderMenuItem(node),
251 : {
252 : label: t('g.rename'),
253 : icon: 'icon-[lucide--file-pen-line]',
254 : command: () => {
255 4 : if (node) {
256 4 : renameCommand(node)
257 : }
258 : },
259 : visible: node?.handleRename !== undefined
260 : },
261 : {
262 : label: t('g.delete'),
263 : icon: 'icon-[lucide--trash-2]',
264 : command: async () => {
265 18 : if (node) {
266 18 : await deleteCommand(node)
267 : }
268 : },
269 : visible: node?.handleDelete !== undefined
270 : },
271 : ...extraMenuItems.value
272 : ].map((menuItem: MenuItem) =>
273 : menuItem.command
274 : ? {
275 : ...menuItem,
276 : command: wrapCommandWithErrorHandler(menuItem.command)
277 : }
278 : : menuItem
279 : )
280 : })
281 :
282 369 : const handleContextMenu = (
283 : e: MouseEvent,
284 : node: RenderedTreeExplorerNode<T>
285 : ) => {
286 30 : menuTargetNode.value = node
287 30 : emit('contextMenu', node, e)
288 : }
289 :
290 369 : const wrapCommandWithErrorHandler = (
291 : command: (event: MenuItemCommandEvent) => unknown
292 : ) => {
293 1270 : const node = menuTargetNode.value
294 1270 : return errorHandling.wrapWithErrorHandlingAsync(command, node?.handleError)
295 : }
296 :
297 2355 : const PREVIEW_GAP = 16
298 :
299 369 : const previews = useTemplateRef<HTMLElement[]>('preview')
300 369 : const previewElement = computed(() => previews.value?.[0])
301 369 : const previewRow = useElementBounding(() =>
302 : previewElement.value?.closest<HTMLElement>('[role="treeitem"]')
303 : )
304 369 : const previewSize = useElementSize(previewElement, undefined, {
305 : box: 'border-box'
306 : })
307 369 : const { height: windowHeight } = useWindowSize()
308 369 : const settingStore = useSettingStore()
309 369 : const previewStyle = computed(() => {
310 73 : const top = Math.max(
311 : 0,
312 : Math.min(
313 : previewRow.top.value,
314 : windowHeight.value - previewSize.height.value - PREVIEW_GAP
315 : )
316 : )
317 73 : const left =
318 : settingStore.get('Comfy.Sidebar.Location') === 'right'
319 : ? previewRow.left.value - previewSize.width.value - PREVIEW_GAP
320 : : previewRow.right.value + PREVIEW_GAP
321 73 : return { top: `${top}px`, left: `${left}px` }
322 : })
323 :
324 369 : defineExpose({
325 : /**
326 : * The command to add a folder to a node via the context menu
327 : * @param targetNodeKey - The key of the node where the folder will be added under
328 : */
329 : addFolderCommand: (targetNodeKey: string) => {
330 1 : const targetNode = findNodeByKey(renderedRoot.value, targetNodeKey)
331 1 : if (targetNode) {
332 1 : addFolderCommand(targetNode)
333 : }
334 : }
335 : })
336 : </script>
|