From 39e711ab61e52e35d3512c7d379a0340a2e57f4c Mon Sep 17 00:00:00 2001 From: Benjamin Lu Date: Mon, 26 Oct 2026 11:28:36 -0700 Subject: [PATCH] refactor(keybindings): resolve every keydown once, in the capture phase Main has two dispatchers with different guards: a window bubble listener for most shortcuts and a canvas listener, reached through the patched LGraphCanvas.processKey, for canvas-targeted ones. Each looked the key up again, at a different moment. A window capture listener now resolves each keydown once and records the result per event. The canvas path and the window bubble path read that result and commit exactly where they did before: canvas-targeted, non-repeat keys at the canvas with stopImmediatePropagation, everything else at window bubble. Key order seen by extensions does not change. Behaviour that does change: - Keys typed anywhere inside a contenteditable region, including plaintext-only editors and nested elements, stay with the editor. Before, only an element whose own contentEditable was "true" counted. - Keys pressed while an input method is composing are left to it. - A key is judged against the state when it was pressed. A keydown that closes a dialog on its way to the window no longer also runs the workspace shortcut bound to that key. --- .../keybindingService.resolution.test.ts | 143 +++++++++++ src/platform/keybindings/keybindingService.ts | 242 +++++++++++------- src/views/GraphView.test.ts | 2 +- src/views/GraphView.vue | 2 +- 4 files changed, 297 insertions(+), 92 deletions(-) create mode 100644 src/platform/keybindings/keybindingService.resolution.test.ts diff --git a/src/platform/keybindings/keybindingService.resolution.test.ts b/src/platform/keybindings/keybindingService.resolution.test.ts new file mode 100644 index 00000000000..409a3d1479b --- /dev/null +++ b/src/platform/keybindings/keybindingService.resolution.test.ts @@ -0,0 +1,143 @@ +import { effectScope, markRaw } from 'vue' +import type { EffectScope } from 'vue' +import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest' + +import { KeybindingImpl } from '@/platform/keybindings/keybinding' +import { useKeybindingService } from '@/platform/keybindings/keybindingService' +import { useKeybindingStore } from '@/platform/keybindings/keybindingStore' +import { useSettingStore } from '@/platform/settings/settingStore' +import { useCommandStore } from '@/stores/commandStore' +import { useDialogStore } from '@/stores/dialogStore' + +const COMMAND_ID = 'Test.Shortcut' + +function pressKey(target: EventTarget, init: KeyboardEventInit = {}) { + target.dispatchEvent( + new KeyboardEvent('keydown', { + key: 'k', + bubbles: true, + cancelable: true, + ...init + }) + ) +} + +function bindTestShortcut(targetElementId?: string) { + useKeybindingStore().addUserKeybinding( + new KeybindingImpl({ + commandId: COMMAND_ID, + combo: { key: 'k' }, + targetElementId + }) + ) +} + +function openDialog() { + useDialogStore().dialogStack.push({ + key: 'test-dialog', + visible: true, + component: markRaw({ template: '
' }), + contentProps: {}, + dialogComponentProps: {}, + priority: 0 + }) +} + +describe('keybindingService - keydown resolution', () => { + let scope: EffectScope + const removals: Array<() => void> = [] + + beforeEach(() => { + vi.mocked(useSettingStore().get).mockImplementation(() => []) + vi.mocked(useCommandStore().execute).mockResolvedValue(undefined) + useDialogStore().dialogStack.length = 0 + useCommandStore().registerCommand({ id: COMMAND_ID, function: vi.fn() }) + + scope = effectScope() + scope.run(() => useKeybindingService().listenForKeydowns()) + }) + + afterEach(() => { + scope.stop() + removals.splice(0).forEach((remove) => remove()) + document.body.replaceChildren() + }) + + it('runs a bound shortcut through the window listeners', () => { + bindTestShortcut() + + pressKey(document.body) + + expect(useCommandStore().execute).toHaveBeenCalledOnce() + expect(useCommandStore().execute).toHaveBeenCalledWith(COMMAND_ID) + }) + + it.for([ + { + name: 'a plaintext-only editor', + build: (editor: HTMLElement) => { + editor.contentEditable = 'plaintext-only' + return editor + } + }, + { + name: 'a focusable element nested in an editor', + build: (editor: HTMLElement) => { + editor.contentEditable = 'true' + const chip = document.createElement('span') + chip.tabIndex = 0 + editor.append(chip) + return chip + } + } + ])('leaves a key typed in $name to the editor', ({ build }) => { + bindTestShortcut() + const editor = document.createElement('div') + document.body.append(editor) + + pressKey(build(editor)) + + expect(useCommandStore().execute).not.toHaveBeenCalled() + }) + + it('leaves keys to an input method while it is composing', () => { + bindTestShortcut() + + pressKey(document.body, { isComposing: true }) + + expect(useCommandStore().execute).not.toHaveBeenCalled() + }) + + it('does not run a workspace shortcut for a key that also closed a dialog', () => { + bindTestShortcut() + openDialog() + const closeDialog = () => { + useDialogStore().dialogStack.length = 0 + } + document.addEventListener('keydown', closeDialog) + removals.push(() => document.removeEventListener('keydown', closeDialog)) + + pressKey(document.body) + + expect(useCommandStore().execute).not.toHaveBeenCalled() + }) + + it('runs a canvas-targeted shortcut from the canvas listener', () => { + bindTestShortcut('graph-canvas-container') + const container = document.createElement('div') + container.id = 'graph-canvas-container' + const canvas = document.createElement('canvas') + container.append(canvas) + document.body.append(container) + const { executeCanvasKeybinding } = useKeybindingService() + const onCanvasKeydown = (event: KeyboardEvent) => { + executeCanvasKeybinding(event) + } + canvas.addEventListener('keydown', onCanvasKeydown, true) + + pressKey(canvas) + + expect(useCommandStore().execute).toHaveBeenCalledOnce() + expect(useCommandStore().execute).toHaveBeenCalledWith(COMMAND_ID) + }) +}) diff --git a/src/platform/keybindings/keybindingService.ts b/src/platform/keybindings/keybindingService.ts index eb90bd1a3fb..dcc8eb551d2 100644 --- a/src/platform/keybindings/keybindingService.ts +++ b/src/platform/keybindings/keybindingService.ts @@ -1,3 +1,5 @@ +import { useEventListener } from '@vueuse/core' + import { isCloud } from '@/platform/distribution/types' import { useSettingStore } from '@/platform/settings/settingStore' import { useCommandStore } from '@/stores/commandStore' @@ -10,6 +12,89 @@ import { KeyComboImpl } from './keyCombo' import { KeybindingImpl } from './keybinding' import { useKeybindingStore } from './keybindingStore' +type KeydownResolution = + | { kind: 'unclaimed' } + | { kind: 'blockedByModal'; suppressBrowserDefault: boolean } + | { kind: 'legacyEscape' } + | { kind: 'claimed'; keybinding: KeybindingImpl } + +const UNCLAIMED: KeydownResolution = { kind: 'unclaimed' } +const LEGACY_ESCAPE: KeydownResolution = { kind: 'legacyEscape' } + +const CANVAS_CONTAINER_ID = 'graph-canvas-container' + +const RUN_COMMAND_IDS = new Set([ + 'Comfy.QueuePrompt', + 'Comfy.QueuePromptFront', + 'Comfy.QueueSelectedOutputNodes' +]) + +const resolutions = new WeakMap() + +function isTextEditingTarget(target: EventTarget | undefined): boolean { + if (!(target instanceof Element)) return false + if (target instanceof HTMLElement && target.isContentEditable) return true + return ( + target.tagName === 'TEXTAREA' || + target.tagName === 'INPUT' || + (target.tagName === 'SPAN' && target.classList.contains('property_value')) + ) +} + +function isEscapeOwnedByMenuOrDialog( + event: KeyboardEvent, + target: EventTarget | undefined +): boolean { + return ( + event.key === 'Escape' && + target instanceof Element && + target.closest('[role="menu"], [role="menubar"], [role="dialog"]') !== null + ) +} + +function isLeftToTarget( + event: KeyboardEvent, + keyCombo: KeyComboImpl, + target: EventTarget | undefined +): boolean { + return ( + keyCombo.isModifier || + event.isComposing || + isEscapeOwnedByMenuOrDialog(event, target) || + (keyCombo.isReservedByTextInput && isTextEditingTarget(target)) + ) +} + +function isWithinTargetElement( + keybinding: KeybindingImpl, + target: EventTarget | undefined +): boolean { + const targetElementId = + keybinding.targetElementId === 'graph-canvas' + ? CANVAS_CONTAINER_ID + : keybinding.targetElementId + if (!targetElementId) return true + const container = document.getElementById(targetElementId) + return target instanceof Node && container?.contains(target) === true +} + +function isUnmodifiedEscape(event: KeyboardEvent): boolean { + return ( + event.key === 'Escape' && !event.ctrlKey && !event.altKey && !event.metaKey + ) +} + +function closeLegacyModals() { + for (const modal of document.querySelectorAll('.comfy-modal')) { + const display = window.getComputedStyle(modal).getPropertyValue('display') + if (display !== 'none') { + modal.style.display = 'none' + break + } + } + for (const dialog of document.querySelectorAll('dialog')) dialog.close() +} + export function useKeybindingService() { const keybindingStore = useKeybindingStore() const commandStore = useCommandStore() @@ -23,115 +108,91 @@ export function useKeybindingService() { : undefined } + function resolve(event: KeyboardEvent): KeydownResolution { + const keyCombo = KeyComboImpl.fromEvent(event) + const target = event.composedPath()[0] + if (isLeftToTarget(event, keyCombo, target)) return UNCLAIMED + + const keybinding = getExecutableKeybinding(keyCombo) + if (!keybinding) + return isUnmodifiedEscape(event) ? LEGACY_ESCAPE : UNCLAIMED + if (!isWithinTargetElement(keybinding, target)) return UNCLAIMED + if (isModalOpen(dialogStore.dialogStack.length)) { + return { kind: 'blockedByModal', suppressBrowserDefault: keyCombo.ctrl } + } + return { kind: 'claimed', keybinding } + } + + function resolutionOf(event: KeyboardEvent): KeydownResolution { + const resolved = resolutions.get(event) + if (resolved) return resolved + const resolution = resolve(event) + resolutions.set(event, resolution) + return resolution + } + + function resolveKeydown(event: KeyboardEvent) { + resolutions.set(event, resolve(event)) + } + function executeCanvasKeybinding(event: KeyboardEvent): boolean { if (event.type !== 'keydown' || event.repeat) return false - if (isModalOpen(dialogStore.dialogStack.length)) return false - const keybinding = getExecutableKeybinding(KeyComboImpl.fromEvent(event)) - if (keybinding?.targetElementId !== 'graph-canvas-container') return false + const resolution = resolutionOf(event) + if ( + resolution.kind !== 'claimed' || + resolution.keybinding.targetElementId !== CANVAS_CONTAINER_ID + ) { + return false + } - void commandStore.execute(keybinding.commandId) + void commandStore.execute(resolution.keybinding.commandId) event.preventDefault() event.stopImmediatePropagation() return true } - async function keybindHandler(event: KeyboardEvent) { - const keyCombo = KeyComboImpl.fromEvent(event) - if (keyCombo.isModifier) { - return - } - - const target = event.composedPath()[0] as HTMLElement - // Let the active menu own Escape without also triggering the global shortcut. - // `target` is usually the focused element, but when nothing has focus some - // browsers (e.g. Safari) target the event at `document` instead of - // `document.body`, which has no `closest` method. - if ( - event.key === 'Escape' && - target instanceof Element && - target.closest('[role="menu"], [role="menubar"], [role="dialog"]') - ) { + async function executeKeybinding(keybinding: KeybindingImpl) { + if (RUN_COMMAND_IDS.has(keybinding.commandId)) { + await commandStore.execute(keybinding.commandId, { + metadata: { trigger_source: 'keybinding' } + }) return } + await commandStore.execute(keybinding.commandId) + } - if ( - keyCombo.isReservedByTextInput && - (target.tagName === 'TEXTAREA' || - target.tagName === 'INPUT' || - target.contentEditable === 'true' || - (target.tagName === 'SPAN' && - target.classList.contains('property_value'))) - ) { + async function commitAtWindow( + keybinding: KeybindingImpl, + event: KeyboardEvent + ) { + if (event.key === 'Escape' && consultEscapeOverride(event)) { + if (!event.defaultPrevented) event.preventDefault() return } + event.preventDefault() + await executeKeybinding(keybinding) + } - const keybinding = getExecutableKeybinding(keyCombo) - if (keybinding) { - const targetElementId = - keybinding.targetElementId === 'graph-canvas' - ? 'graph-canvas-container' - : keybinding.targetElementId - if (targetElementId) { - const container = document.getElementById(targetElementId) - if (!container?.contains(target)) { - return - } - } - if (isModalOpen(dialogStore.dialogStack.length)) { - // Bare keys still have to reach inputs inside the dialog. - if (keyCombo.ctrl) { - event.preventDefault() - } + async function keybindHandler(event: KeyboardEvent) { + const resolution = resolutionOf(event) + switch (resolution.kind) { + case 'unclaimed': return - } - - // A registered override (e.g. the agent composer owning Escape while a - // turn is running) wins over the default keybinding, but only once an - // open menu or dialog has already had first refusal above - those are - // more specific to the moment than "some feature elsewhere is running". - if (event.key === 'Escape' && consultEscapeOverride(event)) { - if (!event.defaultPrevented) event.preventDefault() + case 'blockedByModal': + if (resolution.suppressBrowserDefault) event.preventDefault() return - } - - event.preventDefault() - const runCommandIds = new Set([ - 'Comfy.QueuePrompt', - 'Comfy.QueuePromptFront', - 'Comfy.QueueSelectedOutputNodes' - ]) - if (runCommandIds.has(keybinding.commandId)) { - await commandStore.execute(keybinding.commandId, { - metadata: { - trigger_source: 'keybinding' - } - }) - } else { - await commandStore.execute(keybinding.commandId) - } - return - } - - if (event.ctrlKey || event.altKey || event.metaKey) { - return + case 'legacyEscape': + closeLegacyModals() + return + case 'claimed': + await commitAtWindow(resolution.keybinding, event) } + } - if (event.key === 'Escape') { - const modals = document.querySelectorAll('.comfy-modal') - for (const modal of modals) { - const modalDisplay = window - .getComputedStyle(modal) - .getPropertyValue('display') - - if (modalDisplay !== 'none') { - modal.style.display = 'none' - break - } - } - - for (const d of document.querySelectorAll('dialog')) d.close() - } + function listenForKeydowns() { + useEventListener(window, 'keydown', resolveKeydown, { capture: true }) + useEventListener(window, 'keydown', keybindHandler) } function registerCoreKeybindings() { @@ -175,6 +236,7 @@ export function useKeybindingService() { } return { + listenForKeydowns, executeCanvasKeybinding, keybindHandler, registerCoreKeybindings, diff --git a/src/views/GraphView.test.ts b/src/views/GraphView.test.ts index 73586d64fad..0ce58c17ea2 100644 --- a/src/views/GraphView.test.ts +++ b/src/views/GraphView.test.ts @@ -158,7 +158,7 @@ vi.mock(import('@/services/autoQueueService'), () => ({ vi.mock(import('@/platform/keybindings/keybindingService'), () => ({ useKeybindingService: () => ({ registerCoreKeybindings: vi.fn(), - keybindHandler: vi.fn() + listenForKeydowns: vi.fn() }) })) diff --git a/src/views/GraphView.vue b/src/views/GraphView.vue index 8cd68292d01..e315e052112 100644 --- a/src/views/GraphView.vue +++ b/src/views/GraphView.vue @@ -335,7 +335,7 @@ onBeforeUnmount(() => { executionStore.unbindExecutionEvents() }) -useEventListener(window, 'keydown', useKeybindingService().keybindHandler) +useKeybindingService().listenForKeydowns() const { wrapWithErrorHandling, wrapWithErrorHandlingAsync } = useErrorHandling()