@adecore/editor 0.22.0 → 0.23.0

package/src/geometry-stops.ts

@@ -0,0 +1,51 @@
+import type { Affinity, LineGeometry } from './layout.ts';
+
+export function stopCount(geometry: LineGeometry): number {
+    return geometry.uniform === undefined ? geometry.offsets.length : geometry.text.length + 1;
+}
+
+export function offsetOfStop(geometry: LineGeometry, stop: number): number {
+    return geometry.uniform === undefined ? geometry.offsets[stop]! : stop;
+}
+
+export function rowOfStop(geometry: LineGeometry, stop: number): number {
+    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: LineGeometry, stop: number, affinity: Affinity = 'before'): number {
+    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: LineGeometry, offset: number): number {
+    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/src/grammar-preparation.ts

@@ -0,0 +1,158 @@
+import type { DocumentChange, DocumentModel } from '@adecore/editor-core';
+import type { LineTokenizer } from './types.ts';
+
+type Schedule = (callback: () => void, delay: number) => () => void;
+const scheduleTimer: Schedule = (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 {
+    private tokenizer: LineTokenizer | null = null;
+    private generation = 0;
+    private pending: string[] = [];
+    private size = 0;
+    private lastLine = -1;
+    private full = false;
+    private running = false;
+    private due = false;
+    private paused = false;
+    private disposed = false;
+    private cancelTimer: (() => void) | null = null;
+
+    private readonly model: Pick<DocumentModel, 'getText' | 'getLine' | 'positionAt'>;
+    private readonly changed: () => void;
+    private readonly schedule: Schedule;
+
+    constructor(model: Pick<DocumentModel, 'getText' | 'getLine' | 'positionAt'>, changed: () => void, schedule: Schedule = scheduleTimer) {
+        this.model = model;
+        this.changed = changed;
+        this.schedule = schedule;
+    }
+
+    begin(): void {
+        this.generation++;
+        this.tokenizer = null;
+        this.clear();
+    }
+
+    ready(tokenizer: LineTokenizer | null): void {
+        this.tokenizer = tokenizer;
+        this.scheduleFlush();
+    }
+
+    edited(batches: readonly (readonly DocumentChange[])[]): void {
+        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: boolean): void {
+        if (this.paused === paused) {
+            return;
+        }
+        this.paused = paused;
+        this.generation++;
+        this.clear();
+        if (!paused) {
+            this.full = true;
+            this.scheduleFlush();
+        }
+    }
+
+    dispose(): void {
+        this.disposed = true;
+        this.generation++;
+        this.clear();
+        this.tokenizer = null;
+    }
+
+    private clear(): void {
+        this.cancelTimer?.();
+        this.cancelTimer = null;
+        this.pending = [];
+        this.size = 0;
+        this.lastLine = -1;
+        this.full = false;
+        this.due = false;
+    }
+
+    private scheduleFlush(): void {
+        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);
+    }
+
+    private async flush(): Promise<void> {
+        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/src/index.ts

@@ -1,4 +1,6 @@
+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';
@@ -28,18 +30,24 @@ export type {
     EditorFindState,
     EditorReplaceOptions,
     EditorGutterAction,
+    EditorGutterIcon,
     EditorGutterMarker,
+    EditorReplacement,
     EditorIndentation,
     EditorContentChange,
     EditorHighlight,
     EditorHighlightKind,
     EditorHover,
     EditorGhostText,
+    EditorInlayClick,
+    EditorInlayClickHandler,
     EditorInlayHint,
+    EditorInlayTarget,
     EditorKeyHandler,
     EditorLineAction,
     EditorLineHighlight,
     EditorMarker,
+    EditorInputPopup,
     EditorMessages,
     EditorMarkerSeverity,
     EditorReveal,
@@ -49,6 +57,7 @@ export type {
     EditorPosition,
     EditorRemoteCursor,
     EditorRange,
+    EditorApplyEditsOptions,
     EditorTextChange,
     EditorTrackedRange,
     EditorRunCommand,
@@ -59,6 +68,7 @@ export type {
     FoldRole,
     KeyChord,
     LineToken,
+    LineTokenKind,
     ScopeColorSource,
     ScopeColors,
     ScopeStyle,

package/src/keymap-table.ts

@@ -105,6 +105,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'),
@@ -120,7 +122,10 @@ export const KEYMAP = {
 
 export type KeymapId = keyof typeof KEYMAP;
 
-export type Keymap = Readonly<Record<KeymapId, KeyBinding>>;
+/* Commands added after a host may have written a full keymap of its own; a keymap without one falls back to the built-in chord. */
+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 const KEYMAP_IDS = Object.keys(KEYMAP) as KeymapId[];
@@ -131,7 +136,7 @@ export function resolveKeymap(overrides: KeymapOverrides = {}): Keymap {
 
 /* The chord of a command on a platform, or null when the platform has none. */
 export function chordOf(id: KeymapId, apple: boolean, keymap: Keymap = KEYMAP): string | null {
-    return keymap[id][apple ? 'mac' : 'other'];
+    return (keymap[id] ?? KEYMAP[id])[apple ? 'mac' : 'other'];
 }
 
 const MODIFIERS = new Map<string, 'mod' | 'ctrl' | 'meta' | 'alt' | 'shift'>([
@@ -161,3 +166,40 @@ export function parseChord(text: string): KeyChord {
     }
     return chord;
 }
+
+const BASE_PUNCTUATION: Readonly<Record<string, string>> = {
+    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: string): string | null {
+    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: { key: string; code?: string; ctrlKey: boolean; altKey: boolean }, apple: boolean): boolean {
+    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/src/keymap.ts

@@ -1,5 +1,5 @@
 import type { EditorCommand } from '@adecore/editor-core';
-import { chordOf, KEYMAP, KEYMAP_IDS, type Keymap, type KeymapId, parseChord } from './keymap-table.ts';
+import { chordOf, KEYMAP, KEYMAP_IDS, type Keymap, type KeymapId, parseChord, typesInsteadOfChord } from './keymap-table.ts';
 import type { EditorViewCommand, KeyChord } from './types.ts';
 
 export interface KeyLike {
@@ -10,6 +10,7 @@ export interface KeyLike {
     metaKey: boolean;
     altKey: boolean;
     shiftKey: boolean;
+    getModifierState?(key: string): boolean;
 }
 
 export type MoveKey = 'ArrowLeft' | 'ArrowRight' | 'ArrowUp' | 'ArrowDown' | 'PageUp' | 'PageDown';
@@ -129,6 +130,9 @@ function keyMatches(chordKey: string, event: KeyLike): boolean {
 
 /* 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: KeyChord, event: KeyLike, apple: boolean): boolean {
+    if (typesInsteadOfChord(event, apple)) {
+        return false;
+    }
     const wantsMeta = chord.meta || (chord.mod && apple);
     const wantsCtrl = chord.ctrl || (chord.mod && !apple);
     return (

package/src/layout-changes.ts

@@ -0,0 +1,33 @@
+import type { DocumentChange } from '@adecore/editor-core';
+import { offsetMapper } from './offsets.ts';
+
+export interface LineBounds {
+    start: number;
+    end: number;
+}
+
+export function lineChangeMapper(batches: readonly (readonly DocumentChange[])[]): (bounds: LineBounds) => LineBounds | null {
+    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 };
+    };
+}