@adecore/editor-react 0.42.0 → 0.44.0

package/dist/call-hierarchy.d.ts

@@ -9,6 +9,7 @@ export declare class CallHierarchyFeature {
     private nodes;
     private roots;
     private prepared;
+    private position;
     private direction;
     private controller;
     private epoch;
@@ -17,6 +18,7 @@ export declare class CallHierarchyFeature {
     constructor(language: EditorLanguage, timers?: Timers);
     get isOpen(): boolean;
     get supported(): boolean;
+    get typesSupported(): boolean;
     open(position?: EditorPosition, direction?: CallDirection): Promise<void>;
     close(): void;
     setDirection(direction: CallDirection): void;
@@ -31,6 +33,7 @@ export declare class CallHierarchyFeature {
     private mounted;
     private patch;
     private load;
+    private childrenOf;
     private preview;
     private hasAncestor;
     private key;

package/dist/call-hierarchy.js

@@ -1,6 +1,6 @@
 import { StaleResultError } from '@adecore/lsp';
 import { KEY_PRIORITY } from './key-priority.js';
-import { CALL_LEVEL_LIMIT, childrenOf, moreIdOf, rootsOf, rowsOf, statusIdOf, stepsOf, targetOf } from './call-hierarchy-model.js';
+import { CALL_LEVEL_LIMIT, childrenOf, isTypeDirection, moreIdOf, rootsOf, rowsOf, statusIdOf, stepsOf, targetOf, typeChildrenOf } from './call-hierarchy-model.js';
 import { PEEK_HEIGHT } from './peek.js';
 import { snippetOf } from './peek-model.js';
 import { isShortcut } from './shortcut-keys.js';
@@ -8,6 +8,7 @@ import { messageOf } from './error-message.js';
 import { realTimers, revealRow } from './timers.js';
 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;
 const OWNER = 'call-hierarchy';
@@ -24,6 +25,7 @@ export class CallHierarchyFeature {
   nodes = new Map();
   roots = [];
   prepared = [];
+  position = null;
   direction = 'incoming';
   controller = new AbortController();
   /* Raised whenever the tree starts over or closes, so an answer for the tree that was never lands in the one that is. */
@@ -37,11 +39,13 @@ export class CallHierarchyFeature {
       editor
     } = language;
     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] = 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;
       }
@@ -60,35 +64,45 @@ export class CallHierarchyFeature {
   /* Whether a server of this document answers the three requests the tree is made of. */
   get supported() {
     const {
-      project,
+      service,
       uri
     } = this.language;
-    const {
-      service
-    } = project;
     return service.prepareCallHierarchy !== undefined && service.incomingCalls !== undefined && service.outgoingCalls !== undefined && service.supports(PREPARE, uri);
   }
-  /* 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() {
+    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 = this.language.editor.getCaret(), direction = 'incoming') {
     const {
       editor,
-      project,
+      service,
       uri
     } = this.language;
-    if (!this.supported) {
-      this.tell(this.say('unavailable'));
+    const types = isTypeDirection(direction);
+    if (!(types ? this.typesSupported : this.supported)) {
+      this.tell(this.say(types ? 'typesUnavailable' : 'unavailable'));
       return;
     }
     this.close();
     const epoch = this.epoch;
     let items;
     try {
-      items = await project.service.prepareCallHierarchy(uri, position, {
+      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', {
+        this.tell(this.say(types ? 'typesFailed' : 'failed', {
           message: messageOf(error)
         }));
       }
@@ -98,11 +112,12 @@ export class CallHierarchyFeature {
       return;
     }
     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];
@@ -143,12 +158,16 @@ export class CallHierarchyFeature {
     this.language.editor.setInputPopup(null);
     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) {
     const view = this.language.popups.getState().callHierarchy;
     if (view === null || view.direction === direction) {
       return;
     }
+    if (isTypeDirection(direction) !== isTypeDirection(view.direction)) {
+      void this.open(this.position ?? undefined, direction);
+      return;
+    }
     this.reset();
     this.direction = direction;
     this.seed();
@@ -309,11 +328,9 @@ export class CallHierarchyFeature {
       return;
     }
     const {
-      service,
       i18n
     } = this.language.project;
     const {
-      uri,
       editor
     } = this.language;
     const {
@@ -329,11 +346,10 @@ export class CallHierarchyFeature {
       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);
       }
@@ -360,6 +376,22 @@ export class CallHierarchyFeature {
       });
     }
   }
+  async childrenOf(direction, node, options) {
+    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)) ?? []);
+    }
+  }
   async preview(node, site) {
     const {
       project

package/dist/clipboard-history.d.ts

@@ -0,0 +1,31 @@
+export interface ClipboardEntry {
+    readonly text: string;
+    readonly wholeLines: boolean;
+    readonly at: number;
+}
+export interface ClipboardHistoryOptions {
+    readonly limit?: number;
+    readonly maxLength?: number;
+    readonly entries?: readonly ClipboardEntry[];
+    onChange?(entries: readonly ClipboardEntry[]): void;
+    readonly clock?: () => number;
+}
+export declare class ClipboardHistory {
+    private readonly limit;
+    private readonly maxLength;
+    private readonly onChange;
+    private readonly clock;
+    private readonly listeners;
+    private list;
+    constructor(options?: ClipboardHistoryOptions);
+    get entries(): readonly ClipboardEntry[];
+    add(text: string, options?: {
+        readonly wholeLines?: boolean;
+    }): void;
+    remove(entry: ClipboardEntry): void;
+    promote(entry: ClipboardEntry): void;
+    clear(): void;
+    subscribe(listener: () => void): () => void;
+    private change;
+    private trimmed;
+}

package/dist/clipboard-history.js

@@ -0,0 +1,70 @@
+/* The texts copied or cut in the editors of a project, newest first, for Paste from History. */
+export class ClipboardHistory {
+  limit;
+  maxLength;
+  onChange;
+  clock;
+  listeners = new Set();
+  list;
+  constructor(options = {}) {
+    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() {
+    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, options = {}) {
+    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) {
+    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) {
+    if (this.list.includes(entry) && this.list[0] !== entry) {
+      this.change([entry, ...this.list.filter(other => other !== entry)]);
+    }
+  }
+  clear() {
+    if (this.list.length > 0) {
+      this.change([]);
+    }
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+  change(entries) {
+    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. */
+  trimmed(entries) {
+    const kept = [];
+    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/dist/code-actions.d.ts

@@ -1,5 +1,5 @@
 import { type ActionEntry } from './code-actions-model.ts';
-import type { Problem } from './diagnostics-model.ts';
+import { type Problem } from './diagnostics-model.ts';
 import type { EditorLanguage } from './editor-language.ts';
 import { type Timers } from './timers.ts';
 export declare class CodeActionsFeature {
@@ -14,6 +14,8 @@ export declare class CodeActionsFeature {
     quickFixFor(problem: Problem): Promise<void>;
     organizeImports(): Promise<void>;
     formatDocument(): Promise<void>;
+    get formatsSelection(): boolean;
+    formatSelection(): Promise<void>;
     list(only: readonly string[]): Promise<ActionEntry[] | null>;
     private ask;
     private request;

package/dist/code-actions.js

@@ -1,6 +1,7 @@
 import { ErrorCodes, LspError, StaleResultError } from '@adecore/lsp';
 import { KEY_PRIORITY } from './key-priority.js';
 import { ACTION_GROUPS, REFACTOR_GROUPS, actionsOf, diagnosticsAt, fixableOnLine, isHint, mergeEntries, previewOf } from './code-actions-model.js';
+import { comparePositions } from './diagnostics-model.js';
 import { Refresher } from './refresher.js';
 import { isShortcut } from './shortcut-keys.js';
 import { realTimers } from './timers.js';
@@ -64,7 +65,7 @@ export class CodeActionsFeature {
     });
   }
   get supported() {
-    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. */
   open() {
@@ -121,15 +122,14 @@ export class CodeActionsFeature {
   async formatDocument() {
     const {
       editor,
-      project,
       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, {
+      const edits = await this.language.service.formatting(uri, {
         ...editor.getIndentation()
       });
       if (edits !== null && edits.length > 0 && !editor.applyEdits(edits.map(edit => ({
@@ -142,6 +142,48 @@ export class CodeActionsFeature {
       this.fail(error);
     }
   }
+  /* Whether a server formats a part of this document, so `formatSelection` has something to ask. */
+  get formatsSelection() {
+    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() {
+    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) {
     if (!this.supported) {
@@ -206,7 +248,6 @@ export class CodeActionsFeature {
   /* Asks the servers; null when they could not answer, with the reason said aloud for a request a person made. */
   async request(range, triggerKind, options = {}) {
     const {
-      project,
       uri,
       diagnostics
     } = this.language;
@@ -224,7 +265,7 @@ export class CodeActionsFeature {
         } : {}),
         triggerKind: triggerKind
       };
-      const entries = actionsOf(await project.service.codeActions(uri, range, context, {
+      const entries = actionsOf(await this.language.service.codeActions(uri, range, context, {
         signal
       }), order);
       // A server may answer with more than the kinds asked for.
@@ -283,16 +324,15 @@ export class CodeActionsFeature {
       return known;
     }
     const {
-      project,
       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, {
+        result = await this.language.service.resolveCodeAction(uri, action, {
           signal
         });
       } catch (error) {
@@ -383,7 +423,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/dist/code-vision.js

@@ -111,7 +111,7 @@ export class CodeVisionFeature {
     this.plan();
   }
   get canCount() {
-    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. */
   plan() {
@@ -128,14 +128,13 @@ export class CodeVisionFeature {
   }
   async count(declaration) {
     const {
-      project,
       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, {
+      const locations = await this.language.service.references(uri, declaration.position, false, {
         signal: controller.signal,
         parallel: true
       });

package/dist/completion.d.ts

@@ -1,5 +1,26 @@
+import { type CompletionItem } from '@adecore/lsp';
+import type { EditorPosition } from '@adecore/editor';
 import type { EditorLanguage } from './editor-language.ts';
 import { type Timers } from './timers.ts';
+/** A row a source of the editor offers beside the language server's. */
+export interface LocalCompletionItem {
+    /** The label, kind, detail, documentation, filter text and sort text of the row; its edit range is the typed prefix on the caret's line, ending at the caret. */
+    readonly item: CompletionItem;
+    /** Runs instead of the insertion: the source inserts the row itself. */
+    accept(): void;
+}
+/** What a source is asked for when the list is requested. */
+export interface CompletionRequest {
+    readonly position: EditorPosition;
+    /** Whether the person asked for the list with the keyboard. */
+    readonly explicit: boolean;
+    readonly triggerCharacter?: string;
+}
+/** Rows that come from the editor itself, such as templates, merged into the list of the language server. */
+export interface CompletionSource {
+    /** Synchronous and cheap; asked on every request of the list. */
+    items(request: CompletionRequest): readonly LocalCompletionItem[];
+}
 export declare class CompletionFeature {
     private readonly language;
     private readonly timers;
@@ -24,9 +45,16 @@ export declare class CompletionFeature {
     private acceptSequence;
     private disposed;
     private readonly resolved;
+    private readonly sources;
+    private locals;
+    private shown;
     constructor(language: EditorLanguage, timers?: Timers);
     get isOpen(): boolean;
     invoke(): void;
+    /** Adds rows to every list, also in a document without a language server. Returns the function that takes the source away again. */
+    addSource(source: CompletionSource): () => void;
+    /** Opens the list with only these rows, the typed prefix starting at `start`, as Insert Live Template does. */
+    showItems(items: readonly LocalCompletionItem[], start: EditorPosition): void;
     move(delta: number): void;
     accept(replace: boolean, index?: number, commit?: string): Promise<void>;
     private insert;