LCOV - code coverage report
Current view: top level - src/renderer/extensions/vueNodes/widgets/utils - multilineTextarea.ts Coverage Total Hit
Test: ComfyUI E2E Coverage Lines: 59.7 % 62 37
Test Date: 2026-11-17 04:17:53

            Line data    Source code
       1              : import { useChainCallback } from '@/composables/functional/useChainCallback'
       2              : import type { INodeInputSlot, LGraphNode } from '@/lib/litegraph/src/litegraph'
       3              : import type { IBaseWidget } from '@comfyorg/graph-model/widgets'
       4              : import { useSettingStore } from '@/platform/settings/settingStore'
       5              : import { forwardMiddleButtonToCanvas } from '@/renderer/extensions/vueNodes/widgets/utils/forwardMiddleButtonToCanvas'
       6              : import { useApp } from '@/scripts/appInstance'
       7              : import { DOMWidgetImpl, isDOMWidget } from '@/scripts/domWidget'
       8              : import type { BaseDOMWidget } from '@/types/domWidget'
       9              : import { useDomWidgetStore } from '@/stores/domWidgetStore'
      10              : import { useWidgetValueStore } from '@/stores/widgetValueStore'
      11              : import type { WidgetId } from '@comfyorg/graph-model/widgetId'
      12              : 
      13         2356 : const TRACKPAD_DETECTION_THRESHOLD = 50
      14              : 
      15              : /** Creates the `<textarea>` element backing a `customtext` multiline widget. */
      16         7187 : export function createMultilineInputElement(
      17              :   value: string,
      18              :   placeholder: string
      19              : ): HTMLTextAreaElement {
      20         7187 :   const element = document.createElement('textarea')
      21         7187 :   element.className = 'comfy-multiline-input'
      22         7187 :   element.dataset.testid = 'dom-widget-textarea'
      23         7187 :   element.value = value
      24         7187 :   element.placeholder = placeholder
      25         7187 :   element.spellcheck = useSettingStore().get('Comfy.TextareaWidget.Spellcheck')
      26         7187 :   return element
      27              : }
      28              : 
      29              : /**
      30              :  * Wires textarea value propagation, trackpad gestures, and middle-button canvas
      31              :  * panning onto a `customtext` DOM widget, torn down via the widget's `onRemove`.
      32              :  */
      33         7187 : export function bindMultilineTextareaWidget(
      34              :   widget: BaseDOMWidget<string>,
      35              :   element: HTMLTextAreaElement
      36              : ): void {
      37         7187 :   const controller = new AbortController()
      38         7187 :   const { signal } = controller
      39              : 
      40         7187 :   element.addEventListener(
      41              :     'input',
      42              :     () => {
      43           17 :       widget.value = element.value
      44           17 :       widget.callback?.(widget.value)
      45              :     },
      46              :     { signal }
      47              :   )
      48              : 
      49         7187 :   forwardMiddleButtonToCanvas(element, signal)
      50              : 
      51         7187 :   element.addEventListener(
      52              :     'wheel',
      53              :     (event: WheelEvent) => {
      54            0 :       const gesturesEnabled = useSettingStore().get(
      55              :         'LiteGraph.Pointer.TrackpadGestures'
      56              :       )
      57            0 :       const deltaX = event.deltaX
      58            0 :       const deltaY = event.deltaY
      59              : 
      60            0 :       const canScrollY = element.scrollHeight > element.clientHeight
      61            0 :       const isHorizontal = Math.abs(deltaX) > Math.abs(deltaY)
      62              : 
      63              :       // Prevent pinch zoom from zooming the page
      64            0 :       if (event.ctrlKey) {
      65            0 :         event.preventDefault()
      66            0 :         event.stopPropagation()
      67            0 :         useApp().canvas.processMouseWheel(event)
      68            0 :         return
      69              :       }
      70              : 
      71              :       // Detect if this is likely a trackpad gesture vs mouse wheel
      72              :       // Trackpads usually have deltaX or smaller deltaY values (< TRACKPAD_DETECTION_THRESHOLD)
      73              :       // Mouse wheels typically have larger discrete deltaY values (>= TRACKPAD_DETECTION_THRESHOLD)
      74              :       const isLikelyTrackpad =
      75              :         Math.abs(deltaX) > 0 || Math.abs(deltaY) < TRACKPAD_DETECTION_THRESHOLD
      76              : 
      77              :       // Trackpad gestures: when enabled, trackpad panning goes to canvas
      78            0 :       if (gesturesEnabled && isLikelyTrackpad) {
      79            0 :         event.preventDefault()
      80            0 :         event.stopPropagation()
      81            0 :         useApp().canvas.processMouseWheel(event)
      82            0 :         return
      83              :       }
      84              : 
      85              :       // When gestures disabled: horizontal always goes to canvas (no horizontal scroll in textarea)
      86            0 :       if (isHorizontal) {
      87            0 :         event.preventDefault()
      88            0 :         event.stopPropagation()
      89            0 :         useApp().canvas.processMouseWheel(event)
      90            0 :         return
      91              :       }
      92              : 
      93              :       // Vertical scrolling when gestures disabled: let textarea scroll if scrollable
      94            0 :       if (canScrollY) {
      95            0 :         event.stopPropagation()
      96            0 :         return
      97              :       }
      98              : 
      99              :       // If textarea can't scroll vertically, pass to canvas
     100            0 :       event.preventDefault()
     101            0 :       useApp().canvas.processMouseWheel(event)
     102              :     },
     103              :     { signal }
     104              :   )
     105              : 
     106         7187 :   widget.onRemove = useChainCallback(widget.onRemove, () => {
     107         3670 :     controller.abort()
     108              :   })
     109              : }
     110              : 
     111              : interface PromotedMultilineWidgetContext {
     112              :   subgraphNode: LGraphNode
     113              :   input: INodeInputSlot
     114              :   widgetId: WidgetId
     115              :   sourceWidget: Readonly<IBaseWidget>
     116              : }
     117              : 
     118              : /**
     119              :  * Builds the promoted textarea as a host-owned DOM widget, registered directly
     120              :  * with the DOM widget store since `SubgraphNode.widgets` is a projected getter.
     121              :  * Returns undefined to fall back to the store-backed projection.
     122              :  */
     123         1106 : export function createPromotedMultilineWidget(
     124              :   context: PromotedMultilineWidgetContext
     125              : ): IBaseWidget | undefined {
     126         1106 :   const { subgraphNode, input, widgetId, sourceWidget } = context
     127              : 
     128              :   // Only materialize once the host node is settled in its graph; clone/configure
     129              :   // run with a transient id and would leak duplicate DOM widgets.
     130         1106 :   const graph = subgraphNode.graph
     131         1106 :   if (!graph || graph.getNodeById(subgraphNode.id) !== subgraphNode)
     132            9 :     return undefined
     133         1100 :   if (!isDOMWidget(sourceWidget)) return undefined
     134          837 :   if (!(sourceWidget.element instanceof HTMLTextAreaElement)) return undefined
     135              : 
     136          639 :   const widgetStore = useWidgetValueStore()
     137              : 
     138          639 :   const readValue = (): string => {
     139         1825 :     const value = widgetStore.getWidget(widgetId)?.value
     140         1825 :     return typeof value === 'string' ? value : ''
     141              :   }
     142              : 
     143         1106 :   const element = createMultilineInputElement(
     144              :     readValue(),
     145              :     input.label ?? input.name
     146              :   )
     147              : 
     148         1106 :   const widget = new DOMWidgetImpl<HTMLTextAreaElement, string>({
     149              :     node: subgraphNode,
     150              :     name: input.name,
     151              :     type: 'customtext',
     152              :     element,
     153              :     options: {
     154              :       hideOnZoom: true,
     155              :       minNodeSize: [400, 200],
     156              :       getValue: readValue,
     157              :       setValue: (value: string) => {
     158          168 :         element.value = value
     159          168 :         widgetStore.setValue(widgetId, value)
     160              :       }
     161              :     }
     162              :   })
     163              : 
     164         1106 :   bindMultilineTextareaWidget(widget, element)
     165         1106 :   useDomWidgetStore().registerWidget(widget)
     166              : 
     167         1106 :   return widget
     168              : }
        

Generated by: LCOV version 2.0-1