@adecore/editor-react 0.41.1 → 0.43.0

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);
         });
     }
 

package/src/testing.ts

@@ -38,7 +38,24 @@ import {
     type SignatureHelpContext,
     type TextEdit,
     type WorkspaceEdit,
-    type WorkspaceSymbolResult
+    type WorkspaceSymbolResult,
+    type Color,
+    type ColorInformation,
+    type ColorPresentation,
+    type DocumentLink,
+    type InlineCompletionContext,
+    type InlineCompletionResult,
+    type InlineValue,
+    type InlineValueContext,
+    type LinkedEditingRanges,
+    type Moniker,
+    type PreviousResultId,
+    type ServerMessage,
+    type ShowDocumentParams,
+    type ShowDocumentResult,
+    type TextDocumentSaveReason,
+    type TypeHierarchyItem,
+    type WorkspaceDiagnosticReport
 } from '@adecore/lsp';
 
 export { ManualTimers } from './timers.ts';
@@ -57,6 +74,8 @@ export class FakeLanguageService implements LanguageService {
     private readonly answers = new Map<string, (call: LanguageCall) => unknown>();
     private readonly diagnostics = new Set<(report: DiagnosticsReport) => void>();
     private readonly changes = new Set<(uri: string) => void>();
+    private readonly messages = new Set<(message: ServerMessage) => void>();
+    private showDocument: ((params: ShowDocumentParams) => Promise<ShowDocumentResult>) | null = null;
 
     respond(method: string, answer: (call: LanguageCall) => unknown, provider: ProviderOptions = {}): void {
         this.answers.set(method, answer);
@@ -271,4 +290,110 @@ export class FakeLanguageService implements LanguageService {
     resolveCodeLens(uri: string, lens: CodeLens, options: LanguageRequestOptions = {}): Promise<CodeLens> {
         return this.request<CodeLens>('codeLens/resolve', uri, lens, options);
     }
+
+    documentLinks(uri: string, options: LanguageRequestOptions = {}): Promise<DocumentLink[] | null> {
+        return this.request<DocumentLink[] | null>('textDocument/documentLink', uri, {}, options);
+    }
+
+    resolveDocumentLink(uri: string, link: DocumentLink, options: LanguageRequestOptions = {}): Promise<DocumentLink> {
+        return this.request<DocumentLink>('documentLink/resolve', uri, link, options);
+    }
+
+    documentColors(uri: string, options: LanguageRequestOptions = {}): Promise<ColorInformation[] | null> {
+        return this.request<ColorInformation[] | null>('textDocument/documentColor', uri, {}, options);
+    }
+
+    colorPresentations(uri: string, color: Color, range: Range, options: LanguageRequestOptions = {}): Promise<ColorPresentation[] | null> {
+        return this.request<ColorPresentation[] | null>('textDocument/colorPresentation', uri, { color, range }, options);
+    }
+
+    linkedEditingRanges(uri: string, position: Position, options: LanguageRequestOptions = {}): Promise<LinkedEditingRanges | null> {
+        return this.request<LinkedEditingRanges | null>('textDocument/linkedEditingRange', uri, { position }, options);
+    }
+
+    monikers(uri: string, position: Position, options: LanguageRequestOptions = {}): Promise<Moniker[] | null> {
+        return this.request<Moniker[] | null>('textDocument/moniker', uri, { position }, options);
+    }
+
+    prepareTypeHierarchy(uri: string, position: Position, options: LanguageRequestOptions = {}): Promise<TypeHierarchyItem[] | null> {
+        return this.request<TypeHierarchyItem[] | null>('textDocument/prepareTypeHierarchy', uri, { position }, options);
+    }
+
+    supertypes(uri: string, item: TypeHierarchyItem, options: LanguageRequestOptions = {}): Promise<TypeHierarchyItem[] | null> {
+        return this.request<TypeHierarchyItem[] | null>('typeHierarchy/supertypes', uri, { item }, options);
+    }
+
+    subtypes(uri: string, item: TypeHierarchyItem, options: LanguageRequestOptions = {}): Promise<TypeHierarchyItem[] | null> {
+        return this.request<TypeHierarchyItem[] | null>('typeHierarchy/subtypes', uri, { item }, options);
+    }
+
+    inlineValues(uri: string, range: Range, context: InlineValueContext, options: LanguageRequestOptions = {}): Promise<InlineValue[] | null> {
+        return this.request<InlineValue[] | null>('textDocument/inlineValue', uri, { range, context }, options);
+    }
+
+    inlineCompletions(
+        uri: string,
+        position: Position,
+        context: InlineCompletionContext,
+        options: LanguageRequestOptions = {}
+    ): Promise<InlineCompletionResult> {
+        return this.request<InlineCompletionResult>('textDocument/inlineCompletion', uri, { position, context }, options);
+    }
+
+    rangesFormatting(uri: string, ranges: readonly Range[], formatting: FormattingOptions, options: LanguageRequestOptions = {}): Promise<TextEdit[] | null> {
+        return this.request<TextEdit[] | null>('textDocument/rangesFormatting', uri, { ranges, options: formatting }, options);
+    }
+
+    async willSave(uri: string, reason: TextDocumentSaveReason = 1): Promise<void> {
+        this.calls.push({ method: 'textDocument/willSave', uri, params: { reason }, options: {} });
+    }
+
+    async willSaveWaitUntil(uri: string, reason: TextDocumentSaveReason = 1, options: LanguageRequestOptions = {}): Promise<TextEdit[] | null> {
+        return this.supports('textDocument/willSaveWaitUntil', uri)
+            ? this.request<TextEdit[] | null>('textDocument/willSaveWaitUntil', uri, { reason }, options)
+            : null;
+    }
+
+    workspaceDiagnostics(
+        uri: string,
+        previousResultIds: readonly PreviousResultId[] = [],
+        options: LanguageRequestOptions = {}
+    ): Promise<WorkspaceDiagnosticReport> {
+        return this.request<WorkspaceDiagnosticReport>('workspace/diagnostic', uri, { previousResultIds }, options);
+    }
+
+    async textDocumentContent(uri: string, options: LanguageRequestOptions = {}): Promise<string | null> {
+        if (!this.supports('workspace/textDocumentContent', uri)) {
+            return null;
+        }
+        return (await this.request<{ text: string } | null>('workspace/textDocumentContent', uri, { uri }, options))?.text ?? null;
+    }
+
+    onServerMessage(listener: (message: ServerMessage) => void): Disposable {
+        this.messages.add(listener);
+        return { dispose: () => this.messages.delete(listener) };
+    }
+
+    onShowDocument(handler: (params: ShowDocumentParams) => Promise<ShowDocumentResult>): Disposable {
+        this.showDocument = handler;
+        return {
+            dispose: () => {
+                if (this.showDocument === handler) {
+                    this.showDocument = null;
+                }
+            }
+        };
+    }
+
+    /* Sends a message as a server would. */
+    message(message: ServerMessage): void {
+        for (const listener of this.messages) {
+            listener(message);
+        }
+    }
+
+    /* Asks the host to show a document as a server would; false when nothing handles it. */
+    async show(params: ShowDocumentParams): Promise<boolean> {
+        return (await this.showDocument?.(params))?.success ?? false;
+    }
 }