LCOV - code coverage report
Current view: top level - src/renderer/extensions/vueNodes/widgets/composables - useMarkdownWidget.ts Coverage Total Hit
Test: ComfyUI E2E Coverage Lines: 85.4 % 48 41
Test Date: 2026-11-17 04:17:53

            Line data    Source code
       1              : import type { Editor as TiptapEditor } from '@tiptap/core'
       2              : 
       3              : import { useChainCallback } from '@/composables/functional/useChainCallback'
       4              : import type { LGraphNode } from '@/lib/litegraph/src/litegraph'
       5              : import { resolveNodeRootGraphId } from '@/lib/litegraph/src/utils/widget'
       6              : import { reportError } from '@comfyorg/telemetry/reportError'
       7              : import { forwardMiddleButtonToCanvas } from '@/renderer/extensions/vueNodes/widgets/utils/forwardMiddleButtonToCanvas'
       8              : import type { InputSpec } from '@comfyorg/object-info-parser/schemas/nodeDefSchemaV2'
       9              : import { useApp } from '@/scripts/appInstance'
      10              : import type { ComfyWidgetConstructorV2 } from '@/types/widgetConstructor'
      11              : import { useWidgetValueStore } from '@/stores/widgetValueStore'
      12              : import { widgetId } from '@comfyorg/graph-model/widgetId'
      13              : 
      14           15 : function addMarkdownWidget(
      15              :   node: LGraphNode,
      16              :   name: string,
      17              :   opts: { defaultVal: string }
      18              : ) {
      19           15 :   const widgetStore = useWidgetValueStore()
      20              : 
      21           15 :   const inputEl = document.createElement('div')
      22           15 :   inputEl.classList.add('comfy-markdown')
      23           15 :   const textarea = document.createElement('textarea')
      24           15 :   inputEl.append(textarea)
      25           15 :   let editor: TiptapEditor | undefined
      26           15 :   let markdown = opts.defaultVal
      27           15 :   function render(value: string) {
      28           15 :     markdown = value
      29           15 :     editor?.commands.setContent(value)
      30              :   }
      31              : 
      32           15 :   const widget = node.addDOMWidget(name, 'MARKDOWN', inputEl, {
      33              :     getValue(): string {
      34           68 :       const graphId = resolveNodeRootGraphId(node, useApp().rootGraph.id)
      35           68 :       const storedValue = widgetStore.getWidget(
      36              :         widgetId(graphId, node.id, name)
      37              :       )?.value
      38           68 :       return typeof storedValue === 'string' ? storedValue : textarea.value
      39              :     },
      40              :     setValue(v: string) {
      41           15 :       textarea.value = v
      42           15 :       render(v)
      43           15 :       const graphId = resolveNodeRootGraphId(node, useApp().rootGraph.id)
      44           15 :       const widgetState = widgetStore.getWidget(
      45              :         widgetId(graphId, node.id, name)
      46              :       )
      47           15 :       if (widgetState) widgetState.value = v
      48              :     }
      49              :   })
      50           15 :   widget.element = inputEl
      51           15 :   widget.options.minNodeSize = [400, 200]
      52              : 
      53           15 :   const controller = new AbortController()
      54           15 :   const { signal } = controller
      55              : 
      56           15 :   inputEl.addEventListener(
      57              :     'input',
      58              :     (event) => {
      59            0 :       if (event.target instanceof HTMLTextAreaElement) {
      60            0 :         widget.value = event.target.value
      61              :       }
      62            0 :       widget.callback?.(widget.value)
      63              :     },
      64              :     { signal }
      65              :   )
      66              : 
      67           15 :   inputEl.addEventListener(
      68              :     'dblclick',
      69              :     () => {
      70            0 :       inputEl.classList.add('editing')
      71            0 :       setTimeout(() => textarea.focus(), 0)
      72              :     },
      73              :     { signal }
      74              :   )
      75              : 
      76           15 :   textarea.addEventListener('blur', () => inputEl.classList.remove('editing'), {
      77              :     signal
      78              :   })
      79              : 
      80           15 :   textarea.addEventListener(
      81              :     'change',
      82              :     () => {
      83            0 :       render(textarea.value)
      84            0 :       widget.callback?.(widget.value)
      85              :     },
      86              :     { signal }
      87              :   )
      88              : 
      89           15 :   inputEl.addEventListener('keydown', (event) => event.stopPropagation(), {
      90              :     signal
      91              :   })
      92              : 
      93           15 :   forwardMiddleButtonToCanvas(inputEl, signal)
      94              : 
      95           15 :   widget.onRemove = useChainCallback(widget.onRemove, () => {
      96            3 :     controller.abort()
      97            3 :     if (editor && !editor.isDestroyed) editor.destroy()
      98              :   })
      99              : 
     100           15 :   void import('./markdownEditor')
     101              :     .then(({ createMarkdownEditor }) => {
     102           12 :       if (signal.aborted) return
     103           12 :       editor = createMarkdownEditor(inputEl, markdown)
     104              :     })
     105              :     .catch((error: unknown) =>
     106              :       reportError(error, {
     107              :         errorType: 'error_loading_markdown_editor',
     108              :         surface: 'platform'
     109              :       })
     110              :     )
     111              : 
     112           15 :   return widget
     113              : }
     114              : 
     115         2356 : export const useMarkdownWidget = () => {
     116         2356 :   const widgetConstructor: ComfyWidgetConstructorV2 = (
     117              :     node: LGraphNode,
     118              :     inputSpec: InputSpec
     119              :   ) => {
     120           15 :     return addMarkdownWidget(node, inputSpec.name, {
     121              :       defaultVal: inputSpec.default ?? ''
     122              :     })
     123              :   }
     124              : 
     125         2356 :   return widgetConstructor
     126              : }
        

Generated by: LCOV version 2.0-1