@adecore/editor-react 0.42.0 → 0.44.0

package/dist/history.js

@@ -3,6 +3,7 @@ import { isShortcut } from './shortcut-keys.js';
 /* Back, Forward and the list of recent locations over the history the whole project shares. */
 export class HistoryFeature {
   language;
+  editing = false;
   constructor(language) {
     this.language = language;
     const off = language.onKey(event => {
@@ -18,9 +19,37 @@ export class HistoryFeature {
         this.recent();
         return true;
       }
+      if (isShortcut(this.language.shortcuts.lastEditLocation, event)) {
+        this.lastEdit();
+        return true;
+      }
+      if (isShortcut(this.language.shortcuts.nextEditLocation, event)) {
+        this.nextEdit();
+        return true;
+      }
       return false;
     }, KEY_PRIORITY.history);
-    language.onDispose(off);
+    // A jump of the editor's own, such as Method Down, is a place Back returns to like any other jump.
+    const navigations = language.editor.onNavigate?.(from => language.project.history.record({
+      uri: language.uri,
+      position: from
+    }));
+    const changes = language.editor.onTextChange(change => this.edited(change));
+    const carets = language.editor.onCaret(position => this.moved(position));
+    language.onDispose(() => {
+      off();
+      navigations?.();
+      changes();
+      carets();
+    });
+  }
+  /* Goes to where the project was edited before the carets' place; false when there is no such place. */
+  lastEdit() {
+    return this.visitEdit(this.language.project.edits.previous(this.currentEdit()));
+  }
+  /* Goes to where the project was edited after the place Last Edit Location came back to. */
+  nextEdit() {
+    return this.visitEdit(this.language.project.edits.next(this.currentEdit()));
   }
   /* Returns to where the caret was before the last jump; false when there is no such place. */
   back() {
@@ -40,6 +69,55 @@ export class HistoryFeature {
       }
     })), this.language.editor.getCaret(), this.language.project.i18n.t('editor:language.history.recent'));
   }
+  currentEdit() {
+    return {
+      uri: this.language.uri,
+      selections: this.language.editor.getSelections()
+    };
+  }
+  /* Every edit moves the places of the file; one a person made counts as an edit location once the caret has settled. */
+  edited(change) {
+    const {
+      editor,
+      project,
+      uri
+    } = this.language;
+    project.edits.map(uri, change.changes);
+    this.editing = true;
+    queueMicrotask(() => {
+      this.editing = false;
+      if (change.source !== 'external' && editor.hasFocus?.() !== false && !this.language.isDisposed) {
+        project.edits.record(this.currentEdit());
+      }
+    });
+  }
+  /* A caret that moves on its own ends the walk through the edits, unless an edit moved it. */
+  moved(position) {
+    if (!this.editing) {
+      this.language.project.edits.moved(this.language.uri, position);
+    }
+  }
+  visitEdit(place) {
+    if (place === null) {
+      return false;
+    }
+    const {
+      editor,
+      project,
+      uri
+    } = this.language;
+    if (place.uri === uri) {
+      editor.setSelections(place.selections, 'center');
+      editor.focus();
+    } else {
+      // Another file opens on one caret, the primary.
+      project.openPlace({
+        uri: place.uri,
+        position: place.selections.at(-1).end
+      });
+    }
+    return true;
+  }
   visit(place) {
     if (place === null) {
       return false;

package/dist/host-types.d.ts

@@ -2,9 +2,12 @@ import type { WorkerRequestPort } from '@adecore/editor/worker-client';
 import type { EditorPosition, EditorRange } from '@adecore/editor';
 import type { i18n } from 'i18next';
 import type { Keymap } from '@adecore/editor/keymap';
+import type { ClipboardHistory } from './clipboard-history.ts';
 import type { ProjectFiles } from './workspace-edit.ts';
 import type { Place } from './navigation-history.ts';
 import type { ProblemSource } from './project-problems.ts';
+import type { LiveTemplateDraft, TemplateRegistry } from './templates.ts';
+import type { ServerMessage } from '@adecore/lsp';
 export interface DiskText {
     text: string;
     mtime: number;
@@ -55,13 +58,20 @@ export interface LanguageHost {
     readonly files?: ProjectFiles;
     readonly apple?: boolean;
     readonly keymap?: Keymap;
+    readonly clipboard?: ClipboardHistory;
+    readonly templates?: TemplateRegistry;
+    saveAsLiveTemplate?(draft: LiveTemplateDraft): void;
+    openTemplateSettings?(): void;
+    readonly editHistoryLimit?: number;
     readonly panelBodyHeight?: number;
     onPanelResize?(height: number): void;
     readonly problemSource?: ProblemSource;
     openPlace?(place: Place): void;
+    openExternal?(url: string): void;
     pathOfUri?(uri: string): string | null;
     serverNames?(uri: string): readonly string[];
     notify?(notification: EditorNotification): void;
+    onServerMessage?(message: ServerMessage): void;
     resolveSnippetVariable?(name: string, context: SnippetVariableContext): string | undefined;
     suggestNames?(request: RenameSuggestionsRequest, signal: AbortSignal): Promise<readonly string[]>;
 }

package/dist/index.d.ts

@@ -3,7 +3,7 @@ export { KEY_PRIORITY } from './key-priority.ts';
 export { realTimers, type Timers } from './timers.ts';
 export { type SemanticTokensOptions } from './semantic-tokens.ts';
 export { ProjectLanguage, type FileOperationTarget } from './project-language.ts';
-export type { LanguageDocumentHandle } from './project-language.ts';
+export type { AcquireOptions, LanguageDocumentHandle } from './project-language.ts';
 export type { SnippetVariableContext, LanguageHost, DiskText, GitBlameCommit, GitBlameResult, EditorNotification, RenameSuggestionsRequest } from './host-types.ts';
 export { EditorView } from './EditorView.tsx';
 export { createHolder } from './holder.ts';
@@ -13,6 +13,10 @@ export type { LanguagePopupsProps } from './LanguagePopups.tsx';
 export { AnchoredPopup } from './AnchoredPopup.tsx';
 export { SignatureCard } from './SignatureCard.tsx';
 export { type RenderedDocsFeature } from './rendered-docs.ts';
+export { type DocumentLinksFeature } from './document-links.ts';
+export { type DocumentColorsFeature } from './document-colors.ts';
+export { type LinkedEditingFeature } from './linked-editing.ts';
+export { type InlineCompletionFeature, type InlineSuggestion } from './inline-completion.ts';
 export type { RenderedDocEntry, RenderedDocsSettings } from './rendered-docs.ts';
 export type { DocTagEntry, DocTagSection, ParsedDocComment } from './doc-comment-model.ts';
 export { EditorRenderingProvider } from './rendering.tsx';
@@ -28,12 +32,19 @@ export { useProblemCounts } from './use-problem-counts.ts';
 export type { ProblemCounts } from './diagnostics.ts';
 export type { BlameSource, CodeVisionSettings } from './code-vision.ts';
 export type { HoverSettings } from './hover.ts';
-export type { PopupState, PopupStore, HoverInfo, HoverView, CompletionView, CompletionDocs, CompletionRow, SignatureView, RenameView, RenameFileView, PeekView, CallHierarchyView, PickView, PickGroup, PickRow, PickPreview, SymbolsView, MenuView, AuthorsView } from './popups.ts';
+export type { PopupState, PopupStore, HoverInfo, HoverView, CompletionView, CompletionDocs, CompletionRow, SignatureView, RenameView, RenameFileView, PeekView, CallHierarchyView, PickView, PickGroup, PickRow, PickPreview, SymbolsView, MenuView, AuthorsView, WrapView } from './popups.ts';
+export { type MarkupFeature } from './markup.ts';
+export { type SurroundFeature } from './surround.ts';
+export type { MarkupSettings } from './markup.ts';
 export { RowHost, LineActionHost } from './row-host.ts';
 export type { HostedRow, HostedAction } from './row-host.ts';
 export { type HighlightLayers, highlightLayers } from './highlight-layers.ts';
 export { type NavigationHistory } from './navigation-history.ts';
 export type { Place } from './navigation-history.ts';
+export { EditLocations, type EditPlace } from './edit-locations.ts';
+export { ClipboardHistory, type ClipboardEntry, type ClipboardHistoryOptions } from './clipboard-history.ts';
+export { type PasteHistoryFeature } from './paste-history.ts';
+export { TemplateRegistry, checkTemplate, BUILT_IN_LIVE_TEMPLATES, BUILT_IN_POSTFIX_TEMPLATES, type TemplatesFeature, type LiveTemplate, type PostfixTemplate, type LiveTemplateDraft, type TemplateLanguage, type TemplatePlace, type TemplateSettings, type TemplateRegistryOptions, type TemplateUpdate } from './templates.ts';
 export { openingPlace, viewStates, followViewStates, viewStateKey, forgetMovesFrom } from './view-state.ts';
 export type { ViewState, RevealLineRequest } from './view-state.ts';
 export { lspLanguageIdOf, shikiLanguageOf, shikiLanguageOfPath } from './language-ids.ts';

package/dist/index.js

@@ -9,15 +9,25 @@ export { LanguagePopups } from "./LanguagePopups.js";
 export { AnchoredPopup } from "./AnchoredPopup.js";
 export { SignatureCard } from "./SignatureCard.js";
 export {} from './rendered-docs.js';
+export {} from './document-links.js';
+export {} from './document-colors.js';
+export {} from './linked-editing.js';
+export {} from './inline-completion.js';
 export { EditorRenderingProvider } from "./rendering.js";
 export { FindReplace } from "./FindReplace.js";
 export { ChangeReview } from "./ChangeReview.js";
 export { ProjectProblems, serviceProblems, countsOf } from './project-problems.js';
 export { applyWorkspaceEdit, supportedResourceOperations } from './workspace-edit.js';
 export { useProblemCounts } from './use-problem-counts.js';
+export {} from './markup.js';
+export {} from './surround.js';
 export { RowHost, LineActionHost } from './row-host.js';
 export { highlightLayers } from './highlight-layers.js';
 export {} from './navigation-history.js';
+export { EditLocations } from './edit-locations.js';
+export { ClipboardHistory } from './clipboard-history.js';
+export {} from './paste-history.js';
+export { TemplateRegistry, checkTemplate, BUILT_IN_LIVE_TEMPLATES, BUILT_IN_POSTFIX_TEMPLATES } from './templates.js';
 export { openingPlace, viewStates, followViewStates, viewStateKey, forgetMovesFrom } from './view-state.js';
 export { lspLanguageIdOf, shikiLanguageOf, shikiLanguageOfPath } from './language-ids.js';
 export { AttributionCard } from "./AttributionCard.js";

package/dist/inlay-hints.js

@@ -321,7 +321,7 @@ export class InlayHintsFeature {
   }
   /* Whether asking the server could still change what the hint offers. */
   resolvable(entry) {
-    return !entry.answered && entry.epoch === this.epoch && this.language.project.service.supports(RESOLVE_METHOD, this.language.uri);
+    return !entry.answered && entry.epoch === this.epoch && this.language.service.supports(RESOLVE_METHOD, this.language.uri);
   }
   /* Underlines the part under the pointer when a press would do something with it: a command always, a place while the key is down. */
   updateLink() {
@@ -398,7 +398,7 @@ export class InlayHintsFeature {
         this.cancelHover();
         this.language.goTo(action.location);
       } else if (action.kind === 'run') {
-        await project.service.executeCommand(uri, action.command);
+        await this.language.service.executeCommand(uri, action.command);
       } else if (entry.epoch === this.epoch && editsFit(editor, action.edits)) {
         this.cancelHover();
         const applied = editor.applyEdits(action.edits.map(edit => ({

package/dist/inline-completion.d.ts

@@ -0,0 +1,39 @@
+import type { EditorPosition } from '@adecore/editor';
+import type { InlineCompletionItem, InlineCompletionResult, Range } from '@adecore/lsp';
+import type { EditorLanguage } from './editor-language.ts';
+import { type Timers } from './timers.ts';
+export interface InlineSuggestion {
+    readonly item: InlineCompletionItem;
+    readonly text: string;
+    readonly range: Range;
+    readonly rest: string;
+}
+export declare function itemsOf(result: InlineCompletionResult): InlineCompletionItem[];
+export declare function suggestionOf(item: InlineCompletionItem, caret: EditorPosition, textOf: (range: Range) => string): InlineSuggestion | null;
+export declare class InlineCompletionFeature {
+    private readonly language;
+    private readonly timers;
+    private enabled;
+    private suggestions;
+    private index;
+    private timer;
+    private controller;
+    private revision;
+    private accepting;
+    constructor(language: EditorLanguage, timers?: Timers);
+    get supported(): boolean;
+    get isEnabled(): boolean;
+    get current(): InlineSuggestion | null;
+    configure(settings: {
+        readonly enabled?: boolean;
+    }): void;
+    trigger(): void;
+    accept(): boolean;
+    cycle(step: 1 | -1): void;
+    hide(): void;
+    private key;
+    private edited;
+    private moved;
+    private ask;
+    private draw;
+}

package/dist/inline-completion.js

@@ -0,0 +1,221 @@
+import { comparePositions } from './diagnostics-model.js';
+import { KEY_PRIORITY } from './key-priority.js';
+import { isShortcut } from './shortcut-keys.js';
+import { parseSnippet } from './snippet.js';
+import { realTimers } from './timers.js';
+const METHOD = 'textDocument/inlineCompletion';
+/* How long typing rests before a suggestion is asked. */
+const DELAY_MS = 300;
+export function itemsOf(result) {
+  if (result === null) {
+    return [];
+  }
+  return Array.isArray(result) ? result : result.items;
+}
+/*
+ * A server's item as a suggestion at the caret, or null when it does not continue what the line holds: the text the
+ * item replaces up to the caret must start its insert text, so the rest can stand after the caret.
+ */
+export function suggestionOf(item, caret, textOf) {
+  const text = typeof item.insertText === 'string' ? item.insertText : parseSnippet(item.insertText.value).text;
+  const range = item.range ?? {
+    start: caret,
+    end: caret
+  };
+  if (comparePositions(range.start, caret) > 0 || comparePositions(range.end, caret) < 0) {
+    return null;
+  }
+  const typed = textOf({
+    start: range.start,
+    end: caret
+  });
+  if (!text.startsWith(typed)) {
+    return null;
+  }
+  const rest = text.slice(typed.length);
+  return rest === '' ? null : {
+    item,
+    text,
+    range,
+    rest
+  };
+}
+/*
+ * Suggestions a server writes ahead of the caret, drawn as ghost text: asked a moment after typing stops, or at
+ * once with the `suggestInline` key of the host. Tab takes the suggestion, Alt+] and Alt+[ step through the others,
+ * Escape and any key that moves away put it away. Off unless the host turns it on, since a host may draw
+ * suggestions of its own in the same place.
+ */
+export class InlineCompletionFeature {
+  language;
+  timers;
+  enabled = false;
+  suggestions = [];
+  index = 0;
+  timer = null;
+  controller = null;
+  revision = 0;
+  accepting = false;
+  constructor(language, timers = realTimers) {
+    this.language = language;
+    this.timers = timers;
+    const {
+      editor
+    } = language;
+    const offs = [language.onKey(event => this.key(event), KEY_PRIORITY.inlineCompletion), editor.onTextChange(change => this.edited(change)), editor.onCaret(() => queueMicrotask(() => this.moved()))];
+    language.onDispose(() => {
+      this.hide();
+      for (const off of offs) {
+        off();
+      }
+    });
+  }
+  get supported() {
+    const {
+      service
+    } = this.language;
+    return service.inlineCompletions !== undefined && service.supports(METHOD, this.language.uri);
+  }
+  get isEnabled() {
+    return this.enabled;
+  }
+  /* The suggestion drawn now, or null. */
+  get current() {
+    return this.suggestions[this.index] ?? null;
+  }
+  configure(settings) {
+    this.enabled = settings.enabled === true;
+    if (!this.enabled) {
+      this.hide();
+    }
+  }
+  /* Asks for suggestions at the caret now, as a person asking for one does. */
+  trigger() {
+    this.timers.clear(this.timer);
+    void this.ask(1);
+  }
+  /* Takes the drawn suggestion into the text; false when there is none. */
+  accept() {
+    const suggestion = this.current;
+    if (suggestion === null) {
+      return false;
+    }
+    const {
+      editor,
+      service,
+      uri
+    } = this.language;
+    this.accepting = true;
+    try {
+      editor.applyEdits([{
+        range: suggestion.range,
+        text: suggestion.text
+      }]);
+    } finally {
+      this.accepting = false;
+    }
+    this.hide();
+    const {
+      command
+    } = suggestion.item;
+    if (command !== undefined && service.supports('workspace/executeCommand', uri)) {
+      void service.executeCommand(uri, command).catch(() => undefined);
+    }
+    return true;
+  }
+  /* Steps to the next or the previous suggestion. */
+  cycle(step) {
+    if (this.suggestions.length > 1) {
+      this.index = (this.index + step + this.suggestions.length) % this.suggestions.length;
+      this.draw();
+    }
+  }
+  hide() {
+    this.revision++;
+    this.timers.clear(this.timer);
+    this.controller?.abort();
+    if (this.suggestions.length > 0) {
+      this.suggestions = [];
+      this.language.editor.setGhostText(null);
+    }
+  }
+  key(event) {
+    if (isShortcut(this.language.shortcuts.suggestInline, event) && this.enabled) {
+      this.trigger();
+      return true;
+    }
+    if (this.current === null || event.isComposing) {
+      return false;
+    }
+    if (event.key === 'Tab' && !event.shiftKey && !event.altKey && !event.ctrlKey && !event.metaKey) {
+      return this.accept();
+    }
+    if (event.key === 'Escape') {
+      this.hide();
+      return true;
+    }
+    if (event.altKey && !event.ctrlKey && !event.metaKey && (event.code === 'BracketRight' || event.code === 'BracketLeft')) {
+      this.cycle(event.code === 'BracketRight' ? 1 : -1);
+      return true;
+    }
+    return false;
+  }
+  edited(change) {
+    if (this.accepting) {
+      return;
+    }
+    this.hide();
+    if (this.enabled && change.source === 'input' && this.supported) {
+      this.timer = this.timers.set(() => void this.ask(2), DELAY_MS);
+    }
+  }
+  /* A caret that left the place of the suggestion puts it away. */
+  moved() {
+    const suggestion = this.current;
+    if (suggestion === null) {
+      return;
+    }
+    const caret = this.language.editor.getCaret();
+    const selections = this.language.editor.getSelections();
+    if (selections.length !== 1 || suggestionOf(suggestion.item, caret, range => this.language.editor.textInRange(range)) === null) {
+      this.hide();
+    }
+  }
+  async ask(triggerKind) {
+    const {
+      editor,
+      service,
+      uri
+    } = this.language;
+    if (!this.enabled || !this.supported || editor.getSelections().length !== 1 || editor.isReadOnly?.() === true) {
+      return;
+    }
+    this.controller?.abort();
+    const controller = new AbortController();
+    this.controller = controller;
+    const revision = this.revision;
+    const caret = editor.getCaret();
+    try {
+      const result = await service.inlineCompletions(uri, caret, {
+        triggerKind
+      }, {
+        signal: controller.signal
+      });
+      if (revision !== this.revision || comparePositions(editor.getCaret(), caret) !== 0) {
+        return;
+      }
+      this.suggestions = itemsOf(result).flatMap(item => suggestionOf(item, caret, range => editor.textInRange(range)) ?? []);
+      this.index = 0;
+      this.draw();
+    } catch {
+      // A refusal or a failing server is no suggestion; the next pause asks again.
+    }
+  }
+  draw() {
+    const suggestion = this.current;
+    this.language.editor.setGhostText(suggestion === null ? null : {
+      position: this.language.editor.getCaret(),
+      text: suggestion.rest
+    });
+  }
+}

package/dist/key-priority.d.ts

@@ -1,10 +1,12 @@
 import type { EditorKeyHandler } from '@adecore/editor';
 export declare const KEY_PRIORITY: {
-    readonly pick: 1500;
-    readonly diagnostics: 1400;
-    readonly hover: 1300;
-    readonly completion: 1200;
-    readonly snippets: 1100;
+    readonly pick: 1600;
+    readonly diagnostics: 1500;
+    readonly hover: 1400;
+    readonly completion: 1300;
+    readonly snippets: 1200;
+    readonly templates: 1150;
+    readonly markup: 1100;
     readonly signature: 1000;
     readonly highlights: 900;
     readonly codeActions: 800;
@@ -15,6 +17,8 @@ export declare const KEY_PRIORITY: {
     readonly symbolPicker: 300;
     readonly history: 200;
     readonly renderedDocs: 100;
+    readonly pasteHistory: 50;
+    readonly inlineCompletion: 25;
 };
 export declare class KeyDispatcher {
     private readonly entries;

package/dist/key-priority.js

@@ -3,11 +3,14 @@
  * apart, so a handler of the app can stand between two features; 0, the default, comes after all of them.
  */
 export const KEY_PRIORITY = {
-  pick: 1500,
-  diagnostics: 1400,
-  hover: 1300,
-  completion: 1200,
-  snippets: 1100,
+  pick: 1600,
+  diagnostics: 1500,
+  hover: 1400,
+  completion: 1300,
+  snippets: 1200,
+  // Between snippets and markup, so the spacing of a hundred bends here: Tab has to reach the templates after a running snippet and before Emmet.
+  templates: 1150,
+  markup: 1100,
   signature: 1000,
   highlights: 900,
   codeActions: 800,
@@ -17,7 +20,9 @@ export const KEY_PRIORITY = {
   callHierarchy: 400,
   symbolPicker: 300,
   history: 200,
-  renderedDocs: 100
+  renderedDocs: 100,
+  pasteHistory: 50,
+  inlineCompletion: 25
 };
 /* Hands a key to its handlers by priority until one takes it; of two of the same priority the one added first. */
 export class KeyDispatcher {

package/dist/linked-editing.d.ts

@@ -0,0 +1,26 @@
+import type { LinkedEditingRanges } from '@adecore/lsp';
+import type { EditorLanguage } from './editor-language.ts';
+import { type Timers } from './timers.ts';
+export declare function wordPatternOf(ranges: LinkedEditingRanges): RegExp | null;
+export declare class LinkedEditingFeature {
+    private readonly language;
+    private readonly timers;
+    private session;
+    private timer;
+    private controller;
+    private revision;
+    private mirroring;
+    private enabled;
+    constructor(language: EditorLanguage, timers?: Timers);
+    get supported(): boolean;
+    get isActive(): boolean;
+    configure(settings: {
+        readonly enabled?: boolean;
+    }): void;
+    private stop;
+    private caretOffset;
+    private moved;
+    private ask;
+    private edited;
+    private mirror;
+}