25 MB lightweight cross-platform database client for 100+ databases, including MySQL, PostgreSQL, SQLite, Redis, MongoDB, DuckDB, SQL Server, and Dameng. Built-in AI, MCP Server, CLI, desktop and Docker. | 轻量级跨平台数据库管理工具,支持 MySQL、PostgreSQL、SQLite、Redis、MongoDB、达梦等 100+ 数据库,提供桌面端、Docker、CLI、内置 AI 助手和 MCP。
TypeScript aicliclickhousedatabasedatabase-clientdatabase-managementdockerguimcpmongodbmysqlpostgresqlredisrustsql-serversqlitetaurivue
fix(editor): let blank-area clicks clear a select-all selection
zipge90186b48c67
diff --git a/apps/desktop/src/components/editor/QueryEditor.vue b/apps/desktop/src/components/editor/QueryEditor.vueindex cf854a549b..abd34cc47b 100644--- a/apps/desktop/src/components/editor/QueryEditor.vue+++ b/apps/desktop/src/components/editor/QueryEditor.vue@@ -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,});diff --git a/apps/desktop/src/components/editor/__tests__/useQueryEditorPointer.spec.ts b/apps/desktop/src/components/editor/__tests__/useQueryEditorPointer.spec.tsindex 65486e0306..2a04a89d93 100644--- a/apps/desktop/src/components/editor/__tests__/useQueryEditorPointer.spec.ts+++ b/apps/desktop/src/components/editor/__tests__/useQueryEditorPointer.spec.ts@@ -11,21 +11,27 @@ vi.mock("@/lib/backend/tauriRuntime", () => ({ isTauriRuntime: vi.fn(() => falsevi.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);diff --git a/apps/desktop/src/components/editor/useQueryEditorPointer.ts b/apps/desktop/src/components/editor/useQueryEditorPointer.tsindex 37e4d83623..4f54f0c410 100644--- a/apps/desktop/src/components/editor/useQueryEditorPointer.ts+++ b/apps/desktop/src/components/editor/useQueryEditorPointer.ts@@ -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 };}diff --git a/apps/desktop/src/lib/editor/__tests__/queryEditorNativeSelection.spec.ts b/apps/desktop/src/lib/editor/__tests__/queryEditorNativeSelection.spec.tsindex 3d701f6d83..6eecb5d65f 100644--- a/apps/desktop/src/lib/editor/__tests__/queryEditorNativeSelection.spec.ts+++ b/apps/desktop/src/lib/editor/__tests__/queryEditorNativeSelection.spec.ts@@ -1,7 +1,7 @@// @vitest-environment happy-domimport { describe, expect, it, vi } from "vitest";import type { EditorView } from "@codemirror/view";-import { NATIVE_SELECTION_PARK_MIN_CHARS, parkEditorNativeSelection } from "../queryEditorNativeSelection";+import { NATIVE_SELECTION_PARK_MIN_CHARS, isLargeEditorSelection, keepNativeSelectionParkedDuringDrag, parkEditorNativeSelection } from "../queryEditorNativeSelection";const DOC = `SELECT ${"x".repeat(NATIVE_SELECTION_PARK_MIN_CHARS)}`;@@ -10,9 +10,38 @@ interface FakeView {contentDOM: HTMLElement;dispatch: ReturnType<typeof vi.fn>;selectedText: () => string;+ /** Move the editor's own selection, as a pointer gesture would. */+ setSelection: (from: number, to: number) => void;+ /** Re-publish the state selection as the browser selection. */+ publishSelection: () => void;+ /** The private CodeMirror internals the drag park shadows, when requested. */+ docView: { updateSelection: ReturnType<typeof vi.fn> } | null;+ observer: { selectionRange: { focusNode: Node | null }; readSelectionRange: ReturnType<typeof vi.fn> } | null;}-function fakeView(from: number, to: number): FakeView {+/** Runs the park module's `requestAnimationFrame` loop by hand. */+function manualFrames() {+ const queue: Array<{ id: number; callback: () => void }> = [];+ let nextId = 0;+ vi.spyOn(window, "requestAnimationFrame").mockImplementation((callback: FrameRequestCallback) => {+ const id = ++nextId;+ queue.push({ id, callback: () => callback(performance.now()) });+ return id;+ });+ vi.spyOn(window, "cancelAnimationFrame").mockImplementation((id: number) => {+ const index = queue.findIndex((entry) => entry.id === id);+ if (index >= 0) queue.splice(index, 1);+ });+ return {+ runFrame: () => {+ const next = queue.shift();+ expect(next).toBeDefined();+ next!.callback();+ },+ };+}++function fakeView(from: number, to: number, options: { withSelectionInternals?: boolean } = {}): FakeView {const dom = document.createElement("div");const contentDOM = document.createElement("div");const paragraph = document.createElement("p");@@ -30,6 +59,10 @@ function fakeView(from: number, to: number): FakeView {readOnly: false,sliceDoc: (start: number, end: number) => DOC.slice(start, end),};+ // CodeMirror keeps `updateSelection` on the doc view's prototype, which is what+ // the suppression shadows on the instance and deletes again on release.+ const docView = options.withSelectionInternals ? (Object.create({ updateSelection: vi.fn() }) as { updateSelection: ReturnType<typeof vi.fn> }) : null;+ const observer = options.withSelectionInternals ? { selectionRange: { focusNode: null as Node | null }, readSelectionRange: vi.fn(() => true) } : null;const view = {root: document,dom,@@ -37,13 +70,26 @@ function fakeView(from: number, to: number): FakeView {state,dispatch,domAtPos: (pos: number) => ({ node: text, offset: Math.min(pos, DOC.length) }),+ docView,+ observer,} as unknown as EditorView;- const selection = document.getSelection()!;- selection.collapse(text, from);- selection.extend(text, to);+ const publishSelection = () => {+ const selection = document.getSelection()!;+ selection.collapse(text, range.from);+ selection.extend(text, range.to);+ };+ publishSelection();++ const setSelection = (nextFrom: number, nextTo: number) => {+ range.from = nextFrom;+ range.to = nextTo;+ range.empty = nextFrom === nextTo;+ range.anchor = nextFrom;+ range.head = nextTo;+ };- return { view, contentDOM, dispatch, selectedText: () => document.getSelection()?.toString() ?? "" };+ return { view, contentDOM, dispatch, selectedText: () => document.getSelection()?.toString() ?? "", setSelection, publishSelection, docView, observer };}function copyEvent(target: EventTarget, type = "copy") {@@ -118,3 +164,199 @@ describe("parkEditorNativeSelection", () => {expect(data.setData).not.toHaveBeenCalled();});});++describe("isLargeEditorSelection", () => {+ it("only counts selections long enough to be worth parking", () => {+ const short = fakeView(0, NATIVE_SELECTION_PARK_MIN_CHARS - 1);+ expect(isLargeEditorSelection(short.view)).toBe(false);++ const long = fakeView(0, NATIVE_SELECTION_PARK_MIN_CHARS);+ expect(isLargeEditorSelection(long.view)).toBe(true);++ const caret = fakeView(10, 10);+ expect(isLargeEditorSelection(caret.view)).toBe(false);+ });+});++describe("keepNativeSelectionParkedDuringDrag", () => {+ it("parks once the gesture has dragged out enough lines to be worth it", () => {+ const frames = manualFrames();+ const { view, contentDOM, setSelection } = fakeView(0, 4);+ const park = keepNativeSelectionParkedDuringDrag(view);++ expect(contentDOM.contains(document.getSelection()?.anchorNode ?? null)).toBe(true);++ setSelection(0, NATIVE_SELECTION_PARK_MIN_CHARS);+ frames.runFrame();+ expect(contentDOM.contains(document.getSelection()?.anchorNode ?? null)).toBe(false);++ park.release();+ });++ it("leaves a gesture that never grows past a few lines alone", () => {+ const frames = manualFrames();+ const { view, contentDOM, setSelection, publishSelection } = fakeView(0, 4);+ const park = keepNativeSelectionParkedDuringDrag(view);++ setSelection(0, 40);+ publishSelection();+ frames.runFrame();+ frames.runFrame();++ expect(contentDOM.contains(document.getSelection()?.anchorNode ?? null)).toBe(true);++ park.release();+ });++ it("stops parking once the caller reports the gesture is over", () => {+ const frames = manualFrames();+ const { view, contentDOM, publishSelection } = fakeView(0, NATIVE_SELECTION_PARK_MIN_CHARS);+ let dragging = true;+ const park = keepNativeSelectionParkedDuringDrag(view, { shouldKeepParked: () => dragging });++ publishSelection();+ frames.runFrame();+ expect(contentDOM.contains(document.getSelection()?.anchorNode ?? null)).toBe(false);++ dragging = false;+ publishSelection();+ frames.runFrame();+ expect(contentDOM.contains(document.getSelection()?.anchorNode ?? null)).toBe(true);++ park.release();+ });++ it("fills the clipboard for a copy taken while the gesture is still running", () => {+ manualFrames();+ const { view, contentDOM } = fakeView(0, NATIVE_SELECTION_PARK_MIN_CHARS);+ const park = keepNativeSelectionParkedDuringDrag(view);++ const { data } = copyEvent(contentDOM);+ expect(data.setData).toHaveBeenCalledWith("text/plain", DOC.slice(0, NATIVE_SELECTION_PARK_MIN_CHARS));++ park.release();+ });++ it("re-parks after CodeMirror rewrites the browser selection from its own state", () => {+ const frames = manualFrames();+ const { view, contentDOM, publishSelection } = fakeView(0, NATIVE_SELECTION_PARK_MIN_CHARS);+ const park = keepNativeSelectionParkedDuringDrag(view);++ // CodeMirror writes the browser selection on every selection update, which+ // puts a long selection back on the text services the parking exists to+ // keep away from it.+ publishSelection();+ expect(contentDOM.contains(document.getSelection()?.anchorNode ?? null)).toBe(true);++ frames.runFrame();+ expect(contentDOM.contains(document.getSelection()?.anchorNode ?? null)).toBe(false);++ park.release();+ });+});++describe("drag park selection-write suppression", () => {+ it("shadows CodeMirror's browser-selection write for the length of the park", () => {+ manualFrames();+ const { view, contentDOM, docView, observer } = fakeView(0, NATIVE_SELECTION_PARK_MIN_CHARS, { withSelectionInternals: true });+ const park = keepNativeSelectionParkedDuringDrag(view);++ // CodeMirror rewrites the browser selection on every selection update, and+ // a parked selection always looks stale to it, so the write is shadowed and+ // the read half is kept.+ expect(Object.prototype.hasOwnProperty.call(docView, "updateSelection")).toBe(true);+ docView!.updateSelection(true);+ expect(observer!.readSelectionRange).toHaveBeenCalled();+ expect(contentDOM.contains(document.getSelection()?.anchorNode ?? null)).toBe(false);++ park.release();+ expect(Object.prototype.hasOwnProperty.call(docView, "updateSelection")).toBe(false);+ });++ it("leaves a view that does not expose the internals it was written against untouched", () => {+ manualFrames();+ const { view, contentDOM } = fakeView(0, NATIVE_SELECTION_PARK_MIN_CHARS);+ const park = keepNativeSelectionParkedDuringDrag(view);++ expect(contentDOM.contains(document.getSelection()?.anchorNode ?? null)).toBe(false);+ park.release();+ });++ it("does not shadow the write when the caller opts out", () => {+ manualFrames();+ const { view, docView } = fakeView(0, NATIVE_SELECTION_PARK_MIN_CHARS, { withSelectionInternals: true });+ const park = keepNativeSelectionParkedDuringDrag(view, { suppressEditorSelectionWrites: false });++ expect(Object.prototype.hasOwnProperty.call(docView, "updateSelection")).toBe(false);+ park.release();+ });++ it("never clobbers a write somebody else already owns", () => {+ manualFrames();+ const { view, docView } = fakeView(0, NATIVE_SELECTION_PARK_MIN_CHARS, { withSelectionInternals: true });+ const existing = vi.fn();+ docView!.updateSelection = existing;++ const park = keepNativeSelectionParkedDuringDrag(view);+ expect(docView!.updateSelection).toBe(existing);++ park.release();+ expect(docView!.updateSelection).toBe(existing);+ });++ it("waits for the gesture's own write and only restores when the selection is still parked", () => {+ const frames = manualFrames();+ const { view, contentDOM, setSelection } = fakeView(0, NATIVE_SELECTION_PARK_MIN_CHARS, { withSelectionInternals: true });+ const park = keepNativeSelectionParkedDuringDrag(view);+ expect(contentDOM.contains(document.getSelection()?.anchorNode ?? null)).toBe(false);++ // The click that ends the gesture collapses the editor selection, and that+ // collapse is what CodeMirror writes into the browser. Restoring first would+ // re-create the whole selection only to have CodeMirror collapse it again.+ setSelection(0, 0);+ park.release();+ expect(contentDOM.contains(document.getSelection()?.anchorNode ?? null)).toBe(false);++ frames.runFrame();+ expect(contentDOM.contains(document.getSelection()?.anchorNode ?? null)).toBe(true);+ });++ it("leaves a browser selection CodeMirror wrote itself alone", () => {+ const frames = manualFrames();+ const { view, contentDOM, setSelection } = fakeView(0, NATIVE_SELECTION_PARK_MIN_CHARS, { withSelectionInternals: true });+ const park = keepNativeSelectionParkedDuringDrag(view);++ setSelection(0, 0);+ document.getSelection()!.collapse(view.contentDOM.querySelector("p")!.firstChild!, 7);+ park.release();+ frames.runFrame();++ // The parked selection is gone, so there is nothing to put back.+ expect(document.getSelection()!.anchorOffset).toBe(7);+ expect(contentDOM.contains(document.getSelection()!.anchorNode)).toBe(true);+ });++ it("still restores the menu park inside release, before the caller's next task", () => {+ const { view, contentDOM } = fakeView(0, NATIVE_SELECTION_PARK_MIN_CHARS);+ const park = parkEditorNativeSelection(view);+ expect(contentDOM.contains(document.getSelection()?.anchorNode ?? null)).toBe(false);++ park!.release();+ expect(contentDOM.contains(document.getSelection()?.anchorNode ?? null)).toBe(true);+ });++ it("leaves the browser selection to a park that started before its deferred restore ran", () => {+ const frames = manualFrames();+ const { view, contentDOM } = fakeView(0, NATIVE_SELECTION_PARK_MIN_CHARS, { withSelectionInternals: true });+ const first = keepNativeSelectionParkedDuringDrag(view);+ first.release();++ const second = keepNativeSelectionParkedDuringDrag(view);+ frames.runFrame();+ expect(contentDOM.contains(document.getSelection()?.anchorNode ?? null)).toBe(false);++ second.release();+ frames.runFrame();+ expect(contentDOM.contains(document.getSelection()?.anchorNode ?? null)).toBe(true);+ });+});diff --git a/apps/desktop/src/lib/editor/queryEditorNativeSelection.ts b/apps/desktop/src/lib/editor/queryEditorNativeSelection.tsindex e58a4e9a13..40b8ec23a0 100644--- a/apps/desktop/src/lib/editor/queryEditorNativeSelection.ts+++ b/apps/desktop/src/lib/editor/queryEditorNativeSelection.ts@@ -14,9 +14,16 @@ import { appendDebugLog } from "@/lib/backend/debugLog";* The browser selection does not have to cover the selection for the editor to* behave: CodeMirror paints the selection itself (`drawSelection` keeps the* native one transparent), it copies from its own state, and it ignores a- * selection parked outside its content element. So while an overlay menu is- * shown on top of the editor the browser selection is parked on the editor- * chrome and restored as soon as the menu closes.+ * selection parked outside its content element. So the browser selection is+ * parked on the editor chrome while an overlay menu covers the editor, and for+ * as long as a pointer gesture is dragging a long selection out, and restored+ * as soon as the menu closes or the pointer is released.+ *+ * The drag is the case that is easiest to misread from a bug report: sweeping+ * the pointer to the edge of the editor autoscrolls and never leaves the+ * pointer on the text, so it stays smooth, while moving back up into the+ * already selected lines pays the serialization cost on every mouse move+ * (smooth in Chrome/Blink, which does not make that request at all).** Parking outside `contentDOM` is what makes CodeMirror leave the editor state* alone (it maps a foreign selection back to the selection it already has), so@@ -27,15 +34,38 @@ import { appendDebugLog } from "@/lib/backend/debugLog";/*** Selections shorter than this are serialized cheaply enough that parking them- * would only trade a measurable cost for an invisible one.+ * would only trade a measurable cost for an invisible one. Dragging a selection+ * out keeps the browser selection live until it crosses this length, so a drag+ * over a few lines behaves exactly as it did before.*/export const NATIVE_SELECTION_PARK_MIN_CHARS = 1000;+/** Whether the editor's primary selection is long enough to be worth parking. */+export function isLargeEditorSelection(currentView: EditorView): boolean {+ const main = currentView.state.selection.main;+ return !main.empty && main.to - main.from >= NATIVE_SELECTION_PARK_MIN_CHARS;+}+export interface EditorNativeSelectionPark {/** Put the browser selection back where the editor state has it. */release(): void;}+export interface EditorNativeSelectionDragParkOptions extends EditorNativeSelectionParkOptions {+ /**+ * Parking is suspended while this returns false, which lets a caller keep one+ * handle for a whole gesture and still let a short selection behave normally.+ */+ shouldKeepParked?: () => boolean;+ /**+ * Whether CodeMirror's own browser-selection writes are suspended while the+ * park holds. Only the drag park wants this, because only the drag park is+ * re-collapsed in a frame loop that CodeMirror then writes against. See+ * `suppressEditorSelectionWrites`.+ */+ suppressEditorSelectionWrites?: boolean;+}+export interface EditorNativeSelectionParkOptions {/*** Applied to the text the parked copy path puts on the clipboard. Pass the@@ -63,6 +93,48 @@ function isParkedOutsideContent(currentView: EditorView, selection: Selection):return !!anchor && !currentView.contentDOM.contains(anchor);}+interface EditorViewSelectionInternals {+ docView?: { updateSelection?: (mustRead?: boolean, fromPointer?: boolean) => void };+ observer?: { selectionRange: { focusNode: Node | null }; readSelectionRange: () => boolean };+}++const UPDATE_SELECTION = "updateSelection";++/**+ * Stops CodeMirror from writing its selection into the browser while parked.+ *+ * Parking alone is not enough for a drag. CodeMirror rewrites the browser+ * selection whenever it differs from the editor state, and a parked selection+ * always differs, so every pointer move issues a fresh `collapse` inside the+ * editable — which is exactly the operation that costs tens of milliseconds on+ * macOS 26/27. Measured on a 2500 line document: 21 writes over a 300 line+ * drag, 23–167 ms each, all of the web process main thread. Those writes buy+ * nothing while parked: CodeMirror draws and copies the selection from its own+ * state, a parked selection is by definition not what the user sees.+ *+ * The suppression is narrow on purpose — it shadows the single method that+ * performs the write and keeps its read half, so CodeMirror still notices a+ * selection the browser moved on its own. It is restored by the park's+ * `release()`, and it refuses to touch a view whose internals do not look like+ * the ones it was written against.+ */+function suppressEditorSelectionWrites(currentView: EditorView): (() => void) | null {+ const internals = currentView as unknown as EditorViewSelectionInternals;+ const docView = internals.docView;+ const observer = internals.observer;+ if (!docView || typeof docView[UPDATE_SELECTION] !== "function" || !observer) return null;+ // Never clobber a patch somebody else owns; without our shadow the prototype+ // method is what CodeMirror calls, and that is exactly what we restore.+ if (Object.prototype.hasOwnProperty.call(docView, UPDATE_SELECTION)) return null;+ const suppressed = (mustRead?: boolean) => {+ if (mustRead || !observer.selectionRange.focusNode) observer.readSelectionRange();+ };+ docView[UPDATE_SELECTION] = suppressed;+ return () => {+ if (docView[UPDATE_SELECTION] === suppressed) delete docView[UPDATE_SELECTION];+ };+}+function parkSelection(currentView: EditorView, selection: Selection): void {try {// `view.dom` (the editor element) sits outside `view.contentDOM`, so@@ -138,38 +210,89 @@ function handleParkedClipboardEvent(currentView: EditorView, finalizeClipboardTe}/**- * Parks the browser selection while an overlay menu covers the editor.+ * The machinery both parking windows share.*- * @returns a handle that restores the browser selection, or `null` when there- * was nothing worth parking.+ * Parking is idempotent and self-healing: the browser can put a selection back+ * into the editor on its own (focus, a redraw, the platform moving a caret), so+ * the collapse is repeated for as long as the window lasts. Reading `anchorNode`+ * costs no layout, so the frame loop is cheap enough to run for the length of a+ * gesture. A drag park additionally stops CodeMirror from writing the browser+ * selection at all while it holds — see `suppressEditorSelectionWrites` — which+ * is what removes the per-pointer-move cost of re-collapsing a large selection.*/-export function parkEditorNativeSelection(currentView: EditorView, options: EditorNativeSelectionParkOptions = {}): EditorNativeSelectionPark | null {- const main = currentView.state.selection.main;- if (main.empty || main.to - main.from < NATIVE_SELECTION_PARK_MIN_CHARS) return null;- const selection = editorRootSelection(currentView);- if (!selection || !selection.anchorNode || !currentView.dom.contains(selection.anchorNode)) return null;- // Kept for field diagnosis: it only writes while debug logging is switched- // on, and it is the one line that shows whether the parked window was even- // entered when somebody reports the editor still stuttering.- appendDebugLog("info", "[DBX][QueryEditor:native-selection:park]", { chars: main.to - main.from });+interface NativeSelectionParkConfig {+ /** Whether the window should still hold. Re-read on every frame. */+ shouldKeepParked: () => boolean;+ finalizeClipboardText: (text: string) => string;+ /** See `suppressEditorSelectionWrites`. */+ suppressWrites?: boolean;+ /**+ * Restore the browser selection on the next frame instead of inside+ * `release()`, and skip the restore when the browser selection is no longer+ * parked by then.+ *+ * A gesture ends by dispatching: CodeMirror collapses the selection for a+ * click and rewrites the browser selection for a drag. Either way its own+ * write lands first, after which there is nothing left to restore — and+ * restoring first would put the whole long selection back into the browser+ * only to have CodeMirror write over it. On macOS 26/27 each of those writes+ * is the expensive text-services operation this module exists to avoid, so a+ * click that clears a long drag paid for three of them. The frame is the+ * safety net for the gestures that end without any dispatch — a release+ * outside the window, a focus change — where the parked selection would+ * otherwise stay parked. The restore re-reads the editor state when it runs.+ */+ deferReleaseRestore?: boolean;+}++/**+ * Which park most recently took the browser selection. A deferred restore only+ * acts while its own park is still the newest one: a park that starts before the+ * microtask runs owns the browser selection, and restoring under it would hand+ * the selection back to the text services for a frame.+ */+let latestParkSequence = 0;- parkSelection(currentView, selection);+function createNativeSelectionPark(currentView: EditorView, config: NativeSelectionParkConfig): EditorNativeSelectionPark {+ const { shouldKeepParked, finalizeClipboardText, suppressWrites = false, deferReleaseRestore = false } = config;+ const sequence = ++latestParkSequence;+ const doc = currentView.dom.ownerDocument;+ const win = doc.defaultView ?? window;let released = false;let frame = 0;- const finalizeClipboardText = options.finalizeClipboardText ?? ((text: string) => text);+ let parkedOnce = false;+ let parkedSince = 0;+ let restoreWrites: (() => void) | null = null;++ const park = () => {+ if (released || !shouldKeepParked()) return;+ const selection = editorRootSelection(currentView);+ if (!selection || isParkedOutsideContent(currentView, selection)) return;+ parkSelection(currentView, selection);+ if (!parkedOnce) {+ parkedOnce = true;+ parkedSince = performance.now();+ if (suppressWrites) restoreWrites = suppressEditorSelectionWrites(currentView);+ // Kept for field diagnosis: it only writes while debug logging is+ // switched on, and it is the one line that shows whether the parking+ // window was even entered when somebody reports the editor stuttering.+ appendDebugLog("info", "[DBX][QueryEditor:native-selection:park]", {+ chars: currentView.state.selection.main.to - currentView.state.selection.main.from,+ suppressesEditorWrites: !!restoreWrites,+ });+ }+ };+ park();++ const onCopy = (event: ClipboardEvent) => handleParkedClipboardEvent(currentView, finalizeClipboardText, () => released, event);// `copy`/`cut` bubble through the document, so listening there catches the// event no matter which editor chrome inside the view holds focus.- const doc = currentView.dom.ownerDocument;- const win = doc.defaultView ?? window;- const onCopy = (event: ClipboardEvent) => handleParkedClipboardEvent(currentView, finalizeClipboardText, () => released, event);doc.addEventListener("copy", onCopy);doc.addEventListener("cut", onCopy);- // CodeMirror rewrites the browser selection from its own state on every- // selection update (menu actions, diagnostics re-anchoring, typing), so a- // single collapse does not stick. Reading `anchorNode` costs no layout.+const keepParked = () => {if (released) return;- if (!isParkedOutsideContent(currentView, selection)) parkSelection(currentView, selection);+ park();frame = win.requestAnimationFrame(keepParked);};frame = win.requestAnimationFrame(keepParked);@@ -181,8 +304,60 @@ export function parkEditorNativeSelection(currentView: EditorView, options: Editdoc.removeEventListener("copy", onCopy);doc.removeEventListener("cut", onCopy);win.cancelAnimationFrame(frame);- const live = editorRootSelection(currentView);- if (live && isParkedOutsideContent(currentView, live)) restoreSelectionFromState(currentView, live);+ restoreWrites?.();+ restoreWrites = null;+ const restore = () => {+ if (sequence !== latestParkSequence) return;+ const live = editorRootSelection(currentView);+ if (live && isParkedOutsideContent(currentView, live)) restoreSelectionFromState(currentView, live);+ };+ if (deferReleaseRestore) win.requestAnimationFrame(restore);+ else restore();+ if (parkedOnce) {+ // Field diagnosis for "the selection took seconds to clear": how long a+ // park lived says whether a gesture was still parked while the user+ // thought it had ended, and how many frame-collapses it took.+ appendDebugLog("info", "[DBX][QueryEditor:native-selection:release]", {+ ms: Math.round(performance.now() - parkedSince),+ chars: currentView.state.selection.main.to - currentView.state.selection.main.from,+ suppressedEditorWrites: suppressWrites,+ });+ }},};}++/**+ * Parks the browser selection while an overlay menu covers the editor.+ *+ * @returns a handle that restores the browser selection, or `null` when there+ * was nothing worth parking.+ */+export function parkEditorNativeSelection(currentView: EditorView, options: EditorNativeSelectionParkOptions = {}): EditorNativeSelectionPark | null {+ if (!isLargeEditorSelection(currentView)) return null;+ const selection = editorRootSelection(currentView);+ if (!selection || !selection.anchorNode || !currentView.dom.contains(selection.anchorNode)) return null;+ return createNativeSelectionPark(currentView, { shouldKeepParked: () => true, finalizeClipboardText: options.finalizeClipboardText ?? ((text: string) => text) });+}++/**+ * Parks the browser selection for the length of a pointer gesture.+ *+ * Call this on pointer down and `release()` on pointer up: the browser+ * selection stays parked only while the editor's own selection is long enough+ * to be worth it (`isLargeEditorSelection`), so a gesture that never grows past+ * a few lines — or one that starts by shrinking a selection back down — keeps+ * behaving exactly as it did before. The editor keeps its own selection while+ * this runs, so the highlight, the selection that survives the release and the+ * text on the clipboard are unchanged.+ */+export function keepNativeSelectionParkedDuringDrag(currentView: EditorView, options: EditorNativeSelectionDragParkOptions = {}): EditorNativeSelectionPark {+ return createNativeSelectionPark(currentView, {+ shouldKeepParked: () => isLargeEditorSelection(currentView) && (options.shouldKeepParked?.() ?? true),+ finalizeClipboardText: options.finalizeClipboardText ?? ((text: string) => text),+ suppressWrites: options.suppressEditorSelectionWrites ?? true,+ // A gesture ends by dispatching a selection change, and that write is both+ // the correct one and the cheap one to land first. See `deferReleaseRestore`.+ deferReleaseRestore: true,+ });+}