@adecore/editor-react 0.22.1 → 0.23.1

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);
     }

package/src/timers.ts

@@ -43,3 +43,8 @@ export class ManualTimers implements Timers {
         return this.pending.size;
     }
 }
+
+/* Scrolls a row the editor opened under the caret line into view, which may sit at the bottom of the view with the row below the fold. The element is in the page a turn later. */
+export function revealRow(timers: Timers, container: HTMLElement): void {
+    timers.set(() => container.scrollIntoView?.({ block: 'nearest' }), 0);
+}

package/src/use-panel-body.ts

@@ -0,0 +1,17 @@
+import { useEffect, useState } from 'react';
+import type { EditorLanguage } from './editor-language.ts';
+import { clampPanelBody } from './panel-size.ts';
+
+/* The body height of a panel, from the project that remembers it for the next one; `commit` hands it to the host. */
+export function usePanelBody(language: EditorLanguage): { height: number; set(height: number): void; commit(height: number): void } {
+    const { project } = language;
+    const [height, set] = useState(() => clampPanelBody(project.panelBodyHeight));
+
+    useEffect(() => project.onPanelBodyChange((value) => set(clampPanelBody(value))), [project]);
+
+    return {
+        height,
+        set,
+        commit: (value) => project.resizePanelBody(value)
+    };
+}