@adecore/editor 0.22.1 → 0.23.1

package/src/fake.ts

@@ -5,7 +5,9 @@ import type {
     EditorBlock,
     EditorCodeBlockOptions,
     EditorLineAction,
+    EditorReplacement,
     EditorLineHighlight,
+    LineToken,
     EditorChangeMark,
     EditorCodeVision,
     EditorClick,
@@ -22,9 +24,14 @@ import type {
     EditorHover,
     EditorIndentation,
     EditorGhostText,
+    EditorInlayClick,
+    EditorInlayClickHandler,
     EditorInlayHint,
+    EditorInlayTarget,
     EditorKeyHandler,
+    EditorInputPopup,
     EditorMarker,
+    EditorMessages,
     EditorOptions,
     EditorPosition,
     EditorRemoteCursor,
@@ -38,6 +45,7 @@ import type {
     EditorFolds,
     EditorSemanticToken,
     EditorSmartKeys,
+    EditorApplyEditsOptions,
     EditorTextChange,
     EditorTrackedRange,
     EditorTheme,
@@ -59,7 +67,7 @@ export class FakeEditor implements Editor {
     readonly language: string | undefined;
     readonly path: string | undefined;
     readonly column: number | null;
-    readonly scrollTop: number | null;
+    scrollTop: number | null;
     wrap: boolean;
     theme: EditorTheme;
     readOnly: boolean;
@@ -130,7 +138,7 @@ export class FakeEditor implements Editor {
     }
 
     /* The text becomes `text`, and listeners of the text hear the one stretch that differs, as the real editor reports it. */
-    private replaceText(text: string, source: EditorTextChange['source'] = 'external'): void {
+    private replaceText(text: string, source: EditorTextChange['source'] = 'external', selections?: readonly EditorRange[]): void {
         const span = changedSpan(this.text, text);
         const before = this.text;
         this.text = text;
@@ -139,7 +147,11 @@ export class FakeEditor implements Editor {
         }
         // As in the real editor the caret lands behind what was typed, and listeners of the caret hear it before those of the text.
         if (source !== 'external') {
-            this.moveCaret(positionIn(text, span.start + span.text.length));
+            if (selections === undefined) {
+                this.moveCaret(positionIn(text, span.start + span.text.length));
+            } else {
+                this.setSelections(selections);
+            }
         }
         this.followTracked(span.start, span.end, span.text.length);
         this.ghost = null;
@@ -250,6 +262,10 @@ export class FakeEditor implements Editor {
         return this.readOnly ? 0 : this.findState.count;
     }
 
+    async replaceAllAsync(replacement: string, options: EditorReplaceOptions = {}): Promise<number> {
+        return this.replaceAll(replacement, options);
+    }
+
     setReplacePreview(replacement: string | null): void {
         this.replacePreview = replacement;
     }
@@ -288,11 +304,19 @@ export class FakeEditor implements Editor {
     blocks: readonly EditorBlock[] | null = null;
     private readonly scopes = new Set<(scope: readonly EditorBlock[]) => void>();
 
-    /* What the host marked as changed last. */
-    changeMarks: readonly EditorChangeMark[] = [];
+    /* The marks of every layer, in the order the layers last became non-empty. */
+    get changeMarks(): readonly EditorChangeMark[] {
+        return [...this.changeLayers.values()].flat();
+    }
+
+    private readonly changeLayers = new Map<string, readonly EditorChangeMark[]>();
 
-    setChangeMarks(marks: readonly EditorChangeMark[]): void {
-        this.changeMarks = marks;
+    setChangeMarks(marks: readonly EditorChangeMark[], layer = ''): void {
+        if (marks.length === 0) {
+            this.changeLayers.delete(layer);
+        } else {
+            this.changeLayers.set(layer, marks);
+        }
     }
 
     /* The tinted lines the host set last. */
@@ -305,6 +329,43 @@ export class FakeEditor implements Editor {
     /* What the host drew as code outside the document: the text and how, and into which element. */
     codeBlocks: { container: HTMLElement; text: string; options: EditorCodeBlockOptions }[] = [];
 
+    lineNumbers: ((line: number) => string | null) | null = null;
+    lineTokens: ((line: number) => readonly LineToken[] | null | undefined) | null = null;
+
+    setLineNumbers(labels: ((line: number) => string | null) | null): void {
+        this.lineNumbers = labels;
+    }
+
+    lineLabels: ((line: number) => string | null) | null = null;
+
+    setLineLabels(labels: ((line: number) => string | null) | null): void {
+        this.lineLabels = labels;
+    }
+
+    /* What the input points at, as the last call left it. */
+    inputPopup: EditorInputPopup | null = null;
+
+    setInputPopup(popup: EditorInputPopup | null): void {
+        this.inputPopup = popup;
+    }
+
+    /* Every sentence said, oldest first. */
+    announcements: string[] = [];
+
+    announce(message: string): void {
+        this.announcements.push(message);
+    }
+
+    messages: Partial<EditorMessages> = {};
+
+    setMessages(messages: Partial<EditorMessages>): void {
+        this.messages = { ...this.messages, ...messages };
+    }
+
+    setLineTokens(tokens: ((line: number) => readonly LineToken[] | null | undefined) | null): void {
+        this.lineTokens = tokens;
+    }
+
     renderCode(container: HTMLElement, text: string, options: EditorCodeBlockOptions = {}): void {
         this.codeBlocks.push({ container, text, options });
     }
@@ -359,12 +420,22 @@ export class FakeEditor implements Editor {
         const before = this.drawnWidgets.get(owner) ?? new Set<string>();
         for (const widget of widgets) {
             if (!before.has(widget.id)) {
-                widget.render({} as HTMLElement);
+                widget.render(this.element.ownerDocument?.createElement('div') ?? ({} as HTMLElement));
             }
         }
         this.drawnWidgets.set(owner, new Set(widgets.map((widget) => widget.id)));
     }
 
+    readonly replacementsByOwner = new Map<string, readonly EditorReplacement[]>();
+
+    setReplacements(replacements: readonly EditorReplacement[], owner = 'default'): void {
+        if (replacements.length === 0) {
+            this.replacementsByOwner.delete(owner);
+        } else {
+            this.replacementsByOwner.set(owner, replacements);
+        }
+    }
+
     readonly lineActionsByOwner = new Map<string, readonly EditorLineAction[]>();
 
     setLineActions(actions: readonly EditorLineAction[], owner = 'default'): void {
@@ -438,6 +509,7 @@ export class FakeEditor implements Editor {
     smartKeys: Partial<EditorSmartKeys>;
 
     guides = true;
+    stickyScroll = true;
     whitespace = false;
     rightMargin: number | null = null;
 
@@ -445,6 +517,10 @@ export class FakeEditor implements Editor {
         this.guides = guides;
     }
 
+    setStickyScroll(sticky: boolean): void {
+        this.stickyScroll = sticky;
+    }
+
     setWhitespace(whitespace: boolean): void {
         this.whitespace = whitespace;
     }
@@ -487,6 +563,7 @@ export class FakeEditor implements Editor {
     charSize = { width: 8, height: 20 };
     private readonly carets = new Set<(position: EditorPosition) => void>();
     private readonly hovers = new Set<(hover: EditorHover | null) => void>();
+    private readonly lineHeights = new Set<Listener>();
     private readonly views = new Set<Listener>();
     private readonly keys = new Set<EditorKeyHandler>();
 
@@ -501,6 +578,35 @@ export class FakeEditor implements Editor {
         this.inlayHints = hints;
     }
 
+    private readonly inlayHovers = new Set<(target: EditorInlayTarget | null) => void>();
+    private readonly inlayHandlers = new Set<EditorInlayClickHandler>();
+
+    /* The hint, or part of one, the last `setInlayLink` drew as a link. */
+    inlayLink: { readonly id: string; readonly part: number | null } | null = null;
+
+    onInlayHover(listener: (target: EditorInlayTarget | null) => void): () => void {
+        return subscribe(this.inlayHovers, listener);
+    }
+
+    /* The pointer resting on a hint or a part of one, or leaving them. */
+    hoverInlay(id: string | null, part: number | null = null): void {
+        emit(this.inlayHovers, id === null ? null : { id, part, rect: { left: 0, top: 0, right: 40, bottom: 20 } });
+    }
+
+    onInlayClick(handler: EditorInlayClickHandler): () => void {
+        return subscribe(this.inlayHandlers, handler);
+    }
+
+    /* A press on a hint as the editor sees it first; true when a handler took it. */
+    clickInlay(click: Partial<EditorInlayClick> & Pick<EditorInlayClick, 'id'>): boolean {
+        const full: EditorInlayClick = { part: null, mod: false, alt: false, shift: false, clicks: 1, touch: false, ...click };
+        return [...this.inlayHandlers].some((handler) => handler(full));
+    }
+
+    setInlayLink(target: { readonly id: string; readonly part: number | null } | null): void {
+        this.inlayLink = target;
+    }
+
     /* The suggestion after the caret now, which any change of the text takes away as the real editor does. */
     ghost: EditorGhostText | null = null;
 
@@ -544,6 +650,32 @@ export class FakeEditor implements Editor {
     /* The selection a person made; without one the caret. */
     selection: EditorRange | null = null;
 
+    /* A test supplies the measured height; this fake has no layout. */
+    contentHeight = 0;
+
+    setScrollTop(top: number): void {
+        if (Number.isFinite(top) && this.getScrollTop() !== Math.max(0, top)) {
+            this.scrollTop = Math.max(0, top);
+            emit(this.views);
+        }
+    }
+
+    getLineHeight(line: number): number {
+        return Number.isInteger(line) && line >= 0 && line < this.text.split('\n').length ? this.charSize.height : 0;
+    }
+
+    getBaseLineHeight(): number {
+        return this.charSize.height;
+    }
+
+    onLineHeights(listener: Listener): () => void {
+        return subscribe(this.lineHeights, listener);
+    }
+
+    getContentHeight(): number {
+        return this.contentHeight;
+    }
+
     getSelection(): EditorRange {
         return this.selection ?? { start: this.caret, end: this.caret };
     }
@@ -675,7 +807,8 @@ export class FakeEditor implements Editor {
         return [...this.keys].some((handler) => handler(full));
     }
 
-    applyEdits(edits: readonly EditorContentChange[]): boolean {
+    /* The fake keeps no undo history, so `mergeUndo` changes nothing here. It keeps no selection direction either, so a test of `mapSelections` keeping a backward selection needs the real editor. */
+    applyEdits(edits: readonly EditorContentChange[], options: EditorApplyEditsOptions = {}): boolean {
         if (this.readOnly || edits.length === 0) {
             return false;
         }
@@ -702,11 +835,14 @@ export class FakeEditor implements Editor {
             return offset + delta;
         };
         const moved = others.map((range) => ({ anchor: follow(range.anchor), head: follow(range.head) }));
-        this.replaceText(text, 'command');
-        this.otherSelections = moved.map((range) => ({
-            start: positionIn(text, Math.min(range.anchor, range.head)),
-            end: positionIn(text, Math.max(range.anchor, range.head))
-        }));
+        const mapped = options.mapSelections && this.getSelections().map((range) => options.mapSelections!(range));
+        this.replaceText(text, 'command', mapped);
+        if (mapped === undefined) {
+            this.otherSelections = moved.map((range) => ({
+                start: positionIn(text, Math.min(range.anchor, range.head)),
+                end: positionIn(text, Math.max(range.anchor, range.head))
+            }));
+        }
         emit(this.changes);
         return true;
     }
@@ -724,6 +860,10 @@ export class FakeEditor implements Editor {
         this.readOnlyReason = reason;
     }
 
+    isReadOnly(): boolean {
+        return this.readOnly;
+    }
+
     /* The commands run, in order; the fake has no commands of its own to carry out. */
     readonly commands: EditorRunCommand[] = [];
 
@@ -742,8 +882,11 @@ export class FakeEditor implements Editor {
         this.textChanges.clear();
         this.carets.clear();
         this.hovers.clear();
+        this.inlayHovers.clear();
+        this.inlayHandlers.clear();
         this.attributionHovers.clear();
         this.views.clear();
+        this.lineHeights.clear();
         this.keys.clear();
         this.saves.clear();
         this.blurs.clear();

package/src/find-search.ts

@@ -0,0 +1,165 @@
+import { EditorSearchError, type EditorSearchClient } from './search-client.ts';
+
+export interface FindSearchOptions {
+    readonly createClient: () => EditorSearchClient | null;
+    readonly schedule?: (callback: () => void, delay: number) => () => void;
+    readonly now?: () => number;
+}
+
+type SearchKind = 'live' | 'preview' | 'command';
+
+interface SearchJob {
+    readonly kind: SearchKind;
+    readonly valid?: () => boolean;
+    readonly run: (client: EditorSearchClient, isCurrent: () => boolean) => Promise<unknown>;
+    readonly resolve: (value: unknown) => void;
+    readonly reject: (error: unknown) => void;
+    cancelled: boolean;
+}
+
+export function scheduleFind(callback: () => void, delay: number): () => void {
+    const timer = setTimeout(callback, delay);
+    return () => clearTimeout(timer);
+}
+
+function superseded(): EditorSearchError {
+    return new EditorSearchError('superseded', 'The find operation is no longer current.');
+}
+
+/* Commands finish atomically; short background requests reuse the worker before newer work starts. */
+export class FindSearchQueue {
+    private client: EditorSearchClient | null | undefined;
+    private active: SearchJob | undefined;
+    private pending: SearchJob[] = [];
+    private cancelTimer: (() => void) | undefined;
+    private started = 0;
+    private disposed = false;
+    private epoch = 0;
+    private readonly options: FindSearchOptions;
+
+    constructor(options: FindSearchOptions) {
+        this.options = options;
+    }
+
+    get busy(): boolean {
+        return this.active !== undefined || this.pending.length > 0;
+    }
+
+    request<Result>(
+        run: (client: EditorSearchClient, isCurrent: () => boolean) => Promise<Result>,
+        kind: SearchKind = 'live',
+        valid?: () => boolean
+    ): Promise<Result> {
+        if (this.disposed) {
+            return Promise.reject(new EditorSearchError('disposed', 'The find session was disposed.'));
+        }
+        return new Promise((resolve, reject) => {
+            this.pending = this.pending.filter((job) => {
+                if (job.kind !== 'command' && (job.kind === kind || (kind !== 'preview' && job.kind === 'preview'))) {
+                    job.cancelled = true;
+                    job.reject(superseded());
+                    return false;
+                }
+                return true;
+            });
+            this.pending.push({ kind, valid, run, resolve: (value) => resolve(value as Result), reject, cancelled: false });
+            this.pending.sort((left, right) => priority(left.kind) - priority(right.kind));
+            if (this.active === undefined) {
+                this.pump();
+            } else if (
+                (kind !== 'preview' || this.active.valid?.() === false) &&
+                (this.active.kind !== 'command' || this.active.valid?.() === false) &&
+                this.cancelTimer === undefined
+            ) {
+                this.cancelTimer = (this.options.schedule ?? scheduleFind)(
+                    () => {
+                        this.cancelTimer = undefined;
+                        if (this.pending.length > 0 && this.active !== undefined && (this.active.kind !== 'command' || this.active.valid?.() === false)) {
+                            this.active.cancelled = true;
+                            this.active.reject(superseded());
+                            this.client?.cancel();
+                        }
+                    },
+                    Math.max(0, 200 - (this.now() - this.started))
+                );
+            }
+        });
+    }
+
+    private now(): number {
+        return this.options.now?.() ?? performance.now();
+    }
+
+    private pump(): void {
+        if (this.disposed || this.active !== undefined) {
+            return;
+        }
+        const job = this.pending.shift();
+        if (job === undefined) {
+            return;
+        }
+        this.active = job;
+        this.started = this.now();
+        const epoch = this.epoch;
+        const alive = (): boolean => !this.disposed && epoch === this.epoch && !job.cancelled;
+        const isCurrent = (): boolean => alive() && job.valid?.() !== false;
+        void Promise.resolve()
+            .then(() => {
+                if (!isCurrent()) {
+                    throw superseded();
+                }
+                this.client ??= this.options.createClient();
+                if (this.client === null) {
+                    throw new EditorSearchError('unavailable', 'Regex search needs a search worker.');
+                }
+                const client = this.client;
+                const guarded: EditorSearchClient = {
+                    search: (...args) => (isCurrent() ? client.search(...args) : Promise.reject(superseded())),
+                    match: (...args) => (isCurrent() ? client.match(...args) : Promise.reject(superseded())),
+                    next: (...args) => (isCurrent() ? client.next(...args) : Promise.reject(superseded())),
+                    replacements: (...args) => (isCurrent() ? client.replacements(...args) : Promise.reject(superseded())),
+                    cancel: () => client.cancel(),
+                    release: () => client.release(),
+                    dispose: () => client.dispose()
+                };
+                return job.run(guarded, isCurrent);
+            })
+            .then((value) => {
+                if (alive()) {
+                    job.resolve(value);
+                } else {
+                    job.reject(superseded());
+                }
+            }, job.reject)
+            .finally(() => {
+                this.active = undefined;
+                this.cancelTimer?.();
+                this.cancelTimer = undefined;
+                this.pump();
+            });
+    }
+
+    release(): void {
+        this.epoch++;
+        this.active?.reject(superseded());
+        for (const job of this.pending) {
+            job.cancelled = true;
+            job.reject(superseded());
+        }
+        this.pending = [];
+        this.cancelTimer?.();
+        this.cancelTimer = undefined;
+        this.client?.release();
+    }
+
+    dispose(): void {
+        this.disposed = true;
+        this.release();
+        this.client?.dispose();
+        this.client = undefined;
+    }
+}
+
+function priority(kind: SearchKind): number {
+    return kind === 'command' ? 0 : kind === 'live' ? 1 : 2;
+}