@adecore/editor-react 0.21.1 → 0.21.2

package/dist/AnchoredPopup.js

@@ -3,9 +3,8 @@ import { useLayoutEffect, useRef } from 'react';
 import { createPortal } from 'react-dom';
 import { placePopup } from './popup-placement.js';
 /*
- * A card next to a character of the editor, in a layer of the page itself: a canvas puts a scale on its
- * nodes, and a card inside one would be drawn at that scale and cut off by the node's edge. It is
- * placed from the character's screen rectangle, so it is right at any zoom, and it never leaves the window.
+ * A card next to a character of the editor, portaled to the page: inside a scaled canvas node it would be
+ * drawn at that scale and clipped by the node. Placed from the character's screen rectangle, so it holds at any zoom.
  */
 export function AnchoredPopup({ rect, className, children, placement, onPointerEnter, onPointerLeave }) {
     const element = useRef(null);

package/dist/HoverSections.js

@@ -1,10 +1,10 @@
 import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { useEditorRendering } from './rendering-context.js';
 import { useEffect, useState } from 'react';
-import { Markdown } from './Markdown.js';
 import { Tooltip } from '@adecore/ui';
-import { hoverSectionsOf, markdownParts } from './hover-content.js';
 import { BaselineStatus } from './BaselineStatus.js';
+import { hoverSectionsOf, markdownParts } from './hover-content.js';
+import { Markdown } from './Markdown.js';
+import { useEditorRendering } from './rendering-context.js';
 import { declaredNameOf, linkTypeNames } from './symbol-links.js';
 /* Code as the viewer colors it, plain until the grammar is in so the card never changes size under the pointer by much. */
 export function Signature({ code, language, onName }) {
@@ -53,20 +53,14 @@ export function SymbolSections({ text, onName }) {
 function phpWithoutOpenTag(html) {
     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 }) {
     const { theme, highlight } = useEditorRendering();
     const [html, setHtml] = useState(null);
     const highlighted = language === 'php' && text.startsWith('use ');
     const key = `${theme}\0${text}`;
     useEffect(() => {
-        if (!highlighted) {
-            return;
-        }
-        if (highlight === undefined) {
+        if (!highlighted || highlight === undefined) {
             return;
         }
         let alive = true;

package/dist/PeekPanel.js

@@ -1,5 +1,4 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { useEditorRendering } from './rendering-context.js';
 import { useEffect, useMemo, useRef, useState } from 'react';
 import { createPortal } from 'react-dom';
 import { useTranslation } from 'react-i18next';
@@ -7,11 +6,12 @@ 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.js';
+import { basenameOf, relativeTo } from './paths.js';
 import { shikiLanguageOfPath } from './language-ids.js';
 import { PathText } from './PathText.js';
 import { PEEK_HEIGHT } from './peek.js';
 import { distinguishingFolders, visualColumnOf } from './peek-model.js';
+import { useEditorRendering } from './rendering-context.js';
 const TAB_SIZE = 4;
 const CODE = 'font-mono text-(length:--code-font-size) [tab-size:4] [&_.line]:block [&_.line]:h-(--code-line-height) [&_.line]:leading-(--code-line-height) [&_pre]:m-0 [&_pre]:bg-transparent! [&_pre]:p-0 [&_pre]:whitespace-pre [&_code]:font-mono';
 /* The code around the active reference, drawn like the editor's own rows: its gutter, the line the reference is on and the name marked. */
@@ -23,10 +23,7 @@ function Preview({ view }) {
     const path = preview === null ? null : fileUriToPath(preview.uri);
     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;
@@ -57,9 +54,6 @@ function columnsOf(line, name) {
     const start = visualColumnOf(line, name.start, TAB_SIZE);
     return { start, end: visualColumnOf(line, name.end, TAB_SIZE) };
 }
-function relativeTo(path, folder) {
-    return path.startsWith(`${folder}/`) ? path.slice(folder.length + 1) : path;
-}
 function folderOf(path) {
     return path.slice(0, Math.max(0, path.lastIndexOf('/')));
 }
@@ -90,10 +84,9 @@ function Places({ language, view }) {
         }) }));
 }
 /*
- * 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 }) {
     const { t } = useTranslation('editor');

package/dist/RenameCard.js

@@ -6,7 +6,7 @@ import { Sparkles } from 'lucide-react';
 import { fileUriToPath } from '@adecore/lsp';
 import { Button, Icon } from '@adecore/ui';
 import { formatNumber } from '@adecore/ui/format';
-import { basenameOf } from './paths.js';
+import { basenameOf, relativeTo } from './paths.js';
 import { AnchoredPopup } from './AnchoredPopup.js';
 const CARD_ATTRIBUTE = 'data-rename-card';
 /* Whether the focus moved to something that belongs to the rename, which is not leaving it. */
@@ -37,7 +37,7 @@ function Preview({ language, view }) {
     const folder = language.project.folder;
     return (_jsxs("div", { className: "flex w-[520px] max-w-full flex-col", onPointerDown: (event) => event.preventDefault(), children: [_jsx("div", { className: "max-h-[320px] overflow-y-auto", children: 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 (_jsxs("div", { className: "border-b border-border last:border-b-0", children: [_jsxs("div", { className: "flex items-center gap-2 px-3 py-1.5 text-xs", children: [_jsx("span", { className: "font-medium", children: path === null ? shown : basenameOf(path) }), _jsx("span", { className: "min-w-0 truncate text-text-faint", children: shown })] }), _jsx("div", { className: "flex flex-col gap-px px-1 pb-1.5 font-mono text-code", children: file.rows.map((row) => (_jsxs("div", { className: "flex flex-col gap-px", children: [_jsxs("div", { className: "flex gap-2 rounded-sm bg-status-error/10 px-1.5 whitespace-pre", children: [_jsx("span", { className: "w-8 shrink-0 text-right text-text-faint", children: row.line }), _jsx("span", { className: "min-w-0 truncate", children: row.before })] }), _jsxs("div", { className: "flex gap-2 rounded-sm bg-status-idle/10 px-1.5 whitespace-pre", children: [_jsx("span", { className: "w-8 shrink-0" }), _jsx("span", { className: "min-w-0 truncate", children: row.after })] })] }, row.line))) })] }, file.uri));
                 }) }), _jsxs("div", { className: "flex items-center justify-end gap-2 border-t border-border p-2", children: [_jsx(Button, { size: "xs", variant: "ghost", onClick: () => language.rename.cancel(), children: t('language.rename.cancel') }), _jsx(Button, { size: "xs", variant: "primary", onClick: () => void language.rename.confirm(), children: t('language.rename.apply') })] })] }));
 }

package/dist/SymbolPicker.js

@@ -3,11 +3,10 @@ import { useEffect, useMemo, useRef, useState } 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 { fileUriToPath } from '@adecore/lsp';
+import { formatShortcut, Icon } from '@adecore/ui';
 import { formatNumber } from '@adecore/ui/format';
 import { basenameOf } from './paths.js';
-import { fileUriToPath } from '@adecore/lsp';
 import { filterEntries, groupEntries, letterOfKind, modeOf, toneOfKind } from './symbol-picker-model.js';
 const TONES = {
     callable: 'bg-accent-soft text-accent',

package/dist/code-actions-model.js

@@ -5,6 +5,13 @@ import { entriesOf, renamesOf } from './workspace-edit.js';
 export const ACTION_GROUPS = ['quickfix', 'rewrite', 'extract', 'inline', 'move', 'refactor', 'source', 'other'];
 /* The order of Refactor This: what changes the structure of the code first, the rewrites after it. */
 export const REFACTOR_GROUPS = ['extract', 'inline', 'move', 'rewrite', 'refactor'];
+/* Entries in the order of `order`, the preferred actions of each group first. */
+function inGroupOrder(entries, order) {
+    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) {
     if (kind === 'quickfix' || kind?.startsWith('quickfix.')) {
@@ -32,10 +39,7 @@ export function actionsOf(result, order = ACTION_GROUPS) {
         .map((item) => (typeof item.command === 'string' ? { title: item.title, command: item } : item))
         .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. */
 export function mergeEntries(lists) {
@@ -48,10 +52,7 @@ export function mergeEntries(lists) {
         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. */
 export function isHint(entry) {

package/dist/code-actions.d.ts

@@ -3,7 +3,6 @@ import type { Problem } from './diagnostics-model.ts';
 import type { EditorLanguage } from './editor-language.ts';
 import { type Timers } from './timers.ts';
 export declare class CodeActionsFeature {
-    private tell;
     private readonly language;
     private readonly refresher;
     private asking;
@@ -25,6 +24,7 @@ export declare class CodeActionsFeature {
     private refusalOf;
     apply(entry: ActionEntry): Promise<void>;
     private startRename;
+    private tell;
     private fail;
     private say;
 }

package/dist/code-actions.js

@@ -3,6 +3,7 @@ import { ACTION_GROUPS, REFACTOR_GROUPS, actionsOf, diagnosticsAt, fixableOnLine
 import { Refresher } from './refresher.js';
 import { isShortcut } from './shortcut-keys.js';
 import { realTimers } from './timers.js';
+import { messageOf } from './error-message.js';
 const METHOD = 'textDocument/codeAction';
 const PAUSE_MS = 250;
 const INVOKED = 1;
@@ -19,15 +20,11 @@ function isRefusal(error) {
     return error instanceof LspError && error.code === ErrorCodes.InternalError;
 }
 /*
- * 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 {
-    tell(kind, title) {
-        this.language.project.host.notify?.({ id: TOAST_ID, kind, title });
-    }
     language;
     refresher;
     /* While a list is being asked for, the lightbulb waits: both are the same request and the newer one would cancel the older. */
@@ -90,7 +87,7 @@ export class CodeActionsFeature {
     async organizeImports() {
         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'));
@@ -116,9 +113,10 @@ export class CodeActionsFeature {
     }
     /* The actions of one kind for the selection, as entries a menu can list and `apply` runs. */
     list(only) {
-        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 });
     }
     async ask(options) {
         if (!this.supported) {
@@ -132,7 +130,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;
@@ -164,14 +162,14 @@ export class CodeActionsFeature {
         });
     }
     /* Asks the servers; null when they could not answer, with the reason said aloud for a request a person made. */
-    async request(range, only, triggerKind, signal, about, order) {
+    async request(range, triggerKind, options = {}) {
         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
             };
@@ -191,7 +189,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.
      */
     async requestWithLine(range, triggerKind, signal) {
-        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;
         }
@@ -200,7 +198,7 @@ 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 ?? [])]);
     }
     async hint(signal) {
@@ -315,9 +313,12 @@ export class CodeActionsFeature {
             await this.language.rename.start();
         }
     }
+    tell(kind, title) {
+        this.language.project.host.notify?.({ id: TOAST_ID, kind, title });
+    }
     fail(error) {
         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) }));
         }
     }
     say(key, options) {

package/dist/code-authors.js

@@ -1,6 +1,6 @@
 import { diffLines, splitLines } from '@adecore/merge';
 import { formatNumber } from '@adecore/ui/format';
-/* 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;
 /*
  * The commit of every line of the text in the editor. Blame was run for the text on disk, so a line

package/dist/code-vision.d.ts

@@ -42,6 +42,7 @@ export declare class CodeVisionFeature {
     private count;
     private publish;
     private rows;
+    private authorshipOf;
     private mapOfBlame;
     private showAuthors;
     closeAuthors(restoreFocus?: boolean): void;

package/dist/code-vision.js

@@ -11,11 +11,10 @@ const SCROLL_PAUSE_MS = 150;
 /* Past this many lines a file gets no rows at all, which is also what keeps blame and the walk of symbols cheap. */
 export const MAX_LINES = 20_000;
 /*
- * 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 {
     language;
@@ -185,23 +184,27 @@ 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' : 'user' } : {}),
-                    activate: (anchor) => this.showAuthors(declaration, shown, anchor)
+                    text: authorsText(authorship, this.language.project.i18n),
+                    ...(authorship.authors.length > 0 ? { icon: authorship.authors.length > 1 ? 'users' : 'user' } : {}),
+                    activate: (anchor) => this.showAuthors(declaration, authorship, anchor)
                 });
             }
             rows.push({ id: declaration.id, line: declaration.line, entries });
         }
         return rows;
     }
+    authorshipOf(declaration, commits, mapped) {
+        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;
+    }
     mapOfBlame(source) {
         if (this.mapped?.blame !== source.blame) {
             this.mapped = { blame: source.blame, lines: mapBlame(source.blame, source.base, this.lines) };

package/dist/completion-call.js

@@ -1,4 +1,4 @@
-import { CLASS_KIND, CONSTRUCTOR_KIND, FUNCTION_KIND, METHOD_KIND, SNIPPET_FORMAT } from './completion-model.js';
+import { CLASS_KIND, SNIPPET_FORMAT, SOURCE_LINE, isCallableKind } from './completion-model.js';
 /* 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';
 const CALL_LANGUAGES = new Set(['typescript', 'typescriptreact', 'javascript', 'javascriptreact', 'vue', 'php', 'python']);
@@ -9,13 +9,9 @@ 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)/;
 /* 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, lineBefore) {
-    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. */
 function listedParameters(signature) {

package/dist/completion-model.d.ts

@@ -1,5 +1,5 @@
 import type { EditorContentChange, EditorPosition, EditorRange } from '@adecore/editor';
-import type { CompletionItem, CompletionResult, InsertReplaceEdit, MarkupContent, TextEdit } from '@adecore/lsp';
+import type { CompletionItem, CompletionResult, MarkupContent } from '@adecore/lsp';
 import type { CompletionDocs } from './popups.ts';
 import { type SnippetStop } from './snippet.ts';
 export declare function isIdentifierCharacter(character: string): boolean;
@@ -32,6 +32,7 @@ export declare const FUNCTION_KIND = 3;
 export declare const CONSTRUCTOR_KIND = 4;
 export declare const CLASS_KIND = 7;
 export declare const SNIPPET_FORMAT = 2;
+export declare function isCallableKind(kind: number | undefined): boolean;
 export interface Insertion {
     readonly range: EditorRange;
     readonly text: string;
@@ -40,8 +41,8 @@ export interface Insertion {
 export declare function insertionOf(item: CompletionItem, caret: EditorPosition, lineBefore: string, replace: boolean, lineAfter?: string): Insertion;
 export declare function mirroredInsertions(carets: readonly EditorRange[], primary: EditorRange, caret: EditorPosition, text: (range: EditorRange) => string, insertion: Insertion): EditorContentChange[];
 export declare function documentationText(documentation: string | MarkupContent | undefined): string;
+export declare const SOURCE_LINE: RegExp;
 export declare function completionDocsOf(item: CompletionItem, highlightLanguage: string): CompletionDocs | null;
-export type { InsertReplaceEdit, TextEdit };
 export type KindTone = 'callable' | 'value' | 'type' | 'other';
 export declare function kindLetterOf(kind: number | undefined): string;
 export declare function kindToneOf(kind: number | undefined): KindTone;

package/dist/completion-model.js

@@ -1,5 +1,5 @@
 import { comparePositions } from './diagnostics-model.js';
-import { isEmptyHover, splitSignatures } from './hover-content.js';
+import { escapeMarkdown, isEmptyHover, splitSignatures } from './hover-content.js';
 import { parseSnippet, tabOrder } from './snippet.js';
 const IDENTIFIER_CHARACTER = /[\p{L}\p{N}\p{M}_$]/u;
 export function isIdentifierCharacter(character) {
@@ -224,6 +224,9 @@ export const FUNCTION_KIND = 3;
 export const CONSTRUCTOR_KIND = 4;
 export const CLASS_KIND = 7;
 export const SNIPPET_FORMAT = 2;
+export function isCallableKind(kind) {
+    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) {
     const open = snippet.search(/(?<!\\)\(/);
@@ -244,8 +247,7 @@ export function insertionOf(item, caret, lineBefore, replace, lineAfter = '') {
         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) };
 }
 /*
@@ -279,13 +281,10 @@ export function documentationText(documentation) {
     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
  * documentation split into signature, prose and tags. A first line that only says where the item comes from is

package/dist/completion.js

@@ -4,6 +4,8 @@ import { completionDocsOf, identifierPrefix, insertionOf, isIdentifierCharacter,
 import { PARAMETER_HINTS_COMMAND, isCallItem, planCall, withParentheses } from './completion-call.js';
 import { RecentChoices, recentChoicesOf } from './recent-choices.js';
 import { shikiLanguageOf } from './language-ids.js';
+import { textBeforeOf } from './line-text.js';
+import { isEmptyRange } from './proposal-model.js';
 import { isShortcut } from './shortcut-keys.js';
 import { realTimers } from './timers.js';
 const METHOD = 'textDocument/completion';
@@ -14,9 +16,6 @@ const RESOLVE_DELAY_MS = 120;
 const PAGE = 8;
 const LINES_BACK = 60;
 const TOAST_ID = 'language-completion';
-function isEmpty(range) {
-    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
@@ -95,7 +94,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 : '(');
@@ -277,12 +276,11 @@ 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);
         }
@@ -295,7 +293,7 @@ export class CompletionFeature {
                 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);
         }
     }
@@ -359,7 +357,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;
@@ -386,7 +384,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();
         const textBetween = (range) => {

package/dist/context-menu.js

@@ -1,7 +1,6 @@
 /*
- * 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 {
     language;
@@ -9,7 +8,7 @@ export class ContextMenuFeature {
     constructor(language) {
         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);
             }
@@ -26,7 +25,7 @@ export class ContextMenuFeature {
             this.language.popups.setState({ menu: null });
         }
     }
-    /* 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) {
         const { editor } = this.language;
         editor.focus();

package/dist/definition-link.js

@@ -1,5 +1,6 @@
 import { isIdentifierCharacter } from './completion-model.js';
 import { locationsOf } from './hover-content.js';
+import { lineTextOf } from './line-text.js';
 import { wordRangeAt } from './rename-model.js';
 /*
  * The name under the pointer drawn as a link while Cmd (Ctrl elsewhere) is held and a server knows where it
@@ -71,7 +72,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/dist/diagnostics-model.d.ts

@@ -1,11 +1,13 @@
 import type { EditorContentChange, EditorMarker, EditorMarkerSeverity, EditorPosition, EditorRange } from '@adecore/editor';
 import type { Diagnostic } from '@adecore/lsp';
+import type { ProblemCounts } from './diagnostics.ts';
 export interface Problem {
     readonly diagnostic: Diagnostic;
     readonly server: string;
 }
 export declare function severityOf(diagnostic: Diagnostic): EditorMarkerSeverity;
 export declare function markerOf(diagnostic: Diagnostic): EditorMarker;
+export declare function problemCountsOf(diagnostics: readonly Diagnostic[]): ProblemCounts;
 export declare function comparePositions(left: EditorPosition, right: EditorPosition): number;
 export declare function shiftPosition(position: EditorPosition, change: EditorContentChange): EditorPosition;
 export declare function shiftRange(range: EditorRange, changes: readonly EditorContentChange[]): EditorRange;