diff --git a/browser_tests/fixtures/components/Topbar.ts b/browser_tests/fixtures/components/Topbar.ts index 608a262f075..870e787b97e 100644 --- a/browser_tests/fixtures/components/Topbar.ts +++ b/browser_tests/fixtures/components/Topbar.ts @@ -59,10 +59,14 @@ export class Topbar { return classes ? !classes.includes('invisible') : false } + getWorkflowTabLabel(tabName: string): Locator { + return this.page.locator( + `.workflow-tabs .workflow-label:has-text("${tabName}")` + ) + } + getWorkflowTab(tabName: string): Locator { - return this.page - .locator(`.workflow-tabs .workflow-label:has-text("${tabName}")`) - .locator('..') + return this.getWorkflowTabLabel(tabName).locator('..') } getTab(index: number): Locator { diff --git a/browser_tests/tests/canvas/copyPasteAfterTextSelection.spec.ts b/browser_tests/tests/canvas/copyPasteAfterTextSelection.spec.ts new file mode 100644 index 00000000000..c7cbe206b1b --- /dev/null +++ b/browser_tests/tests/canvas/copyPasteAfterTextSelection.spec.ts @@ -0,0 +1,28 @@ +import { + comfyExpect as expect, + comfyPageFixture as test +} from '@e2e/fixtures/ComfyPage' + +test.describe( + 'Copy and paste after selecting text outside the canvas', + { tag: ['@canvas', '@node'] }, + () => { + test('a node clicked on the classic canvas copies and pastes while topbar text is selected', async ({ + comfyPage + }) => { + const before = await comfyPage.nodeOps.getGraphNodesCount() + const [node] = await comfyPage.nodeOps.getNodeRefsByTitle('KSampler') + + await comfyPage.menu.topbar + .getWorkflowTabLabel('Unsaved Workflow') + .selectText() + await node.click('title') + await comfyPage.clipboard.copy() + await comfyPage.clipboard.paste() + + await expect + .poll(() => comfyPage.nodeOps.getGraphNodesCount()) + .toBe(before + 1) + }) + } +) diff --git a/src/components/graph/GraphCanvas.vue b/src/components/graph/GraphCanvas.vue index 665d411d76b..816e5c73d5d 100644 --- a/src/components/graph/GraphCanvas.vue +++ b/src/components/graph/GraphCanvas.vue @@ -202,7 +202,10 @@ import { ChangeTracker } from '@/scripts/changeTracker' import { IS_CONTROL_WIDGET, updateControlWidgetLabel } from '@/scripts/widgets' import { useColorPaletteService } from '@/services/colorPaletteService' import { useNewUserService } from '@/services/useNewUserService' -import { shouldIgnoreCopyPaste } from '@/workbench/eventHelpers' +import { + collapseOutsideSelectionOnPrimaryPointerDown, + shouldIgnoreCopyPaste +} from '@/workbench/eventHelpers' import { storeToRefs } from 'pinia' import { useBootstrapStore } from '@/stores/bootstrapStore' @@ -617,7 +620,16 @@ onUnmounted(() => { cleanupErrorHooks?.() cleanupErrorHooks = null }) + +useEventListener( + canvasRef, + 'pointerdown', + collapseOutsideSelectionOnPrimaryPointerDown, + { capture: true } +) + function forwardPointerDownPanEvent(e: PointerEvent) { + collapseOutsideSelectionOnPrimaryPointerDown(e) forwardPanEvent(e, isMiddlePointerInput) } diff --git a/src/composables/useCopy.test.ts b/src/composables/useCopy.test.ts index afd70f8a2e9..5c468bd0cfc 100644 --- a/src/composables/useCopy.test.ts +++ b/src/composables/useCopy.test.ts @@ -1,55 +1,64 @@ -import { beforeEach, describe, expect, it, vi } from 'vitest' +import { + assert, + beforeEach, + describe, + expect, + it, + onTestFinished, + vi +} from 'vitest' +import { effectScope } from 'vue' import { useCopy } from './useCopy' +import { useCanvasStore } from '@/renderer/core/canvas/canvasStore' +import type { LGraphCanvas } from '@/lib/litegraph/src/litegraph' +import { fromPartial } from '@total-typescript/shoehorn' -const copyMocks = vi.hoisted(() => ({ - copyHandler: undefined as ((event: ClipboardEvent) => unknown) | undefined, +const copyMocks = { canvas: { selectedItems: new Set([{}]), copyToClipboard: vi.fn() } -})) - -vi.mock('@vueuse/core', () => ({ - useEventListener: vi.fn( - ( - _target: EventTarget, - event: string, - handler: (event: ClipboardEvent) => unknown - ) => { - if (event === 'copy') copyMocks.copyHandler = handler - return vi.fn() - } - ) -})) +} -vi.mock('@/renderer/core/canvas/canvasStore', () => ({ - useCanvasStore: () => ({ - canvas: copyMocks.canvas - }) -})) +const multiChunkPayloadLength = 0x8000 * 6 + 123 +const canvasClipboardKey = 'litegrapheditor_clipboard' +const canvasClipboardIdKey = 'litegrapheditor_clipboard_id' -vi.mock('@/workbench/eventHelpers', () => ({ - shouldIgnoreCopyPaste: vi.fn(() => false) -})) +function mountCopy(): void { + const scope = effectScope() + scope.run(useCopy) + onTestFinished(() => scope.stop()) +} -const multiChunkPayloadLength = 0x8000 * 6 + 123 +function dispatchCopy(target: EventTarget = document): DataTransfer { + const dataTransfer = new DataTransfer() + target.dispatchEvent( + new ClipboardEvent('copy', { clipboardData: dataTransfer, bubbles: true }) + ) + + return dataTransfer +} function copySerializedData(serializedData: string): DataTransfer { copyMocks.canvas.copyToClipboard.mockReturnValue(serializedData) + return dispatchCopy() +} - useCopy() - - const dataTransfer = new DataTransfer() - const event = new ClipboardEvent('copy', { - clipboardData: dataTransfer +function selectDocumentText(selectedCharacters: number): void { + const paragraph = document.createElement('p') + const text = document.createTextNode('Transcript text') + paragraph.append(text) + document.body.append(paragraph) + const range = document.createRange() + range.setStart(text, 0) + range.setEnd(text, selectedCharacters) + const selection = window.getSelection() + assert.exists(selection) + selection.addRange(range) + onTestFinished(() => { + selection.removeAllRanges() + paragraph.remove() }) - const copyHandler = copyMocks.copyHandler - expect(copyHandler).toBeDefined() - if (!copyHandler) throw new Error('Expected copy handler to be registered') - - expect(() => copyHandler(event)).not.toThrow() - - return dataTransfer } function readSerializedClipboardMetadata(dataTransfer: DataTransfer): string { @@ -66,7 +75,8 @@ function readSerializedClipboardMetadata(dataTransfer: DataTransfer): string { describe('useCopy', () => { beforeEach(() => { - copyMocks.copyHandler = undefined + useCanvasStore().canvas = fromPartial(copyMocks.canvas) + mountCopy() }) it('should write large serialized node data to clipboard metadata', () => { @@ -90,4 +100,116 @@ describe('useCopy', () => { expect(readSerializedClipboardMetadata(dataTransfer)).toBe(serializedData) }) + + describe('copy on a target the canvas ignores', () => { + const keyboardNode = '{"nodes":[{"type":"LoadImage"}]}' + const contextMenuNode = '{"nodes":[{"type":"SaveImage"}]}' + let copyId = 0 + + function writeCanvasClipboard(serializedData: string): void { + localStorage.setItem(canvasClipboardKey, serializedData) + localStorage.setItem(canvasClipboardIdKey, String(++copyId)) + } + + function copyNodeWithKeyboard(): void { + copyMocks.canvas.copyToClipboard.mockImplementation(() => { + writeCanvasClipboard(keyboardNode) + return keyboardNode + }) + dispatchCopy() + } + + function copyNodeFromContextMenu( + serializedData: string = contextMenuNode + ): void { + writeCanvasClipboard(serializedData) + } + + beforeEach(() => { + copyId = 0 + onTestFinished(() => { + localStorage.removeItem(canvasClipboardKey) + localStorage.removeItem(canvasClipboardIdKey) + }) + }) + + it.for([ + { + slot: 'a keyboard node copy', + writeSlot: [copyNodeWithKeyboard], + selection: 'selected document text', + selectedCharacters: 'Transcript'.length, + slotAfter: null + }, + { + slot: 'a keyboard node copy', + writeSlot: [copyNodeWithKeyboard], + selection: 'a collapsed caret', + selectedCharacters: 0, + slotAfter: keyboardNode + }, + { + slot: 'a context-menu copy', + writeSlot: [copyNodeFromContextMenu], + selection: 'selected document text', + selectedCharacters: 'Transcript'.length, + slotAfter: contextMenuNode + }, + { + slot: 'a context-menu copy after a keyboard node copy', + writeSlot: [copyNodeWithKeyboard, copyNodeFromContextMenu], + selection: 'selected document text', + selectedCharacters: 'Transcript'.length, + slotAfter: contextMenuNode + }, + { + slot: 'an equal context-menu copy after a keyboard node copy', + writeSlot: [ + copyNodeWithKeyboard, + () => copyNodeFromContextMenu(keyboardNode) + ], + selection: 'selected document text', + selectedCharacters: 'Transcript'.length, + slotAfter: keyboardNode + } + ])( + 'with $selection after $slot leaves the canvas clipboard slot as $slotAfter', + ({ writeSlot, selectedCharacters, slotAfter }) => { + for (const write of writeSlot) write() + copyMocks.canvas.copyToClipboard.mockClear() + selectDocumentText(selectedCharacters) + const textarea = document.createElement('textarea') + document.body.append(textarea) + onTestFinished(() => textarea.remove()) + + const dataTransfer = dispatchCopy(textarea) + + expect(localStorage.getItem(canvasClipboardKey)).toBe(slotAfter) + expect(dataTransfer.getData('text/html')).toBe('') + expect(copyMocks.canvas.copyToClipboard).not.toHaveBeenCalled() + } + ) + + it.for([ + { name: 'textarea', make: () => document.createElement('textarea') }, + { + name: 'search input', + make: () => + Object.assign(document.createElement('input'), { type: 'search' }) + } + ])( + 'clears a keyboard node copy after copying selected $name text', + ({ make }) => { + copyNodeWithKeyboard() + const input = make() + input.value = 'selected text' + document.body.append(input) + input.setSelectionRange(0, 'selected'.length) + + dispatchCopy(input) + + expect(localStorage.getItem(canvasClipboardKey)).toBeNull() + } + ) + }) }) diff --git a/src/composables/useCopy.ts b/src/composables/useCopy.ts index e7585192b7c..9825791f784 100644 --- a/src/composables/useCopy.ts +++ b/src/composables/useCopy.ts @@ -1,7 +1,13 @@ import { useEventListener } from '@vueuse/core' import { useCanvasStore } from '@/renderer/core/canvas/canvasStore' -import { shouldIgnoreCopyPaste } from '@/workbench/eventHelpers' +import { + hasTextSelection, + shouldIgnoreCopyPaste +} from '@/workbench/eventHelpers' + +const CANVAS_CLIPBOARD_KEY = 'litegrapheditor_clipboard' +const CANVAS_CLIPBOARD_ID_KEY = 'litegrapheditor_clipboard_id' const clipboardHTMLWrapper = [ '
{ + const graph = mount(document.createElement('div')) + graph.addEventListener( + 'pointerdown', + collapseOutsideSelectionOnPrimaryPointerDown + ) + selectTextOf(mount(textBlock('agent reply'))) + + graph.dispatchEvent( + new PointerEvent('pointerdown', { button: code, bubbles: true }) + ) + + expect(window.getSelection()?.toString()).toBe(selected) + } + ) +}) diff --git a/src/workbench/eventHelpers.ts b/src/workbench/eventHelpers.ts index f3bfd3aa766..8ecc80abd60 100644 --- a/src/workbench/eventHelpers.ts +++ b/src/workbench/eventHelpers.ts @@ -4,12 +4,57 @@ import { useCanvasStore } from '@/renderer/core/canvas/canvasStore' * Utility functions for handling workbench events */ +function activeTextSelection(): Selection | null { + const selection = window.getSelection() + return selection !== null && !selection.isCollapsed ? selection : null +} + +export function hasTextSelection(target: EventTarget | null): boolean { + if ( + target instanceof HTMLInputElement || + target instanceof HTMLTextAreaElement + ) { + if ( + target.selectionStart !== null && + target.selectionEnd !== null && + target.selectionStart !== target.selectionEnd + ) + return true + } + + return activeTextSelection() !== null +} + +function rangesOf(selection: Selection): Range[] { + return Array.from({ length: selection.rangeCount }, (_, i) => + selection.getRangeAt(i) + ) +} + /** - * Check if there is selected text in the document. + * Collapse a text selection unless every range lies wholly inside + * `container`, the way a plain mousedown would before the canvas called + * `preventDefault()` on it. A copy or paste that follows a click on the graph + * then reaches the graph instead of the stale selection. */ -function hasTextSelection(): boolean { - const selection = window.getSelection() - return selection !== null && selection.toString().trim().length > 0 +export function collapseTextSelectionOutside(container: Element): void { + const selection = activeTextSelection() + if ( + selection && + rangesOf(selection).some( + (range) => + !container.contains(range.startContainer) || + !container.contains(range.endContainer) + ) + ) + selection.removeAllRanges() +} + +export function collapseOutsideSelectionOnPrimaryPointerDown( + event: PointerEvent +): void { + if (event.button === 0 && event.target instanceof Element) + collapseTextSelectionOutside(event.target) } /** @@ -23,6 +68,7 @@ function hasTextSelection(): boolean { export function shouldIgnoreCopyPaste(target: EventTarget | null): boolean { const isTextInput = target instanceof HTMLTextAreaElement || + (target instanceof HTMLElement && target.isContentEditable) || (target instanceof HTMLInputElement && ![ 'button', @@ -33,8 +79,9 @@ export function shouldIgnoreCopyPaste(target: EventTarget | null): boolean { 'radio', 'range', 'reset', - 'search', 'submit' ].includes(target.type)) - return isTextInput || useCanvasStore().linearMode || hasTextSelection() + return ( + isTextInput || useCanvasStore().linearMode || activeTextSelection() !== null + ) }