@adecore/editor-react 0.42.0 → 0.43.0

package/src/WrapCard.tsx

@@ -0,0 +1,64 @@
+import { useLayoutEffect, useRef, useState, type KeyboardEvent } from 'react';
+import { useTranslation } from 'react-i18next';
+import type { EditorRect } from '@adecore/editor';
+import { Input } from '@adecore/ui';
+import { AnchoredPopup } from './AnchoredPopup.tsx';
+import type { EditorLanguage } from './editor-language.ts';
+import type { WrapView } from './popups.ts';
+
+/* The field for the abbreviation a selection is wrapped in: Enter wraps, Escape or leaving the field cancels. */
+export function WrapCard({ language, view, rect }: { language: EditorLanguage; view: WrapView; rect: EditorRect }) {
+    const { t } = useTranslation('editor');
+    const input = useRef<HTMLInputElement>(null);
+    const [value, setValue] = useState('');
+
+    useLayoutEffect(() => {
+        input.current?.focus();
+    }, []);
+
+    function onKeyDown(event: KeyboardEvent<HTMLInputElement>): void {
+        if (event.nativeEvent.isComposing) {
+            return;
+        }
+        if (event.key === 'Escape') {
+            event.preventDefault();
+            event.stopPropagation();
+            language.markup.cancelWrap();
+            language.editor.focus();
+        } else if (event.key === 'Enter') {
+            event.preventDefault();
+            event.stopPropagation();
+            if (value.trim() !== '') {
+                language.markup.submitWrap(value);
+            }
+        }
+    }
+
+    return (
+        <AnchoredPopup rect={rect} placement={{ prefer: 'above' }}>
+            <div className="flex w-[280px] flex-col gap-1.5 p-2">
+                <Input
+                    ref={input}
+                    size="sm"
+                    mono
+                    value={value}
+                    spellCheck={false}
+                    autoComplete="off"
+                    aria-label={t('language.markup.wrap')}
+                    aria-invalid={view.error !== null}
+                    placeholder={t('language.markup.placeholder')}
+                    onChange={(event) => setValue(event.target.value)}
+                    onKeyDown={onKeyDown}
+                    onBlur={() => language.markup.cancelWrap()}
+                />
+                {view.error !== null ? (
+                    <div role="alert" className="text-xs text-status-error">
+                        {view.error}
+                    </div>
+                ) : (
+                    <div className="text-xs text-text-muted">↵ {t('language.markup.apply')}</div>
+                )}
+            </div>
+        </AnchoredPopup>
+    );
+}

package/src/call-hierarchy-model.ts

@@ -1,7 +1,12 @@
-import type { CallHierarchyIncomingCall, CallHierarchyItem, CallHierarchyOutgoingCall, Range } from '@adecore/lsp';
+import type { CallHierarchyIncomingCall, CallHierarchyItem, CallHierarchyOutgoingCall, Range, TypeHierarchyItem } from '@adecore/lsp';
 
-/* Callers of a symbol, or the symbols it calls. */
-export type CallDirection = 'incoming' | 'outgoing';
+/* Callers of a symbol or the symbols it calls; or the super and sub types of a type, which the same tree draws. */
+export type CallDirection = 'incoming' | 'outgoing' | 'supertypes' | 'subtypes';
+
+/* Whether a direction walks a type hierarchy and not the calls. */
+export function isTypeDirection(direction: CallDirection): direction is 'supertypes' | 'subtypes' {
+    return direction === 'supertypes' || direction === 'subtypes';
+}
 
 /* The most calls of one level that are drawn at once; the rest wait behind a row that shows more. */
 export const CALL_LEVEL_LIMIT = 50;
@@ -103,6 +108,23 @@ export function childrenOf(direction: CallDirection, parent: CallNode, calls: re
     }));
 }
 
+/* The children of a node made from the types a server returned; a type has no call sites, so a row goes to the type itself. */
+export function typeChildrenOf(parent: CallNode, items: readonly TypeHierarchyItem[]): CallNode[] {
+    return items.map((item, index) => ({
+        id: `${parent.id}.${index}`,
+        parent: parent.id,
+        level: parent.level + 1,
+        item,
+        sites: [],
+        siteUri: null,
+        expanded: false,
+        load: 'idle',
+        error: null,
+        children: [],
+        shown: 0
+    }));
+}
+
 /* The lines the tree draws: every root, and under an expanded node its status, its calls and the row that shows more. */
 export function rowsOf(nodes: ReadonlyMap<string, CallNode>, roots: readonly string[]): CallRow[] {
     const rows: CallRow[] = [];

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

package/src/completion.ts

@@ -236,7 +236,7 @@ export class CompletionFeature {
 
         recentChoicesOf(this.language.languageId).record(entry.item);
         let item = this.resolved.get(entry.item) ?? entry.item;
-        const needsResolve = !this.resolved.has(entry.item) && project.service.providerOptions('completionItem/resolve', uri) !== undefined;
+        const needsResolve = !this.resolved.has(entry.item) && this.language.service.providerOptions('completionItem/resolve', uri) !== undefined;
         this.close();
 
         if (needsResolve) {
@@ -522,7 +522,7 @@ export class CompletionFeature {
 
     /* Parameter info for a call that was opened (or that the server asks for), then the item's own command. */
     private afterInsert(item: CompletionItem, commit: string | undefined, lineBefore: string): void {
-        const { editor, project, uri, signature } = this.language;
+        const { editor, uri, signature } = this.language;
         const { start } = editor.getSelection();
         const insideCall = start.character > 0 && editor.textInRange({ start: { line: start.line, character: start.character - 1 }, end: start }) === '(';
 
@@ -539,7 +539,7 @@ export class CompletionFeature {
         if (command.command === PARAMETER_HINTS_COMMAND) {
             signature.trigger();
         } else {
-            project.service.executeCommand(uri, command).catch(() => undefined);
+            this.language.service.executeCommand(uri, command).catch(() => undefined);
         }
     }
 
@@ -549,10 +549,10 @@ export class CompletionFeature {
      * suggestion is resolved in that one; an item that cannot be resolved is still inserted as it is.
      */
     private async resolveNow(item: CompletionItem, signal: AbortSignal): Promise<CompletionItem> {
-        const { editor, project, uri } = this.language;
+        const { editor, uri } = this.language;
 
         try {
-            return { ...item, ...(await project.service.resolveCompletion(uri, item, { signal })) };
+            return { ...item, ...(await this.language.service.resolveCompletion(uri, item, { signal })) };
         } catch (error) {
             if (!(error instanceof StaleResultError)) {
                 return item;
@@ -560,11 +560,11 @@ export class CompletionFeature {
         }
 
         try {
-            const fresh = itemsOf(await project.service.completion(uri, editor.getCaret(), { triggerKind: 1 }, { signal })).items.find(
+            const fresh = itemsOf(await this.language.service.completion(uri, editor.getCaret(), { triggerKind: 1 }, { signal })).items.find(
                 (candidate) => candidate.label === item.label && candidate.kind === item.kind
             );
 
-            return fresh === undefined ? item : { ...fresh, ...(await project.service.resolveCompletion(uri, fresh, { signal }).catch(() => fresh)) };
+            return fresh === undefined ? item : { ...fresh, ...(await this.language.service.resolveCompletion(uri, fresh, { signal }).catch(() => fresh)) };
         } catch {
             return item;
         }
@@ -703,15 +703,15 @@ export class CompletionFeature {
     }
 
     private triggerCharacters(): readonly string[] {
-        const { project, uri } = this.language;
+        const { uri } = this.language;
 
-        return project.service.providerOptions(METHOD, uri)?.triggerCharacters ?? [];
+        return this.language.service.providerOptions(METHOD, uri)?.triggerCharacters ?? [];
     }
 
     private beginRequest(context: CompletionContext, delay: number): void {
-        const { project, uri } = this.language;
+        const { uri } = this.language;
 
-        if (!project.service.supports(METHOD, uri)) {
+        if (!this.language.service.supports(METHOD, uri)) {
             return;
         }
 
@@ -729,7 +729,7 @@ export class CompletionFeature {
         let normalized: ReturnType<typeof itemsOf>;
 
         try {
-            const result = await project.service.completion(uri, position, context, { signal: controller.signal });
+            const result = await this.language.service.completion(uri, position, context, { signal: controller.signal });
 
             if (request !== this.request || this.controller !== controller || controller.signal.aborted) {
                 return;
@@ -839,12 +839,12 @@ export class CompletionFeature {
     }
 
     private scheduleResolve(): void {
-        const { project, uri } = this.language;
+        const { uri } = this.language;
         this.timers.clear(this.resolveTimer);
         this.resolving?.abort();
         const entry = this.ranked[this.active];
 
-        if (entry === undefined || this.resolved.has(entry.item) || project.service.providerOptions('completionItem/resolve', uri) === undefined) {
+        if (entry === undefined || this.resolved.has(entry.item) || this.language.service.providerOptions('completionItem/resolve', uri) === undefined) {
             return;
         }
 
@@ -854,7 +854,7 @@ export class CompletionFeature {
             const controller = new AbortController();
             this.resolving = controller;
 
-            void project.service
+            void this.language.service
                 .resolveCompletion(uri, entry.item, { signal: controller.signal })
                 .then((item) => {
                     this.resolved.set(entry.item, { ...entry.item, ...item });

package/src/context-menu-rows.ts

@@ -1,7 +1,7 @@
 import type { KeymapId } from '@adecore/editor/keymap';
 import type { NavigationKind } from './navigation.ts';
 
-export type MenuRowId = NavigationKind | 'peekReferences' | 'callHierarchy' | 'renameSymbol' | 'codeActions';
+export type MenuRowId = NavigationKind | 'peekReferences' | 'callHierarchy' | 'typeHierarchy' | 'renameSymbol' | 'codeActions';
 
 export interface MenuRowSpec {
     readonly id: MenuRowId;
@@ -19,7 +19,8 @@ const GO_TO: readonly MenuRowSpec[] = [
 
 const REFERENCES: readonly MenuRowSpec[] = [
     { id: 'peekReferences', method: 'textDocument/references', shortcut: 'peekReferences' },
-    { id: 'callHierarchy', method: 'textDocument/prepareCallHierarchy', shortcut: 'callHierarchy' }
+    { id: 'callHierarchy', method: 'textDocument/prepareCallHierarchy', shortcut: 'callHierarchy' },
+    { id: 'typeHierarchy', method: 'textDocument/prepareTypeHierarchy', shortcut: 'typeHierarchy' }
 ];
 
 const CHANGES: readonly MenuRowSpec[] = [