@adecore/editor-react 0.22.1 → 0.23.0

package/src/split-scroll.ts

@@ -0,0 +1,54 @@
+import type { Editor } from '@adecore/editor';
+import type { DiffSourceSide } from './diff-syntax.ts';
+
+type ScrollEditor = Pick<Editor, 'getScrollTop' | 'setScrollTop'>;
+
+export class SplitScroll {
+    private leader: DiffSourceSide = 'new';
+    private syncing = false;
+    private readonly expected: Record<DiffSourceSide, number>;
+
+    private readonly editors: Record<DiffSourceSide, ScrollEditor>;
+
+    constructor(editors: Record<DiffSourceSide, ScrollEditor>) {
+        this.editors = editors;
+        this.expected = { old: editors.old.getScrollTop(), new: editors.new.getScrollTop() };
+    }
+
+    drive(side: DiffSourceSide): void {
+        this.leader = side;
+    }
+
+    changed(side: DiffSourceSide): void {
+        if (this.syncing) {
+            return;
+        }
+        const top = this.editors[side].getScrollTop();
+        if (side !== this.leader) {
+            // Native scroll echoes arrive after setScrollTop returns, including a clamped follower position.
+            if (Math.abs(top - this.expected[side]) < 1) {
+                return;
+            }
+            this.leader = side;
+        }
+        this.sync();
+    }
+
+    sync(): void {
+        const side = this.leader;
+        const other = side === 'old' ? 'new' : 'old';
+        const top = this.editors[side].getScrollTop();
+        this.expected[side] = top;
+        if (Math.abs(this.editors[other].getScrollTop() - top) < 1) {
+            this.expected[other] = this.editors[other].getScrollTop();
+            return;
+        }
+        this.syncing = true;
+        try {
+            this.editors[other].setScrollTop(top);
+        } finally {
+            this.expected[other] = this.editors[other].getScrollTop();
+            this.syncing = false;
+        }
+    }
+}

package/src/symbols.ts

@@ -27,11 +27,13 @@ export interface SymbolSpan {
     readonly name: string;
     readonly kind: number;
     readonly range: Range;
+    /* The line of the name, when the server says where the name is. */
+    readonly nameLine?: number;
 }
 
 function walk(symbols: readonly DocumentSymbol[], spans: SymbolSpan[]): void {
     for (const symbol of symbols) {
-        spans.push({ name: symbol.name, kind: symbol.kind, range: symbol.range });
+        spans.push({ name: symbol.name, kind: symbol.kind, range: symbol.range, nameLine: symbol.selectionRange?.start.line });
         walk(symbol.children ?? [], spans);
     }
 }
@@ -49,17 +51,51 @@ export function symbolSpansOf(result: DocumentSymbolResult): SymbolSpan[] {
     return (result as SymbolInformation[]).map((symbol) => ({ name: symbol.name, kind: symbol.kind, range: symbol.location.range }));
 }
 
-function blockOf({ name, kind, range }: SymbolSpan): EditorBlock | null {
+/* A line a declaration can have above it: blank, a comment, or an attribute. A bare `#` is no comment, since it heads a Markdown section. */
+const PRELUDE = /^\s*(?:$|\/\/|\/\*|\*|#\[)/;
+
+/*
+ * The line a block is pinned by. A range may begin at the doc comment or the attributes of a declaration, so the
+ * line of the name wins, and without it the first line below the comment that holds the name.
+ */
+function headerLineOf({ name, range, nameLine }: SymbolSpan, lines: readonly string[] | undefined): number {
+    const { start, end } = range;
+    if (nameLine !== undefined && nameLine >= start.line && nameLine <= end.line) {
+        return nameLine;
+    }
+    if (lines === undefined) {
+        return start.line;
+    }
+    const last = Math.min(end.line, lines.length - 1);
+    let first = start.line;
+    while (first < last && PRELUDE.test(lines[first] ?? '')) {
+        first++;
+    }
+    const short = name.slice(name.lastIndexOf('\\') + 1);
+    for (let line = first; line <= last; line++) {
+        if (!PRELUDE.test(lines[line] ?? '') && (lines[line] ?? '').includes(short)) {
+            return line;
+        }
+    }
+    return first;
+}
+
+function blockOf(span: SymbolSpan, lines: readonly string[] | undefined): EditorBlock | null {
+    const { name, kind, range } = span;
     const label = KINDS[kind];
     // A one-line symbol has no body to pin, and a property or an enum member is part of the block around it.
     return label === undefined || range.end.line <= range.start.line
         ? null
-        : { startLine: range.start.line + 1, endLine: range.end.line + 1, name, kind: label };
+        : { startLine: headerLineOf(span, lines) + 1, endLine: range.end.line + 1, name, kind: label };
 }
 
-/* The multi-line symbols of a file as blocks, outermost first, in one-based lines. */
-export function blocksOf(result: DocumentSymbolResult): EditorBlock[] {
-    const blocks = symbolSpansOf(result).flatMap((span) => blockOf(span) ?? []);
+/*
+ * The multi-line symbols of a file as blocks, outermost first, in one-based lines. The text of the document
+ * lets a block start at its declaration rather than at the comment a server counts into the symbol.
+ */
+export function blocksOf(result: DocumentSymbolResult, text?: string): EditorBlock[] {
+    const lines = text?.split('\n');
+    const blocks = symbolSpansOf(result).flatMap((span) => blockOf(span, lines) ?? []);
     return blocks.sort((left, right) => left.startLine - right.startLine || right.endLine - left.endLine);
 }
 
@@ -80,7 +116,7 @@ export class SymbolsFeature {
                 }
                 const result = await project.service.documentSymbols(uri, { signal });
                 if (!signal.aborted) {
-                    editor.setBlocks(result === null ? null : blocksOf(result));
+                    editor.setBlocks(result === null ? null : blocksOf(result, editor.getText()));
                     for (const listener of [...this.listeners]) {
                         listener(result);
                     }

package/src/testing.ts

@@ -10,6 +10,9 @@ import {
     type ContentChange,
     type Disposable,
     type ProviderOptions,
+    type CallHierarchyIncomingCall,
+    type CallHierarchyItem,
+    type CallHierarchyOutgoingCall,
     type CodeAction,
     type CodeActionContext,
     type CodeLens,
@@ -200,6 +203,16 @@ export class FakeLanguageService implements LanguageService {
         return this.request<TextEdit[] | null>('textDocument/rangeFormatting', uri, { range, options: formatting }, options);
     }
 
+    onTypeFormatting(
+        uri: string,
+        position: Position,
+        ch: string,
+        formatting: FormattingOptions,
+        options: LanguageRequestOptions = {}
+    ): Promise<TextEdit[] | null> {
+        return this.request<TextEdit[] | null>('textDocument/onTypeFormatting', uri, { position, ch, options: formatting }, options);
+    }
+
     semanticTokens(uri: string, options: LanguageRequestOptions = {}): Promise<SemanticTokens | null> {
         return this.request<SemanticTokens | null>('textDocument/semanticTokens/full', uri, {}, options);
     }
@@ -232,6 +245,18 @@ export class FakeLanguageService implements LanguageService {
         return this.request<SelectionRange[] | null>('textDocument/selectionRange', uri, { positions }, options);
     }
 
+    prepareCallHierarchy(uri: string, position: Position, options: LanguageRequestOptions = {}): Promise<CallHierarchyItem[] | null> {
+        return this.request<CallHierarchyItem[] | null>('textDocument/prepareCallHierarchy', uri, { position }, options);
+    }
+
+    incomingCalls(uri: string, item: CallHierarchyItem, options: LanguageRequestOptions = {}): Promise<CallHierarchyIncomingCall[] | null> {
+        return this.request<CallHierarchyIncomingCall[] | null>('callHierarchy/incomingCalls', uri, { item }, options);
+    }
+
+    outgoingCalls(uri: string, item: CallHierarchyItem, options: LanguageRequestOptions = {}): Promise<CallHierarchyOutgoingCall[] | null> {
+        return this.request<CallHierarchyOutgoingCall[] | null>('callHierarchy/outgoingCalls', uri, { item }, options);
+    }
+
     codeLenses(uri: string, options: LanguageRequestOptions = {}): Promise<CodeLens[] | null> {
         return this.request<CodeLens[] | null>('textDocument/codeLens', uri, {}, options);
     }