@adecore/editor 0.39.0 → 0.40.0

package/src/grammar-preparation.ts

@@ -2,10 +2,13 @@ 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. */
@@ -47,6 +50,7 @@ export class GrammarPreparation {
         if (this.disposed || this.paused) {
             return;
         }
+
         if (this.tokenizer === null || batches.length !== 1) {
             this.full = true;
             this.lastLine = -1;
@@ -55,32 +59,42 @@ export class GrammarPreparation {
         } 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();
     }
 
@@ -88,9 +102,11 @@ export class GrammarPreparation {
         if (this.paused === paused) {
             return;
         }
+
         this.paused = paused;
         this.generation++;
         this.clear();
+
         if (!paused) {
             this.full = true;
             this.scheduleFlush();
@@ -118,8 +134,10 @@ export class GrammarPreparation {
         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;
@@ -129,9 +147,11 @@ export class GrammarPreparation {
 
     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 = [];
@@ -140,8 +160,10 @@ export class GrammarPreparation {
         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();
@@ -150,6 +172,7 @@ export class GrammarPreparation {
             // 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

@@ -4,6 +4,7 @@ export { findDocComments, MAX_DOC_COMMENTS, type DocComment } from '@adecore/edi
 export { createSmartEditorEngine } from './engine.ts';
 export { DEFAULT_SMART_KEYS } from './smart-keys.ts';
 export { shikiScopeColors, shikiTokenizers } from './shiki.ts';
+
 export type {
     Editor,
     EditorAttributionHover,

package/src/input.ts

@@ -3,22 +3,28 @@ import type { Selection, TextEdit } from '@adecore/editor-core';
 /* The one stretch two texts differ in, found from both ends and never inside a surrogate pair. */
 export function findChange(before: string, after: string): TextEdit {
     let from = 0;
+
     while (from < before.length && from < after.length && before[from] === after[from]) {
         from++;
     }
+
     if (from > 0 && /[\uDC00-\uDFFF]/.test(before[from] ?? '') && /[\uD800-\uDBFF]/.test(before[from - 1]!)) {
         from--;
     }
+
     let endBefore = before.length;
     let endAfter = after.length;
+
     while (endBefore > from && endAfter > from && before[endBefore - 1] === after[endAfter - 1]) {
         endBefore--;
         endAfter--;
     }
+
     if (endBefore < before.length && /[\uDC00-\uDFFF]/.test(before[endBefore] ?? '') && /[\uD800-\uDBFF]/.test(before[endBefore - 1] ?? '')) {
         endBefore++;
         endAfter++;
     }
+
     return { from, to: endBefore, text: after.slice(from, endAfter) };
 }
 
@@ -27,15 +33,18 @@ export function replacementEdits(selections: readonly Selection[], text: string)
     const sorted = selections
         .map((selection, index) => ({ from: Math.min(selection.anchor, selection.head), to: Math.max(selection.anchor, selection.head), index }))
         .sort((left, right) => left.from - right.from);
+
     const edits: TextEdit[] = [];
     const positions: Selection[] = [];
     let delta = 0;
+
     for (const range of sorted) {
         edits.push({ from: range.from, to: range.to, text });
         const head = range.from + delta + text.length;
         positions[range.index] = { anchor: head, head };
         delta += text.length - (range.to - range.from);
     }
+
     return { edits, selections: positions };
 }
 
@@ -46,15 +55,19 @@ export function textareaText(text: string): string {
 /* A textarea normalizes CRLF; the model keeps its own UTF-16 offsets. */
 export function modelOffset(text: string, nativeOffset: number): number {
     let native = 0;
+
     for (let index = 0; index < text.length; index++) {
         if (native === nativeOffset) {
             return index;
         }
+
         if (text[index] === '\r' && text[index + 1] === '\n') {
             continue;
         }
+
         native++;
     }
+
     return text.length;
 }
 

package/src/keymap-table.ts

@@ -151,8 +151,10 @@ const MODIFIERS = new Map<string, 'mod' | 'ctrl' | 'meta' | 'alt' | 'shift'>([
 export function parseChord(text: string): KeyChord {
     const words = text.endsWith('++') ? [...text.slice(0, -2).split('+'), '+'] : text.split('+');
     const chord = { mod: false, ctrl: false, meta: false, alt: false, shift: false, key: '' };
+
     for (const word of words) {
         const modifier = MODIFIERS.get(word);
+
         if (modifier !== undefined) {
             chord[modifier] = true;
         } else if (word === '' || chord.key !== '') {
@@ -161,9 +163,11 @@ export function parseChord(text: string): KeyChord {
             chord.key = word.length === 1 ? word.toUpperCase() : word;
         }
     }
+
     if (chord.key === '') {
         throw new Error(`The chord "${text}" names no key`);
     }
+
     return chord;
 }
 
@@ -184,10 +188,13 @@ const BASE_PUNCTUATION: Readonly<Record<string, string>> = {
 /* 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);
 }
 
@@ -200,6 +207,8 @@ export function typesInsteadOfChord(event: { key: string; code?: string; ctrlKey
     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

@@ -108,23 +108,31 @@ const FOLD_CODES: Readonly<Record<string, readonly string[]>> = { '-': ['Minus',
 /* Letters and punctuation by the physical key when the event has one, since Option changes the character on macOS and Shift on every platform. */
 function keyMatches(chordKey: string, event: KeyLike): boolean {
     const code = event.code;
+
     if (/^[A-Z]$/.test(chordKey)) {
         return code ? code === `Key${chordKey}` : event.key.toUpperCase() === chordKey;
     }
+
     if (/^[0-9]$/.test(chordKey)) {
         return code ? code === `Digit${chordKey}` || code === `Numpad${chordKey}` : event.key === chordKey;
     }
+
     const fold = FOLD_CODES[chordKey];
+
     if (fold !== undefined) {
         return (code !== undefined && fold.includes(code)) || event.key === chordKey || (chordKey === '=' && event.key === '+');
     }
+
     const punctuation = PUNCTUATION_CODES[chordKey];
+
     if (punctuation !== undefined) {
         return code ? code === punctuation : event.key === chordKey;
     }
+
     if (chordKey === 'Space') {
         return event.key === ' ' || code === 'Space';
     }
+
     return event.key === chordKey;
 }
 
@@ -133,8 +141,10 @@ export function chordMatches(chord: KeyChord, event: KeyLike, apple: boolean): b
     if (typesInsteadOfChord(event, apple)) {
         return false;
     }
+
     const wantsMeta = chord.meta || (chord.mod && apple);
     const wantsCtrl = chord.ctrl || (chord.mod && !apple);
+
     return (
         wantsMeta === event.metaKey &&
         wantsCtrl === event.ctrlKey &&
@@ -155,6 +165,7 @@ function bound(apple: boolean, keymap: Keymap): BoundAction[] {
     return KEYMAP_IDS.flatMap((id) => {
         const text = chordOf(id, apple, keymap);
         const action = ACTIONS[id];
+
         return text === null || action === undefined ? [] : [{ chord: parseChord(text), action }];
     });
 }
@@ -165,47 +176,61 @@ function bound(apple: boolean, keymap: Keymap): BoundAction[] {
  */
 export function keyAction(event: KeyLike, apple: boolean, keymap: Keymap = KEYMAP): KeyAction | null {
     let resolved = bindings.get(keymap);
+
     if (resolved === undefined) {
         resolved = { mac: bound(true, keymap), other: bound(false, keymap) };
         bindings.set(keymap, resolved);
     }
+
     for (const { chord, action } of resolved[apple ? 'mac' : 'other']) {
         if (chordMatches(chord, event, apple)) {
             return action;
         }
     }
+
     const key = event.key.toLowerCase();
     const mod = apple ? event.metaKey : event.ctrlKey;
     const { altKey: alt, shiftKey: shift, ctrlKey: ctrl, metaKey: meta } = event;
+
     if (mod && !alt && (key === 'home' || key === 'end')) {
         return { type: 'edge', end: key === 'end', extend: shift };
     }
+
     if (mod || alt || ctrl || meta) {
         return null;
     }
+
     if (key === 'home') {
         return command(shift ? 'selectSmartHome' : 'smartHome');
     }
+
     if (key === 'end') {
         return command(shift ? 'selectSmartEnd' : 'smartEnd');
     }
+
     if (key === 'tab') {
         return command(shift ? 'outdent' : 'insertTab');
     }
+
     if (key === 'enter') {
         return command('insertNewline');
     }
+
     if (key === 'backspace') {
         return command('smartBackspace');
     }
+
     if (key === 'delete') {
         return command('deleteForward');
     }
+
     if (MOVES.has(event.key)) {
         return { type: 'move', key: event.key as MoveKey, extend: shift };
     }
+
     if (key === 'escape') {
         return { type: 'escape' };
     }
+
     return null;
 }

package/src/layout-changes.ts

@@ -8,26 +8,33 @@ export interface LineBounds {
 
 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 };
     };
 }