LCOV - code coverage report
Current view: top level - src/components/common - TreeExplorer.vue Coverage Total Hit
Test: ComfyUI E2E Coverage Lines: 97.6 % 85 83
Test Date: 2026-11-17 04:17:53

            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>
        

Generated by: LCOV version 2.0-1