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

@@ -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 };
}