@adecore/editor-react 0.22.1 → 0.23.1

package/dist/semantic-tokens.js

@@ -1,36 +1,196 @@
+import { StaleResultError } from '@adecore/lsp';
+import { covers, withMargin } from './inlay-hints.js';
+import { lineTextOf } from './line-text.js';
 import { Refresher } from './refresher.js';
+import { applySemanticEdits } from './semantic-delta.js';
 import { decodeSemanticTokens } from './semantic-model.js';
 import { realTimers } from './timers.js';
-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;
 /*
  * 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 {
     refresher;
-    constructor(language, 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));
+    scrolled;
+    language;
+    options;
+    held = null;
+    heldLegend = '';
+    /* True once the whole document is drawn from a full answer; a range answer then no longer paints. */
+    complete = false;
+    /* The lines a range answer drew, null when nothing of that kind is on screen. */
+    covered = null;
+    drawn = [];
+    epoch = 0;
+    constructor(language, timers = realTimers, options = {}) {
+        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();
             }
-        }, PAUSE_MS, timers);
-        const edits = editor.onTextChange(() => this.refresher.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. */
+    forget() {
+        this.held = null;
+        this.complete = false;
+        this.covered = null;
+    }
+    legend() {
+        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;
+    }
+    isLarge() {
+        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));
+    }
+    viewport() {
+        const { editor } = this.language;
+        return withMargin(editor.getVisibleRange(), editor.positionAt(Number.MAX_SAFE_INTEGER), (line) => ({
+            line,
+            character: lineTextOf(editor, line).length
+        }));
+    }
+    async refresh(signal) {
+        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. */
+    async askFull(signal) {
+        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) => {
+                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. */
+    fromDelta(base, answer) {
+        if (!('edits' in answer)) {
+            return answer;
+        }
+        const data = applySemanticEdits(base.data, answer.edits);
+        return data === null ? null : { ...(answer.resultId === undefined ? {} : { resultId: answer.resultId }), data };
+    }
+    hold(tokens) {
+        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. */
+    async askRange(range, legend, signal, fresh) {
+        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();
+        }
+    }
+    async fillViewport(signal) {
+        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/dist/shortcut-keys.d.ts

@@ -10,6 +10,7 @@ export declare function shortcutsOf(keymap: Keymap, apple: boolean): {
     addCaretBelow: LanguageShortcut | null;
     addCaretPerSelectedLine: LanguageShortcut | null;
     autoIndentLines: LanguageShortcut | null;
+    callHierarchy: LanguageShortcut | null;
     codeActions: LanguageShortcut | null;
     collapse: LanguageShortcut | null;
     collapseAll: LanguageShortcut | null;
@@ -82,6 +83,7 @@ export declare function shortcutsOf(keymap: Keymap, apple: boolean): {
     toggleCase: LanguageShortcut | null;
     toggleColumnMode: LanguageShortcut | null;
     toggleLineComment: LanguageShortcut | null;
+    toggleRenderedDocs: LanguageShortcut | null;
     triggerCompletion: LanguageShortcut | null;
     undo: LanguageShortcut | null;
     unselectOccurrence: LanguageShortcut | null;

package/dist/shortcut-keys.js

@@ -1,4 +1,4 @@
-import { chordOf, KEYMAP_IDS, parseChord } from '@adecore/editor/keymap';
+import { chordOf, KEYMAP_IDS, parseChord, typesInsteadOfChord } from '@adecore/editor/keymap';
 import { matchesShortcut } from '@adecore/ui';
 export function shortcutsOf(keymap, apple) {
     const shortcuts = Object.fromEntries(KEYMAP_IDS.map((id) => {
@@ -7,6 +7,10 @@ export function shortcutsOf(keymap, apple) {
     }));
     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, event) {
-    return target !== null && matchesShortcut(target, event, target.apple);
+    if (target === null || typesInsteadOfChord(event, target.apple)) {
+        return false;
+    }
+    return matchesShortcut(target, event, target.apple);
 }

package/dist/signature.js

@@ -25,7 +25,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/dist/snippet-field-transforms.d.ts

@@ -0,0 +1,30 @@
+import type { Editor, EditorContentChange, EditorRange } from '@adecore/editor';
+import type { SnippetTransform } from './snippet.ts';
+import type { SnippetTransformLease } from './snippet-transform-queue.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[];
+}
+export declare class SnippetFieldTransforms {
+    private readonly entries;
+    private applying;
+    private readonly editor;
+    private readonly lease;
+    private readonly apply;
+    constructor(editor: Editor, lease: SnippetTransformLease | null, apply: (targets: readonly FieldTransformTarget[], values: readonly string[]) => void);
+    get pending(): boolean;
+    get ranges(): number;
+    settle(): Promise<void>;
+    enqueue(targets: FieldTransformTarget[], current: () => boolean): void;
+    prune(): void;
+    clear(): void;
+    private cancel;
+    edited(changes: readonly EditorContentChange[], detached?: <Range extends EditorRange>(range: Range) => Range): void;
+}

package/dist/snippet-field-transforms.js

@@ -0,0 +1,116 @@
+import { comparePositions, shiftPosition } from './diagnostics-model.js';
+/* Navigation frames can pop before a worker replies; their tracked targets live independently. */
+export class SnippetFieldTransforms {
+    entries = new Set();
+    applying = null;
+    editor;
+    lease;
+    apply;
+    constructor(editor, lease, apply) {
+        this.editor = editor;
+        this.lease = lease;
+        this.apply = apply;
+    }
+    get pending() {
+        return this.entries.size > 0;
+    }
+    get ranges() {
+        return [...this.entries].reduce((sum, entry) => sum + entry.targets.length, 0);
+    }
+    async settle() {
+        await Promise.all([...this.entries].map((entry) => entry.done));
+    }
+    enqueue(targets, current) {
+        if (targets.length === 0 || this.lease === null) {
+            return;
+        }
+        let finish;
+        const done = new Promise((resolve) => {
+            finish = resolve;
+        });
+        const entry = { targets, current, done, finish, cancelled: false };
+        this.entries.add(entry);
+        const jobs = [], keys = new Map();
+        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 = () => !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() {
+        for (const entry of this.entries) {
+            if (!entry.current()) {
+                this.cancel(entry);
+            }
+        }
+    }
+    clear() {
+        for (const entry of this.entries) {
+            this.cancel(entry);
+        }
+    }
+    cancel(entry) {
+        entry.cancelled = true;
+        this.entries.delete(entry);
+        entry.finish();
+    }
+    edited(changes, detached) {
+        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/dist/snippet-indent.d.ts

@@ -0,0 +1,2 @@
+import { type ParsedSnippet } from './snippet.ts';
+export declare function indentSnippet(parsed: ParsedSnippet, before: string): ParsedSnippet;

package/dist/snippet-indent.js

@@ -0,0 +1,49 @@
+import { snippetOrderOf, withSnippetOrder } from './snippet-range-order.js';
+import { MAX_SNIPPET_TEXT } from './snippet.js';
+/* Indentation edits map the offsets once, including child projections in copied parents. */
+export function indentSnippet(parsed, before) {
+    const prefix = /^[\t ]*/.exec(before)?.[0] ?? '';
+    if (prefix === '' || !parsed.text.includes('\n')) {
+        return parsed;
+    }
+    const insertions = [];
+    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, after = true) => {
+        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) => 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/dist/snippet-range-order.d.ts

@@ -0,0 +1,3 @@
+export declare function snippetOrderOf(range: object): number | undefined;
+export declare function withSnippetOrder<Range extends object>(range: Range, order: number | undefined): Range;
+export declare function compareSnippetOrder(left: readonly number[], right: readonly number[]): number;

package/dist/snippet-range-order.js

@@ -0,0 +1,19 @@
+/* Source order disambiguates empty stops without changing the public parsed range shape. */
+const orders = new WeakMap();
+export function snippetOrderOf(range) {
+    return orders.get(range);
+}
+export function withSnippetOrder(range, order) {
+    if (order !== undefined) {
+        orders.set(range, order);
+    }
+    return range;
+}
+export function compareSnippetOrder(left, right) {
+    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;
+}

package/dist/snippet-session.d.ts

@@ -1,17 +1,53 @@
-import type { EditorPosition } from '@adecore/editor';
+import { type Timers } from './timers.ts';
+import { type SnippetTransformJob } from './snippet-transform-protocol.ts';
+import type { EditorContentChange, EditorPosition, EditorRange } from '@adecore/editor';
 import type { EditorLanguage } from './editor-language.ts';
-import type { SnippetStop } from './snippet.ts';
+import type { SnippetField, SnippetStop } from './snippet.ts';
 export declare function positionInInsertion(start: EditorPosition, text: string, offset: number): EditorPosition;
+export interface SnippetInsertion {
+    readonly start: EditorPosition;
+    readonly text: string;
+    readonly stops: readonly SnippetStop[];
+    readonly fields?: readonly SnippetField[];
+}
+type SnippetHost = Pick<EditorLanguage, 'editor' | 'onDispose'> & Partial<Pick<EditorLanguage, 'popups' | 'pick' | 'project'>>;
 export declare class SnippetFeature {
     private readonly language;
-    private stops;
-    private current;
-    constructor(language: EditorLanguage);
+    private frames;
+    private placed;
+    private visiting;
+    private applying;
+    private extras;
+    private generation;
+    private choicePrefix;
+    private readonly transforms;
+    private readonly fieldTransforms;
+    private exitGeneration;
+    private detached;
+    constructor(language: SnippetHost, timers?: Timers);
+    transformVariables(jobs: readonly SnippetTransformJob[], current?: () => boolean): Promise<readonly string[] | null>;
+    get hasPendingTransforms(): boolean;
+    settleTransforms(current: () => boolean, edited?: (changes: readonly EditorContentChange[], map: (range: EditorRange) => EditorRange) => void): Promise<boolean>;
     get isActive(): boolean;
-    begin(start: EditorPosition, text: string, stops: readonly SnippetStop[]): void;
+    get token(): number;
+    begin(start: EditorPosition | readonly EditorPosition[], text: string, stops: readonly SnippetStop[], fields?: readonly SnippetField[]): void;
+    beginInstances(insertions: readonly SnippetInsertion[], options?: {
+        nested?: boolean;
+    }): void;
+    applyEdits(changes: readonly EditorContentChange[], token: number, extras?: readonly EditorContentChange[]): boolean;
     end(): void;
+    private closeChoices;
+    private pop;
     private visit;
+    private announceField;
+    private fieldOf;
+    private openChoices;
+    private step;
     private key;
+    private exitField;
+    private applyFieldTransforms;
+    private mapFrame;
     private edited;
     private moved;
 }
+export {};