@adecore/editor 0.39.0 → 0.40.0

package/src/testing.ts

@@ -10,32 +10,40 @@ export function createPage(): { document: Document; window: Window & typeof glob
     const { document, window } = parseHTML('<html><body><div id="host"></div></body></html>');
     const prototype = (window as unknown as { HTMLTextAreaElement: { prototype: Record<string, unknown> } }).HTMLTextAreaElement.prototype;
     const selections = new WeakMap<object, { start: number; end: number; direction: string }>();
+
     const read = (element: object): { start: number; end: number; direction: string } => selections.get(element) ?? { start: 0, end: 0, direction: 'none' };
+
     Object.defineProperty(prototype, 'selectionStart', {
         get: function (this: object) {
             return read(this).start;
         },
         configurable: true
     });
+
     Object.defineProperty(prototype, 'selectionEnd', {
         get: function (this: object) {
             return read(this).end;
         },
         configurable: true
     });
+
     Object.defineProperty(prototype, 'selectionDirection', {
         get: function (this: object) {
             return read(this).direction;
         },
         configurable: true
     });
+
     prototype.setSelectionRange = function (this: object, start: number, end: number, direction = 'none'): void {
         selections.set(this, { start, end, direction });
     };
+
     const element = (window as unknown as { HTMLElement: { prototype: object } }).HTMLElement.prototype;
+
     for (const name of ['scrollTop', 'scrollLeft']) {
         Object.defineProperty(element, name, { value: 0, writable: true, configurable: true });
     }
+
     return {
         document: document as unknown as Document,
         window: window as unknown as Window & typeof globalThis,
@@ -61,6 +69,7 @@ export function press(window: Window, target: Element, key: string, options: Key
     const event = createEvent(window, 'keydown');
     Object.assign(event, { key, ctrlKey: false, metaKey: false, altKey: false, shiftKey: false, isComposing: false, ...options });
     target.dispatchEvent(event);
+
     return event.defaultPrevented;
 }
 
@@ -86,6 +95,7 @@ export function clipboard(
     data: { text: string } = { text: '' }
 ): { prevented: boolean; text: string } {
     const event = createEvent(window, type);
+
     Object.assign(event, {
         clipboardData: {
             getData: () => data.text,
@@ -94,7 +104,9 @@ export function clipboard(
             }
         }
     });
+
     target.dispatchEvent(event);
+
     return { prevented: event.defaultPrevented, text: data.text };
 }
 
@@ -108,6 +120,7 @@ export function pointer(
     options: KeyOptions = {}
 ): void {
     const event = createEvent(window, type);
+
     Object.assign(event, {
         clientX: x,
         clientY: y,
@@ -120,6 +133,7 @@ export function pointer(
         metaKey: false,
         ...options
     });
+
     target.dispatchEvent(event);
 }
 
@@ -139,13 +153,16 @@ export interface MountedEditor {
 /* An editor on a page of its own, with the helpers that drive it the way a person would. */
 export function mountEditor(options: Partial<EditorOptions> = {}, engineOptions: Partial<SmartEditorEngineOptions> = {}): MountedEditor {
     const page = createPage();
+
     const editor = createSmartEditorEngine({ tokenizer: async () => null, ...engineOptions }).mount(page.host, {
         text: 'one\ntwo\nthree',
         theme: 'dark',
         ...options
     });
+
     const input = page.host.querySelector('textarea')!;
     const viewport = page.host.querySelector('.se-viewport') as HTMLElement;
+
     return {
         editor,
         page,

package/src/theme-scopes.ts

@@ -26,19 +26,25 @@ function selectorScore(selector: string, stack: readonly string[]): number | nul
     const words = selector.trim().split(/\s+/);
     const last = words[words.length - 1]!;
     const innermost = stack[stack.length - 1];
+
     if (innermost === undefined || !nameMatches(last, innermost)) {
         return null;
     }
+
     let at = stack.length - 2;
+
     for (let word = words.length - 2; word >= 0; word--) {
         while (at >= 0 && !nameMatches(words[word]!, stack[at]!)) {
             at--;
         }
+
         if (at < 0) {
             return null;
         }
+
         at--;
     }
+
     return last.length * 100 + words.length;
 }
 
@@ -55,21 +61,29 @@ export function scopeColorsOf(rules: readonly ThemeRule[]): ScopeColors {
             order
         }))
     );
+
     const cache = new Map<string, ScopeStyle | undefined>();
+
     return (stack) => {
         const key = stack.join(' ');
+
         if (cache.has(key)) {
             return cache.get(key);
         }
+
         let best: { score: number; order: number; style: ScopeStyle } | undefined;
+
         for (const entry of flat) {
             const score = entry.selector === '' ? null : selectorScore(entry.selector, stack);
+
             if (score !== null && (best === undefined || score > best.score || (score === best.score && entry.order > best.order))) {
                 best = { score, order: entry.order, style: entry.style };
             }
         }
+
         const style = best !== undefined && best.style.color !== '' ? best.style : undefined;
         cache.set(key, style);
+
         return style;
     };
 }

package/src/tokens.ts

@@ -63,16 +63,21 @@ export class TokenCache {
     /* The colors of text that is not part of the document, a line at a time, or null without a tokenizer. */
     tokenizeText(lines: readonly string[]): (readonly LineToken[])[] | null {
         const tokenizer = this.tokenizer;
+
         if (tokenizer === null) {
             return null;
         }
+
         let state: unknown = null;
+
         return lines.map((text) => {
             if (text.length > LONGEST_COLORED_LINE) {
                 return [{ length: text.length, color: '', fontStyle: 0 }];
             }
+
             const result = tokenizer.tokenizeLine(text, state);
             state = result.state;
+
             return result.tokens;
         });
     }
@@ -87,27 +92,35 @@ export class TokenCache {
         const lineCount = this.source.getLineCount();
         const delta = lineCount - this.lines;
         this.lines = lineCount;
+
         if (this.tokenizer === null) {
             return;
         }
+
         const first = batches[0]?.[0];
+
         if (first === undefined) {
             this.entries = [];
             this.staleFrom = Number.POSITIVE_INFINITY;
             this.frontier = 0;
             this.forgetPivot();
+
             return;
         }
+
         const firstLine = lineOf(first.from);
         const changes = batches.length === 1 ? batches[0]! : [];
         let shift = 0;
+
         for (let i = 0; i < changes.length - 1; i++) {
             shift += changes[i]!.insertedLength - (changes[i]!.to - changes[i]!.from);
         }
+
         const last = changes.at(-1);
         const lastNew = last === undefined ? -1 : lineOf(last.from + shift + last.insertedLength);
         const lastOld = lastNew - delta;
         this.frontier = Math.min(this.frontier, firstLine);
+
         if (last === undefined && Number.isFinite(this.staleFrom)) {
             // A history batch has no single mapping for the old grammar boundary.
             this.staleFrom = 0;
@@ -117,14 +130,19 @@ export class TokenCache {
         } else if (this.staleFrom > firstLine) {
             this.staleFrom = firstLine;
         }
+
         if (last === undefined || lastOld < firstLine || this.entries.length <= firstLine) {
             this.entries.length = Math.min(this.entries.length, firstLine);
+
             if (this.staleFrom >= this.entries.length) {
                 this.staleFrom = Number.POSITIVE_INFINITY;
             }
+
             this.forgetPivot();
+
             return;
         }
+
         const old = this.entries[lastOld];
         this.pivotLine = old ? lastNew : -1;
         this.pivotState = old?.state;
@@ -138,9 +156,11 @@ export class TokenCache {
         if (this.tokenizer?.stale?.() !== true) {
             return false;
         }
+
         this.frontier = 0;
         this.staleFrom = 0;
         this.forgetPivot();
+
         return true;
     }
 
@@ -151,45 +171,56 @@ export class TokenCache {
      */
     advance(until: number, budget: number, now: () => number = () => performance.now()): { from: number; to: number } | null {
         const tokenizer = this.tokenizer;
+
         if (tokenizer === null) {
             return null;
         }
+
         this.revalidate();
         const count = this.source.getLineCount();
         const limit = Math.min(until, count - 1);
         const deadline = now() + budget;
         const from = this.frontier;
+
         while (this.frontier <= limit && this.frontier < count) {
             const line = this.frontier;
             const text = this.source.getLineText(line);
             const state = line === 0 ? null : (this.entries[line - 1]?.state ?? null);
             const previous = this.entries[line];
             let next: Entry;
+
             if (text.length > LONGEST_COLORED_LINE) {
                 next = { tokens: [{ length: text.length, color: '', fontStyle: 0 }], state };
             } else {
                 const result = tokenizer.tokenizeLine(text, state);
                 next = { tokens: result.tokens, state: result.state };
             }
+
             this.entries[line] = next;
             this.frontier = line + 1;
             const fresh = line < this.staleFrom;
+
             if (line === this.staleFrom) {
                 this.staleFrom = line + 1 >= this.entries.length ? Number.POSITIVE_INFINITY : line + 1;
             }
+
             const settled =
                 fresh &&
                 ((line === this.pivotLine && tokenizer.sameState(this.pivotState, next.state)) ||
                     (previous !== undefined && line >= this.reusableFrom && tokenizer.sameState(previous.state, next.state)));
+
             if (settled) {
                 this.frontier = Math.min(this.entries.length, this.staleFrom);
                 this.forgetPivot();
+
                 break;
             }
+
             if (now() > deadline) {
                 break;
             }
         }
+
         return this.frontier > from ? { from, to: this.frontier - 1 } : null;
     }
 

package/src/touch.ts

@@ -50,6 +50,7 @@ export class TouchSelection {
     start(event: PointerEvent, area: 'text' | 'gutter' = 'text', taken?: () => boolean): void {
         this.cancel();
         this.contact = { id: event.pointerId, x: event.clientX, y: event.clientY, area, moved: false, pressed: false, taken };
+
         if (area === 'text') {
             this.timer = setTimeout(() => this.press(), LONG_PRESS_MS);
         }
@@ -57,9 +58,11 @@ export class TouchSelection {
 
     move(event: PointerEvent): void {
         const contact = this.contact;
+
         if (contact === undefined || event.pointerId !== contact.id || contact.moved) {
             return;
         }
+
         if (Math.abs(event.clientX - contact.x) > TAP_SLOP || Math.abs(event.clientY - contact.y) > TAP_SLOP) {
             contact.moved = true;
             this.clearTimer();
@@ -69,13 +72,17 @@ export class TouchSelection {
     /* The finger lifted: a tap that did not scroll and was not a long press lands here. */
     end(event: PointerEvent): void {
         const contact = this.contact;
+
         if (contact === undefined || event.pointerId !== contact.id) {
             return;
         }
+
         this.cancel();
+
         if (event.type === 'pointercancel' || contact.moved || contact.pressed) {
             return;
         }
+
         this.tap(contact, event);
     }
 
@@ -87,20 +94,26 @@ export class TouchSelection {
         const { model } = this.host;
         const offset = this.host.offsetAt(contact.x, contact.y);
         this.host.focus();
+
         if (contact.area === 'gutter') {
             const line = this.host.lineAt(offset);
             model.setSelections([{ anchor: line.from, head: line.to }]);
+
             return;
         }
+
         if (contact.taken?.()) {
             return;
         }
+
         const last = this.lastTap;
+
         const double =
             last !== undefined &&
             event.timeStamp - last.time <= DOUBLE_TAP_MS &&
             Math.abs(contact.x - last.x) <= DOUBLE_TAP_DISTANCE &&
             Math.abs(contact.y - last.y) <= DOUBLE_TAP_DISTANCE;
+
         this.lastTap = double ? undefined : { time: event.timeStamp, x: contact.x, y: contact.y };
         const word = double ? model.wordSelectionAt(offset, this.host.camelHumps()) : null;
         model.setSelections([word === null ? { anchor: offset, head: offset } : { anchor: word.from, head: word.to }]);
@@ -109,9 +122,11 @@ export class TouchSelection {
     private press(): void {
         const contact = this.contact;
         this.timer = undefined;
+
         if (contact === undefined || contact.moved) {
             return;
         }
+
         contact.pressed = true;
         this.lastTap = undefined;
         const offset = this.host.offsetAt(contact.x, contact.y);
@@ -124,6 +139,7 @@ export class TouchSelection {
         if (this.timer !== undefined) {
             clearTimeout(this.timer);
         }
+
         this.timer = undefined;
     }
 

package/src/tracked-range.ts

@@ -8,15 +8,20 @@ import type { DocumentChange } from '@adecore/editor-core';
  */
 export function mapTrackedRange(from: number, to: number, changes: readonly DocumentChange[]): { from: number; to: number } | null {
     let delta = 0;
+
     for (const change of changes) {
         if (change.to <= from) {
             delta += change.insertedLength - (change.to - change.from);
+
             continue;
         }
+
         if (change.from >= to) {
             break;
         }
+
         return null;
     }
+
     return { from: from + delta, to: to + delta };
 }

package/src/uniform-geometry.ts

@@ -10,21 +10,28 @@ export function uniformGeometry(
     const rowStarts = [0, ...breaks];
     const firstLength = rowStarts[1] ?? line.text.length;
     let continuationLength = 0;
+
     for (let row = 1; row < rowStarts.length; row++) {
         continuationLength = Math.max(continuationLength, (rowStarts[row + 1] ?? line.text.length) - rowStarts[row]!);
     }
+
     // A shared prefix preserves repeated floating-point addition exactly, even for fallback font metrics.
     if (Math.max(firstLength, continuationLength) > 4096) {
         return null;
     }
+
     const positions = (start: number, length: number): number[] => {
         const result = [start];
+
         for (let index = 0; index < length; index++) {
             result.push(result.at(-1)! + metrics.charWidth);
         }
+
         return result;
     };
+
     const uniform = { first: positions(0, firstLength), continuation: positions(indent, continuationLength) };
+
     const geometry: LineGeometry = {
         start: line.start,
         end: line.end,
@@ -43,15 +50,18 @@ export function uniformGeometry(
         width: 0,
         uniform
     };
+
     for (let row = 0; row < rowStarts.length; row++) {
         const from = rowStarts[row]!;
         const to = rowStarts[row + 1] ?? line.text.length;
         const end = uniform[row === 0 ? 'first' : 'continuation'][to - from]!;
         geometry.rowEnds.push(end);
         geometry.width = Math.max(geometry.width, end);
+
         if (from < to) {
             geometry.runs.push({ from, to, x: row === 0 ? 0 : indent, subRow: row, text: line.text.slice(from, to) });
         }
     }
+
     return geometry;
 }