@adecore/editor-react 0.21.0 → 0.21.2

package/src/HoverSections.tsx

@@ -1,9 +1,9 @@
-import { useEditorRendering } from './rendering-context.ts';
 import { useEffect, useState, type MouseEvent } from 'react';
-import { Markdown } from './Markdown.tsx';
 import { Tooltip } from '@adecore/ui';
-import { hoverSectionsOf, markdownParts, type DocTag, type HoverSection, type HoverText } from './hover-content.ts';
 import { BaselineStatus } from './BaselineStatus.tsx';
+import { hoverSectionsOf, markdownParts, type DocTag, type HoverSection, type HoverText } from './hover-content.ts';
+import { Markdown } from './Markdown.tsx';
+import { useEditorRendering } from './rendering-context.ts';
 import { declaredNameOf, linkTypeNames } from './symbol-links.ts';
 
 /* Code as the viewer colors it, plain until the grammar is in so the card never changes size under the pointer by much. */
@@ -102,10 +102,7 @@ function phpWithoutOpenTag(html: string): string {
     return html.replace(/<span[^>]*>&#x3C;\?<\/span><span[^>]*>php<\/span>(<span[^>]*>) /, '$1');
 }
 
-/*
- * Where a suggestion comes from, such as `use Raxos\Database\Orm\Attribute\PrimaryKey`, on one line that gives
- * way from its start, so the end of the name stays readable and a word is never cut in two. The full text is in the tooltip.
- */
+/* Where a suggestion comes from, such as a PHP `use` line, cut from its start so the end of the name stays readable. */
 export function SourceLine({ text, language }: { text: string; language: string }) {
     const { theme, highlight } = useEditorRendering();
     const [html, setHtml] = useState<{ key: string; html: string } | null>(null);
@@ -113,10 +110,7 @@ export function SourceLine({ text, language }: { text: string; language: string
     const key = `${theme}\0${text}`;
 
     useEffect(() => {
-        if (!highlighted) {
-            return;
-        }
-        if (highlight === undefined) {
+        if (!highlighted || highlight === undefined) {
             return;
         }
         let alive = true;

package/src/PeekPanel.tsx

@@ -1,4 +1,3 @@
-import { useEditorRendering } from './rendering-context.ts';
 import { useEffect, useMemo, useRef, useState } from 'react';
 import { createPortal } from 'react-dom';
 import { useTranslation } from 'react-i18next';
@@ -6,13 +5,14 @@ import { ChevronDown, ChevronRight, X } from 'lucide-react';
 import { fileUriToPath } from '@adecore/lsp';
 import { FileIcon, IconButton, Tooltip } from '@adecore/ui';
 import { formatNumber } from '@adecore/ui/format';
-import { basenameOf } from './paths.ts';
+import { basenameOf, relativeTo } from './paths.ts';
 import type { EditorLanguage } from './editor-language.ts';
 import { shikiLanguageOfPath } from './language-ids.ts';
 import { PathText } from './PathText.tsx';
 import { PEEK_HEIGHT } from './peek.ts';
 import { distinguishingFolders, visualColumnOf, type NameRange, type PeekPlace } from './peek-model.ts';
 import type { PeekView } from './popups.ts';
+import { useEditorRendering } from './rendering-context.ts';
 
 const TAB_SIZE = 4;
 const CODE =
@@ -28,10 +28,7 @@ function Preview({ view }: { view: PeekView }) {
     const key = preview === null ? '' : `${theme}\0${path}\0${preview.text}`;
 
     useEffect(() => {
-        if (preview === null) {
-            return;
-        }
-        if (highlight === undefined) {
+        if (preview === null || highlight === undefined) {
             return;
         }
         let alive = true;
@@ -98,10 +95,6 @@ function columnsOf(line: string, name: NameRange): NameRange {
     return { start, end: visualColumnOf(line, name.end, TAB_SIZE) };
 }
 
-function relativeTo(path: string, folder: string): string {
-    return path.startsWith(`${folder}/`) ? path.slice(folder.length + 1) : path;
-}
-
 function folderOf(path: string): string {
     return path.slice(0, Math.max(0, path.lastIndexOf('/')));
 }
@@ -177,10 +170,9 @@ function Places({ language, view }: { language: EditorLanguage; view: PeekView }
 }
 
 /*
- * The references of a name drawn in the row the editor leaves under the line: the file of the active
- * reference and where it is, the code around it on the left and every place on the right. It lives in a
- * portal into the editor's own row, which the editor makes again when it scrolls back into view. It has
- * the editor's own ground and no edge of its own, so it reads as part of the file.
+ * The references of a name in the row the editor leaves under the line: the code around the active one on
+ * the left and every place on the right. It portals into that row, which the editor makes again when it
+ * scrolls back into view, and has no edge of its own, so it reads as part of the file.
  */
 export function PeekPanel({ language, view }: { language: EditorLanguage; view: PeekView }) {
     const { t } = useTranslation('editor');

package/src/RenameCard.tsx

@@ -6,7 +6,7 @@ import { fileUriToPath } from '@adecore/lsp';
 import type { EditorRect } from '@adecore/editor';
 import { Button, Icon } from '@adecore/ui';
 import { formatNumber } from '@adecore/ui/format';
-import { basenameOf } from './paths.ts';
+import { basenameOf, relativeTo } from './paths.ts';
 import { AnchoredPopup } from './AnchoredPopup.tsx';
 import type { EditorLanguage } from './editor-language.ts';
 import type { RenameView } from './popups.ts';
@@ -91,7 +91,7 @@ function Preview({ language, view }: { language: EditorLanguage; view: RenameVie
             <div className="max-h-[320px] overflow-y-auto">
                 {view.files.map((file) => {
                     const path = fileUriToPath(file.uri);
-                    const shown = path === null ? file.uri : path.startsWith(`${folder}/`) ? path.slice(folder.length + 1) : path;
+                    const shown = path === null ? file.uri : relativeTo(path, folder);
                     return (
                         <div key={file.uri} className="border-b border-border last:border-b-0">
                             <div className="flex items-center gap-2 px-3 py-1.5 text-xs">

package/src/SymbolPicker.tsx

@@ -2,12 +2,11 @@ import { useEffect, useMemo, useRef, useState, type KeyboardEvent } from 'react'
 import { createPortal } from 'react-dom';
 import { useTranslation } from 'react-i18next';
 import { AtSign, Hash } from 'lucide-react';
-import { Icon } from '@adecore/ui';
-import { formatShortcut } from '@adecore/ui';
-import { formatNumber } from '@adecore/ui/format';
-import { basenameOf } from './paths.ts';
 import { fileUriToPath } from '@adecore/lsp';
+import { formatShortcut, Icon } from '@adecore/ui';
+import { formatNumber } from '@adecore/ui/format';
 import type { EditorLanguage } from './editor-language.ts';
+import { basenameOf } from './paths.ts';
 import type { SymbolsView } from './popups.ts';
 import {
     filterEntries,

package/src/code-actions-model.ts

@@ -17,6 +17,14 @@ export interface ActionEntry {
     readonly group: ActionGroup;
 }
 
+/* Entries in the order of `order`, the preferred actions of each group first. */
+function inGroupOrder(entries: readonly ActionEntry[], order: readonly ActionGroup[]): ActionEntry[] {
+    return order.flatMap((group) => {
+        const own = entries.filter((entry) => entry.group === group);
+        return [...own.filter((entry) => entry.action.isPreferred === true), ...own.filter((entry) => entry.action.isPreferred !== true)];
+    });
+}
+
 /* The kinds nest by dots: `refactor.extract.function` is an extraction and `source.organizeImports` a source action. */
 export function groupOf(kind: string | undefined): ActionGroup {
     if (kind === 'quickfix' || kind?.startsWith('quickfix.')) {
@@ -45,10 +53,7 @@ export function actionsOf(result: readonly (CodeAction | Command)[] | null, orde
         .map((item) => (typeof item.command === 'string' ? ({ title: item.title, command: item as Command } satisfies CodeAction) : (item as CodeAction)))
         .filter((action) => action.disabled === undefined)
         .map((action, index) => ({ id: String(index), action, group: groupOf(action.kind) }));
-    return order.flatMap((group) => {
-        const own = entries.filter((entry) => entry.group === group);
-        return [...own.filter((entry) => entry.action.isPreferred === true), ...own.filter((entry) => entry.action.isPreferred !== true)];
-    });
+    return inGroupOrder(entries, order);
 }
 
 /* Entries from several requests as one list: the same order as a single answer, and an id of its own for each row. Two actions with a title and kind alike are one. */
@@ -62,10 +67,7 @@ export function mergeEntries(lists: readonly (readonly ActionEntry[])[]): Action
         seen.add(key);
         return true;
     });
-    return ACTION_GROUPS.flatMap((group) => {
-        const own = unique.filter((entry) => entry.group === group);
-        return [...own.filter((entry) => entry.action.isPreferred === true), ...own.filter((entry) => entry.action.isPreferred !== true)];
-    }).map((entry, index) => ({ ...entry, id: String(index) }));
+    return inGroupOrder(unique, ACTION_GROUPS).map((entry, index) => ({ ...entry, id: String(index) }));
 }
 
 /* Whether the lightbulb offers it: a source action such as organizing imports is a command of its own and never a hint. */

package/src/code-actions.ts

@@ -18,6 +18,7 @@ import type { PickGroup, PickPreview } from './popups.ts';
 import { Refresher } from './refresher.ts';
 import { isShortcut } from './shortcut-keys.ts';
 import { realTimers, type Timers } from './timers.ts';
+import { messageOf } from './error-message.ts';
 
 const METHOD = 'textDocument/codeAction';
 const PAUSE_MS = 250;
@@ -36,6 +37,14 @@ function isRefusal(error: unknown): boolean {
     return error instanceof LspError && error.code === ErrorCodes.InternalError;
 }
 
+interface RequestOptions {
+    readonly only?: readonly string[];
+    readonly signal?: AbortSignal;
+    /* The problems the actions are about; the ones touching the range when absent. */
+    readonly about?: readonly Diagnostic[];
+    readonly order?: readonly ActionGroup[];
+}
+
 interface AskOptions {
     readonly range: EditorRange;
     readonly only?: readonly string[];
@@ -49,16 +58,11 @@ interface AskOptions {
 }
 
 /*
- * What the language servers offer to do at the caret or the selection: a lightbulb in the gutter on the line
- * that has something, a list under the caret (Mod+.) grouped by kind with the change an action would make
- * shown under it, the Quick fix of a problem's card, and the commands that organize imports and format the file.
- * An action is resolved before it is applied, since a server fills in its edit only when asked for it.
+ * What the servers offer at the caret or the selection: the gutter's lightbulb, the list under the caret
+ * with a preview of each change, a problem's Quick fix, organize imports and format. An action is resolved
+ * before it is applied, since a server fills in its edit only when asked for it.
  */
 export class CodeActionsFeature {
-    private tell(kind: 'success' | 'error', title: string): void {
-        this.language.project.host.notify?.({ id: TOAST_ID, kind, title });
-    }
-
     private readonly language: EditorLanguage;
     private readonly refresher: Refresher;
     /* While a list is being asked for, the lightbulb waits: both are the same request and the newer one would cancel the older. */
@@ -127,7 +131,7 @@ export class CodeActionsFeature {
     async organizeImports(): Promise<void> {
         const { editor } = this.language;
         const everything = { start: { line: 0, character: 0 }, end: editor.positionAt(Number.MAX_SAFE_INTEGER) };
-        const entries = await this.request(everything, ['source.organizeImports'], INVOKED);
+        const entries = await this.request(everything, INVOKED, { only: ['source.organizeImports'] });
         const entry = entries?.find((candidate) => candidate.action.kind?.startsWith('source.organizeImports') === true);
         if (entry === undefined) {
             this.tell('success', this.say(entries === null ? 'unavailable' : 'organized'));
@@ -154,16 +158,10 @@ export class CodeActionsFeature {
 
     /* The actions of one kind for the selection, as entries a menu can list and `apply` runs. */
     list(only: readonly string[]): Promise<ActionEntry[] | null> {
-        return this.supported
-            ? this.request(
-                  this.language.editor.getSelection(),
-                  only,
-                  AUTOMATIC,
-                  undefined,
-                  undefined,
-                  only.includes('refactor') ? REFACTOR_GROUPS : ACTION_GROUPS
-              )
-            : Promise.resolve(null);
+        if (!this.supported) {
+            return Promise.resolve(null);
+        }
+        return this.request(this.language.editor.getSelection(), AUTOMATIC, { only, order: only.includes('refactor') ? REFACTOR_GROUPS : ACTION_GROUPS });
     }
 
     private async ask(options: AskOptions): Promise<void> {
@@ -178,7 +176,7 @@ export class CodeActionsFeature {
         try {
             entries = options.withLine
                 ? await this.requestWithLine(options.range, INVOKED)
-                : await this.request(options.range, options.only, INVOKED, undefined, options.diagnostics, options.groups);
+                : await this.request(options.range, INVOKED, { only: options.only, about: options.diagnostics, order: options.groups });
         } finally {
             this.asking = false;
         }
@@ -210,24 +208,18 @@ export class CodeActionsFeature {
     }
 
     /* Asks the servers; null when they could not answer, with the reason said aloud for a request a person made. */
-    private async request(
-        range: EditorRange,
-        only: readonly string[] | undefined,
-        triggerKind: number,
-        signal?: AbortSignal,
-        about?: readonly Diagnostic[],
-        order?: readonly ActionGroup[]
-    ): Promise<ActionEntry[] | null> {
+    private async request(range: EditorRange, triggerKind: number, options: RequestOptions = {}): Promise<ActionEntry[] | null> {
         const { project, uri, diagnostics } = this.language;
+        const { only, signal, order } = options;
         try {
+            const about =
+                options.about ??
+                diagnosticsAt(
+                    diagnostics.problems.map((problem) => problem.diagnostic),
+                    range
+                );
             const context = {
-                diagnostics: [
-                    ...(about ??
-                        diagnosticsAt(
-                            diagnostics.problems.map((problem) => problem.diagnostic),
-                            range
-                        ))
-                ],
+                diagnostics: [...about],
                 ...(only ? { only: [...only] } : {}),
                 triggerKind: triggerKind as 1 | 2
             };
@@ -247,7 +239,7 @@ export class CodeActionsFeature {
      * elsewhere on its line too, since the fix of an error is wanted from anywhere on the line it is on.
      */
     private async requestWithLine(range: EditorRange, triggerKind: number, signal?: AbortSignal): Promise<ActionEntry[] | null> {
-        const entries = await this.request(range, undefined, triggerKind, signal);
+        const entries = await this.request(range, triggerKind, { signal });
         if (entries === null || range.start.line !== range.end.line) {
             return entries;
         }
@@ -256,7 +248,9 @@ export class CodeActionsFeature {
             return entries;
         }
         const onLine = fixableOnLine(all, range.start.line).slice(0, LINE_PROBLEMS);
-        const fixes = await Promise.all(onLine.map((diagnostic) => this.request(diagnostic.range, ['quickfix'], triggerKind, signal, [diagnostic])));
+        const fixes = await Promise.all(
+            onLine.map((diagnostic) => this.request(diagnostic.range, triggerKind, { only: ['quickfix'], signal, about: [diagnostic] }))
+        );
         return mergeEntries([entries, ...fixes.map((list) => list ?? [])]);
     }
 
@@ -372,9 +366,13 @@ export class CodeActionsFeature {
         }
     }
 
+    private tell(kind: 'success' | 'error', title: string): void {
+        this.language.project.host.notify?.({ id: TOAST_ID, kind, title });
+    }
+
     private fail(error: unknown): void {
         if (!(error instanceof StaleResultError)) {
-            this.tell('error', this.say('failed', { message: error instanceof Error ? error.message : String(error) }));
+            this.tell('error', this.say('failed', { message: messageOf(error) }));
         }
     }
 

package/src/code-authors.ts

@@ -1,9 +1,9 @@
 import type { i18n } from 'i18next';
 import { diffLines, splitLines } from '@adecore/merge';
-import type { GitBlameCommit, GitBlameResult } from './host-types.ts';
 import { formatNumber } from '@adecore/ui/format';
+import type { GitBlameCommit, GitBlameResult } from './host-types.ts';
 
-/* What a line of the text in the editor is: the index of the commit that wrote it, or this for a line no commit holds yet. */
+/* A line no commit holds yet; every other line maps to the index of the commit that wrote it. */
 export const UNCOMMITTED = -1;
 
 /*

package/src/code-vision.ts

@@ -1,5 +1,5 @@
 import { splitLines } from '@adecore/merge';
-import type { GitBlameResult } from './host-types.ts';
+import type { GitBlameCommit, GitBlameResult } from './host-types.ts';
 import type { EditorCodeVision, EditorCodeVisionEntry, EditorRect } from '@adecore/editor';
 import type { DocumentSymbolResult } from '@adecore/lsp';
 import type { EditorLanguage } from './editor-language.ts';
@@ -30,11 +30,10 @@ export type BlameSource =
     | { readonly kind: 'ready'; readonly blame: GitBlameResult; readonly base: string; openCommit?(hash: string): void };
 
 /*
- * The rows above declarations: how often each is used and, once git has been asked, who wrote it. The
- * declarations come from the symbols the servers know, and a row holds its height from the first
- * answer on, empty until its entries are in, so the text never moves when they arrive. Counts are asked
- * lazily, for the declarations in view and a margin around them, a few at a time, and only after the
- * text has settled; an old count stays on its row until the new one is in.
+ * The rows above declarations: how often each is used and who wrote it. A row holds its height from the
+ * first answer on, empty until its entries are in, so the text never moves when they arrive. Counts are
+ * asked for the declarations near the view, a few at a time, once the text has settled; an old count
+ * stays on its row until the new one is in.
  */
 export class CodeVisionFeature {
     private readonly language: EditorLanguage;
@@ -214,17 +213,12 @@ export class CodeVisionFeature {
                 });
             }
             if (mapped !== null && declaration.authors) {
-                let authorship = this.authorships.get(declaration.id);
-                if (authorship === undefined) {
-                    authorship = authorshipOf(commits, mapped, this.lines, declaration.authorFrom, declaration.authorTo);
-                    this.authorships.set(declaration.id, authorship);
-                }
-                const shown = authorship;
+                const authorship = this.authorshipOf(declaration, commits, mapped);
                 entries.push({
                     id: 'authors',
-                    text: authorsText(shown, this.language.project.i18n),
-                    ...(shown.authors.length > 0 ? { icon: shown.authors.length > 1 ? ('users' as const) : ('user' as const) } : {}),
-                    activate: (anchor) => this.showAuthors(declaration, shown, anchor)
+                    text: authorsText(authorship, this.language.project.i18n),
+                    ...(authorship.authors.length > 0 ? { icon: authorship.authors.length > 1 ? ('users' as const) : ('user' as const) } : {}),
+                    activate: (anchor) => this.showAuthors(declaration, authorship, anchor)
                 });
             }
             rows.push({ id: declaration.id, line: declaration.line, entries });
@@ -232,6 +226,16 @@ export class CodeVisionFeature {
         return rows;
     }
 
+    private authorshipOf(declaration: CodeVisionDeclaration, commits: readonly GitBlameCommit[], mapped: Int32Array): CodeAuthorship {
+        const known = this.authorships.get(declaration.id);
+        if (known !== undefined) {
+            return known;
+        }
+        const authorship = authorshipOf(commits, mapped, this.lines, declaration.authorFrom, declaration.authorTo);
+        this.authorships.set(declaration.id, authorship);
+        return authorship;
+    }
+
     private mapOfBlame(source: Extract<BlameSource, { kind: 'ready' }>): Int32Array | null {
         if (this.mapped?.blame !== source.blame) {
             this.mapped = { blame: source.blame, lines: mapBlame(source.blame, source.base, this.lines) };

package/src/completion-call.ts

@@ -1,5 +1,5 @@
 import type { CompletionItem } from '@adecore/lsp';
-import { CLASS_KIND, CONSTRUCTOR_KIND, FUNCTION_KIND, METHOD_KIND, SNIPPET_FORMAT, type Insertion } from './completion-model.ts';
+import { CLASS_KIND, SNIPPET_FORMAT, SOURCE_LINE, isCallableKind, type Insertion } from './completion-model.ts';
 
 /* What the platform's editors send to ask for parameter info once an item is in; the card is ours to open. */
 export const PARAMETER_HINTS_COMMAND = 'editor.action.triggerParameterHints';
@@ -13,7 +13,6 @@ const TYPE_OPERATOR = /\b(?:typeof|keyof|instanceof|implements|satisfies|as)\s+[
 const AFTER_NEW = /\bnew\s+[\w$.\\]*$/;
 const EXISTING_CALL = /^\s*\(/;
 const SIGNATURE_KIND_PREFIX = /^\([a-z]+(?: [a-z]+)*\)\s+(?!=>)/;
-const SOURCE_LINE = /^(?:use\s|Auto import from\b)/;
 
 /*
  * What accepting an item does about the call it names: nothing, parentheses added with the caret inside or
@@ -37,10 +36,7 @@ export interface CallSite {
 
 /* Whether the item is something that is called where it stands: a function, a method, a constructor, or a class after `new`. */
 export function isCallItem(item: CompletionItem, lineBefore: string): boolean {
-    if (item.kind === METHOD_KIND || item.kind === FUNCTION_KIND || item.kind === CONSTRUCTOR_KIND) {
-        return true;
-    }
-    return item.kind === CLASS_KIND && AFTER_NEW.test(lineBefore);
+    return isCallableKind(item.kind) || (item.kind === CLASS_KIND && AFTER_NEW.test(lineBefore));
 }
 
 /* Whether the parameter list in a signature has anything in it; null when the text names no list. */

package/src/completion-model.ts

@@ -1,7 +1,7 @@
 import type { EditorContentChange, EditorPosition, EditorRange } from '@adecore/editor';
-import type { CompletionItem, CompletionList, CompletionResult, InsertReplaceEdit, MarkupContent, TextEdit } from '@adecore/lsp';
+import type { CompletionItem, CompletionList, CompletionResult, MarkupContent } from '@adecore/lsp';
 import { comparePositions } from './diagnostics-model.ts';
-import { isEmptyHover, splitSignatures, type HoverText } from './hover-content.ts';
+import { escapeMarkdown, isEmptyHover, splitSignatures, type HoverText } from './hover-content.ts';
 import type { CompletionDocs } from './popups.ts';
 import { parseSnippet, tabOrder, type SnippetStop } from './snippet.ts';
 
@@ -280,6 +280,10 @@ export const CONSTRUCTOR_KIND = 4;
 export const CLASS_KIND = 7;
 export const SNIPPET_FORMAT = 2;
 
+export function isCallableKind(kind: number | undefined): boolean {
+    return kind === METHOD_KIND || kind === FUNCTION_KIND || kind === CONSTRUCTOR_KIND;
+}
+
 /* A call snippet with the call cut off, for a name that already has its parentheses: `log(${1:value})$0` becomes `log`. */
 function withoutCall(snippet: string): string {
     const open = snippet.search(/(?<!\\)\(/);
@@ -309,8 +313,7 @@ export function insertionOf(item: CompletionItem, caret: EditorPosition, lineBef
         return { range, text: raw, stops: [] };
     }
     const followed = range.end.line === caret.line && lineAfter.slice(Math.max(0, range.end.character - caret.character)).startsWith('(');
-    const callable = item.kind === METHOD_KIND || item.kind === FUNCTION_KIND || item.kind === CONSTRUCTOR_KIND;
-    const parsed = parseSnippet(followed && callable ? withoutCall(raw) : raw);
+    const parsed = parseSnippet(followed && isCallableKind(item.kind) ? withoutCall(raw) : raw);
     return { range, text: parsed.text, stops: tabOrder(parsed) };
 }
 
@@ -352,14 +355,11 @@ export function documentationText(documentation: string | MarkupContent | undefi
     if (documentation === undefined) {
         return '';
     }
-    return typeof documentation === 'string'
-        ? documentation
-        : documentation.kind === 'plaintext'
-          ? documentation.value.replace(/([\\`*_{}[\]()#+\-.!|<>~])/g, '\\$1')
-          : documentation.value;
+    return typeof documentation === 'string' ? documentation : documentation.kind === 'plaintext' ? escapeMarkdown(documentation.value) : documentation.value;
 }
 
-const SOURCE_LINE = /^(?:use\s|Auto import from\b)/;
+/* A detail line that only says where an item comes from: a PHP `use` or an auto import. */
+export const SOURCE_LINE = /^(?:use\s|Auto import from\b)/;
 
 /*
  * What is said about a suggestion beside the list, in the shape a hover has: the signature it names and the
@@ -379,8 +379,6 @@ export function completionDocsOf(item: CompletionItem, highlightLanguage: string
     return source === '' && isEmptyHover(text) ? null : { source, text };
 }
 
-export type { InsertReplaceEdit, TextEdit };
-
 const KIND_LETTERS: Record<number, string> = {
     1: 't',
     2: 'm',

package/src/completion.ts

@@ -20,6 +20,8 @@ import {
 import { PARAMETER_HINTS_COMMAND, isCallItem, planCall, withParentheses, type CallPlan } from './completion-call.ts';
 import { RecentChoices, recentChoicesOf } from './recent-choices.ts';
 import { shikiLanguageOf } from './language-ids.ts';
+import { textBeforeOf } from './line-text.ts';
+import { isEmptyRange } from './proposal-model.ts';
 import { isShortcut } from './shortcut-keys.ts';
 import type { CompletionRow, CompletionView } from './popups.ts';
 import { realTimers, type Timers } from './timers.ts';
@@ -33,10 +35,6 @@ const PAGE = 8;
 const LINES_BACK = 60;
 const TOAST_ID = 'language-completion';
 
-function isEmpty(range: EditorRange): boolean {
-    return comparePositions(range.start, range.end) === 0;
-}
-
 /*
  * The suggestions that open while a word is typed. A single typed identifier character or a trigger
  * character of the server asks for the list; every character after that only filters the list that
@@ -120,7 +118,7 @@ export class CompletionFeature {
             item = await this.resolveNow(entry.item);
         }
         const caret = editor.getCaret();
-        const lineBefore = editor.textInRange({ start: { line: caret.line, character: 0 }, end: caret });
+        const lineBefore = textBeforeOf(editor, caret);
         const lineAfter = editor.textInRange({ start: caret, end: { line: caret.line, character: Number.MAX_SAFE_INTEGER } });
         // A character that commits is typed after the name, so a call is not added before it.
         const planned = insertionOf(item, caret, lineBefore, replace, commit === undefined ? lineAfter : '(');
@@ -310,13 +308,10 @@ export class CompletionFeature {
         const triggers = this.triggerCharacters();
         const last = Array.from(text).at(-1) ?? '';
         const typedIdentifier = text !== '' && Array.from(text).every(isIdentifierCharacter);
-        if (text.length > 0 && triggers.includes(last) && text.length === 1) {
+        if (text.length === 1 && triggers.includes(last)) {
             this.close();
             this.beginRequest({ triggerKind: 2, triggerCharacter: last }, 0);
-        } else if (
-            isEmpty(range) &&
-            opensCompletion(this.language.editor.textInRange({ start: { line: range.start.line, character: 0 }, end: range.start }), text)
-        ) {
+        } else if (isEmptyRange(range) && opensCompletion(textBeforeOf(this.language.editor, range.start), text)) {
             this.close();
             this.beginRequest({ triggerKind: 1 }, START_DELAY_MS);
         } else if (this.isOpen) {
@@ -326,7 +321,7 @@ export class CompletionFeature {
             } else {
                 this.close();
             }
-        } else if (text.length === 1 && typedIdentifier && isEmpty(range)) {
+        } else if (text.length === 1 && typedIdentifier && isEmptyRange(range)) {
             this.beginRequest({ triggerKind: 1 }, START_DELAY_MS);
         }
     }
@@ -393,7 +388,7 @@ export class CompletionFeature {
         this.server = project.host.serverNames?.(uri)[0] ?? '';
         if (!refresh) {
             const caret = editor.getCaret();
-            const lineBefore = editor.textInRange({ start: { line: caret.line, character: 0 }, end: caret });
+            const lineBefore = textBeforeOf(editor, caret);
             const prefix = context.triggerKind === 2 ? '' : identifierPrefix(lineBefore);
             this.start = { line: caret.line, character: caret.character - prefix.length };
             this.active = 0;
@@ -419,7 +414,7 @@ export class CompletionFeature {
             this.close();
             return;
         }
-        const lineBefore = editor.textInRange({ start: { line: caret.line, character: 0 }, end: caret });
+        const lineBefore = textBeforeOf(editor, caret);
         // Most items of a list replace the same range, so the text under it is read once and not once per item.
         const typed = new Map<string, string>();
         const textBetween = (range: EditorRange): string => {

package/src/context-menu.ts

@@ -3,9 +3,8 @@ import type { EditorLanguage } from './editor-language.ts';
 export type ClipboardAction = 'cut' | 'copy' | 'paste';
 
 /*
- * The editor's context menu. The editor only says where it was asked for; the menu is drawn by the page
- * (`EditorContextMenu`) from what the language servers support at the caret, and the refactors it lists
- * are asked for while it opens, so it never waits for them.
+ * The editor only says where its context menu was asked for; `EditorContextMenu` draws it from what the
+ * servers support at the caret. The refactors are asked for while it opens, so it never waits for them.
  */
 export class ContextMenuFeature {
     private readonly language: EditorLanguage;
@@ -14,7 +13,7 @@ export class ContextMenuFeature {
     constructor(language: EditorLanguage) {
         this.language = language;
         const off = language.editor.onContextMenu((menu) => {
-            // A right click outside the selection moves the caret there first, as every code editor does, so the menu is about what was clicked.
+            // A right click outside the selection moves the caret first, so the menu is about what was clicked.
             if (!menu.inSelection) {
                 language.editor.setCaret(menu.position);
             }
@@ -33,7 +32,7 @@ export class ContextMenuFeature {
         }
     }
 
-    /* Cut, copy and paste go through the browser's own commands on the editor's input, which is what keeps the clipboard and the undo history one thing. */
+    /* The browser's own commands on the editor's input, which keep the clipboard and the undo history one thing. */
     clipboard(action: ClipboardAction): void {
         const { editor } = this.language;
         editor.focus();

package/src/definition-link.ts

@@ -2,6 +2,7 @@ import type { EditorPosition } from '@adecore/editor';
 import { isIdentifierCharacter } from './completion-model.ts';
 import type { EditorLanguage } from './editor-language.ts';
 import { locationsOf } from './hover-content.ts';
+import { lineTextOf } from './line-text.ts';
 import { wordRangeAt } from './rename-model.ts';
 
 /*
@@ -78,7 +79,7 @@ export class DefinitionLinkFeature {
             return;
         }
         const { editor, project, uri } = this.language;
-        const line = editor.textInRange({ start: { line: pointer.line, character: 0 }, end: { line: pointer.line, character: Number.MAX_SAFE_INTEGER } });
+        const line = lineTextOf(editor, pointer.line);
         const word = isIdentifierCharacter(line[pointer.character] ?? '') ? wordRangeAt(line, pointer) : null;
         if (word === null) {
             this.clear();

package/src/diagnostics-model.ts

@@ -1,5 +1,6 @@
 import type { EditorContentChange, EditorMarker, EditorMarkerSeverity, EditorPosition, EditorRange } from '@adecore/editor';
 import type { Diagnostic } from '@adecore/lsp';
+import type { ProblemCounts } from './diagnostics.ts';
 
 /* A diagnostic and the language server process that reported it. */
 export interface Problem {
@@ -8,6 +9,7 @@ export interface Problem {
 }
 
 const SEVERITIES: Record<number, EditorMarkerSeverity> = { 1: 'error', 2: 'warning', 3: 'info', 4: 'hint' };
+const HINT = 4;
 const UNNECESSARY = 1;
 const DEPRECATED = 2;
 /* The scroll track's tip is a line or two, so a long message is cut where it stops being a tip. */
@@ -28,6 +30,12 @@ export function markerOf(diagnostic: Diagnostic): EditorMarker {
     };
 }
 
+/* A diagnostic that names no severity counts as an error. */
+export function problemCountsOf(diagnostics: readonly Diagnostic[]): ProblemCounts {
+    const count = (severity: number): number => diagnostics.filter((diagnostic) => (diagnostic.severity ?? 1) === severity).length;
+    return { error: count(1), warning: count(2), info: count(3) };
+}
+
 export function comparePositions(left: EditorPosition, right: EditorPosition): number {
     return left.line === right.line ? left.character - right.character : left.line - right.line;
 }
@@ -74,14 +82,14 @@ export function rangeHolds(range: EditorRange, position: EditorPosition): boolea
 export function problemsAt(problems: readonly Problem[], position: EditorPosition): Problem[] {
     const rank = (problem: Problem): number => problem.diagnostic.severity ?? 1;
     return problems
-        .filter((problem) => (problem.diagnostic.severity ?? 1) < 4 && rangeHolds(problem.diagnostic.range, position))
+        .filter((problem) => (problem.diagnostic.severity ?? 1) < HINT && rangeHolds(problem.diagnostic.range, position))
         .sort((left, right) => rank(left) - rank(right));
 }
 
 /* The start of the first problem after the position, or the last one before it when `direction` is back; it wraps round the document. */
 export function neighborProblem(problems: readonly Problem[], from: EditorPosition, direction: 1 | -1): Problem | null {
     const candidates = problems
-        .filter((problem) => (problem.diagnostic.severity ?? 1) < 4)
+        .filter((problem) => (problem.diagnostic.severity ?? 1) < HINT)
         .sort((left, right) => comparePositions(left.diagnostic.range.start, right.diagnostic.range.start));
     if (candidates.length === 0) {
         return null;