fix(editor): let blank-area clicks clear a select-all selection

This commit is contained in:
zipg authored and GitHub committed 2026-09-28 21:17:17 +08:00
1 parent 3e681fe61b
commit e90186b48c
5 files changed
+748 -42

No files matched your search

@@ -538,7 +538,7 @@ const {
const hoverContent = createQueryEditorHoverContent({ isDark, t, toast });
const { resolveSqlHoverTooltip } = useQueryEditorHover({ props, contextMenuOpen, settingsStore, connectionStore, metadata: completionMetadata, createHoverDom: hoverContent.createHoverDom, semanticCompletionEnabled: SEMANTIC_SQL_COMPLETION_ENABLED, maxCompletionTables: MAX_COMPLETION_TABLES });
const pointerInteractions = useQueryEditorPointer({ props, clearTableNavigationHover: () => clearTableNavigationHover(), emit });
const { registerEditorScrollbarPointerGuard, startEditorSelectionDrag } = pointerInteractions;
const { registerEditorScrollbarPointerGuard, registerEditorNativeSelectionDragGuard, startEditorSelectionDrag } = pointerInteractions;
const tableDrop = useQueryEditorTableDrop({ props, view, editorRef, settingsStore });
const { hasDroppedTableReference, insertDroppedTableReference, queryEditorDropCaret, queryEditorDropCaretStyle, showQueryEditorDropCaretAt, hideQueryEditorDropCaret, registerTableReferenceDropListener, unregisterTableReferenceDropListener } = tableDrop;
const objectNavigation = useQueryEditorObjectNavigation({
@@ -2124,6 +2124,13 @@ const codeMirrorLifecycle = useQueryEditorCodeMirror({
batchSelection.attach(view.value, tooltipParent);
postCompositionKeyGuardCleanup = postCompositionKeyGuard.attach(view.value.contentDOM);
registerEditorScrollbarPointerGuard(view.value);
// `clipboardLineEndings` is what the editor registers as its
// `clipboardOutputFilter`; the drag park needs it for the same reason
// the context-menu park does, so a Cmd+C during a long drag is byte
// identical to one taken with the selection live. It is resolved when
// such a copy happens rather than here, because that is the only moment
// the normalizer is used.
registerEditorNativeSelectionDragGuard(view.value, { finalizeClipboardText: (text) => clipboardLineEndings(text) });
view.value.scrollDOM.addEventListener("scroll", scheduleEditorViewportEmit, {
passive: true,
});
@@ -11,21 +11,27 @@ vi.mock("@/lib/backend/tauriRuntime", () => ({ isTauriRuntime: vi.fn(() => false
vi.mock("@/lib/backend/platform", () => ({ isMacOS: vi.fn(() => false) }));
const cleanups: Array<() => void> = [];
/** Lets the drag park's frame-deferred restore run. */
const nextFrame = () => new Promise<void>((resolve) => requestAnimationFrame(() => resolve()));
afterEach(() => {
for (const cleanup of cleanups.splice(0).reverse()) cleanup();
vi.restoreAllMocks();
});
function createHarness(readOnly = false) {
const LONG_DOC = Array.from({ length: 60 }, (_, index) => `select column_${index} from table_${index} where id = ${index};`).join("\n");
function createHarness(readOnly = false, options: { doc?: string; selection?: { anchor: number; head: number } } = {}) {
const doc = options.doc ?? "abc def ghi";
const host = document.createElement("div");
document.body.append(host);
const view = new EditorView({ parent: host, state: EditorState.create({ doc: "abc def ghi", selection: { anchor: 4, head: 7 } }) });
const view = new EditorView({ parent: host, state: EditorState.create({ doc, selection: options.selection ?? { anchor: 4, head: 7 } }) });
const position = vi.spyOn(view, "posAtCoords").mockReturnValue(5);
vi.spyOn(view, "coordsAtPos").mockReturnValue({ left: 50, right: 51, top: 20, bottom: 38 });
vi.spyOn(view, "focus").mockImplementation(() => {});
const emit = vi.fn();
const clearTableNavigationHover = vi.fn();
const pointer = useQueryEditorPointer({ props: { modelValue: "abc def ghi", readOnly }, clearTableNavigationHover, emit });
const pointer = useQueryEditorPointer({ props: { modelValue: doc, readOnly }, clearTableNavigationHover, emit });
const start = (init: MouseEventInit = {}) => {
const event = new MouseEvent("mousedown", { button: 0, detail: 1, clientX: 10, clientY: 10, cancelable: true, ...init });
Object.defineProperty(event, "target", { value: view.contentDOM });
@@ -41,6 +47,21 @@ function createHarness(readOnly = false) {
return { host, view, position, emit, clearTableNavigationHover, pointer, start, move, release };
}
/**
* Dispatches a mousedown the editor's own mouse-selection handler would try to
* hit-test, which happy-dom cannot answer. The capture listener runs after the
* guard under test and stops the event before CodeMirror sees it.
*/
function dispatchEditorMouseDown(view: EditorView, init: MouseEventInit = {}) {
const block = (event: Event) => event.stopImmediatePropagation();
view.contentDOM.addEventListener("mousedown", block, true);
try {
view.contentDOM.dispatchEvent(new MouseEvent("mousedown", { button: 0, bubbles: true, ...init }));
} finally {
view.contentDOM.removeEventListener("mousedown", block, true);
}
}
describe("QueryEditor pointer ownership", () => {
it.each(["read-only", "non-primary", "shift", "double-click", "empty-selection", "outside-selection"])("does not capture %s gestures", (kind) => {
const { view, position, start, emit } = createHarness(kind === "read-only");
@@ -65,6 +86,43 @@ describe("QueryEditor pointer ownership", () => {
expect(document.querySelector(".dbx-editor-selection-drop-cursor")).toBeNull();
});
it("keeps a click that drifts past the drag threshold on the selection a caret move", () => {
const { view, position, start, move, release } = createHarness();
expect(start().handled).toBe(true);
position.mockReturnValue(6);
move({ clientX: 20 });
expect(document.querySelector(".dbx-editor-selection-drop-cursor")).toBeNull();
expect(view.contentDOM.style.cursor).toBe("");
release({ clientX: 20 });
expect(view.state.doc.toString()).toBe("abc def ghi");
expect(view.state.selection.main.anchor).toBe(6);
expect(view.state.selection.main.empty).toBe(true);
});
it("keeps the selection when a drag is carried out and brought back onto it", () => {
const { view, position, start, move, release } = createHarness();
start();
position.mockReturnValue(11);
move();
expect(view.contentDOM.style.cursor).toBe("move");
position.mockReturnValue(6);
release();
expect(view.state.doc.toString()).toBe("abc def ghi");
expect([view.state.selection.main.from, view.state.selection.main.to]).toEqual([4, 7]);
});
it("drops the move cursor when the window loses focus mid-drag", () => {
const { view, position, start, move } = createHarness();
start();
position.mockReturnValue(11);
move();
expect(view.contentDOM.style.cursor).toBe("move");
expect(document.querySelector(".dbx-editor-selection-drop-cursor")).not.toBeNull();
window.dispatchEvent(new Event("blur"));
expect(view.contentDOM.style.cursor).toBe("");
expect(document.querySelector(".dbx-editor-selection-drop-cursor")).toBeNull();
});
it.each(["move", "control-copy", "command-copy"])("preserves %s text and selection mapping", (kind) => {
const { view, position, start, move, release, emit } = createHarness();
const modifiers = { ctrlKey: kind === "control-copy", metaKey: kind === "command-copy" };
@@ -112,6 +170,99 @@ describe("QueryEditor pointer ownership", () => {
expect(bubble).toHaveBeenCalledOnce();
});
it("parks a long selection for the length of a drag and restores it on release", async () => {
const { view, pointer } = createHarness(false, { doc: LONG_DOC, selection: { anchor: 0, head: 1200 } });
const anchorInsideContent = () => view.contentDOM.contains(document.getSelection()?.anchorNode ?? null);
document.getSelection()!.collapse(view.contentDOM, 0);
pointer.registerEditorNativeSelectionDragGuard(view);
dispatchEditorMouseDown(view);
expect(anchorInsideContent()).toBe(false);
document.dispatchEvent(new MouseEvent("mouseup", { bubbles: true }));
// The restore waits a microtask so a collapse dispatched in the same task
// replaces the selection instead of being overwritten by it.
await nextFrame();
expect(anchorInsideContent()).toBe(true);
});
it("leaves a short selection alone while dragging", () => {
const { view, pointer } = createHarness();
document.getSelection()!.collapse(view.contentDOM, 0);
pointer.registerEditorNativeSelectionDragGuard(view);
dispatchEditorMouseDown(view);
expect(view.contentDOM.contains(document.getSelection()?.anchorNode ?? null)).toBe(true);
document.dispatchEvent(new MouseEvent("mouseup", { bubbles: true }));
});
it("does not start a parking window for gestures outside the editor content", () => {
const { view, pointer } = createHarness(false, { doc: LONG_DOC, selection: { anchor: 0, head: 1200 } });
document.getSelection()!.collapse(view.contentDOM, 0);
pointer.registerEditorNativeSelectionDragGuard(view);
view.scrollDOM.dispatchEvent(new MouseEvent("mousedown", { button: 0, bubbles: true }));
expect(view.contentDOM.contains(document.getSelection()?.anchorNode ?? null)).toBe(true);
});
it("stops the parking window when the pointer comes back with the button already up", async () => {
const { view, pointer } = createHarness(false, { doc: LONG_DOC, selection: { anchor: 0, head: 1200 } });
document.getSelection()!.collapse(view.contentDOM, 0);
pointer.registerEditorNativeSelectionDragGuard(view);
dispatchEditorMouseDown(view);
expect(view.contentDOM.contains(document.getSelection()?.anchorNode ?? null)).toBe(false);
document.dispatchEvent(new MouseEvent("mousemove", { buttons: 0, bubbles: true }));
await nextFrame();
expect(view.contentDOM.contains(document.getSelection()?.anchorNode ?? null)).toBe(true);
});
it("replaces drag parking listeners and removes them on disposal", () => {
const { view, pointer } = createHarness(false, { doc: LONG_DOC, selection: { anchor: 0, head: 1200 } });
document.getSelection()!.collapse(view.contentDOM, 0);
pointer.registerEditorNativeSelectionDragGuard(view);
pointer.registerEditorNativeSelectionDragGuard(view);
pointer.dispose();
dispatchEditorMouseDown(view);
expect(view.contentDOM.contains(document.getSelection()?.anchorNode ?? null)).toBe(true);
});
it("cancels the browser's own drag session for the length of the gesture", () => {
const { view, pointer } = createHarness(false, { doc: LONG_DOC, selection: { anchor: 0, head: 1200 } });
document.getSelection()!.collapse(view.contentDOM, 0);
pointer.registerEditorNativeSelectionDragGuard(view);
dispatchEditorMouseDown(view);
const during = new Event("dragstart", { bubbles: true, cancelable: true });
view.contentDOM.dispatchEvent(during);
expect(during.defaultPrevented).toBe(true);
// The gesture is over, so the browser may drag again.
document.dispatchEvent(new MouseEvent("mouseup", { bubbles: true }));
const after = new Event("dragstart", { bubbles: true, cancelable: true });
view.contentDOM.dispatchEvent(after);
expect(after.defaultPrevented).toBe(false);
});
it("ends the parking window on the first non-modifier key so typing never lands inside a parked gesture", async () => {
const { view, pointer } = createHarness(false, { doc: LONG_DOC, selection: { anchor: 0, head: 1200 } });
document.getSelection()!.collapse(view.contentDOM, 0);
pointer.registerEditorNativeSelectionDragGuard(view);
dispatchEditorMouseDown(view);
expect(view.contentDOM.contains(document.getSelection()?.anchorNode ?? null)).toBe(false);
document.dispatchEvent(new KeyboardEvent("keydown", { key: "Shift", bubbles: true }));
expect(view.contentDOM.contains(document.getSelection()?.anchorNode ?? null)).toBe(false);
document.dispatchEvent(new KeyboardEvent("keydown", { key: "a", bubbles: true }));
await nextFrame();
expect(view.contentDOM.contains(document.getSelection()?.anchorNode ?? null)).toBe(true);
});
it("prevents native macOS Tauri scrollbar focus changes outside editor content", () => {
const { view, pointer } = createHarness();
vi.mocked(isTauriRuntime).mockReturnValue(true);
@@ -1,5 +1,6 @@
import type { EditorView as EditorViewType } from "@codemirror/view";
import { startsQueryEditorSelectionDrag } from "@/lib/editor/queryEditorPointerSelection";
import { keepNativeSelectionParkedDuringDrag, type EditorNativeSelectionPark } from "@/lib/editor/queryEditorNativeSelection";
import { isTauriRuntime } from "@/lib/backend/tauriRuntime";
import { isMacOS } from "@/lib/backend/platform";
import type { QueryEditorProps } from "./queryEditorTypes";
@@ -10,10 +11,22 @@ interface QueryEditorPointerOptions {
emit: (event: "closeColumnPanel") => void;
}
export interface QueryEditorNativeSelectionDragGuardOptions {
/**
* Applied to the text the parked copy path puts on the clipboard. Pass the
* same normalizer the editor registers as `EditorView.clipboardOutputFilter`
* (DBX rewrites line endings there) so a copy taken while the selection is
* parked matches a copy taken while it is not.
*/
finalizeClipboardText?: (text: string) => string;
}
export function useQueryEditorPointer(options: QueryEditorPointerOptions) {
const { props, clearTableNavigationHover, emit } = options;
let editorScrollbarPointerCleanup: (() => void) | null = null;
let editorNativeSelectionParkCleanup: (() => void) | null = null;
let editorSelectionDragCleanup: (() => void) | null = null;
let editorSelectionDropCursorEl: HTMLDivElement | null = null;
@@ -52,6 +65,90 @@ export function useQueryEditorPointer(options: QueryEditorPointerOptions) {
};
}
/**
* Parks the browser selection for the length of a selection gesture.
*
* macOS 26/27 has the web view serialize the browser selection whenever the
* pointer dwells on text services, at a cost that grows with the number of
* highlighted runs the selection covers. That is why a long drag is only
* smooth while the pointer stays at the edge of the editor (autoscrolling
* never puts it back on the text) and stalls as soon as it moves up over the
* lines it has already selected. Parking removes that cost; the editor keeps
* its own selection, so nothing about the gesture's result changes. See
* queryEditorNativeSelection.ts.
*
* The guard owns the whole gesture rather than a single mousedown/mouseup
* pair: the window has to cover CodeMirror's own mouse selection, the app's
* move/copy selection drag, and the autoscroll timer that keeps extending the
* selection while the pointer is held at the edge. It also cancels the
* browser's own drag session for that window, which would otherwise serialize
* the selection and take the pointer over with it.
*/
function registerEditorNativeSelectionDragGuard(currentView: EditorViewType, guardOptions: QueryEditorNativeSelectionDragGuardOptions = {}) {
editorNativeSelectionParkCleanup?.();
const doc = currentView.contentDOM.ownerDocument;
const win = doc.defaultView ?? window;
let park: EditorNativeSelectionPark | null = null;
const stop = () => {
park?.release();
park = null;
doc.removeEventListener("mouseup", onUp, true);
doc.removeEventListener("mousemove", onMove, true);
doc.removeEventListener("keydown", onKeyDown, true);
doc.removeEventListener("dragstart", blockNativeDrag, true);
win.removeEventListener("blur", stop);
};
// macOS turns a press, or a few pixels of travel, on selected text into its
// own drag session: it serializes the selection into drag data, puts up its
// own cursor, and then follows the pointer across whatever sits underneath
// — which is how a drag started in the editor ends up moving the selection
// over the SQL library list. On macOS 26/27 that serialization is the same
// per-run text-services cost the parking exists to remove, so a long
// selection stalls for seconds before the cursor even changes. The editor
// already implements its own move/copy drag (`startEditorSelectionDrag`), so
// the browser's session is cancelled for the length of the gesture. The
// column-header drag cancels the same event for the same reason — see
// `blockColumnHeaderNativeInteraction` in useDataGridColumnLayout.ts.
const blockNativeDrag = (event: Event) => event.preventDefault();
// A release outside the window (or over another app) never reaches the
// document, so a pointer that comes back with the button already up ends
// the gesture instead of leaving the selection parked.
const onMove = (event: MouseEvent) => {
if ((event.buttons & 1) === 0) stop();
};
const onUp = () => stop();
// A parked selection is invisible to CodeMirror by design, so the park must
// never outlive the gesture: the first key that is not a modifier ends it,
// which is what keeps typing (and IME) out of a parked window.
const onKeyDown = (event: KeyboardEvent) => {
if (event.key === "Shift" || event.key === "Alt" || event.key === "Control" || event.key === "Meta") return;
stop();
};
const onDown = (event: MouseEvent) => {
if (event.button !== 0 || !currentView.contentDOM.contains(event.target as Node | null)) return;
stop();
park = keepNativeSelectionParkedDuringDrag(currentView, { finalizeClipboardText: guardOptions.finalizeClipboardText });
doc.addEventListener("mouseup", onUp, true);
doc.addEventListener("mousemove", onMove, true);
doc.addEventListener("keydown", onKeyDown, true);
doc.addEventListener("dragstart", blockNativeDrag, true);
win.addEventListener("blur", stop);
};
currentView.contentDOM.addEventListener("mousedown", onDown, true);
editorNativeSelectionParkCleanup = () => {
currentView.contentDOM.removeEventListener("mousedown", onDown, true);
stop();
editorNativeSelectionParkCleanup = null;
};
}
function selectedRangeAtPointer(currentView: EditorViewType, event: MouseEvent) {
if (props.readOnly || event.button !== 0) return null;
if (!currentView.contentDOM.contains(event.target as Node | null)) return null;
@@ -66,6 +163,19 @@ export function useQueryEditorPointer(options: QueryEditorPointerOptions) {
};
}
/**
* Whether the pointer is still over the text the press landed on.
*
* `posAtCoords` answers with the position the pointer is closest to, so a
* pointer in the blank area right of a line answers with that line's end —
* inside the selection whenever the line is part of it, which is exactly what
* a click on a long selection has to be read as.
*/
function pointerOverSelection(currentView: EditorViewType, event: MouseEvent, selection: { from: number; to: number }) {
const pos = currentView.posAtCoords({ x: event.clientX, y: event.clientY }, false);
return pos != null && pos >= selection.from && pos <= selection.to;
}
function moveOrCopySelectionToPointer(currentView: EditorViewType, selection: { from: number; to: number; text: string }, event: MouseEvent) {
const dropPos = currentView.posAtCoords({ x: event.clientX, y: event.clientY }, false);
if (dropPos == null) return false;
@@ -140,18 +250,37 @@ export function useQueryEditorPointer(options: QueryEditorPointerOptions) {
const startY = event.clientY;
let dragging = false;
const win = currentView.contentDOM.ownerDocument.defaultView ?? window;
const cleanup = () => {
currentView.contentDOM.ownerDocument.removeEventListener("mousemove", onMove, true);
currentView.contentDOM.ownerDocument.removeEventListener("mouseup", onUp, true);
currentView.contentDOM.ownerDocument.removeEventListener("keydown", onKeyDown, true);
win.removeEventListener("blur", onCancel);
hideEditorSelectionDropCursor();
editorSelectionDragCleanup = null;
};
// A release outside the window never reaches the document, so without this
// the drop cursor and the move/copy pointer would stay behind until the
// next press.
const onCancel = () => {
cleanup();
currentView.contentDOM.style.cursor = "";
};
const onMove = (moveEvent: MouseEvent) => {
const distance = Math.hypot(moveEvent.clientX - startX, moveEvent.clientY - startY);
if (!dragging && distance < EDITOR_SELECTION_DRAG_THRESHOLD_PX) return;
dragging = true;
if (!dragging) {
const distance = Math.hypot(moveEvent.clientX - startX, moveEvent.clientY - startY);
if (distance < EDITOR_SELECTION_DRAG_THRESHOLD_PX) return;
// A press that never leaves the selected text is a click that drifted,
// not a text drag, and it has to keep behaving like a click: the browser
// would place the caret where the pointer came up. Taking it over
// instead swallowed the release — the drop landed back inside the
// selection, `moveOrCopySelectionToPointer` had nothing to do, and a
// long selection looked like it could not be cleared at all.
if (pointerOverSelection(currentView, moveEvent, selection)) return;
dragging = true;
}
if (moveEvent.ctrlKey || moveEvent.metaKey) {
currentView.contentDOM.style.cursor = "copy";
} else {
@@ -195,6 +324,7 @@ export function useQueryEditorPointer(options: QueryEditorPointerOptions) {
currentView.contentDOM.ownerDocument.addEventListener("mousemove", onMove, true);
currentView.contentDOM.ownerDocument.addEventListener("mouseup", onUp, true);
currentView.contentDOM.ownerDocument.addEventListener("keydown", onKeyDown, true);
win.addEventListener("blur", onCancel);
editorSelectionDragCleanup = () => {
cleanup();
currentView.contentDOM.style.cursor = "";
@@ -204,8 +334,9 @@ export function useQueryEditorPointer(options: QueryEditorPointerOptions) {
function dispose() {
editorScrollbarPointerCleanup?.();
editorNativeSelectionParkCleanup?.();
editorSelectionDragCleanup?.();
}
return { registerEditorScrollbarPointerGuard, startEditorSelectionDrag, dispose };
return { registerEditorScrollbarPointerGuard, registerEditorNativeSelectionDragGuard, startEditorSelectionDrag, dispose };
}