From 8cf0bffa8b6b68011f2da4b3bfa42573a0d77caa Mon Sep 17 00:00:00 2001 From: Christian Byrne Date: Tue, 18 Aug 2026 18:35:36 -0700 Subject: [PATCH] fix: resolve widget labels, output names and tooltips from the backend (#14797) https://github.com/Comfy-Org/ComfyUI_frontend/pull/14541 made English `display_name` and `description` come from the backend. Widget labels, output names and tooltips were still read from the stale bundled snapshot, so a renamed node showed a new title beside old labels. Adds `resolveNodeDefInputText` / `resolveNodeDefOutputText` and extracts `resolveNodeDefPath`, so the per-locale precedence table now lives in exactly one place and `resolveNodeDefText` delegates to it. Applied in `litegraphService` (widget labels, socket and output `localized_name`), `NodeTooltip.vue`, and `useNodeTooltips.ts`. Also fixes `getNodeDescription`, which wrapped an already-resolved value in `st()` and let the stale bundle win. ## Review focus **Tooltips must never be escaped or compiled.** They are read through `stRaw`/`tm()`, which returns the message uncompiled, so a literal `{'@'}` would render to the user. One function decides it: ```ts return field === 'tooltip' ? stRaw : st ``` Backend values short-circuit before any reader runs, so a tooltip reaches the compiler by no path. No runtime escaping added; `escapeI18nMessage` stays build-time-only. Coverage was verified by mutation rather than inspection, which matters here: `st()` swallows a vue-i18n `SyntaxError` and returns the raw stored message, so a fixture containing a throwing character passes whether or not the code is correct. The raw/compiled fixture (`50{'%'} {'@'}`) compiles cleanly so that escape hatch cannot mask a defect. Forcing the reader to always-`st` or always-`stRaw` each fails the suite. ## Migration guidance (`node.widgets`) `widget.label` now resolves through the node-def text pipeline (custom-node translations, then the live backend value, then the bundled snapshot) instead of taking the node definition's `display_name` verbatim. The resolved string therefore varies by active locale and by what `/object_info` sends. Extensions must use `widget.name` for widget identity. `widget.label` is display text and was never stable across locales. No type or API shape changed. Fixes #14631 --- Previously merged without review and backed out by https://github.com/Comfy-Org/ComfyUI_frontend/pull/14791. Re-submitting for normal review. Rebased onto post-revert `main`; content unchanged. --------- Co-authored-by: Connor Byrne Co-authored-by: Alexander Brown Co-authored-by: Amp Co-authored-by: DrJKL --- src/components/graph/NodeTooltip.test.ts | 68 ++++++-- src/components/graph/NodeTooltip.vue | 40 +++-- src/i18n.test.ts | 149 +++++++++++++++++- src/i18n.ts | 88 ++++++++--- src/locales/en/main.json | 1 + .../vueNodes/components/InputSlot.test.ts | 129 +++++++++++++++ .../vueNodes/components/InputSlot.vue | 9 +- .../composables/useNodeTooltips.test.ts | 38 +++-- .../vueNodes/composables/useNodeTooltips.ts | 37 +++-- src/services/litegraphService.test.ts | 139 +++++++++++++++- src/services/litegraphService.ts | 45 ++++-- 11 files changed, 650 insertions(+), 93 deletions(-) create mode 100644 src/renderer/extensions/vueNodes/components/InputSlot.test.ts diff --git a/src/components/graph/NodeTooltip.test.ts b/src/components/graph/NodeTooltip.test.ts index 3712b3e680f..5ed9eda1529 100644 --- a/src/components/graph/NodeTooltip.test.ts +++ b/src/components/graph/NodeTooltip.test.ts @@ -1,9 +1,10 @@ import { render, screen } from '@testing-library/vue' +import { cloneDeep } from 'es-toolkit' import userEvent from '@testing-library/user-event' import { nextTick } from 'vue' import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest' -import { i18n, te } from '@/i18n' +import { i18n, mergeCustomNodesI18n } from '@/i18n' import type * as LiteGraphModule from '@/lib/litegraph/src/litegraph' import { useSettingStore } from '@/platform/settings/settingStore' import type { Settings } from '@/schemas/apiSchema' @@ -12,6 +13,7 @@ import { useNodeDefStore } from '@/stores/nodeDefStore' import NodeTooltip from './NodeTooltip.vue' +const enMessages = cloneDeep(i18n.global.getLocaleMessage('en')) type HitTest = ( node: MockNode, x: number, @@ -80,17 +82,12 @@ vi.mock('@/scripts/domWidget', () => ({ const jsonTooltip = 'Positive point prompts as JSON [{"x": int, "y": int}, ...] (pixel coords)' -const positiveCoordsTooltipKey = - 'nodeDefs.SAM3_Detect.inputs.positive_coords.tooltip' - -const outputTooltipKey = 'nodeDefs.SAM3_Detect.outputs.0.tooltip' - const sam3DetectNodeDef: ComfyNodeDef = { name: 'SAM3_Detect', display_name: 'SAM3 Detect', category: 'detection/', python_module: 'comfy_extras.nodes_sam3', - description: '', + description: 'Frontend description', input: { required: {}, optional: { @@ -135,6 +132,14 @@ function mergeOutputTooltipMessage(tooltip: string | null) { }) } +function mergeInputTooltipMessage(tooltip: string | null) { + i18n.global.mergeLocaleMessage('en', { + nodeDefs: { + SAM3_Detect: { inputs: { positive_coords: { tooltip } } } + } + }) +} + async function renderAndHoverCanvas() { const user = userEvent.setup({ advanceTimers: vi.advanceTimersByTime }) @@ -173,7 +178,23 @@ describe('NodeTooltip', () => { }) afterEach(() => { - mergeOutputTooltipMessage(null) + mergeCustomNodesI18n({}) + i18n.global.setLocaleMessage('en', cloneDeep(enMessages)) + }) + + it('resolves the node description shown over the title', async () => { + mergeCustomNodesI18n({ + en: { + nodeDefs: { + SAM3_Detect: { description: 'Localized description' } + } + } + }) + mockCanvas.graph_mouse[1] = -1 + + await renderAndHoverCanvas() + + expect(screen.getByText('Localized description')).toBeInTheDocument() }) it('shows input slot JSON tooltips without i18n placeholder errors', async () => { @@ -182,7 +203,6 @@ describe('NodeTooltip', () => { await renderAndHoverCanvas() - expect(te(positiveCoordsTooltipKey)).toBe(true) expect(screen.getByText(jsonTooltip)).toBeInTheDocument() expect(consoleError).not.toHaveBeenCalled() }) @@ -193,7 +213,6 @@ describe('NodeTooltip', () => { await renderAndHoverCanvas() - expect(te(outputTooltipKey)).toBe(true) expect(screen.getByText(jsonTooltip)).toBeInTheDocument() expect(consoleError).not.toHaveBeenCalled() }) @@ -206,8 +225,35 @@ describe('NodeTooltip', () => { await renderAndHoverCanvas() - expect(te(positiveCoordsTooltipKey)).toBe(true) expect(screen.getByText(jsonTooltip)).toBeInTheDocument() expect(consoleError).not.toHaveBeenCalled() }) + + describe('when the bundled snapshot has gone stale', () => { + const staleInputTooltip = 'stale bundled input tooltip' + const staleOutputTooltip = 'stale bundled output tooltip' + + beforeEach(() => { + mergeInputTooltipMessage(staleInputTooltip) + mergeOutputTooltipMessage(staleOutputTooltip) + }) + + it('shows the live backend input slot tooltip', async () => { + vi.mocked(mockIsOverNodeInput).mockReturnValue(0) + + await renderAndHoverCanvas() + + expect(screen.getByText(jsonTooltip)).toBeInTheDocument() + expect(screen.queryByText(staleInputTooltip)).not.toBeInTheDocument() + }) + + it('shows the live backend output slot tooltip', async () => { + vi.mocked(mockIsOverNodeOutput).mockReturnValue(0) + + await renderAndHoverCanvas() + + expect(screen.getByText(jsonTooltip)).toBeInTheDocument() + expect(screen.queryByText(staleOutputTooltip)).not.toBeInTheDocument() + }) + }) }) diff --git a/src/components/graph/NodeTooltip.vue b/src/components/graph/NodeTooltip.vue index fd21640c686..b0cd37b18ef 100644 --- a/src/components/graph/NodeTooltip.vue +++ b/src/components/graph/NodeTooltip.vue @@ -13,7 +13,7 @@ import { useEventListener } from '@vueuse/core' import { nextTick, ref } from 'vue' -import { stRaw } from '@/i18n' +import { resolveNodeDefSlotText, resolveNodeDefText } from '@/i18n' import { LiteGraph, isOverNodeInput, @@ -23,7 +23,6 @@ import { useSettingStore } from '@/platform/settings/settingStore' import { app as comfyApp } from '@/scripts/app' import { isDOMWidget } from '@/scripts/domWidget' import { useNodeDefStore } from '@/stores/nodeDefStore' -import { normalizeI18nKey } from '@/utils/formatUtil' let idleTimeout: number const nodeDefStore = useNodeDefStore() @@ -65,13 +64,16 @@ function onIdle() { if (!node || node.flags?.ghost) return const ctor = node.constructor as { title_mode?: 0 | 1 | 2 | 3 } - const nodeDef = nodeDefStore.nodeDefsByName[node.type ?? ''] + const nodeType = node.type ?? '' + const nodeDef = nodeDefStore.nodeDefsByName[nodeType] if ( ctor.title_mode !== LiteGraph.NO_TITLE && canvas.graph_mouse[1] < node.pos[1] // If we are over a node, but not within the node then we are on its title ) { - return showTooltip(nodeDef?.description) + return showTooltip( + resolveNodeDefText('description', nodeType, nodeDef?.description) + ) } if (node.flags?.collapsed) return @@ -84,11 +86,14 @@ function onIdle() { ) if (inputSlot !== -1) { const inputName = node.inputs[inputSlot].name - const translatedTooltip = stRaw( - `nodeDefs.${normalizeI18nKey(node.type ?? '')}.inputs.${normalizeI18nKey(inputName)}.tooltip`, - nodeDef?.inputs[inputName]?.tooltip ?? '' + return showTooltip( + resolveNodeDefSlotText( + 'tooltip', + nodeType, + inputName, + nodeDef?.inputs[inputName]?.tooltip + ) ) - return showTooltip(translatedTooltip) } const outputSlot = isOverNodeOutput( @@ -98,19 +103,24 @@ function onIdle() { [0, 0] ) if (outputSlot !== -1) { - const translatedTooltip = stRaw( - `nodeDefs.${normalizeI18nKey(node.type ?? '')}.outputs.${outputSlot}.tooltip`, - nodeDef?.outputs[outputSlot]?.tooltip ?? '' + return showTooltip( + resolveNodeDefSlotText( + 'tooltip', + nodeType, + outputSlot, + nodeDef?.outputs[outputSlot]?.tooltip + ) ) - return showTooltip(translatedTooltip) } const widget = comfyApp.canvas.getWidgetAtCursor() // Dont show for DOM widgets, these use native browser tooltips as we dont get proper mouse events on these if (widget && !isDOMWidget(widget)) { - const translatedTooltip = stRaw( - `nodeDefs.${normalizeI18nKey(node.type ?? '')}.inputs.${normalizeI18nKey(widget.name)}.tooltip`, - nodeDef?.inputs[widget.name]?.tooltip ?? '' + const translatedTooltip = resolveNodeDefSlotText( + 'tooltip', + nodeType, + widget.name, + nodeDef?.inputs[widget.name]?.tooltip ) // Widget tooltip can be set dynamically, current translation collection does not support this. return showTooltip(widget.tooltip ?? translatedTooltip) diff --git a/src/i18n.test.ts b/src/i18n.test.ts index de60aec8395..2d3aad48d92 100644 --- a/src/i18n.test.ts +++ b/src/i18n.test.ts @@ -5,6 +5,7 @@ import type * as I18nModule from './i18n' let i18n: typeof I18nModule.i18n let loadLocale: typeof I18nModule.loadLocale let resolveNodeDefText: typeof I18nModule.resolveNodeDefText +let resolveNodeDefSlotText: typeof I18nModule.resolveNodeDefSlotText let setBackendNodeText: typeof I18nModule.setBackendNodeText let mergeCustomNodesI18n: typeof I18nModule.mergeCustomNodesI18n let resolveSupportedLocale: typeof I18nModule.resolveSupportedLocale @@ -16,6 +17,7 @@ async function importI18nModule() { i18n = i18nModule.i18n loadLocale = i18nModule.loadLocale resolveNodeDefText = i18nModule.resolveNodeDefText + resolveNodeDefSlotText = i18nModule.resolveNodeDefSlotText setBackendNodeText = i18nModule.setBackendNodeText mergeCustomNodesI18n = i18nModule.mergeCustomNodesI18n resolveSupportedLocale = i18nModule.resolveSupportedLocale @@ -37,7 +39,18 @@ function restoreEnNodeDefsMock() { } Object.assign(enNodeDefsMock, { testNode: 'Test Node', - KSampler: { display_name: 'KSampler (bundled)' } + KSampler: { + display_name: 'KSampler (bundled)', + inputs: { + seed: { name: 'seed (bundled)', tooltip: 'Seed tooltip (bundled)' }, + // The serializer escapes `name` and leaves `tooltip` verbatim, so the + // same source text is stored differently per field. + syntax: { name: "50{'%'} {'@'}", tooltip: "50{'%'} {'@'}" } + }, + outputs: { + 0: { name: 'LATENT (bundled)', tooltip: 'Latent tooltip (bundled)' } + } + } }) } @@ -54,7 +67,12 @@ vi.mock('./locales/en/settings.json', () => ({ // Mock lazy-loaded locales vi.mock('./locales/zh/main.json', () => ({ default: { welcome: '欢迎' } })) vi.mock('./locales/zh/nodeDefs.json', () => ({ - default: { testNode: '测试节点' } + default: { + testNode: '测试节点', + KSampler: { + inputs: { seed: { name: '种子', tooltip: '种子提示' } } + } + } })) vi.mock('./locales/zh/commands.json', () => ({ default: { save: '保存' } })) vi.mock('./locales/zh/settings.json', () => ({ default: { theme: '主题' } })) @@ -154,7 +172,9 @@ describe('i18n', () => { // 4. Also verify base locale data is present expect(zhMessages.welcome).toBe('欢迎') - expect(zhMessages.nodeDefs).toEqual({ testNode: '测试节点' }) + expect(zhMessages.nodeDefs).toEqual( + expect.objectContaining({ testNode: '测试节点' }) + ) }) it('should handle multiple locales in custom nodes i18n data', async () => { @@ -366,6 +386,129 @@ describe('i18n', () => { }) }) + describe('slot text', () => { + describe('precedence', () => { + it.for([ + { field: 'name', slot: 'seed', backend: 'Live Seed' }, + { field: 'tooltip', slot: 0, backend: 'Live tooltip' } + ] as const)( + 'en: live $field for slot $slot beats the bundled snapshot', + ({ field, slot, backend }) => { + expect(resolveNodeDefSlotText(field, 'KSampler', slot, backend)).toBe( + backend + ) + } + ) + + it.for([ + { + field: 'tooltip', + slot: 'seed', + expected: 'Seed tooltip (bundled)' + }, + { + field: 'name', + slot: 0, + expected: 'LATENT (bundled)' + } + ] as const)( + 'en: bundled $field for slot $slot is used without backend text', + ({ field, slot, expected }) => { + expect(resolveNodeDefSlotText(field, 'KSampler', slot)).toBe(expected) + } + ) + + it('en: falls back to the caller fallback when nothing supplies text', () => { + expect( + resolveNodeDefSlotText('name', 'Unknown', 'seed', undefined, 'seed') + ).toBe('seed') + expect(resolveNodeDefSlotText('tooltip', 'Unknown', 0)).toBe('') + }) + + it('en: a custom-node translation beats the backend', () => { + mergeCustomNodesI18n({ + en: { + nodeDefs: { + KSampler: { inputs: { seed: { name: 'Custom Seed' } } } + } + } + }) + + expect( + resolveNodeDefSlotText('name', 'KSampler', 'seed', 'Live Seed') + ).toBe('Custom Seed') + }) + + it('non-en: the translation stays authoritative over the backend', async () => { + await setActiveLocale('zh') + + expect( + resolveNodeDefSlotText('name', 'KSampler', 'seed', 'Live Seed') + ).toBe('种子') + expect( + resolveNodeDefSlotText('tooltip', 'KSampler', 'seed', 'Live tooltip') + ).toBe('种子提示') + }) + + it('non-en: falls back to the live backend value, not the en snapshot', async () => { + await setActiveLocale('zh') + + expect( + resolveNodeDefSlotText('name', 'KSampler', 0, 'Live Latent') + ).toBe('Live Latent') + }) + }) + + describe('raw / compiled split', () => { + it('compiles a bundled name but returns a bundled tooltip uncompiled', () => { + expect(resolveNodeDefSlotText('name', 'KSampler', 'syntax')).toBe( + '50% @' + ) + expect(resolveNodeDefSlotText('tooltip', 'KSampler', 'syntax')).toBe( + "50{'%'} {'@'}" + ) + }) + + it('returns backend slot text verbatim, never through the compiler', () => { + const raw = "Mask {'@'} 100% | D:\\output" + + expect(resolveNodeDefSlotText('tooltip', 'KSampler', 'seed', raw)).toBe( + raw + ) + }) + }) + + describe('key resolution', () => { + it('normalizes dotted input names', () => { + mergeCustomNodesI18n({ + en: { + nodeDefs: { + KSampler: { inputs: { a_b: { name: 'Dotted Input' } } } + } + } + }) + + expect(resolveNodeDefSlotText('name', 'KSampler', 'a.b', 'Live')).toBe( + 'Dotted Input' + ) + }) + + it('resolves the legacy nested shape hand-written locales use', () => { + mergeCustomNodesI18n({ + en: { + nodeDefs: { + my: { node: { inputs: { seed: { name: 'Nested Seed' } } } } + } + } + }) + + expect(resolveNodeDefSlotText('name', 'my.node', 'seed', 'Live')).toBe( + 'Nested Seed' + ) + }) + }) + }) + describe('loadLocale', () => { it('should not reload already loaded locale', async () => { await loadLocale('zh') diff --git a/src/i18n.ts b/src/i18n.ts index 569c99fd45b..bee9df28c7b 100644 --- a/src/i18n.ts +++ b/src/i18n.ts @@ -167,25 +167,22 @@ export function setBackendNodeText( } } -function customNodesProvide( - nodeName: string, - field: NodeDefTextField -): boolean { +function customNodesProvide(nodeName: string, path: string): boolean { const data = customNodesI18nData[i18n.global.locale.value] if (typeof data !== 'object' || data === null) return false const nodeDefs = (data as Record)['nodeDefs'] if (typeof nodeDefs !== 'object' || nodeDefs === null) return false - for (const path of nodeDefKeyCandidates(nodeName)) { + for (const candidate of nodeDefKeyCandidates(nodeName)) { let cursor: unknown = nodeDefs - for (const segment of path.split('.')) { - if (typeof cursor !== 'object' || cursor === null) break + for (const segment of `${candidate}.${path}`.split('.')) { + if (typeof cursor !== 'object' || cursor === null) { + cursor = undefined + break + } cursor = (cursor as Record)[segment] } - if (typeof cursor === 'object' && cursor !== null) { - if (typeof (cursor as Record)[field] === 'string') - return true - } + if (typeof cursor === 'string') return true } return false } @@ -200,14 +197,20 @@ function nodeDefKeyCandidates(nodeName: string): string[] { return normalized === nodeName ? [normalized] : [normalized, nodeName] } +/** + * Reads a resolved locale message. `st` compiles it; `stRaw` does not. + */ +type MessageReader = (key: string, fallbackMessage: string) => string + function translateNodeDefText( nodeName: string, - field: NodeDefTextField, - fallback: string + path: string, + fallback: string, + read: MessageReader ): string { - for (const path of nodeDefKeyCandidates(nodeName)) { - const key = `nodeDefs.${path}.${field}` - if (te(key)) return st(key, fallback) + for (const candidate of nodeDefKeyCandidates(nodeName)) { + const key = `nodeDefs.${candidate}.${path}` + if (te(key)) return read(key, fallback) } return fallback } @@ -222,6 +225,21 @@ function translateNodeDefText( * Other locales: translations stay authoritative, falling back to the live * backend value rather than the stale English snapshot. */ +function resolveNodeDefPath( + nodeName: string, + path: string, + backend: string | undefined, + fallback: string, + read: MessageReader +): string { + if (customNodesProvide(nodeName, path)) { + return translateNodeDefText(nodeName, path, fallback, read) + } + if (i18n.global.locale.value === 'en' && backend !== undefined) return backend + + return translateNodeDefText(nodeName, path, fallback, read) +} + export function resolveNodeDefText( field: NodeDefTextField, nodeName: string, @@ -230,12 +248,40 @@ export function resolveNodeDefText( const backend = backendValue ?? backendNodeText.get(nodeName)?.[field] const fallback = backend ?? (field === 'display_name' ? nodeName : '') - if (customNodesProvide(nodeName, field)) { - return translateNodeDefText(nodeName, field, fallback) - } - if (i18n.global.locale.value === 'en' && backend !== undefined) return backend + return resolveNodeDefPath(nodeName, field, backend, fallback, st) +} + +/** Slot fields the generated locales carry text for. */ +export type NodeDefSlotTextField = 'name' | 'tooltip' - return translateNodeDefText(nodeName, field, fallback) +/** + * `name` is escaped by `scripts/nodeDefLocaleSerializer.ts` and has to be + * compiled back; `tooltip` is stored verbatim and must never reach the message + * compiler, or a literal `{'@'}` would render to the user. + */ +function slotMessageReader(field: NodeDefSlotTextField): MessageReader { + return field === 'tooltip' ? stRaw : st +} + +export function resolveNodeDefSlotText( + field: NodeDefSlotTextField, + nodeName: string, + slot: string | number, + backendValue?: string, + fallbackValue = '' +): string { + const slotPath = + typeof slot === 'string' + ? `inputs.${normalizeI18nKey(slot)}` + : `outputs.${slot}` + + return resolveNodeDefPath( + nodeName, + `${slotPath}.${field}`, + backendValue, + backendValue ?? fallbackValue, + slotMessageReader(field) + ) } // Only include English in the initial bundle; other locales lazy-load. diff --git a/src/locales/en/main.json b/src/locales/en/main.json index fc856a020e3..a45bed8cc4d 100644 --- a/src/locales/en/main.json +++ b/src/locales/en/main.json @@ -232,6 +232,7 @@ "bookmarked": "Bookmarked", "essentials": "Essentials", "input": "Input", + "inputTooltip": "Input: {name}", "output": "Output", "community": "Community", "all": "All", diff --git a/src/renderer/extensions/vueNodes/components/InputSlot.test.ts b/src/renderer/extensions/vueNodes/components/InputSlot.test.ts new file mode 100644 index 00000000000..9498025a6f2 --- /dev/null +++ b/src/renderer/extensions/vueNodes/components/InputSlot.test.ts @@ -0,0 +1,129 @@ +import { createTestingPinia } from '@pinia/testing' +import { describe, expect, it, vi } from 'vitest' +import { defineComponent } from 'vue' +import type { DirectiveBinding } from 'vue' +import { createI18n } from 'vue-i18n' + +import { render, screen } from '@testing-library/vue' + +import type { INodeSlot } from '@/lib/litegraph/src/litegraph' +import { useSettingStore } from '@/platform/settings/settingStore' +import type { Settings } from '@/schemas/apiSchema' +import type { ComfyNodeDef } from '@/schemas/nodeDefSchema' +import { useNodeDefStore } from '@/stores/nodeDefStore' + +import InputSlot from './InputSlot.vue' + +vi.mock('@/composables/useErrorHandling', () => ({ + useErrorHandling: () => ({ toastErrorHandler: vi.fn() }) +})) + +vi.mock('@/renderer/core/canvas/links/slotLinkDragUIState', () => ({ + useSlotLinkDragUIState: () => ({ + state: { active: false, compatible: new Map() } + }) +})) + +vi.mock( + '@/renderer/extensions/vueNodes/composables/useSlotElementTracking', + () => ({ useSlotElementTracking: vi.fn() }) +) + +vi.mock( + '@/renderer/extensions/vueNodes/composables/useSlotLinkInteraction', + () => ({ + useSlotLinkInteraction: () => ({ + onClick: vi.fn(), + onDoubleClick: vi.fn(), + onPointerDown: vi.fn() + }) + }) +) + +vi.mock('@/renderer/core/layout/slots/slotIdentifier', () => ({ + getSlotKey: () => 'mock-key' +})) + +const SlotConnectionDotStub = defineComponent({ + name: 'SlotConnectionDot', + template: '
' +}) +const i18n = createI18n({ + legacy: false, + locale: 'en', + messages: { en: { g: { inputTooltip: 'Translated input: {name}' } } } +}) + +const nodeDef: ComfyNodeDef = { + name: 'TestInputSlot', + display_name: 'Test Input Slot', + category: 'testing', + python_module: 'nodes', + description: '', + input: { + required: { + raw_seed: ['INT', { tooltip: 'Metadata seed tooltip' }] + } + }, + output: [], + output_node: false +} + +function renderInputSlot(slotData: INodeSlot, nodeType = nodeDef.name) { + const pinia = createTestingPinia({ stubActions: false }) + const settingStore = useSettingStore(pinia) + vi.spyOn(settingStore, 'get').mockImplementation( + (key: K): Settings[K] => { + if (key === 'Comfy.EnableTooltips') return true as Settings[K] + if (key === 'LiteGraph.Node.TooltipDelay') return 500 as Settings[K] + return undefined as Settings[K] + } + ) + useNodeDefStore(pinia).addNodeDef(nodeDef) + const tooltipDirective = { + mounted: vi.fn((_element: Element, _binding: DirectiveBinding) => {}) + } + + render(InputSlot, { + props: { slotData, index: 0, nodeType }, + global: { + plugins: [i18n, pinia], + directives: { tooltip: tooltipDirective }, + stubs: { SlotConnectionDot: SlotConnectionDotStub } + } + }) + + return tooltipDirective +} + +describe('InputSlot', () => { + it('resolves metadata tooltips by raw input name', () => { + const tooltipDirective = renderInputSlot({ + name: 'raw_seed', + localized_name: 'Localized Seed', + type: 'INT' + } as INodeSlot) + + expect(screen.getByText('Localized Seed')).toBeInTheDocument() + expect(tooltipDirective.mounted.mock.calls[0]?.[1].value).toEqual( + expect.objectContaining({ value: 'Metadata seed tooltip' }) + ) + }) + + it('uses the localized display name in the translated fallback', () => { + const tooltipDirective = renderInputSlot( + { + name: 'raw_count', + localized_name: 'Localized Count', + type: 'INT' + } as INodeSlot, + 'UnknownNode' + ) + + expect(tooltipDirective.mounted.mock.calls[0]?.[1].value).toEqual( + expect.objectContaining({ + value: 'Translated input: Localized Count' + }) + ) + }) +}) diff --git a/src/renderer/extensions/vueNodes/components/InputSlot.vue b/src/renderer/extensions/vueNodes/components/InputSlot.vue index 3db6bafd2a3..e076378f9e5 100644 --- a/src/renderer/extensions/vueNodes/components/InputSlot.vue +++ b/src/renderer/extensions/vueNodes/components/InputSlot.vue @@ -57,6 +57,7 @@