LCOV - code coverage report
Current view: top level - src/renderer/extensions/propertiesPanel/subgraph - SubgraphEditor.vue Coverage Total Hit
Test: ComfyUI E2E Coverage Lines: 79.5 % 151 120
Test Date: 2026-11-17 04:17:53

            Line data    Source code
       1              : <script setup lang="ts">
       2              : import { useEventListener } from '@vueuse/core'
       3              : import { computed, onMounted, ref, shallowRef, watch } from 'vue'
       4              : 
       5              : import DraggableList from '@/components/common/DraggableList.vue'
       6              : import Button from '@comfyorg/design-system/button/Button'
       7              : import { useVueFeatureFlags } from '@/composables/useVueFeatureFlags'
       8              : import {
       9              :   demoteWidget,
      10              :   getPromotableWidgets,
      11              :   isRecommendedWidget,
      12              :   promoteWidget,
      13              :   pruneDisconnected,
      14              :   refreshPromotedWidgetRendering,
      15              :   reorderSubgraphInputsByWidgetOrder
      16              : } from '@/core/graph/subgraph/promotionUtils'
      17              : import {
      18              :   promotedInputSource,
      19              :   promotedInputWidget
      20              : } from '@/core/graph/subgraph/promotedInputWidget'
      21              : import type { PromotedSource } from '@/core/graph/subgraph/promotedInputWidget'
      22              : import type { WidgetItem } from '@/core/graph/subgraph/promotionUtils'
      23              : import type { PreviewExposure } from '@/core/schemas/previewExposureSchema'
      24              : import type {
      25              :   INodeInputSlot,
      26              :   ISubgraphInput
      27              : } from '@comfyorg/graph-model/slots'
      28              : import type { LGraphNode } from '@/lib/litegraph/src/litegraph'
      29              : import { SubgraphNode } from '@/lib/litegraph/src/subgraph/SubgraphNode'
      30              : import type { IBaseWidget } from '@comfyorg/graph-model/widgets'
      31              : import { useCanvasStore } from '@/renderer/core/canvas/canvasStore'
      32              : import AsyncSearchInput from '@comfyorg/design-system/search-input/AsyncSearchInput'
      33              : import { useLitegraphService } from '@/services/litegraphService'
      34              : import {
      35              :   getPreviewExposureHostLocator,
      36              :   usePreviewExposureStore
      37              : } from '@/stores/previewExposureStore'
      38              : import { deriveWidgetVisibility } from '@/types/widgetVisibility'
      39              : import { cn } from '@comfyorg/tailwind-utils'
      40              : 
      41              : import SubgraphNodeWidget from './SubgraphNodeWidget.vue'
      42              : 
      43              : type PromotedRow = {
      44              :   kind: 'promoted'
      45              :   node: LGraphNode
      46              :   input: INodeInputSlot & Partial<ISubgraphInput>
      47              :   widget: IBaseWidget
      48              : }
      49              : type PreviewRow = {
      50              :   kind: 'preview'
      51              :   node: LGraphNode
      52              :   exposure: PreviewExposure
      53              :   realWidget?: IBaseWidget
      54              : }
      55              : type ActiveRow = PromotedRow | PreviewRow
      56              : 
      57         2355 : const canvasStore = useCanvasStore()
      58           16 : const previewExposureStore = usePreviewExposureStore()
      59           16 : const searchQuery = ref('')
      60           16 : const { shouldRenderVueNodes } = useVueFeatureFlags()
      61              : 
      62           16 : const activeNode = computed(() => {
      63           16 :   const node = canvasStore.selectedItems[0]
      64           16 :   if (node instanceof SubgraphNode) return node
      65              :   return undefined
      66              : })
      67              : 
      68           16 : const promotedRows = shallowRef<readonly PromotedRow[]>([])
      69           31 : function buildPromotedRows(node: SubgraphNode): PromotedRow[] {
      70           31 :   return node.inputs.flatMap((input): PromotedRow[] => {
      71           72 :     const widget = promotedInputWidget(input)
      72           72 :     if (!widget) return []
      73           38 :     const source = promotedInputSource(node, input)
      74           67 :     if (!source) return []
      75           38 :     const sourceNode = node.subgraph._nodes_by_id[source.nodeId]
      76           67 :     if (!sourceNode) return []
      77           38 :     return [{ kind: 'promoted', node: sourceNode, input, widget }]
      78              :   })
      79              : }
      80           31 : function refreshPromotedRows() {
      81           31 :   const node = activeNode.value
      82           31 :   promotedRows.value = node ? buildPromotedRows(node) : []
      83              : }
      84           16 : watch(activeNode, refreshPromotedRows, { immediate: true })
      85           16 : useEventListener(
      86              :   () => activeNode.value?.subgraph.events,
      87              :   [
      88              :     'widget-promoted',
      89              :     'widget-demoted',
      90              :     'input-added',
      91              :     'removing-input',
      92              :     'inputs-reordered'
      93              :   ],
      94              :   refreshPromotedRows
      95              : )
      96              : 
      97           40 : function promotedRowSource(row: PromotedRow): PromotedSource | undefined {
      98           40 :   const node = activeNode.value
      99           40 :   return node ? promotedInputSource(node, row.input) : undefined
     100              : }
     101              : 
     102           16 : const activeRows = computed<ActiveRow[]>(() => {
     103           24 :   const node = activeNode.value
     104           24 :   if (!node) return []
     105           24 :   return [...promotedRows.value, ...getActivePreviewRows(node)]
     106              : })
     107              : 
     108           16 : const activePromotedRows = computed<PromotedRow[]>({
     109              :   get() {
     110           18 :     return [...promotedRows.value]
     111              :   },
     112              :   set(value: PromotedRow[]) {
     113            1 :     updateActivePromotedRows(value, activePromotedRows.value)
     114              :   }
     115              : })
     116              : 
     117           24 : function getActivePreviewRows(node: SubgraphNode): PreviewRow[] {
     118           24 :   const hostLocator = getPreviewExposureHostLocator(node)
     119           24 :   if (!hostLocator) return []
     120           24 :   const rootGraphId = node.rootGraph.id
     121              :   const exposures = previewExposureStore.getExposures(rootGraphId, hostLocator)
     122           24 :   return exposures.flatMap((exposure): PreviewRow[] => {
     123           16 :     const sourceNode = node.subgraph.getNodeById(exposure.sourceNodeId)
     124           16 :     if (!sourceNode) return []
     125              :     const realWidget = getPromotableWidgets(sourceNode).find(
     126              :       (candidate) => candidate.name === exposure.sourcePreviewName
     127              :     )
     128           16 :     return [{ kind: 'preview', node: sourceNode, exposure, realWidget }]
     129              :   })
     130              : }
     131              : 
     132            1 : function updateActivePromotedRows(
     133              :   value: PromotedRow[],
     134              :   currentItems: PromotedRow[]
     135              : ) {
     136            1 :   const node = activeNode.value
     137            1 :   if (!node) {
     138            0 :     console.error('Attempted to toggle widgets with no node selected')
     139            0 :     return
     140              :   }
     141            1 :   const currentKeys = new Set(currentItems.map(promotedRowKey))
     142            1 :   const nextKeys = new Set(value.map(promotedRowKey))
     143            1 :   for (const item of value) {
     144            2 :     if (!currentKeys.has(promotedRowKey(item))) promotePromotedRow(item)
     145              :   }
     146            1 :   for (const item of currentItems) {
     147            2 :     if (!nextKeys.has(promotedRowKey(item))) demoteRow(item)
     148              :   }
     149            1 :   if (currentKeys.size === nextKeys.size) {
     150            1 :     reorderSubgraphInputsByWidgetOrder(
     151              :       node,
     152              :       value.map((row) => ({ widgetId: row.widget.widgetId }))
     153              :     )
     154              :   }
     155            1 :   refreshActiveNodeRendering()
     156              : }
     157              : 
     158           16 : const interiorWidgets = computed<WidgetItem[]>(() => {
     159           22 :   const node = activeNode.value
     160           22 :   if (!node) return []
     161           22 :   const { updatePreviews } = useLitegraphService()
     162           22 :   const interiorNodes = node.subgraph.nodes
     163           22 :   for (const node of interiorNodes) {
     164           38 :     node.updateComputedDisabled()
     165           38 :     updatePreviews(node)
     166              :   }
     167           22 :   return interiorNodes
     168              :     .flatMap(nodeWidgets)
     169              :     .filter(([_, w]: WidgetItem) => !w.computedDisabled)
     170              : })
     171              : 
     172           56 : function activeRowSourceKey(row: ActiveRow): string {
     173           56 :   if (row.kind !== 'promoted')
     174           16 :     return `${row.exposure.sourceNodeId}:${row.exposure.sourcePreviewName}`
     175              : 
     176           40 :   const source = promotedRowSource(row)
     177           56 :   return `${source?.nodeId ?? row.node.id}:${source?.widgetName ?? ''}`
     178              : }
     179              : 
     180           16 : const candidateWidgets = computed<WidgetItem[]>(() => {
     181              :   const node = activeNode.value
     182           25 :   if (!node) return []
     183           25 :   const promotedSourceKeys = new Set(activeRows.value.map(activeRowSourceKey))
     184           25 :   return interiorWidgets.value
     185              :     .filter(([n, w]) => !promotedSourceKeys.has(`${n.id}:${w.name}`))
     186              :     .filter(([, widget]) => {
     187           87 :       const visibility = widget.visibility ?? deriveWidgetVisibility(widget)
     188           87 :       return (
     189              :         widget.name.startsWith('$$') ||
     190              :         !(shouldRenderVueNodes.value && visibility.surfaces.vueNode === 'never')
     191              :       )
     192              :     })
     193              : })
     194           16 : const filteredCandidates = computed<WidgetItem[]>(() => {
     195           26 :   const query = searchQuery.value.toLowerCase()
     196           26 :   if (!query) return candidateWidgets.value
     197            1 :   return candidateWidgets.value.filter(
     198              :     ([n, w]: WidgetItem) =>
     199              :       n.title.toLowerCase().includes(query) ||
     200              :       w.name.toLowerCase().includes(query)
     201              :   )
     202              : })
     203              : 
     204           16 : const recommendedWidgets = computed(() => {
     205              :   const node = activeNode.value
     206           25 :   if (!node) return []
     207           25 :   return filteredCandidates.value.filter(isRecommendedWidget)
     208              : })
     209              : 
     210            0 : function rowMatchesQuery(row: ActiveRow, query: string): boolean {
     211            0 :   return (
     212              :     row.node.title.toLowerCase().includes(query) ||
     213              :     rowDisplayName(row).toLowerCase().includes(query)
     214              :   )
     215              : }
     216              : 
     217           16 : const filteredActive = computed<ActiveRow[]>(() => {
     218           25 :   const query = searchQuery.value.toLowerCase()
     219           25 :   if (!query) return activeRows.value
     220            1 :   return activeRows.value.filter((row) => rowMatchesQuery(row, query))
     221              : })
     222              : 
     223           16 : const filteredActivePromoted = computed<PromotedRow[]>(() =>
     224              :   filteredActive.value.filter(
     225              :     (row): row is PromotedRow => row.kind === 'promoted'
     226              :   )
     227              : )
     228              : 
     229           16 : const filteredActivePreviews = computed<PreviewRow[]>(() =>
     230              :   filteredActive.value.filter(
     231              :     (row): row is PreviewRow => row.kind === 'preview'
     232              :   )
     233              : )
     234              : 
     235            1 : function refreshActiveNodeRendering() {
     236            1 :   const node = activeNode.value
     237            1 :   if (!node) return
     238              : 
     239            1 :   refreshPromotedWidgetRendering([node])
     240              : }
     241              : 
     242           55 : function rowDisplayName(row: ActiveRow): string {
     243           55 :   if (row.kind === 'promoted') {
     244           36 :     return row.widget.label || row.widget.name
     245              :   }
     246           55 :   return (
     247              :     row.realWidget?.label ||
     248              :     row.realWidget?.name ||
     249              :     row.exposure.sourcePreviewName
     250              :   )
     251              : }
     252              : 
     253           55 : function isRowLinked(row: ActiveRow): boolean {
     254           55 :   return row.kind === 'promoted'
     255              : }
     256              : 
     257           44 : function promotedRowKey(row: PromotedRow): string {
     258           44 :   return `${row.node.id}: ${row.widget.name}`
     259              : }
     260              : 
     261           55 : function rowKey(row: ActiveRow): string {
     262           55 :   return row.kind === 'promoted'
     263              :     ? promotedRowKey(row)
     264              :     : `${row.node.id}: ${row.exposure.name}`
     265              : }
     266              : 
     267           38 : function nodeWidgets(n: LGraphNode): WidgetItem[] {
     268           38 :   return getPromotableWidgets(n).map((w) => [n, w])
     269              : }
     270              : 
     271            1 : function demoteRow(row: ActiveRow) {
     272            1 :   const subgraphNode = activeNode.value
     273            1 :   if (!subgraphNode) return
     274            1 :   if (row.kind === 'promoted') {
     275            0 :     const subgraphSlot = row.input._subgraphSlot
     276            0 :     if (subgraphSlot) {
     277            0 :       const inputIndex = subgraphNode.inputs.indexOf(row.input)
     278            0 :       if (subgraphNode.isInputConnected(inputIndex)) subgraphSlot.disconnect()
     279            0 :       else subgraphNode.subgraph.removeInput(subgraphSlot)
     280              :     }
     281            0 :     refreshActiveNodeRendering()
     282            0 :     return
     283              :   }
     284            1 :   if (row.realWidget) {
     285            1 :     demoteWidget(row.node, row.realWidget, [subgraphNode])
     286            1 :     return
     287              :   }
     288            0 :   const hostLocator = getPreviewExposureHostLocator(subgraphNode)
     289            0 :   if (!hostLocator) return
     290            0 :   previewExposureStore.removeExposure(
     291              :     subgraphNode.rootGraph.id,
     292              :     hostLocator,
     293              :     row.exposure.name
     294              :   )
     295            0 :   refreshActiveNodeRendering()
     296              : }
     297              : 
     298            0 : function promotePromotedRow(row: PromotedRow) {
     299            0 :   const subgraphNode = activeNode.value
     300            0 :   if (!subgraphNode) return
     301            0 :   const source = promotedRowSource(row)
     302            0 :   const sourceWidget = source
     303              :     ? row.node.widgets?.find((widget) => widget.name === source.widgetName)
     304              :     : undefined
     305            0 :   if (sourceWidget) promoteWidget(row.node, sourceWidget, [subgraphNode])
     306              : }
     307              : 
     308            6 : function promoteCandidate([node, widget]: WidgetItem) {
     309            6 :   const subgraphNode = activeNode.value
     310            6 :   if (!subgraphNode) return
     311            6 :   promoteWidget(node, widget, [subgraphNode])
     312            6 :   refreshPromotedRows()
     313              : }
     314              : 
     315            0 : function showAll() {
     316            0 :   for (const item of filteredCandidates.value) {
     317            0 :     promoteCandidate(item)
     318              :   }
     319              : }
     320            0 : function hideAll() {
     321            0 :   for (const row of filteredActive.value) {
     322            0 :     if (String(row.node.id) === '-1') continue
     323            0 :     demoteRow(row)
     324              :   }
     325              : }
     326            0 : function showRecommended() {
     327            0 :   for (const item of recommendedWidgets.value) {
     328            0 :     promoteCandidate(item)
     329              :   }
     330              : }
     331              : 
     332           16 : onMounted(() => {
     333           16 :   if (activeNode.value) pruneDisconnected(activeNode.value)
     334              : })
     335           16 : </script>
     336              : 
     337              : <template>
     338           28 :   <div v-if="activeNode" class="subgraph-edit-section flex h-full flex-col">
     339              :     <div class="flex gap-2 border-b px-4 pt-1 pb-4">
     340              :       <AsyncSearchInput
     341              :         v-model="searchQuery"
     342              :         :clear-label="$t('g.clear')"
     343              :         :placeholder="$t('g.searchPlaceholder', { subject: '' })"
     344              :         :accessible-label="$t('g.search')"
     345              :       />
     346              :     </div>
     347              : 
     348              :     <div class="flex-1">
     349              :       <div
     350              :         v-if="
     351              :           searchQuery &&
     352              :           filteredActive.length === 0 &&
     353              :           filteredCandidates.length === 0
     354              :         "
     355              :         class="px-4 py-10 text-center text-sm text-muted-foreground"
     356              :       >
     357              :         {{ $t('rightSidePanel.noneSearchDesc') }}
     358              :       </div>
     359              : 
     360              :       <div
     361              :         v-if="filteredActive.length"
     362              :         data-testid="subgraph-editor-shown-section"
     363              :         class="flex flex-col border-b"
     364              :       >
     365              :         <div
     366              :           class="sticky top-0 z-10 flex min-h-12 items-center justify-between px-4 backdrop-blur-xl"
     367              :         >
     368              :           <div class="line-clamp-1 text-sm font-semibold uppercase">
     369              :             {{ $t('subgraphStore.shown') }}
     370              :           </div>
     371              :           <a
     372              :             class="cursor-pointer text-right text-xs font-normal whitespace-nowrap text-muted-foreground hover:text-primary"
     373              :             @click.stop="hideAll"
     374              :           >
     375              :             {{ $t('subgraphStore.hideAll') }}</a
     376              :           >
     377              :         </div>
     378              :         <DraggableList v-slot="{ dragClass }" v-model="activePromotedRows">
     379           36 :           <SubgraphNodeWidget
     380              :             v-for="row in filteredActivePromoted"
     381              :             :key="rowKey(row)"
     382              :             :data-nodeid="row.node.id"
     383              :             :class="cn(!searchQuery && dragClass, 'bg-background')"
     384              :             :node-title="row.node.title"
     385              :             :widget-name="rowDisplayName(row)"
     386              :             :is-physical="isRowLinked(row)"
     387              :             :is-draggable="!searchQuery"
     388              :             is-shown
     389              :             @toggle-visibility="demoteRow(row)"
     390              :           />
     391              :         </DraggableList>
     392              :         <div class="mt-0.5 space-y-0.5 px-2 pb-2">
     393           19 :           <SubgraphNodeWidget
     394              :             v-for="row in filteredActivePreviews"
     395              :             :key="rowKey(row)"
     396              :             :data-nodeid="row.node.id"
     397              :             class="bg-background"
     398              :             :node-title="row.node.title"
     399              :             :widget-name="rowDisplayName(row)"
     400              :             :is-physical="isRowLinked(row)"
     401              :             :is-draggable="false"
     402              :             is-shown
     403              :             @toggle-visibility="demoteRow(row)"
     404              :           />
     405              :         </div>
     406              :       </div>
     407              : 
     408              :       <div
     409              :         v-if="filteredCandidates.length"
     410              :         data-testid="subgraph-editor-hidden-section"
     411              :         class="flex flex-col border-b"
     412              :       >
     413              :         <div
     414              :           class="sticky top-0 z-10 flex min-h-12 items-center justify-between px-4 backdrop-blur-xl"
     415              :         >
     416              :           <div class="line-clamp-1 text-sm font-semibold uppercase">
     417              :             {{ $t('subgraphStore.hidden') }}
     418              :           </div>
     419              :           <a
     420              :             class="cursor-pointer text-right text-xs font-normal whitespace-nowrap text-muted-foreground hover:text-primary"
     421              :             @click.stop="showAll"
     422              :           >
     423              :             {{ $t('subgraphStore.showAll') }}</a
     424              :           >
     425              :         </div>
     426              :         <div class="mt-0.5 space-y-0.5 px-2 pb-2">
     427           91 :           <SubgraphNodeWidget
     428              :             v-for="[node, widget] in filteredCandidates"
     429              :             :key="`${node.id}:${widget.name}`"
     430              :             :data-nodeid="node.id"
     431              :             class="bg-background"
     432              :             :node-title="node.title"
     433              :             :widget-name="widget.name"
     434              :             @toggle-visibility="promoteCandidate([node, widget])"
     435              :           />
     436              :         </div>
     437              :       </div>
     438              : 
     439              :       <div
     440              :         v-if="recommendedWidgets.length"
     441              :         class="flex justify-center border-b py-4"
     442              :       >
     443              :         <Button size="sm" class="px-3 py-0.5" @click.stop="showRecommended">
     444              :           {{ $t('subgraphStore.showRecommended') }}
     445              :         </Button>
     446              :       </div>
     447              :     </div>
     448              :   </div>
     449              : </template>
        

Generated by: LCOV version 2.0-1