@adecore/editor-react 0.21.1 → 0.21.2

package/src/review-group.ts

@@ -4,7 +4,6 @@ export interface ReviewMember {
     hide(runIds: readonly string[]): void;
     /* Restores runs after a refused operation. */
     show(runIds: readonly string[]): void;
-    /* Refreshes runs after an operation. */
     refresh(): void;
 }
 
@@ -24,20 +23,21 @@ export class ReviewGroup {
     }
 
     hide(runIds: readonly string[]): void {
-        for (const member of [...this.members]) {
-            member.hide(runIds);
-        }
+        this.each((member) => member.hide(runIds));
     }
 
     show(runIds: readonly string[]): void {
-        for (const member of [...this.members]) {
-            member.show(runIds);
-        }
+        this.each((member) => member.show(runIds));
     }
 
     refresh(): void {
+        this.each((member) => member.refresh());
+    }
+
+    /* Over a copy, since a member may leave while it hears. */
+    private each(action: (member: ReviewMember) => void): void {
         for (const member of [...this.members]) {
-            member.refresh();
+            action(member);
         }
     }
 }
@@ -46,13 +46,9 @@ const groups = new Map<string, { group: ReviewGroup; holders: number }>();
 
 /* The host supplies a shared file key; the group is released with its last editor. */
 export function joinReviewGroup(key: string): { group: ReviewGroup; leave(): void } {
-    let entry = groups.get(key);
-    if (entry === undefined) {
-        entry = { group: new ReviewGroup(), holders: 0 };
-        groups.set(key, entry);
-    }
-    entry.holders++;
-    const held = entry;
+    const held = groups.get(key) ?? { group: new ReviewGroup(), holders: 0 };
+    groups.set(key, held);
+    held.holders++;
     let left = false;
     return {
         group: held.group,

package/src/row-host.ts

@@ -8,14 +8,16 @@ export interface HostedRow {
     height: number;
 }
 
-/*
- * The rows of one owner in an editor, and the elements the editor draws them in, so React can portal
- * into them. The editor makes an element again whenever its row scrolls back into view, which is why a
- * row's content never keeps state of its own.
- */
-export class RowHost {
-    private readonly editor: Editor;
-    private readonly owner: string;
+export interface HostedAction {
+    id: string;
+    /* Zero-based. */
+    line: number;
+}
+
+/* The elements an editor made for one owner's entries, and a version React reads them by. */
+abstract class ContainerHost {
+    protected readonly editor: Editor;
+    protected readonly owner: string;
     private readonly containers = new Map<string, HTMLElement>();
     private readonly listeners = new Set<() => void>();
     private version = 0;
@@ -39,19 +41,50 @@ export class RowHost {
         return this.containers.get(id);
     }
 
-    /* Sets the owner's rows; the same rows again are left alone, so an editor does not measure them twice. */
-    set(rows: readonly HostedRow[]): void {
-        const signature = rows.map((row) => `${row.id}@${row.line}${row.placement}`).join('|');
+    /* False for the same entries again, so an editor does not measure them twice; otherwise drops the elements of entries that left. */
+    protected replace(signature: string, ids: readonly string[]): boolean {
         if (signature === this.signature) {
-            return;
+            return false;
         }
         this.signature = signature;
-        const kept = new Set(rows.map((row) => row.id));
+        const kept = new Set(ids);
         for (const id of [...this.containers.keys()]) {
             if (!kept.has(id)) {
                 this.containers.delete(id);
             }
         }
+        return true;
+    }
+
+    protected mounted(id: string, container: HTMLElement): void {
+        this.containers.set(id, container);
+        this.bump();
+    }
+
+    protected bump(): void {
+        this.version++;
+        for (const listener of [...this.listeners]) {
+            listener();
+        }
+    }
+}
+
+/*
+ * The rows of one owner in an editor, and the elements the editor draws them in, so React can portal
+ * into them. The editor makes an element again whenever its row scrolls back into view, which is why a
+ * row's content never keeps state of its own.
+ */
+export class RowHost extends ContainerHost {
+    set(rows: readonly HostedRow[]): void {
+        const signature = rows.map((row) => `${row.id}@${row.line}${row.placement}`).join('|');
+        if (
+            !this.replace(
+                signature,
+                rows.map((row) => row.id)
+            )
+        ) {
+            return;
+        }
         this.editor.setWidgets(
             rows.map((row) => ({
                 id: row.id,
@@ -68,24 +101,6 @@ export class RowHost {
     clear(): void {
         this.set([]);
     }
-
-    private mounted(id: string, container: HTMLElement): void {
-        this.containers.set(id, container);
-        this.bump();
-    }
-
-    private bump(): void {
-        this.version++;
-        for (const listener of [...this.listeners]) {
-            listener();
-        }
-    }
-}
-
-export interface HostedAction {
-    id: string;
-    /* Zero-based. */
-    line: number;
 }
 
 /*
@@ -93,52 +108,22 @@ export interface HostedAction {
  * them. An element lives as long as its action does, unlike a row's, so what React draws into it keeps
  * its state.
  */
-export class LineActionHost {
-    private readonly editor: Editor;
-    private readonly owner: string;
-    private readonly containers = new Map<string, HTMLElement>();
-    private readonly listeners = new Set<() => void>();
-    private version = 0;
-    private signature = '';
-
-    constructor(editor: Editor, owner: string) {
-        this.editor = editor;
-        this.owner = owner;
-    }
-
-    getVersion = (): number => this.version;
-
-    subscribe = (listener: () => void): (() => void) => {
-        this.listeners.add(listener);
-        return () => {
-            this.listeners.delete(listener);
-        };
-    };
-
-    container(id: string): HTMLElement | undefined {
-        return this.containers.get(id);
-    }
-
+export class LineActionHost extends ContainerHost {
     set(actions: readonly HostedAction[]): void {
         const signature = actions.map((action) => `${action.id}@${action.line}`).join('|');
-        if (signature === this.signature) {
+        if (
+            !this.replace(
+                signature,
+                actions.map((action) => action.id)
+            )
+        ) {
             return;
         }
-        this.signature = signature;
-        const kept = new Set(actions.map((action) => action.id));
-        for (const id of [...this.containers.keys()]) {
-            if (!kept.has(id)) {
-                this.containers.delete(id);
-            }
-        }
         this.editor.setLineActions(
             actions.map((action) => ({
                 id: action.id,
                 line: action.line,
-                render: (container: HTMLElement) => {
-                    this.containers.set(action.id, container);
-                    this.bump();
-                }
+                render: (container: HTMLElement) => this.mounted(action.id, container)
             })),
             this.owner
         );
@@ -148,11 +133,4 @@ export class LineActionHost {
     clear(): void {
         this.set([]);
     }
-
-    private bump(): void {
-        this.version++;
-        for (const listener of [...this.listeners]) {
-            listener();
-        }
-    }
 }

package/src/semantic-model.ts

@@ -2,12 +2,10 @@ import type { EditorSemanticToken } from '@adecore/editor';
 import type { SemanticTokens, SemanticTokensLegend } from '@adecore/lsp';
 
 /*
- * The TextMate scopes a classification stands for, so the editor's theme colors it the way its own
- * grammar colors the same thing. Null where the grammar already did better: a keyword, a string, a
- * local variable. A function being called, a method, a static member and a declaration are scopes of
- * their own, as the platform's color scheme tells them apart. `scoped` says the server marks what is
- * local to a function, so a variable it leaves unmarked lives at the top of a file or comes from a
- * library, which the scheme draws as a global.
+ * The TextMate scopes a classification stands for, so the theme colors it as its grammar would; null where
+ * the grammar already did better (a keyword, a string, a local variable). Calls, methods, statics and
+ * declarations get scopes of their own, as the color scheme tells them apart. `scoped` says the server
+ * marks what is local to a function, so a variable it leaves unmarked is drawn as a global.
  */
 export function scopesOf(type: string, modifiers: ReadonlySet<string>, scoped = false): string[] | null {
     switch (type) {

package/src/semantic-tokens.ts

@@ -7,10 +7,8 @@ const METHOD = 'textDocument/semanticTokens/full';
 const PAUSE_MS = 200;
 
 /*
- * Colors the editor draws from what the language servers know, over what the grammar made of the text:
- * a class is a class and a call is a call where the grammar could only guess. It asks after a pause in
- * typing and when a server says its offer changed, and keeps drawing the last answer, which follows its
- * text through edits, in between, so the colors never blink out while the next one is on its way.
+ * Colors from what the language servers know, over the grammar's guess. It asks after a pause in typing
+ * and when a server's offer changed, and keeps drawing the last answer meanwhile so the colors never blink out.
  */
 export class SemanticTokensFeature {
     private readonly refresher: Refresher;

package/src/signature.ts

@@ -67,7 +67,7 @@ export class SignatureFeature {
         this.ask({ triggerKind: 2, triggerCharacter: '(', isRetrigger: false });
     }
 
-    /* Shows the next overload, or the one before, while the card is up and has more than one; false when it has not, which leaves the arrow to the caret. */
+    /* Shows the next or previous overload; false when the card has fewer than two, which leaves the arrow to the caret. */
     private cycle(step: 1 | -1): boolean {
         const { help } = this;
         if (help === null || help.signatures.length < 2 || !this.isOpen) {

package/src/snippet-session.ts

@@ -12,10 +12,9 @@ export function positionInInsertion(start: EditorPosition, text: string, offset:
 }
 
 /*
- * The tab stops of a snippet that was just inserted. The caret goes to the first one, with its default text
- * selected; Tab goes on to the next and Shift+Tab back, and the last stop (`$0`, or the end of the text)
- * ends it. Escape, a caret that leaves the snippet and any change that is not typing end it too. Typing in
- * a stop does not touch the others: they follow the text, but a mirror of a stop is not edited along.
+ * The tab stops of a snippet that was just inserted. Tab and Shift+Tab move between them; the last stop,
+ * Escape, a caret that leaves the snippet and any change that is not typing end it. A mirror of a stop
+ * follows the text but is not edited along.
  */
 export class SnippetFeature {
     private readonly language: EditorLanguage;

package/src/symbol-links.ts

@@ -3,9 +3,9 @@ import type { Location, SymbolInformation, WorkspaceSymbol, WorkspaceSymbolResul
 /* The classes a name in a signature has: a pointer and an underline on hover, and the accent only then, so the signature stays calm. */
 export const SYMBOL_LINK_CLASS = 'cursor-pointer hover:text-accent hover:underline';
 
-/* A name that reads as a type: it starts with a capital and has a lowercase letter, which leaves `DEFAULT_WEIGHTS` and `T` alone. */
 const TYPE_NAME = /^[A-Z][A-Za-z0-9_]*$/;
 
+/* A name that starts with a capital and has a lowercase letter, which leaves `DEFAULT_WEIGHTS` and `T` alone. */
 export function isTypeName(name: string): boolean {
     return TYPE_NAME.test(name) && /[a-z]/.test(name);
 }
@@ -27,7 +27,7 @@ export function declaredNameOf(code: string): string | null {
     return DECLARES.exec(code)?.[1] ?? null;
 }
 
-/* What a workspace symbol is that a type name can mean. */
+/* The symbol kinds a type name can mean: module, namespace, class, enum, interface, struct and type parameter. */
 const TYPE_KINDS = new Set([2, 3, 5, 10, 11, 23, 26]);
 
 interface Found {

package/src/symbol-picker-model.ts

@@ -40,6 +40,8 @@ export function groupOfKind(kind: number): SymbolGroup {
     return GROUP_OF_KIND[kind] ?? 'other';
 }
 
+const ENUM_MEMBER = 22;
+
 const LETTERS: Record<SymbolGroup, string> = {
     namespaces: 'N',
     classes: 'C',
@@ -55,20 +57,26 @@ const LETTERS: Record<SymbolGroup, string> = {
 
 /* The letter in the badge in front of a symbol. */
 export function letterOfKind(kind: number): string {
-    return kind === 22 ? 'e' : LETTERS[groupOfKind(kind)];
+    return kind === ENUM_MEMBER ? 'e' : LETTERS[groupOfKind(kind)];
 }
 
 export type SymbolTone = 'callable' | 'value' | 'type' | 'other';
 
+const TONES: Record<SymbolGroup, SymbolTone> = {
+    namespaces: 'other',
+    classes: 'type',
+    interfaces: 'type',
+    enums: 'type',
+    functions: 'callable',
+    methods: 'callable',
+    properties: 'value',
+    variables: 'value',
+    constants: 'value',
+    other: 'other'
+};
+
 export function toneOfKind(kind: number): SymbolTone {
-    const group = groupOfKind(kind);
-    return group === 'functions' || group === 'methods'
-        ? 'callable'
-        : group === 'classes' || group === 'interfaces' || group === 'enums'
-          ? 'type'
-          : group === 'properties' || group === 'variables' || group === 'constants'
-            ? 'value'
-            : 'other';
+    return TONES[groupOfKind(kind)];
 }
 
 /* One symbol of a file as a row of the picker. */

package/src/symbol-picker.ts

@@ -3,6 +3,7 @@ import { basenameOf } from './paths.ts';
 import type { EditorLanguage } from './editor-language.ts';
 import { entriesOf, workspaceEntriesOf, type SymbolEntry, type WorkspaceEntry } from './symbol-picker-model.ts';
 import { isShortcut } from './shortcut-keys.ts';
+import { messageOf } from './error-message.ts';
 
 const TOAST_ID = 'language-symbols';
 
@@ -43,7 +44,7 @@ export class SymbolPickerFeature {
                 this.language.project.host.notify?.({
                     id: TOAST_ID,
                     kind: 'error',
-                    title: this.language.project.i18n.t('editor:language.symbols.failed', { message: error instanceof Error ? error.message : String(error) })
+                    title: this.language.project.i18n.t('editor:language.symbols.failed', { message: messageOf(error) })
                 });
             }
         }

package/src/symbols.ts

@@ -1,5 +1,5 @@
 import type { EditorBlock } from '@adecore/editor';
-import type { DocumentSymbol, DocumentSymbolResult, SymbolInformation } from '@adecore/lsp';
+import type { DocumentSymbol, DocumentSymbolResult, Range, SymbolInformation } from '@adecore/lsp';
 import type { EditorLanguage } from './editor-language.ts';
 import { Refresher } from './refresher.ts';
 import { realTimers, type Timers } from './timers.ts';
@@ -23,42 +23,43 @@ const KINDS: Record<number, string> = {
     23: 'struct'
 };
 
-function isHierarchical(symbols: readonly (DocumentSymbol | SymbolInformation)[]): symbols is DocumentSymbol[] {
-    return symbols.length > 0 && 'range' in symbols[0]!;
+export interface SymbolSpan {
+    readonly name: string;
+    readonly kind: number;
+    readonly range: Range;
 }
 
-function blockOf(name: string, kind: number, startLine: number, endLine: number): EditorBlock | null {
-    const label = KINDS[kind];
-    // A one-line symbol has no body to pin, and a property or an enum member is part of the block around it.
-    return label === undefined || endLine <= startLine ? null : { startLine: startLine + 1, endLine: endLine + 1, name, kind: label };
-}
-
-function walk(symbols: readonly DocumentSymbol[], blocks: EditorBlock[]): void {
+function walk(symbols: readonly DocumentSymbol[], spans: SymbolSpan[]): void {
     for (const symbol of symbols) {
-        const block = blockOf(symbol.name, symbol.kind, symbol.range.start.line, symbol.range.end.line);
-        if (block !== null) {
-            blocks.push(block);
-        }
-        walk(symbol.children ?? [], blocks);
+        spans.push({ name: symbol.name, kind: symbol.kind, range: symbol.range });
+        walk(symbol.children ?? [], spans);
     }
 }
 
-/* The multi-line symbols of a file as blocks, outermost first, in one-based lines. */
-export function blocksOf(result: DocumentSymbolResult): EditorBlock[] {
-    const blocks: EditorBlock[] = [];
+/* Every symbol of an answer, a parent before its children, whether the server sent a tree or a flat list. */
+export function symbolSpansOf(result: DocumentSymbolResult): SymbolSpan[] {
+    const spans: SymbolSpan[] = [];
     if (result === null || result.length === 0) {
-        return blocks;
+        return spans;
     }
-    if (isHierarchical(result)) {
-        walk(result, blocks);
-    } else {
-        for (const symbol of result as SymbolInformation[]) {
-            const block = blockOf(symbol.name, symbol.kind, symbol.location.range.start.line, symbol.location.range.end.line);
-            if (block !== null) {
-                blocks.push(block);
-            }
-        }
+    if ('range' in result[0]!) {
+        walk(result as DocumentSymbol[], spans);
+        return spans;
     }
+    return (result as SymbolInformation[]).map((symbol) => ({ name: symbol.name, kind: symbol.kind, range: symbol.location.range }));
+}
+
+function blockOf({ name, kind, range }: SymbolSpan): EditorBlock | null {
+    const label = KINDS[kind];
+    // A one-line symbol has no body to pin, and a property or an enum member is part of the block around it.
+    return label === undefined || range.end.line <= range.start.line
+        ? null
+        : { startLine: range.start.line + 1, endLine: range.end.line + 1, name, kind: label };
+}
+
+/* The multi-line symbols of a file as blocks, outermost first, in one-based lines. */
+export function blocksOf(result: DocumentSymbolResult): EditorBlock[] {
+    const blocks = symbolSpansOf(result).flatMap((span) => blockOf(span) ?? []);
     return blocks.sort((left, right) => left.startLine - right.startLine || right.endLine - left.endLine);
 }
 

package/src/testing.ts

@@ -1,5 +1,6 @@
 import {
     applyContentChanges,
+    ErrorCodes,
     LspError,
     StaleResultError,
     type LanguageService,
@@ -69,7 +70,7 @@ export class FakeLanguageService implements LanguageService {
     async changeDocument(uri: string, changes: readonly ContentChange[]): Promise<void> {
         const held = this.documents.get(uri);
         if (held === undefined) {
-            throw new LspError('Document is not open', -32002);
+            throw new LspError('Document is not open', ErrorCodes.ServerNotInitialized);
         }
         held.text = applyContentChanges(held.text, changes);
         held.version++;
@@ -113,7 +114,7 @@ export class FakeLanguageService implements LanguageService {
 
     private async request<Result>(method: string, uri: string, params: unknown, options: LanguageRequestOptions = {}): Promise<Result> {
         if (!this.supports(method, uri)) {
-            throw new LspError(`${method} is unavailable`, -32601);
+            throw new LspError(`${method} is unavailable`, ErrorCodes.MethodNotFound);
         }
         options.signal?.throwIfAborted();
         const version = this.documents.get(uri)?.version;
@@ -126,6 +127,7 @@ export class FakeLanguageService implements LanguageService {
         }
         return result as Result;
     }
+
     completion(uri: string, position: Position, context?: CompletionContext, options: LanguageRequestOptions = {}): Promise<CompletionResult> {
         return this.request<CompletionResult>('textDocument/completion', uri, { position, context }, options);
     }

package/src/view-state.ts

@@ -1,7 +1,9 @@
 import type { EditorFolds, FoldRole } from '@adecore/editor';
+
 export interface RevealLineRequest {
     readonly line: number;
 }
+
 function endpointKey(namespace: string, path: string): string {
     return `${namespace}:${path}`;
 }

package/src/word-diff.ts

@@ -4,10 +4,8 @@ import { diffLines } from '@adecore/merge';
 const TOKEN = /\w+|\s+|[^\w\s]/g;
 
 /*
- * The character ranges of each removed line that the added lines changed, `[start, end)` per line, for
- * the stronger tint on the words a change replaced. Lines are only compared when as many were added as
- * removed, since then each removed line has the line it became; any other change has no such pairing
- * and draws no words.
+ * The `[start, end)` ranges of each removed line that the added lines replaced. Lines pair up only when as
+ * many were added as removed; any other change has no pairing and marks no words.
  */
 export function replacedWords(removed: readonly string[], added: readonly string[]): Array<Array<[number, number]>> {
     return removed.map((line, index) => (removed.length === added.length ? replacedRanges(line, added[index]!) : []));

package/src/workspace-edit.ts

@@ -9,6 +9,7 @@ import {
     type WorkspaceEdit
 } from '@adecore/lsp';
 import type { DiskText } from './host-types.ts';
+import { messageOf } from './error-message.ts';
 
 /* A file that changed without an editor of this project holding it: its new text waits as an unsaved draft. */
 export interface StagedFile {
@@ -113,12 +114,10 @@ interface PlannedCreate {
 type Planned = PlannedEdits | PlannedCreate | { readonly kind: 'rename'; readonly oldPath: string; readonly newPath: string };
 
 /*
- * Applies an LSP workspace edit on the client, step by step in the order it says. A file an editor holds takes
- * its edits as one undo step. Any other file gets its new text as an unsaved draft that a person saves, and
- * nothing is written to disk on a server's word alone, unless the edit also moves a file: the edits and the
- * move are then one change, so every file is saved through the machine and the move is made there. A file
- * the edit creates is made through the machine with the text the edit writes into it. The edit is checked
- * against every text first, so one that does not fit changes nothing.
+ * Applies an LSP workspace edit step by step, after checking it against every text so one that does not fit
+ * changes nothing. A file an editor holds takes its edits as one undo step; any other file gets an unsaved
+ * draft, since nothing is written to disk on a server's word alone, unless the edit also moves a file: then it
+ * is one change, saved and moved through the machine. A file the edit creates is made through the machine.
  */
 export async function applyWorkspaceEdit(edit: WorkspaceEdit, host: WorkspaceEditHost): Promise<ApplyWorkspaceEditResult> {
     const steps = stepsOf(edit);
@@ -206,7 +205,7 @@ async function plan(steps: readonly Step[], host: WorkspaceEditHost): Promise<Pl
             try {
                 created.text = applyTextEdits(created.text, step.edits);
             } catch (error) {
-                return error instanceof Error ? error.message : String(error);
+                return messageOf(error);
             }
             continue;
         }
@@ -228,7 +227,7 @@ async function plan(steps: readonly Step[], host: WorkspaceEditHost): Promise<Pl
         try {
             after = applyTextEdits(held.text, step.edits);
         } catch (error) {
-            return error instanceof Error ? error.message : String(error);
+            return messageOf(error);
         }
         planned.push({ kind: 'edits', uri: step.uri, edits: step.edits, before: held.text, after, disk: held.disk });
         texts.set(source, { text: after, disk: held.disk });