@adecore/editor-react 0.22.1 → 0.23.0

package/dist/host-types.d.ts

@@ -1,3 +1,5 @@
+import type { WorkerRequestPort } from '@adecore/editor/worker-client';
+import type { EditorPosition, EditorRange } from '@adecore/editor';
 import type { i18n } from 'i18next';
 import type { Keymap } from '@adecore/editor/keymap';
 import type { ProjectFiles } from './workspace-edit.ts';
@@ -31,7 +33,21 @@ export interface RenameSuggestionsRequest {
     context: string;
     uses: readonly string[];
 }
+export interface SnippetVariableContext {
+    readonly uri: string;
+    readonly languageId: string;
+    readonly position: EditorPosition;
+    readonly selection: EditorRange;
+    readonly selectedText: string;
+    readonly currentLine: string;
+    readonly currentWord: string;
+    readonly cursorIndex: number;
+    readonly cursorCount: number;
+    readonly folder?: string;
+    readonly path?: string;
+}
 export interface LanguageHost {
+    readonly snippetTransformWorker?: () => WorkerRequestPort;
     readonly i18n?: i18n;
     readonly folder?: string;
     readonly files?: ProjectFiles;
@@ -41,5 +57,6 @@ export interface LanguageHost {
     pathOfUri?(uri: string): string | null;
     serverNames?(uri: string): readonly string[];
     notify?(notification: EditorNotification): void;
+    resolveSnippetVariable?(name: string, context: SnippetVariableContext): string | undefined;
     suggestNames?(request: RenameSuggestionsRequest, signal: AbortSignal): Promise<readonly string[]>;
 }

package/dist/hover.d.ts

@@ -1,6 +1,8 @@
 import type { EditorPosition, EditorRange } from '@adecore/editor';
 import type { EditorLanguage } from './editor-language.ts';
+import { type HoverText } from './hover-content.ts';
 import { type Timers } from './timers.ts';
+export declare const SHOW_DELAY_MS = 300;
 export declare class HoverFeature {
     private readonly language;
     private readonly timers;
@@ -19,6 +21,8 @@ export declare class HoverFeature {
     showProblemsAt(position: EditorPosition): boolean;
     keep(): void;
     showRange(range: EditorRange): void;
+    showText(position: EditorPosition, text: HoverText): void;
+    release(): void;
     hide(): void;
     private moved;
     private scheduleHide;

package/dist/hover.js

@@ -4,7 +4,7 @@ import { lineTextOf } from './line-text.js';
 import { wordRangeAt } from './rename-model.js';
 import { isShortcut } from './shortcut-keys.js';
 import { realTimers } from './timers.js';
-const SHOW_DELAY_MS = 300;
+export const SHOW_DELAY_MS = 300;
 const HIDE_DELAY_MS = 250;
 /* How long a card has to stay up before the references of its symbol are counted, which can be a request over the whole project. */
 const COUNT_DELAY_MS = 500;
@@ -61,7 +61,7 @@ export class HoverFeature {
                     this.quickInfo();
                     return true;
                 }
-                if (event.key === 'Escape' && this.language.popups.getState().hover !== null) {
+                if (event.key === 'Escape' && this.language.popups.getState().hover !== null && this.language.popups.getState().callHierarchy == null) {
                     this.hide();
                     return true;
                 }
@@ -114,6 +114,15 @@ export class HoverFeature {
         this.keep();
         this.present(range.start, [], null, range);
     }
+    /* A card of text another feature brings, such as the tooltip of an inlay hint, which goes the way any hover card does. */
+    showText(position, text) {
+        this.hide();
+        this.present(position, [], { text, definition: null, word: '', references: null, plain: true }, null);
+    }
+    /* The pointer left what a card was opened for: it closes unless the pointer reaches the card in time. */
+    release() {
+        this.scheduleHide();
+    }
     hide() {
         this.pinned = false;
         this.held = false;
@@ -199,6 +208,10 @@ export class HoverFeature {
         }
         if (problems.length === 0 && info === null) {
             this.hide();
+            if (pinned && (await this.language.inlayHints.showTooltipAt(position))) {
+                this.pinned = true;
+                return;
+            }
             if (pinned) {
                 this.language.project.host.notify?.({ id: TOAST_ID, kind: 'error', title: this.language.project.i18n.t('editor:language.hover.none') });
             }

package/dist/index.d.ts

@@ -1,7 +1,8 @@
-export { EditorLanguage } from './editor-language.ts';
-export { ProjectLanguage } from './project-language.ts';
+export { EditorLanguage, type EditorLanguageOptions } from './editor-language.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';
-export type { LanguageHost, DiskText, GitBlameCommit, GitBlameResult, EditorNotification, RenameSuggestionsRequest } from './host-types.ts';
+export type { SnippetVariableContext, LanguageHost, DiskText, GitBlameCommit, GitBlameResult, EditorNotification, RenameSuggestionsRequest } from './host-types.ts';
 export { EditorView } from './EditorView.tsx';
 export { createHolder } from './holder.ts';
 export type { EditorViewProps } from './EditorView.tsx';
@@ -13,8 +14,14 @@ export { SignatureCard } from './SignatureCard.tsx';
 export { RenameCard } from './RenameCard.tsx';
 export { PickPopup } from './PickPopup.tsx';
 export { PeekPanel } from './PeekPanel.tsx';
+export { CallHierarchyPanel } from './CallHierarchyPanel.tsx';
 export { SymbolPicker } from './SymbolPicker.tsx';
 export { CodeAuthorsCard } from './CodeAuthorsCard.tsx';
+export { RenderedDocs } from './RenderedDocs.tsx';
+export { RenderedDocsFeature } from './rendered-docs.ts';
+export type { RenderedDocEntry, RenderedDocsSettings } from './rendered-docs.ts';
+export { parseDocComment, sectionsOf, htmlToMarkdown, DOC_LINK_PREFIX } from './doc-comment-model.ts';
+export type { DocTagEntry, DocTagSection, ParsedDocComment } from './doc-comment-model.ts';
 export { EditorContextMenu } from './EditorContextMenu.tsx';
 export { EditorRenderingProvider } from './rendering.tsx';
 export type { EditorRendering } from './rendering-context.ts';
@@ -23,13 +30,13 @@ 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 { applyWorkspaceEdit } from './workspace-edit.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 { Problem } from './diagnostics-model.ts';
-export type { PopupState, PopupStore, HoverInfo, HoverView, CompletionView, CompletionDocs, CompletionRow, SignatureView, RenameView, RenameFileView, PeekView, PickView, PickGroup, PickRow, PickPreview, SymbolsView, MenuView, AuthorsView } from './popups.ts';
+export type { PopupState, PopupStore, HoverInfo, HoverView, CompletionView, CompletionDocs, CompletionRow, SignatureView, RenameView, RenameFileView, PeekView, CallHierarchyView, PickView, PickGroup, PickRow, PickPreview, SymbolsView, MenuView, AuthorsView } from './popups.ts';
 export { RowHost, LineActionHost } from './row-host.ts';
 export type { HostedRow, HostedAction } from './row-host.ts';
 export { HighlightLayers, highlightLayers } from './highlight-layers.ts';
@@ -42,3 +49,10 @@ export { AttributionCard } from './AttributionCard.tsx';
 export type { AttributionCardProps } from './AttributionCard.tsx';
 export { ReviewGroup, joinReviewGroup } from './review-group.ts';
 export type { ReviewMember } from './review-group.ts';
+export { DiffView } from './DiffView.tsx';
+export type { DiffViewProps } from './DiffView.tsx';
+export type { DiffLimits } from './diff-expansion.ts';
+export { diffSyntaxDocument } from './diff-syntax.ts';
+export type { DiffSourceSide, DiffSourceTokens, DiffSyntaxSources } from './diff-syntax.ts';
+export { decoratePatch, usePatchDecorations } from './patch-decorations.ts';
+export type { PatchDecoration, PatchDecorationOptions, PatchLineLabels, PatchTimer } from './patch-decorations.ts';

package/dist/index.js

@@ -1,4 +1,5 @@
 export { EditorLanguage } from './editor-language.js';
+export { DEFAULT_RANGE_LINES, DEFAULT_RANGE_CHARACTERS } from './semantic-tokens.js';
 export { ProjectLanguage } from './project-language.js';
 export { EditorView } from './EditorView.js';
 export { createHolder } from './holder.js';
@@ -10,14 +11,18 @@ export { SignatureCard } from './SignatureCard.js';
 export { RenameCard } from './RenameCard.js';
 export { PickPopup } from './PickPopup.js';
 export { PeekPanel } from './PeekPanel.js';
+export { CallHierarchyPanel } from './CallHierarchyPanel.js';
 export { SymbolPicker } from './SymbolPicker.js';
 export { CodeAuthorsCard } from './CodeAuthorsCard.js';
+export { RenderedDocs } from './RenderedDocs.js';
+export { RenderedDocsFeature } from './rendered-docs.js';
+export { parseDocComment, sectionsOf, htmlToMarkdown, DOC_LINK_PREFIX } from './doc-comment-model.js';
 export { EditorContextMenu } from './EditorContextMenu.js';
 export { EditorRenderingProvider } from './rendering.js';
 export { FindReplace } from './FindReplace.js';
 export { ChangeReview } from './ChangeReview.js';
 export { ProjectProblems, countsOf, compareRows } from './project-problems.js';
-export { applyWorkspaceEdit } from './workspace-edit.js';
+export { applyWorkspaceEdit, supportedResourceOperations } from './workspace-edit.js';
 export { useProblemCounts } from './use-problem-counts.js';
 export { RowHost, LineActionHost } from './row-host.js';
 export { HighlightLayers, highlightLayers } from './highlight-layers.js';
@@ -26,3 +31,6 @@ export { openingPlace, viewStates, followViewStates, viewStateKey, forgetMovesFr
 export { lspLanguageIdOf, shikiLanguageOf, shikiLanguageOfPath } from './language-ids.js';
 export { AttributionCard } from './AttributionCard.js';
 export { ReviewGroup, joinReviewGroup } from './review-group.js';
+export { DiffView } from './DiffView.js';
+export { diffSyntaxDocument } from './diff-syntax.js';
+export { decoratePatch, usePatchDecorations } from './patch-decorations.js';

package/dist/inlay-hints.d.ts

@@ -1,13 +1,58 @@
-import type { EditorInlayHint, EditorPosition, EditorRange } from '@adecore/editor';
-import type { InlayHint } from '@adecore/lsp';
+import type { Editor, EditorInlayClick, EditorInlayHint, EditorPosition, EditorRange } from '@adecore/editor';
+import type { Command, InlayHint, InlayHintLabelPart, Location, MarkupContent, TextEdit } from '@adecore/lsp';
 import type { EditorLanguage } from './editor-language.ts';
+import { type HoverText } from './hover-content.ts';
 import { type Timers } from './timers.ts';
 export declare function hintLabelOf(hint: InlayHint): string;
+export declare function drawableHints(hints: readonly InlayHint[]): InlayHint[];
+export declare function editorHintOf(hint: InlayHint, id: string): EditorInlayHint;
 export declare function editorHintsOf(hints: readonly InlayHint[]): EditorInlayHint[];
 export declare function withMargin(visible: EditorRange, endOfDocument: EditorPosition, endOfLine: (line: number) => EditorPosition): EditorRange;
 export declare function covers(asked: EditorRange, visible: EditorRange): boolean;
+export declare function tooltipTextOf(tooltip: string | MarkupContent | undefined): HoverText | null;
+export declare function partOf(hint: InlayHint, index: number | null): InlayHintLabelPart | null;
+export declare function tooltipOf(hint: InlayHint, index: number | null): HoverText | null;
+export declare function lacksInfo(hint: InlayHint, index: number | null): boolean;
+export declare function editsFit(editor: Editor, edits: readonly TextEdit[]): boolean;
+type Action = {
+    readonly kind: 'go';
+    readonly location: Location;
+} | {
+    readonly kind: 'run';
+    readonly command: Command;
+} | {
+    readonly kind: 'insert';
+    readonly edits: TextEdit[];
+};
+export declare function actionOf(hint: InlayHint, click: Pick<EditorInlayClick, 'part' | 'mod' | 'clicks'>): Action | null;
 export declare class InlayHintsFeature {
+    private readonly language;
+    private readonly timers;
     private readonly refresher;
     private asked;
+    private readonly entries;
+    private shown;
+    private generation;
+    private epoch;
+    private target;
+    private modHeld;
+    private showTimer;
+    private commandTimer;
+    private pressCount;
+    private request;
     constructor(language: EditorLanguage, timers?: Timers);
+    setModHeld(held: boolean): void;
+    showTooltipAt(position: EditorPosition): Promise<boolean>;
+    private install;
+    private hovered;
+    private cancelHover;
+    private cardOpen;
+    private showTooltip;
+    private resolve;
+    private resolvable;
+    private updateLink;
+    private pressed;
+    private press;
+    private perform;
 }
+export {};

package/dist/inlay-hints.js

@@ -1,20 +1,41 @@
+import { hoverTextOf, isEmptyHover } from './hover-content.js';
+import { SHOW_DELAY_MS } from './hover.js';
+import { messageOf } from './error-message.js';
 import { lineTextOf } from './line-text.js';
 import { Refresher } from './refresher.js';
 import { realTimers } from './timers.js';
 const METHOD = 'textDocument/inlayHint';
+const RESOLVE_METHOD = 'inlayHint/resolve';
+const TOAST_ID = 'language-inlay-hint';
 const PAUSE_MS = 300;
+/* How long a click on a hint that a double click would also act on waits for its second press; the editor's own interval for a double press. */
+const DOUBLE_PRESS_MS = 500;
 /* Lines asked for above and below what is in view, so a little scrolling stays inside what is already drawn. */
 const MARGIN_LINES = 60;
 /* A hint's label is a string or a list of parts, which are read as one text. */
 export function hintLabelOf(hint) {
     return typeof hint.label === 'string' ? hint.label : hint.label.map((part) => part.value).join('');
 }
-export function editorHintsOf(hints) {
+/* The hints worth drawing, in the order of the text. */
+export function drawableHints(hints) {
     return hints
-        .map((hint) => ({ position: hint.position, label: hintLabelOf(hint) }))
-        .filter((hint) => hint.label !== '')
+        .filter((hint) => hintLabelOf(hint) !== '')
         .sort((left, right) => left.position.line - right.position.line || left.position.character - right.position.character);
 }
+/* A hint as the editor draws it: a label with parts keeps them apart so each can be pointed at. */
+export function editorHintOf(hint, id) {
+    return {
+        id,
+        position: hint.position,
+        label: hintLabelOf(hint),
+        ...(typeof hint.label === 'string' ? {} : { parts: hint.label.map((part) => part.value) }),
+        ...(hint.paddingLeft ? { paddingLeft: true } : {}),
+        ...(hint.paddingRight ? { paddingRight: true } : {})
+    };
+}
+export function editorHintsOf(hints) {
+    return drawableHints(hints).map((hint, index) => editorHintOf(hint, `hint-${index}`));
+}
 /* The lines in view with a margin of lines around them, from the start of the first to the end of the last. */
 export function withMargin(visible, endOfDocument, endOfLine) {
     const first = Math.max(0, visible.start.line - MARGIN_LINES);
@@ -25,16 +46,102 @@ export function withMargin(visible, endOfDocument, endOfLine) {
 export function covers(asked, visible) {
     return asked.start.line <= visible.start.line && asked.end.line >= visible.end.line;
 }
+/* The words of a tooltip: plain text is escaped so it reads as typed, Markdown goes through the hover card's own rendering. */
+export function tooltipTextOf(tooltip) {
+    if (tooltip === undefined) {
+        return null;
+    }
+    const text = hoverTextOf({ contents: typeof tooltip === 'string' ? { kind: 'plaintext', value: tooltip } : tooltip });
+    return isEmptyHover(text) ? null : text;
+}
+/* One part of a hint's label, or null for a hint whose label is a string. */
+export function partOf(hint, index) {
+    return index === null || typeof hint.label === 'string' ? null : (hint.label[index] ?? null);
+}
+/* What a hover shows: the part's tooltip, else the hint's, else (with no part to point at) that of the first part that has one. */
+export function tooltipOf(hint, index) {
+    const part = partOf(hint, index);
+    const own = part?.tooltip ?? hint.tooltip;
+    if (own !== undefined || index !== null || typeof hint.label === 'string') {
+        return tooltipTextOf(own);
+    }
+    return tooltipTextOf(hint.label.find((candidate) => candidate.tooltip !== undefined)?.tooltip);
+}
+/* Whether a server could still say more about the hint: nothing in it gives a tooltip, a place or a command yet. */
+export function lacksInfo(hint, index) {
+    if (hint.tooltip !== undefined) {
+        return false;
+    }
+    const parts = typeof hint.label === 'string' ? [] : index === null ? hint.label : [hint.label[index]];
+    return !parts.some((part) => part !== undefined && (part.tooltip !== undefined || part.location !== undefined || part.command !== undefined));
+}
+/* Whether the edits fit the text as it is now: positions inside it, each range in order, none overlapping the next. */
+export function editsFit(editor, edits) {
+    const end = editor.positionAt(Number.MAX_SAFE_INTEGER);
+    const inside = (position) => Number.isInteger(position.line) &&
+        Number.isInteger(position.character) &&
+        position.line >= 0 &&
+        position.character >= 0 &&
+        position.line <= end.line &&
+        position.character <= lineTextOf(editor, position.line).length;
+    const before = (left, right) => left.line < right.line || (left.line === right.line && left.character <= right.character);
+    const ordered = [...edits].sort((left, right) => (before(left.range.start, right.range.start) ? -1 : 1));
+    return ordered.every((edit, index) => {
+        const next = ordered[index + 1];
+        return (inside(edit.range.start) &&
+            inside(edit.range.end) &&
+            before(edit.range.start, edit.range.end) &&
+            (next === undefined || before(edit.range.end, next.range.start)));
+    });
+}
+/* What a press does, from what is known of the hint: a double click inserts it and nothing else, Mod+click follows a part's place, a plain click runs its command. */
+export function actionOf(hint, click) {
+    if (click.clicks === 2) {
+        return hint.textEdits !== undefined && hint.textEdits.length > 0 ? { kind: 'insert', edits: hint.textEdits } : null;
+    }
+    const part = partOf(hint, click.part);
+    if (click.mod) {
+        return part?.location === undefined ? null : { kind: 'go', location: part.location };
+    }
+    return part?.command === undefined ? null : { kind: 'run', command: part.command };
+}
 /*
  * Types and parameter names the servers infer, asked for the lines in view and a margin around them. The
  * last ones stay until the answer comes, so nothing blinks while typing; scrolling asks again only once the
  * view leaves the lines that were asked for.
+ *
+ * A hint can be acted on with the pointer. The server is asked to resolve a hint as the pointer arrives, and
+ * resting on it for the hover delay shows its tooltip. Mod+click on a part follows its place, a click on a
+ * part runs its command and a double click inserts its text edits as one undo step, never together with the
+ * command: when a hint has both, the command waits for the double press interval. A press on a hint that
+ * offers nothing (yet) moves the caret as beside the text. A finger has no hover, so a tap shows the
+ * tooltip and does nothing more. All of it is for the pointer: the hints are not part
+ * of the text and stay out of the keyboard's way, and Quick Info on the caret shows the tooltip of a hint that
+ * sits there.
  */
 export class InlayHintsFeature {
+    language;
+    timers;
     refresher;
     /* The lines the hints on screen were asked for. */
     asked = null;
+    entries = new Map();
+    shown = [];
+    generation = 0;
+    /* Counts the edits of the text, which hints and answers made for an earlier one are tested against. */
+    epoch = 0;
+    target = null;
+    modHeld = false;
+    showTimer;
+    /* The command of a click that may still become a double click. */
+    commandTimer;
+    /* Counts presses, so one that waited for a resolve gives way to a later one. */
+    pressCount = 0;
+    /* Counts what the pointer does, so a tooltip that was waited for is dropped once the pointer has moved on. */
+    request = 0;
     constructor(language, timers = realTimers) {
+        this.language = language;
+        this.timers = timers;
         const { editor, project, uri } = language;
         this.refresher = new Refresher(async (signal) => {
             const { service } = project;
@@ -46,26 +153,256 @@ export class InlayHintsFeature {
                 character: lineTextOf(editor, line).length
             }));
             this.asked = range;
+            const epoch = this.epoch;
             const hints = await service.inlayHints(uri, range, { signal });
-            if (!signal.aborted) {
-                editor.setInlayHints(hints === null ? [] : editorHintsOf(hints));
+            if (!signal.aborted && epoch === this.epoch) {
+                this.install(hints === null ? [] : drawableHints(hints), epoch);
             }
         }, PAUSE_MS, timers);
-        const edits = editor.onTextChange(() => this.refresher.later());
-        const scrolls = editor.onViewChange(() => {
-            if (this.asked !== null && !covers(this.asked, editor.getVisibleRange())) {
+        const offs = [
+            editor.onTextChange(() => {
+                this.epoch++;
+                this.cancelHover();
                 this.refresher.later();
-            }
-        });
-        const providers = language.onProvidersChanged(() => {
-            this.refresher.now();
-        });
+            }),
+            editor.onViewChange(() => {
+                if (this.asked !== null && !covers(this.asked, editor.getVisibleRange())) {
+                    this.refresher.later();
+                }
+            }),
+            language.onProvidersChanged(() => {
+                this.refresher.now();
+            })
+        ];
+        if (editor.onInlayHover !== undefined) {
+            offs.push(editor.onInlayHover((target) => this.hovered(target === null ? null : { id: target.id, part: target.part })));
+        }
+        if (editor.onInlayClick !== undefined) {
+            offs.push(editor.onInlayClick((click) => this.pressed(click)));
+        }
+        if (typeof window !== 'undefined') {
+            const modKey = language.apple ? 'Meta' : 'Control';
+            const keys = (event) => {
+                if (event.key === modKey) {
+                    this.setModHeld(event.type === 'keydown');
+                }
+            };
+            const lost = () => this.setModHeld(false);
+            window.addEventListener('keydown', keys);
+            window.addEventListener('keyup', keys);
+            window.addEventListener('blur', lost);
+            offs.push(() => {
+                window.removeEventListener('keydown', keys);
+                window.removeEventListener('keyup', keys);
+                window.removeEventListener('blur', lost);
+            });
+        }
         language.onDispose(() => {
-            edits();
-            scrolls();
-            providers();
+            for (const off of offs) {
+                off();
+            }
+            this.cancelHover();
+            this.timers.clear(this.commandTimer);
             this.refresher.dispose();
+            this.entries.clear();
             editor.setInlayHints([]);
         });
     }
+    /* The key that follows a place is down or up; it comes from the window, as the editor only says where the pointer is. */
+    setModHeld(held) {
+        if (held !== this.modHeld) {
+            this.modHeld = held;
+            this.updateLink();
+        }
+    }
+    /* The tooltip of a hint that sits at a position, as a card; false when there is none. This is how the keyboard reaches it. */
+    async showTooltipAt(position) {
+        const found = [...this.entries].find(([, entry]) => entry.epoch === this.epoch && sameSpot(entry.hint.position, position));
+        if (found === undefined) {
+            return false;
+        }
+        return this.showTooltip({ id: found[0], part: null }, this.request, false);
+    }
+    install(hints, epoch) {
+        this.generation++;
+        this.entries.clear();
+        this.shown = hints.map((hint, index) => {
+            const id = `hint-${this.generation}-${index}`;
+            this.entries.set(id, { id, hint, epoch, resolution: null, answered: false });
+            return editorHintOf(hint, id);
+        });
+        this.language.editor.setInlayHints(this.shown);
+        this.target = null;
+        this.updateLink();
+    }
+    hovered(target) {
+        this.target = target;
+        this.timers.clear(this.showTimer);
+        const request = ++this.request;
+        this.updateLink();
+        if (target === null) {
+            if (this.cardOpen()) {
+                this.language.hover.release();
+            }
+            return;
+        }
+        this.showTimer = this.timers.set(() => void this.showTooltip(target, request), SHOW_DELAY_MS);
+        // A press has to know what the hint offers when it comes, so the answer is asked for as the pointer arrives.
+        const entry = this.entries.get(target.id);
+        if (entry !== undefined && this.resolvable(entry)) {
+            void this.resolve(entry).then(() => this.updateLink());
+        }
+    }
+    cancelHover() {
+        this.timers.clear(this.showTimer);
+        this.request++;
+        this.target = null;
+        this.updateLink();
+        if (this.cardOpen()) {
+            this.language.hover.hide();
+        }
+    }
+    /* Whether the card up is a tooltip, which is the only kind that has no footer. */
+    cardOpen() {
+        return this.language.popups.getState().hover?.info?.plain === true;
+    }
+    /* The card for a hint or part, once the server has said what it can. Says whether it opened. */
+    async showTooltip(target, request, pointer = true) {
+        const entry = this.entries.get(target.id);
+        if (entry === undefined) {
+            return false;
+        }
+        if (lacksInfo(entry.hint, target.part)) {
+            await this.resolve(entry);
+            this.updateLink();
+        }
+        if ((pointer && request !== this.request) || entry.epoch !== this.epoch) {
+            return false;
+        }
+        const text = tooltipOf(entry.hint, target.part);
+        if (text === null) {
+            if (this.cardOpen()) {
+                this.language.hover.hide();
+            }
+            return false;
+        }
+        this.language.hover.showText(entry.hint.position, text);
+        return true;
+    }
+    /* Asks the server for more of a hint, once; what it says is kept only while the text is the one the hint was made for. */
+    resolve(entry) {
+        if (entry.resolution !== null) {
+            return entry.resolution;
+        }
+        const { service } = this.language.project;
+        if (entry.epoch !== this.epoch || !service.supports(RESOLVE_METHOD, this.language.uri)) {
+            return Promise.resolve(entry.hint);
+        }
+        entry.resolution = service
+            .resolveInlayHint(this.language.uri, entry.hint)
+            .then((resolved) => {
+            if (entry.epoch === this.epoch) {
+                entry.hint = { ...entry.hint, ...resolved, position: entry.hint.position };
+            }
+            return entry.hint;
+        })
+            .catch(() => entry.hint)
+            .finally(() => {
+            entry.answered = true;
+        });
+        return entry.resolution;
+    }
+    /* Whether asking the server could still change what the hint offers. */
+    resolvable(entry) {
+        return !entry.answered && entry.epoch === this.epoch && this.language.project.service.supports(RESOLVE_METHOD, this.language.uri);
+    }
+    /* Underlines the part under the pointer when a press would do something with it: a command always, a place while the key is down. */
+    updateLink() {
+        const { target } = this;
+        const entry = target === null ? undefined : this.entries.get(target.id);
+        const part = entry === undefined || target === null || entry.epoch !== this.epoch ? null : partOf(entry.hint, target.part);
+        const link = part !== null && (part.command !== undefined || (this.modHeld && part.location !== undefined));
+        this.language.editor.setInlayLink?.(link ? target : null);
+    }
+    pressed(click) {
+        const entry = this.entries.get(click.id);
+        if (entry === undefined || entry.epoch !== this.epoch) {
+            return false;
+        }
+        if (click.touch) {
+            this.timers.clear(this.showTimer);
+            const request = ++this.request;
+            const worth = tooltipOf(entry.hint, click.part) !== null || this.resolvable(entry);
+            if (worth) {
+                void this.showTooltip({ id: click.id, part: click.part }, request);
+            }
+            return worth;
+        }
+        if (click.alt || click.shift) {
+            return false;
+        }
+        this.timers.clear(this.commandTimer);
+        const press = ++this.pressCount;
+        if (this.resolvable(entry) && (click.clicks === 2 || actionOf(entry.hint, click) !== null)) {
+            // The server may still add edits, which would make this the first press of a double click.
+            void this.resolve(entry).then(() => {
+                if (press === this.pressCount) {
+                    this.press(entry, click);
+                }
+            });
+            return true;
+        }
+        return this.press(entry, click);
+    }
+    press(entry, click) {
+        this.timers.clear(this.commandTimer);
+        const action = actionOf(entry.hint, click);
+        const insertable = entry.hint.textEdits !== undefined && entry.hint.textEdits.length > 0;
+        if (action?.kind === 'run' && insertable) {
+            // A double click inserts the edits, so the command of its first press waits to see whether a second one comes.
+            const epoch = this.epoch;
+            this.commandTimer = this.timers.set(() => {
+                if (epoch === this.epoch) {
+                    void this.perform(entry, action);
+                }
+            }, DOUBLE_PRESS_MS);
+            return true;
+        }
+        if (action !== null) {
+            void this.perform(entry, action);
+            return true;
+        }
+        // The first press of a double click must not move the caret either, or the second would land beside the hint.
+        return click.clicks === 1 && !click.mod && insertable;
+    }
+    async perform(entry, action) {
+        const { editor, project, uri } = this.language;
+        try {
+            if (action.kind === 'go') {
+                this.cancelHover();
+                this.language.goTo(action.location);
+            }
+            else if (action.kind === 'run') {
+                await project.service.executeCommand(uri, action.command);
+            }
+            else if (entry.epoch === this.epoch && editsFit(editor, action.edits)) {
+                this.cancelHover();
+                const applied = editor.applyEdits(action.edits.map((edit) => ({ range: edit.range, text: edit.newText })));
+                if (applied) {
+                    this.shown = this.shown.filter((hint) => hint.id !== entry.id);
+                    editor.setInlayHints(this.shown);
+                }
+            }
+        }
+        catch (error) {
+            this.language.project.host.notify?.({
+                id: TOAST_ID,
+                kind: 'error',
+                title: project.i18n.t('editor:language.inlay.failed', { message: messageOf(error) })
+            });
+        }
+    }
+}
+function sameSpot(left, right) {
+    return left.line === right.line && left.character === right.character;
 }