@adecore/editor-react 0.39.0 → 0.40.1

package/src/symbol-picker-model.ts

@@ -62,6 +62,14 @@ export function letterOfKind(kind: number): string {
 
 export type SymbolTone = 'callable' | 'value' | 'type' | 'other';
 
+/* The badge colors of a tone, shared by the symbol picker and the suggestions list. */
+export const TONE_CLASSES: Record<SymbolTone, string> = {
+    callable: 'bg-accent-soft text-accent',
+    value: 'bg-status-running/15 text-status-running',
+    type: 'bg-status-idle/15 text-status-idle',
+    other: 'bg-surface-hover text-text-muted'
+};
+
 const TONES: Record<SymbolGroup, SymbolTone> = {
     namespaces: 'other',
     classes: 'type',
@@ -100,18 +108,22 @@ function isHierarchical(symbols: readonly (DocumentSymbol | SymbolInformation)[]
 /* The symbols of a file, parents before their children, in the order of the file. */
 export function entriesOf(result: DocumentSymbolResult): SymbolEntry[] {
     const entries: SymbolEntry[] = [];
+
     const add = (name: string, kind: number, container: string, detail: string, at: EditorRange['start']): void => {
         entries.push({ id: String(entries.length), name, kind, container, detail, line: at.line, character: at.character });
     };
+
     const walk = (symbols: readonly DocumentSymbol[], container: string): void => {
         for (const symbol of symbols) {
             add(symbol.name, symbol.kind, container, symbol.detail ?? '', symbol.selectionRange.start);
             walk(symbol.children ?? [], container === '' ? symbol.name : `${container}.${symbol.name}`);
         }
     };
+
     if (result === null || result.length === 0) {
         return entries;
     }
+
     if (isHierarchical(result)) {
         walk(result, '');
     } else {
@@ -119,6 +131,7 @@ export function entriesOf(result: DocumentSymbolResult): SymbolEntry[] {
             add(symbol.name, symbol.kind, symbol.containerName ?? '', '', symbol.location.range.start);
         }
     }
+
     return entries;
 }
 
@@ -126,22 +139,29 @@ export function entriesOf(result: DocumentSymbolResult): SymbolEntry[] {
 export function scoreOf(name: string, query: string): number {
     const haystack = name.toLowerCase();
     const needle = query.toLowerCase();
+
     if (needle === '') {
         return 1;
     }
+
     if (haystack.startsWith(needle)) {
         return 3;
     }
+
     if (haystack.includes(needle)) {
         return 2;
     }
+
     let from = 0;
+
     for (const character of needle) {
         from = haystack.indexOf(character, from) + 1;
+
         if (from === 0) {
             return 0;
         }
     }
+
     return 1;
 }
 
@@ -149,6 +169,7 @@ export function scoreOf(name: string, query: string): number {
 export function filterEntries(entries: readonly SymbolEntry[], query: string): SymbolEntry[] {
     const trimmed = query.trim();
     const scored = entries.map((entry, index) => ({ entry, index, score: scoreOf(entry.name, trimmed) })).filter((candidate) => candidate.score > 0);
+
     return scored
         .sort((left, right) => (trimmed === '' ? left.index - right.index : right.score - left.score || left.index - right.index))
         .map((candidate) => candidate.entry);
@@ -163,6 +184,7 @@ export interface EntryGroup {
 export function groupEntries(entries: readonly SymbolEntry[]): EntryGroup[] {
     return SYMBOL_GROUPS.flatMap((group) => {
         const own = entries.filter((entry) => groupOfKind(entry.kind) === group);
+
         return own.length === 0 ? [] : [{ group, entries: own }];
     });
 }
@@ -177,10 +199,13 @@ export function modeOf(input: string): PickerMode {
     if (input.startsWith('#')) {
         return { mode: 'workspace', text: input.slice(1).trim() };
     }
+
     if (input.startsWith(':')) {
         const line = Number.parseInt(input.slice(1), 10);
+
         return { mode: 'line', line: Number.isFinite(line) && line > 0 ? line : null };
     }
+
     return { mode: 'symbol', text: input };
 }
 

package/src/symbol-picker.ts

@@ -18,13 +18,17 @@ export class SymbolPickerFeature {
 
     constructor(language: EditorLanguage) {
         this.language = language;
+
         const off = language.onKey((event) => {
             if (!isShortcut(this.language.shortcuts.goToSymbol, event)) {
                 return false;
             }
+
             void this.open();
+
             return true;
         }, KEY_PRIORITY.symbolPicker);
+
         language.onDispose(() => {
             off();
             this.close();
@@ -33,10 +37,13 @@ export class SymbolPickerFeature {
 
     async open(): Promise<void> {
         const { project, uri, popups } = this.language;
+
         if (!project.service.supports('textDocument/documentSymbol', uri)) {
             this.language.project.host.notify?.({ id: TOAST_ID, kind: 'error', title: this.language.project.i18n.t('editor:language.symbols.unavailable') });
+
             return;
         }
+
         try {
             const entries = entriesOf(await project.service.documentSymbols(uri));
             popups.setState({ symbols: { file: basenameOf(this.language.uri), entries } });
@@ -73,9 +80,11 @@ export class SymbolPickerFeature {
     /* The symbols of the project that answer to a name, which is a request to the server and so waits for a pause in the typing. */
     async search(text: string, signal: AbortSignal): Promise<WorkspaceEntry[]> {
         const { project, uri } = this.language;
+
         if (text === '' || !project.service.supports('workspace/symbol', uri)) {
             return [];
         }
+
         return workspaceEntriesOf(await project.service.workspaceSymbols(uri, text, { signal }));
     }
 

package/src/symbols.ts

@@ -41,13 +41,17 @@ function walk(symbols: readonly DocumentSymbol[], spans: SymbolSpan[]): void {
 /* Every symbol of an answer, a parent before its children, whether the server sent a tree or a flat list. */
 export function symbolSpansOf(result: DocumentSymbolResult): SymbolSpan[] {
     const spans: SymbolSpan[] = [];
+
     if (result === null || result.length === 0) {
         return spans;
     }
+
     if ('range' in result[0]!) {
         walk(result as DocumentSymbol[], spans);
+
         return spans;
     }
+
     return (result as SymbolInformation[]).map((symbol) => ({ name: symbol.name, kind: symbol.kind, range: symbol.location.range }));
 }
 
@@ -60,29 +64,37 @@ const PRELUDE = /^\s*(?:$|\/\/|\/\*|\*|#\[)/;
  */
 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
@@ -96,6 +108,7 @@ function blockOf(span: SymbolSpan, lines: readonly string[] | undefined): Editor
 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);
 }
 
@@ -109,14 +122,18 @@ export class SymbolsFeature {
 
     constructor(language: EditorLanguage, timers: Timers = realTimers) {
         const { editor, project, uri } = language;
+
         this.refresher = new Refresher(
             async (signal) => {
                 if (!project.service.supports(METHOD, uri)) {
                     return;
                 }
+
                 const result = await project.service.documentSymbols(uri, { signal });
+
                 if (!signal.aborted) {
                     editor.setBlocks(result === null ? null : blocksOf(result, editor.getText()));
+
                     for (const listener of [...this.listeners]) {
                         listener(result);
                     }
@@ -125,10 +142,13 @@ export class SymbolsFeature {
             PAUSE_MS,
             timers
         );
+
         const edits = editor.onTextChange(() => this.refresher.later());
+
         const providers = language.onProvidersChanged(() => {
             this.refresher.now();
         });
+
         language.onDispose(() => {
             edits();
             providers();
@@ -140,6 +160,7 @@ export class SymbolsFeature {
     /* Called with every answer that was not replaced before it came. */
     onResult(listener: (result: DocumentSymbolResult) => void): () => void {
         this.listeners.add(listener);
+
         return () => {
             this.listeners.delete(listener);
         };

package/src/testing.ts

@@ -72,9 +72,11 @@ export class FakeLanguageService implements LanguageService {
 
     async changeDocument(uri: string, changes: readonly ContentChange[]): Promise<void> {
         const held = this.documents.get(uri);
+
         if (held === undefined) {
             throw new LspError('Document is not open', ErrorCodes.ServerNotInitialized);
         }
+
         held.text = applyContentChanges(held.text, changes);
         held.version++;
         this.calls.push({ method: 'change', uri, params: changes, options: {} });
@@ -95,11 +97,13 @@ export class FakeLanguageService implements LanguageService {
 
     onProvidersChanged(listener: (uri: string) => void): Disposable {
         this.changes.add(listener);
+
         return { dispose: () => this.changes.delete(listener) };
     }
 
     onDiagnostics(listener: (report: DiagnosticsReport) => void): Disposable {
         this.diagnostics.add(listener);
+
         return { dispose: () => this.diagnostics.delete(listener) };
     }
 
@@ -119,15 +123,18 @@ export class FakeLanguageService implements LanguageService {
         if (!this.supports(method, uri)) {
             throw new LspError(`${method} is unavailable`, ErrorCodes.MethodNotFound);
         }
+
         options.signal?.throwIfAborted();
         const version = this.documents.get(uri)?.version;
         const call = { method, uri, params, options };
         this.calls.push(call);
         const result = await this.answers.get(method)?.(call);
         options.signal?.throwIfAborted();
+
         if (this.documents.get(uri)?.version !== version) {
             throw new StaleResultError(uri);
         }
+
         return result as Result;
     }
 

package/src/timers.ts

@@ -18,6 +18,7 @@ export class ManualTimers implements Timers {
     set(callback: () => void, delay: number): unknown {
         const id = this.next++;
         this.pending.set(id, { at: this.now + delay, callback });
+
         return id;
     }
 
@@ -27,15 +28,19 @@ export class ManualTimers implements Timers {
 
     advance(milliseconds: number): void {
         const until = this.now + milliseconds;
+
         for (;;) {
             const due = [...this.pending].filter(([, entry]) => entry.at <= until).sort((left, right) => left[1].at - right[1].at)[0];
+
             if (due === undefined) {
                 break;
             }
+
             this.now = due[1].at;
             this.pending.delete(due[0]);
             due[1].callback();
         }
+
         this.now = until;
     }
 

package/src/unique.ts

@@ -0,0 +1,23 @@
+/* The items in order, without any whose key an earlier one had. */
+export function uniqueBy<T>(items: readonly T[], keyOf: (item: T) => string): T[] {
+    const seen = new Set<string>();
+
+    return items.filter((item) => {
+        const key = keyOf(item);
+
+        if (seen.has(key)) {
+            return false;
+        }
+
+        seen.add(key);
+
+        return true;
+    });
+}
+
+export function placeKey(location: {
+    readonly uri: string;
+    readonly range: { readonly start: { readonly line: number; readonly character: number } };
+}): string {
+    return `${location.uri}\0${location.range.start.line}\0${location.range.start.character}`;
+}

package/src/use-problem-counts.ts

@@ -6,12 +6,15 @@ const NONE: ProblemCounts = { error: 0, warning: 0, info: 0 };
 
 function countsStore(language: EditorLanguage | null): { get(): ProblemCounts; subscribe(listener: () => void): () => void } {
     let current = language?.diagnostics.counts() ?? NONE;
+
     return {
         get: () => {
             const next = language?.diagnostics.counts() ?? NONE;
+
             if (next.error !== current.error || next.warning !== current.warning || next.info !== current.info) {
                 current = next;
             }
+
             return current;
         },
         subscribe: (listener) => language?.diagnostics.onChange(listener) ?? (() => undefined)
@@ -21,5 +24,6 @@ function countsStore(language: EditorLanguage | null): { get(): ProblemCounts; s
 /* How many errors, warnings and infos the file has, said again when the servers report. */
 export function useProblemCounts(language: EditorLanguage | null): ProblemCounts {
     const store = useMemo(() => countsStore(language), [language]);
+
     return useSyncExternalStore(store.subscribe, store.get);
 }

package/src/view-state.ts

@@ -32,12 +32,15 @@ export function openingPlace(
     foldDefaults: readonly FoldRole[]
 ): { line?: number; column?: number; scrollTop?: number; folds?: EditorFolds; foldDefaults?: readonly FoldRole[] } {
     const folds = last === undefined ? { foldDefaults } : { folds: last.folds };
+
     if (reveal !== null) {
         return { line: reveal.line, ...folds };
     }
+
     if (last !== undefined) {
         return { line: last.line, column: last.column, scrollTop: last.scrollTop, ...folds };
     }
+
     return { scrollTop: placeholderScroll, ...folds };
 }
 
@@ -48,6 +51,7 @@ function movedKey(key: string, from: string, to: string): string | null {
     if (key === from) {
         return to;
     }
+
     return key.startsWith(`${from}/`) ? `${to}${key.slice(from.length)}` : null;
 }
 
@@ -59,13 +63,16 @@ function movedKey(key: string, from: string, to: string): string | null {
 export function followViewStates(endpointId: string, from: string, to: string): void {
     const oldKey = endpointKey(endpointId, from);
     const newKey = endpointKey(endpointId, to);
+
     for (const [key, state] of [...viewStates]) {
         const target = movedKey(key, oldKey, newKey);
+
         if (target !== null) {
             viewStates.delete(key);
             viewStates.set(target, state);
         }
     }
+
     moves.push({ from: oldKey, to: newKey });
 }
 
@@ -73,10 +80,12 @@ export function followViewStates(endpointId: string, from: string, to: string):
 export function viewStateKey(key: string): string {
     for (const { from, to } of moves) {
         const target = movedKey(key, from, to);
+
         if (target !== null) {
             return target;
         }
     }
+
     return key;
 }
 

package/src/word-diff.ts

@@ -16,18 +16,23 @@ function replacedRanges(removed: string, added: string): Array<[number, number]>
     const after = added.match(TOKEN) ?? [];
     const starts: number[] = [];
     let offset = 0;
+
     for (const token of before) {
         starts.push(offset);
         offset += token.length;
     }
+
     starts.push(offset);
     const ranges: Array<[number, number]> = [];
+
     for (const change of diffLines(before, after)) {
         const text = removed.slice(starts[change.baseStart]!, starts[change.baseEnd]!);
+
         if (text.trim() !== '') {
             const start = starts[change.baseStart]! + (text.length - text.trimStart().length);
             ranges.push([start, start + text.trim().length]);
         }
     }
+
     return ranges;
 }