@adecore/editor 0.22.0 → 0.23.0

package/dist/geometry-stops.js

@@ -0,0 +1,47 @@
+export function stopCount(geometry) {
+    return geometry.uniform === undefined ? geometry.offsets.length : geometry.text.length + 1;
+}
+export function offsetOfStop(geometry, stop) {
+    return geometry.uniform === undefined ? geometry.offsets[stop] : stop;
+}
+export function rowOfStop(geometry, stop) {
+    if (geometry.uniform === undefined) {
+        return geometry.rowOf[stop];
+    }
+    let first = 0;
+    let last = geometry.rowStarts.length;
+    while (first < last) {
+        const middle = (first + last) >>> 1;
+        if (geometry.rowStarts[middle] <= stop) {
+            first = middle + 1;
+        }
+        else {
+            last = middle;
+        }
+    }
+    return Math.max(0, first - 1);
+}
+export function xOfStop(geometry, stop, affinity = 'before') {
+    if (geometry.uniform === undefined) {
+        return geometry[affinity][stop];
+    }
+    const row = rowOfStop(geometry, stop);
+    return geometry.uniform[row === 0 ? 'first' : 'continuation'][stop - geometry.rowStarts[row]];
+}
+export function stopAtOffset(geometry, offset) {
+    if (geometry.uniform !== undefined) {
+        return Math.min(geometry.text.length, Math.max(0, Math.ceil(offset)));
+    }
+    let first = 0;
+    let last = geometry.offsets.length;
+    while (first < last) {
+        const middle = (first + last) >>> 1;
+        if (geometry.offsets[middle] < offset) {
+            first = middle + 1;
+        }
+        else {
+            last = middle;
+        }
+    }
+    return Math.min(geometry.offsets.length - 1, first);
+}

package/dist/grammar-preparation.d.ts

@@ -0,0 +1,29 @@
+import type { DocumentChange, DocumentModel } from '@adecore/editor-core';
+import type { LineTokenizer } from './types.ts';
+type Schedule = (callback: () => void, delay: number) => () => void;
+export declare class GrammarPreparation {
+    private tokenizer;
+    private generation;
+    private pending;
+    private size;
+    private lastLine;
+    private full;
+    private running;
+    private due;
+    private paused;
+    private disposed;
+    private cancelTimer;
+    private readonly model;
+    private readonly changed;
+    private readonly schedule;
+    constructor(model: Pick<DocumentModel, 'getText' | 'getLine' | 'positionAt'>, changed: () => void, schedule?: Schedule);
+    begin(): void;
+    ready(tokenizer: LineTokenizer | null): void;
+    edited(batches: readonly (readonly DocumentChange[])[]): void;
+    pause(paused: boolean): void;
+    dispose(): void;
+    private clear;
+    private scheduleFlush;
+    private flush;
+}
+export {};

package/dist/grammar-preparation.js

@@ -0,0 +1,147 @@
+const scheduleTimer = (callback, delay) => {
+    const timer = setTimeout(callback, delay);
+    return () => clearTimeout(timer);
+};
+const MAX_BUFFER = 64 * 1024;
+/* Edits collect language declarations without making every key wait for grammar loading. */
+export class GrammarPreparation {
+    tokenizer = null;
+    generation = 0;
+    pending = [];
+    size = 0;
+    lastLine = -1;
+    full = false;
+    running = false;
+    due = false;
+    paused = false;
+    disposed = false;
+    cancelTimer = null;
+    model;
+    changed;
+    schedule;
+    constructor(model, changed, schedule = scheduleTimer) {
+        this.model = model;
+        this.changed = changed;
+        this.schedule = schedule;
+    }
+    begin() {
+        this.generation++;
+        this.tokenizer = null;
+        this.clear();
+    }
+    ready(tokenizer) {
+        this.tokenizer = tokenizer;
+        this.scheduleFlush();
+    }
+    edited(batches) {
+        if (this.disposed || this.paused) {
+            return;
+        }
+        if (this.tokenizer === null || batches.length !== 1) {
+            this.full = true;
+            this.lastLine = -1;
+        }
+        else if (this.tokenizer.prepare === undefined) {
+            return;
+        }
+        else if (!this.full) {
+            let shift = 0;
+            let through = -1;
+            for (const change of batches[0]) {
+                const first = this.model.positionAt(change.from + shift).line;
+                const last = this.model.positionAt(change.from + shift + change.insertedLength).line;
+                shift += change.insertedLength - (change.to - change.from);
+                for (let line = Math.max(first, through + 1); line <= last; line++) {
+                    const text = this.model.getLine(line).text;
+                    const replacing = batches[0].length === 1 && first === last && line === this.lastLine;
+                    if (replacing) {
+                        this.size -= this.pending.pop().length + 1;
+                    }
+                    this.size += text.length + 1;
+                    if (this.size > MAX_BUFFER) {
+                        this.full = true;
+                        this.pending = [];
+                        this.lastLine = -1;
+                        break;
+                    }
+                    this.pending.push(text);
+                    this.lastLine = line;
+                }
+                through = last;
+                if (this.full) {
+                    break;
+                }
+            }
+        }
+        this.scheduleFlush();
+    }
+    pause(paused) {
+        if (this.paused === paused) {
+            return;
+        }
+        this.paused = paused;
+        this.generation++;
+        this.clear();
+        if (!paused) {
+            this.full = true;
+            this.scheduleFlush();
+        }
+    }
+    dispose() {
+        this.disposed = true;
+        this.generation++;
+        this.clear();
+        this.tokenizer = null;
+    }
+    clear() {
+        this.cancelTimer?.();
+        this.cancelTimer = null;
+        this.pending = [];
+        this.size = 0;
+        this.lastLine = -1;
+        this.full = false;
+        this.due = false;
+    }
+    scheduleFlush() {
+        if (this.disposed || this.paused || this.tokenizer?.prepare === undefined || (!this.full && this.pending.length === 0)) {
+            return;
+        }
+        this.cancelTimer?.();
+        this.due = false;
+        this.cancelTimer = this.schedule(() => {
+            this.cancelTimer = null;
+            this.due = true;
+            void this.flush();
+        }, 200);
+    }
+    async flush() {
+        const tokenizer = this.tokenizer;
+        if (this.running || this.disposed || this.paused || tokenizer?.prepare === undefined || !this.due) {
+            return;
+        }
+        const generation = this.generation;
+        const text = this.full ? this.model.getText() : this.pending.join('\n');
+        this.pending = [];
+        this.size = 0;
+        this.lastLine = -1;
+        this.full = false;
+        this.due = false;
+        this.running = true;
+        try {
+            await tokenizer.prepare(text);
+            if (!this.disposed && !this.paused && generation === this.generation && tokenizer === this.tokenizer) {
+                // A load completed while paused may already have rebuilt this grammar.
+                this.changed();
+            }
+        }
+        catch {
+            // Keep the current colors; a later edit may retry the failed load.
+        }
+        finally {
+            this.running = false;
+            if (this.due) {
+                void this.flush();
+            }
+        }
+    }
+}

package/dist/index.d.ts

@@ -1,5 +1,7 @@
+export { MAX_REPLACEMENT_PAGE, MAX_REPLACEMENT_CHARACTERS } from './search-protocol.ts';
 export { AGENT_COLORS } from './attribution.ts';
+export { findDocComments, MAX_DOC_COMMENTS, type DocComment } from '@adecore/editor-core';
 export { createSmartEditorEngine } from './engine.ts';
 export { DEFAULT_SMART_KEYS } from './smart-keys.ts';
 export { shikiScopeColors, shikiTokenizers } from './shiki.ts';
-export type { Editor, EditorAttributionHover, EditorAttributionMark, EditorMarkColor, EditorBlock, EditorChangeKind, EditorChangeMark, EditorCodeVision, EditorCodeVisionEntry, EditorClick, EditorCodeBlockOptions, EditorClickHandler, EditorCommand, EditorContextMenu, EditorEngine, EditorFindQuery, EditorFoldHints, EditorFoldRangeHint, EditorFoldOutline, EditorFoldRange, EditorFoldSymbol, EditorFolds, EditorFindState, EditorReplaceOptions, EditorGutterAction, EditorGutterMarker, EditorIndentation, EditorContentChange, EditorHighlight, EditorHighlightKind, EditorHover, EditorGhostText, EditorInlayHint, EditorKeyHandler, EditorLineAction, EditorLineHighlight, EditorMarker, EditorMessages, EditorMarkerSeverity, EditorReveal, EditorRect, EditorSmartKeys, EditorOptions, EditorPosition, EditorRemoteCursor, EditorRange, EditorTextChange, EditorTrackedRange, EditorRunCommand, EditorSelectionRanges, EditorTheme, EditorViewCommand, EditorWidget, FoldRole, KeyChord, LineToken, ScopeColorSource, ScopeColors, ScopeStyle, EditorSemanticToken, LineTokenizer, SmartEditorEngineOptions, TokenizedLine, TokenizerSource } from './types.ts';
+export type { Editor, EditorAttributionHover, EditorAttributionMark, EditorMarkColor, EditorBlock, EditorChangeKind, EditorChangeMark, EditorCodeVision, EditorCodeVisionEntry, EditorClick, EditorCodeBlockOptions, EditorClickHandler, EditorCommand, EditorContextMenu, EditorEngine, EditorFindQuery, EditorFoldHints, EditorFoldRangeHint, EditorFoldOutline, EditorFoldRange, EditorFoldSymbol, EditorFolds, EditorFindState, EditorReplaceOptions, EditorGutterAction, EditorGutterIcon, EditorGutterMarker, EditorReplacement, EditorIndentation, EditorContentChange, EditorHighlight, EditorHighlightKind, EditorHover, EditorGhostText, EditorInlayClick, EditorInlayClickHandler, EditorInlayHint, EditorInlayTarget, EditorKeyHandler, EditorLineAction, EditorLineHighlight, EditorMarker, EditorInputPopup, EditorMessages, EditorMarkerSeverity, EditorReveal, EditorRect, EditorSmartKeys, EditorOptions, EditorPosition, EditorRemoteCursor, EditorRange, EditorApplyEditsOptions, EditorTextChange, EditorTrackedRange, EditorRunCommand, EditorSelectionRanges, EditorTheme, EditorViewCommand, EditorWidget, FoldRole, KeyChord, LineToken, LineTokenKind, ScopeColorSource, ScopeColors, ScopeStyle, EditorSemanticToken, LineTokenizer, SmartEditorEngineOptions, TokenizedLine, TokenizerSource } from './types.ts';

package/dist/index.js

@@ -1,4 +1,6 @@
+export { MAX_REPLACEMENT_PAGE, MAX_REPLACEMENT_CHARACTERS } from './search-protocol.js';
 export { AGENT_COLORS } from './attribution.js';
+export { findDocComments, MAX_DOC_COMMENTS } from '@adecore/editor-core';
 export { createSmartEditorEngine } from './engine.js';
 export { DEFAULT_SMART_KEYS } from './smart-keys.js';
 export { shikiScopeColors, shikiTokenizers } from './shiki.js';

package/dist/keymap-table.d.ts

@@ -82,6 +82,8 @@ export declare const KEYMAP: {
     readonly goToImplementation: KeyBinding;
     readonly peekDefinition: KeyBinding;
     readonly peekReferences: KeyBinding;
+    readonly callHierarchy: KeyBinding;
+    readonly toggleRenderedDocs: KeyBinding;
     readonly historyBack: KeyBinding;
     readonly historyForward: KeyBinding;
     readonly recentLocations: KeyBinding;
@@ -94,9 +96,16 @@ export declare const KEYMAP: {
     readonly replace: KeyBinding;
 };
 export type KeymapId = keyof typeof KEYMAP;
-export type Keymap = Readonly<Record<KeymapId, KeyBinding>>;
+export type OptionalKeymapId = 'toggleRenderedDocs';
+export type Keymap = Readonly<Record<Exclude<KeymapId, OptionalKeymapId>, KeyBinding> & Partial<Record<OptionalKeymapId, KeyBinding>>>;
 export type KeymapOverrides = Partial<Record<KeymapId, Partial<KeyBinding>>>;
 export declare const KEYMAP_IDS: KeymapId[];
 export declare function resolveKeymap(overrides?: KeymapOverrides): Keymap;
 export declare function chordOf(id: KeymapId, apple: boolean, keymap?: Keymap): string | null;
 export declare function parseChord(text: string): KeyChord;
+export declare function typesInsteadOfChord(event: {
+    key: string;
+    code?: string;
+    ctrlKey: boolean;
+    altKey: boolean;
+}, apple: boolean): boolean;

package/dist/keymap-table.js

@@ -81,6 +81,8 @@ export const KEYMAP = {
     goToImplementation: bind('Mod+Alt+B'),
     peekDefinition: bind('Alt+Space', 'Ctrl+Shift+I'),
     peekReferences: bind('Alt+F7'),
+    callHierarchy: bind('Ctrl+Alt+H'),
+    toggleRenderedDocs: bind('Ctrl+Alt+Q'),
     historyBack: bind('Mod+[', 'Ctrl+Alt+ArrowLeft'),
     historyForward: bind('Mod+]', 'Ctrl+Alt+ArrowRight'),
     recentLocations: bind('Mod+Shift+E'),
@@ -98,7 +100,7 @@ export function resolveKeymap(overrides = {}) {
 }
 /* The chord of a command on a platform, or null when the platform has none. */
 export function chordOf(id, apple, keymap = KEYMAP) {
-    return keymap[id][apple ? 'mac' : 'other'];
+    return (keymap[id] ?? KEYMAP[id])[apple ? 'mac' : 'other'];
 }
 const MODIFIERS = new Map([
     ['Mod', 'mod'],
@@ -128,3 +130,37 @@ export function parseChord(text) {
     }
     return chord;
 }
+const BASE_PUNCTUATION = {
+    Comma: ',',
+    Period: '.',
+    Slash: '/',
+    Semicolon: ';',
+    Quote: "'",
+    Backquote: '`',
+    Backslash: '\\',
+    BracketLeft: '[',
+    BracketRight: ']',
+    Minus: '-',
+    Equal: '='
+};
+/* The character a physical key has with no layer on it, null for a key that has none, such as an arrow or Enter. */
+function baseCharacter(code) {
+    const letter = /^Key([A-Z])$/.exec(code);
+    if (letter !== null) {
+        return letter[1].toLowerCase();
+    }
+    const digit = /^(?:Digit|Numpad)([0-9])$/.exec(code);
+    return digit !== null ? digit[1] : (BASE_PUNCTUATION[code] ?? null);
+}
+/*
+ * Whether Ctrl and Alt together type a character instead of pressing a chord. AltGr reports both, on Windows even
+ * for the left Ctrl and Alt, and a browser may report AltGraph for Option, so the state is no evidence: the character is.
+ * Never on Apple platforms, where Option types with no Ctrl.
+ */
+export function typesInsteadOfChord(event, apple) {
+    if (apple || !event.ctrlKey || !event.altKey || event.code === undefined || [...event.key].length !== 1) {
+        return false;
+    }
+    const base = baseCharacter(event.code);
+    return base !== null && event.key.toLowerCase() !== base;
+}

package/dist/keymap.d.ts

@@ -8,6 +8,7 @@ export interface KeyLike {
     metaKey: boolean;
     altKey: boolean;
     shiftKey: boolean;
+    getModifierState?(key: string): boolean;
 }
 export type MoveKey = 'ArrowLeft' | 'ArrowRight' | 'ArrowUp' | 'ArrowDown' | 'PageUp' | 'PageDown';
 export type KeyAction = {

package/dist/keymap.js

@@ -1,4 +1,4 @@
-import { chordOf, KEYMAP, KEYMAP_IDS, parseChord } from './keymap-table.js';
+import { chordOf, KEYMAP, KEYMAP_IDS, parseChord, typesInsteadOfChord } from './keymap-table.js';
 const MOVES = new Set(['ArrowLeft', 'ArrowRight', 'ArrowUp', 'ArrowDown', 'PageUp', 'PageDown']);
 function command(name) {
     return { type: 'command', command: name };
@@ -98,6 +98,9 @@ function keyMatches(chordKey, event) {
 }
 /* Whether an event is a chord, with `mod` as Cmd on macOS and Ctrl elsewhere and every modifier the chord does not name up. */
 export function chordMatches(chord, event, apple) {
+    if (typesInsteadOfChord(event, apple)) {
+        return false;
+    }
     const wantsMeta = chord.meta || (chord.mod && apple);
     const wantsCtrl = chord.ctrl || (chord.mod && !apple);
     return (wantsMeta === event.metaKey &&

package/dist/layout-changes.d.ts

@@ -0,0 +1,6 @@
+import type { DocumentChange } from '@adecore/editor-core';
+export interface LineBounds {
+    start: number;
+    end: number;
+}
+export declare function lineChangeMapper(batches: readonly (readonly DocumentChange[])[]): (bounds: LineBounds) => LineBounds | null;

package/dist/layout-changes.js

@@ -0,0 +1,27 @@
+import { offsetMapper } from './offsets.js';
+export function lineChangeMapper(batches) {
+    const steps = batches.map((changes) => ({ changes, map: offsetMapper(changes) }));
+    return (bounds) => {
+        let { start, end } = bounds;
+        for (const { changes, map } of steps) {
+            let first = 0;
+            let last = changes.length;
+            while (first < last) {
+                const middle = (first + last) >>> 1;
+                if (changes[middle].to < start) {
+                    first = middle + 1;
+                }
+                else {
+                    last = middle;
+                }
+            }
+            // Touching either boundary can merge lines or change a CRLF ending.
+            if (changes[first] !== undefined && changes[first].from <= end) {
+                return null;
+            }
+            start = map(start);
+            end = map(end);
+        }
+        return { start, end };
+    };
+}

package/dist/layout.d.ts

@@ -1,5 +1,14 @@
-import type { Position } from '@adecore/editor-core';
+import type { DocumentChange, Position } from '@adecore/editor-core';
 export type Affinity = 'before' | 'after';
+export interface VerticalWindow {
+    top: number;
+    bottom: number;
+}
+export interface SubRowBand {
+    first: number;
+    last: number;
+}
+export declare function subRowBand(top: number, subRows: number, lineHeight: number, window: VerticalWindow, block?: number): SubRowBand;
 export interface LayoutDocument {
     getLineCount(): number;
     getLine(line: number): {
@@ -22,6 +31,9 @@ export interface Inlay {
     at: number;
     text: string;
     tooltip?: string;
+    parts?: readonly string[];
+    gapLeft?: number;
+    gapRight?: number;
     composition?: boolean;
     ghost?: boolean;
 }
@@ -34,6 +46,18 @@ export interface BlockWidget {
     height?: number;
     revision?: number;
     lens?: boolean;
+    fixed?: boolean;
+}
+export interface BlockReplacement {
+    id: string;
+    from: number;
+    to: number;
+    render: (container: HTMLElement) => void;
+    height?: number;
+    revision?: number;
+    label?: string;
+    enterable?: boolean;
+    onReveal?: () => void;
 }
 export interface FoldState {
     startLine: number;
@@ -55,6 +79,7 @@ export interface TextRow extends RowBase {
     tail: number | null;
     head: number | null;
     subRows: number;
+    replacement?: BlockReplacement;
 }
 export interface BlockRow extends RowBase {
     kind: 'block';
@@ -77,6 +102,7 @@ export interface InlineBox {
 export interface LineGeometry {
     start: number;
     end: number;
+    next: number;
     text: string;
     offsets: number[];
     before: number[];
@@ -84,6 +110,11 @@ export interface LineGeometry {
     rowOf: number[];
     rowStarts: number[];
     rowEnds: number[];
+    rowTriggers: number[];
+    uniform?: {
+        first: readonly number[];
+        continuation: readonly number[];
+    };
     runs: TextRun[];
     inlays: InlineBox[];
     subRows: number;
@@ -100,22 +131,32 @@ export declare const BOTTOM_PADDING = 8;
 export declare const RIGHT_PADDING = 16;
 export declare function wrapIndent(text: string, metrics: LayoutMetrics, limit: number): number;
 export declare function wrapStops(text: string, offsets: readonly number[], metrics: LayoutMetrics, limit: number): number[];
+export declare function scanDenseLine(line: {
+    start: number;
+    end: number;
+    text: string;
+    next?: number;
+}, metrics: LayoutMetrics, limit: number | null, lineInlays: readonly Inlay[]): LineGeometry;
 export declare function scanLine(line: {
     start: number;
     end: number;
     text: string;
+    next?: number;
 }, metrics: LayoutMetrics, limit: number | null, lineInlays: readonly Inlay[]): LineGeometry;
 export interface LayoutConfig {
     textChanged?: boolean;
+    changes?: readonly (readonly DocumentChange[])[];
     metrics?: LayoutMetrics;
     wrapWidth?: number | null;
     inlays?: readonly Inlay[];
     blocks?: readonly BlockWidget[];
     folds?: readonly FoldState[];
+    replacements?: readonly BlockReplacement[];
 }
 export declare class EditorLayout {
     rows: LayoutRow[];
     height: number;
+    lineHeightsVersion: number;
     width: number;
     private lineRows;
     private geometryCache;
@@ -125,12 +166,14 @@ export declare class EditorLayout {
     private inlays;
     private blocks;
     private folds;
+    private replacements;
     private wrapWidth;
     readonly document: LayoutDocument;
     metrics: LayoutMetrics;
     constructor(document: LayoutDocument, metrics: LayoutMetrics);
     get wrapping(): boolean;
     configure(config: LayoutConfig): void;
+    private retainGeometry;
     private rowCountOf;
     private rebuild;
     private clampToLine;
@@ -163,7 +206,7 @@ export declare class EditorLayout {
         offset: number;
         rowEnd: boolean;
     };
-    rectangles(from: number, to: number, rows: readonly LayoutRow[]): LayoutRect[];
+    rectangles(from: number, to: number, rows: readonly LayoutRow[], window?: VerticalWindow): LayoutRect[];
     verticalOffset(offset: number, direction: -1 | 1, x: number, distance?: number): number;
     horizontalOffset(offset: number, direction: -1 | 1): number;
 }