@adecore/editor-react 0.42.0 → 0.43.0

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

package/src/rename.ts

@@ -67,9 +67,9 @@ export class RenameFeature {
     }
 
     async start(): Promise<void> {
-        const { editor, project, uri } = this.language;
+        const { editor, uri } = this.language;
 
-        if (!project.service.supports(METHOD, uri)) {
+        if (!this.language.service.supports(METHOD, uri)) {
             this.tell('error', this.say('unavailable'));
 
             return;
@@ -77,11 +77,11 @@ export class RenameFeature {
 
         this.cancel();
         const caret = editor.getCaret();
-        const prepare = project.service.providerOptions(METHOD, uri)?.prepareProvider === true;
+        const prepare = this.language.service.providerOptions(METHOD, uri)?.prepareProvider === true;
         let answer: PrepareRenameResult;
 
         try {
-            answer = prepare ? await project.service.prepareRename(uri, caret) : { defaultBehavior: true };
+            answer = prepare ? await this.language.service.prepareRename(uri, caret) : { defaultBehavior: true };
         } catch (error) {
             if (!(error instanceof StaleResultError)) {
                 this.tell('error', this.say('nothing'));
@@ -127,7 +127,7 @@ export class RenameFeature {
         const { project, uri } = this.language;
 
         try {
-            const edit = await project.service.rename(uri, session.target.range.start, next);
+            const edit = await this.language.service.rename(uri, session.target.range.start, next);
 
             if (this.session !== session) {
                 return;
@@ -218,14 +218,14 @@ export class RenameFeature {
 
     /* Lights up the places the name has in this file, and counts them all; what the servers listed, or null when they did not. */
     private async light(session: Session): Promise<readonly Location[] | null> {
-        const { editor, project, uri } = this.language;
+        const { editor, uri } = this.language;
 
-        if (!project.service.supports('textDocument/references', uri)) {
+        if (!this.language.service.supports('textDocument/references', uri)) {
             return null;
         }
 
         try {
-            const locations = await project.service.references(uri, session.target.range.start, true);
+            const locations = await this.language.service.references(uri, session.target.range.start, true);
 
             if (this.session !== session || locations === null) {
                 return null;
@@ -277,14 +277,14 @@ export class RenameFeature {
 
     /* So a suggester knows a function from a variable; a rename on a use finds the kind through the declaration's place in this file. */
     private async kindOf(session: Session, locations: readonly Location[]): Promise<string | undefined> {
-        const { project, uri } = this.language;
+        const { uri } = this.language;
 
-        if (!project.service.supports('textDocument/documentSymbol', uri)) {
+        if (!this.language.service.supports('textDocument/documentSymbol', uri)) {
             return undefined;
         }
 
         try {
-            const symbols = await project.service.documentSymbols(uri, { signal: session.names.signal, parallel: true });
+            const symbols = await this.language.service.documentSymbols(uri, { signal: session.names.signal, parallel: true });
 
             return renameKindOf(symbols, session.original, [session.target.range, ...occurrencesOf(locations, uri).inFile]);
         } catch {

package/src/rendered-docs.ts

@@ -254,9 +254,9 @@ export class RenderedDocsFeature {
 
     /* Whether names in `{@link}` and `@see` can be followed, which takes a server that finds symbols by name. */
     get canFollow(): boolean {
-        const { project, uri } = this.language;
+        const { uri } = this.language;
 
-        return project.service.supports('workspace/symbol', uri);
+        return this.language.service.supports('workspace/symbol', uri);
     }
 
     /* Goes to what a link in a comment names. */

package/src/selection-ranges.ts

@@ -21,14 +21,14 @@ export function selectionChainOf(selection: SelectionRange): EditorRange[] {
  */
 export class SelectionRangesFeature {
     constructor(language: EditorLanguage) {
-        const { editor, project, uri } = language;
+        const { editor, uri } = language;
 
         editor.setSelectionRanges(async (positions) => {
-            if (!project.service.supports(METHOD, uri)) {
+            if (!language.service.supports(METHOD, uri)) {
                 return null;
             }
 
-            const chains = await project.service.selectionRanges(uri, positions);
+            const chains = await language.service.selectionRanges(uri, positions);
 
             return chains === null || chains.length !== positions.length ? null : chains.map(selectionChainOf);
         });

package/src/signature.ts

@@ -111,8 +111,8 @@ export class SignatureFeature {
     }
 
     private options(): { triggers: readonly string[]; retriggers: readonly string[] } | null {
-        const { project, uri } = this.language;
-        const options = project.service.providerOptions(METHOD, uri);
+        const { uri } = this.language;
+        const options = this.language.service.providerOptions(METHOD, uri);
 
         return options === undefined ? null : { triggers: options.triggerCharacters ?? [], retriggers: options.retriggerCharacters ?? [] };
     }
@@ -147,9 +147,9 @@ export class SignatureFeature {
     }
 
     private ask(context: Omit<SignatureHelpContext, 'activeSignatureHelp'>): void {
-        const { project, uri } = this.language;
+        const { uri } = this.language;
 
-        if (!project.service.supports(METHOD, uri)) {
+        if (!this.language.service.supports(METHOD, uri)) {
             return;
         }
 
@@ -160,7 +160,7 @@ export class SignatureFeature {
     }
 
     private async fetch(context: SignatureHelpContext, request: number): Promise<void> {
-        const { editor, project, uri } = this.language;
+        const { editor, uri } = this.language;
         const caret = editor.getCaret();
         this.controller?.abort();
         const controller = new AbortController();
@@ -168,7 +168,7 @@ export class SignatureFeature {
         let help: SignatureHelp | null;
 
         try {
-            help = await project.service.signatureHelp(uri, caret, context, { signal: controller.signal });
+            help = await this.language.service.signatureHelp(uri, caret, context, { signal: controller.signal });
         } catch {
             return;
         }

package/src/snippet-session.ts

@@ -5,7 +5,7 @@ import { acquireSnippetTransforms, type SnippetTransformLease } from './snippet-
 import { realTimers, type Timers } from './timers.ts';
 import { KEY_PRIORITY } from './key-priority.ts';
 import { MAX_TRANSFORM_CHARACTERS, type SnippetTransformJob } from './snippet-transform-protocol.ts';
-import type { EditorContentChange, EditorPosition, EditorRange, EditorTextChange } from '@adecore/editor';
+import type { EditorApplyEditsOptions, EditorContentChange, EditorPosition, EditorRange, EditorTextChange } from '@adecore/editor';
 import { comparePositions, endOfInsertion, rangeHolds, sameRange, shiftPosition } from './diagnostics-model.ts';
 import type { EditorLanguage } from './editor-language.ts';
 import { textBeforeOf } from './line-text.ts';
@@ -367,7 +367,12 @@ export class SnippetFeature {
     }
 
     /* Imports can touch a hull's edge; their affinity must differ from edits inside its active field. */
-    applyEdits(changes: readonly EditorContentChange[], token: number, extras: readonly EditorContentChange[] = []): boolean {
+    applyEdits(
+        changes: readonly EditorContentChange[],
+        token: number,
+        extras: readonly EditorContentChange[] = [],
+        options?: EditorApplyEditsOptions
+    ): boolean {
         const frame = this.frames.at(-1);
 
         const fits =
@@ -385,14 +390,14 @@ export class SnippetFeature {
         if (token !== this.generation || !fits) {
             this.end();
 
-            return this.language.editor.applyEdits(changes);
+            return this.language.editor.applyEdits(changes, options);
         }
 
         this.applying = true;
         this.extras = extras;
 
         try {
-            return this.language.editor.applyEdits(changes);
+            return this.language.editor.applyEdits(changes, options);
         } finally {
             this.applying = false;
             this.extras = [];

package/src/symbol-picker.ts

@@ -36,16 +36,16 @@ export class SymbolPickerFeature {
     }
 
     async open(): Promise<void> {
-        const { project, uri, popups } = this.language;
+        const { uri, popups } = this.language;
 
-        if (!project.service.supports('textDocument/documentSymbol', uri)) {
+        if (!this.language.service.supports('textDocument/documentSymbol', uri)) {
             this.language.project.host.notify?.({ id: TOAST_ID, kind: 'error', title: this.language.project.i18n.t('editor:language.symbols.unavailable') });
 
             return;
         }
 
         try {
-            const entries = entriesOf(await project.service.documentSymbols(uri));
+            const entries = entriesOf(await this.language.service.documentSymbols(uri));
             popups.setState({ symbols: { file: basenameOf(this.language.uri), entries } });
         } catch (error) {
             if (!(error instanceof StaleResultError)) {
@@ -79,13 +79,13 @@ export class SymbolPickerFeature {
 
     /* The symbols of the project that answer to a name, which is a request to the server and so waits for a pause in the typing. */
     async search(text: string, signal: AbortSignal): Promise<WorkspaceEntry[]> {
-        const { project, uri } = this.language;
+        const { uri } = this.language;
 
-        if (text === '' || !project.service.supports('workspace/symbol', uri)) {
+        if (text === '' || !this.language.service.supports('workspace/symbol', uri)) {
             return [];
         }
 
-        return workspaceEntriesOf(await project.service.workspaceSymbols(uri, text, { signal }));
+        return workspaceEntriesOf(await this.language.service.workspaceSymbols(uri, text, { signal }));
     }
 
     goToWorkspace(entry: WorkspaceEntry): void {

package/src/symbols.ts

@@ -1,4 +1,4 @@
-import type { EditorBlock } from '@adecore/editor';
+import type { EditorBlock, EditorPosition } from '@adecore/editor';
 import type { DocumentSymbol, DocumentSymbolResult, Range, SymbolInformation } from '@adecore/lsp';
 import type { EditorLanguage } from './editor-language.ts';
 import { Refresher } from './refresher.ts';
@@ -55,6 +55,29 @@ export function symbolSpansOf(result: DocumentSymbolResult): SymbolSpan[] {
     return (result as SymbolInformation[]).map((symbol) => ({ name: symbol.name, kind: symbol.kind, range: symbol.location.range }));
 }
 
+function declarationsOf(result: DocumentSymbolResult): EditorPosition[] {
+    if (result === null || result.length === 0) {
+        return [];
+    }
+
+    if (!('range' in result[0]!)) {
+        return (result as SymbolInformation[]).map((symbol) => symbol.location.range.start);
+    }
+
+    const stops: EditorPosition[] = [];
+
+    const visit = (symbols: readonly DocumentSymbol[]): void => {
+        for (const symbol of symbols) {
+            stops.push((symbol.selectionRange ?? symbol.range).start);
+            visit(symbol.children ?? []);
+        }
+    };
+
+    visit(result as DocumentSymbol[]);
+
+    return stops;
+}
+
 /* A line a declaration can have above it: blank, a comment, or an attribute. A bare `#` is no comment, since it heads a Markdown section. */
 const PRELUDE = /^\s*(?:$|\/\/|\/\*|\*|#\[)/;
 
@@ -121,18 +144,20 @@ export class SymbolsFeature {
     private readonly listeners = new Set<(result: DocumentSymbolResult) => void>();
 
     constructor(language: EditorLanguage, timers: Timers = realTimers) {
-        const { editor, project, uri } = language;
+        const { editor, uri } = language;
 
         this.refresher = new Refresher(
             async (signal) => {
-                if (!project.service.supports(METHOD, uri)) {
+                if (!language.service.supports(METHOD, uri)) {
                     return;
                 }
 
-                const result = await project.service.documentSymbols(uri, { signal });
+                const result = await language.service.documentSymbols(uri, { signal });
 
                 if (!signal.aborted) {
                     editor.setBlocks(result === null ? null : blocksOf(result, editor.getText()));
+                    const declarations = declarationsOf(result);
+                    editor.setDeclarations?.(declarations.length === 0 ? null : declarations);
 
                     for (const listener of [...this.listeners]) {
                         listener(result);
@@ -154,6 +179,7 @@ export class SymbolsFeature {
             providers();
             this.refresher.dispose();
             editor.setBlocks(null);
+            editor.setDeclarations?.(null);
         });
     }