@adecore/editor-react 0.23.0 → 0.24.0

package/src/diagnostics.ts

@@ -1,6 +1,8 @@
 import type { Diagnostic } from '@adecore/lsp';
+import { KEY_PRIORITY } from './key-priority.ts';
 import type { EditorContentChange, EditorPosition, EditorReveal } from '@adecore/editor';
 import type { EditorLanguage } from './editor-language.ts';
+import { sameRange } from './hover-content.ts';
 import { isShortcut } from './shortcut-keys.ts';
 import { comparePositions, markerOf, neighborProblem, problemCountsOf, problemsAt, severityOf, shiftRange, type Problem } from './diagnostics-model.ts';
 
@@ -27,19 +29,19 @@ export class DiagnosticsFeature {
         const reports = project.service.onDiagnostics((report) => {
             if (report.uri === uri) {
                 this.reports.set(report.source, report.diagnostics);
-                this.rebuild(true);
+                this.rebuild();
             }
         });
         const edits = editor.onTextChange((change) => this.shift(change.changes));
         // These keys are the editor's while it has the keyboard; elsewhere the menu's commands answer.
-        const keys = editor.onKeyDown((event) => {
+        const keys = language.onKey((event) => {
             const next = isShortcut(this.language.shortcuts.nextProblem, event);
             if (!next && !isShortcut(this.language.shortcuts.previousProblem, event)) {
                 return false;
             }
             this.step(next ? 1 : -1);
             return true;
-        });
+        }, KEY_PRIORITY.diagnostics);
         language.onDispose(() => {
             keys();
             reports.dispose();
@@ -99,23 +101,37 @@ export class DiagnosticsFeature {
         editor.announce(project.i18n.t('editor:language.announce.problem', { severity, message: problem.diagnostic.message }));
     }
 
+    /* The problems follow the edit as the markers do. Their number does not change, so nobody is told. */
     private shift(changes: readonly EditorContentChange[]): void {
+        let moved = false;
         for (const [server, diagnostics] of this.reports) {
-            this.reports.set(
-                server,
-                diagnostics.map((diagnostic) => ({ ...diagnostic, range: shiftRange(diagnostic.range, changes) }))
-            );
+            let shifted: Diagnostic[] | null = null;
+            for (const [index, diagnostic] of diagnostics.entries()) {
+                const range = shiftRange(diagnostic.range, changes);
+                if (!sameRange(range, diagnostic.range)) {
+                    shifted ??= [...diagnostics];
+                    shifted[index] = { ...diagnostic, range };
+                }
+            }
+            if (shifted !== null) {
+                this.reports.set(server, shifted);
+                moved = true;
+            }
+        }
+        if (moved) {
+            this.collect();
         }
-        this.rebuild(false);
     }
 
-    private rebuild(draw: boolean): void {
-        this.list = [...this.reports].flatMap(([server, diagnostics]) => diagnostics.map((diagnostic): Problem => ({ diagnostic, server })));
-        if (draw) {
-            this.language.editor.setMarkers(this.list.map((problem) => markerOf(problem.diagnostic)));
-        }
+    private rebuild(): void {
+        this.collect();
+        this.language.editor.setMarkers(this.list.map((problem) => markerOf(problem.diagnostic)));
         for (const listener of [...this.listeners]) {
             listener();
         }
     }
+
+    private collect(): void {
+        this.list = [...this.reports].flatMap(([server, diagnostics]) => diagnostics.map((diagnostic): Problem => ({ diagnostic, server })));
+    }
 }

package/src/diff-overlays.tsx

@@ -1,7 +1,7 @@
 import { useSyncExternalStore } from 'react';
 import { createPortal } from 'react-dom';
 import { useTranslation } from 'react-i18next';
-import { Button } from '@adecore/ui';
+import { Button, Tooltip } from '@adecore/ui';
 import { formatNumber } from '@adecore/ui/format';
 import type { Editor, EditorEngine } from '@adecore/editor';
 import type { DiffDisplay } from '@adecore/merge';
@@ -38,13 +38,17 @@ export function DiffOverlays({
                 const text = t('diff.hidden', { count: formatNumber(Math.max(row.oldCount, row.newCount)) });
                 return createPortal(
                     <div className="adecore-editor-diff-gap">
-                        {row.unfoldable ? (
-                            <Button
-                                size="xs"
-                                disabled={blocked?.has(row.id)}
-                                title={blocked?.has(row.id) ? t('diff.contextLimit') : undefined}
-                                onClick={() => unfold(row.id)}
-                            >
+                        {row.unfoldable && blocked?.has(row.id) === true ? (
+                            <Tooltip label={t('diff.contextLimit')}>
+                                {/* A disabled button gets no pointer events, so the hint hangs on a wrapper. */}
+                                <span className="inline-flex">
+                                    <Button size="xs" disabled>
+                                        {text}
+                                    </Button>
+                                </span>
+                            </Tooltip>
+                        ) : row.unfoldable ? (
+                            <Button size="xs" onClick={() => unfold(row.id)}>
                                 {text}
                             </Button>
                         ) : (

package/src/editor-language.ts

@@ -1,5 +1,5 @@
 import { KEYMAP, type Keymap } from '@adecore/editor/keymap';
-import type { Editor, EditorPosition } from '@adecore/editor';
+import type { Editor, EditorKeyHandler, EditorPosition } from '@adecore/editor';
 import type { Location } from '@adecore/lsp';
 import { CallHierarchyFeature } from './call-hierarchy.ts';
 import { CodeActionsFeature } from './code-actions.ts';
@@ -13,6 +13,7 @@ import { FormatOnTypeFeature } from './format-on-type.ts';
 import { HighlightsFeature } from './highlights.ts';
 import { HistoryFeature } from './history.ts';
 import { HoverFeature } from './hover.ts';
+import { KeyDispatcher } from './key-priority.ts';
 import { NavigationFeature, locationRow } from './navigation.ts';
 import { PeekFeature } from './peek.ts';
 import { PickFeature } from './pick.ts';
@@ -73,6 +74,7 @@ export class EditorLanguage {
     readonly formatOnType: FormatOnTypeFeature;
     readonly renderedDocs: RenderedDocsFeature;
     private readonly disposers: Array<() => void> = [];
+    private readonly keys = new KeyDispatcher();
     private disposed = false;
 
     constructor(project: ProjectLanguage, editor: Editor, uri: string, languageId: string, timers: Timers = realTimers, options: EditorLanguageOptions = {}) {
@@ -83,6 +85,7 @@ export class EditorLanguage {
         this.project = project;
         this.languageId = languageId;
         this.document = project.acquire(uri, languageId, editor);
+        this.onDispose(editor.onKeyDown((event) => this.keys.dispatch(event)));
         this.pick = new PickFeature(this, timers);
         this.diagnostics = new DiagnosticsFeature(this);
         this.hover = new HoverFeature(this, timers);
@@ -97,7 +100,7 @@ export class EditorLanguage {
         this.codeActions = new CodeActionsFeature(this, timers);
         this.rename = new RenameFeature(this);
         this.navigation = new NavigationFeature(this);
-        this.peek = new PeekFeature(this);
+        this.peek = new PeekFeature(this, timers);
         this.callHierarchy = new CallHierarchyFeature(this, timers);
         this.symbolPicker = new SymbolPickerFeature(this);
         this.contextMenu = new ContextMenuFeature(this);
@@ -177,6 +180,14 @@ export class EditorLanguage {
         };
     }
 
+    /*
+     * Lets `handler` see the editor's keys before every handler of a lower `priority`, the first to take a key
+     * winning. `KEY_PRIORITY` holds the features'; the default, 0, comes after all of them.
+     */
+    onKey(handler: EditorKeyHandler, priority = 0): () => void {
+        return this.keys.add(handler, priority);
+    }
+
     /* Runs `dispose` when the editor lets go of its document. */
     onDispose(dispose: () => void): void {
         this.disposers.push(dispose);

package/src/format-on-type.ts

@@ -26,12 +26,11 @@ function overlaps(edits: readonly TextEdit[]): boolean {
  * second caret, a read-only editor or a snippet session, whose tab stops an edit could move. An answer is applied
  * only while the text is exactly what it was asked about, and the caret where it was.
  *
- * The edits join the undo step of the typed character, so one undo takes both back. On by default where the server offers it; `configure(false)`
- * turns it off for a host that has a setting for it.
+ * The edits join the undo step of the typed character, so one undo takes both back. Off by default; a host enables it explicitly with `configure(true)`.
  */
 export class FormatOnTypeFeature {
     private readonly language: EditorLanguage;
-    private enabled = true;
+    private enabled = false;
     /* Raised by every change of the text, so an answer for an older text is told from the one for the text that is. */
     private revision = 0;
     private controller = new AbortController();

package/src/highlights.ts

@@ -1,4 +1,5 @@
 import type { DocumentHighlight } from '@adecore/lsp';
+import { KEY_PRIORITY } from './key-priority.ts';
 import type { EditorHighlight, EditorHighlightKind, EditorPosition, EditorRange } from '@adecore/editor';
 import { comparePositions, rangeHolds } from './diagnostics-model.ts';
 import { isIdentifierCharacter } from './completion-model.ts';
@@ -70,13 +71,13 @@ export class HighlightsFeature {
                 this.current = [];
                 this.refresher.later();
             }),
-            editor.onKeyDown((event) => {
+            language.onKey((event) => {
                 const next = isShortcut(this.language.shortcuts.nextHighlight, event);
                 if (!next && !isShortcut(this.language.shortcuts.previousHighlight, event)) {
                     return false;
                 }
                 return this.step(next ? 1 : -1);
-            })
+            }, KEY_PRIORITY.highlights)
         ];
         language.onDispose(() => {
             for (const off of offs) {

package/src/history.ts

@@ -1,4 +1,5 @@
 import type { EditorLanguage } from './editor-language.ts';
+import { KEY_PRIORITY } from './key-priority.ts';
 import type { Place } from './navigation-history.ts';
 import { isShortcut } from './shortcut-keys.ts';
 
@@ -8,7 +9,7 @@ export class HistoryFeature {
 
     constructor(language: EditorLanguage) {
         this.language = language;
-        const off = language.editor.onKeyDown((event) => {
+        const off = language.onKey((event) => {
             if (isShortcut(this.language.shortcuts.historyBack, event)) {
                 this.back();
                 return true;
@@ -22,7 +23,7 @@ export class HistoryFeature {
                 return true;
             }
             return false;
-        });
+        }, KEY_PRIORITY.history);
         language.onDispose(off);
     }
 

package/src/holder.ts

@@ -1,15 +1,16 @@
-export function createHolder<T>() {
+/* One value that an effect sets and a render reads through `useSyncExternalStore`, without a state update inside the effect. */
+export function createHolder<T>(): { get(): T | null; set(value: T | null): void; subscribe(listener: () => void): () => void } {
     let value: T | null = null;
     const listeners = new Set<() => void>();
     return {
         get: () => value,
-        set: (next: T | null) => {
+        set: (next) => {
             value = next;
-            for (const listener of listeners) {
+            for (const listener of [...listeners]) {
                 listener();
             }
         },
-        subscribe: (listener: () => void) => {
+        subscribe: (listener) => {
             listeners.add(listener);
             return () => {
                 listeners.delete(listener);

package/src/host-types.ts

@@ -4,6 +4,7 @@ import type { i18n } from 'i18next';
 import type { Keymap } from '@adecore/editor/keymap';
 import type { ProjectFiles } from './workspace-edit.ts';
 import type { Place } from './navigation-history.ts';
+import type { ProblemSource } from './project-problems.ts';
 
 export interface DiskText {
     text: string;
@@ -35,6 +36,8 @@ export interface RenameSuggestionsRequest {
     uri: string;
     languageId: string;
     name: string;
+    /* What the name belongs to, in words (`function`, `class`, `type parameter`), when the outline of the file lists it. */
+    kind?: string;
     context: string;
     uses: readonly string[];
 }
@@ -61,6 +64,12 @@ export interface LanguageHost {
     readonly files?: ProjectFiles;
     readonly apple?: boolean;
     readonly keymap?: Keymap;
+    /* The height in pixels of the list-and-preview area of the peek and the call hierarchy, so a person's drag outlives the panel; 180 without one. */
+    readonly panelBodyHeight?: number;
+    /* A person finished resizing a peek or call hierarchy panel; the height is already within what the editor allows. */
+    onPanelResize?(height: number): void;
+    /* Where `project.problems` reads its reports, such as a machine that also reports files no editor here holds; the service's diagnostics without one. */
+    readonly problemSource?: ProblemSource;
     openPlace?(place: Place): void;
     pathOfUri?(uri: string): string | null;
     serverNames?(uri: string): readonly string[];

package/src/hover.ts

@@ -1,4 +1,5 @@
 import type { EditorHover, EditorPosition, EditorRange } from '@adecore/editor';
+import { KEY_PRIORITY } from './key-priority.ts';
 import type { EditorLanguage } from './editor-language.ts';
 import { rangeHolds, type Problem } from './diagnostics-model.ts';
 import { hoverTextOf, isEmptyHover, locationsOf, type HoverText } from './hover-content.ts';
@@ -14,6 +15,11 @@ const HIDE_DELAY_MS = 250;
 const COUNT_DELAY_MS = 500;
 const TOAST_ID = 'language-hover';
 
+export interface HoverSettings {
+    /* Counts the references of the symbol on a card that stays up, which can be a search over the whole project; on unless false. */
+    readonly referenceCount?: boolean;
+}
+
 /*
  * The card under a character the pointer rests on: the problems there, and what the language servers
  * say about the symbol. It opens after the pointer has stayed a moment, stays while the pointer is on
@@ -28,6 +34,7 @@ export class HoverFeature {
     private hideTimer: unknown;
     private countTimer: unknown;
     private inCard = false;
+    private referenceCount = true;
     /* Counts every request, so an answer that arrives after the pointer moved on is dropped. */
     private request = 0;
     private lookup: AbortController | null = null;
@@ -62,17 +69,17 @@ export class HoverFeature {
                     this.hide();
                 }
             }),
-            editor.onKeyDown((event) => {
+            language.onKey((event) => {
                 if (isShortcut(this.language.shortcuts.quickInfo, event)) {
                     this.quickInfo();
                     return true;
                 }
-                if (event.key === 'Escape' && this.language.popups.getState().hover !== null && this.language.popups.getState().callHierarchy == null) {
+                if (event.key === 'Escape' && this.language.popups.getState().hover !== null && this.language.popups.getState().callHierarchy === null) {
                     this.hide();
                     return true;
                 }
                 return false;
-            })
+            }, KEY_PRIORITY.hover)
         ];
         language.onDispose(() => {
             for (const off of offs) {
@@ -82,6 +89,13 @@ export class HoverFeature {
         });
     }
 
+    configure(settings: HoverSettings): void {
+        this.referenceCount = settings.referenceCount !== false;
+        if (!this.referenceCount) {
+            this.timers.clear(this.countTimer);
+        }
+    }
+
     /* The pointer entered or left the card, which is where a link in it is clicked. */
     holdCard(inside: boolean): void {
         this.inCard = inside;
@@ -236,7 +250,7 @@ export class HoverFeature {
         }
         this.pinned = pinned;
         this.present(position, problems, info, problems[0]?.diagnostic.range ?? range);
-        if (info !== null) {
+        if (info !== null && this.referenceCount) {
             this.scheduleCount(position, request, controller.signal);
         }
     }
@@ -270,7 +284,7 @@ export class HoverFeature {
     /* How many places use the symbol, which can take a while in a large project and so arrives after the card does. */
     private async count(position: EditorPosition, key: string, request: number, signal: AbortSignal): Promise<void> {
         const { service } = this.language.project;
-        if (request !== this.request || !service.supports('textDocument/references', this.language.uri)) {
+        if (request !== this.request || !this.referenceCount || !service.supports('textDocument/references', this.language.uri)) {
             return;
         }
         const found = await service.references(this.language.uri, position, false, { signal }).catch(() => null);

package/src/index.ts

@@ -1,4 +1,6 @@
 export { EditorLanguage, type EditorLanguageOptions } from './editor-language.ts';
+export { KEY_PRIORITY } from './key-priority.ts';
+export { realTimers, type Timers } from './timers.ts';
 export { DEFAULT_RANGE_LINES, DEFAULT_RANGE_CHARACTERS, type SemanticTokensOptions } from './semantic-tokens.ts';
 export { ProjectLanguage, type FileOperationTarget } from './project-language.ts';
 export type { LanguageDocumentHandle } from './project-language.ts';
@@ -15,6 +17,7 @@ export { EditorView } from './EditorView.tsx';
 export { createHolder } from './holder.ts';
 export type { EditorViewProps } from './EditorView.tsx';
 export { LanguagePopups } from './LanguagePopups.tsx';
+export type { LanguagePopupsProps } from './LanguagePopups.tsx';
 export { AnchoredPopup } from './AnchoredPopup.tsx';
 export { HoverCard } from './HoverCard.tsx';
 export { CompletionPopup } from './CompletionPopup.tsx';
@@ -36,13 +39,14 @@ export type { EditorRendering } from './rendering-context.ts';
 export { FindReplace } from './FindReplace.tsx';
 export { ChangeReview } from './ChangeReview.tsx';
 export type { ChangeReviewProps } from './ChangeReview.tsx';
-export { ProjectProblems, countsOf, compareRows } from './project-problems.ts';
-export type { ProblemFile, ProblemRow } from './project-problems.ts';
+export { ProjectProblems, serviceProblems, countsOf, compareRows } from './project-problems.ts';
+export type { ProblemFile, ProblemRow, ProblemReport, ProblemSource } from './project-problems.ts';
 export { applyWorkspaceEdit, supportedResourceOperations } from './workspace-edit.ts';
 export type { ProjectFiles, StagedFile, WorkspaceEditHost } from './workspace-edit.ts';
 export { useProblemCounts } from './use-problem-counts.ts';
 export type { ProblemCounts } from './diagnostics.ts';
 export type { BlameSource, CodeVisionSettings } from './code-vision.ts';
+export type { HoverSettings } from './hover.ts';
 export type { Problem } from './diagnostics-model.ts';
 export type {
     PopupState,

package/src/key-priority.ts

@@ -0,0 +1,49 @@
+import type { EditorKeyHandler } from '@adecore/editor';
+
+/*
+ * Where each feature of an editor sees a key through `EditorLanguage.onKey`, the highest first. A hundred
+ * apart, so a handler of the app can stand between two features; 0, the default, comes after all of them.
+ */
+export const KEY_PRIORITY = {
+    pick: 1500,
+    diagnostics: 1400,
+    hover: 1300,
+    completion: 1200,
+    snippets: 1100,
+    signature: 1000,
+    highlights: 900,
+    codeActions: 800,
+    rename: 700,
+    navigation: 600,
+    peek: 500,
+    callHierarchy: 400,
+    symbolPicker: 300,
+    history: 200,
+    renderedDocs: 100
+} as const;
+
+interface Entry {
+    readonly handler: EditorKeyHandler;
+    readonly priority: number;
+}
+
+/* Hands a key to its handlers by priority until one takes it; of two of the same priority the one added first. */
+export class KeyDispatcher {
+    private readonly entries: Entry[] = [];
+
+    add(handler: EditorKeyHandler, priority: number): () => void {
+        const entry = { handler, priority };
+        const index = this.entries.findIndex((other) => other.priority < priority);
+        this.entries.splice(index === -1 ? this.entries.length : index, 0, entry);
+        return () => {
+            const at = this.entries.indexOf(entry);
+            if (at !== -1) {
+                this.entries.splice(at, 1);
+            }
+        };
+    }
+
+    dispatch(event: KeyboardEvent): boolean {
+        return [...this.entries].some((entry) => entry.handler(event));
+    }
+}

package/src/locales/en.json

@@ -82,6 +82,9 @@
                 "symbol": "Matches"
             }
         },
+        "panel": {
+            "resize": "Resize panel"
+        },
         "peek": {
             "unavailable": "No language server finds references in this file",
             "none": "No references found",
@@ -175,7 +178,8 @@
             "details": "Details",
             "none": "No suggestions",
             "transformBusy": "Snippet transforms are busy; try again",
-            "transformFailed": "Snippet transform could not be applied"
+            "transformFailed": "Snippet transform could not be applied",
+            "failed": "Could not insert the suggestion: {{message}}"
         },
         "history": {
             "recent": "Recent locations"

package/src/locales/nl.json

@@ -82,6 +82,9 @@
                 "symbol": "Overeenkomsten"
             }
         },
+        "panel": {
+            "resize": "Paneel vergroten of verkleinen"
+        },
         "peek": {
             "unavailable": "Geen language server vindt referenties in dit bestand",
             "none": "Geen referenties gevonden",
@@ -175,7 +178,8 @@
             "details": "Details",
             "none": "Geen suggesties",
             "transformBusy": "Snippettransformaties zijn bezig; probeer het opnieuw",
-            "transformFailed": "Snippettransformatie kon niet worden toegepast"
+            "transformFailed": "Snippettransformatie kon niet worden toegepast",
+            "failed": "De suggestie kon niet worden ingevoegd: {{message}}"
         },
         "history": {
             "recent": "Recente plekken"

package/src/models.ts

@@ -37,6 +37,7 @@ export {
     markerOf,
     comparePositions,
     shiftPosition,
+    endOfInsertion,
     shiftRange,
     rangeHolds,
     problemsAt,
@@ -159,7 +160,6 @@ export {
     type InlineAnswer,
     parseAnswer,
     fitReplacement,
-    endOfInsertion,
     type DiffSegment,
     diffSegments,
     emphasisOf,

package/src/navigation.ts

@@ -1,4 +1,5 @@
 import { StaleResultError, fileUriToPath, type LanguageService, type Location, type LocationLink, type NavigationResult, type Range } from '@adecore/lsp';
+import { KEY_PRIORITY } from './key-priority.ts';
 import type { EditorPosition } from '@adecore/editor';
 import { basenameOf } from './paths.ts';
 import type { EditorLanguage } from './editor-language.ts';
@@ -76,14 +77,14 @@ export class NavigationFeature {
                 void this.go('definition', click.position);
                 return true;
             }),
-            editor.onKeyDown((event) => {
+            language.onKey((event) => {
                 const found = SHORTCUT_KINDS.find(([, name]) => isShortcut(this.language.shortcuts[name], event));
                 if (found === undefined) {
                     return false;
                 }
                 void this.go(found[0]);
                 return true;
-            })
+            }, KEY_PRIORITY.navigation)
         ];
         language.onDispose(() => {
             for (const off of offs) {

package/src/panel-size.ts

@@ -0,0 +1,28 @@
+/* The height of the list-and-preview area of a peek or a call hierarchy, which is what a person drags; the bands and the title bar around it stay. */
+export const PANEL_BODY_HEIGHT = 180;
+/* Four rows of 22px, so a list never shrinks to nothing. */
+export const PANEL_BODY_MIN = 88;
+/* What the bands and the title bar take of the panel, which the share of the editor has to leave room for. */
+const PANEL_CHROME = 63;
+/* The share of the editor's height a panel may take, so the line it belongs to stays in view. */
+const PANEL_MAX_SHARE = 0.8;
+const PANEL_FALLBACK_AVAILABLE = 800;
+export const PANEL_KEY_STEP = 22;
+
+/* The tallest body for an editor that is `available` pixels high; never below the minimum, so a tiny editor still gets a usable panel. */
+export function panelBodyMax(available: number): number {
+    return Math.max(PANEL_BODY_MIN, Math.floor(available * PANEL_MAX_SHARE) - PANEL_CHROME);
+}
+
+export function clampPanelBody(height: number, available: number = PANEL_FALLBACK_AVAILABLE): number {
+    if (!Number.isFinite(height)) {
+        return PANEL_BODY_HEIGHT;
+    }
+    return Math.min(panelBodyMax(available), Math.max(PANEL_BODY_MIN, Math.round(height)));
+}
+
+/* The height of the editor's scrolling area around a panel's row; the fallback stands in where nothing is laid out. */
+export function availableHeightOf(container: HTMLElement | null): number {
+    const height = container?.closest<HTMLElement>('.se-viewport')?.clientHeight ?? 0;
+    return height > 0 ? height : PANEL_FALLBACK_AVAILABLE;
+}

package/src/peek.ts

@@ -1,4 +1,5 @@
 import { StaleResultError, type Location, type Range } from '@adecore/lsp';
+import { KEY_PRIORITY } from './key-priority.ts';
 import type { EditorPosition } from '@adecore/editor';
 import type { EditorLanguage } from './editor-language.ts';
 import { uniquePlaces } from './navigation.ts';
@@ -6,6 +7,7 @@ import { PEEK_READ_FILES, definitionSnippetOf, peekFilesOf, snippetOf, type Peek
 import type { PeekView } from './popups.ts';
 import { isShortcut } from './shortcut-keys.ts';
 import { messageOf } from './error-message.ts';
+import { realTimers, revealRow, type Timers } from './timers.ts';
 
 const TOAST_ID = 'language-peek';
 /* The block as the panel draws it: a hatched band, the header, eight lines of code and a hatched band, until the editor has measured it. */
@@ -29,6 +31,7 @@ function placeKey(location: Location): string {
  */
 export class PeekFeature {
     private readonly language: EditorLanguage;
+    private readonly timers: Timers;
     private kind: PeekKind = 'references';
     /* The whole declaration of each place of a definition peek, where the server gave it. */
     private targets = new Map<string, Range>();
@@ -38,11 +41,12 @@ export class PeekFeature {
     private line = 0;
     private token = 0;
 
-    constructor(language: EditorLanguage) {
+    constructor(language: EditorLanguage, timers: Timers = realTimers) {
         this.language = language;
+        this.timers = timers;
         const { editor } = language;
         const offs = [
-            editor.onKeyDown((event) => {
+            language.onKey((event) => {
                 if (isShortcut(this.language.shortcuts.peekReferences, event)) {
                     void this.open();
                     return true;
@@ -52,7 +56,7 @@ export class PeekFeature {
                     return true;
                 }
                 return this.key(event);
-            }),
+            }, KEY_PRIORITY.peek),
             editor.onTextChange(() => this.close())
         ];
         language.onDispose(() => {
@@ -201,6 +205,7 @@ export class PeekFeature {
         const view = this.language.popups.getState().peek;
         if (view !== null && view.container !== container) {
             this.language.popups.setState({ peek: { ...view, container } });
+            revealRow(this.timers, container);
         }
     }
 

package/src/pick.ts

@@ -1,4 +1,5 @@
 import type { EditorPosition } from '@adecore/editor';
+import { KEY_PRIORITY } from './key-priority.ts';
 import type { EditorLanguage } from './editor-language.ts';
 import type { PickGroup, PickPreview } from './popups.ts';
 import { realTimers, type Timers } from './timers.ts';
@@ -45,7 +46,7 @@ export class PickFeature {
         this.timers = timers;
         const { editor } = language;
         const offs = [
-            editor.onKeyDown((event) => this.key(event)),
+            language.onKey((event) => this.key(event), KEY_PRIORITY.pick),
             editor.onTextChange(() => this.close()),
             editor.onCaret(() => this.close()),
             editor.onBlur(() => this.close())

package/src/popup-focus.ts

@@ -0,0 +1,17 @@
+import type { FocusEvent, MouseEvent } from 'react';
+
+/*
+ * The handlers for a popup list whose rows the keyboard never enters: the text it belongs to keeps the
+ * focus, and the active row is only `aria-activedescendant` or a highlight. Chromium reports that row as
+ * the focused element, so a tool that focuses it before it types would otherwise pull the keys out of the
+ * text. A press on the list moves no focus, and a row that gets it anyway hands it straight back.
+ */
+export function keepFocusOutOfList(focusBack: () => void): {
+    onMouseDown(event: MouseEvent): void;
+    onFocus(event: FocusEvent): void;
+} {
+    return {
+        onMouseDown: (event) => event.preventDefault(),
+        onFocus: () => focusBack()
+    };
+}

package/src/popups.ts

@@ -203,8 +203,7 @@ export interface PopupState {
     readonly pick: PickView | null;
     readonly rename: RenameView | null;
     readonly peek: PeekView | null;
-    /* Optional so a host that builds a `PopupState` literal from before the call hierarchy still fits; absent reads as closed. */
-    readonly callHierarchy?: CallHierarchyView | null;
+    readonly callHierarchy: CallHierarchyView | null;
     readonly symbols: SymbolsView | null;
     readonly menu: MenuView | null;
     readonly authors: AuthorsView | null;