@adecore/editor-react 0.42.0 → 0.44.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,27 @@ export class PickFeature {
         this.close();
         return true;
       default:
-        return false;
+        if (spec.filter === true && event.key.length === 1) {
+          this.requery(this.query + event.key);
+          return true;
+        }
+        return spec.filter !== true && event.key.length === 1 && this.takeMnemonic(event.key);
+    }
+  }
+  /* Takes the visible row whose mnemonic is the typed character, whatever the case. */
+  takeMnemonic(character) {
+    const wanted = character.toLowerCase();
+    const row = this.visibleGroups().flatMap(group => group.rows).find(candidate => candidate.mnemonic?.toLowerCase() === wanted);
+    if (row === undefined) {
+      return false;
     }
+    this.choose(row.id);
+    return true;
   }
   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 +305,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,8 @@ export interface PickRow {
     readonly label: string;
     readonly detail: string;
     readonly path?: boolean;
+    readonly search?: string;
+    readonly mnemonic?: string;
 }
 export interface PickGroup {
     readonly title: string | null;
@@ -64,6 +66,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 +74,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 +139,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 +154,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/postfix.d.ts

@@ -0,0 +1,21 @@
+import type { EditorPosition } from '@adecore/editor';
+import type { LocalCompletionItem } from './completion.ts';
+import type { EditorLanguage } from './editor-language.ts';
+interface PostfixKey {
+    readonly start: EditorPosition;
+    expand(): boolean;
+}
+export declare class PostfixFeature {
+    private readonly language;
+    constructor(language: EditorLanguage);
+    key(): PostfixKey | null;
+    rows(position: EditorPosition): readonly LocalCompletionItem[];
+    private row;
+    private candidates;
+    private expandKey;
+    private expand;
+    private run;
+    private rendered;
+    private expressionOf;
+}
+export {};

package/dist/postfix.js

@@ -0,0 +1,212 @@
+import { isIdentifierCharacter } from './completion-model.js';
+import { comparePositions } from './diagnostics-model.js';
+import { lineTextOf, textBeforeOf } from './line-text.js';
+import { bodyWithIndentUnit, dedentLines, indentUnitOf, insertSnippet } from './snippet-insert.js';
+import { compileSnippet } from './snippet.js';
+import { SNIPPET_KIND, sortAfterServer, templateContextAt } from './template-context.js';
+const MAX_ROW_LENGTH = 80;
+/* The identifier characters after the last dot of `before`, and where that dot is; null when no dot leads them. */
+function typedKey(before) {
+  let index = before.length;
+  while (index > 0 && isIdentifierCharacter(before[index - 1])) {
+    index--;
+  }
+  return index > 0 && before[index - 1] === '.' ? {
+    key: before.slice(index),
+    dot: index - 1
+  } : null;
+}
+/* One line of a chooser row: whitespace collapsed and cut short. */
+function rowLabel(text) {
+  const line = text.replace(/\s+/g, ' ').trim();
+  return line.length > MAX_ROW_LENGTH ? `${line.slice(0, MAX_ROW_LENGTH - 1)}…` : line;
+}
+/*
+ * Postfix completion: a dot and a key after an expression, and Tab or an accepted row wraps the expression in a
+ * template. The registry holds the templates and `TemplatesFeature` decides whether Tab is ours or a live template's.
+ */
+export class PostfixFeature {
+  language;
+  constructor(language) {
+    this.language = language;
+  }
+  /* The key before the caret that a template of the registry applies to; null where Tab has no postfix template to expand. */
+  key() {
+    const {
+      editor,
+      project
+    } = this.language;
+    if (!project.templates.settings.postfix) {
+      return null;
+    }
+    const caret = editor.getCaret();
+    const typed = typedKey(textBeforeOf(editor, caret));
+    if (typed === null || typed.key === '') {
+      return null;
+    }
+    const candidates = this.candidates({
+      line: caret.line,
+      character: typed.dot
+    }, template => template.key === typed.key);
+    if (candidates === null) {
+      return null;
+    }
+    return {
+      start: candidates.dot,
+      expand: () => this.expandKey(candidates, caret)
+    };
+  }
+  /* The rows of the suggestion list after a dot, for the templates whose key the typed characters can lead to. */
+  rows(position) {
+    const {
+      editor,
+      project
+    } = this.language;
+    const {
+      settings
+    } = project.templates;
+    const selections = editor.getSelections();
+    if (!settings.postfix || !settings.postfixInCompletion || selections.length !== 1 || comparePositions(selections[0].start, selections[0].end) !== 0) {
+      return [];
+    }
+    const typed = typedKey(textBeforeOf(editor, position));
+    if (typed === null) {
+      return [];
+    }
+    const candidates = this.candidates({
+      line: position.line,
+      character: typed.dot
+    }, template => template.key.startsWith(typed.key));
+    if (candidates === null) {
+      return [];
+    }
+    const range = {
+      start: {
+        line: position.line,
+        character: typed.dot + 1
+      },
+      end: position
+    };
+    return candidates.templates.map(template => this.row(template, candidates, range, sortAfterServer(template.key)));
+  }
+  row(template, candidates, range, sortText) {
+    const item = {
+      label: template.key,
+      kind: SNIPPET_KIND,
+      detail: template.example,
+      documentation: template.description,
+      filterText: template.key,
+      sortText,
+      textEdit: {
+        range,
+        newText: template.key
+      }
+    };
+    return {
+      item,
+      accept: () => this.expand(template, candidates, this.language.editor.getCaret())
+    };
+  }
+  /* The templates `matches` lets through that apply to the expressions before `dot`; null when none does. */
+  candidates(dot, matches) {
+    const {
+      editor,
+      project
+    } = this.language;
+    const operands = editor.postfixOperands?.(dot) ?? [];
+    if (operands.length === 0) {
+      return null;
+    }
+    const context = templateContextAt(this.language, dot);
+    if (context.place !== 'code') {
+      return null;
+    }
+    const widest = operands.at(-1);
+    const templates = project.templates.postfix.filter(template => matches(template) && template.languages.some(family => context.families.includes(family)) && (template.expression !== 'statement' || widest.statement));
+    return templates.length === 0 ? null : {
+      dot,
+      operands,
+      templates
+    };
+  }
+  /* Expands the one template of a key, or lists them when several share it. */
+  expandKey(candidates, caret) {
+    if (candidates.templates.length === 1) {
+      this.expand(candidates.templates[0], candidates, caret);
+      return true;
+    }
+    const start = {
+      line: candidates.dot.line,
+      character: candidates.dot.character + 1
+    };
+    this.language.completion.showItems(candidates.templates.map(template => this.row(template, candidates, {
+      start,
+      end: caret
+    }, template.id)), start);
+    return true;
+  }
+  /* Wraps the widest expression for a statement, the only one there is, or the one a person picks from the expressions. */
+  expand(template, candidates, caret) {
+    const {
+      operands
+    } = candidates;
+    if (template.expression === 'statement' || operands.length === 1) {
+      void this.run(template, template.expression === 'statement' ? operands.at(-1) : operands[0], caret);
+      return;
+    }
+    const {
+      editor,
+      completion,
+      pick,
+      project
+    } = this.language;
+    const rows = operands.map((operand, index) => ({
+      id: String(index),
+      label: rowLabel(editor.textInRange(operand.range)),
+      detail: ''
+    }));
+    completion.close();
+    pick.open({
+      anchor: caret,
+      title: project.i18n.t('editor:language.postfix.expressions'),
+      groups: [{
+        title: null,
+        rows
+      }],
+      accept: id => void this.run(template, operands[Number(id)], caret),
+      preview: id => Promise.resolve({
+        removed: [],
+        added: this.rendered(template, operands[Number(id)]).split('\n'),
+        note: null,
+        kind: 'text'
+      })
+    });
+  }
+  run(template, operand, caret) {
+    const {
+      editor
+    } = this.language;
+    const expression = this.expressionOf(operand);
+    return insertSnippet(this.language, bodyWithIndentUnit(template.body, indentUnitOf(editor)), [{
+      range: {
+        start: operand.range.start,
+        end: caret
+      }
+    }], name => name === 'EXPR' ? expression : undefined);
+  }
+  /* What the template would put in place of the expression, tab stops at their placeholders. */
+  rendered(template, operand) {
+    const expression = this.expressionOf(operand);
+    return compileSnippet(bodyWithIndentUnit(template.body, indentUnitOf(this.language.editor))).render(name => name === 'EXPR' ? expression : undefined, undefined, {
+      indentVariables: true
+    }).text;
+  }
+  /* The text of an expression, with the indentation of its first line taken off the lines after it. */
+  expressionOf(operand) {
+    const {
+      editor
+    } = this.language;
+    const indent = /^[\t ]*/.exec(lineTextOf(editor, operand.range.start.line))[0];
+    return dedentLines(editor.textInRange(operand.range).trimEnd(), indent);
+  }
+}

package/dist/project-language.d.ts

@@ -1,6 +1,9 @@
 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 { TemplateRegistry } from './templates.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 +13,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 +27,9 @@ export declare class ProjectLanguage {
     readonly folder: string;
     readonly problems: ProjectProblems;
     readonly history: NavigationHistory;
+    readonly edits: EditLocations;
+    readonly clipboard: ClipboardHistory;
+    readonly templates: TemplateRegistry;
     private readonly holders;
     private readonly files;
     panelBodyHeight: number;
@@ -28,6 +37,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 +49,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;
 }