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