@adecore/editor 0.22.1 → 0.23.1

package/dist/fake.js

@@ -76,7 +76,7 @@ export class FakeEditor {
         this.replaceText(text);
     }
     /* The text becomes `text`, and listeners of the text hear the one stretch that differs, as the real editor reports it. */
-    replaceText(text, source = 'external') {
+    replaceText(text, source = 'external', selections) {
         const span = changedSpan(this.text, text);
         const before = this.text;
         this.text = text;
@@ -85,7 +85,12 @@ export class FakeEditor {
         }
         // 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;
@@ -180,6 +185,9 @@ export class FakeEditor {
         this.replaceOptions.push(options);
         return this.readOnly ? 0 : this.findState.count;
     }
+    async replaceAllAsync(replacement, options = {}) {
+        return this.replaceAll(replacement, options);
+    }
     setReplacePreview(replacement) {
         this.replacePreview = replacement;
     }
@@ -210,10 +218,18 @@ export class FakeEditor {
     /* What the host handed it last; null while it reads the structure itself. */
     blocks = null;
     scopes = new Set();
-    /* What the host marked as changed last. */
-    changeMarks = [];
-    setChangeMarks(marks) {
-        this.changeMarks = marks;
+    /* The marks of every layer, in the order the layers last became non-empty. */
+    get changeMarks() {
+        return [...this.changeLayers.values()].flat();
+    }
+    changeLayers = new Map();
+    setChangeMarks(marks, layer = '') {
+        if (marks.length === 0) {
+            this.changeLayers.delete(layer);
+        }
+        else {
+            this.changeLayers.set(layer, marks);
+        }
     }
     /* The tinted lines the host set last. */
     lineHighlights = [];
@@ -222,6 +238,32 @@ export class FakeEditor {
     }
     /* What the host drew as code outside the document: the text and how, and into which element. */
     codeBlocks = [];
+    lineNumbers = null;
+    lineTokens = null;
+    setLineNumbers(labels) {
+        this.lineNumbers = labels;
+    }
+    lineLabels = null;
+    setLineLabels(labels) {
+        this.lineLabels = labels;
+    }
+    /* What the input points at, as the last call left it. */
+    inputPopup = null;
+    setInputPopup(popup) {
+        this.inputPopup = popup;
+    }
+    /* Every sentence said, oldest first. */
+    announcements = [];
+    announce(message) {
+        this.announcements.push(message);
+    }
+    messages = {};
+    setMessages(messages) {
+        this.messages = { ...this.messages, ...messages };
+    }
+    setLineTokens(tokens) {
+        this.lineTokens = tokens;
+    }
     renderCode(container, text, options = {}) {
         this.codeBlocks.push({ container, text, options });
     }
@@ -265,11 +307,20 @@ export class FakeEditor {
         const before = this.drawnWidgets.get(owner) ?? new Set();
         for (const widget of widgets) {
             if (!before.has(widget.id)) {
-                widget.render({});
+                widget.render(this.element.ownerDocument?.createElement('div') ?? {});
             }
         }
         this.drawnWidgets.set(owner, new Set(widgets.map((widget) => widget.id)));
     }
+    replacementsByOwner = new Map();
+    setReplacements(replacements, owner = 'default') {
+        if (replacements.length === 0) {
+            this.replacementsByOwner.delete(owner);
+        }
+        else {
+            this.replacementsByOwner.set(owner, replacements);
+        }
+    }
     lineActionsByOwner = new Map();
     setLineActions(actions, owner = 'default') {
         if (actions.length === 0) {
@@ -329,11 +380,15 @@ export class FakeEditor {
     }
     smartKeys;
     guides = true;
+    stickyScroll = true;
     whitespace = false;
     rightMargin = null;
     setGuides(guides) {
         this.guides = guides;
     }
+    setStickyScroll(sticky) {
+        this.stickyScroll = sticky;
+    }
     setWhitespace(whitespace) {
         this.whitespace = whitespace;
     }
@@ -367,6 +422,7 @@ export class FakeEditor {
     charSize = { width: 8, height: 20 };
     carets = new Set();
     hovers = new Set();
+    lineHeights = new Set();
     views = new Set();
     keys = new Set();
     setMarkers(markers) {
@@ -377,6 +433,28 @@ export class FakeEditor {
     setInlayHints(hints) {
         this.inlayHints = hints;
     }
+    inlayHovers = new Set();
+    inlayHandlers = new Set();
+    /* The hint, or part of one, the last `setInlayLink` drew as a link. */
+    inlayLink = null;
+    onInlayHover(listener) {
+        return subscribe(this.inlayHovers, listener);
+    }
+    /* The pointer resting on a hint or a part of one, or leaving them. */
+    hoverInlay(id, part = null) {
+        emit(this.inlayHovers, id === null ? null : { id, part, rect: { left: 0, top: 0, right: 40, bottom: 20 } });
+    }
+    onInlayClick(handler) {
+        return subscribe(this.inlayHandlers, handler);
+    }
+    /* A press on a hint as the editor sees it first; true when a handler took it. */
+    clickInlay(click) {
+        const full = { part: null, mod: false, alt: false, shift: false, clicks: 1, touch: false, ...click };
+        return [...this.inlayHandlers].some((handler) => handler(full));
+    }
+    setInlayLink(target) {
+        this.inlayLink = target;
+    }
     /* The suggestion after the caret now, which any change of the text takes away as the real editor does. */
     ghost = null;
     setGhostText(ghost) {
@@ -408,6 +486,26 @@ export class FakeEditor {
     }
     /* The selection a person made; without one the caret. */
     selection = null;
+    /* A test supplies the measured height; this fake has no layout. */
+    contentHeight = 0;
+    setScrollTop(top) {
+        if (Number.isFinite(top) && this.getScrollTop() !== Math.max(0, top)) {
+            this.scrollTop = Math.max(0, top);
+            emit(this.views);
+        }
+    }
+    getLineHeight(line) {
+        return Number.isInteger(line) && line >= 0 && line < this.text.split('\n').length ? this.charSize.height : 0;
+    }
+    getBaseLineHeight() {
+        return this.charSize.height;
+    }
+    onLineHeights(listener) {
+        return subscribe(this.lineHeights, listener);
+    }
+    getContentHeight() {
+        return this.contentHeight;
+    }
     getSelection() {
         return this.selection ?? { start: this.caret, end: this.caret };
     }
@@ -512,7 +610,8 @@ export class FakeEditor {
         const full = { ctrlKey: false, metaKey: false, altKey: false, shiftKey: false, preventDefault: () => undefined, ...event };
         return [...this.keys].some((handler) => handler(full));
     }
-    applyEdits(edits) {
+    /* 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, options = {}) {
         if (this.readOnly || edits.length === 0) {
             return false;
         }
@@ -539,11 +638,14 @@ export class FakeEditor {
             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;
     }
@@ -557,6 +659,9 @@ export class FakeEditor {
         this.readOnly = readOnly;
         this.readOnlyReason = reason;
     }
+    isReadOnly() {
+        return this.readOnly;
+    }
     /* The commands run, in order; the fake has no commands of its own to carry out. */
     commands = [];
     runCommand(command) {
@@ -572,8 +677,11 @@ export class FakeEditor {
         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/dist/find-search.d.ts

@@ -0,0 +1,26 @@
+import { 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';
+export declare function scheduleFind(callback: () => void, delay: number): () => void;
+export declare class FindSearchQueue {
+    private client;
+    private active;
+    private pending;
+    private cancelTimer;
+    private started;
+    private disposed;
+    private epoch;
+    private readonly options;
+    constructor(options: FindSearchOptions);
+    get busy(): boolean;
+    request<Result>(run: (client: EditorSearchClient, isCurrent: () => boolean) => Promise<Result>, kind?: SearchKind, valid?: () => boolean): Promise<Result>;
+    private now;
+    private pump;
+    release(): void;
+    dispose(): void;
+}
+export {};

package/dist/find-search.js

@@ -0,0 +1,130 @@
+import { EditorSearchError } from './search-client.js';
+export function scheduleFind(callback, delay) {
+    const timer = setTimeout(callback, delay);
+    return () => clearTimeout(timer);
+}
+function superseded() {
+    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 {
+    client;
+    active;
+    pending = [];
+    cancelTimer;
+    started = 0;
+    disposed = false;
+    epoch = 0;
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    get busy() {
+        return this.active !== undefined || this.pending.length > 0;
+    }
+    request(run, kind = 'live', valid) {
+        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), 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)));
+            }
+        });
+    }
+    now() {
+        return this.options.now?.() ?? performance.now();
+    }
+    pump() {
+        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 = () => !this.disposed && epoch === this.epoch && !job.cancelled;
+        const isCurrent = () => 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 = {
+                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() {
+        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() {
+        this.disposed = true;
+        this.release();
+        this.client?.dispose();
+        this.client = undefined;
+    }
+}
+function priority(kind) {
+    return kind === 'command' ? 0 : kind === 'live' ? 1 : 2;
+}

package/dist/find.d.ts

@@ -1,18 +1,45 @@
-import type { DocumentChange, DocumentModel } from '@adecore/editor-core';
+import type { DocumentChange, DocumentModel, FindMatch } from '@adecore/editor-core';
+import { type FindSearchOptions } from './find-search.ts';
 import type { EditorFindQuery, EditorFindState } from './types.ts';
 export interface FindMark {
     from: number;
     to: number;
 }
 export declare const FIND_LIMIT = 10000;
+export interface FindControllerOptions extends FindSearchOptions {
+    readonly changed: (reveal?: boolean) => void;
+}
 export declare class FindController {
     private query;
     private marks;
+    private cache?;
     private index;
+    private outside;
+    private seeking;
+    private replacing;
+    private replaceEpoch;
+    private replaced;
+    private replaceFailed;
     private bounds;
     pendingAnchor: number | undefined;
     private readonly model;
-    constructor(model: DocumentModel);
+    private readonly options;
+    private readonly search;
+    private regexCache;
+    private snapshotMemo;
+    private retained;
+    private epoch;
+    private searching;
+    private failed;
+    private captureFailed;
+    private pendingStep;
+    private cancelSearch;
+    private cancelMatch;
+    private preview;
+    private disposed;
+    private revision;
+    private cursorRequests;
+    constructor(model: DocumentModel, options?: FindControllerOptions);
     get activeQuery(): EditorFindQuery | null;
     get active(): boolean;
     get matches(): readonly FindMark[];
@@ -23,8 +50,29 @@ export declare class FindController {
         to: number;
     } | null;
     get currentMark(): FindMark | null;
+    matchesBetween(from: number, to: number): readonly FindMark[];
+    get currentMatch(): FindMatch | null;
+    get completeMatches(): readonly FindMatch[] | null;
+    private get cachedMatches();
+    private cacheKey;
     set(query: EditorFindQuery | null): void;
     mapBounds(changes: readonly DocumentChange[]): void;
     refresh(): void;
     step(direction: 1 | -1): void;
+    private get freshRegex();
+    private resetRegex;
+    private refreshRegex;
+    private startRegex;
+    private snapshot;
+    setPreview(active: boolean): void;
+    private preparePreview;
+    ensureMatch(command?: boolean): Promise<FindMatch | null>;
+    private chooseCurrent;
+    private seek;
+    nextFromCursor(query: EditorFindQuery, offset: number, direction: 1 | -1): Promise<FindMark | null>;
+    reportReplaceFailed(failure: NonNullable<EditorFindState['replaceFailed']>): void;
+    reportReplaced(count: number): void;
+    replaceOne(replacement: string, preserveCase: boolean, canApply: () => boolean): Promise<boolean>;
+    replaceAll(replacement: string, preserveCase: boolean, canApply: () => boolean): Promise<number>;
+    dispose(): void;
 }