@adecore/editor-react 0.39.0 → 0.40.1

package/src/inlay-hints.ts

@@ -1,5 +1,7 @@
 import type { Editor, EditorInlayClick, EditorInlayHint, EditorPosition, EditorRange } from '@adecore/editor';
 import type { Command, InlayHint, InlayHintLabelPart, Location, MarkupContent, TextEdit } from '@adecore/lsp';
+import { followModKey } from './definition-link.ts';
+import { comparePositions } from './diagnostics-model.ts';
 import type { EditorLanguage } from './editor-language.ts';
 import { hoverTextOf, isEmptyHover, type HoverText } from './hover-content.ts';
 import { SHOW_DELAY_MS } from './hover.ts';
@@ -12,21 +14,19 @@ 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: InlayHint): string {
     return typeof hint.label === 'string' ? hint.label : hint.label.map((part) => part.value).join('');
 }
 
-/* The hints worth drawing, in the order of the text. */
 export function drawableHints(hints: readonly InlayHint[]): InlayHint[] {
-    return hints
-        .filter((hint) => hintLabelOf(hint) !== '')
-        .sort((left, right) => left.position.line - right.position.line || left.position.character - right.position.character);
+    return hints.filter((hint) => hintLabelOf(hint) !== '').sort((left, right) => comparePositions(left.position, right.position));
 }
 
 /* A hint as the editor draws it: a label with parts keeps them apart so each can be pointed at. */
@@ -41,18 +41,13 @@ export function editorHintOf(hint: InlayHint, id: string): EditorInlayHint {
     };
 }
 
-export function editorHintsOf(hints: readonly InlayHint[]): EditorInlayHint[] {
-    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: EditorRange, endOfDocument: EditorPosition, endOfLine: (line: number) => EditorPosition): EditorRange {
     const first = Math.max(0, visible.start.line - MARGIN_LINES);
     const last = Math.min(endOfDocument.line, visible.end.line + MARGIN_LINES);
+
     return { start: { line: first, character: 0 }, end: last === endOfDocument.line ? endOfDocument : endOfLine(last) };
 }
 
-/* Whether what was asked for already holds every line in view. */
 export function covers(asked: EditorRange, visible: EditorRange): boolean {
     return asked.start.line <= visible.start.line && asked.end.line >= visible.end.line;
 }
@@ -62,11 +57,12 @@ export function tooltipTextOf(tooltip: string | MarkupContent | undefined): Hove
     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: InlayHint, index: number | null): InlayHintLabelPart | null {
     return index === null || typeof hint.label === 'string' ? null : (hint.label[index] ?? null);
 }
@@ -75,9 +71,11 @@ export function partOf(hint: InlayHint, index: number | null): InlayHintLabelPar
 export function tooltipOf(hint: InlayHint, index: number | null): HoverText | null {
     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);
 }
 
@@ -86,13 +84,16 @@ export function lacksInfo(hint: InlayHint, index: number | null): boolean {
     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: Editor, edits: readonly TextEdit[]): boolean {
     const end = editor.positionAt(Number.MAX_SAFE_INTEGER);
+
     const inside = (position: EditorPosition): boolean =>
         Number.isInteger(position.line) &&
         Number.isInteger(position.character) &&
@@ -100,11 +101,14 @@ export function editsFit(editor: Editor, edits: readonly TextEdit[]): boolean {
         position.character >= 0 &&
         position.line <= end.line &&
         position.character <= lineTextOf(editor, position.line).length;
-    const before = (left: EditorPosition, right: EditorPosition): boolean =>
-        left.line < right.line || (left.line === right.line && left.character <= right.character);
+
+    const before = (left: EditorPosition, right: EditorPosition): boolean => comparePositions(left, right) <= 0;
+
     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) &&
@@ -124,14 +128,16 @@ export function actionOf(hint: InlayHint, click: Pick<EditorInlayClick, 'part' |
     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 };
 }
 
-/* A hint on screen and what has become known of it. */
 interface Entry {
     readonly id: string;
     hint: InlayHint;
@@ -144,36 +150,38 @@ interface Entry {
 
 /*
  * 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.
+ * last ones stay until the answer comes, so nothing blinks while typing.
  *
- * 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.
+ * Mod+click on a part follows its place, a click runs its command and a double click inserts its text edits
+ * as one undo step, never together with the command. A press on a hint that offers nothing (yet) moves the
+ * caret; a tap only shows the tooltip. The hints stay out of the keyboard's way: Quick Info on the caret
+ * shows the tooltip of a hint that sits there.
  */
 export class InlayHintsFeature {
     private readonly language: EditorLanguage;
     private readonly timers: Timers;
     private readonly refresher: Refresher;
+
     /* The lines the hints on screen were asked for. */
     private asked: EditorRange | null = null;
+
     private readonly entries = new Map<string, Entry>();
     private shown: EditorInlayHint[] = [];
     private generation = 0;
+
     /* Counts the edits of the text, which hints and answers made for an earlier one are tested against. */
     private epoch = 0;
+
     private target: { id: string; part: number | null } | null = null;
     private modHeld = false;
     private showTimer: unknown;
+
     /* The command of a click that may still become a double click. */
     private commandTimer: unknown;
+
     /* Counts presses, so one that waited for a resolve gives way to a later one. */
     private pressCount = 0;
+
     /* Counts what the pointer does, so a tooltip that was waited for is dropped once the pointer has moved on. */
     private request = 0;
 
@@ -181,19 +189,24 @@ export class InlayHintsFeature {
         this.language = language;
         this.timers = timers;
         const { editor, project, uri } = language;
+
         this.refresher = new Refresher(
             async (signal) => {
                 const { service } = project;
+
                 if (!service.supports(METHOD, uri)) {
                     return;
                 }
+
                 const range = withMargin(editor.getVisibleRange(), editor.positionAt(Number.MAX_SAFE_INTEGER), (line) => ({
                     line,
                     character: lineTextOf(editor, line).length
                 }));
+
                 this.asked = range;
                 const epoch = this.epoch;
                 const hints = await service.inlayHints(uri, range, { signal });
+
                 if (!signal.aborted && epoch === this.epoch) {
                     this.install(hints === null ? [] : drawableHints(hints), epoch);
                 }
@@ -201,6 +214,7 @@ export class InlayHintsFeature {
             PAUSE_MS,
             timers
         );
+
         const offs = [
             editor.onTextChange(() => {
                 this.epoch++;
@@ -216,33 +230,22 @@ export class InlayHintsFeature {
                 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: KeyboardEvent): void => {
-                if (event.key === modKey) {
-                    this.setModHeld(event.type === 'keydown');
-                }
-            };
-            const lost = (): void => 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);
-            });
-        }
+
+        offs.push(followModKey(language.apple, (held) => this.setModHeld(held)));
+
         language.onDispose(() => {
             for (const off of offs) {
                 off();
             }
+
             this.cancelHover();
             this.timers.clear(this.commandTimer);
             this.refresher.dispose();
@@ -261,21 +264,26 @@ export class InlayHintsFeature {
 
     /* 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: EditorPosition): Promise<boolean> {
-        const found = [...this.entries].find(([, entry]) => entry.epoch === this.epoch && sameSpot(entry.hint.position, position));
+        const found = [...this.entries].find(([, entry]) => entry.epoch === this.epoch && comparePositions(entry.hint.position, position) === 0);
+
         if (found === undefined) {
             return false;
         }
+
         return this.showTooltip({ id: found[0], part: null }, this.request, false);
     }
 
     private install(hints: readonly InlayHint[], epoch: number): void {
         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();
@@ -286,15 +294,19 @@ export class InlayHintsFeature {
         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());
         }
@@ -305,6 +317,7 @@ export class InlayHintsFeature {
         this.request++;
         this.target = null;
         this.updateLink();
+
         if (this.cardOpen()) {
             this.language.hover.hide();
         }
@@ -318,24 +331,32 @@ export class InlayHintsFeature {
     /* The card for a hint or part, once the server has said what it can. Says whether it opened. */
     private async showTooltip(target: { id: string; part: number | null }, request: number, pointer = true): Promise<boolean> {
         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;
     }
 
@@ -344,22 +365,27 @@ export class InlayHintsFeature {
         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;
     }
 
@@ -379,23 +405,30 @@ export class InlayHintsFeature {
 
     private pressed(click: EditorInlayClick): boolean {
         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(() => {
@@ -403,8 +436,10 @@ export class InlayHintsFeature {
                     this.press(entry, click);
                 }
             });
+
             return true;
         }
+
         return this.press(entry, click);
     }
 
@@ -412,26 +447,33 @@ export class InlayHintsFeature {
         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;
     }
 
     private async perform(entry: Entry, action: Action): Promise<void> {
         const { editor, project, uri } = this.language;
+
         try {
             if (action.kind === 'go') {
                 this.cancelHover();
@@ -441,6 +483,7 @@ export class InlayHintsFeature {
             } 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);
@@ -455,7 +498,3 @@ export class InlayHintsFeature {
         }
     }
 }
-
-function sameSpot(left: EditorPosition, right: EditorPosition): boolean {
-    return left.line === right.line && left.character === right.character;
-}

package/src/key-priority.ts

@@ -35,8 +35,10 @@ export class KeyDispatcher {
         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);
             }

package/src/line-edits.ts

@@ -19,16 +19,21 @@ export function replaceLines(text: string, replacement: LineReplacement): Editor
     const raw = text.split('\n');
     const count = splitLines(text).length;
     const body = lines.join(eol);
+
     if (to < count || text === '' || text.endsWith('\n')) {
         return { range: { start: { line: from, character: 0 }, end: { line: to, character: 0 } }, text: lines.length === 0 ? '' : `${body}${eol}` };
     }
+
     const end = { line: count - 1, character: raw[count - 1]!.length };
+
     if (from === count) {
         return { range: { start: end, end }, text: lines.length === 0 ? '' : `${eol}${body}` };
     }
+
     if (lines.length === 0 && from > 0) {
         return { range: { start: { line: from - 1, character: raw[from - 1]!.length }, end }, text: '' };
     }
+
     return { range: { start: { line: from, character: 0 }, end }, text: body };
 }
 
@@ -36,13 +41,16 @@ export function replaceLines(text: string, replacement: LineReplacement): Editor
 export function replaceAllLines(text: string, replacements: readonly LineReplacement[]): EditorContentChange[] {
     const ordered = [...replacements].sort((left, right) => left.from - right.from);
     const merged: LineReplacement[] = [];
+
     for (const next of ordered) {
         const last = merged.at(-1);
+
         if (last !== undefined && last.to >= next.from) {
             merged[merged.length - 1] = { from: last.from, to: Math.max(last.to, next.to), lines: [...last.lines, ...next.lines] };
         } else {
             merged.push(next);
         }
     }
+
     return merged.map((replacement) => replaceLines(text, replacement));
 }

package/src/models.ts

@@ -12,6 +12,7 @@ export { type ActionGroup, type ActionEntry, type EditPreview } from './code-act
 export { type ResourceOperationView } from './workspace-edit.ts';
 export { type CodeVisionDeclaration, type DeclarationSource } from './code-vision-model.ts';
 export { type CodeAuthor, type CodeAuthorship } from './code-authors.ts';
+
 export {
     type SnippetTransform,
     type SnippetStop,
@@ -24,6 +25,7 @@ export {
     parseSnippet,
     tabOrder
 } from './snippet.ts';
+
 export {
     type LineSpan,
     lineSpanOf,
@@ -40,8 +42,10 @@ export {
     replaceRange,
     locateSelection
 } from './proposal-model.ts';
+
 export { type LineReplacement, replaceLines, replaceAllLines } from './line-edits.ts';
 export { replacedWords } from './word-diff.ts';
+
 export {
     type FindOptions,
     type FindQuery,
@@ -53,8 +57,10 @@ export {
     matchesIn,
     stepIndex
 } from './find-query.ts';
+
 export { type PopupSize, type PopupPlacement, type PlaceOptions } from './popup-placement.ts';
 export { planConflict, type ConflictStretch, type ConflictPlan } from './conflict-model.ts';
+
 export {
     patchLayoutOf,
     type PatchLayout,

package/src/navigation-history.ts

@@ -27,10 +27,12 @@ export class NavigationHistory {
             this.backs[this.backs.length - 1] = from;
         } else {
             this.backs.push(from);
+
             if (this.backs.length > LIMIT) {
                 this.backs.shift();
             }
         }
+
         this.forwards = [];
     }
 
@@ -59,11 +61,14 @@ export class NavigationHistory {
     private walk(from: Place[], to: Place[], current: Place): Place | null {
         while (from.length > 0) {
             const place = from.pop()!;
+
             if (!samePlace(place, current)) {
                 to.push(current);
+
                 return place;
             }
         }
+
         return null;
     }
 }