@adecore/editor 0.0.1 → 0.17.0-beta.2

package/dist/fake.js

@@ -0,0 +1,663 @@
+import { emit, subscribe } from './listeners.js';
+import { changedSpan } from '@adecore/editor-core';
+import { mapTrackedRange } from './tracked-range.js';
+function positionIn(text, offset) {
+    const before = text.slice(0, Math.max(0, offset));
+    const lines = before.split('\n');
+    return { line: lines.length - 1, character: lines.at(-1).length };
+}
+/* An editor without a DOM, for tests: `type`, `save` and `blur` do what a person would, the rest says what the client asked of it. */
+export class FakeEditor {
+    element;
+    language;
+    path;
+    column;
+    scrollTop;
+    wrap;
+    theme;
+    readOnly;
+    readOnlyReason;
+    revealedLine;
+    focused = false;
+    indentation;
+    /* How often the client asked it to read the code face off the page again. */
+    fontRefreshes = 0;
+    disposed = false;
+    /* What the client asked to find last; null once it ended the find. */
+    findQuery = null;
+    findState = { count: 0, current: null };
+    text;
+    changes = new Set();
+    textChanges = new Set();
+    saves = new Set();
+    blurs = new Set();
+    finds = new Set();
+    constructor(element, options) {
+        this.element = element;
+        this.text = options.text;
+        this.language = options.language;
+        this.path = options.path;
+        this.wrap = options.wrap ?? false;
+        this.indentation = options.indentation ?? { tabSize: 4, insertSpaces: true };
+        this.smartKeys = options.smartKeys ?? {};
+        this.theme = options.theme;
+        this.readOnly = options.readOnly ?? false;
+        this.readOnlyReason = options.readOnlyReason;
+        this.label = options.label ?? 'Code editor';
+        this.revealedLine = options.line ?? null;
+        this.column = options.column ?? null;
+        this.scrollTop = options.scrollTop ?? null;
+    }
+    /* A person's edit: the text changes and every change listener hears it. A read-only editor refuses it, as the real editor does. */
+    type(text) {
+        this.assertLive();
+        if (this.readOnly || text === this.text) {
+            return;
+        }
+        this.replaceText(text, 'input');
+        emit(this.changes);
+    }
+    /* Mod+S inside the editor. */
+    save() {
+        this.assertLive();
+        emit(this.saves);
+    }
+    /* The focus leaving the editor. */
+    blur() {
+        this.assertLive();
+        this.focused = false;
+        emit(this.blurs);
+    }
+    getText() {
+        return this.text;
+    }
+    setText(text) {
+        this.assertLive();
+        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') {
+        const span = changedSpan(this.text, text);
+        const before = this.text;
+        this.text = text;
+        if (span === null) {
+            return;
+        }
+        // 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));
+        }
+        this.followTracked(span.start, span.end, span.text.length);
+        this.ghost = null;
+        const change = {
+            source,
+            changes: [{ range: { start: positionIn(before, span.start), end: positionIn(before, span.end) }, text: span.text }]
+        };
+        for (const listener of [...this.textChanges]) {
+            listener(change);
+        }
+    }
+    tracked = new Set();
+    /* The fake sees one change per edit, the stretch that differs, so a range it tracks is lost a little sooner than the real editor's. */
+    followTracked(from, to, insertedLength) {
+        for (const entry of this.tracked) {
+            const mapped = mapTrackedRange(entry.from, entry.to, [{ from, to, insertedLength }]);
+            if (mapped === null) {
+                this.tracked.delete(entry);
+                entry.lost = true;
+            }
+            else {
+                Object.assign(entry, mapped);
+            }
+        }
+    }
+    trackRange(range) {
+        const entry = { from: this.offsetAt(range.start), to: this.offsetAt(range.end), lost: false };
+        this.tracked.add(entry);
+        return {
+            get: () => (entry.lost ? null : { start: this.positionAt(entry.from), end: this.positionAt(entry.to) }),
+            dispose: () => {
+                entry.lost = true;
+                this.tracked.delete(entry);
+            }
+        };
+    }
+    onTextChange(listener) {
+        this.textChanges.add(listener);
+        return () => {
+            this.textChanges.delete(listener);
+        };
+    }
+    positionAt(offset) {
+        return positionIn(this.text, offset);
+    }
+    textInRange(range) {
+        return this.text.slice(this.offsetAt(range.start), this.offsetAt(range.end));
+    }
+    offsetAt(position) {
+        const lines = this.text.split('\n');
+        let offset = 0;
+        for (let line = 0; line < Math.min(position.line, lines.length - 1); line++) {
+            offset += lines[line].length + 1;
+        }
+        const current = lines[Math.min(position.line, lines.length - 1)];
+        return offset + Math.min(position.character, current.length);
+    }
+    onChange(listener) {
+        return subscribe(this.changes, listener);
+    }
+    onSave(listener) {
+        return subscribe(this.saves, listener);
+    }
+    onBlur(listener) {
+        return subscribe(this.blurs, listener);
+    }
+    /* How the client last asked the view to follow a jump. */
+    lastReveal = null;
+    revealLine(line, reveal = 'center') {
+        this.revealedLine = line;
+        this.lastReveal = reveal;
+    }
+    /* Counts plain occurrences only; the matcher itself is the editor's, and a test here is about the client's side. */
+    find(query) {
+        this.findQuery = query;
+        const needle = query === null || query.text === '' ? '' : query.caseSensitive ? query.text : query.text.toLowerCase();
+        const haystack = query?.caseSensitive === true ? this.text : this.text.toLowerCase();
+        const count = needle === '' ? 0 : haystack.split(needle).length - 1;
+        this.announceFind({ count, current: count === 0 ? null : 0 });
+    }
+    /* What the client asked to replace, one match at a time and all at once. */
+    replacements = [];
+    replaceOptions = [];
+    /* What the client last asked to show under the match. */
+    replacePreview = null;
+    /* What the client asked to select all matches of, and how many it was told there were. */
+    selectedMatches = 0;
+    lastFindFromCursor = null;
+    replacementsOfAll = [];
+    replace(replacement, options = {}) {
+        this.replacements.push(replacement);
+        this.replaceOptions.push(options);
+        return !this.readOnly && this.findState.count > 0;
+    }
+    replaceAll(replacement, options = {}) {
+        this.replacementsOfAll.push(replacement);
+        this.replaceOptions.push(options);
+        return this.readOnly ? 0 : this.findState.count;
+    }
+    setReplacePreview(replacement) {
+        this.replacePreview = replacement;
+    }
+    selectFindMatches() {
+        this.selectedMatches = this.findState.count;
+        this.find(null);
+        return this.selectedMatches;
+    }
+    findFromCursor(query, direction) {
+        this.lastFindFromCursor = { query, direction };
+        return true;
+    }
+    findStep(direction) {
+        const { count, current } = this.findState;
+        if (count > 0) {
+            this.announceFind({ count, current: ((current ?? 0) + direction + count) % count });
+        }
+    }
+    onFind(listener) {
+        this.finds.add(listener);
+        return () => {
+            this.finds.delete(listener);
+        };
+    }
+    endFind() {
+        this.find(null);
+    }
+    setWrap(wrap) {
+        this.wrap = wrap;
+    }
+    /* What the client handed it last; null while it reads the structure itself. */
+    blocks = null;
+    scopes = new Set();
+    /* What the client marked as changed last. */
+    changeMarks = [];
+    setChangeMarks(marks) {
+        this.changeMarks = marks;
+    }
+    /* The tinted lines the client set last. */
+    lineHighlights = [];
+    setLineHighlights(highlights) {
+        this.lineHighlights = highlights;
+    }
+    /* What the client drew as code outside the document: the text and how, and into which element. */
+    codeBlocks = [];
+    renderCode(container, text, options = {}) {
+        this.codeBlocks.push({ container, text, options });
+    }
+    /* The cursors of agents the client set last. */
+    remoteCursors = [];
+    setRemoteCursors(cursors) {
+        this.remoteCursors = cursors;
+    }
+    /* What the client marked as written by an agent last. */
+    attributionMarks = [];
+    attributionHovers = new Set();
+    setAttributionMarks(marks) {
+        this.attributionMarks = marks;
+    }
+    onAttributionHover(listener) {
+        this.attributionHovers.add(listener);
+        return () => {
+            this.attributionHovers.delete(listener);
+        };
+    }
+    /* The pointer on the bar of a mark, or leaving it. The rect is where `rectAt` puts the mark's first line unless given. */
+    hoverAttribution(id, rect) {
+        const mark = id === null ? undefined : this.attributionMarks.find((candidate) => candidate.id === id);
+        const hover = mark === undefined
+            ? null
+            : { id: mark.id, rect: rect ?? this.rectAt({ line: mark.startLine - 1, character: 0 }) ?? { left: 0, top: 0, right: 0, bottom: 0 } };
+        for (const listener of [...this.attributionHovers]) {
+            listener(hover);
+        }
+    }
+    /* What each owner put next to lines of the text last. */
+    widgetsByOwner = new Map();
+    /* The default owner's rows. */
+    get widgets() {
+        return this.widgetsByOwner.get('default') ?? [];
+    }
+    /* The row ids each owner has drawn, since the editor draws a row once and keeps it for as long as its id stays. */
+    drawnWidgets = new Map();
+    setWidgets(widgets, owner = 'default') {
+        if (widgets.length === 0) {
+            this.widgetsByOwner.delete(owner);
+            this.drawnWidgets.delete(owner);
+            return;
+        }
+        this.widgetsByOwner.set(owner, widgets);
+        const before = this.drawnWidgets.get(owner) ?? new Set();
+        for (const widget of widgets) {
+            if (!before.has(widget.id)) {
+                widget.render({});
+            }
+        }
+        this.drawnWidgets.set(owner, new Set(widgets.map((widget) => widget.id)));
+    }
+    lineActionsByOwner = new Map();
+    setLineActions(actions, owner = 'default') {
+        if (actions.length === 0) {
+            this.lineActionsByOwner.delete(owner);
+        }
+        else {
+            this.lineActionsByOwner.set(owner, actions);
+        }
+    }
+    /* The code vision rows the client set last. */
+    codeVision = [];
+    setCodeVision(rows) {
+        this.codeVision = rows;
+    }
+    /* The button the client set in the gutter last. */
+    gutterAction = null;
+    gutterActionListeners = new Set();
+    setGutterAction(action) {
+        this.gutterAction = action;
+    }
+    onGutterAction(listener) {
+        this.gutterActionListeners.add(listener);
+        return () => {
+            this.gutterActionListeners.delete(listener);
+        };
+    }
+    /* What each owner put in the gutter last. */
+    gutterMarkersByOwner = new Map();
+    gutterMarkerListeners = new Set();
+    setGutterMarkers(markers, owner = 'default') {
+        if (markers.length === 0) {
+            this.gutterMarkersByOwner.delete(owner);
+        }
+        else {
+            this.gutterMarkersByOwner.set(owner, markers);
+        }
+    }
+    onGutterMarker(listener) {
+        this.gutterMarkerListeners.add(listener);
+        return () => {
+            this.gutterMarkerListeners.delete(listener);
+        };
+    }
+    /* A press on a gutter marker. */
+    pressGutterMarker(id) {
+        for (const listener of [...this.gutterMarkerListeners]) {
+            listener(id);
+        }
+    }
+    /* A press on the gutter button, if there is one. */
+    pressGutterAction() {
+        if (this.gutterAction !== null) {
+            for (const listener of [...this.gutterActionListeners]) {
+                listener(this.gutterAction.line);
+            }
+        }
+    }
+    setBlocks(blocks) {
+        this.blocks = blocks;
+    }
+    onScope(listener) {
+        this.scopes.add(listener);
+        return () => {
+            this.scopes.delete(listener);
+        };
+    }
+    /* The caret moving into blocks, for a test of what the client draws from it. */
+    enterScope(scope) {
+        for (const listener of [...this.scopes]) {
+            listener(scope);
+        }
+    }
+    smartKeys;
+    guides = true;
+    whitespace = false;
+    rightMargin = null;
+    setGuides(guides) {
+        this.guides = guides;
+    }
+    setWhitespace(whitespace) {
+        this.whitespace = whitespace;
+    }
+    setRightMargin(column) {
+        this.rightMargin = column;
+    }
+    foldOutline = 'hover';
+    foldHints = null;
+    setFoldOutline(outline) {
+        this.foldOutline = outline;
+    }
+    label;
+    setLabel(label) {
+        this.label = label;
+    }
+    setFoldHints(hints) {
+        this.foldHints = hints;
+    }
+    setSmartKeys(keys) {
+        this.smartKeys = keys;
+    }
+    setIndentation(indentation) {
+        this.indentation = indentation;
+    }
+    /* What the client marked and highlighted last. */
+    markers = [];
+    highlights = [];
+    caret = { line: 0, character: 0 };
+    /* Where `rectAt` puts a position, which a test can move to simulate scrolling. */
+    origin = { left: 100, top: 100 };
+    charSize = { width: 8, height: 20 };
+    carets = new Set();
+    hovers = new Set();
+    views = new Set();
+    keys = new Set();
+    setMarkers(markers) {
+        this.markers = markers;
+    }
+    /* What the client drew as hints last. */
+    inlayHints = [];
+    setInlayHints(hints) {
+        this.inlayHints = hints;
+    }
+    /* The suggestion after the caret now, which any change of the text takes away as the real editor does. */
+    ghost = null;
+    setGhostText(ghost) {
+        this.ghost = ghost;
+    }
+    /* What the client classified last. */
+    semanticTokens = null;
+    setSemanticTokens(tokens) {
+        this.semanticTokens = tokens;
+    }
+    /* What the client drew as a link last. */
+    link = null;
+    setLink(range) {
+        this.link = range;
+    }
+    setHighlights(highlights) {
+        this.highlights = highlights;
+    }
+    getCaret() {
+        return this.caret;
+    }
+    /* The folds the client asked to keep. */
+    folds = { collapsed: [], custom: [] };
+    getFolds() {
+        return this.folds;
+    }
+    getScrollTop() {
+        return this.scrollTop ?? 0;
+    }
+    /* The selection a person made; without one the caret. */
+    selection = null;
+    getSelection() {
+        return this.selection ?? { start: this.caret, end: this.caret };
+    }
+    /* The other selections of the editor; the primary one is always last. */
+    otherSelections = [];
+    /* The other carets of the editor, which a test sets. */
+    get otherCarets() {
+        return this.otherSelections.map((range) => range.end);
+    }
+    set otherCarets(positions) {
+        this.otherSelections = positions.map((position) => ({ start: position, end: position }));
+    }
+    getSelections() {
+        return [...this.otherSelections, this.getSelection()];
+    }
+    setSelections(ranges, reveal = 'relative') {
+        const last = ranges.at(-1);
+        if (last === undefined) {
+            return;
+        }
+        this.otherSelections = ranges.slice(0, -1).map((range) => ({ ...range }));
+        this.setSelection(last, reveal);
+    }
+    getIndentation() {
+        return this.indentation;
+    }
+    setCaret(position, reveal = 'relative') {
+        this.lastReveal = reveal;
+        this.caret = position;
+        this.revealedLine = position.line + 1;
+        this.moveCaret(position);
+    }
+    setSelection(range, reveal = 'relative') {
+        this.lastReveal = reveal;
+        this.caret = range.end;
+        this.selection = range;
+        for (const listener of [...this.carets]) {
+            listener(range.end);
+        }
+    }
+    /* The caret a person's click or key moved. */
+    moveCaret(position) {
+        this.caret = position;
+        this.selection = null;
+        for (const listener of [...this.carets]) {
+            listener(position);
+        }
+    }
+    onCaret(listener) {
+        this.carets.add(listener);
+        return () => {
+            this.carets.delete(listener);
+        };
+    }
+    onHover(listener) {
+        this.hovers.add(listener);
+        return () => {
+            this.hovers.delete(listener);
+        };
+    }
+    /* The pointer resting on a position, or leaving the text. */
+    hover(position) {
+        const hover = position === null ? null : { position, rect: this.rectAt(position) };
+        for (const listener of [...this.hovers]) {
+            listener(hover);
+        }
+    }
+    rectAt(position) {
+        const left = this.origin.left + position.character * this.charSize.width;
+        const top = this.origin.top + position.line * this.charSize.height;
+        return { left, top, right: left + this.charSize.width, bottom: top + this.charSize.height };
+    }
+    onViewChange(listener) {
+        return subscribe(this.views, listener);
+    }
+    /* What `getVisibleRange` answers; the whole text until a test scrolls. */
+    visibleRange = null;
+    getVisibleRange() {
+        return this.visibleRange ?? { start: { line: 0, character: 0 }, end: this.positionAt(Number.MAX_SAFE_INTEGER) };
+    }
+    /* The editor scrolling, to a range of lines when a test says which. */
+    scroll(range) {
+        if (range !== undefined) {
+            this.visibleRange = range;
+        }
+        emit(this.views);
+    }
+    /* What `setSelectionRanges` was last given. */
+    selectionRanges = null;
+    setSelectionRanges(provider) {
+        this.selectionRanges = provider;
+    }
+    onKeyDown(handler) {
+        this.keys.add(handler);
+        return () => {
+            this.keys.delete(handler);
+        };
+    }
+    clickHandlers = new Set();
+    contextListeners = new Set();
+    onClick(handler) {
+        this.clickHandlers.add(handler);
+        return () => {
+            this.clickHandlers.delete(handler);
+        };
+    }
+    onContextMenu(listener) {
+        this.contextListeners.add(listener);
+        return () => {
+            this.contextListeners.delete(listener);
+        };
+    }
+    /* A press on a character as the editor sees it first; true when a handler took it, and the caret stays where it is otherwise only until the test moves it. */
+    click(click) {
+        return [...this.clickHandlers].some((handler) => handler(click));
+    }
+    /* The context menu asked for at a position. */
+    openContextMenu(menu) {
+        for (const listener of [...this.contextListeners]) {
+            listener(menu);
+        }
+    }
+    /* A key as the editor sees it first; true when a handler took it. */
+    press(event) {
+        const full = { ctrlKey: false, metaKey: false, altKey: false, shiftKey: false, preventDefault: () => undefined, ...event };
+        return [...this.keys].some((handler) => handler(full));
+    }
+    applyEdits(edits) {
+        if (this.readOnly || edits.length === 0) {
+            return false;
+        }
+        let text = this.text;
+        const ordered = edits
+            .map((edit) => ({ from: this.offsetAt(edit.range.start), to: this.offsetAt(edit.range.end), text: edit.text }))
+            .sort((a, b) => b.from - a.from);
+        for (const edit of ordered) {
+            text = text.slice(0, edit.from) + edit.text + text.slice(edit.to);
+        }
+        // The other carets follow the text as the real editor's do: one inside a replaced stretch ends behind what replaced it.
+        const others = this.otherSelections.map((range) => ({ anchor: this.offsetAt(range.start), head: this.offsetAt(range.end) }));
+        const follow = (offset) => {
+            let delta = 0;
+            for (const edit of [...ordered].reverse()) {
+                if (offset < edit.from) {
+                    break;
+                }
+                if (offset < edit.to || (offset === edit.from && edit.from === edit.to)) {
+                    return edit.from + delta + edit.text.length;
+                }
+                delta += edit.text.length - (edit.to - edit.from);
+            }
+            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))
+        }));
+        emit(this.changes);
+        return true;
+    }
+    setTheme(theme) {
+        this.theme = theme;
+    }
+    refreshFont() {
+        this.fontRefreshes += 1;
+    }
+    setReadOnly(readOnly, reason) {
+        this.readOnly = readOnly;
+        this.readOnlyReason = reason;
+    }
+    /* The commands run, in order; the fake has no commands of its own to carry out. */
+    commands = [];
+    runCommand(command) {
+        this.commands.push(command);
+        return false;
+    }
+    focus() {
+        this.focused = true;
+    }
+    dispose() {
+        this.disposed = true;
+        this.changes.clear();
+        this.textChanges.clear();
+        this.carets.clear();
+        this.hovers.clear();
+        this.attributionHovers.clear();
+        this.views.clear();
+        this.keys.clear();
+        this.saves.clear();
+        this.blurs.clear();
+        this.finds.clear();
+        this.scopes.clear();
+        this.tracked.clear();
+    }
+    announceFind(state) {
+        this.findState = state;
+        for (const listener of [...this.finds]) {
+            listener(state);
+        }
+    }
+    /* A test that drives an editor its client already disposed has found a leak. */
+    assertLive() {
+        if (this.disposed) {
+            throw new Error('The editor is disposed');
+        }
+    }
+}
+export class FakeEditorEngine {
+    editors = [];
+    mount(element, options) {
+        const editor = new FakeEditor(element, options);
+        this.editors.push(editor);
+        return editor;
+    }
+    /* The editor mounted last, which is the one a test of a single surface drives. */
+    get last() {
+        const editor = this.editors.at(-1);
+        if (!editor) {
+            throw new Error('No editor was mounted');
+        }
+        return editor;
+    }
+}

package/dist/find.d.ts

@@ -0,0 +1,30 @@
+import type { DocumentChange, DocumentModel } from '@adecore/editor-core';
+import type { EditorFindQuery, EditorFindState } from './types.ts';
+export interface FindMark {
+    from: number;
+    to: number;
+}
+export declare const FIND_LIMIT = 10000;
+export declare class FindController {
+    private query;
+    private marks;
+    private index;
+    private bounds;
+    pendingAnchor: number | undefined;
+    private readonly model;
+    constructor(model: DocumentModel);
+    get activeQuery(): EditorFindQuery | null;
+    get active(): boolean;
+    get matches(): readonly FindMark[];
+    get current(): number | null;
+    get state(): EditorFindState;
+    get scope(): {
+        from: number;
+        to: number;
+    } | null;
+    get currentMark(): FindMark | null;
+    set(query: EditorFindQuery | null): void;
+    mapBounds(changes: readonly DocumentChange[]): void;
+    refresh(): void;
+    step(direction: 1 | -1): void;
+}