@adecore/editor-react 0.42.0 → 0.43.0

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.js

@@ -198,7 +198,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) {
       // Resolving can add the import an item needs; an item that cannot be resolved is still inserted as it is.
@@ -482,7 +482,6 @@ export class CompletionFeature {
   afterInsert(item, commit, lineBefore) {
     const {
       editor,
-      project,
       uri,
       signature
     } = this.language;
@@ -508,7 +507,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);
     }
   }
   /*
@@ -519,13 +518,12 @@ export class CompletionFeature {
   async resolveNow(item, signal) {
     const {
       editor,
-      project,
       uri
     } = this.language;
     try {
       return {
         ...item,
-        ...(await project.service.resolveCompletion(uri, item, {
+        ...(await this.language.service.resolveCompletion(uri, item, {
           signal
         }))
       };
@@ -535,14 +533,14 @@ export class CompletionFeature {
       }
     }
     try {
-      const fresh = itemsOf(await project.service.completion(uri, editor.getCaret(), {
+      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, {
+        ...(await this.language.service.resolveCompletion(uri, fresh, {
           signal
         }).catch(() => fresh))
       };
@@ -672,17 +670,15 @@ export class CompletionFeature {
   }
   triggerCharacters() {
     const {
-      project,
       uri
     } = this.language;
-    return project.service.providerOptions(METHOD, uri)?.triggerCharacters ?? [];
+    return this.language.service.providerOptions(METHOD, uri)?.triggerCharacters ?? [];
   }
   beginRequest(context, delay) {
     const {
-      project,
       uri
     } = this.language;
-    if (!project.service.supports(METHOD, uri)) {
+    if (!this.language.service.supports(METHOD, uri)) {
       return;
     }
     this.timers.clear(this.requestTimer);
@@ -701,7 +697,7 @@ export class CompletionFeature {
     this.controller = controller;
     let normalized;
     try {
-      const result = await project.service.completion(uri, position, context, {
+      const result = await this.language.service.completion(uri, position, context, {
         signal: controller.signal
       });
       if (request !== this.request || this.controller !== controller || controller.signal.aborted) {
@@ -805,20 +801,19 @@ export class CompletionFeature {
   }
   scheduleResolve() {
     const {
-      project,
       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;
     }
     const request = this.request;
     this.resolveTimer = this.timers.set(() => {
       const controller = new AbortController();
       this.resolving = controller;
-      void project.service.resolveCompletion(uri, entry.item, {
+      void this.language.service.resolveCompletion(uri, entry.item, {
         signal: controller.signal
       }).then(item => {
         this.resolved.set(entry.item, {

package/dist/context-menu-rows.d.ts

@@ -1,6 +1,6 @@
 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;
     readonly method: string;

package/dist/context-menu-rows.js

@@ -24,6 +24,10 @@ const REFERENCES = [{
   id: 'callHierarchy',
   method: 'textDocument/prepareCallHierarchy',
   shortcut: 'callHierarchy'
+}, {
+  id: 'typeHierarchy',
+  method: 'textDocument/prepareTypeHierarchy',
+  shortcut: 'typeHierarchy'
 }];
 const CHANGES = [{
   id: 'renameSymbol',

package/dist/definition-link.js

@@ -25,8 +25,8 @@ export function followModKey(apple, onHeld) {
 }
 /*
  * The name under the pointer drawn as a link while Cmd (Ctrl elsewhere) is held and a server knows where it
- * is defined, which is what a Mod+click on it follows. The editor only says where the pointer is, so the
- * key comes from the window.
+ * is defined, which is what a Mod+click on it follows. A document link under the pointer goes first. The
+ * editor only says where the pointer is, so the key comes from the window.
  */
 export class DefinitionLinkFeature {
   language;
@@ -71,13 +71,23 @@ export class DefinitionLinkFeature {
     const {
       pointer
     } = this;
-    if (!this.held || pointer === null || !this.language.project.service.supports('textDocument/definition', this.language.uri)) {
+    const link = pointer === null ? null : this.language.links.rangeAt(pointer);
+    if (this.held && link !== null) {
+      const key = `link:${link.start.line}:${link.start.character}`;
+      if (key !== this.shownKey) {
+        this.clear();
+        this.shownKey = key;
+        this.drawn = true;
+        this.language.editor.setLink(link);
+      }
+      return;
+    }
+    if (!this.held || pointer === null || !this.language.service.supports('textDocument/definition', this.language.uri)) {
       this.clear();
       return;
     }
     const {
       editor,
-      project,
       uri
     } = this.language;
     const line = lineTextOf(editor, pointer.line);
@@ -95,7 +105,7 @@ export class DefinitionLinkFeature {
     const request = ++this.request;
     const controller = new AbortController();
     this.lookup = controller;
-    project.service.definition(uri, pointer, {
+    this.language.service.definition(uri, pointer, {
       signal: controller.signal
     }).then(result => {
       if (request === this.request && locationsOf(result).length > 0) {

package/dist/document-colors.d.ts

@@ -0,0 +1,24 @@
+import type { Color, ColorInformation, ColorPresentation, TextEdit } from '@adecore/lsp';
+import type { EditorLanguage } from './editor-language.ts';
+import { type Timers } from './timers.ts';
+export declare function cssColorOf(color: Color): string;
+export declare function colorOfHex(value: string): Color | null;
+export declare function presentationEdits(presentation: ColorPresentation, information: ColorInformation): TextEdit[];
+export declare class DocumentColorsFeature {
+    private readonly language;
+    private colors;
+    private readonly query;
+    private enabled;
+    constructor(language: EditorLanguage, timers?: Timers);
+    get supported(): boolean;
+    all(): readonly ColorInformation[];
+    configure(settings: {
+        readonly enabled?: boolean;
+    }): void;
+    presentations(information: ColorInformation, color?: Color): Promise<ColorPresentation[]>;
+    apply(presentation: ColorPresentation, information: ColorInformation): boolean;
+    private show;
+    private pressed;
+    private open;
+    private choose;
+}