Files
dbx/apps/desktop/src/components/editor/useQueryEditorPointer.ts
T

343 lines
15 KiB
TypeScript

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";
interface QueryEditorPointerOptions {
props: Readonly<QueryEditorProps>;
clearTableNavigationHover: () => void;
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;
const EDITOR_SCROLLBAR_POINTER_GUTTER_PX = 18;
const EDITOR_SELECTION_DRAG_THRESHOLD_PX = 6;
function isEditorScrollbarPointerEvent(currentView: EditorViewType, event: MouseEvent) {
if (event.button !== 0) return false;
const scrollDOM = currentView.scrollDOM;
const rect = scrollDOM.getBoundingClientRect();
const hasVerticalScrollbar = scrollDOM.scrollHeight > scrollDOM.clientHeight + 1;
const hasHorizontalScrollbar = scrollDOM.scrollWidth > scrollDOM.clientWidth + 1;
const verticalGutter = Math.max(scrollDOM.offsetWidth - scrollDOM.clientWidth, EDITOR_SCROLLBAR_POINTER_GUTTER_PX);
const horizontalGutter = Math.max(scrollDOM.offsetHeight - scrollDOM.clientHeight, EDITOR_SCROLLBAR_POINTER_GUTTER_PX);
const inVerticalScrollbar = hasVerticalScrollbar && event.clientX >= rect.right - verticalGutter && event.clientX <= rect.right;
const inHorizontalScrollbar = hasHorizontalScrollbar && event.clientY >= rect.bottom - horizontalGutter && event.clientY <= rect.bottom;
return inVerticalScrollbar || inHorizontalScrollbar;
}
function registerEditorScrollbarPointerGuard(currentView: EditorViewType) {
editorScrollbarPointerCleanup?.();
const onPointerDown = (event: MouseEvent) => {
if (!isEditorScrollbarPointerEvent(currentView, event)) return;
clearTableNavigationHover();
event.stopPropagation();
if (isTauriRuntime() && isMacOS() && !currentView.contentDOM.contains(event.target as Node | null)) {
event.preventDefault();
}
};
currentView.scrollDOM.addEventListener("mousedown", onPointerDown, true);
editorScrollbarPointerCleanup = () => {
currentView.scrollDOM.removeEventListener("mousedown", onPointerDown, true);
editorScrollbarPointerCleanup = null;
};
}
/**
* 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;
const range = currentView.state.selection.main;
if (range.empty) return null;
const pos = currentView.posAtCoords({ x: event.clientX, y: event.clientY }, false);
if (pos == null || pos < range.from || pos > range.to) return null;
return {
from: range.from,
to: range.to,
text: currentView.state.sliceDoc(range.from, range.to),
};
}
/**
* 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;
const copy = event.ctrlKey || event.metaKey;
if (!copy && dropPos >= selection.from && dropPos <= selection.to) return true;
const insert = { from: dropPos, insert: selection.text };
const changes = copy ? currentView.state.changes(insert) : currentView.state.changes([{ from: selection.from, to: selection.to }, insert]);
currentView.dispatch({
changes,
selection: {
anchor: changes.mapPos(dropPos, -1),
head: changes.mapPos(dropPos, 1),
},
scrollIntoView: true,
userEvent: copy ? "input.drop" : "move.drop",
});
currentView.focus();
return true;
}
function hideEditorSelectionDropCursor() {
editorSelectionDropCursorEl?.remove();
editorSelectionDropCursorEl = null;
}
function updateEditorSelectionDropCursor(currentView: EditorViewType, event: MouseEvent) {
const pos = currentView.posAtCoords({ x: event.clientX, y: event.clientY }, false);
if (pos == null) {
hideEditorSelectionDropCursor();
return;
}
const coords = currentView.coordsAtPos(pos);
if (!coords) {
hideEditorSelectionDropCursor();
return;
}
const ownerDocument = currentView.dom.ownerDocument;
const cursor = editorSelectionDropCursorEl ?? ownerDocument.createElement("div");
if (!editorSelectionDropCursorEl) {
cursor.setAttribute("aria-hidden", "true");
cursor.className = "dbx-editor-selection-drop-cursor";
// Use a fixed overlay instead of CodeMirror's internal drop cursor layer so
// the marker stays visible above selection layers, themes, and scrollers.
cursor.style.position = "fixed";
cursor.style.zIndex = "2147483647";
cursor.style.width = "2px";
cursor.style.pointerEvents = "none";
cursor.style.backgroundImage = "repeating-linear-gradient(to bottom, #e879f9 0 4px, transparent 4px 7px)";
cursor.style.filter = "drop-shadow(0 0 1px rgba(0, 0, 0, 0.7))";
ownerDocument.body.appendChild(cursor);
editorSelectionDropCursorEl = cursor;
}
cursor.style.left = `${Math.round(coords.left) - 1}px`;
cursor.style.top = `${Math.round(coords.top)}px`;
cursor.style.height = `${Math.max(16, Math.round(coords.bottom - coords.top))}px`;
}
function startEditorSelectionDrag(currentView: EditorViewType, event: MouseEvent): boolean {
if (!startsQueryEditorSelectionDrag(event)) return false;
const selection = selectedRangeAtPointer(currentView, event);
if (!selection) return false;
event.preventDefault();
event.stopPropagation();
if (!event.ctrlKey && !event.metaKey) {
emit("closeColumnPanel");
}
editorSelectionDragCleanup?.();
const startX = event.clientX;
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) => {
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 {
currentView.contentDOM.style.cursor = "move";
}
updateEditorSelectionDropCursor(currentView, moveEvent);
moveEvent.preventDefault();
moveEvent.stopImmediatePropagation();
};
const onUp = (upEvent: MouseEvent) => {
cleanup();
currentView.contentDOM.style.cursor = "";
upEvent.preventDefault();
upEvent.stopImmediatePropagation();
if (dragging) {
moveOrCopySelectionToPointer(currentView, selection, upEvent);
return;
}
const pos = currentView.posAtCoords({
x: upEvent.clientX,
y: upEvent.clientY,
});
if (pos != null) {
currentView.dispatch({
selection: { anchor: pos },
userEvent: "select.pointer",
});
currentView.focus();
}
};
const onKeyDown = (keyEvent: KeyboardEvent) => {
if (keyEvent.key !== "Escape") return;
cleanup();
currentView.contentDOM.style.cursor = "";
keyEvent.preventDefault();
keyEvent.stopImmediatePropagation();
};
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 = "";
};
return true;
}
function dispose() {
editorScrollbarPointerCleanup?.();
editorNativeSelectionParkCleanup?.();
editorSelectionDragCleanup?.();
}
return { registerEditorScrollbarPointerGuard, registerEditorNativeSelectionDragGuard, startEditorSelectionDrag, dispose };
}