@adecore/editor-react 0.0.1 → 0.17.0-beta.2

package/src/project-problems.ts

@@ -0,0 +1,87 @@
+import type { Diagnostic } from '@adecore/lsp';
+import type { LanguageService } from '@adecore/lsp';
+import { comparePositions, severityOf } from './diagnostics-model.ts';
+import type { ProblemCounts } from './diagnostics.ts';
+
+/* One problem of a file and the server that reported it. */
+export interface ProblemRow {
+    readonly diagnostic: Diagnostic;
+    readonly server: string;
+}
+
+/* A file with problems; its path is a stored path (relative to the project folder, absolute outside it). */
+export interface ProblemFile {
+    readonly path: string;
+    readonly rows: readonly ProblemRow[];
+}
+
+const SEVERITY_ORDER = { error: 0, warning: 1, info: 2, hint: 3 } as const;
+
+/* Worst first, then in the order of the file. */
+export function compareRows(left: ProblemRow, right: ProblemRow): number {
+    return (
+        SEVERITY_ORDER[severityOf(left.diagnostic)] - SEVERITY_ORDER[severityOf(right.diagnostic)] ||
+        comparePositions(left.diagnostic.range.start, right.diagnostic.range.start)
+    );
+}
+
+/*
+ * Each report replaces the previous diagnostics from that source for the file. Files with no
+ * remaining problems drop out. Hints remain editor annotations rather than listed problems.
+ */
+export class ProjectProblems {
+    private readonly reports = new Map<string, Map<string, readonly Diagnostic[]>>();
+    private readonly listeners = new Set<() => void>();
+    private readonly stop: () => void;
+    private snapshot: readonly ProblemFile[] = [];
+
+    constructor(service: LanguageService, pathOf: (uri: string) => string = (uri) => uri) {
+        const subscription = service.onDiagnostics((report) => this.report(pathOf(report.uri), report.source, report.diagnostics));
+        this.stop = () => subscription.dispose();
+    }
+
+    report(path: string, server: string, diagnostics: readonly Diagnostic[]): void {
+        const kept = diagnostics.filter((diagnostic) => severityOf(diagnostic) !== 'hint');
+        const servers = this.reports.get(path) ?? new Map<string, readonly Diagnostic[]>();
+        if (kept.length === 0) {
+            servers.delete(server);
+        } else {
+            servers.set(server, kept);
+        }
+        if (servers.size === 0) {
+            this.reports.delete(path);
+        } else {
+            this.reports.set(path, servers);
+        }
+        this.snapshot = [...this.reports]
+            .map(([file, byServer]): ProblemFile => ({
+                path: file,
+                rows: [...byServer].flatMap(([name, list]) => list.map((diagnostic): ProblemRow => ({ diagnostic, server: name }))).sort(compareRows)
+            }))
+            .sort((left, right) => left.path.localeCompare(right.path));
+        for (const listener of [...this.listeners]) {
+            listener();
+        }
+    }
+
+    /* The same array until the next report, which is what a store a component reads must hand out. */
+    getSnapshot = (): readonly ProblemFile[] => this.snapshot;
+
+    subscribe = (listener: () => void): (() => void) => {
+        this.listeners.add(listener);
+        return () => {
+            this.listeners.delete(listener);
+        };
+    };
+
+    dispose(): void {
+        this.stop();
+        this.listeners.clear();
+    }
+}
+
+export function countsOf(files: readonly ProblemFile[]): ProblemCounts {
+    const rows = files.flatMap((file) => file.rows);
+    const count = (severity: number): number => rows.filter((row) => (row.diagnostic.severity ?? 1) === severity).length;
+    return { error: count(1), warning: count(2), info: count(3) };
+}

package/src/proposal-model.ts

@@ -0,0 +1,259 @@
+import { diffLines } from '@adecore/merge';
+import type { EditorPosition, EditorRange } from '@adecore/editor';
+import { replacedWords } from './word-diff.ts';
+
+/* The one-based lines a range covers; a selection that ends at the start of a line did not take that line. */
+export interface LineSpan {
+    readonly startLine: number;
+    readonly endLine: number;
+}
+
+export function lineSpanOf(range: EditorRange): LineSpan {
+    const endsOnBreak = range.end.character === 0 && range.end.line > range.start.line;
+    return { startLine: range.start.line + 1, endLine: endsOnBreak ? range.end.line : range.end.line + 1 };
+}
+
+export function isEmptyRange(range: EditorRange): boolean {
+    return range.start.line === range.end.line && range.start.character === range.end.character;
+}
+
+/* The selection, or the whole line under the caret while nothing is selected. */
+export function inlineRangeOf(selection: EditorRange, lineLength: (line: number) => number): EditorRange {
+    if (!isEmptyRange(selection)) {
+        return selection;
+    }
+    const { line } = selection.start;
+    return { start: { line, character: 0 }, end: { line, character: lineLength(line) } };
+}
+
+/* A problem the card lists for the lines, as the language servers reported it. */
+export interface InlineProblem {
+    /* One-based. */
+    readonly line: number;
+    readonly severity: 'error' | 'warning' | 'info' | 'hint';
+    readonly message: string;
+    /* The server's code, with its source in front when it names one: `ts 2345`. */
+    readonly code: string;
+}
+
+export function problemsOnLines<T extends { range: EditorRange }>(
+    diagnostics: readonly T[],
+    span: LineSpan,
+    describe: (diagnostic: T) => Omit<InlineProblem, 'line'>
+): InlineProblem[] {
+    return diagnostics
+        .filter((diagnostic) => diagnostic.range.start.line + 1 <= span.endLine && diagnostic.range.end.line + 1 >= span.startLine)
+        .map((diagnostic) => ({ line: Math.max(diagnostic.range.start.line + 1, span.startLine), ...describe(diagnostic) }))
+        .sort((left, right) => left.line - right.line);
+}
+
+interface FenceStart {
+    char: string;
+    length: number;
+    indent: number;
+    info: string;
+}
+
+const OPENING = /^( {0,3})(`{3,}|~{3,})(.*)$/;
+
+function openingOf(line: string): FenceStart | null {
+    const match = OPENING.exec(line);
+    if (match === null) {
+        return null;
+    }
+    const [, indent = '', marks = '', info = ''] = match;
+    // The info string of a backtick fence holds no backtick, which is what keeps a line of inline code from opening one.
+    if (marks.startsWith('`') && info.includes('`')) {
+        return null;
+    }
+    return { char: marks[0]!, length: marks.length, indent: indent.length, info: info.trim() };
+}
+
+function closes(line: string, start: FenceStart): boolean {
+    const match = /^ {0,3}(`+|~+)\s*$/.exec(line);
+    return match !== null && match[1]![0] === start.char && match[1]!.length >= start.length;
+}
+
+function isReplacement(info: string): boolean {
+    return info
+        .toLowerCase()
+        .split(/[\s,:=]+/)
+        .includes('replacement');
+}
+
+export interface InlineAnswer {
+    /* The text of the last closed block labeled `replacement`; null when the answer has none. */
+    readonly replacement: string | null;
+    /* The answer without that block: what the agent said about it, or all of it. */
+    readonly rest: string;
+}
+
+/*
+ * Reads the answer the way a markdown reader does: a fence closes at a line of at least as many marks,
+ * so a fence inside the code stays code. A block that never closes is a turn that was cut off, and
+ * applying half of it would be worse than showing the answer as text, so it counts as no block.
+ */
+export function parseAnswer(text: string): InlineAnswer {
+    const lines = text.replace(/\r\n/g, '\n').split('\n');
+    let open: { start: FenceStart; from: number; body: string[] } | null = null;
+    let found: { from: number; to: number; body: string[] } | null = null;
+    for (const [index, line] of lines.entries()) {
+        if (open === null) {
+            const start = openingOf(line);
+            if (start !== null) {
+                open = { start, from: index, body: [] };
+            }
+            continue;
+        }
+        if (closes(line, open.start)) {
+            if (isReplacement(open.start.info)) {
+                found = { from: open.from, to: index, body: open.body };
+            }
+            open = null;
+            continue;
+        }
+        open.body.push(line.replace(new RegExp(`^ {0,${open.start.indent}}`), ''));
+    }
+    if (found === null) {
+        return { replacement: null, rest: text.trim() };
+    }
+    return {
+        replacement: found.body.join('\n'),
+        rest: [...lines.slice(0, found.from), ...lines.slice(found.to + 1)]
+            .join('\n')
+            .replace(/\n{3,}/g, '\n\n')
+            .trim()
+    };
+}
+
+/* The proposal in the shape of the text it replaces: its line breaks and whether it ends on one. */
+export function fitReplacement(selected: string, replacement: string): string {
+    const breaks = selected.includes('\r\n') ? '\r\n' : '\n';
+    let fitted = replacement.replace(/\r\n/g, '\n');
+    const endsOnBreak = selected.endsWith('\n');
+    if (fitted !== '' && endsOnBreak && !fitted.endsWith('\n')) {
+        fitted += '\n';
+    } else if (!endsOnBreak && fitted.endsWith('\n')) {
+        fitted = fitted.slice(0, -1);
+    }
+    return breaks === '\n' ? fitted : fitted.replace(/\n/g, breaks);
+}
+
+/* Where the caret stands after `text` was typed at `start`. */
+export function endOfInsertion(start: EditorPosition, text: string): EditorPosition {
+    const lines = text.split('\n');
+    if (lines.length === 1) {
+        return { line: start.line, character: start.character + text.length };
+    }
+    return { line: start.line + lines.length - 1, character: lines.at(-1)!.length };
+}
+
+/* One stretch of the proposal as the card draws it. */
+export interface DiffSegment {
+    readonly kind: 'same' | 'added' | 'removed';
+    readonly text: string;
+    /* One-based number of its first line in the proposal; absent for lines the proposal drops. */
+    readonly firstLine?: number;
+    /* For added lines, the selected lines they take the place of; absent for lines that stand where nothing stood. */
+    readonly replaces?: string;
+}
+
+function linesOf(text: string): string[] {
+    const lines = text.replace(/\r\n/g, '\n').split('\n');
+    return lines.length > 1 && lines.at(-1) === '' ? lines.slice(0, -1) : lines;
+}
+
+/*
+ * The proposal against the selection, line by line. Lines the proposal changes show as added, since
+ * the old ones are the selected text above the card; lines it drops without a replacement are the
+ * only removed ones, because nothing in the proposal would show them gone.
+ */
+export function diffSegments(selected: string, proposal: string, startLine: number): DiffSegment[] {
+    const base = linesOf(selected);
+    const other = linesOf(proposal);
+    const segments: DiffSegment[] = [];
+    let cursor = 0;
+    const same = (until: number): void => {
+        if (until > cursor) {
+            segments.push({ kind: 'same', text: other.slice(cursor, until).join('\n'), firstLine: startLine + cursor });
+        }
+    };
+    for (const change of diffLines(base, other)) {
+        same(change.otherStart);
+        if (change.otherEnd > change.otherStart) {
+            segments.push({
+                kind: 'added',
+                text: other.slice(change.otherStart, change.otherEnd).join('\n'),
+                firstLine: startLine + change.otherStart,
+                ...(change.baseEnd > change.baseStart ? { replaces: base.slice(change.baseStart, change.baseEnd).join('\n') } : {})
+            });
+        } else {
+            segments.push({ kind: 'removed', text: base.slice(change.baseStart, change.baseEnd).join('\n') });
+        }
+        cursor = change.otherEnd;
+    }
+    same(other.length);
+    return segments;
+}
+
+/* Per line of an added stretch, the character ranges of the words that differ from the line it replaces, for the stronger tint; undefined when none do. */
+export function emphasisOf(segment: DiffSegment): Array<Array<[number, number]>> | undefined {
+    if (segment.kind !== 'added' || segment.replaces === undefined) {
+        return undefined;
+    }
+    const ranges = replacedWords(linesOf(segment.text), linesOf(segment.replaces));
+    return ranges.some((line) => line.length > 0) ? ranges : undefined;
+}
+
+/* The offset of a position in a text whose lines end in `\n` or `\r\n`; null when the text is not that long. */
+export function offsetOf(text: string, position: EditorPosition): number | null {
+    let offset = 0;
+    for (let line = 0; line < position.line; line++) {
+        const end = text.indexOf('\n', offset);
+        if (end === -1) {
+            return null;
+        }
+        offset = end + 1;
+    }
+    const lineEnd = text.indexOf('\n', offset);
+    const length = (lineEnd === -1 ? text.length : lineEnd) - offset;
+    return position.character > length ? null : offset + position.character;
+}
+
+/* The text in a range of `text`, or null when the range is not in it. */
+export function textInRange(text: string, range: EditorRange): string | null {
+    const from = offsetOf(text, range.start);
+    const to = offsetOf(text, range.end);
+    return from === null || to === null || to < from ? null : text.slice(from, to);
+}
+
+/* `text` with the range replaced; null when the range is not in it. */
+export function replaceRange(text: string, range: EditorRange, replacement: string): string | null {
+    const from = offsetOf(text, range.start);
+    const to = offsetOf(text, range.end);
+    return from === null || to === null || to < from ? null : `${text.slice(0, from)}${replacement}${text.slice(to)}`;
+}
+
+/*
+ * Where `selected` stands in `text` now: its own range while it still holds, and otherwise the one
+ * place it occurs when lines moved. Null when it is gone or ambiguous, which is a selection that changed.
+ */
+export function locateSelection(text: string, range: EditorRange, selected: string): EditorRange | null {
+    if (textInRange(text, range) === selected) {
+        return range;
+    }
+    if (selected === '') {
+        return null;
+    }
+    const first = text.indexOf(selected);
+    if (first === -1 || text.indexOf(selected, first + 1) !== -1) {
+        return null;
+    }
+    return { start: positionAt(text, first), end: positionAt(text, first + selected.length) };
+}
+
+function positionAt(text: string, offset: number): EditorPosition {
+    const before = text.slice(0, offset);
+    const line = before.split('\n').length - 1;
+    return { line, character: offset - (before.lastIndexOf('\n') + 1) };
+}

package/src/recent-choices.ts

@@ -0,0 +1,48 @@
+import type { CompletionItem } from '@adecore/lsp';
+import { qualifierOf } from './completion-model.ts';
+
+const LIMIT = 200;
+
+/*
+ * The suggestions a person took lately, so one they use again comes first among equal matches. It lives in
+ * memory only, one per language, and forgets the oldest choice past a few hundred.
+ */
+export class RecentChoices {
+    private readonly order = new Map<string, number>();
+    private tick = 0;
+
+    /* An item is told by its label, its kind and where it comes from, so two `Property` of two namespaces are two choices. */
+    static keyOf(item: CompletionItem): string {
+        return `${item.label}\0${item.kind ?? ''}\0${qualifierOf(item)}`;
+    }
+
+    record(item: CompletionItem): void {
+        const key = RecentChoices.keyOf(item);
+        this.order.delete(key);
+        this.order.set(key, ++this.tick);
+        if (this.order.size > LIMIT) {
+            this.order.delete(this.order.keys().next().value!);
+        }
+    }
+
+    /* Higher for a later choice, 0 for an item never chosen. */
+    recency(item: CompletionItem): number {
+        return this.order.get(RecentChoices.keyOf(item)) ?? 0;
+    }
+}
+
+const stores = new Map<string, RecentChoices>();
+
+export function recentChoicesOf(languageId: string): RecentChoices {
+    let store = stores.get(languageId);
+    if (store === undefined) {
+        store = new RecentChoices();
+        stores.set(languageId, store);
+    }
+    return store;
+}
+
+/* For a test that must not hear the choices an earlier one made. */
+export function forgetRecentChoices(): void {
+    stores.clear();
+}

package/src/refresher.ts

@@ -0,0 +1,56 @@
+import { StaleResultError } from '@adecore/lsp';
+import { realTimers, type Timers } from './timers.ts';
+
+/*
+ * Asks again for something a document's text decides, such as its colors or its hints: after a pause
+ * in typing, when a server says what it offers changed, and never twice at once. A newer ask aborts the
+ * one before it, and an answer for a text that has moved on is dropped, since another ask is on its way.
+ */
+export class Refresher {
+    private timer: unknown;
+    private controller: AbortController | null = null;
+    private disposed = false;
+    private readonly timers: Timers;
+    private readonly delay: number;
+    private readonly run: (signal: AbortSignal) => Promise<void>;
+
+    constructor(run: (signal: AbortSignal) => Promise<void>, delay: number, timers: Timers = realTimers) {
+        this.run = run;
+        this.delay = delay;
+        this.timers = timers;
+    }
+
+    /* After a pause: every call starts the wait again. */
+    later(): void {
+        this.timers.clear(this.timer);
+        this.timer = this.timers.set(() => this.now(), this.delay);
+    }
+
+    now(): void {
+        if (this.disposed) {
+            return;
+        }
+        this.timers.clear(this.timer);
+        this.controller?.abort();
+        const controller = new AbortController();
+        this.controller = controller;
+        this.run(controller.signal).catch((error: unknown) => {
+            // A server that cannot answer yet is asked again when it says it can; a stale text is asked again by its own change.
+            if (!(error instanceof StaleResultError) && !controller.signal.aborted && !isQuiet(error)) {
+                console.warn('Language request failed', error);
+            }
+        });
+    }
+
+    dispose(): void {
+        this.disposed = true;
+        this.timers.clear(this.timer);
+        this.controller?.abort();
+    }
+}
+
+/* The failures of a server that is not up, does not offer the feature or was asked to stop, which are not worth a line in the console. */
+function isQuiet(error: unknown): boolean {
+    const code = (error as { code?: number } | null)?.code;
+    return code === -32002 || code === -32601 || code === -32800 || code === -32801;
+}

package/src/relative-time.ts

@@ -0,0 +1,10 @@
+import { formatAgo, formatDay, formatDayWithYear } from '@adecore/ui/format';
+
+export function relativeTime(at: number, now: number): string {
+    const seconds = Math.max(0, now - at);
+    if (seconds < 7 * 24 * 60 * 60) {
+        return formatAgo(seconds * 1000);
+    }
+    const date = new Date(at * 1000);
+    return date.getFullYear() === new Date(now * 1000).getFullYear() ? formatDay(date) : formatDayWithYear(date);
+}

package/src/rename-model.ts

@@ -0,0 +1,130 @@
+import type { EditorPosition, EditorRange } from '@adecore/editor';
+import type { Location, PrepareRenameResult, TextEdit, WorkspaceEdit } from '@adecore/lsp';
+import { isIdentifierCharacter } from './completion-model.ts';
+import { entriesOf } from './workspace-edit.ts';
+
+/* The identifier the caret is in or touches; null where there is none. */
+export function wordRangeAt(lineText: string, position: EditorPosition): EditorRange | null {
+    let start = Math.min(position.character, lineText.length);
+    let end = start;
+    while (start > 0 && isIdentifierCharacter(lineText[start - 1]!)) {
+        start--;
+    }
+    while (end < lineText.length && isIdentifierCharacter(lineText[end]!)) {
+        end++;
+    }
+    return start === end ? null : { start: { line: position.line, character: start }, end: { line: position.line, character: end } };
+}
+
+/* What a server said about renaming at a position: the range to put the input over, and the name it starts with. */
+export interface RenameTarget {
+    readonly range: EditorRange;
+    readonly placeholder: string;
+}
+
+/*
+ * The target of a prepare answer. A server that answers with a bare range or the default behavior leaves
+ * the name to the text, and one that answers null says nothing here can be renamed.
+ */
+export function renameTargetOf(
+    result: PrepareRenameResult,
+    textOf: (range: EditorRange) => string,
+    wordAtCaret: () => EditorRange | null
+): RenameTarget | null {
+    if (result === null) {
+        return null;
+    }
+    if ('placeholder' in result) {
+        return { range: result.range, placeholder: result.placeholder };
+    }
+    if ('start' in result) {
+        return { range: result, placeholder: textOf(result) };
+    }
+    const word = wordAtCaret();
+    return word === null ? null : { range: word, placeholder: textOf(word) };
+}
+
+/* Where the places of one name are, in the open file and in how many files all together. */
+export interface Occurrences {
+    readonly inFile: readonly EditorRange[];
+    readonly count: number;
+    readonly files: number;
+}
+
+export function occurrencesOf(locations: readonly Location[], uri: string): Occurrences {
+    return {
+        inFile: locations.filter((location) => location.uri === uri).map((location) => location.range),
+        count: locations.length,
+        files: new Set(locations.map((location) => location.uri)).size
+    };
+}
+
+/* One line a rename changes: the line as it is and as it will be. */
+export interface RenameRow {
+    /* One-based. */
+    readonly line: number;
+    readonly before: string;
+    readonly after: string;
+}
+
+export interface RenameFile {
+    readonly uri: string;
+    readonly rows: readonly RenameRow[];
+}
+
+function lineStarts(text: string): number[] {
+    const starts = [0];
+    for (let index = 0; index < text.length; index++) {
+        const code = text.charCodeAt(index);
+        if (code === 13 && text.charCodeAt(index + 1) === 10) {
+            index++;
+            starts.push(index + 1);
+        } else if (code === 10 || code === 13) {
+            starts.push(index + 1);
+        }
+    }
+    return starts;
+}
+
+/* The lines of a file an edit touches, each once, as they read before and after. An edit across lines is shown from its first line. */
+export function renameRowsOf(text: string, edits: readonly TextEdit[]): RenameRow[] {
+    const starts = lineStarts(text);
+    const lineAt = (line: number): { from: number; to: number } => {
+        const from = starts[line] ?? text.length;
+        let to = (starts[line + 1] ?? text.length + 1) - 1;
+        while (to > from && (text[to - 1] === '\n' || text[to - 1] === '\r')) {
+            to--;
+        }
+        return { from, to: Math.min(to, text.length) };
+    };
+    const byLine = new Map<number, TextEdit[]>();
+    for (const edit of edits) {
+        byLine.set(edit.range.start.line, [...(byLine.get(edit.range.start.line) ?? []), edit]);
+    }
+    return [...byLine]
+        .sort((left, right) => left[0] - right[0])
+        .map(([line, own]) => {
+            const { from, to } = lineAt(line);
+            const before = text.slice(from, to);
+            let after = before;
+            for (const edit of [...own].sort((left, right) => right.range.start.character - left.range.start.character)) {
+                const end = edit.range.end.line === line ? edit.range.end.character : before.length;
+                after = after.slice(0, edit.range.start.character) + edit.newText + after.slice(end);
+            }
+            return { line: line + 1, before, after };
+        });
+}
+
+/* Resource renames are omitted; create/delete operations refuse the text-only preview with null. */
+export async function renamePreviewOf(edit: WorkspaceEdit, textOf: (uri: string) => Promise<string | null>): Promise<RenameFile[] | null> {
+    const entries = entriesOf(edit);
+    if (entries === null) {
+        return null;
+    }
+    const files: RenameFile[] = [];
+    for (const [uri, list] of entries) {
+        const text = await textOf(uri);
+        files.push({ uri, rows: text === null ? [] : renameRowsOf(text, list.flat()) });
+    }
+    return files;
+}