LCOV - code coverage report
Current view: top level - src/components/sidebar/tabs - BaseWorkflowsSidebarTab.vue Coverage Total Hit
Test: ComfyUI E2E Coverage Lines: 90.8 % 65 59
Test Date: 2026-11-17 04:17:53

            Line data    Source code
       1              : <template>
       2           91 :   <SidebarTabTemplate
       3              :     :title="title"
       4              :     v-bind="$attrs"
       5              :     :data-testid="dataTestid"
       6              :     class="workflows-sidebar-tab"
       7              :   >
       8              :     <template #alt-title>
       9              :       <slot name="alt-title" />
      10              :     </template>
      11              :     <template #tool-buttons>
      12              :       <Button
      13              :         :tooltip="$t('g.refresh')"
      14              :         tooltip-side="bottom"
      15              :         data-testid="workflows-refresh-button"
      16              :         variant="muted-textonly"
      17              :         size="icon"
      18              :         :aria-label="$t('g.refresh')"
      19              :         :aria-busy="workflowStore.isSyncLoading"
      20              :         :disabled="workflowStore.isSyncLoading"
      21              :         @click="workflowStore.syncWorkflows()"
      22              :       >
      23              :         <i
      24              :           aria-hidden="true"
      25              :           data-testid="workflows-refresh-icon"
      26              :           :class="
      27              :             cn(
      28              :               'icon-[lucide--refresh-cw]',
      29              :               workflowStore.isSyncLoading && 'animate-spin'
      30              :             )
      31              :           "
      32              :         />
      33              :       </Button>
      34              :       <slot
      35              :         name="header-actions"
      36              :         :has-results="filteredPersistedWorkflows.length > 0"
      37              :       />
      38              :     </template>
      39              :     <template #header>
      40              :       <SidebarTopArea>
      41              :         <SearchInput
      42              :           ref="searchBoxRef"
      43              :           v-model:model-value="searchQuery"
      44              :           :clear-label="$t('g.clear')"
      45              :           :accessible-label="
      46              :             $t('g.searchPlaceholder', { subject: searchSubject })
      47              :           "
      48              :           :placeholder="$t('g.searchPlaceholder', { subject: searchSubject })"
      49              :           @search="handleSearch"
      50              :         />
      51              :       </SidebarTopArea>
      52              :     </template>
      53              :     <template #body>
      54              :       <div v-if="!isSearching" class="comfyui-workflows-panel">
      55              :         <div
      56              :           v-if="workflowTabsPosition === 'Sidebar'"
      57              :           class="comfyui-workflows-open"
      58              :         >
      59              :           <TextDivider
      60              :             :text="t('sideToolbar.workflowTab.workflowTreeType.open')"
      61              :             type="dashed"
      62              :             class="ml-2"
      63              :           />
      64              :           <TreeExplorer
      65              :             v-model:expanded-keys="dummyExpandedKeys"
      66              :             :root="renderTreeNode(openWorkflowsTree, WorkflowTreeType.Open)"
      67              :             :selection-keys="selectionKeys"
      68              :           >
      69              :             <template #node="{ node }">
      70              :               <TreeExplorerTreeNode :node="node">
      71              :                 <template #before-label="{ node: treeNode }">
      72              :                   <span
      73              :                     v-if="
      74              :                       treeNode.data?.isModified || !treeNode.data?.isPersisted
      75              :                     "
      76              :                     >*</span
      77              :                   >
      78              :                 </template>
      79              :                 <template #actions="{ node: treeNode }">
      80              :                   <Button
      81              :                     class="close-workflow-button"
      82              :                     :variant="
      83              :                       workspaceStore.shiftDown ? 'destructive' : 'textonly'
      84              :                     "
      85              :                     size="icon-sm"
      86              :                     :aria-label="$t('g.close')"
      87              :                     @click.stop="handleCloseWorkflow(treeNode.data)"
      88              :                   >
      89              :                     <i class="icon-[lucide--x] size-3" />
      90              :                   </Button>
      91              :                 </template>
      92              :               </TreeExplorerTreeNode>
      93              :             </template>
      94              :           </TreeExplorer>
      95              :         </div>
      96              :         <div
      97              :           v-show="filteredBookmarkedWorkflows.length > 0"
      98              :           class="comfyui-workflows-bookmarks"
      99              :         >
     100              :           <TextDivider
     101              :             :text="t('sideToolbar.workflowTab.workflowTreeType.bookmarks')"
     102              :             type="dashed"
     103              :             class="ml-2"
     104              :           />
     105              :           <TreeExplorer
     106              :             v-model:expanded-keys="dummyExpandedKeys"
     107              :             :root="
     108              :               renderTreeNode(
     109              :                 bookmarkedWorkflowsTree,
     110              :                 WorkflowTreeType.Bookmarks
     111              :               )
     112              :             "
     113              :             :selection-keys="selectionKeys"
     114              :           >
     115              :             <template #node="{ node }">
     116              :               <WorkflowTreeLeaf :node="node" />
     117              :             </template>
     118              :           </TreeExplorer>
     119              :         </div>
     120              :         <div class="comfyui-workflows-browse">
     121              :           <TextDivider
     122              :             :text="t('sideToolbar.workflowTab.workflowTreeType.browse')"
     123              :             type="dashed"
     124              :             class="ml-2"
     125              :           />
     126              :           <TreeExplorer
     127              :             v-if="filteredPersistedWorkflows.length > 0"
     128              :             v-model:expanded-keys="expandedKeys"
     129              :             :root="renderTreeNode(workflowsTree, WorkflowTreeType.Browse)"
     130              :             :selection-keys="selectionKeys"
     131              :           >
     132              :             <template #node="{ node }">
     133              :               <WorkflowTreeLeaf :node="node" />
     134              :             </template>
     135              :           </TreeExplorer>
     136              :           <slot v-else name="empty-state">
     137              :             <NoResultsPlaceholder
     138              :               icon="icon-[lucide--folder]"
     139              :               :title="$t('g.empty')"
     140              :               :message="$t('g.noWorkflowsFound')"
     141              :             />
     142              :           </slot>
     143              :         </div>
     144              :       </div>
     145              :       <div v-else class="comfyui-workflows-search-panel">
     146              :         <TreeExplorer
     147              :           v-model:expanded-keys="expandedKeys"
     148              :           :root="renderTreeNode(filteredRoot, WorkflowTreeType.Browse)"
     149              :         >
     150              :           <template #node="{ node }">
     151              :             <WorkflowTreeLeaf :node="node" />
     152              :           </template>
     153              :         </TreeExplorer>
     154              :       </div>
     155              :     </template>
     156              :   </SidebarTabTemplate>
     157              : </template>
     158              : 
     159              : <script setup lang="ts">
     160              : import { computed, nextTick, onMounted, ref } from 'vue'
     161              : import { useI18n } from 'vue-i18n'
     162              : 
     163              : import NoResultsPlaceholder from '@comfyorg/design-system/common/NoResultsPlaceholder'
     164              : import SearchInput from '@comfyorg/design-system/search-input/SearchInput'
     165              : import SidebarTopArea from '@comfyorg/design-system/navigation/SidebarTopArea'
     166              : import TextDivider from '@comfyorg/design-system/common/TextDivider'
     167              : import TreeExplorer from '@/components/common/TreeExplorer.vue'
     168              : import TreeExplorerTreeNode from '@/components/common/TreeExplorerTreeNode.vue'
     169              : import type { MenuItem } from '@comfyorg/design-system/lib/menu/types'
     170              : import SidebarTabTemplate from '@/components/sidebar/tabs/SidebarTabTemplate.vue'
     171              : import WorkflowTreeLeaf from '@/components/sidebar/tabs/workflows/WorkflowTreeLeaf.vue'
     172              : import Button from '@comfyorg/design-system/button/Button'
     173              : import { useTreeExpansion } from '@/composables/useTreeExpansion'
     174              : import { useAppMode } from '@/composables/useAppMode'
     175              : import { useSettingStore } from '@/platform/settings/settingStore'
     176              : import { useSearchQueryTracking } from '@/platform/telemetry/searchQuery/useSearchQueryTracking'
     177              : import { useWorkflowService } from '@/platform/workflow/core/services/workflowService'
     178              : import {
     179              :   ComfyWorkflow,
     180              :   useWorkflowBookmarkStore,
     181              :   useWorkflowStore
     182              : } from '@/platform/workflow/management/stores/workflowStore'
     183              : import { useWorkspaceStore } from '@/stores/workspaceStore'
     184              : import type { TreeExplorerNode, TreeNode } from '@/types/treeExplorerTypes'
     185              : import {
     186              :   ensureWorkflowSuffix,
     187              :   getFilenameDetails,
     188              :   getWorkflowSuffix
     189              : } from '@/utils/formatUtil'
     190              : import { buildTree, sortedTree } from '@/utils/treeUtil'
     191              : import { cn } from '@comfyorg/tailwind-utils'
     192              : 
     193              : const { title, filter, searchSubject, dataTestid, hideLeafIcon } = defineProps<{
     194              :   title: string
     195              :   filter?: (workflow: ComfyWorkflow) => boolean
     196              :   searchSubject: string
     197              :   dataTestid: string
     198              :   hideLeafIcon?: boolean
     199              : }>()
     200              : 
     201           89 : const { t } = useI18n()
     202           89 : const { isAppMode } = useAppMode()
     203              : 
     204           89 : const applyFilter = (workflows: ComfyWorkflow[]) =>
     205              :   filter ? workflows.filter(filter) : workflows
     206              : 
     207           89 : const settingStore = useSettingStore()
     208           89 : const workflowTabsPosition = computed(() =>
     209              :   settingStore.get('Comfy.Workflow.WorkflowTabsPosition')
     210              : )
     211              : 
     212           89 : const searchBoxRef = ref()
     213              : 
     214           89 : const searchQuery = ref('')
     215           89 : const isSearching = computed(() => searchQuery.value.length > 0)
     216           89 : const filteredWorkflows = computed(() => {
     217            9 :   if (searchQuery.value.length === 0) return []
     218            9 :   const lowerQuery = searchQuery.value.toLocaleLowerCase()
     219            9 :   return applyFilter(workflowStore.workflows).filter((workflow) =>
     220              :     workflow.path.toLocaleLowerCase().includes(lowerQuery)
     221              :   )
     222              : })
     223           89 : useSearchQueryTracking('apps', searchQuery, filteredWorkflows)
     224           89 : const filteredRoot = computed<TreeNode<ComfyWorkflow>>(() => {
     225            9 :   return buildWorkflowTree(filteredWorkflows.value)
     226              : })
     227           89 : const handleSearch = async (query: string) => {
     228            0 :   if (query.length === 0) {
     229            0 :     expandedKeys.value = {}
     230            0 :     return
     231              :   }
     232            0 :   await nextTick()
     233            0 :   expandNode(filteredRoot.value)
     234              : }
     235              : 
     236           89 : const workflowStore = useWorkflowStore()
     237           89 : const workflowService = useWorkflowService()
     238           89 : const workspaceStore = useWorkspaceStore()
     239           89 : const expandedKeys = ref<Record<string, boolean>>({})
     240           89 : const { expandNode, toggleNodeOnEvent } = useTreeExpansion(expandedKeys)
     241           89 : const dummyExpandedKeys = ref<Record<string, boolean>>({})
     242              : 
     243           89 : const handleCloseWorkflow = async (workflow?: ComfyWorkflow) => {
     244            1 :   if (workflow) {
     245            1 :     await workflowService.closeWorkflows([workflow], {
     246              :       warnIfUnsaved: !workspaceStore.shiftDown,
     247              :       initiator: 'user'
     248              :     })
     249              :   }
     250              : }
     251              : 
     252              : enum WorkflowTreeType {
     253              :   Open = 'Open',
     254              :   Bookmarks = 'Bookmarks',
     255              :   Browse = 'Browse'
     256              : }
     257              : 
     258           89 : const buildWorkflowTree = (workflows: ComfyWorkflow[]) => {
     259         1090 :   return buildTree(workflows, (workflow: ComfyWorkflow) =>
     260              :     workflow.key.split('/')
     261              :   )
     262              : }
     263              : 
     264           89 : const filteredPersistedWorkflows = computed(() =>
     265              :   applyFilter(workflowStore.persistedWorkflows)
     266              : )
     267           89 : const filteredBookmarkedWorkflows = computed(() =>
     268              :   applyFilter(workflowStore.bookmarkedWorkflows)
     269              : )
     270              : 
     271           89 : const workflowsTree = computed(() =>
     272              :   sortedTree(buildWorkflowTree(filteredPersistedWorkflows.value), {
     273              :     groupLeaf: true
     274              :   })
     275              : )
     276              : // Bookmarked workflows tree is flat.
     277           89 : const bookmarkedWorkflowsTree = computed(() =>
     278              :   buildTree(filteredBookmarkedWorkflows.value, (workflow) => [workflow.key])
     279              : )
     280              : // Open workflows tree is flat.
     281           89 : const openWorkflowsTree = computed(() =>
     282              :   buildTree(applyFilter(workflowStore.openWorkflows), (workflow) => [
     283              :     workflow.key
     284              :   ])
     285              : )
     286              : 
     287            2 : function renamedWorkflowPath(
     288              :   workflow: ComfyWorkflow,
     289              :   type: WorkflowTreeType,
     290              :   newName: string
     291              : ) {
     292            2 :   const fileName = ensureWorkflowSuffix(
     293              :     newName,
     294              :     getWorkflowSuffix(workflow.suffix)
     295              :   )
     296            2 :   if (type === WorkflowTreeType.Browse) {
     297            0 :     return `${workflow.directory}/${fileName}`
     298              :   }
     299            2 :   return ComfyWorkflow.basePath + fileName
     300              : }
     301              : 
     302           22 : function workflowContextMenuItems(workflow: ComfyWorkflow): MenuItem[] {
     303           22 :   const duplicate: MenuItem = {
     304              :     label: t('g.duplicate'),
     305              :     icon: 'icon-[lucide--file-output]',
     306              :     command: () => workflowService.duplicateWorkflow(workflow)
     307              :   }
     308           22 :   if (isAppMode.value) return [duplicate]
     309              : 
     310              :   const insert: MenuItem = {
     311              :     label: t('g.insert'),
     312              :     icon: 'icon-[lucide--file-output]',
     313              :     command: () => workflowService.insertWorkflow(workflow)
     314              :   }
     315           22 :   return [insert, duplicate]
     316              : }
     317              : 
     318         3667 : function workflowLeafActions(
     319              :   workflow: ComfyWorkflow,
     320              :   type: WorkflowTreeType
     321              : ): Partial<TreeExplorerNode<ComfyWorkflow>> {
     322         3667 :   const actions: Partial<TreeExplorerNode<ComfyWorkflow>> = {
     323              :     contextMenuItems: () => workflowContextMenuItems(workflow),
     324              :     draggable: true,
     325              :     handleRename: (newName: string) =>
     326              :       workflowService.renameWorkflow(
     327              :         workflow,
     328              :         renamedWorkflowPath(workflow, type, newName)
     329              :       )
     330              :   }
     331         3667 :   if (!workflow.isTemporary) {
     332         2285 :     actions.handleDelete = async () => {
     333           16 :       await workflowService.deleteWorkflow(workflow)
     334              :     }
     335              :   }
     336         3667 :   return actions
     337              : }
     338              : 
     339           89 : const renderTreeNode = (
     340              :   node: TreeNode<ComfyWorkflow>,
     341              :   type: WorkflowTreeType
     342              : ): TreeExplorerNode<ComfyWorkflow> => {
     343         7631 :   const workflow = node.data
     344              : 
     345           77 :   async function handleClick(
     346              :     this: TreeExplorerNode<ComfyWorkflow>,
     347              :     e: MouseEvent
     348              :   ) {
     349           77 :     if (this.leaf && workflow) {
     350           76 :       await workflowService.openWorkflow(workflow, { initiator: 'user' })
     351              :     } else {
     352            1 :       toggleNodeOnEvent(e, this)
     353              :     }
     354              :   }
     355              : 
     356         7631 :   return {
     357              :     key: node.key,
     358              :     label: node.leaf ? getFilenameDetails(node.label).filename : node.label,
     359              :     children: node.children?.map((child) => renderTreeNode(child, type)),
     360              :     data: workflow,
     361              :     handleClick,
     362              :     icon: node.leaf && hideLeafIcon ? 'hidden' : undefined,
     363              :     leaf: node.leaf,
     364              :     ...(node.leaf && workflow ? workflowLeafActions(workflow, type) : {})
     365              :   }
     366              : }
     367              : 
     368           89 : const selectionKeys = computed(() => ({
     369              :   [`root/${workflowStore.activeWorkflow?.key}`]: true
     370              : }))
     371              : 
     372           89 : const workflowBookmarkStore = useWorkflowBookmarkStore()
     373           89 : onMounted(async () => {
     374           89 :   searchBoxRef.value?.focus()
     375           89 :   await workflowBookmarkStore.loadBookmarks()
     376              : })
     377              : </script>
        

Generated by: LCOV version 2.0-1