@adecore/editor-react 0.0.1 → 0.17.0-beta.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,20 @@
+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;
+}

package/dist/rename.js

@@ -0,0 +1,258 @@
+import i18next from 'i18next';
+import { StaleResultError } from '@adecore/lsp';
+import { occurrencesOf, renamePreviewOf, renameTargetOf, wordRangeAt } from './rename-model.js';
+import { isShortcut } from './shortcut-keys.js';
+const METHOD = 'textDocument/rename';
+const TOAST_ID = 'language-rename';
+/* How many names are offered, and how many other lines and files are read to say how the symbol is used. */
+const SAMPLE_LOCATIONS = 8;
+const SAMPLE_OTHER_FILES = 3;
+const CONTEXT_LINES = 3;
+function say(key, options) {
+    return i18next.t(`editor:language.rename.${key}`, options);
+}
+/*
+ * Renaming a symbol. The input sits on the symbol itself, every place the name has lights up while the
+ * new one is typed, Enter applies the server's edit at once and Shift+Enter lists what it would change first.
+ * Edits to other files land as unsaved drafts (`applyWorkspaceEdit`), so nothing is written to disk here.
+ */
+export class RenameFeature {
+    tell(kind, title) {
+        this.language.project.host.notify?.({ id: TOAST_ID, kind, title });
+    }
+    language;
+    session = null;
+    constructor(language) {
+        this.language = language;
+        const { editor } = language;
+        const offs = [
+            editor.onKeyDown((event) => {
+                if (!isShortcut(this.language.shortcuts.rename, event)) {
+                    return false;
+                }
+                void this.start();
+                return true;
+            }),
+            editor.onTextChange(() => this.cancel())
+        ];
+        language.onDispose(() => {
+            for (const off of offs) {
+                off();
+            }
+            this.cancel();
+        });
+    }
+    get isOpen() {
+        return this.session !== null;
+    }
+    async start() {
+        const { editor, project, uri } = this.language;
+        if (!project.service.supports(METHOD, uri)) {
+            this.tell('error', say('unavailable'));
+            return;
+        }
+        this.cancel();
+        const caret = editor.getCaret();
+        const prepare = project.service.providerOptions(METHOD, uri)?.prepareProvider === true;
+        let answer;
+        try {
+            answer = prepare ? await project.service.prepareRename(uri, caret) : { defaultBehavior: true };
+        }
+        catch (error) {
+            if (!(error instanceof StaleResultError)) {
+                this.tell('error', say('nothing'));
+            }
+            return;
+        }
+        const target = renameTargetOf(answer, (range) => editor.textInRange(range), () => wordRangeAt(editor.textInRange({ start: { line: caret.line, character: 0 }, end: { line: caret.line, character: Number.MAX_SAFE_INTEGER } }), caret));
+        if (target === null) {
+            this.tell('error', say('nothing'));
+            return;
+        }
+        const session = { target, original: editor.textInRange(target.range), edit: null, names: new AbortController() };
+        this.session = session;
+        this.publish({ phase: 'input', busy: false, name: target.placeholder, files: [], occurrences: null, suggestions: [] });
+        void this.light(session).then((locations) => this.suggest(session, locations));
+    }
+    /* The name was typed: Enter applies it, Shift+Enter lists what it would change first. */
+    async submit(name, preview) {
+        const session = this.session;
+        const next = name.trim();
+        if (session === null) {
+            return;
+        }
+        if (next === '' || next === session.original) {
+            this.finish();
+            return;
+        }
+        this.publish({ phase: 'input', busy: true, name: next, error: null });
+        const { project, uri } = this.language;
+        try {
+            const edit = await project.service.rename(uri, session.target.range.start, next);
+            if (this.session !== session) {
+                return;
+            }
+            if (edit === null) {
+                this.fail(say('refused'));
+                return;
+            }
+            session.edit = edit;
+            if (!preview) {
+                await this.apply(session);
+                return;
+            }
+            const files = await renamePreviewOf(edit, (target) => project.readText(target));
+            if (this.session !== session) {
+                return;
+            }
+            if (files === null) {
+                // An edit that renames files too has no list of lines to show, so it is applied or refused as a whole.
+                await this.apply(session);
+                return;
+            }
+            this.publish({ phase: 'preview', busy: false, name: next, files });
+        }
+        catch (error) {
+            if (this.session === session) {
+                this.fail(error instanceof StaleResultError ? say('stale') : error instanceof Error ? error.message : String(error));
+            }
+        }
+    }
+    /* Applies the edit the preview showed. */
+    async confirm() {
+        const session = this.session;
+        if (session?.edit) {
+            await this.apply(session);
+        }
+    }
+    cancel() {
+        if (this.session === null) {
+            return;
+        }
+        this.finish();
+    }
+    async apply(session) {
+        const result = await this.language.project.applyWorkspaceEdit(session.edit);
+        if (this.session !== session) {
+            return;
+        }
+        if (result.applied) {
+            this.finish();
+        }
+        else {
+            this.fail(result.failureReason ?? say('refused'));
+        }
+    }
+    /* The input stays, with the reason under it, so the name can be changed and tried again. */
+    fail(message) {
+        if (this.session !== null) {
+            this.session.edit = null;
+            this.publish({ phase: 'input', busy: false, files: [], error: say('failed', { message }) });
+        }
+    }
+    /* The name was changed, which answers the failure under it. */
+    edited() {
+        if (this.language.popups.getState().rename?.error != null) {
+            this.publish({ error: null });
+        }
+    }
+    finish() {
+        this.session?.names.abort();
+        this.session = null;
+        const { editor, popups } = this.language;
+        popups.setState({ rename: null });
+        editor.setHighlights([]);
+        editor.focus();
+    }
+    /* Lights up the places the name has in this file, and counts them all; what the servers listed, or null when they did not. */
+    async light(session) {
+        const { editor, project, uri } = this.language;
+        if (!project.service.supports('textDocument/references', uri)) {
+            return null;
+        }
+        try {
+            const locations = await project.service.references(uri, session.target.range.start, true);
+            if (this.session !== session || locations === null) {
+                return null;
+            }
+            const found = occurrencesOf(locations, uri);
+            editor.setHighlights(found.inFile.map((range) => ({ range, kind: 'write' })));
+            this.publish({ occurrences: { count: found.count, files: found.files } });
+            return locations;
+        }
+        catch {
+            // The count is a courtesy; renaming does not wait for it.
+            return null;
+        }
+    }
+    /*
+     * Names from the host suggestion provider, using the lines around the symbol and a sample of the lines that
+     * use it. They only appear under the input: the name that is typed stays the one that is applied.
+     */
+    async suggest(session, locations) {
+        const suggestNames = this.language.project.host.suggestNames;
+        if (suggestNames === undefined || this.session !== session) {
+            return;
+        }
+        const { editor, languageId, uri } = this.language;
+        try {
+            const line = session.target.range.start.line;
+            const context = editor.textInRange({
+                start: { line: Math.max(0, line - CONTEXT_LINES), character: 0 },
+                end: { line: line + CONTEXT_LINES, character: Number.MAX_SAFE_INTEGER }
+            });
+            const uses = await this.linesOf(locations ?? []);
+            const names = await suggestNames({ uri, languageId, name: session.original, context, uses }, session.names.signal);
+            if (this.session === session && names.length > 0) {
+                this.publish({ suggestions: names });
+            }
+        }
+        catch {
+            // Suggestions do not prevent a manual rename.
+        }
+    }
+    /* The text of the first lines that name the symbol, in the order the servers listed them, reading at most a few other files. */
+    async linesOf(locations) {
+        const { project } = this.language;
+        const texts = new Map();
+        const lines = [];
+        let others = 0;
+        for (const location of locations.slice(0, SAMPLE_LOCATIONS)) {
+            if (!texts.has(location.uri)) {
+                if (location.uri !== this.language.uri && others++ >= SAMPLE_OTHER_FILES) {
+                    continue;
+                }
+                texts.set(location.uri, (await project.readText(location.uri))?.split('\n') ?? null);
+            }
+            const text = texts.get(location.uri)?.[location.range.start.line];
+            if (text !== undefined && text.trim() !== '' && !lines.includes(text)) {
+                lines.push(text);
+            }
+        }
+        return lines;
+    }
+    publish(patch) {
+        const session = this.session;
+        if (session === null) {
+            return;
+        }
+        const { popups } = this.language;
+        const current = popups.getState().rename;
+        popups.setState({
+            rename: {
+                phase: 'input',
+                range: session.target.range,
+                original: session.original,
+                placeholder: session.target.placeholder,
+                occurrences: null,
+                busy: false,
+                error: null,
+                name: session.target.placeholder,
+                files: [],
+                suggestions: [],
+                ...current,
+                ...patch
+            }
+        });
+    }
+}

package/dist/rendering-context.d.ts

@@ -0,0 +1,6 @@
+export interface EditorRendering {
+    readonly theme: string;
+    highlight?(code: string, language: string, theme: string): Promise<string>;
+}
+export declare const RenderingContext: import("react").Context<EditorRendering>;
+export declare function useEditorRendering(): EditorRendering;

package/dist/rendering-context.js

@@ -0,0 +1,5 @@
+import { createContext, useContext } from 'react';
+export const RenderingContext = createContext({ theme: 'light' });
+export function useEditorRendering() {
+    return useContext(RenderingContext);
+}

package/dist/rendering.d.ts

@@ -0,0 +1,6 @@
+import type { ReactNode } from 'react';
+import { type EditorRendering } from './rendering-context.ts';
+export declare function EditorRenderingProvider({ value, children }: {
+    value: EditorRendering;
+    children: ReactNode;
+}): import("react").JSX.Element;

package/dist/rendering.js

@@ -0,0 +1,5 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { RenderingContext } from './rendering-context.js';
+export function EditorRenderingProvider({ value, children }) {
+    return _jsx(RenderingContext, { value: value, children: children });
+}

package/dist/review-group.d.ts

@@ -0,0 +1,16 @@
+export interface ReviewMember {
+    hide(runIds: readonly string[]): void;
+    show(runIds: readonly string[]): void;
+    refresh(): void;
+}
+export declare class ReviewGroup {
+    private readonly members;
+    join(member: ReviewMember): () => void;
+    hide(runIds: readonly string[]): void;
+    show(runIds: readonly string[]): void;
+    refresh(): void;
+}
+export declare function joinReviewGroup(key: string): {
+    group: ReviewGroup;
+    leave(): void;
+};

package/dist/review-group.js

@@ -0,0 +1,54 @@
+/*
+ * The editors of one file in this window. An answer in one of them is an answer for all: the rows of
+ * the others go with it at once and every one of them reads the runs again, so no editor keeps a
+ * change in front of a person that the other already took.
+ */
+export class ReviewGroup {
+    members = new Set();
+    join(member) {
+        this.members.add(member);
+        return () => {
+            this.members.delete(member);
+        };
+    }
+    hide(runIds) {
+        for (const member of [...this.members]) {
+            member.hide(runIds);
+        }
+    }
+    show(runIds) {
+        for (const member of [...this.members]) {
+            member.show(runIds);
+        }
+    }
+    refresh() {
+        for (const member of [...this.members]) {
+            member.refresh();
+        }
+    }
+}
+const groups = new Map();
+/* The host supplies a shared file key; the group is released with its last editor. */
+export function joinReviewGroup(key) {
+    let entry = groups.get(key);
+    if (entry === undefined) {
+        entry = { group: new ReviewGroup(), holders: 0 };
+        groups.set(key, entry);
+    }
+    entry.holders++;
+    const held = entry;
+    let left = false;
+    return {
+        group: held.group,
+        leave: () => {
+            if (left) {
+                return;
+            }
+            left = true;
+            held.holders--;
+            if (held.holders === 0 && groups.get(key) === held) {
+                groups.delete(key);
+            }
+        }
+    };
+}

package/dist/row-host.d.ts

@@ -0,0 +1,42 @@
+import type { Editor } from '@adecore/editor';
+export interface HostedRow {
+    id: string;
+    line: number;
+    placement: 'above' | 'below';
+    height: number;
+}
+export declare class RowHost {
+    private readonly editor;
+    private readonly owner;
+    private readonly containers;
+    private readonly listeners;
+    private version;
+    private signature;
+    constructor(editor: Editor, owner: string);
+    getVersion: () => number;
+    subscribe: (listener: () => void) => (() => void);
+    container(id: string): HTMLElement | undefined;
+    set(rows: readonly HostedRow[]): void;
+    clear(): void;
+    private mounted;
+    private bump;
+}
+export interface HostedAction {
+    id: string;
+    line: number;
+}
+export declare class LineActionHost {
+    private readonly editor;
+    private readonly owner;
+    private readonly containers;
+    private readonly listeners;
+    private version;
+    private signature;
+    constructor(editor: Editor, owner: string);
+    getVersion: () => number;
+    subscribe: (listener: () => void) => (() => void);
+    container(id: string): HTMLElement | undefined;
+    set(actions: readonly HostedAction[]): void;
+    clear(): void;
+    private bump;
+}