@adecore/editor-react 0.22.1 → 0.23.1

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;
 }

package/dist/language-ids.js

@@ -16,7 +16,8 @@ const LSP_IDS = {
     python: 'python',
     shellscript: 'shellscript',
     docker: 'dockerfile',
-    twig: 'twig'
+    twig: 'twig',
+    sql: 'sql'
 };
 /* The LSP language id of a file, or null when no language server here knows its language. */
 export function lspLanguageIdOf(language) {
@@ -43,7 +44,8 @@ const PATH_IDS = {
     scss: 'scss',
     html: 'html',
     md: 'markdown',
-    twig: 'twig'
+    twig: 'twig',
+    sql: 'sql'
 };
 /* The highlighter id for the code of a file we only know by its path, such as a place another file refers to. */
 export function shikiLanguageOfPath(path) {

package/dist/locales/en.json

@@ -9,6 +9,9 @@
             "line": "Line {{line}}",
             "none": "No information for this position"
         },
+        "inlay": {
+            "failed": "The hint's action failed: {{message}}"
+        },
         "edit": {
             "staged_one": "{{count}} file changed and not saved yet",
             "staged_other": "{{count}} files changed and not saved yet",
@@ -30,6 +33,10 @@
             "otherFiles_other": "and {{count}} other files",
             "moves_one": "moves {{count}} file",
             "moves_other": "moves {{count}} files",
+            "creates_one": "creates {{count}} file",
+            "creates_other": "creates {{count}} files",
+            "deletes_one": "deletes {{count}} file",
+            "deletes_other": "deletes {{count}} files",
             "groups": {
                 "quickfix": "Quick fix",
                 "rewrite": "Rewrite",
@@ -56,7 +63,12 @@
             "cancel": "Cancel",
             "apply": "Rename",
             "suggestions": "Suggested names",
-            "useSuggestion": "Use suggestion"
+            "useSuggestion": "Use suggestion",
+            "operations": {
+                "create": "Creates",
+                "rename": "Moves",
+                "delete": "Deletes"
+            }
         },
         "navigation": {
             "unavailable": "No language server answers that here",
@@ -70,6 +82,9 @@
                 "symbol": "Matches"
             }
         },
+        "panel": {
+            "resize": "Resize panel"
+        },
         "peek": {
             "unavailable": "No language server finds references in this file",
             "none": "No references found",
@@ -84,6 +99,33 @@
             "noDefinition": "No definition found",
             "unavailableDefinition": "No language server finds definitions in this file"
         },
+        "callHierarchy": {
+            "unavailable": "No language server finds calls in this file",
+            "none": "No symbol with calls found here",
+            "failed": "Could not look up the calls: {{message}}",
+            "label": "Call hierarchy",
+            "direction": "Direction",
+            "incoming": "Callers",
+            "outgoing": "Callees",
+            "close": "Close",
+            "loading": "Loading…",
+            "noIncoming": "No callers",
+            "noOutgoing": "No callees",
+            "retry": "Could not load the calls: {{message}}. Press to try again",
+            "more_one": "Show {{formatted}} more call ({{hidden}} left)",
+            "more_other": "Show {{formatted}} more calls ({{hidden}} left)",
+            "sites_one": "{{formatted}} call",
+            "sites_other": "{{formatted}} calls",
+            "site": "Call {{current}} of {{total}}",
+            "previousSite": "Previous call",
+            "nextSite": "Next call",
+            "announce": {
+                "incoming_one": "{{count}} caller of {{name}}",
+                "incoming_other": "{{count}} callers of {{name}}",
+                "outgoing_one": "{{count}} callee of {{name}}",
+                "outgoing_other": "{{count}} callees of {{name}}"
+            }
+        },
         "codeVision": {
             "usagesNone": "No usages",
             "usages_one": "{{formatted}} usage",
@@ -126,20 +168,65 @@
             "copy": "Copy",
             "paste": "Paste"
         },
+        "snippet": {
+            "choices": "Snippet choice"
+        },
         "completion": {
+            "tooLarge": "Completion is too large to insert",
             "insert": "Insert",
             "replace": "Replace",
             "details": "Details",
-            "none": "No suggestions"
+            "none": "No suggestions",
+            "transformBusy": "Snippet transforms are busy; try again",
+            "transformFailed": "Snippet transform could not be applied"
         },
         "history": {
             "recent": "Recent locations"
+        },
+        "announce": {
+            "problem": "{{severity}}: {{message}}",
+            "severity": {
+                "error": "Error",
+                "warning": "Warning",
+                "info": "Information",
+                "hint": "Hint"
+            },
+            "field": "Field {{current}} of {{total}}",
+            "fieldChoices_one": "Field {{current}} of {{total}}, {{count}} choice",
+            "fieldChoices_other": "Field {{current}} of {{total}}, {{count}} choices"
+        },
+        "fold": {
+            "fold": "Fold lines {{start}} to {{end}}",
+            "unfold": "Unfold lines {{start}} to {{end}}"
+        },
+        "docs": {
+            "label": "Rendered documentation",
+            "labelNamed": "Rendered documentation: {{- summary}}",
+            "render": "Show rendered documentation",
+            "showSource": "Show documentation source",
+            "tags": {
+                "deprecated": "Deprecated",
+                "template": "Type parameters",
+                "param": "Parameters",
+                "property": "Properties",
+                "type": "Type",
+                "var": "Variable",
+                "return": "Returns",
+                "yield": "Yields",
+                "throws": "Throws",
+                "see": "See also",
+                "example": "Example",
+                "since": "Since",
+                "version": "Version",
+                "author": "Author"
+            }
         }
     },
     "commands": {
         "goToDefinition": "Go to definition",
         "goToTypeDefinition": "Go to type definition",
         "goToImplementation": "Go to implementation",
+        "callHierarchy": "Call hierarchy",
         "peekReferences": "Peek references",
         "renameSymbol": "Rename symbol",
         "codeActions": "Code actions",
@@ -148,6 +235,7 @@
     "find": {
         "label": "Find",
         "count": "{{current}} / {{total}}",
+        "countLimited": "{{current}} / {{total}}+",
         "none": "No results",
         "invalid": "Invalid regular expression",
         "caseSensitive": "Match case",
@@ -166,7 +254,33 @@
             "allLabel": "Replace all",
             "preserveCase": "Preserve case",
             "toggle": "Show replace",
-            "hide": "Hide replace"
+            "hide": "Hide replace",
+            "failed": {
+                "limit": "Too much to replace at once ({{edits}} edits or {{characters}} output characters)",
+                "timeout": "Replacement timed out; the text was not changed",
+                "unavailable": "Replacement needs the search worker",
+                "error": "Could not replace; the text was not changed"
+            }
+        },
+        "countMore": "{{total}}+ matches",
+        "searching": "Searching…",
+        "large": "Large document: press Enter to search",
+        "replaced": "Replaced {{count}} matches",
+        "failed": {
+            "timeout": "Search timed out; press Enter to retry",
+            "unavailable": "Regex search is unavailable",
+            "invalid": "Invalid regular expression",
+            "error": "Could not finish the search"
         }
+    },
+    "diff": {
+        "hidden": "Show {{count}} hidden lines",
+        "contextLimit": "Context limit reached",
+        "oldSide": "Before",
+        "newSide": "After",
+        "noNewline": "No final newline",
+        "added": "Added, new line {{number}}",
+        "removed": "Removed, old line {{number}}",
+        "unchanged": "Old line {{old}}, new line {{new}}"
     }
 }