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

package/dist/proposal-model.js

@@ -0,0 +1,197 @@
+import { diffLines } from '@adecore/merge';
+import { replacedWords } from './word-diff.js';
+export function lineSpanOf(range) {
+    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) {
+    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, lineLength) {
+    if (!isEmptyRange(selection)) {
+        return selection;
+    }
+    const { line } = selection.start;
+    return { start: { line, character: 0 }, end: { line, character: lineLength(line) } };
+}
+export function problemsOnLines(diagnostics, span, describe) {
+    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);
+}
+const OPENING = /^( {0,3})(`{3,}|~{3,})(.*)$/;
+function openingOf(line) {
+    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, start) {
+    const match = /^ {0,3}(`+|~+)\s*$/.exec(line);
+    return match !== null && match[1][0] === start.char && match[1].length >= start.length;
+}
+function isReplacement(info) {
+    return info
+        .toLowerCase()
+        .split(/[\s,:=]+/)
+        .includes('replacement');
+}
+/*
+ * 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) {
+    const lines = text.replace(/\r\n/g, '\n').split('\n');
+    let open = null;
+    let found = 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, replacement) {
+    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, text) {
+    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 };
+}
+function linesOf(text) {
+    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, proposal, startLine) {
+    const base = linesOf(selected);
+    const other = linesOf(proposal);
+    const segments = [];
+    let cursor = 0;
+    const same = (until) => {
+        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) {
+    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, position) {
+    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, range) {
+    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, range, replacement) {
+    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, range, selected) {
+    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, offset) {
+    const before = text.slice(0, offset);
+    const line = before.split('\n').length - 1;
+    return { line, character: offset - (before.lastIndexOf('\n') + 1) };
+}

package/dist/recent-choices.d.ts

@@ -0,0 +1,10 @@
+import type { CompletionItem } from '@adecore/lsp';
+export declare class RecentChoices {
+    private readonly order;
+    private tick;
+    static keyOf(item: CompletionItem): string;
+    record(item: CompletionItem): void;
+    recency(item: CompletionItem): number;
+}
+export declare function recentChoicesOf(languageId: string): RecentChoices;
+export declare function forgetRecentChoices(): void;

package/dist/recent-choices.js

@@ -0,0 +1,39 @@
+import { qualifierOf } from './completion-model.js';
+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 {
+    order = new Map();
+    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) {
+        return `${item.label}\0${item.kind ?? ''}\0${qualifierOf(item)}`;
+    }
+    record(item) {
+        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) {
+        return this.order.get(RecentChoices.keyOf(item)) ?? 0;
+    }
+}
+const stores = new Map();
+export function recentChoicesOf(languageId) {
+    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() {
+    stores.clear();
+}

package/dist/refresher.d.ts

@@ -0,0 +1,13 @@
+import { type Timers } from './timers.ts';
+export declare class Refresher {
+    private timer;
+    private controller;
+    private disposed;
+    private readonly timers;
+    private readonly delay;
+    private readonly run;
+    constructor(run: (signal: AbortSignal) => Promise<void>, delay: number, timers?: Timers);
+    later(): void;
+    now(): void;
+    dispose(): void;
+}

package/dist/refresher.js

@@ -0,0 +1,50 @@
+import { StaleResultError } from '@adecore/lsp';
+import { realTimers } from './timers.js';
+/*
+ * 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 {
+    timer;
+    controller = null;
+    disposed = false;
+    timers;
+    delay;
+    run;
+    constructor(run, delay, timers = realTimers) {
+        this.run = run;
+        this.delay = delay;
+        this.timers = timers;
+    }
+    /* After a pause: every call starts the wait again. */
+    later() {
+        this.timers.clear(this.timer);
+        this.timer = this.timers.set(() => this.now(), this.delay);
+    }
+    now() {
+        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) => {
+            // 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() {
+        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) {
+    const code = error?.code;
+    return code === -32002 || code === -32601 || code === -32800 || code === -32801;
+}

package/dist/relative-time.d.ts

@@ -0,0 +1 @@
+export declare function relativeTime(at: number, now: number): string;

package/dist/relative-time.js

@@ -0,0 +1,9 @@
+import { formatAgo, formatDay, formatDayWithYear } from '@adecore/ui/format';
+export function relativeTime(at, now) {
+    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/dist/rename-model.d.ts

@@ -0,0 +1,25 @@
+import type { EditorPosition, EditorRange } from '@adecore/editor';
+import type { Location, PrepareRenameResult, TextEdit, WorkspaceEdit } from '@adecore/lsp';
+export declare function wordRangeAt(lineText: string, position: EditorPosition): EditorRange | null;
+export interface RenameTarget {
+    readonly range: EditorRange;
+    readonly placeholder: string;
+}
+export declare function renameTargetOf(result: PrepareRenameResult, textOf: (range: EditorRange) => string, wordAtCaret: () => EditorRange | null): RenameTarget | null;
+export interface Occurrences {
+    readonly inFile: readonly EditorRange[];
+    readonly count: number;
+    readonly files: number;
+}
+export declare function occurrencesOf(locations: readonly Location[], uri: string): Occurrences;
+export interface RenameRow {
+    readonly line: number;
+    readonly before: string;
+    readonly after: string;
+}
+export interface RenameFile {
+    readonly uri: string;
+    readonly rows: readonly RenameRow[];
+}
+export declare function renameRowsOf(text: string, edits: readonly TextEdit[]): RenameRow[];
+export declare function renamePreviewOf(edit: WorkspaceEdit, textOf: (uri: string) => Promise<string | null>): Promise<RenameFile[] | null>;

package/dist/rename-model.js

@@ -0,0 +1,93 @@
+import { isIdentifierCharacter } from './completion-model.js';
+import { entriesOf } from './workspace-edit.js';
+/* The identifier the caret is in or touches; null where there is none. */
+export function wordRangeAt(lineText, position) {
+    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 } };
+}
+/*
+ * 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, textOf, wordAtCaret) {
+    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) };
+}
+export function occurrencesOf(locations, uri) {
+    return {
+        inFile: locations.filter((location) => location.uri === uri).map((location) => location.range),
+        count: locations.length,
+        files: new Set(locations.map((location) => location.uri)).size
+    };
+}
+function lineStarts(text) {
+    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, edits) {
+    const starts = lineStarts(text);
+    const lineAt = (line) => {
+        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();
+    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, textOf) {
+    const entries = entriesOf(edit);
+    if (entries === null) {
+        return null;
+    }
+    const files = [];
+    for (const [uri, list] of entries) {
+        const text = await textOf(uri);
+        files.push({ uri, rows: text === null ? [] : renameRowsOf(text, list.flat()) });
+    }
+    return files;
+}

package/dist/rename.d.ts

@@ -0,0 +1,21 @@
+import type { EditorLanguage } from './editor-language.ts';
+export declare class RenameFeature {
+    private tell;
+    private readonly language;
+    private session;
+    constructor(language: EditorLanguage);
+    get isOpen(): boolean;
+    start(): Promise<void>;
+    submit(name: string, preview: boolean): Promise<void>;
+    confirm(): Promise<void>;
+    cancel(): void;
+    private apply;
+    private fail;
+    edited(): void;
+    private finish;
+    private light;
+    private suggest;
+    private linesOf;
+    private publish;
+    private say;
+}