@adecore/editor-react 0.42.0 → 0.44.0

package/src/call-hierarchy.ts

@@ -5,12 +5,14 @@ import type { EditorLanguage } from './editor-language.ts';
 import {
     CALL_LEVEL_LIMIT,
     childrenOf,
+    isTypeDirection,
     moreIdOf,
     rootsOf,
     rowsOf,
     statusIdOf,
     stepsOf,
     targetOf,
+    typeChildrenOf,
     type CallDirection,
     type CallNode,
     type CallRow
@@ -23,6 +25,7 @@ import { realTimers, revealRow, type Timers } from './timers.ts';
 
 const TOAST_ID = 'language-call-hierarchy';
 const PREPARE = 'textDocument/prepareCallHierarchy';
+const PREPARE_TYPES = 'textDocument/prepareTypeHierarchy';
 
 /* The row the panel stands in is as tall as a peek's, plus the segmented control that is a pixel taller than the peek's title bar. */
 export const CALL_HIERARCHY_HEIGHT = PEEK_HEIGHT + 2;
@@ -42,6 +45,7 @@ export class CallHierarchyFeature {
     private nodes = new Map<string, CallNode>();
     private roots: string[] = [];
     private prepared: CallHierarchyItem[] = [];
+    private position: EditorPosition | null = null;
     private direction: CallDirection = 'incoming';
     private controller = new AbortController();
 
@@ -58,11 +62,13 @@ export class CallHierarchyFeature {
 
         const offs = [
             language.onKey((event) => {
-                if (isShortcut(this.language.shortcuts.callHierarchy, event)) {
-                    if (this.isOpen) {
-                        this.setDirection(this.direction === 'incoming' ? 'outgoing' : 'incoming');
+                const calls = isShortcut(this.language.shortcuts.callHierarchy, event);
+                if (calls || isShortcut(this.language.shortcuts.typeHierarchy, event)) {
+                    const [first, second]: CallDirection[] = calls ? ['incoming', 'outgoing'] : ['supertypes', 'subtypes'];
+                    if (this.isOpen && isTypeDirection(this.direction) !== calls) {
+                        this.setDirection(this.direction === first ? second : first);
                     } else {
-                        void this.open();
+                        void this.open(undefined, first);
                     }
 
                     return true;
@@ -88,8 +94,7 @@ export class CallHierarchyFeature {
 
     /* Whether a server of this document answers the three requests the tree is made of. */
     get supported(): boolean {
-        const { project, uri } = this.language;
-        const { service } = project;
+        const { service, uri } = this.language;
 
         return (
             service.prepareCallHierarchy !== undefined &&
@@ -99,12 +104,28 @@ export class CallHierarchyFeature {
         );
     }
 
-    /* Opens the tree for the symbol at the position, on its callers unless told otherwise. */
+    /* Whether a server of this document answers the three requests of the type hierarchy. */
+    get typesSupported(): boolean {
+        const { service, uri } = this.language;
+
+        return (
+            service.prepareTypeHierarchy !== undefined &&
+            service.supertypes !== undefined &&
+            service.subtypes !== undefined &&
+            service.supports(PREPARE_TYPES, uri)
+        );
+    }
+
+    /*
+     * Opens the tree for the symbol at the position, on its callers unless told otherwise; `supertypes` or `subtypes`
+     * open the type hierarchy of the type at the position.
+     */
     async open(position: EditorPosition = this.language.editor.getCaret(), direction: CallDirection = 'incoming'): Promise<void> {
-        const { editor, project, uri } = this.language;
+        const { editor, service, uri } = this.language;
+        const types = isTypeDirection(direction);
 
-        if (!this.supported) {
-            this.tell(this.say('unavailable'));
+        if (!(types ? this.typesSupported : this.supported)) {
+            this.tell(this.say(types ? 'typesUnavailable' : 'unavailable'));
 
             return;
         }
@@ -114,10 +135,12 @@ export class CallHierarchyFeature {
         let items: CallHierarchyItem[] | null;
 
         try {
-            items = await project.service.prepareCallHierarchy!(uri, position, { signal: this.controller.signal });
+            const options = { signal: this.controller.signal };
+
+            items = types ? await service.prepareTypeHierarchy!(uri, position, options) : await service.prepareCallHierarchy!(uri, position, options);
         } catch (error) {
             if (epoch === this.epoch && !(error instanceof StaleResultError)) {
-                this.tell(this.say('failed', { message: messageOf(error) }));
+                this.tell(this.say(types ? 'typesFailed' : 'failed', { message: messageOf(error) }));
             }
 
             return;
@@ -128,13 +151,14 @@ export class CallHierarchyFeature {
         }
 
         if (items === null || items.length === 0) {
-            this.tell(this.say('none'));
+            this.tell(this.say(types ? 'typesNone' : 'none'));
 
             return;
         }
 
         this.language.peek.close();
         this.prepared = items;
+        this.position = position;
         this.direction = direction;
         this.seed();
         const active = this.roots[0]!;
@@ -171,7 +195,7 @@ export class CallHierarchyFeature {
         this.language.editor.focus();
     }
 
-    /* Starts the tree over from the same symbols for the other direction. */
+    /* Starts the tree over from the same symbols for the other direction; a switch between calls and types prepares the symbol again. */
     setDirection(direction: CallDirection): void {
         const view = this.language.popups.getState().callHierarchy;
 
@@ -179,6 +203,12 @@ export class CallHierarchyFeature {
             return;
         }
 
+        if (isTypeDirection(direction) !== isTypeDirection(view.direction)) {
+            void this.open(this.position ?? undefined, direction);
+
+            return;
+        }
+
         this.reset();
         this.direction = direction;
         this.seed();
@@ -331,22 +361,19 @@ export class CallHierarchyFeature {
             return;
         }
 
-        const { service, i18n } = this.language.project;
-        const { uri, editor } = this.language;
+        const { i18n } = this.language.project;
+        const { editor } = this.language;
         const { direction, epoch } = this;
         const options = { signal: this.controller.signal, parallel: true };
         this.patch(id, { load: 'loading', error: null });
 
         try {
-            const calls =
-                direction === 'incoming' ? await service.incomingCalls!(uri, node.item, options) : await service.outgoingCalls!(uri, node.item, options);
+            const children = await this.childrenOf(direction, node, options);
 
             if (epoch !== this.epoch) {
                 return;
             }
 
-            const children = childrenOf(direction, node, calls ?? []);
-
             for (const child of children) {
                 this.nodes.set(child.id, child);
             }
@@ -368,6 +395,21 @@ export class CallHierarchyFeature {
         }
     }
 
+    private async childrenOf(direction: CallDirection, node: CallNode, options: { signal: AbortSignal; parallel: boolean }): Promise<CallNode[]> {
+        const { service, uri } = this.language;
+
+        switch (direction) {
+            case 'incoming':
+                return childrenOf(direction, node, (await service.incomingCalls!(uri, node.item, options)) ?? []);
+            case 'outgoing':
+                return childrenOf(direction, node, (await service.outgoingCalls!(uri, node.item, options)) ?? []);
+            case 'supertypes':
+                return typeChildrenOf(node, (await service.supertypes!(uri, node.item, options)) ?? []);
+            case 'subtypes':
+                return typeChildrenOf(node, (await service.subtypes!(uri, node.item, options)) ?? []);
+        }
+    }
+
     private async preview(node: CallNode, site: number): Promise<void> {
         const { project } = this.language;
         const epoch = ++this.previewEpoch;

package/src/clipboard-history.ts

@@ -0,0 +1,102 @@
+/* One copy or cut, as the editors of a project made it. */
+export interface ClipboardEntry {
+    readonly text: string;
+    /* The copy took the lines of bare carets, which paste back above the lines of bare carets. */
+    readonly wholeLines: boolean;
+    readonly at: number;
+}
+
+export interface ClipboardHistoryOptions {
+    /* How many entries the history keeps; 100. */
+    readonly limit?: number;
+    /* The UTF-16 length all entries may take together; 10,000,000. The oldest go first, and the newest stays even when it alone is longer. */
+    readonly maxLength?: number;
+    /* What a host kept, newest first. */
+    readonly entries?: readonly ClipboardEntry[];
+    /* Told after every change, for a host that keeps the entries. */
+    onChange?(entries: readonly ClipboardEntry[]): void;
+    readonly clock?: () => number;
+}
+
+/* The texts copied or cut in the editors of a project, newest first, for Paste from History. */
+export class ClipboardHistory {
+    private readonly limit: number;
+    private readonly maxLength: number;
+    private readonly onChange: ((entries: readonly ClipboardEntry[]) => void) | undefined;
+    private readonly clock: () => number;
+    private readonly listeners = new Set<() => void>();
+    private list: readonly ClipboardEntry[];
+
+    constructor(options: ClipboardHistoryOptions = {}) {
+        this.limit = options.limit ?? 100;
+        this.maxLength = options.maxLength ?? 10_000_000;
+        this.onChange = options.onChange;
+        this.clock = options.clock ?? Date.now;
+        this.list = this.trimmed(options.entries ?? []);
+    }
+
+    /* Newest first. */
+    get entries(): readonly ClipboardEntry[] {
+        return this.list;
+    }
+
+    /* Puts a copy on top. The same text again moves up instead of being kept twice, and nothing is kept for an empty text. */
+    add(text: string, options: { readonly wholeLines?: boolean } = {}): void {
+        if (text === '') {
+            return;
+        }
+
+        const entry = { text, wholeLines: options.wholeLines === true, at: this.clock() };
+
+        this.change([entry, ...this.list.filter((other) => other.text !== text)]);
+    }
+
+    remove(entry: ClipboardEntry): void {
+        if (this.list.includes(entry)) {
+            this.change(this.list.filter((other) => other !== entry));
+        }
+    }
+
+    /* Moves an entry to the top, as choosing it does. */
+    promote(entry: ClipboardEntry): void {
+        if (this.list.includes(entry) && this.list[0] !== entry) {
+            this.change([entry, ...this.list.filter((other) => other !== entry)]);
+        }
+    }
+
+    clear(): void {
+        if (this.list.length > 0) {
+            this.change([]);
+        }
+    }
+
+    subscribe(listener: () => void): () => void {
+        this.listeners.add(listener);
+
+        return () => this.listeners.delete(listener);
+    }
+
+    private change(entries: readonly ClipboardEntry[]): void {
+        this.list = this.trimmed(entries);
+        this.onChange?.(this.list);
+        this.listeners.forEach((listener) => listener());
+    }
+
+    /* Keeps the newest entries that fit the limit and the total length. */
+    private trimmed(entries: readonly ClipboardEntry[]): readonly ClipboardEntry[] {
+        const kept: ClipboardEntry[] = [];
+        let length = 0;
+
+        for (const entry of entries.slice(0, this.limit)) {
+            length += entry.text.length;
+
+            if (kept.length > 0 && length > this.maxLength) {
+                break;
+            }
+
+            kept.push(entry);
+        }
+
+        return kept;
+    }
+}

package/src/code-actions.ts

@@ -13,7 +13,7 @@ import {
     type ActionEntry,
     type ActionGroup
 } from './code-actions-model.ts';
-import type { Problem } from './diagnostics-model.ts';
+import { comparePositions, type Problem } from './diagnostics-model.ts';
 import type { EditorLanguage } from './editor-language.ts';
 import type { PickGroup, PickPreview } from './popups.ts';
 import { Refresher } from './refresher.ts';
@@ -122,7 +122,7 @@ export class CodeActionsFeature {
     }
 
     get supported(): boolean {
-        return this.language.project.service.supports(METHOD, this.language.uri);
+        return this.language.service.supports(METHOD, this.language.uri);
     }
 
     /* The list under the caret, or under the selection's start. */
@@ -162,16 +162,16 @@ export class CodeActionsFeature {
     }
 
     async formatDocument(): Promise<void> {
-        const { editor, project, uri } = this.language;
+        const { editor, uri } = this.language;
 
-        if (!project.service.supports('textDocument/formatting', uri)) {
+        if (!this.language.service.supports('textDocument/formatting', uri)) {
             this.tell('error', this.say('noFormatter'));
 
             return;
         }
 
         try {
-            const edits = await project.service.formatting(uri, { ...editor.getIndentation() });
+            const edits = await this.language.service.formatting(uri, { ...editor.getIndentation() });
 
             if (edits !== null && edits.length > 0 && !editor.applyEdits(edits.map((edit) => ({ range: edit.range, text: edit.newText })))) {
                 this.tell('error', this.say('readOnly'));
@@ -181,6 +181,43 @@ export class CodeActionsFeature {
         }
     }
 
+    /* Whether a server formats a part of this document, so `formatSelection` has something to ask. */
+    get formatsSelection(): boolean {
+        return this.language.service.supports('textDocument/rangeFormatting', this.language.uri);
+    }
+
+    /*
+     * Formats what is selected, every selection in one request when the server formats several ranges at once and
+     * one by one otherwise; the whole document when nothing is selected.
+     */
+    async formatSelection(): Promise<void> {
+        const { editor, uri } = this.language;
+        const ranges = editor.getSelections().filter((range) => comparePositions(range.start, range.end) !== 0);
+        if (ranges.length === 0) {
+            await this.formatDocument();
+            return;
+        }
+        if (!this.formatsSelection) {
+            this.tell('error', this.say('noFormatter'));
+            return;
+        }
+        const { service } = this.language;
+        const formatting = { ...editor.getIndentation() };
+        try {
+            const edits =
+                service.rangesFormatting !== undefined && service.supports('textDocument/rangesFormatting', uri)
+                    ? await service.rangesFormatting(uri, ranges, formatting)
+                    : (await Promise.all(ranges.map((range) => service.rangeFormatting(uri, range, formatting, { parallel: true })))).flatMap(
+                          (list) => list ?? []
+                      );
+            if (edits !== null && edits.length > 0 && !editor.applyEdits(edits.map((edit) => ({ range: edit.range, text: edit.newText })))) {
+                this.tell('error', this.say('readOnly'));
+            }
+        } catch (error) {
+            this.fail(error);
+        }
+    }
+
     /* The actions of one kind for the selection, as entries a menu can list and `apply` runs. */
     list(only: readonly string[]): Promise<ActionEntry[] | null> {
         if (!this.supported) {
@@ -247,7 +284,7 @@ export class CodeActionsFeature {
 
     /* Asks the servers; null when they could not answer, with the reason said aloud for a request a person made. */
     private async request(range: EditorRange, triggerKind: number, options: RequestOptions = {}): Promise<ActionEntry[] | null> {
-        const { project, uri, diagnostics } = this.language;
+        const { uri, diagnostics } = this.language;
         const { only, signal, order } = options;
 
         try {
@@ -264,7 +301,7 @@ export class CodeActionsFeature {
                 triggerKind: triggerKind as 1 | 2
             };
 
-            const entries = actionsOf(await project.service.codeActions(uri, range, context, { signal }), order);
+            const entries = actionsOf(await this.language.service.codeActions(uri, range, context, { signal }), order);
 
             // A server may answer with more than the kinds asked for.
             return only ? entries.filter((entry) => only.some((kind) => entry.action.kind === kind || entry.action.kind?.startsWith(`${kind}.`))) : entries;
@@ -329,13 +366,13 @@ export class CodeActionsFeature {
             return known;
         }
 
-        const { project, uri } = this.language;
+        const { uri } = this.language;
         const { action } = entry;
         let result = action;
 
-        if (action.edit === undefined && project.service.providerOptions(METHOD, uri)?.resolveProvider === true) {
+        if (action.edit === undefined && this.language.service.providerOptions(METHOD, uri)?.resolveProvider === true) {
             try {
-                result = await project.service.resolveCodeAction(uri, action, { signal });
+                result = await this.language.service.resolveCodeAction(uri, action, { signal });
             } catch (error) {
                 if (isRefusal(error)) {
                     throw new ActionRefused((error as Error).message);
@@ -427,7 +464,7 @@ export class CodeActionsFeature {
             if (action.command?.command === INLINE_RENAME_COMMAND) {
                 await this.startRename(action.command);
             } else if (action.command !== undefined) {
-                await project.service.executeCommand(uri, action.command);
+                await this.language.service.executeCommand(uri, action.command);
             }
         } catch (error) {
             this.fail(error);

package/src/code-vision.ts

@@ -149,7 +149,7 @@ export class CodeVisionFeature {
     }
 
     private get canCount(): boolean {
-        return this.settings.usages && this.language.project.service.supports(REFERENCES, this.language.uri);
+        return this.settings.usages && this.language.service.supports(REFERENCES, this.language.uri);
     }
 
     /* Queues the declarations in view whose count is not from the current text, nearest the top of the view first. */
@@ -180,13 +180,13 @@ export class CodeVisionFeature {
     }
 
     private async count(declaration: CodeVisionDeclaration): Promise<void> {
-        const { project, uri } = this.language;
+        const { uri } = this.language;
         const controller = new AbortController();
         this.running.set(declaration.id, controller);
         const epoch = this.epoch;
 
         try {
-            const locations = await project.service.references(uri, declaration.position, false, { signal: controller.signal, parallel: true });
+            const locations = await this.language.service.references(uri, declaration.position, false, { signal: controller.signal, parallel: true });
 
             if (!this.disposed && epoch === this.epoch) {
                 this.counts.set(declaration.id, { count: distinctPlaces(locations ?? []), epoch });