@adecore/editor-react 0.22.1 → 0.23.1

package/src/semantic-tokens.ts

@@ -1,44 +1,227 @@
+import type { EditorRange, EditorSemanticToken } from '@adecore/editor';
+import { StaleResultError, type SemanticTokens, type SemanticTokensDelta, type SemanticTokensLegend } from '@adecore/lsp';
 import type { EditorLanguage } from './editor-language.ts';
+import { covers, withMargin } from './inlay-hints.ts';
+import { lineTextOf } from './line-text.ts';
 import { Refresher } from './refresher.ts';
+import { applySemanticEdits } from './semantic-delta.ts';
 import { decodeSemanticTokens } from './semantic-model.ts';
 import { realTimers, type Timers } from './timers.ts';
 
-const METHOD = 'textDocument/semanticTokens/full';
+const FULL = 'textDocument/semanticTokens/full';
+const DELTA = 'textDocument/semanticTokens/full/delta';
+const RANGE = 'textDocument/semanticTokens/range';
 const PAUSE_MS = 200;
+const SCROLL_PAUSE_MS = 100;
+
+/* A document with more lines or characters than this is first asked for what is in view, when the server answers ranges. */
+export const DEFAULT_RANGE_LINES = 5000;
+export const DEFAULT_RANGE_CHARACTERS = 500_000;
+
+/* What decides when a document is too large to wait for in full. */
+export interface SemanticTokensOptions {
+    /* Lines above which a document is asked for its visible range first. */
+    rangeLines?: number;
+    /* Characters above which a document is asked for its visible range first. */
+    rangeCharacters?: number;
+}
+
+/* The last full answer, which the next delta is computed against. */
+interface Held {
+    resultId: string;
+    data: number[];
+}
 
 /*
  * Colors from what the language servers know, over the grammar's guess. It asks after a pause in typing
  * and when a server's offer changed, and keeps drawing the last answer meanwhile so the colors never blink out.
+ * A server that offers deltas is asked for the change since its last answer; one that offers ranges is asked
+ * for the lines in view first when the document is large, and for them alone when it offers nothing else.
  */
 export class SemanticTokensFeature {
     private readonly refresher: Refresher;
+    private readonly scrolled: Refresher;
+    private readonly language: EditorLanguage;
+    private readonly options: SemanticTokensOptions;
+    private held: Held | null = null;
+    private heldLegend = '';
+    /* True once the whole document is drawn from a full answer; a range answer then no longer paints. */
+    private complete = false;
+    /* The lines a range answer drew, null when nothing of that kind is on screen. */
+    private covered: EditorRange | null = null;
+    private drawn: EditorSemanticToken[] = [];
+    private epoch = 0;
 
-    constructor(language: EditorLanguage, timers: Timers = realTimers) {
-        const { editor, project, uri } = language;
-        this.refresher = new Refresher(
-            async (signal) => {
-                const { service } = project;
-                const legend = service.providerOptions(METHOD, uri)?.legend;
-                if (!service.supports(METHOD, uri) || legend === undefined) {
-                    return;
-                }
-                const tokens = await service.semanticTokens(uri, { signal });
-                if (!signal.aborted) {
-                    editor.setSemanticTokens(tokens === null ? null : decodeSemanticTokens(tokens, legend));
-                }
-            },
-            PAUSE_MS,
-            timers
-        );
-        const edits = editor.onTextChange(() => this.refresher.later());
+    constructor(language: EditorLanguage, timers: Timers = realTimers, options: SemanticTokensOptions = {}) {
+        const { editor } = language;
+        this.language = language;
+        this.options = options;
+        this.refresher = new Refresher((signal) => this.refresh(signal), PAUSE_MS, timers);
+        this.scrolled = new Refresher((signal) => this.fillViewport(signal), SCROLL_PAUSE_MS, timers);
+        const edits = editor.onTextChange(() => {
+            this.epoch++;
+            this.covered = null;
+            this.refresher.later();
+        });
+        const view = editor.onViewChange(() => {
+            if (!this.complete && this.covered !== null && !covers(this.covered, editor.getVisibleRange())) {
+                this.scrolled.later();
+            }
+        });
         const providers = language.onProvidersChanged(() => {
+            this.epoch++;
+            this.scrolled.cancel();
+            this.forget();
             this.refresher.now();
         });
         language.onDispose(() => {
             edits();
+            view();
             providers();
             this.refresher.dispose();
+            this.scrolled.dispose();
+            this.forget();
             editor.setSemanticTokens(null);
         });
     }
+
+    /* Drops what the next delta would be computed against, which a refresh, a restart or a new legend makes meaningless. */
+    private forget(): void {
+        this.held = null;
+        this.complete = false;
+        this.covered = null;
+    }
+
+    private legend(): SemanticTokensLegend | undefined {
+        const { service } = this.language.project;
+        const { uri } = this.language;
+        const legend = (service.providerOptions(FULL, uri) ?? service.providerOptions(RANGE, uri))?.legend;
+        const key = legend === undefined ? '' : JSON.stringify(legend);
+        if (key !== this.heldLegend) {
+            this.heldLegend = key;
+            this.forget();
+        }
+        return legend;
+    }
+
+    private isLarge(): boolean {
+        const { editor } = this.language;
+        const end = editor.positionAt(Number.MAX_SAFE_INTEGER);
+        return (
+            end.line + 1 > (this.options.rangeLines ?? DEFAULT_RANGE_LINES) || editor.offsetAt(end) > (this.options.rangeCharacters ?? DEFAULT_RANGE_CHARACTERS)
+        );
+    }
+
+    private viewport(): EditorRange {
+        const { editor } = this.language;
+        return withMargin(editor.getVisibleRange(), editor.positionAt(Number.MAX_SAFE_INTEGER), (line) => ({
+            line,
+            character: lineTextOf(editor, line).length
+        }));
+    }
+
+    private async refresh(signal: AbortSignal): Promise<void> {
+        const { service } = this.language.project;
+        const { editor, uri } = this.language;
+        const legend = this.legend();
+        const full = service.supports(FULL, uri);
+        const range = service.supports(RANGE, uri);
+        if (legend === undefined || (!full && !range)) {
+            return;
+        }
+        if (!full || (range && !this.complete && this.held === null && this.isLarge())) {
+            await this.askRange(this.viewport(), legend, signal, true);
+            if (!full) {
+                return;
+            }
+        }
+        const epoch = this.epoch;
+        const tokens = await this.askFull(signal);
+        if (signal.aborted || epoch !== this.epoch) {
+            return;
+        }
+        this.complete = tokens !== null;
+        this.covered = null;
+        this.drawn = [];
+        editor.setSemanticTokens(tokens === null ? null : decodeSemanticTokens(tokens, legend));
+    }
+
+    /* The whole document: as a delta when the last answer can be built on, else in full. Null when the server has no tokens. */
+    private async askFull(signal: AbortSignal): Promise<SemanticTokens | null> {
+        const { service } = this.language.project;
+        const { uri } = this.language;
+        const base = this.held;
+        if (base !== null && service.supports(DELTA, uri)) {
+            const answer = await service.semanticTokensDelta(uri, base.resultId, { signal }).catch((error: unknown) => {
+                if (signal.aborted || error instanceof StaleResultError) {
+                    throw error;
+                }
+                // A server that no longer knows our result id is asked in full instead, once.
+                return null;
+            });
+            signal.throwIfAborted();
+            if (answer !== null && this.held === base) {
+                const tokens = this.fromDelta(base, answer);
+                if (tokens !== null) {
+                    this.hold(tokens);
+                    return tokens;
+                }
+            }
+            this.held = null;
+        }
+        const tokens = await service.semanticTokens(uri, { signal });
+        signal.throwIfAborted();
+        this.hold(tokens);
+        return tokens;
+    }
+
+    /* Null when the answer is a delta that does not fit the data it should be applied to. */
+    private fromDelta(base: Held, answer: SemanticTokens | SemanticTokensDelta): SemanticTokens | null {
+        if (!('edits' in answer)) {
+            return answer;
+        }
+        const data = applySemanticEdits(base.data, answer.edits);
+        return data === null ? null : { ...(answer.resultId === undefined ? {} : { resultId: answer.resultId }), data };
+    }
+
+    private hold(tokens: SemanticTokens | null): void {
+        this.held = tokens?.resultId === undefined ? null : { resultId: tokens.resultId, data: tokens.data };
+    }
+
+    /* Draws the lines of a range answer. A fresh one replaces everything drawn, an extension keeps the lines it did not cover. */
+    private async askRange(range: EditorRange, legend: SemanticTokensLegend, signal: AbortSignal, fresh: boolean): Promise<void> {
+        const { service } = this.language.project;
+        const { editor, uri } = this.language;
+        const epoch = this.epoch;
+        const before = this.covered;
+        const tokens = await service.semanticTokensRange(uri, range, { signal });
+        if (signal.aborted || epoch !== this.epoch || this.complete) {
+            return;
+        }
+        const decoded = tokens === null ? [] : decodeSemanticTokens(tokens, legend);
+        if (fresh || before === null || range.start.line > before.end.line + 1 || range.end.line < before.start.line - 1) {
+            this.covered = range;
+            this.drawn = decoded;
+        } else {
+            const kept = this.drawn.filter((token) => token.line < range.start.line || token.line > range.end.line);
+            this.drawn = [...kept, ...decoded];
+            this.covered = {
+                start: before.start.line < range.start.line ? before.start : range.start,
+                end: before.end.line > range.end.line ? before.end : range.end
+            };
+        }
+        editor.setSemanticTokens(this.drawn);
+        if (!this.complete && this.covered !== null && !covers(this.covered, editor.getVisibleRange())) {
+            this.scrolled.later();
+        }
+    }
+
+    private async fillViewport(signal: AbortSignal): Promise<void> {
+        const { service } = this.language.project;
+        const legend = this.legend();
+        if (legend === undefined || !service.supports(RANGE, this.language.uri) || this.complete) {
+            return;
+        }
+        await this.askRange(this.viewport(), legend, signal, false);
+    }
 }

package/src/shortcut-keys.ts

@@ -1,4 +1,4 @@
-import { chordOf, KEYMAP_IDS, parseChord, type Keymap } from '@adecore/editor/keymap';
+import { chordOf, KEYMAP_IDS, parseChord, type Keymap, typesInsteadOfChord } from '@adecore/editor/keymap';
 import type { KeyChord } from '@adecore/editor';
 import { matchesShortcut } from '@adecore/ui';
 
@@ -16,6 +16,10 @@ export function shortcutsOf(keymap: Keymap, apple: boolean) {
     return { ...shortcuts, rename: shortcuts.renameSymbol };
 }
 
+/* Ctrl and Alt together that type a character, as AltGr does on some layouts, are no shortcut. */
 export function isShortcut(target: LanguageShortcut | null, event: KeyboardEvent): boolean {
-    return target !== null && matchesShortcut(target, event, target.apple);
+    if (target === null || typesInsteadOfChord(event, target.apple)) {
+        return false;
+    }
+    return matchesShortcut(target, event, target.apple);
 }

package/src/signature.ts

@@ -31,7 +31,7 @@ export class SignatureFeature {
             editor.onCaret(() => this.retrigger()),
             editor.onBlur(() => this.close()),
             editor.onKeyDown((event) => {
-                if (event.key === 'Escape' && this.isOpen) {
+                if (event.key === 'Escape' && this.isOpen && this.language.popups.getState().callHierarchy == null) {
                     this.close();
                     return true;
                 }

package/src/snippet-field-transforms.ts

@@ -0,0 +1,144 @@
+import type { Editor, EditorContentChange, EditorRange } from '@adecore/editor';
+import { comparePositions, shiftPosition } from './diagnostics-model.ts';
+import type { SnippetTransform } from './snippet.ts';
+import type { SnippetTransformLease } from './snippet-transform-queue.ts';
+import type { SnippetTransformJob } from './snippet-transform-protocol.ts';
+
+export interface FieldTransformTarget {
+    readonly id: symbol;
+    range: EditorRange;
+    readonly value: string;
+    readonly transform: SnippetTransform;
+    readonly parents?: readonly number[];
+    readonly owner: object;
+    readonly frame: object;
+    readonly order: readonly number[];
+    readonly ancestors?: readonly symbol[];
+}
+interface Entry {
+    readonly targets: FieldTransformTarget[];
+    readonly current: () => boolean;
+    readonly done: Promise<void>;
+    readonly finish: () => void;
+    cancelled: boolean;
+}
+
+/* Navigation frames can pop before a worker replies; their tracked targets live independently. */
+export class SnippetFieldTransforms {
+    private readonly entries = new Set<Entry>();
+    private applying: Entry | null = null;
+    private readonly editor: Editor;
+    private readonly lease: SnippetTransformLease | null;
+    private readonly apply: (targets: readonly FieldTransformTarget[], values: readonly string[]) => void;
+    constructor(editor: Editor, lease: SnippetTransformLease | null, apply: (targets: readonly FieldTransformTarget[], values: readonly string[]) => void) {
+        this.editor = editor;
+        this.lease = lease;
+        this.apply = apply;
+    }
+    get pending(): boolean {
+        return this.entries.size > 0;
+    }
+    get ranges(): number {
+        return [...this.entries].reduce((sum, entry) => sum + entry.targets.length, 0);
+    }
+    async settle(): Promise<void> {
+        await Promise.all([...this.entries].map((entry) => entry.done));
+    }
+    enqueue(targets: FieldTransformTarget[], current: () => boolean): void {
+        if (targets.length === 0 || this.lease === null) {
+            return;
+        }
+        let finish!: () => void;
+        const done = new Promise<void>((resolve) => {
+            finish = resolve;
+        });
+        const entry: Entry = { targets, current, done, finish, cancelled: false };
+        this.entries.add(entry);
+        const jobs: SnippetTransformJob[] = [],
+            keys = new Map<string, number>();
+        const slots = targets.map((target) => {
+            const job = { ...target.transform, value: target.value },
+                key = JSON.stringify(job);
+            let slot = keys.get(key);
+            if (slot === undefined) {
+                slot = jobs.length;
+                keys.set(key, slot);
+                jobs.push(job);
+            }
+            return slot;
+        });
+        const valid = (): boolean => !entry.cancelled && entry.current() && targets.every((target) => this.editor.textInRange(target.range) === target.value);
+        void this.lease
+            .request(jobs, { kind: 'exit', current: valid })
+            .then((values) => {
+                if (!valid()) {
+                    return;
+                }
+                this.applying = entry;
+                try {
+                    this.apply(
+                        targets,
+                        slots.map((slot) => values[slot]!)
+                    );
+                } finally {
+                    this.applying = null;
+                }
+            })
+            .catch(() => {
+                /* Failed exits retain the raw field value without retrying. */
+            })
+            .finally(() => {
+                this.entries.delete(entry);
+                finish();
+            });
+    }
+    prune(): void {
+        for (const entry of this.entries) {
+            if (!entry.current()) {
+                this.cancel(entry);
+            }
+        }
+    }
+    clear(): void {
+        for (const entry of this.entries) {
+            this.cancel(entry);
+        }
+    }
+    private cancel(entry: Entry): void {
+        entry.cancelled = true;
+        this.entries.delete(entry);
+        entry.finish();
+    }
+    edited(changes: readonly EditorContentChange[], detached?: <Range extends EditorRange>(range: Range) => Range): void {
+        for (const entry of this.entries) {
+            if (entry === this.applying) {
+                continue;
+            }
+            for (const target of entry.targets) {
+                let { start, end } = target.range;
+                for (const change of changes) {
+                    const empty = comparePositions(start, end) === 0;
+                    const insert = comparePositions(change.range.start, change.range.end) === 0;
+                    const overlaps = insert
+                        ? empty
+                            ? comparePositions(start, change.range.start) === 0
+                            : comparePositions(start, change.range.start) < 0 && comparePositions(change.range.start, end) < 0
+                        : empty
+                          ? comparePositions(change.range.start, start) <= 0 && comparePositions(start, change.range.end) < 0
+                          : comparePositions(change.range.start, end) < 0 && comparePositions(start, change.range.end) < 0;
+                    if (overlaps && !(detached !== undefined && empty && insert)) {
+                        this.cancel(entry);
+                        break;
+                    }
+                    const insertAtEnd = insert && !empty && comparePositions(end, change.range.start) === 0;
+                    start = shiftPosition(start, change);
+                    end = insertAtEnd ? end : shiftPosition(end, change);
+                }
+                target.range = detached === undefined ? { start, end } : detached({ ...target.range, order: target.order });
+                if (entry.cancelled) {
+                    break;
+                }
+            }
+        }
+    }
+}

package/src/snippet-indent.ts

@@ -0,0 +1,53 @@
+import { snippetOrderOf, withSnippetOrder } from './snippet-range-order.ts';
+import { MAX_SNIPPET_TEXT, type ParsedSnippet, type SnippetRange } from './snippet.ts';
+
+/* Indentation edits map the offsets once, including child projections in copied parents. */
+export function indentSnippet(parsed: ParsedSnippet, before: string): ParsedSnippet {
+    const prefix = /^[\t ]*/.exec(before)?.[0] ?? '';
+    if (prefix === '' || !parsed.text.includes('\n')) {
+        return parsed;
+    }
+    const insertions: number[] = [];
+    for (let offset = parsed.text.indexOf('\n'); offset !== -1; offset = parsed.text.indexOf('\n', offset + 1)) {
+        insertions.push(offset + 1);
+    }
+    if (parsed.text.length + insertions.length * prefix.length > MAX_SNIPPET_TEXT) {
+        return { text: parsed.text, stops: [], limited: true };
+    }
+    const shift = (offset: number, after = true): number => {
+        let low = 0;
+        let high = insertions.length;
+        while (low < high) {
+            const middle = (low + high) >>> 1;
+            if (insertions[middle]! < offset || (after && insertions[middle] === offset)) {
+                low = middle + 1;
+            } else {
+                high = middle;
+            }
+        }
+        return offset + low * prefix.length;
+    };
+    const range = <Range extends SnippetRange>(range: Range): Range =>
+        withSnippetOrder(
+            {
+                ...range,
+                start: shift(range.start),
+                end: shift(range.end, range.start === range.end || range.tail === true)
+            },
+            snippetOrderOf(range)
+        );
+    return {
+        text: parsed.text.replace(/\n/g, '\n' + prefix),
+        stops: parsed.stops.map((stop) => range(stop)),
+        ...(parsed.transforms === undefined ? {} : { transforms: parsed.transforms.map((transform) => range(transform)) }),
+        ...(parsed.fields === undefined
+            ? {}
+            : {
+                  fields: parsed.fields.map((field) => ({
+                      ...field,
+                      ranges: field.ranges.map((child) => range(child)),
+                      ...(field.linked === undefined ? {} : { linked: field.linked.map((child) => range(child)) })
+                  }))
+              })
+    };
+}

package/src/snippet-range-order.ts

@@ -0,0 +1,19 @@
+/* Source order disambiguates empty stops without changing the public parsed range shape. */
+const orders = new WeakMap<object, number>();
+export function snippetOrderOf(range: object): number | undefined {
+    return orders.get(range);
+}
+export function withSnippetOrder<Range extends object>(range: Range, order: number | undefined): Range {
+    if (order !== undefined) {
+        orders.set(range, order);
+    }
+    return range;
+}
+export function compareSnippetOrder(left: readonly number[], right: readonly number[]): number {
+    for (let index = 0; index < Math.min(left.length, right.length); index++) {
+        if (left[index] !== right[index]) {
+            return left[index]! - right[index]!;
+        }
+    }
+    return left.length - right.length;
+}