@adecore/editor-react 0.42.0 → 0.44.0

package/dist/document-query.js

@@ -0,0 +1,54 @@
+/*
+ * Asks the servers for something of the whole document: once it is open, a moment after the last edit, and
+ * whenever what the servers offer changes. An edit clears the answer at once, since its ranges point into a
+ * text that is gone; an answer for an older text is dropped.
+ */
+export class DocumentQuery {
+  language;
+  timers;
+  delay;
+  ask;
+  apply;
+  timer = null;
+  controller = null;
+  generation = 0;
+  constructor(language, timers, delay, ask, apply) {
+    this.language = language;
+    this.timers = timers;
+    this.delay = delay;
+    this.ask = ask;
+    this.apply = apply;
+    const offs = [language.onProvidersChanged(() => this.run()), language.editor.onTextChange(() => {
+      this.cancel();
+      this.apply(null);
+      this.timer = this.timers.set(() => this.run(), this.delay);
+    })];
+    language.onDispose(() => {
+      this.cancel();
+      for (const off of offs) {
+        off();
+      }
+    });
+  }
+  /* Asks again now, as a refresh of the host does. */
+  run() {
+    this.cancel();
+    const generation = this.generation;
+    const controller = new AbortController();
+    this.controller = controller;
+    this.ask(controller.signal).then(value => {
+      if (generation === this.generation && !this.language.isDisposed) {
+        this.apply(value);
+      }
+    },
+    // A server that fails or refuses answers nothing; the next edit asks again.
+    () => undefined);
+  }
+  cancel() {
+    this.generation++;
+    this.timers.clear(this.timer);
+    this.timer = null;
+    this.controller?.abort();
+    this.controller = null;
+  }
+}

package/dist/edit-locations.d.ts

@@ -0,0 +1,20 @@
+import type { EditorContentChange, EditorPosition, EditorRange } from '@adecore/editor';
+export interface EditPlace {
+    readonly uri: string;
+    readonly selections: readonly EditorRange[];
+}
+export declare class EditLocations {
+    private readonly limit;
+    private entries;
+    private index;
+    private arriving;
+    constructor(limit?: number);
+    get places(): readonly EditPlace[];
+    record(place: EditPlace): void;
+    moved(uri: string, position: EditorPosition): void;
+    previous(current: EditPlace | null): EditPlace | null;
+    next(current: EditPlace | null): EditPlace | null;
+    map(uri: string, changes: readonly EditorContentChange[]): void;
+    forget(matches: (uri: string) => boolean): void;
+    private arrive;
+}

package/dist/edit-locations.js

@@ -0,0 +1,136 @@
+const LIMIT = 150;
+/* Two places are one when they are in one file with as many carets, and every caret is within three lines of its twin. */
+function isSame(left, right) {
+  return right !== null && left.uri === right.uri && left.selections.length === right.selections.length && left.selections.every((selection, index) => Math.abs(selection.end.line - right.selections[index].end.line) < 4);
+}
+function before(left, right) {
+  return left.line < right.line || left.line === right.line && left.character < right.character;
+}
+/* Where the text of a change ends, in the text after the change. */
+function endOf(change) {
+  const lines = change.text.split('\n');
+  const {
+    start
+  } = change.range;
+  return lines.length === 1 ? {
+    line: start.line,
+    character: start.character + change.text.length
+  } : {
+    line: start.line + lines.length - 1,
+    character: lines[lines.length - 1].length
+  };
+}
+/* A position after a change: untouched in front of it, at the start when the change replaced the text around it, moved along behind it. */
+function follow(position, change) {
+  const {
+    start,
+    end
+  } = change.range;
+  if (!before(start, position)) {
+    return position;
+  }
+  if (before(position, end)) {
+    return start;
+  }
+  const landed = endOf(change);
+  return position.line === end.line ? {
+    line: landed.line,
+    character: landed.character + position.character - end.character
+  } : {
+    line: position.line + landed.line - end.line,
+    character: position.character
+  };
+}
+/*
+ * Where the project was edited, for Last Edit Location and Next Edit Location. An edit within three lines of the
+ * last one is the same place, so typing a paragraph is one stop. A caret that moves without an edit puts the walk
+ * back at the end, and so does an edit.
+ */
+export class EditLocations {
+  limit;
+  entries = [];
+  index = 0;
+  arriving = null;
+  constructor(limit = LIMIT) {
+    this.limit = limit;
+  }
+  get places() {
+    return this.entries;
+  }
+  /* An edit left the carets here. */
+  record(place) {
+    const last = this.entries.at(-1);
+    if (last !== undefined && isSame(last, place)) {
+      this.entries[this.entries.length - 1] = place;
+    } else {
+      this.entries.push(place);
+      if (this.entries.length > this.limit) {
+        this.entries.shift();
+      }
+    }
+    this.index = this.entries.length;
+    this.arriving = null;
+  }
+  /* The caret moved without an edit. The move that lands on the place a walk went to does not count. */
+  moved(uri, position) {
+    if (this.arriving?.uri === uri && this.arriving.line === position.line) {
+      return;
+    }
+    this.arriving = null;
+    this.index = this.entries.length;
+  }
+  /* The place of an earlier edit that is not the one the carets are on; null when there is none. */
+  previous(current) {
+    for (let i = this.index - 1; i >= 0; i--) {
+      if (!isSame(this.entries[i], current)) {
+        this.index = i;
+        return this.arrive(this.entries[i]);
+      }
+    }
+    return null;
+  }
+  /* The place of a later edit; it moves one past the place it returns, so Last Edit Location and Next Edit Location are not exact opposites. */
+  next(current) {
+    for (let i = this.index; i < this.entries.length; i++) {
+      if (!isSame(this.entries[i], current)) {
+        this.index = i + 1;
+        return this.arrive(this.entries[i]);
+      }
+    }
+    return null;
+  }
+  /* The places of a file follow its edits, in the order the editor made them. */
+  map(uri, changes) {
+    if (!this.entries.some(entry => entry.uri === uri)) {
+      return;
+    }
+    this.entries = this.entries.map(entry => {
+      if (entry.uri !== uri) {
+        return entry;
+      }
+      const selections = changes.reduce((current, change) => current.map(selection => ({
+        start: follow(selection.start, change),
+        end: follow(selection.end, change)
+      })), entry.selections);
+      return {
+        uri,
+        selections
+      };
+    });
+  }
+  /* Drops the places of files that are gone. */
+  forget(matches) {
+    this.entries = this.entries.filter(entry => !matches(entry.uri));
+    this.index = this.entries.length;
+    if (this.arriving !== null && matches(this.arriving.uri)) {
+      this.arriving = null;
+    }
+  }
+  arrive(place) {
+    this.arriving = {
+      uri: place.uri,
+      line: place.selections.at(-1).end.line
+    };
+    return place;
+  }
+}

package/dist/editor-language.d.ts

@@ -1,6 +1,10 @@
 import { type Keymap } from '@adecore/editor/keymap';
 import type { Editor, EditorKeyHandler, EditorPosition } from '@adecore/editor';
-import type { Location } from '@adecore/lsp';
+import type { LanguageService, Location, TextDocumentSaveReason } from '@adecore/lsp';
+import { DocumentColorsFeature } from './document-colors.ts';
+import { DocumentLinksFeature } from './document-links.ts';
+import { InlineCompletionFeature } from './inline-completion.ts';
+import { LinkedEditingFeature } from './linked-editing.ts';
 import { CallHierarchyFeature } from './call-hierarchy.ts';
 import { CodeActionsFeature } from './code-actions.ts';
 import { CodeVisionFeature } from './code-vision.ts';
@@ -12,7 +16,9 @@ import { FormatOnTypeFeature } from './format-on-type.ts';
 import { HighlightsFeature } from './highlights.ts';
 import { HistoryFeature } from './history.ts';
 import { HoverFeature } from './hover.ts';
+import { MarkupFeature } from './markup.ts';
 import { NavigationFeature } from './navigation.ts';
+import { PasteHistoryFeature } from './paste-history.ts';
 import { PeekFeature } from './peek.ts';
 import { PickFeature } from './pick.ts';
 import { SymbolPickerFeature } from './symbol-picker.ts';
@@ -24,11 +30,14 @@ import { InlayHintsFeature } from './inlay-hints.ts';
 import { type SemanticTokensOptions } from './semantic-tokens.ts';
 import { SignatureFeature } from './signature.ts';
 import { SnippetFeature } from './snippet-session.ts';
+import { SurroundFeature } from './surround.ts';
 import { SymbolsFeature } from './symbols.ts';
+import { TemplatesFeature } from './live-templates.ts';
 import type { Place } from './navigation-history.ts';
 import type { LanguageDocumentHandle, ProjectLanguage } from './project-language.ts';
 export interface EditorLanguageOptions {
     semanticTokens?: SemanticTokensOptions;
+    serve?: boolean;
 }
 export declare class EditorLanguage {
     readonly editor: Editor;
@@ -38,6 +47,7 @@ export declare class EditorLanguage {
     readonly project: ProjectLanguage;
     readonly document: LanguageDocumentHandle;
     readonly languageId: string;
+    readonly served: boolean;
     readonly popups: import("./popups.ts").PopupStore;
     readonly diagnostics: DiagnosticsFeature;
     readonly hover: HoverFeature;
@@ -45,6 +55,9 @@ export declare class EditorLanguage {
     readonly completion: CompletionFeature;
     readonly signature: SignatureFeature;
     readonly snippets: SnippetFeature;
+    readonly markup: MarkupFeature;
+    readonly templates: TemplatesFeature;
+    readonly surround: SurroundFeature;
     readonly highlights: HighlightsFeature;
     readonly pick: PickFeature;
     readonly codeActions: CodeActionsFeature;
@@ -60,11 +73,18 @@ export declare class EditorLanguage {
     readonly codeVision: CodeVisionFeature;
     readonly formatOnType: FormatOnTypeFeature;
     readonly renderedDocs: RenderedDocsFeature;
+    readonly pasteHistory: PasteHistoryFeature;
+    readonly links: DocumentLinksFeature;
+    readonly colors: DocumentColorsFeature;
+    readonly linkedEditing: LinkedEditingFeature;
+    readonly inlineCompletion: InlineCompletionFeature;
     private readonly disposers;
     private readonly keys;
+    private readonly timers;
     private disposed;
     constructor(project: ProjectLanguage, editor: Editor, uri: string, languageId: string, timers?: Timers, options?: EditorLanguageOptions);
     get uri(): string;
+    get service(): LanguageService;
     get isDisposed(): boolean;
     get place(): Place;
     goTo(location: Location): void;
@@ -73,7 +93,9 @@ export declare class EditorLanguage {
     locations(places: readonly Location[], anchor: EditorPosition, title: string): void;
     onProvidersChanged(listener: () => void): () => void;
     onKey(handler: EditorKeyHandler, priority?: number): () => void;
+    prepareSave(reason?: TextDocumentSaveReason): Promise<void>;
     onDispose(dispose: () => void): void;
     dispose(): void;
+    private otherTexts;
     private placeOpenedCaret;
 }

package/dist/editor-language.js

@@ -1,4 +1,8 @@
 import { KEYMAP } from '@adecore/editor/keymap';
+import { DocumentColorsFeature } from './document-colors.js';
+import { DocumentLinksFeature } from './document-links.js';
+import { InlineCompletionFeature } from './inline-completion.js';
+import { LinkedEditingFeature } from './linked-editing.js';
 import { CallHierarchyFeature } from './call-hierarchy.js';
 import { CodeActionsFeature } from './code-actions.js';
 import { CodeVisionFeature } from './code-vision.js';
@@ -12,7 +16,9 @@ import { HighlightsFeature } from './highlights.js';
 import { HistoryFeature } from './history.js';
 import { HoverFeature } from './hover.js';
 import { KeyDispatcher } from './key-priority.js';
+import { MarkupFeature } from './markup.js';
 import { NavigationFeature, locationRow } from './navigation.js';
+import { PasteHistoryFeature } from './paste-history.js';
 import { PeekFeature } from './peek.js';
 import { PickFeature } from './pick.js';
 import { SymbolPickerFeature } from './symbol-picker.js';
@@ -26,7 +32,11 @@ import { SelectionRangesFeature } from './selection-ranges.js';
 import { SemanticTokensFeature } from './semantic-tokens.js';
 import { SignatureFeature } from './signature.js';
 import { SnippetFeature } from './snippet-session.js';
+import { SurroundFeature } from './surround.js';
 import { SymbolsFeature } from './symbols.js';
+import { TemplatesFeature } from './live-templates.js';
+/* How long the edits servers want before a save are waited for. */
+const SAVE_PARTICIPANT_MS = 1_000;
 /*
  * The one place that connects an editor to the language servers: it opens the file's document for
  * the editor and lets go of it again. Every language feature of the editor hangs off this object.
@@ -39,6 +49,8 @@ export class EditorLanguage {
   project;
   document;
   languageId;
+  /* Whether a server serves this document; read it where a host meant "a language server is behind this editor". */
+  served;
   /* What the features of this editor have open over it: the hover card, the suggestions, the signature. */
   popups = createPopupStore();
   diagnostics;
@@ -47,6 +59,9 @@ export class EditorLanguage {
   completion;
   signature;
   snippets;
+  markup;
+  templates;
+  surround;
   highlights;
   pick;
   codeActions;
@@ -62,8 +77,14 @@ export class EditorLanguage {
   codeVision;
   formatOnType;
   renderedDocs;
+  pasteHistory;
+  links;
+  colors;
+  linkedEditing;
+  inlineCompletion;
   disposers = [];
   keys = new KeyDispatcher();
+  timers;
   disposed = false;
   constructor(project, editor, uri, languageId, timers = realTimers, options = {}) {
     this.editor = editor;
@@ -72,13 +93,20 @@ export class EditorLanguage {
     this.shortcuts = shortcutsOf(this.keymap, this.apple);
     this.project = project;
     this.languageId = languageId;
-    this.document = project.acquire(uri, languageId, editor);
+    this.served = options.serve ?? true;
+    this.document = project.acquire(uri, languageId, editor, {
+      serve: this.served
+    });
+    this.timers = timers;
     this.onDispose(editor.onKeyDown(event => this.keys.dispatch(event)));
     this.pick = new PickFeature(this, timers);
     this.diagnostics = new DiagnosticsFeature(this);
     this.hover = new HoverFeature(this, timers);
     this.completion = new CompletionFeature(this, timers);
     this.snippets = new SnippetFeature(this, timers);
+    this.markup = new MarkupFeature(this);
+    this.templates = new TemplatesFeature(this);
+    this.surround = new SurroundFeature(this);
     this.signature = new SignatureFeature(this, timers);
     this.highlights = new HighlightsFeature(this, timers);
     this.symbols = new SymbolsFeature(this, timers);
@@ -87,6 +115,11 @@ export class EditorLanguage {
     this.inlayHints = new InlayHintsFeature(this, timers);
     this.codeActions = new CodeActionsFeature(this, timers);
     this.rename = new RenameFeature(this);
+    // Before navigation, whose Mod+click goes to a definition: a link under the pointer goes first.
+    this.links = new DocumentLinksFeature(this, timers);
+    this.colors = new DocumentColorsFeature(this, timers);
+    this.linkedEditing = new LinkedEditingFeature(this, timers);
+    this.inlineCompletion = new InlineCompletionFeature(this, timers);
     this.navigation = new NavigationFeature(this);
     this.peek = new PeekFeature(this, timers);
     this.callHierarchy = new CallHierarchyFeature(this, timers);
@@ -97,13 +130,26 @@ export class EditorLanguage {
     this.codeVision = new CodeVisionFeature(this, listener => this.symbols.onResult(listener), timers);
     this.formatOnType = new FormatOnTypeFeature(this);
     this.renderedDocs = new RenderedDocsFeature(this, timers);
+    this.pasteHistory = new PasteHistoryFeature(this);
     new FoldingFeature(this, listener => this.symbols.onResult(listener), timers);
+    const copies = editor.onCopy?.(copy => project.clipboard.add(copy.text, {
+      wholeLines: copy.wholeLines
+    }));
+    if (copies !== undefined) {
+      this.onDispose(copies);
+    }
+    editor.setWordSources?.(() => this.otherTexts());
+    this.onDispose(() => editor.setWordSources?.(null));
     this.placeOpenedCaret(editor.getCaret());
     this.onDispose(editor.onCaret(position => this.placeOpenedCaret(position)));
   }
   get uri() {
     return this.document.uri;
   }
+  /* The service this document is asked through: the project's, or one that answers nothing when no server serves it. */
+  get service() {
+    return this.document.service;
+  }
   get isDisposed() {
     return this.disposed;
   }
@@ -169,7 +215,7 @@ export class EditorLanguage {
         listener();
       }
     }, () => undefined);
-    const providers = this.project.service.onProvidersChanged(uri => {
+    const providers = this.service.onProvidersChanged(uri => {
       if (uri === this.uri) {
         listener();
       }
@@ -186,6 +232,37 @@ export class EditorLanguage {
   onKey(handler, priority = 0) {
     return this.keys.add(handler, priority);
   }
+  /*
+   * Lets the servers in before the host writes the file: tells them a save is coming and applies the edits they
+   * want made first, such as organized imports. A server that has not answered within a second is passed over,
+   * as the specification allows. Call it, then save, then let the service send `didSave`.
+   */
+  async prepareSave(reason = 1) {
+    const {
+      service
+    } = this.project;
+    await service.willSave?.(this.uri, reason).catch(() => undefined);
+    if (service.willSaveWaitUntil === undefined) {
+      return;
+    }
+    const controller = new AbortController();
+    const timer = this.timers.set(() => controller.abort(), SAVE_PARTICIPANT_MS);
+    try {
+      const edits = await service.willSaveWaitUntil(this.uri, reason, {
+        signal: controller.signal
+      });
+      if (!controller.signal.aborted && edits !== null && edits.length > 0) {
+        this.editor.applyEdits(edits.map(edit => ({
+          range: edit.range,
+          text: edit.newText
+        })));
+      }
+    } catch {
+      // A server that fails or is too slow does not keep the file from being saved.
+    } finally {
+      this.timers.clear(timer);
+    }
+  }
   /* Runs `dispose` when the editor lets go of its document. */
   onDispose(dispose) {
     this.disposers.push(dispose);
@@ -200,6 +277,10 @@ export class EditorLanguage {
     }
     this.document.release();
   }
+  /* The texts of the other open editors of the project, which Hippie completion takes words from. */
+  otherTexts() {
+    return this.project.openEditors().filter(open => open.uri !== this.uri).map(open => open.editor.getText());
+  }
   /* A file opened from another one lands on the line; this puts the caret on the column the jump meant. */
   placeOpenedCaret(position) {
     const column = this.project.takeCaret(this.uri, position.line);

package/dist/emmet.d.ts

@@ -0,0 +1,13 @@
+import type { MarkupSyntax } from './markup-context.ts';
+export interface AbbreviationOptions {
+    readonly syntax: MarkupSyntax;
+    readonly indent: string;
+    readonly wrap?: readonly string[];
+}
+export interface FoundAbbreviation {
+    readonly abbreviation: string;
+    readonly start: number;
+    readonly end: number;
+}
+export declare function abbreviationBefore(line: string, character: number): FoundAbbreviation | null;
+export declare function expandAbbreviation(abbreviation: string, options: AbbreviationOptions): string | null;

package/dist/emmet.js

@@ -0,0 +1,62 @@
+// A reference and no import, so an app that type-checks this source reads the declaration of the package too.
+// oxlint-disable-next-line typescript/triple-slash-reference
+/// <reference path="./emmet-module.d.ts" />
+import { extract, markup, markupAbbreviation, resolveConfig } from 'emmet';
+/* A text of an expansion is snippet syntax, where these mean a tab stop or end one. */
+function escapeText(text) {
+  return text.replace(/[$}\\]/g, '\\$&');
+}
+function field(index, placeholder) {
+  return placeholder === '' ? `\${${index}}` : `\${${index}:${escapeText(placeholder)}}`;
+}
+/* `lipsum` is the other name of `lorem` that IntelliJ and the Emmet documentation accept. */
+function renameLipsum(node) {
+  if (node.name !== undefined && /^lipsum(?=\d|$)/i.test(node.name)) {
+    node.name = 'lorem' + node.name.slice(6);
+  }
+  for (const child of node.children) {
+    renameLipsum(child);
+  }
+}
+/* The abbreviation that ends at `character` of a line, or null where nothing before the caret reads as one. */
+export function abbreviationBefore(line, character) {
+  const found = extract(line, character, {
+    type: 'markup',
+    lookAhead: true
+  });
+  if (found === undefined || !/^[A-Za-z!.#([{]/.test(found.abbreviation)) {
+    return null;
+  }
+  return {
+    abbreviation: found.abbreviation,
+    start: found.start,
+    end: found.end
+  };
+}
+/*
+ * The expansion of an abbreviation as snippet text, its places to fill as tab stops; null when it does not
+ * read as one. Lorem ipsum words after the first sentence differ per expansion.
+ */
+export function expandAbbreviation(abbreviation, options) {
+  const text = options.wrap === undefined ? undefined : [...options.wrap];
+  try {
+    const tree = markupAbbreviation(abbreviation, {
+      text
+    });
+    for (const child of tree.children) {
+      renameLipsum(child);
+    }
+    const expanded = markup(tree, resolveConfig({
+      syntax: options.syntax === 'xml' ? 'xml' : 'html',
+      text,
+      options: {
+        'output.field': field,
+        'output.text': escapeText,
+        'output.indent': options.indent
+      }
+    }));
+    return expanded === '' ? null : expanded;
+  } catch {
+    return null;
+  }
+}

package/dist/folding.js

@@ -60,14 +60,13 @@ export class FoldingFeature {
     this.language = language;
     const {
       editor,
-      project,
       uri
     } = language;
     this.refresher = new Refresher(async signal => {
-      if (!project.service.supports(METHOD, uri)) {
+      if (!language.service.supports(METHOD, uri)) {
         return;
       }
-      const ranges = await project.service.foldingRanges(uri, {
+      const ranges = await language.service.foldingRanges(uri, {
         signal
       });
       if (!signal.aborted) {

package/dist/format-on-type.js

@@ -38,10 +38,9 @@ export class FormatOnTypeFeature {
   /* Whether the server of this document formats on type and the service can ask it. */
   get supported() {
     const {
-      project,
       uri
     } = this.language;
-    return project.service.onTypeFormatting !== undefined && project.service.supports(METHOD, uri);
+    return this.language.service.onTypeFormatting !== undefined && this.language.service.supports(METHOD, uri);
   }
   configure(enabled) {
     this.enabled = enabled;
@@ -51,7 +50,7 @@ export class FormatOnTypeFeature {
   }
   /* The characters that ask the server, the first one and the more. */
   triggerCharacters() {
-    const options = this.language.project.service.providerOptions(METHOD, this.language.uri);
+    const options = this.language.service.providerOptions(METHOD, this.language.uri);
     return options === undefined ? [] : [...(options.firstTriggerCharacter === undefined ? [] : [options.firstTriggerCharacter]), ...(options.moreTriggerCharacter ?? [])];
   }
   typed(change) {
@@ -80,14 +79,13 @@ export class FormatOnTypeFeature {
   async ask(revision, typed, caret, signal) {
     const {
       editor,
-      project,
       uri,
       document
     } = this.language;
     try {
       // The change of the typed character reaches the server before this question does.
       await document.ready;
-      const edits = await project.service.onTypeFormatting(uri, caret, typed, {
+      const edits = await this.language.service.onTypeFormatting(uri, caret, typed, {
         ...editor.getIndentation()
       }, {
         signal

package/dist/highlights.js

@@ -40,15 +40,14 @@ export class HighlightsFeature {
     this.language = language;
     const {
       editor,
-      project,
       uri
     } = language;
     this.refresher = new Refresher(async signal => {
-      if (!project.service.supports(METHOD, uri) || !this.onName()) {
+      if (!language.service.supports(METHOD, uri) || !this.onName()) {
         this.clear();
         return;
       }
-      const result = await project.service.documentHighlights(uri, editor.getCaret(), {
+      const result = await language.service.documentHighlights(uri, editor.getCaret(), {
         signal
       });
       if (!signal.aborted) {

package/dist/history.d.ts

@@ -1,9 +1,16 @@
 import type { EditorLanguage } from './editor-language.ts';
 export declare class HistoryFeature {
     private readonly language;
+    private editing;
     constructor(language: EditorLanguage);
+    lastEdit(): boolean;
+    nextEdit(): boolean;
     back(): boolean;
     forward(): boolean;
     recent(): void;
+    private currentEdit;
+    private edited;
+    private moved;
+    private visitEdit;
     private visit;
 }