@adecore/editor-react 0.42.0 → 0.44.0

package/src/document-query.ts

@@ -0,0 +1,71 @@
+import type { EditorLanguage } from './editor-language.ts';
+import type { Timers } from './timers.ts';
+
+/*
+ * 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<Value> {
+    private readonly language: EditorLanguage;
+    private readonly timers: Timers;
+    private readonly delay: number;
+    private readonly ask: (signal: AbortSignal) => Promise<Value | null>;
+    private readonly apply: (value: Value | null) => void;
+    private timer: unknown = null;
+    private controller: AbortController | null = null;
+    private generation = 0;
+
+    constructor(
+        language: EditorLanguage,
+        timers: Timers,
+        delay: number,
+        ask: (signal: AbortSignal) => Promise<Value | null>,
+        apply: (value: Value | null) => void
+    ) {
+        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(): void {
+        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
+        );
+    }
+
+    private cancel(): void {
+        this.generation++;
+        this.timers.clear(this.timer);
+        this.timer = null;
+        this.controller?.abort();
+        this.controller = null;
+    }
+}

package/src/edit-locations.ts

@@ -0,0 +1,162 @@
+import type { EditorContentChange, EditorPosition, EditorRange } from '@adecore/editor';
+
+/* Where an edit left the carets of one file, the primary last. */
+export interface EditPlace {
+    readonly uri: string;
+    readonly selections: readonly EditorRange[];
+}
+
+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: EditPlace, right: EditPlace | null): boolean {
+    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: EditorPosition, right: EditorPosition): boolean {
+    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: EditorContentChange): EditorPosition {
+    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: EditorPosition, change: EditorContentChange): EditorPosition {
+    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 {
+    private readonly limit: number;
+    private entries: EditPlace[] = [];
+    private index = 0;
+    private arriving: { uri: string; line: number } | null = null;
+
+    constructor(limit = LIMIT) {
+        this.limit = limit;
+    }
+
+    get places(): readonly EditPlace[] {
+        return this.entries;
+    }
+
+    /* An edit left the carets here. */
+    record(place: EditPlace): void {
+        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: string, position: EditorPosition): void {
+        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: EditPlace | null): EditPlace | null {
+        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: EditPlace | null): EditPlace | null {
+        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: string, changes: readonly EditorContentChange[]): void {
+        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: (uri: string) => boolean): void {
+        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;
+        }
+    }
+
+    private arrive(place: EditPlace): EditPlace {
+        this.arriving = { uri: place.uri, line: place.selections.at(-1)!.end.line };
+
+        return place;
+    }
+}

package/src/editor-language.ts

@@ -1,6 +1,10 @@
 import { KEYMAP, 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';
@@ -14,7 +18,9 @@ import { HighlightsFeature } from './highlights.ts';
 import { HistoryFeature } from './history.ts';
 import { HoverFeature } from './hover.ts';
 import { KeyDispatcher } from './key-priority.ts';
+import { MarkupFeature } from './markup.ts';
 import { NavigationFeature, locationRow } 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';
@@ -28,14 +34,21 @@ import { SelectionRangesFeature } from './selection-ranges.ts';
 import { SemanticTokensFeature, 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';
 
+/* How long the edits servers want before a save are waited for. */
+const SAVE_PARTICIPANT_MS = 1_000;
+
 /* What an app tunes about the features of one editor. */
 export interface EditorLanguageOptions {
     /* Where a document counts as large for semantic tokens. */
     semanticTokens?: SemanticTokensOptions;
+    /* False for a document no server serves: it counts as open in the project and the features stay inert. True by default. */
+    serve?: boolean;
 }
 
 /*
@@ -51,6 +64,9 @@ export class EditorLanguage {
     readonly document: LanguageDocumentHandle;
     readonly languageId: string;
 
+    /* Whether a server serves this document; read it where a host meant "a language server is behind this editor". */
+    readonly served: boolean;
+
     /* What the features of this editor have open over it: the hover card, the suggestions, the signature. */
     readonly popups = createPopupStore();
 
@@ -60,6 +76,9 @@ export 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;
@@ -75,8 +94,14 @@ export 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: Array<() => void> = [];
     private readonly keys = new KeyDispatcher();
+    private readonly timers: Timers;
     private disposed = false;
 
     constructor(project: ProjectLanguage, editor: Editor, uri: string, languageId: string, timers: Timers = realTimers, options: EditorLanguageOptions = {}) {
@@ -86,13 +111,18 @@ 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);
@@ -101,6 +131,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);
@@ -111,7 +146,17 @@ 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)));
     }
@@ -120,6 +165,11 @@ export class EditorLanguage {
         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(): LanguageService {
+        return this.document.service;
+    }
+
     get isDisposed(): boolean {
         return this.disposed;
     }
@@ -173,7 +223,7 @@ export class EditorLanguage {
             () => undefined
         );
 
-        const providers = this.project.service.onProvidersChanged((uri) => {
+        const providers = this.service.onProvidersChanged((uri) => {
             if (uri === this.uri) {
                 listener();
             }
@@ -193,6 +243,31 @@ export class EditorLanguage {
         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: TextDocumentSaveReason = 1): Promise<void> {
+        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: () => void): void {
         this.disposers.push(dispose);
@@ -212,6 +287,14 @@ export class EditorLanguage {
         this.document.release();
     }
 
+    /* The texts of the other open editors of the project, which Hippie completion takes words from. */
+    private otherTexts(): string[] {
+        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. */
     private placeOpenedCaret(position: EditorPosition): void {
         const column = this.project.takeCaret(this.uri, position.line);

package/src/emmet-module.d.ts

@@ -0,0 +1,44 @@
+// The package ships `dist/index.d.ts`, but its `exports` point TypeScript at none, so the part used here is declared again.
+declare module 'emmet' {
+    export interface MarkupAbbreviationNode {
+        name?: string;
+        children: MarkupAbbreviationNode[];
+    }
+
+    export interface MarkupAbbreviation {
+        type: 'Abbreviation';
+        children: MarkupAbbreviationNode[];
+    }
+
+    export interface ExtractedAbbreviation {
+        abbreviation: string;
+        location: number;
+        start: number;
+        end: number;
+    }
+
+    export interface ExtractOptions {
+        lookAhead: boolean;
+        type: 'markup' | 'stylesheet';
+        prefix: string;
+    }
+
+    export interface UserConfig {
+        syntax?: string;
+        text?: string | string[];
+        options?: {
+            'output.field'?: (index: number, placeholder: string, offset: number, line: number, column: number) => string;
+            'output.text'?: (text: string, offset: number, line: number, column: number) => string;
+            'output.indent'?: string;
+        };
+    }
+
+    export interface Config extends UserConfig {
+        type: 'markup' | 'stylesheet';
+    }
+
+    export function extract(line: string, pos?: number, options?: Partial<ExtractOptions>): ExtractedAbbreviation | undefined;
+    export function markupAbbreviation(abbreviation: string, options?: { text?: string | string[] }): MarkupAbbreviation;
+    export function markup(abbreviation: string | MarkupAbbreviation, config: Config): string;
+    export function resolveConfig(config?: UserConfig): Config;
+}

package/src/emmet.ts

@@ -0,0 +1,73 @@
+// 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, type MarkupAbbreviationNode } from 'emmet';
+import type { MarkupSyntax } from './markup-context.ts';
+
+export interface AbbreviationOptions {
+    readonly syntax: MarkupSyntax;
+    /* One level of indentation inside the expansion. */
+    readonly indent: string;
+    /* Lines the abbreviation wraps; a repeated element without a count takes one line each. */
+    readonly wrap?: readonly string[];
+}
+
+export interface FoundAbbreviation {
+    readonly abbreviation: string;
+    /* UTF-16 columns of the line, `end` past the caret when brackets the editor closed follow it. */
+    readonly start: number;
+    readonly end: number;
+}
+
+/* A text of an expansion is snippet syntax, where these mean a tab stop or end one. */
+function escapeText(text: string): string {
+    return text.replace(/[$}\\]/g, '\\$&');
+}
+
+function field(index: number, placeholder: string): string {
+    return placeholder === '' ? `\${${index}}` : `\${${index}:${escapeText(placeholder)}}`;
+}
+
+/* `lipsum` is the other name of `lorem` that IntelliJ and the Emmet documentation accept. */
+function renameLipsum(node: MarkupAbbreviationNode): void {
+    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: string, character: number): FoundAbbreviation | null {
+    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: string, options: AbbreviationOptions): string | null {
+    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/src/folding.ts

@@ -58,15 +58,15 @@ export class FoldingFeature {
 
     constructor(language: EditorLanguage, onSymbols: (listener: (result: DocumentSymbolResult) => void) => () => void, timers: Timers = realTimers) {
         this.language = language;
-        const { editor, project, uri } = language;
+        const { editor, 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, { signal });
+                const ranges = await language.service.foldingRanges(uri, { signal });
 
                 if (!signal.aborted) {
                     this.ranges = foldRangesOf(ranges);

package/src/format-on-type.ts

@@ -52,9 +52,9 @@ export class FormatOnTypeFeature {
 
     /* Whether the server of this document formats on type and the service can ask it. */
     get supported(): boolean {
-        const { project, uri } = this.language;
+        const { 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: boolean): void {
@@ -67,7 +67,7 @@ export class FormatOnTypeFeature {
 
     /* The characters that ask the server, the first one and the more. */
     triggerCharacters(): readonly string[] {
-        const options = this.language.project.service.providerOptions(METHOD, this.language.uri);
+        const options = this.language.service.providerOptions(METHOD, this.language.uri);
 
         return options === undefined
             ? []
@@ -99,12 +99,12 @@ export class FormatOnTypeFeature {
     }
 
     private async ask(revision: number, typed: string, caret: { line: number; character: number }, signal: AbortSignal): Promise<void> {
-        const { editor, project, uri, document } = this.language;
+        const { editor, 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, { ...editor.getIndentation() }, { signal });
+            const edits = await this.language.service.onTypeFormatting!(uri, caret, typed, { ...editor.getIndentation() }, { signal });
             const here = editor.getCaret();
             const stale = revision !== this.revision || this.language.isDisposed || comparePositions(here, caret) !== 0;
 

package/src/highlights.ts

@@ -46,17 +46,17 @@ export class HighlightsFeature {
 
     constructor(language: EditorLanguage, timers: Timers = realTimers) {
         this.language = language;
-        const { editor, project, uri } = language;
+        const { editor, 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(), { signal });
+                const result = await language.service.documentHighlights(uri, editor.getCaret(), { signal });
 
                 if (!signal.aborted) {
                     this.set(result === null ? [] : editorHighlightsOf(result));