fix(editor): let blank-area clicks clear a select-all selection
This commit is contained in:
5 files changed
+748
-42
No files matched your search
@@ -1,7 +1,7 @@
|
||||
// @vitest-environment happy-dom
|
||||
import { 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();
|
||||
|
||||
return { view, contentDOM, dispatch, selectedText: () => document.getSelection()?.toString() ?? "" };
|
||||
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() ?? "", 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);
|
||||
});
|
||||
});
|
||||
@@ -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;
|
||||
}
|
||||
|
||||
parkSelection(currentView, selection);
|
||||
let released = false;
|
||||
let frame = 0;
|
||||
const finalizeClipboardText = options.finalizeClipboardText ?? ((text: string) => text);
|
||||
// `copy`/`cut` bubble through the document, so listening there catches the
|
||||
// event no matter which editor chrome inside the view holds focus.
|
||||
/**
|
||||
* 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;
|
||||
|
||||
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;
|
||||
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.
|
||||
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: Edit
|
||||
doc.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,
|
||||
});
|
||||
}
|
||||
Reference in new issue
Block a user