@adecore/editor 0.22.1 → 0.23.1

package/dist/engine.js

@@ -1,4 +1,6 @@
 import { changedSpans, DocumentModel, replacementText } from '@adecore/editor-core';
+import { MAX_REPLACEMENT_CHARACTERS } from './search-protocol.js';
+import { GrammarPreparation } from './grammar-preparation.js';
 import { InputController } from './controller.js';
 import { resolveSmartKeys } from './smart-keys.js';
 import { emit, subscribe } from './listeners.js';
@@ -7,11 +9,14 @@ import { EditorView } from './view.js';
 const DEFAULT_TAB_SIZE = 4;
 const DEFAULT_LABEL = 'Code editor';
 const DEFAULT_WIDGET_OWNER = 'default';
+/* The space a hint's padding keeps clear; a whole pixel count so the pill stays on the pixel grid. */
+const INLAY_GAP = 4;
 class SmartEditor {
     model;
     settings;
     view;
     controller;
+    grammarPreparation;
     changes = new Set();
     textChanges = new Set();
     carets = new Set();
@@ -34,6 +39,7 @@ class SmartEditor {
         this.language = options.language;
         this.theme = options.theme;
         this.settings = {
+            searchWorker: engine.searchWorker,
             language: options.language,
             tabSize: options.indentation?.tabSize ?? DEFAULT_TAB_SIZE,
             insertSpaces: options.indentation?.insertSpaces ?? true,
@@ -44,13 +50,16 @@ class SmartEditor {
             messages: options.messages ?? {},
             label: options.label ?? DEFAULT_LABEL,
             guides: options.guides !== false,
+            stickyScroll: options.stickyScroll !== false,
             whitespace: options.whitespace === true,
             rightMargin: options.rightMargin ?? null,
-            foldOutline: options.foldOutline ?? 'hover'
+            foldOutline: options.foldOutline ?? 'hover',
+            folding: options.folding !== false
         };
         this.view = new EditorView(element, this.model, this.settings);
+        this.grammarPreparation = new GrammarPreparation(this.model, () => this.view.grammarChanged());
         this.controller = new InputController(this.view, {
-            handBack: engine.handBack ?? [],
+            handBack: [...(engine.handBack ?? []), ...(options.handBack ?? [])],
             keymap: engine.keymap,
             apple: engine.apple ?? false,
             save: () => emit(this.saves),
@@ -62,8 +71,9 @@ class SmartEditor {
             this.caretMoved(snapshot.selections.at(-1).head);
             if (snapshot.revision !== this.revision) {
                 this.revision = snapshot.revision;
+                this.grammarPreparation.edited(snapshot.changes ?? []);
                 if (snapshot.contentEdits !== undefined && snapshot.contentEdits.length > 0) {
-                    this.announceTextChange(snapshot.contentEdits, snapshot.source ?? 'external');
+                    this.announceTextChange(snapshot.contentEdits, snapshot.source ?? 'external', snapshot.typed === true);
                 }
                 if (!this.settingText) {
                     emit(this.changes);
@@ -96,6 +106,7 @@ class SmartEditor {
     }
     loadTokenizer() {
         const request = ++this.tokenizerRequest;
+        this.grammarPreparation.begin();
         void this.engine
             .scopeColors?.(this.theme)
             .catch(() => null)
@@ -110,6 +121,7 @@ class SmartEditor {
             .then((tokenizer) => {
             if (!this.disposed && request === this.tokenizerRequest) {
                 this.view.setTokenizer(tokenizer);
+                this.grammarPreparation.ready(tokenizer);
             }
         });
     }
@@ -136,9 +148,10 @@ class SmartEditor {
     onTextChange(listener) {
         return subscribe(this.textChanges, listener);
     }
-    announceTextChange(edits, source) {
+    announceTextChange(edits, source, typed) {
         const change = {
             source,
+            ...(typed ? { typed } : {}),
             changes: edits.map((edit) => ({
                 range: { start: { line: edit.start.line, character: edit.start.column }, end: { line: edit.end.line, character: edit.end.column } },
                 text: edit.text
@@ -160,6 +173,21 @@ class SmartEditor {
     getScrollTop() {
         return this.view.scrollPlace.y;
     }
+    setScrollTop(top) {
+        this.view.setScrollTop(top);
+    }
+    getLineHeight(line) {
+        return this.view.getLineHeight(line);
+    }
+    getBaseLineHeight() {
+        return this.view.layout.metrics.lineHeight;
+    }
+    onLineHeights(listener) {
+        return this.view.onLineHeights(listener);
+    }
+    getContentHeight() {
+        return this.view.contentHeight;
+    }
     getSelection() {
         return this.rangeOf(this.model.getPrimary());
     }
@@ -218,12 +246,29 @@ class SmartEditor {
     setSelectionRanges(provider) {
         this.controller.setSelectionRanges(provider);
     }
-    applyEdits(edits) {
+    applyEdits(edits, options = {}) {
         if (this.settings.readOnly || edits.length === 0) {
             return false;
         }
         try {
-            return this.model.applyEdits(edits.map((edit) => ({ from: this.offsetAt(edit.range.start), to: this.offsetAt(edit.range.end), text: edit.text })), { source: 'command' });
+            const { mapSelections } = options;
+            return this.model.applyEdits(edits.map((edit) => ({ from: this.offsetAt(edit.range.start), to: this.offsetAt(edit.range.end), text: edit.text })), {
+                source: 'command',
+                joinPrevious: options.mergeUndo === true,
+                selectionPositions: mapSelections &&
+                    this.model.getSelections().map((selection) => {
+                        const { start, end } = mapSelections(this.rangeOf(selection));
+                        const from = { line: start.line, column: start.character };
+                        const to = { line: end.line, column: end.character };
+                        if (selection.head < selection.anchor) {
+                            return { anchor: to, head: from };
+                        }
+                        return {
+                            anchor: from,
+                            head: selection.head === selection.anchor && start.line === end.line && start.character === end.character ? from : to
+                        };
+                    })
+            });
         }
         catch {
             return false;
@@ -240,7 +285,23 @@ class SmartEditor {
         })));
     }
     setInlayHints(hints) {
-        this.view.setInlays(hints.map((hint, index) => ({ id: `hint-${index}`, at: this.offsetAt(hint.position), text: hint.label })));
+        this.view.setInlays(hints.map((hint, index) => ({
+            id: hint.id ?? `hint-${index}`,
+            at: this.offsetAt(hint.position),
+            text: hint.label,
+            ...(hint.parts === undefined ? {} : { parts: hint.parts }),
+            ...(hint.paddingLeft ? { gapLeft: INLAY_GAP } : {}),
+            ...(hint.paddingRight ? { gapRight: INLAY_GAP } : {})
+        })));
+    }
+    onInlayHover(listener) {
+        return this.view.onInlayHover(listener);
+    }
+    onInlayClick(handler) {
+        return this.controller.onInlayClick(handler);
+    }
+    setInlayLink(target) {
+        this.view.setInlayLink(target);
     }
     setGhostText(ghost) {
         this.view.setGhost(ghost === null ? null : { at: this.offsetAt(ghost.position), text: ghost.text, accessory: ghost.accessory });
@@ -250,7 +311,7 @@ class SmartEditor {
             ? null
             : tokens.map((token) => {
                 const from = this.offsetAt({ line: token.line, character: token.character });
-                return { from, to: from + token.length, scopes: token.scopes };
+                return { from, to: from + token.length, scopes: token.scopes, within: token.within };
             }));
     }
     setHighlights(highlights) {
@@ -292,19 +353,23 @@ class SmartEditor {
     }
     replace(replacement, replaceOptions = {}) {
         const { find } = this.view;
-        const mark = find.currentMark;
-        const query = find.activeQuery;
-        if (mark === null || query === null || this.blockedByReadOnly()) {
+        const match = find.currentMatch;
+        if (this.blockedByReadOnly()) {
             return false;
         }
-        try {
-            const options = { caseSensitive: query.caseSensitive, wholeWord: query.wholeWord, regex: query.regex, from: mark.from, to: mark.to, maxResults: 1 };
-            const match = this.model.find(query.text, options)[0];
-            if (match === undefined) {
+        if (find.activeQuery?.regex === true) {
+            if (find.currentMark === null) {
                 return false;
             }
+            void find.replaceOne(replacement, replaceOptions.preserveCase === true, () => !this.disposed && !this.settings.readOnly);
+            return true;
+        }
+        if (match === null) {
+            return false;
+        }
+        try {
             // The next match is looked for after what was written, or a replacement that holds the query would find itself again.
-            find.pendingAnchor = mark.from + replacementText(this.model.getText(), match, replacement, false, replaceOptions.preserveCase).length;
+            find.pendingAnchor = match.to;
             if (!this.model.replace(match, replacement, { preserveCase: replaceOptions.preserveCase })) {
                 find.pendingAnchor = undefined;
                 return false;
@@ -319,23 +384,48 @@ class SmartEditor {
         return true;
     }
     replaceAll(replacement, options = {}) {
-        const query = this.view.find.activeQuery;
-        if (query === null || this.blockedByReadOnly()) {
+        const { find } = this.view;
+        const query = find.activeQuery;
+        if (query === null || find.state.noSelection === true || this.blockedByReadOnly()) {
             return 0;
         }
         try {
-            return this.model.replaceAll(query.text, replacement, {
-                caseSensitive: query.caseSensitive,
-                wholeWord: query.wholeWord,
-                regex: query.regex,
-                preserveCase: options.preserveCase,
-                ...this.view.find.scope
-            });
+            const matches = find.completeMatches;
+            if (matches !== null) {
+                let characters = 0;
+                for (const match of matches) {
+                    characters += replacementText('', match, replacement, false, options.preserveCase, MAX_REPLACEMENT_CHARACTERS).length;
+                    if (characters > MAX_REPLACEMENT_CHARACTERS) {
+                        find.reportReplaceFailed('limit');
+                        return 0;
+                    }
+                }
+                const count = this.model.replaceMatches(matches, replacement, { preserveCase: options.preserveCase });
+                find.reportReplaced(count);
+                return count;
+            }
+            void this.replaceAllAsync(replacement, options);
+            return 0;
         }
-        catch {
+        catch (error) {
+            find.reportReplaceFailed(error instanceof RangeError ? 'limit' : 'error');
             return 0;
         }
     }
+    async replaceAllAsync(replacement, options = {}) {
+        const { find } = this.view;
+        if (this.disposed || this.blockedByReadOnly() || find.activeQuery === null || find.state.noSelection) {
+            return 0;
+        }
+        if (find.state.limited) {
+            find.reportReplaceFailed('limit');
+            return 0;
+        }
+        if (find.completeMatches !== null) {
+            return this.replaceAll(replacement, options);
+        }
+        return find.replaceAll(replacement, options.preserveCase === true, () => !this.disposed && !this.settings.readOnly);
+    }
     setReplacePreview(replacement, options = {}) {
         this.view.setReplacePreview(replacement, options.preserveCase === true);
     }
@@ -359,24 +449,38 @@ class SmartEditor {
         if (query.text === '') {
             return false;
         }
-        let matches;
+        const { anchor, head } = this.model.getPrimary();
+        const offset = direction === 1 ? Math.max(anchor, head) : Math.min(anchor, head);
+        const reveal = (target) => {
+            if (target === null || this.disposed) {
+                return false;
+            }
+            this.view.ensureVisible(target.from);
+            this.model.setSelections([direction === 1 ? { anchor: target.from, head: target.to } : { anchor: target.to, head: target.from }]);
+            this.view.revealCaret(target.from > head ? 'centerDown' : 'centerUp');
+            return true;
+        };
+        if (query.regex) {
+            const revision = this.model.getRevision();
+            void this.view.find.nextFromCursor(query, offset, direction).then((target) => {
+                const current = this.model.getPrimary();
+                if (this.model.getRevision() === revision && current.anchor === anchor && current.head === head) {
+                    reveal(target);
+                }
+            });
+            return true;
+        }
         try {
-            matches = this.model.find(query.text, { caseSensitive: query.caseSensitive, wholeWord: query.wholeWord, regex: query.regex });
+            return reveal(this.model.findNext(query.text, offset, {
+                caseSensitive: query.caseSensitive,
+                wholeWord: query.wholeWord,
+                backwards: direction === -1,
+                wrap: true
+            }));
         }
         catch {
             return false;
         }
-        if (matches.length === 0) {
-            return false;
-        }
-        const { anchor, head } = this.model.getPrimary();
-        const from = Math.min(anchor, head);
-        const to = Math.max(anchor, head);
-        const target = direction === 1 ? (matches.find((match) => match.from >= to) ?? matches[0]) : (matches.findLast((match) => match.to <= from) ?? matches.at(-1));
-        this.view.ensureVisible(target.from);
-        this.model.setSelections([direction === 1 ? { anchor: target.from, head: target.to } : { anchor: target.to, head: target.from }]);
-        this.view.revealCaret(target.from > head ? 'centerDown' : 'centerUp');
-        return true;
     }
     blockedByReadOnly() {
         if (!this.settings.readOnly) {
@@ -406,8 +510,8 @@ class SmartEditor {
         }
         this.view.applySettings();
     }
-    setChangeMarks(marks) {
-        this.view.setChangeMarks(marks);
+    setChangeMarks(marks, layer) {
+        this.view.setChangeMarks(marks, layer);
     }
     setAttributionMarks(marks) {
         this.view.setAttributionMarks(marks);
@@ -415,6 +519,26 @@ class SmartEditor {
     setLineHighlights(highlights) {
         this.view.setLineHighlights(highlights);
     }
+    setLineLabels(labels) {
+        this.view.setLineLabels(labels);
+    }
+    setInputPopup(popup) {
+        this.view.setInputPopup(popup);
+    }
+    announce(message) {
+        this.view.announce(message);
+    }
+    setMessages(messages) {
+        this.settings.messages = { ...this.settings.messages, ...messages };
+        this.view.repaint();
+    }
+    setLineNumbers(labels) {
+        this.view.setLineNumbers(labels);
+    }
+    setLineTokens(tokens) {
+        this.grammarPreparation.pause(tokens !== null);
+        this.view.setLineTokens(tokens);
+    }
     renderCode(container, text, options = {}) {
         this.view.renderCode(container, text, options);
     }
@@ -430,12 +554,28 @@ class SmartEditor {
             at: this.offsetAt({ line: widget.line, character: 0 }),
             placement: widget.placement ?? 'below',
             height: widget.height,
+            fixed: widget.fixed,
             render: (container) => {
                 container.classList.add('se-widget');
                 widget.render(container);
             }
         })));
     }
+    setReplacements(replacements, owner = DEFAULT_WIDGET_OWNER) {
+        this.view.setReplacements(owner, replacements.map((replacement) => ({
+            id: `replacement:${owner}:${replacement.id}`,
+            from: this.offsetAt({ line: replacement.startLine, character: 0 }),
+            to: this.model.getLine(Math.max(0, Math.min(replacement.endLine, this.model.getLineCount() - 1))).end,
+            height: replacement.height,
+            label: replacement.label,
+            enterable: replacement.enterable,
+            onReveal: replacement.onReveal === undefined ? undefined : () => replacement.onReveal(),
+            render: (container) => {
+                container.classList.add('se-widget-replacement');
+                replacement.render(container);
+            }
+        })));
+    }
     setLineActions(actions, owner = DEFAULT_WIDGET_OWNER) {
         this.view.setLineActions(owner, actions.map((action) => ({
             id: action.id,
@@ -502,6 +642,10 @@ class SmartEditor {
         this.settings.guides = guides;
         this.view.applySettings();
     }
+    setStickyScroll(sticky) {
+        this.settings.stickyScroll = sticky;
+        this.view.applySettings();
+    }
     setWhitespace(whitespace) {
         this.settings.whitespace = whitespace;
         this.view.applySettings();
@@ -568,6 +712,9 @@ class SmartEditor {
         this.settings.readOnlyReason = reason;
         this.view.applySettings();
     }
+    isReadOnly() {
+        return this.settings.readOnly;
+    }
     runCommand(command) {
         return this.controller.command(command);
     }
@@ -582,6 +729,7 @@ class SmartEditor {
             return;
         }
         this.disposed = true;
+        this.grammarPreparation.dispose();
         this.changes.clear();
         this.textChanges.clear();
         this.carets.clear();

package/dist/fake.d.ts

@@ -1,11 +1,11 @@
-import type { Editor, EditorAttributionHover, EditorAttributionMark, EditorBlock, EditorCodeBlockOptions, EditorLineAction, EditorLineHighlight, EditorChangeMark, EditorCodeVision, EditorClick, EditorClickHandler, EditorContextMenu, EditorContentChange, EditorEngine, EditorFindQuery, EditorFindState, EditorReplaceOptions, EditorGutterAction, EditorGutterMarker, EditorHighlight, EditorHover, EditorIndentation, EditorGhostText, EditorInlayHint, EditorKeyHandler, EditorMarker, EditorOptions, EditorPosition, EditorRemoteCursor, EditorRange, EditorReveal, EditorRect, EditorRunCommand, EditorSelectionRanges, EditorFoldHints, EditorFoldOutline, EditorFolds, EditorSemanticToken, EditorSmartKeys, EditorTextChange, EditorTrackedRange, EditorTheme, EditorWidget } from './types.ts';
+import type { Editor, EditorAttributionHover, EditorAttributionMark, EditorBlock, EditorCodeBlockOptions, EditorLineAction, EditorReplacement, EditorLineHighlight, LineToken, EditorChangeMark, EditorCodeVision, EditorClick, EditorClickHandler, EditorContextMenu, EditorContentChange, EditorEngine, EditorFindQuery, EditorFindState, EditorReplaceOptions, EditorGutterAction, EditorGutterMarker, EditorHighlight, EditorHover, EditorIndentation, EditorGhostText, EditorInlayClick, EditorInlayClickHandler, EditorInlayHint, EditorInlayTarget, EditorKeyHandler, EditorInputPopup, EditorMarker, EditorMessages, EditorOptions, EditorPosition, EditorRemoteCursor, EditorRange, EditorReveal, EditorRect, EditorRunCommand, EditorSelectionRanges, EditorFoldHints, EditorFoldOutline, EditorFolds, EditorSemanticToken, EditorSmartKeys, EditorApplyEditsOptions, EditorTextChange, EditorTrackedRange, EditorTheme, EditorWidget } from './types.ts';
 import { type Listener } from './listeners.ts';
 export declare class FakeEditor implements Editor {
     readonly element: HTMLElement;
     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;
@@ -54,6 +54,7 @@ export declare class FakeEditor implements Editor {
     replacementsOfAll: string[];
     replace(replacement: string, options?: EditorReplaceOptions): boolean;
     replaceAll(replacement: string, options?: EditorReplaceOptions): number;
+    replaceAllAsync(replacement: string, options?: EditorReplaceOptions): Promise<number>;
     setReplacePreview(replacement: string | null): void;
     selectFindMatches(): number;
     findFromCursor(query: EditorFindQuery, direction: 1 | -1): boolean;
@@ -63,8 +64,9 @@ export declare class FakeEditor implements Editor {
     setWrap(wrap: boolean): void;
     blocks: readonly EditorBlock[] | null;
     private readonly scopes;
-    changeMarks: readonly EditorChangeMark[];
-    setChangeMarks(marks: readonly EditorChangeMark[]): void;
+    get changeMarks(): readonly EditorChangeMark[];
+    private readonly changeLayers;
+    setChangeMarks(marks: readonly EditorChangeMark[], layer?: string): void;
     lineHighlights: readonly EditorLineHighlight[];
     setLineHighlights(highlights: readonly EditorLineHighlight[]): void;
     codeBlocks: {
@@ -72,6 +74,18 @@ export declare class FakeEditor implements Editor {
         text: string;
         options: EditorCodeBlockOptions;
     }[];
+    lineNumbers: ((line: number) => string | null) | null;
+    lineTokens: ((line: number) => readonly LineToken[] | null | undefined) | null;
+    setLineNumbers(labels: ((line: number) => string | null) | null): void;
+    lineLabels: ((line: number) => string | null) | null;
+    setLineLabels(labels: ((line: number) => string | null) | null): void;
+    inputPopup: EditorInputPopup | null;
+    setInputPopup(popup: EditorInputPopup | null): void;
+    announcements: string[];
+    announce(message: string): void;
+    messages: Partial<EditorMessages>;
+    setMessages(messages: Partial<EditorMessages>): void;
+    setLineTokens(tokens: ((line: number) => readonly LineToken[] | null | undefined) | null): void;
     renderCode(container: HTMLElement, text: string, options?: EditorCodeBlockOptions): void;
     remoteCursors: readonly EditorRemoteCursor[];
     setRemoteCursors(cursors: readonly EditorRemoteCursor[]): void;
@@ -84,6 +98,8 @@ export declare class FakeEditor implements Editor {
     get widgets(): readonly EditorWidget[];
     private readonly drawnWidgets;
     setWidgets(widgets: readonly EditorWidget[], owner?: string): void;
+    readonly replacementsByOwner: Map<string, readonly EditorReplacement[]>;
+    setReplacements(replacements: readonly EditorReplacement[], owner?: string): void;
     readonly lineActionsByOwner: Map<string, readonly EditorLineAction[]>;
     setLineActions(actions: readonly EditorLineAction[], owner?: string): void;
     codeVision: readonly EditorCodeVision[];
@@ -103,9 +119,11 @@ export declare class FakeEditor implements Editor {
     enterScope(scope: readonly EditorBlock[]): void;
     smartKeys: Partial<EditorSmartKeys>;
     guides: boolean;
+    stickyScroll: boolean;
     whitespace: boolean;
     rightMargin: number | null;
     setGuides(guides: boolean): void;
+    setStickyScroll(sticky: boolean): void;
     setWhitespace(whitespace: boolean): void;
     setRightMargin(column: number | null): void;
     foldOutline: EditorFoldOutline;
@@ -129,11 +147,26 @@ export declare class FakeEditor implements Editor {
     };
     private readonly carets;
     private readonly hovers;
+    private readonly lineHeights;
     private readonly views;
     private readonly keys;
     setMarkers(markers: readonly EditorMarker[]): void;
     inlayHints: readonly EditorInlayHint[];
     setInlayHints(hints: readonly EditorInlayHint[]): void;
+    private readonly inlayHovers;
+    private readonly inlayHandlers;
+    inlayLink: {
+        readonly id: string;
+        readonly part: number | null;
+    } | null;
+    onInlayHover(listener: (target: EditorInlayTarget | null) => void): () => void;
+    hoverInlay(id: string | null, part?: number | null): void;
+    onInlayClick(handler: EditorInlayClickHandler): () => void;
+    clickInlay(click: Partial<EditorInlayClick> & Pick<EditorInlayClick, 'id'>): boolean;
+    setInlayLink(target: {
+        readonly id: string;
+        readonly part: number | null;
+    } | null): void;
     ghost: EditorGhostText | null;
     setGhostText(ghost: EditorGhostText | null): void;
     semanticTokens: readonly EditorSemanticToken[] | null;
@@ -146,6 +179,12 @@ export declare class FakeEditor implements Editor {
     getFolds(): EditorFolds;
     getScrollTop(): number;
     selection: EditorRange | null;
+    contentHeight: number;
+    setScrollTop(top: number): void;
+    getLineHeight(line: number): number;
+    getBaseLineHeight(): number;
+    onLineHeights(listener: Listener): () => void;
+    getContentHeight(): number;
     getSelection(): EditorRange;
     private otherSelections;
     get otherCarets(): EditorPosition[];
@@ -174,10 +213,11 @@ export declare class FakeEditor implements Editor {
     click(click: EditorClick): boolean;
     openContextMenu(menu: EditorContextMenu): void;
     press(event: Pick<KeyboardEvent, 'key'> & Partial<KeyboardEvent>): boolean;
-    applyEdits(edits: readonly EditorContentChange[]): boolean;
+    applyEdits(edits: readonly EditorContentChange[], options?: EditorApplyEditsOptions): boolean;
     setTheme(theme: EditorTheme): void;
     refreshFont(): void;
     setReadOnly(readOnly: boolean, reason?: string): void;
+    isReadOnly(): boolean;
     readonly commands: EditorRunCommand[];
     runCommand(command: EditorRunCommand): boolean;
     focus(): void;