@adecore/editor-react 0.42.0 → 0.43.0

package/dist/pick.js

@@ -10,8 +10,14 @@ export class PickFeature {
   language;
   timers;
   spec = null;
+  /* The rows as the spec gave them, or as `remove` left them; `ids` are those a query lets through. */
+  groups = [];
   ids = [];
   active = '';
+  query = '';
+  /* The rows chosen as a run or one by one, in list order, and the row a run of them grows from. */
+  chosen = [];
+  rangeAnchor = null;
   previewTimer;
   controller = null;
   /* The rows that said why they cannot be taken, by id. */
@@ -42,6 +48,10 @@ export class PickFeature {
     }
     this.spec = spec;
     this.refusals = new Map();
+    this.groups = spec.groups;
+    this.query = '';
+    this.chosen = [];
+    this.rangeAnchor = null;
     this.ids = ids;
     this.active = spec.active !== undefined && ids.includes(spec.active) ? spec.active : ids[0];
     this.publish(null);
@@ -59,16 +69,40 @@ export class PickFeature {
       pick: null
     });
   }
-  move(delta) {
+  /* Moves the active row; with `extend`, in a list of several choices, the rows between where the move began and the new row are chosen. */
+  move(delta, extend = false) {
+    if (this.ids.length === 0) {
+      return;
+    }
     const index = this.ids.indexOf(this.active);
-    this.activate(this.ids[Math.max(0, Math.min(this.ids.length - 1, index + delta))]);
+    const id = this.ids[Math.max(0, Math.min(this.ids.length - 1, index + delta))];
+    if (extend && this.spec?.multiple === true) {
+      this.extendTo(id);
+      return;
+    }
+    this.settle(id);
+  }
+  /* Makes `id` the only row the list is on. */
+  settle(id) {
+    const hadChosen = this.chosen.length > 0;
+    this.chosen = [];
+    this.rangeAnchor = null;
+    this.activate(id, hadChosen);
   }
-  /* Takes a row, by a click or Enter. */
-  choose(id) {
+  /* Takes a row, by a click or Enter. In a list of several choices a press with Shift chooses the run up to the row, and one with Mod adds or takes away the row. */
+  choose(id, modifiers = {}) {
     const spec = this.spec;
     if (spec === null || !this.ids.includes(id) || this.attempting) {
       return;
     }
+    if (spec.multiple === true && modifiers.range === true) {
+      this.extendTo(id);
+      return;
+    }
+    if (spec.multiple === true && modifiers.toggle === true) {
+      this.toggle(id);
+      return;
+    }
     if (spec.attempt === undefined) {
       this.close();
       spec.accept(id);
@@ -89,25 +123,99 @@ export class PickFeature {
       this.publish(null);
     });
   }
-  activate(id) {
-    if (id === this.active) {
+  activate(id, force = false) {
+    const moved = id !== this.active;
+    this.active = id;
+    if (moved) {
+      this.controller?.abort();
+      this.schedulePreview();
+    }
+    if (moved || force) {
+      this.publish(null);
+    }
+  }
+  extendTo(id) {
+    const anchor = this.rangeAnchor ?? this.active;
+    const first = this.ids.indexOf(anchor);
+    const last = this.ids.indexOf(id);
+    const run = this.ids.slice(Math.min(first, last), Math.max(first, last) + 1);
+    this.rangeAnchor = anchor;
+    this.chosen = run.length > 1 ? run : [];
+    this.activate(id, true);
+  }
+  toggle(id) {
+    const held = this.chosen.length > 0 ? this.chosen : [this.active];
+    const next = held.includes(id) ? held.filter(other => other !== id) : [...held, id];
+    this.chosen = this.ids.filter(other => next.includes(other));
+    this.rangeAnchor = id;
+    this.activate(id, true);
+  }
+  /* Enter: the chosen rows, or the active one when none is chosen. */
+  takeActive() {
+    const spec = this.spec;
+    if (spec?.acceptMany === undefined) {
+      this.choose(this.active);
       return;
     }
-    this.active = id;
+    const ids = this.chosen.length > 0 ? this.chosen : [this.active];
+    if (this.active !== '' && !this.attempting) {
+      this.close();
+      spec.acceptMany(ids);
+    }
+  }
+  visibleGroups() {
+    const query = this.query.toLowerCase();
+    if (query === '') {
+      return this.groups;
+    }
+    return this.groups.map(group => ({
+      ...group,
+      rows: group.rows.filter(row => (row.search ?? row.label).toLowerCase().includes(query))
+    })).filter(group => group.rows.length > 0);
+  }
+  /* The query changed: the rows it lets through, with the first of them active. */
+  requery(query) {
+    this.query = query;
+    this.ids = this.visibleGroups().flatMap(group => group.rows.map(row => row.id));
+    this.chosen = [];
+    this.rangeAnchor = null;
+    this.active = this.ids[0] ?? '';
+    this.controller?.abort();
+    this.publish(null);
+    this.schedulePreview();
+  }
+  /* Takes the chosen rows, or the active one, out of the list; the list closes when no row is left. */
+  removeChosen() {
+    const spec = this.spec;
+    if (spec?.remove === undefined || this.active === '') {
+      return;
+    }
+    const removed = this.chosen.length > 0 ? this.chosen : [this.active];
+    const index = this.ids.indexOf(removed[0]);
+    this.groups = spec.remove(removed);
+    if (this.groups.every(group => group.rows.length === 0)) {
+      this.close();
+      return;
+    }
+    this.ids = this.visibleGroups().flatMap(group => group.rows.map(row => row.id));
+    this.chosen = [];
+    this.rangeAnchor = null;
+    this.active = this.ids[Math.min(index, this.ids.length - 1)] ?? '';
     this.controller?.abort();
     this.publish(null);
     this.schedulePreview();
   }
   key(event) {
-    if (this.spec === null || event.metaKey || event.ctrlKey || event.altKey) {
+    const spec = this.spec;
+    if (spec === null || event.metaKey || event.ctrlKey || event.altKey) {
       return false;
     }
     switch (event.key) {
       case 'ArrowDown':
-        this.move(1);
+        this.move(1, event.shiftKey);
         return true;
       case 'ArrowUp':
-        this.move(-1);
+        this.move(-1, event.shiftKey);
         return true;
       case 'PageDown':
         this.move(8);
@@ -116,17 +224,26 @@ export class PickFeature {
         this.move(-8);
         return true;
       case 'Home':
-        this.activate(this.ids[0]);
-        return true;
       case 'End':
-        this.activate(this.ids[this.ids.length - 1]);
+        if (this.ids.length > 0) {
+          this.settle(event.key === 'Home' ? this.ids[0] : this.ids[this.ids.length - 1]);
+        }
         return true;
       case 'Enter':
-        this.choose(this.active);
+        this.takeActive();
         return true;
+      case 'Delete':
+        this.removeChosen();
+        return spec.remove !== undefined;
+      case 'Backspace':
+        if (this.query !== '') {
+          this.requery(this.query.slice(0, -1));
+          return true;
+        }
+        this.removeChosen();
+        return spec.remove !== undefined || spec.filter === true;
       case 'Tab':
         {
-          const spec = this.spec;
           if (spec.onTab !== undefined) {
             this.close();
             spec.onTab(event.shiftKey);
@@ -139,13 +256,17 @@ export class PickFeature {
         this.close();
         return true;
       default:
+        if (spec.filter === true && event.key.length === 1) {
+          this.requery(this.query + event.key);
+          return true;
+        }
         return false;
     }
   }
   schedulePreview() {
     const spec = this.spec;
     this.timers.clear(this.previewTimer);
-    if (spec?.preview === undefined) {
+    if (spec?.preview === undefined || this.active === '') {
       return;
     }
     const id = this.active;
@@ -174,10 +295,12 @@ export class PickFeature {
     this.language.popups.setState({
       pick: {
         anchor: spec.anchor,
-        groups: spec.groups,
+        groups: this.visibleGroups(),
         active: this.active,
         preview: shown,
-        title: spec.title ?? null
+        title: spec.title ?? null,
+        query: spec.filter === true ? this.query : null,
+        chosen: this.chosen
       }
     });
   }

package/dist/popups.d.ts

@@ -54,6 +54,7 @@ export interface PickRow {
     readonly label: string;
     readonly detail: string;
     readonly path?: boolean;
+    readonly search?: string;
 }
 export interface PickGroup {
     readonly title: string | null;
@@ -64,6 +65,7 @@ export interface PickPreview {
     readonly added: readonly string[];
     readonly note: string | null;
     readonly refusal?: string;
+    readonly kind?: 'diff' | 'text';
 }
 export interface PickView {
     readonly anchor: EditorPosition;
@@ -71,6 +73,8 @@ export interface PickView {
     readonly active: string;
     readonly preview: PickPreview | null;
     readonly title: string | null;
+    readonly query: string | null;
+    readonly chosen: readonly string[];
 }
 export interface RenameFileView {
     readonly uri: string;
@@ -134,6 +138,10 @@ export interface AuthorsView {
     readonly authorship: CodeAuthorship;
     readonly openCommit: (() => void) | null;
 }
+export interface WrapView {
+    readonly anchor: EditorPosition;
+    readonly error: string | null;
+}
 export interface PopupState {
     readonly hover: HoverView | null;
     readonly completion: CompletionView | null;
@@ -145,6 +153,7 @@ export interface PopupState {
     readonly symbols: SymbolsView | null;
     readonly menu: MenuView | null;
     readonly authors: AuthorsView | null;
+    readonly wrap: WrapView | null;
 }
 export type PopupStore = StoreApi<PopupState>;
 export declare function createPopupStore(): PopupStore;

package/dist/popups.js

@@ -10,6 +10,7 @@ export function createPopupStore() {
     callHierarchy: null,
     symbols: null,
     menu: null,
-    authors: null
+    authors: null,
+    wrap: null
   }));
 }

package/dist/project-language.d.ts

@@ -1,6 +1,8 @@
 import { type i18n } from 'i18next';
 import { type ApplyWorkspaceEditResult, type LanguageService, type WorkspaceEdit } from '@adecore/lsp';
 import type { Editor, EditorPosition } from '@adecore/editor';
+import { ClipboardHistory } from './clipboard-history.ts';
+import { EditLocations } from './edit-locations.ts';
 import { NavigationHistory, type Place } from './navigation-history.ts';
 import { ProjectProblems } from './project-problems.ts';
 import type { LanguageHost } from './host-types.ts';
@@ -10,6 +12,9 @@ export interface LanguageDocumentHandle {
     readonly ready: Promise<void>;
     release(): void;
 }
+export interface AcquireOptions {
+    readonly serve?: boolean;
+}
 export type FileOperationTarget = string | {
     readonly path: string;
     readonly directory?: boolean;
@@ -21,6 +26,8 @@ export declare class ProjectLanguage {
     readonly folder: string;
     readonly problems: ProjectProblems;
     readonly history: NavigationHistory;
+    readonly edits: EditLocations;
+    readonly clipboard: ClipboardHistory;
     private readonly holders;
     private readonly files;
     panelBodyHeight: number;
@@ -28,6 +35,8 @@ export declare class ProjectLanguage {
     private pendingCaret;
     private lastPlace;
     private disposed;
+    private readonly subscriptions;
+    private readonly workspaceResults;
     constructor(service: LanguageService, host?: LanguageHost);
     onPanelBodyChange(listener: (height: number) => void): () => void;
     resizePanelBody(height: number): void;
@@ -38,11 +47,19 @@ export declare class ProjectLanguage {
     willDeleteFiles(targets: readonly FileOperationTarget[]): Promise<WorkspaceEdit | null>;
     didDeleteFiles(targets: readonly FileOperationTarget[]): Promise<void>;
     readText(uri: string): Promise<string | null>;
+    pullWorkspaceProblems(uri: string, options?: {
+        readonly signal?: AbortSignal;
+    }): Promise<boolean>;
+    private showDocument;
     openPlace(place: Place): void;
     noteCaret(place: Place): void;
     jumpTo(place: Place): void;
     takeCaret(uri: string, line: number): EditorPosition | null;
-    acquire(uri: string, languageId: string, editor: Editor): LanguageDocumentHandle;
+    openEditors(): readonly {
+        uri: string;
+        editor: Editor;
+    }[];
+    acquire(uri: string, languageId: string, editor: Editor, options?: AcquireOptions): LanguageDocumentHandle;
     private release;
     dispose(): void;
 }

package/dist/project-language.js

@@ -1,11 +1,14 @@
 import { disposeSnippetTransforms } from './snippet-transform-queue.js';
 import i18next from 'i18next';
-import { fileUriToPath, pathToFileUri } from '@adecore/lsp';
+import { fileUriToPath, pathToFileUri, unservedLanguageService } from '@adecore/lsp';
+import { ClipboardHistory } from './clipboard-history.js';
+import { EditLocations } from './edit-locations.js';
 import { NavigationHistory } from './navigation-history.js';
 import { ProjectProblems, serviceProblems } from './project-problems.js';
 import { applyWorkspaceEdit } from './workspace-edit.js';
 import { relativeTo } from './paths.js';
 import { PANEL_BODY_HEIGHT } from './panel-size.js';
+const UNSERVED = unservedLanguageService();
 /* Sends one editor's edits to the document, holding them until the document is open. */
 class DocumentSync {
   ready;
@@ -86,6 +89,8 @@ export class ProjectLanguage {
   folder;
   problems;
   history = new NavigationHistory();
+  edits;
+  clipboard;
   holders = new Map();
   files;
   /* The body height of the peek and call hierarchy panels, shared by the editors of the project. */
@@ -94,14 +99,22 @@ export class ProjectLanguage {
   pendingCaret = null;
   lastPlace = null;
   disposed = false;
+  subscriptions;
+  /* The result id the server gave each document in its last workspace report, which the next asks with. */
+  workspaceResults = new Map();
   constructor(service, host = {}) {
     this.service = service;
     this.host = host;
     this.i18n = host.i18n ?? i18next;
     this.folder = host.folder ?? '';
     this.files = host.files ?? null;
+    this.edits = new EditLocations(host.editHistoryLimit);
+    this.clipboard = host.clipboard ?? new ClipboardHistory();
     this.panelBodyHeight = host.panelBodyHeight ?? PANEL_BODY_HEIGHT;
     this.problems = new ProjectProblems(host.problemSource ?? serviceProblems(service, uri => this.pathOfLocation(uri) ?? uri));
+    const shows = service.onShowDocument?.(params => this.showDocument(params));
+    const messages = host.onServerMessage === undefined ? undefined : service.onServerMessage?.(message => host.onServerMessage(message));
+    this.subscriptions = [shows, messages].flatMap(subscription => subscription === undefined ? [] : [subscription]);
   }
   /* Open panels of other editors of the project follow a resize. */
   onPanelBodyChange(listener) {
@@ -153,16 +166,86 @@ export class ProjectLanguage {
   }
   /* Tells the servers that files were deleted, once they are. */
   didDeleteFiles(targets) {
-    return this.service.didDeleteFiles?.(filesOf(targets)) ?? Promise.resolve();
+    const files = filesOf(targets);
+    this.edits.forget(uri => files.some(file => file.directory ? uri.startsWith(`${file.uri}/`) : uri === file.uri));
+    return this.service.didDeleteFiles?.(files) ?? Promise.resolve();
   }
-  /* The text of a file as it stands now: an open document's, else a draft's or the machine's; null when it is no text file. */
+  /*
+   * The text of a file as it stands now: an open document's, else a draft's or the machine's; null when it is no
+   * text file. A document of a scheme a server owns, such as a decompiled class, is read from that server.
+   */
   async readText(uri) {
-    const open = this.holders.get(uri)?.sync.text;
+    const open = this.holders.get(uri)?.editors[0]?.getText();
     if (open !== undefined) {
       return open;
     }
     const path = fileUriToPath(uri);
-    return path === null || this.files === null ? null : (await this.files.read(path))?.text ?? null;
+    if (path === null) {
+      return (await this.service.textDocumentContent?.(uri).catch(() => null)) ?? null;
+    }
+    return this.files === null ? null : (await this.files.read(path))?.text ?? null;
+  }
+  /*
+   * Asks the server of `uri` for the problems of every file it knows and lists them in `problems`, for a server that
+   * offers workspace diagnostics. A file the server reports as unchanged keeps what it had. False when no server offers them.
+   */
+  async pullWorkspaceProblems(uri, options = {}) {
+    const {
+      service
+    } = this;
+    if (service.workspaceDiagnostics === undefined || !service.supports('workspace/diagnostic', uri)) {
+      return false;
+    }
+    const previous = [...this.workspaceResults].map(([key, value]) => ({
+      uri: key,
+      value
+    }));
+    const report = await service.workspaceDiagnostics(uri, previous, options);
+    const server = this.host.serverNames?.(uri)[0] ?? 'workspace';
+    for (const item of report.items) {
+      if (item.resultId !== undefined) {
+        this.workspaceResults.set(item.uri, item.resultId);
+      }
+      if (item.kind === 'full') {
+        this.problems.report(this.pathOfLocation(item.uri) ?? item.uri, server, item.items);
+      }
+    }
+    return true;
+  }
+  /* Shows what a server asks for: a web address outside the editor, anything else as a place of the host. */
+  async showDocument(params) {
+    const web = /^(https?|mailto):/i.test(params.uri);
+    if (params.external === true || web) {
+      if (this.host.openExternal !== undefined) {
+        this.host.openExternal(params.uri);
+        return {
+          success: true
+        };
+      }
+      if (typeof window === 'undefined') {
+        return {
+          success: false
+        };
+      }
+      return {
+        success: window.open(params.uri, '_blank', 'noopener,noreferrer') !== null
+      };
+    }
+    if (this.host.openPlace === undefined) {
+      return {
+        success: false
+      };
+    }
+    this.openPlace({
+      uri: params.uri,
+      position: params.selection?.start ?? {
+        line: 0,
+        character: 0
+      }
+    });
+    return {
+      success: true
+    };
   }
   /*
    * Opens the file of a place on its line. A file opens on a line only, so the column is kept here until the editor
@@ -192,27 +275,40 @@ export class ProjectLanguage {
     this.pendingCaret = null;
     return pending.position;
   }
+  /* The editors that hold a document, one per uri in the order the documents were first opened. */
+  openEditors() {
+    return [...this.holders].flatMap(([uri, holder]) => holder.editors[0] === undefined ? [] : [{
+      uri,
+      editor: holder.editors[0]
+    }]);
+  }
   /* Opens `uri` for the editor, or joins the editors that already hold it. */
-  acquire(uri, languageId, editor) {
+  acquire(uri, languageId, editor, options = {}) {
     if (this.disposed) {
       throw new Error('The project language is disposed');
     }
+    const serve = options.serve ?? true;
     let holder = this.holders.get(uri);
     if (holder === undefined) {
       holder = {
         editors: [],
-        sync: new DocumentSync(this.service, uri, languageId, editor),
+        served: [],
+        sync: null,
         languageId
       };
       this.holders.set(uri, holder);
     }
     holder.editors.push(editor);
+    if (serve) {
+      holder.served.push(editor);
+      holder.sync ??= new DocumentSync(this.service, uri, languageId, editor);
+    }
     let released = false;
     return {
       uri,
-      service: this.service,
+      service: serve ? this.service : UNSERVED,
       get ready() {
-        return holder.sync.ready;
+        return serve ? holder.sync?.ready ?? Promise.resolve() : Promise.resolve();
       },
       release: () => {
         if (!released) {
@@ -228,20 +324,29 @@ export class ProjectLanguage {
       return;
     }
     holder.editors.splice(holder.editors.indexOf(editor), 1);
-    const next = holder.editors[0];
-    if (next === undefined) {
-      holder.sync.dispose();
+    if (holder.served.includes(editor)) {
+      holder.served.splice(holder.served.indexOf(editor), 1);
+    }
+    const {
+      sync
+    } = holder;
+    if (holder.editors.length === 0) {
       this.holders.delete(uri);
-      void holder.sync.ready.catch(() => undefined).then(() => {
-        if (this.holders.has(uri)) {
+    }
+    if (sync === null || sync.editor !== editor) {
+      return;
+    }
+    sync.dispose();
+    const next = holder.served[0];
+    // The editor that sent the changes is gone; the next served one takes over and opens the document with its own text.
+    holder.sync = next === undefined ? null : new DocumentSync(this.service, uri, holder.languageId, next);
+    if (holder.sync === null) {
+      void sync.ready.catch(() => undefined).then(() => {
+        if (this.holders.get(uri)?.sync) {
           return undefined;
         }
         return this.service.closeDocument(uri);
       }).catch(() => undefined);
-    } else if (holder.sync.editor === editor) {
-      // The editor that sent the changes is gone; the next one takes over and opens the document with its own text.
-      holder.sync.dispose();
-      holder.sync = new DocumentSync(this.service, uri, holder.languageId, next);
     }
   }
   dispose() {
@@ -249,8 +354,14 @@ export class ProjectLanguage {
       return;
     }
     this.disposed = true;
+    for (const subscription of this.subscriptions) {
+      subscription.dispose();
+    }
     disposeSnippetTransforms(this);
     for (const [uri, holder] of this.holders) {
+      if (holder.sync === null) {
+        continue;
+      }
       holder.sync.dispose();
       void holder.sync.ready.catch(() => undefined).then(() => this.service.closeDocument(uri)).catch(() => undefined);
     }

package/dist/rename.js

@@ -44,19 +44,18 @@ export class RenameFeature {
   async start() {
     const {
       editor,
-      project,
       uri
     } = this.language;
-    if (!project.service.supports(METHOD, uri)) {
+    if (!this.language.service.supports(METHOD, uri)) {
       this.tell('error', this.say('unavailable'));
       return;
     }
     this.cancel();
     const caret = editor.getCaret();
-    const prepare = project.service.providerOptions(METHOD, uri)?.prepareProvider === true;
+    const prepare = this.language.service.providerOptions(METHOD, uri)?.prepareProvider === true;
     let answer;
     try {
-      answer = prepare ? await project.service.prepareRename(uri, caret) : {
+      answer = prepare ? await this.language.service.prepareRename(uri, caret) : {
         defaultBehavior: true
       };
     } catch (error) {
@@ -110,7 +109,7 @@ export class RenameFeature {
       uri
     } = this.language;
     try {
-      const edit = await project.service.rename(uri, session.target.range.start, next);
+      const edit = await this.language.service.rename(uri, session.target.range.start, next);
       if (this.session !== session) {
         return;
       }
@@ -204,14 +203,13 @@ export class RenameFeature {
   async light(session) {
     const {
       editor,
-      project,
       uri
     } = this.language;
-    if (!project.service.supports('textDocument/references', uri)) {
+    if (!this.language.service.supports('textDocument/references', uri)) {
       return null;
     }
     try {
-      const locations = await project.service.references(uri, session.target.range.start, true);
+      const locations = await this.language.service.references(uri, session.target.range.start, true);
       if (this.session !== session || locations === null) {
         return null;
       }
@@ -282,14 +280,13 @@ export class RenameFeature {
   /* So a suggester knows a function from a variable; a rename on a use finds the kind through the declaration's place in this file. */
   async kindOf(session, locations) {
     const {
-      project,
       uri
     } = this.language;
-    if (!project.service.supports('textDocument/documentSymbol', uri)) {
+    if (!this.language.service.supports('textDocument/documentSymbol', uri)) {
       return undefined;
     }
     try {
-      const symbols = await project.service.documentSymbols(uri, {
+      const symbols = await this.language.service.documentSymbols(uri, {
         signal: session.names.signal,
         parallel: true
       });

package/dist/rendered-docs.js

@@ -192,10 +192,9 @@ export class RenderedDocsFeature {
   /* Whether names in `{@link}` and `@see` can be followed, which takes a server that finds symbols by name. */
   get canFollow() {
     const {
-      project,
       uri
     } = this.language;
-    return project.service.supports('workspace/symbol', uri);
+    return this.language.service.supports('workspace/symbol', uri);
   }
   /* Goes to what a link in a comment names. */
   follow(name, comment) {

package/dist/selection-ranges.js

@@ -15,14 +15,13 @@ export class SelectionRangesFeature {
   constructor(language) {
     const {
       editor,
-      project,
       uri
     } = language;
     editor.setSelectionRanges(async positions => {
-      if (!project.service.supports(METHOD, uri)) {
+      if (!language.service.supports(METHOD, uri)) {
         return null;
       }
-      const chains = await project.service.selectionRanges(uri, positions);
+      const chains = await language.service.selectionRanges(uri, positions);
       return chains === null || chains.length !== positions.length ? null : chains.map(selectionChainOf);
     });
     language.onDispose(() => editor.setSelectionRanges(null));