@adecore/editor-react 0.41.1 → 0.43.0

package/src/pick.ts

@@ -22,6 +22,17 @@ export interface PickSpec {
     attempt?(id: string): Promise<string | null>;
     /* What the active row would change, asked a moment after it became active. */
     preview?(id: string, signal: AbortSignal): Promise<PickPreview | null>;
+    /*
+     * Typing narrows the rows to those whose `search` (the label without one) contains the query, whatever the case, and
+     * the list stays open while a person types. Backspace edits the query.
+     */
+    readonly filter?: boolean;
+    /* Shift with the arrows or a press chooses a run of rows, and Mod with a press adds or takes away one. */
+    readonly multiple?: boolean;
+    /* Enter takes the chosen rows, or the active one when none is chosen; without it Enter calls `accept` with the active row. */
+    acceptMany?(ids: readonly string[]): void;
+    /* Delete takes the chosen rows, or the active one, out of the list, and so does Backspace when there is no query. It answers the rows that remain. */
+    remove?(ids: readonly string[]): readonly PickGroup[];
 }
 
 /*
@@ -33,8 +44,18 @@ export class PickFeature {
     private readonly language: EditorLanguage;
     private readonly timers: Timers;
     private spec: PickSpec | null = null;
+
+    /* The rows as the spec gave them, or as `remove` left them; `ids` are those a query lets through. */
+    private groups: readonly PickGroup[] = [];
+
     private ids: readonly string[] = [];
     private active = '';
+    private query = '';
+
+    /* The rows chosen as a run or one by one, in list order, and the row a run of them grows from. */
+    private chosen: readonly string[] = [];
+
+    private rangeAnchor: string | null = null;
     private previewTimer: unknown;
     private controller: AbortController | null = null;
 
@@ -78,6 +99,10 @@ export class PickFeature {
 
         this.spec = spec;
         this.refusals = new Map();
+        this.groups = spec.groups;
+        this.query = '';
+        this.chosen = [];
+        this.rangeAnchor = null;
         this.ids = ids;
         this.active = spec.active !== undefined && ids.includes(spec.active) ? spec.active : ids[0]!;
         this.publish(null);
@@ -96,19 +121,53 @@ export class PickFeature {
         this.language.popups.setState({ pick: null });
     }
 
-    move(delta: number): void {
+    /* Moves the active row; with `extend`, in a list of several choices, the rows between where the move began and the new row are chosen. */
+    move(delta: number, extend = false): void {
+        if (this.ids.length === 0) {
+            return;
+        }
+
         const index = this.ids.indexOf(this.active);
-        this.activate(this.ids[Math.max(0, Math.min(this.ids.length - 1, index + delta))]!);
+        const id = this.ids[Math.max(0, Math.min(this.ids.length - 1, index + delta))]!;
+
+        if (extend && this.spec?.multiple === true) {
+            this.extendTo(id);
+
+            return;
+        }
+
+        this.settle(id);
+    }
+
+    /* Makes `id` the only row the list is on. */
+    private settle(id: string): void {
+        const hadChosen = this.chosen.length > 0;
+
+        this.chosen = [];
+        this.rangeAnchor = null;
+        this.activate(id, hadChosen);
     }
 
-    /* Takes a row, by a click or Enter. */
-    choose(id: string): void {
+    /* Takes a row, by a click or Enter. In a list of several choices a press with Shift chooses the run up to the row, and one with Mod adds or takes away the row. */
+    choose(id: string, modifiers: { readonly toggle?: boolean; readonly range?: boolean } = {}): void {
         const spec = this.spec;
 
         if (spec === null || !this.ids.includes(id) || this.attempting) {
             return;
         }
 
+        if (spec.multiple === true && modifiers.range === true) {
+            this.extendTo(id);
+
+            return;
+        }
+
+        if (spec.multiple === true && modifiers.toggle === true) {
+            this.toggle(id);
+
+            return;
+        }
+
         if (spec.attempt === undefined) {
             this.close();
             spec.accept(id);
@@ -140,29 +199,124 @@ export class PickFeature {
             });
     }
 
-    private activate(id: string): void {
-        if (id === this.active) {
+    private activate(id: string, force = false): void {
+        const moved = id !== this.active;
+
+        this.active = id;
+
+        if (moved) {
+            this.controller?.abort();
+            this.schedulePreview();
+        }
+
+        if (moved || force) {
+            this.publish(null);
+        }
+    }
+
+    private extendTo(id: string): void {
+        const anchor = this.rangeAnchor ?? this.active;
+        const first = this.ids.indexOf(anchor);
+        const last = this.ids.indexOf(id);
+        const run = this.ids.slice(Math.min(first, last), Math.max(first, last) + 1);
+
+        this.rangeAnchor = anchor;
+        this.chosen = run.length > 1 ? run : [];
+        this.activate(id, true);
+    }
+
+    private toggle(id: string): void {
+        const held = this.chosen.length > 0 ? this.chosen : [this.active];
+        const next = held.includes(id) ? held.filter((other) => other !== id) : [...held, id];
+
+        this.chosen = this.ids.filter((other) => next.includes(other));
+        this.rangeAnchor = id;
+        this.activate(id, true);
+    }
+
+    /* Enter: the chosen rows, or the active one when none is chosen. */
+    private takeActive(): void {
+        const spec = this.spec;
+
+        if (spec?.acceptMany === undefined) {
+            this.choose(this.active);
+
             return;
         }
 
-        this.active = id;
+        const ids = this.chosen.length > 0 ? this.chosen : [this.active];
+
+        if (this.active !== '' && !this.attempting) {
+            this.close();
+            spec.acceptMany(ids);
+        }
+    }
+
+    private visibleGroups(): readonly PickGroup[] {
+        const query = this.query.toLowerCase();
+
+        if (query === '') {
+            return this.groups;
+        }
+
+        return this.groups
+            .map((group) => ({ ...group, rows: group.rows.filter((row) => (row.search ?? row.label).toLowerCase().includes(query)) }))
+            .filter((group) => group.rows.length > 0);
+    }
+
+    /* The query changed: the rows it lets through, with the first of them active. */
+    private requery(query: string): void {
+        this.query = query;
+        this.ids = this.visibleGroups().flatMap((group) => group.rows.map((row) => row.id));
+        this.chosen = [];
+        this.rangeAnchor = null;
+        this.active = this.ids[0] ?? '';
+        this.controller?.abort();
+        this.publish(null);
+        this.schedulePreview();
+    }
+
+    /* Takes the chosen rows, or the active one, out of the list; the list closes when no row is left. */
+    private removeChosen(): void {
+        const spec = this.spec;
+
+        if (spec?.remove === undefined || this.active === '') {
+            return;
+        }
+
+        const removed = this.chosen.length > 0 ? this.chosen : [this.active];
+        const index = this.ids.indexOf(removed[0]!);
+        this.groups = spec.remove(removed);
+
+        if (this.groups.every((group) => group.rows.length === 0)) {
+            this.close();
+
+            return;
+        }
+
+        this.ids = this.visibleGroups().flatMap((group) => group.rows.map((row) => row.id));
+        this.chosen = [];
+        this.rangeAnchor = null;
+        this.active = this.ids[Math.min(index, this.ids.length - 1)] ?? '';
         this.controller?.abort();
         this.publish(null);
         this.schedulePreview();
     }
 
     private key(event: KeyboardEvent): boolean {
-        if (this.spec === null || event.metaKey || event.ctrlKey || event.altKey) {
+        const spec = this.spec;
+
+        if (spec === null || event.metaKey || event.ctrlKey || event.altKey) {
             return false;
         }
 
         switch (event.key) {
             case 'ArrowDown':
-                this.move(1);
+                this.move(1, event.shiftKey);
 
                 return true;
             case 'ArrowUp':
-                this.move(-1);
+                this.move(-1, event.shiftKey);
 
                 return true;
             case 'PageDown':
@@ -174,20 +328,31 @@ export class PickFeature {
 
                 return true;
             case 'Home':
-                this.activate(this.ids[0]!);
-
-                return true;
             case 'End':
-                this.activate(this.ids[this.ids.length - 1]!);
+                if (this.ids.length > 0) {
+                    this.settle(event.key === 'Home' ? this.ids[0]! : this.ids[this.ids.length - 1]!);
+                }
 
                 return true;
             case 'Enter':
-                this.choose(this.active);
+                this.takeActive();
 
                 return true;
-            case 'Tab': {
-                const spec = this.spec;
+            case 'Delete':
+                this.removeChosen();
+
+                return spec.remove !== undefined;
+            case 'Backspace':
+                if (this.query !== '') {
+                    this.requery(this.query.slice(0, -1));
 
+                    return true;
+                }
+
+                this.removeChosen();
+
+                return spec.remove !== undefined || spec.filter === true;
+            case 'Tab': {
                 if (spec.onTab !== undefined) {
                     this.close();
                     spec.onTab(event.shiftKey);
@@ -202,6 +367,12 @@ export class PickFeature {
 
                 return true;
             default:
+                if (spec.filter === true && event.key.length === 1) {
+                    this.requery(this.query + event.key);
+
+                    return true;
+                }
+
                 return false;
         }
     }
@@ -210,7 +381,7 @@ export class PickFeature {
         const spec = this.spec;
         this.timers.clear(this.previewTimer);
 
-        if (spec?.preview === undefined) {
+        if (spec?.preview === undefined || this.active === '') {
             return;
         }
 
@@ -239,6 +410,17 @@ export class PickFeature {
 
         const refusal = this.refusals.get(this.active);
         const shown = refusal === undefined ? preview : { removed: [], added: [], note: null, refusal };
-        this.language.popups.setState({ pick: { anchor: spec.anchor, groups: spec.groups, active: this.active, preview: shown, title: spec.title ?? null } });
+
+        this.language.popups.setState({
+            pick: {
+                anchor: spec.anchor,
+                groups: this.visibleGroups(),
+                active: this.active,
+                preview: shown,
+                title: spec.title ?? null,
+                query: spec.filter === true ? this.query : null,
+                chosen: this.chosen
+            }
+        });
     }
 }

package/src/popups.ts

@@ -82,6 +82,8 @@ export interface PickRow {
     readonly detail: string;
     /* The detail is a path, which gives way from its start before the label gives way at all. */
     readonly path?: boolean;
+    /* What a typed query is matched against, when a list filters; the label without it. */
+    readonly search?: string;
 }
 
 export interface PickGroup {
@@ -97,15 +99,22 @@ export interface PickPreview {
     readonly note: string | null;
     /* Why the action cannot be taken here, which the server said; nothing would change. */
     readonly refusal?: string;
+    /* `diff` draws `removed` and `added` as changed lines, which is the default; `text` draws `added` as plain code, such as the content of a clipboard entry. */
+    readonly kind?: 'diff' | 'text';
 }
 
 /* A list under a character of the editor; Enter takes the active row, Escape closes it. */
 export interface PickView {
     readonly anchor: EditorPosition;
+    /* The rows a query lets through. */
     readonly groups: readonly PickGroup[];
     readonly active: string;
     readonly preview: PickPreview | null;
     readonly title: string | null;
+    /* What has been typed to narrow the rows; null for a list that does not filter. */
+    readonly query: string | null;
+    /* The rows chosen as a run or one by one, in list order; empty when none is, and then the active row is the choice. */
+    readonly chosen: readonly string[];
 }
 
 /* One file of a rename in the preview: the lines it changes. */
@@ -192,6 +201,13 @@ export interface AuthorsView {
     readonly openCommit: (() => void) | null;
 }
 
+/* The field that asks for the abbreviation a selection is wrapped in. */
+export interface WrapView {
+    readonly anchor: EditorPosition;
+    /* Why the last abbreviation did not expand; the field stays open for another. */
+    readonly error: string | null;
+}
+
 export interface PopupState {
     readonly hover: HoverView | null;
     readonly completion: CompletionView | null;
@@ -203,6 +219,7 @@ export interface PopupState {
     readonly symbols: SymbolsView | null;
     readonly menu: MenuView | null;
     readonly authors: AuthorsView | null;
+    readonly wrap: WrapView | null;
 }
 
 export type PopupStore = StoreApi<PopupState>;
@@ -218,6 +235,7 @@ export function createPopupStore(): PopupStore {
         callHierarchy: null,
         symbols: null,
         menu: null,
-        authors: null
+        authors: null,
+        wrap: null
     }));
 }

package/src/project-language.ts

@@ -1,7 +1,20 @@
 import { disposeSnippetTransforms } from './snippet-transform-queue.ts';
 import i18next, { type i18n } from 'i18next';
-import { fileUriToPath, pathToFileUri, type ApplyWorkspaceEditResult, type ContentChange, type LanguageService, type WorkspaceEdit } from '@adecore/lsp';
+import {
+    fileUriToPath,
+    pathToFileUri,
+    unservedLanguageService,
+    type ApplyWorkspaceEditResult,
+    type ContentChange,
+    type Disposable,
+    type LanguageService,
+    type ShowDocumentParams,
+    type ShowDocumentResult,
+    type WorkspaceEdit
+} from '@adecore/lsp';
 import type { Editor, EditorPosition } from '@adecore/editor';
+import { ClipboardHistory } from './clipboard-history.ts';
+import { EditLocations } from './edit-locations.ts';
 import { NavigationHistory, type Place } from './navigation-history.ts';
 import { ProjectProblems, serviceProblems } from './project-problems.ts';
 import { applyWorkspaceEdit, type ProjectFiles } from './workspace-edit.ts';
@@ -16,6 +29,8 @@ export interface LanguageDocumentHandle {
     release(): void;
 }
 
+const UNSERVED = unservedLanguageService();
+
 /* Sends one editor's edits to the document, holding them until the document is open. */
 class DocumentSync {
     readonly ready: Promise<void>;
@@ -76,10 +91,18 @@ class DocumentSync {
 
 interface Holder {
     readonly editors: Editor[];
-    sync: DocumentSync;
+    /* The editors a server serves, in the order they came; the first one sends the changes. */
+    readonly served: Editor[];
+    /* Null while no editor of the document is served, so nothing of it is open in the service. */
+    sync: DocumentSync | null;
     languageId: string;
 }
 
+export interface AcquireOptions {
+    /* False registers the editor as open without telling the service, for a document no server serves; true by default. */
+    readonly serve?: boolean;
+}
+
 /* A file or folder for a file operation notification: a bare path is a file. */
 export type FileOperationTarget = string | { readonly path: string; readonly directory?: boolean };
 
@@ -103,6 +126,8 @@ export class ProjectLanguage {
     readonly folder: string;
     readonly problems: ProjectProblems;
     readonly history = new NavigationHistory();
+    readonly edits: EditLocations;
+    readonly clipboard: ClipboardHistory;
     private readonly holders = new Map<string, Holder>();
     private readonly files: ProjectFiles | null;
 
@@ -113,6 +138,9 @@ export class ProjectLanguage {
     private pendingCaret: Place | null = null;
     private lastPlace: Place | null = null;
     private disposed = false;
+    private readonly subscriptions: readonly Disposable[];
+    /* The result id the server gave each document in its last workspace report, which the next asks with. */
+    private readonly workspaceResults = new Map<string, string>();
 
     constructor(service: LanguageService, host: LanguageHost = {}) {
         this.service = service;
@@ -120,8 +148,13 @@ export class ProjectLanguage {
         this.i18n = host.i18n ?? i18next;
         this.folder = host.folder ?? '';
         this.files = host.files ?? null;
+        this.edits = new EditLocations(host.editHistoryLimit);
+        this.clipboard = host.clipboard ?? new ClipboardHistory();
         this.panelBodyHeight = host.panelBodyHeight ?? PANEL_BODY_HEIGHT;
         this.problems = new ProjectProblems(host.problemSource ?? serviceProblems(service, (uri) => this.pathOfLocation(uri) ?? uri));
+        const shows = service.onShowDocument?.((params) => this.showDocument(params));
+        const messages = host.onServerMessage === undefined ? undefined : service.onServerMessage?.((message) => host.onServerMessage!(message));
+        this.subscriptions = [shows, messages].flatMap((subscription) => (subscription === undefined ? [] : [subscription]));
     }
 
     /* Open panels of other editors of the project follow a resize. */
@@ -182,20 +215,73 @@ export class ProjectLanguage {
 
     /* Tells the servers that files were deleted, once they are. */
     didDeleteFiles(targets: readonly FileOperationTarget[]): Promise<void> {
-        return this.service.didDeleteFiles?.(filesOf(targets)) ?? Promise.resolve();
+        const files = filesOf(targets);
+
+        this.edits.forget((uri) => files.some((file) => (file.directory ? uri.startsWith(`${file.uri}/`) : uri === file.uri)));
+
+        return this.service.didDeleteFiles?.(files) ?? Promise.resolve();
     }
 
-    /* The text of a file as it stands now: an open document's, else a draft's or the machine's; null when it is no text file. */
+    /*
+     * The text of a file as it stands now: an open document's, else a draft's or the machine's; null when it is no
+     * text file. A document of a scheme a server owns, such as a decompiled class, is read from that server.
+     */
     async readText(uri: string): Promise<string | null> {
-        const open = this.holders.get(uri)?.sync.text;
+        const open = this.holders.get(uri)?.editors[0]?.getText();
 
         if (open !== undefined) {
             return open;
         }
 
         const path = fileUriToPath(uri);
+        if (path === null) {
+            return (await this.service.textDocumentContent?.(uri).catch(() => null)) ?? null;
+        }
 
-        return path === null || this.files === null ? null : ((await this.files.read(path))?.text ?? null);
+        return this.files === null ? null : ((await this.files.read(path))?.text ?? null);
+    }
+
+    /*
+     * Asks the server of `uri` for the problems of every file it knows and lists them in `problems`, for a server that
+     * offers workspace diagnostics. A file the server reports as unchanged keeps what it had. False when no server offers them.
+     */
+    async pullWorkspaceProblems(uri: string, options: { readonly signal?: AbortSignal } = {}): Promise<boolean> {
+        const { service } = this;
+        if (service.workspaceDiagnostics === undefined || !service.supports('workspace/diagnostic', uri)) {
+            return false;
+        }
+        const previous = [...this.workspaceResults].map(([key, value]) => ({ uri: key, value }));
+        const report = await service.workspaceDiagnostics(uri, previous, options);
+        const server = this.host.serverNames?.(uri)[0] ?? 'workspace';
+        for (const item of report.items) {
+            if (item.resultId !== undefined) {
+                this.workspaceResults.set(item.uri, item.resultId);
+            }
+            if (item.kind === 'full') {
+                this.problems.report(this.pathOfLocation(item.uri) ?? item.uri, server, item.items);
+            }
+        }
+        return true;
+    }
+
+    /* Shows what a server asks for: a web address outside the editor, anything else as a place of the host. */
+    private async showDocument(params: ShowDocumentParams): Promise<ShowDocumentResult> {
+        const web = /^(https?|mailto):/i.test(params.uri);
+        if (params.external === true || web) {
+            if (this.host.openExternal !== undefined) {
+                this.host.openExternal(params.uri);
+                return { success: true };
+            }
+            if (typeof window === 'undefined') {
+                return { success: false };
+            }
+            return { success: window.open(params.uri, '_blank', 'noopener,noreferrer') !== null };
+        }
+        if (this.host.openPlace === undefined) {
+            return { success: false };
+        }
+        this.openPlace({ uri: params.uri, position: params.selection?.start ?? { line: 0, character: 0 } });
+        return { success: true };
     }
 
     /*
@@ -234,27 +320,39 @@ export class ProjectLanguage {
         return pending.position;
     }
 
+    /* The editors that hold a document, one per uri in the order the documents were first opened. */
+    openEditors(): readonly { uri: string; editor: Editor }[] {
+        return [...this.holders].flatMap(([uri, holder]) => (holder.editors[0] === undefined ? [] : [{ uri, editor: holder.editors[0] }]));
+    }
+
     /* Opens `uri` for the editor, or joins the editors that already hold it. */
-    acquire(uri: string, languageId: string, editor: Editor): LanguageDocumentHandle {
+    acquire(uri: string, languageId: string, editor: Editor, options: AcquireOptions = {}): LanguageDocumentHandle {
         if (this.disposed) {
             throw new Error('The project language is disposed');
         }
 
+        const serve = options.serve ?? true;
         let holder = this.holders.get(uri);
 
         if (holder === undefined) {
-            holder = { editors: [], sync: new DocumentSync(this.service, uri, languageId, editor), languageId };
+            holder = { editors: [], served: [], sync: null, languageId };
             this.holders.set(uri, holder);
         }
 
         holder.editors.push(editor);
+
+        if (serve) {
+            holder.served.push(editor);
+            holder.sync ??= new DocumentSync(this.service, uri, languageId, editor);
+        }
+
         let released = false;
 
         return {
             uri,
-            service: this.service,
+            service: serve ? this.service : UNSERVED,
             get ready() {
-                return holder.sync.ready;
+                return serve ? (holder.sync?.ready ?? Promise.resolve()) : Promise.resolve();
             },
             release: () => {
                 if (!released) {
@@ -273,26 +371,38 @@ export class ProjectLanguage {
         }
 
         holder.editors.splice(holder.editors.indexOf(editor), 1);
-        const next = holder.editors[0];
 
-        if (next === undefined) {
-            holder.sync.dispose();
+        if (holder.served.includes(editor)) {
+            holder.served.splice(holder.served.indexOf(editor), 1);
+        }
+
+        const { sync } = holder;
+
+        if (holder.editors.length === 0) {
             this.holders.delete(uri);
+        }
 
-            void holder.sync.ready
+        if (sync === null || sync.editor !== editor) {
+            return;
+        }
+
+        sync.dispose();
+        const next = holder.served[0];
+
+        // The editor that sent the changes is gone; the next served one takes over and opens the document with its own text.
+        holder.sync = next === undefined ? null : new DocumentSync(this.service, uri, holder.languageId, next);
+
+        if (holder.sync === null) {
+            void sync.ready
                 .catch(() => undefined)
                 .then(() => {
-                    if (this.holders.has(uri)) {
+                    if (this.holders.get(uri)?.sync) {
                         return undefined;
                     }
 
                     return this.service.closeDocument(uri);
                 })
                 .catch(() => undefined);
-        } else if (holder.sync.editor === editor) {
-            // The editor that sent the changes is gone; the next one takes over and opens the document with its own text.
-            holder.sync.dispose();
-            holder.sync = new DocumentSync(this.service, uri, holder.languageId, next);
         }
     }
 
@@ -302,9 +412,16 @@ export class ProjectLanguage {
         }
 
         this.disposed = true;
+        for (const subscription of this.subscriptions) {
+            subscription.dispose();
+        }
         disposeSnippetTransforms(this);
 
         for (const [uri, holder] of this.holders) {
+            if (holder.sync === null) {
+                continue;
+            }
+
             holder.sync.dispose();
 
             void holder.sync.ready