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

package/dist/SymbolPicker.js

@@ -0,0 +1,108 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useMemo, useRef, useState } from 'react';
+import { createPortal } from 'react-dom';
+import { useTranslation } from 'react-i18next';
+import { AtSign, Hash } from 'lucide-react';
+import { Icon } from '@adecore/ui';
+import { formatShortcut } from '@adecore/ui';
+import { formatNumber } from '@adecore/ui/format';
+import { basenameOf } from './paths.js';
+import { fileUriToPath } from '@adecore/lsp';
+import { filterEntries, groupEntries, letterOfKind, modeOf, toneOfKind } from './symbol-picker-model.js';
+const TONES = {
+    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 SEARCH_DELAY_MS = 200;
+function Badge({ kind }) {
+    return (_jsx("span", { className: `grid size-4 shrink-0 place-items-center rounded-sm font-mono text-xs font-semibold ${TONES[toneOfKind(kind)]}`, children: letterOfKind(kind) }));
+}
+/*
+ * The picker of go to symbol, over the editor: an input, the symbols of the file in groups by kind, and the
+ * keys. The input keeps the focus; Enter goes, Escape and the focus leaving close it.
+ */
+export function SymbolPicker({ language, view }) {
+    const { t } = useTranslation('editor');
+    const [input, setInput] = useState('');
+    const [active, setActive] = useState(0);
+    const [found, setFound] = useState({ text: '', entries: [] });
+    const activeRow = useRef(null);
+    const mode = modeOf(input);
+    const filterText = mode.mode === 'symbol' ? mode.text : '';
+    const searchText = mode.mode === 'workspace' ? mode.text : '';
+    const groups = useMemo(() => groupEntries(filterEntries(view.entries, filterText)), [view.entries, filterText]);
+    const flat = groups.flatMap((group) => group.entries);
+    const places = mode.mode === 'workspace' && found.text === mode.text ? found.entries : [];
+    const count = mode.mode === 'workspace' ? places.length : mode.mode === 'line' ? (mode.line === null ? 0 : 1) : flat.length;
+    useEffect(() => {
+        if (searchText === '') {
+            return;
+        }
+        const controller = new AbortController();
+        const text = searchText;
+        const timer = setTimeout(() => {
+            language.symbolPicker
+                .search(text, controller.signal)
+                .then((entries) => !controller.signal.aborted && setFound({ text, entries }))
+                .catch(() => undefined);
+        }, SEARCH_DELAY_MS);
+        return () => {
+            clearTimeout(timer);
+            controller.abort();
+        };
+    }, [language, searchText]);
+    useEffect(() => {
+        activeRow.current?.scrollIntoView({ block: 'nearest' });
+    }, [active, input]);
+    function choose(index) {
+        if (mode.mode === 'line') {
+            if (mode.line !== null) {
+                language.symbolPicker.goToLine(mode.line);
+            }
+        }
+        else if (mode.mode === 'workspace') {
+            const place = places[index];
+            if (place !== undefined) {
+                language.symbolPicker.goToWorkspace(place);
+            }
+        }
+        else if (flat[index] !== undefined) {
+            language.symbolPicker.goTo(flat[index]);
+        }
+    }
+    function onKeyDown(event) {
+        if (event.key === 'Escape') {
+            event.preventDefault();
+            event.stopPropagation();
+            language.symbolPicker.close();
+        }
+        else if (event.key === 'Enter' && !event.nativeEvent.isComposing) {
+            event.preventDefault();
+            event.stopPropagation();
+            choose(active);
+        }
+        else if (event.key === 'ArrowDown' || event.key === 'ArrowUp') {
+            event.preventDefault();
+            setActive(Math.max(0, Math.min(Math.max(0, count - 1), active + (event.key === 'ArrowDown' ? 1 : -1))));
+        }
+    }
+    let offset = 0;
+    return createPortal(_jsxs("div", { className: "fixed top-[12vh] left-1/2 z-(--z-popup) flex w-[560px] max-w-[calc(100vw-16px)] -translate-x-1/2 flex-col overflow-hidden rounded-lg border border-border bg-surface-raised text-text shadow-(--float-shadow)", onPointerDown: (event) => event.target !== event.currentTarget && event.target.tagName !== 'INPUT' && event.preventDefault(), children: [_jsxs("div", { className: "flex items-center gap-2 border-b border-border px-3 py-2", children: [_jsx(Icon, { icon: mode.mode === 'workspace' ? Hash : AtSign, size: 14, className: "shrink-0 text-text-muted" }), _jsx("input", { autoFocus: true, value: input, spellCheck: false, autoComplete: "off", placeholder: t('language.symbols.placeholder', { file: view.file }), className: "min-w-0 flex-1 bg-transparent text-sm text-text outline-none placeholder:text-text-faint", onChange: (event) => {
+                            setInput(event.target.value);
+                            setActive(0);
+                        }, onKeyDown: onKeyDown, onBlur: () => language.symbolPicker.close() }), _jsx("span", { className: "shrink-0 text-xs text-text-faint", children: language.shortcuts.goToSymbol === null ? '' : formatShortcut(language.shortcuts.goToSymbol, language.apple) })] }), _jsxs("div", { role: "listbox", className: "max-h-[320px] overflow-y-auto p-1", children: [mode.mode === 'line' && (_jsx("div", { className: "px-2 py-1.5 text-xs text-text-muted", children: mode.line === null ? t('language.symbols.lineHint') : t('language.symbols.goToLine', { line: formatNumber(mode.line) }) })), mode.mode === 'workspace' &&
+                        places.map((place, index) => {
+                            const path = fileUriToPath(place.uri);
+                            return (_jsxs("button", { ref: index === active ? activeRow : undefined, type: "button", role: "option", "aria-selected": index === active, "data-active": index === active, className: "flex h-7 w-full items-center gap-2 rounded-md px-2 text-left text-xs cursor-row", onClick: () => choose(index), children: [_jsx(Badge, { kind: place.kind }), _jsx("span", { className: "shrink-0", children: place.name }), _jsx("span", { className: "min-w-0 truncate font-mono text-text-faint", children: place.container }), _jsxs("span", { className: "ml-auto shrink-0 font-mono text-text-faint", children: [path === null ? '' : basenameOf(path), ":", formatNumber(place.line + 1)] })] }, place.id));
+                        }), mode.mode === 'symbol' &&
+                        groups.map((group) => {
+                            const start = offset;
+                            offset += group.entries.length;
+                            return (_jsxs("div", { role: "group", children: [_jsx("div", { className: "px-2 pt-1.5 pb-0.5 text-xs font-medium text-text-faint", children: t(`language.symbols.groups.${group.group}`) }), group.entries.map((entry, index) => {
+                                        const position = start + index;
+                                        return (_jsxs("button", { ref: position === active ? activeRow : undefined, type: "button", role: "option", "aria-selected": position === active, "data-active": position === active, className: "flex h-7 w-full items-center gap-2 rounded-md px-2 text-left text-xs cursor-row", onClick: () => choose(position), children: [_jsx(Badge, { kind: entry.kind }), _jsx("span", { className: "shrink-0", children: entry.name }), _jsx("span", { className: "min-w-0 truncate font-mono text-text-faint", children: entry.detail }), entry.container !== '' && _jsx("span", { className: "min-w-0 truncate text-text-faint", children: entry.container }), _jsx("span", { className: "ml-auto shrink-0 font-mono text-text-faint", children: formatNumber(entry.line + 1) })] }, entry.id));
+                                    })] }, group.group));
+                        }), mode.mode === 'symbol' && flat.length === 0 && (_jsx("div", { className: "px-2 py-3 text-center text-xs text-text-muted", children: t('language.symbols.none') })), mode.mode === 'workspace' && places.length === 0 && (_jsx("div", { className: "px-2 py-3 text-center text-xs text-text-muted", children: mode.text === '' ? t('language.symbols.workspaceHint') : t('language.symbols.none') }))] }), _jsxs("div", { className: "flex items-center gap-3 border-t border-border px-3 py-1.5 text-xs whitespace-nowrap text-text-faint", children: [_jsxs("span", { children: ["\u2191\u2193 ", t('language.symbols.navigate')] }), _jsxs("span", { children: ["\u21B5 ", t('language.symbols.open')] }), _jsxs("button", { type: "button", className: "ml-auto hover:text-text", onClick: () => setInput('#'), children: ["# ", t('language.symbols.workspace')] }), _jsxs("button", { type: "button", className: "hover:text-text", onClick: () => setInput(':'), children: [": ", t('language.symbols.line')] })] })] }), document.body);
+}

package/dist/code-actions-model.d.ts

@@ -0,0 +1,23 @@
+import { type CodeAction, type Command, type Diagnostic, type Range, type WorkspaceEdit } from '@adecore/lsp';
+export type ActionGroup = 'quickfix' | 'rewrite' | 'extract' | 'inline' | 'move' | 'refactor' | 'source' | 'other';
+export declare const ACTION_GROUPS: readonly ActionGroup[];
+export declare const REFACTOR_GROUPS: readonly ActionGroup[];
+export interface ActionEntry {
+    readonly id: string;
+    readonly action: CodeAction;
+    readonly group: ActionGroup;
+}
+export declare function groupOf(kind: string | undefined): ActionGroup;
+export declare function actionsOf(result: readonly (CodeAction | Command)[] | null, order?: readonly ActionGroup[]): ActionEntry[];
+export declare function mergeEntries(lists: readonly (readonly ActionEntry[])[]): ActionEntry[];
+export declare function isHint(entry: ActionEntry): boolean;
+export declare function fixableOnLine(diagnostics: readonly Diagnostic[], line: number): Diagnostic[];
+export declare function diagnosticsAt(diagnostics: readonly Diagnostic[], range: Range): Diagnostic[];
+export interface EditPreview {
+    readonly removed: readonly string[];
+    readonly added: readonly string[];
+    readonly hiddenLines: number;
+    readonly otherFiles: number;
+    readonly moves: number;
+}
+export declare function previewOf(text: string, edit: WorkspaceEdit, uri: string): EditPreview | null;

package/dist/code-actions-model.js

@@ -0,0 +1,114 @@
+import { applyTextEdits } from '@adecore/lsp';
+import { comparePositions } from './diagnostics-model.js';
+import { entriesOf, renamesOf } from './workspace-edit.js';
+/* The order of the list under the caret: the fixes and the rewrites that are one keystroke away first, the refactorings after them. */
+export const ACTION_GROUPS = ['quickfix', 'rewrite', 'extract', 'inline', 'move', 'refactor', 'source', 'other'];
+/* The order of Refactor This: what changes the structure of the code first, the rewrites after it. */
+export const REFACTOR_GROUPS = ['extract', 'inline', 'move', 'rewrite', 'refactor'];
+/* The kinds nest by dots: `refactor.extract.function` is an extraction and `source.organizeImports` a source action. */
+export function groupOf(kind) {
+    if (kind === 'quickfix' || kind?.startsWith('quickfix.')) {
+        return 'quickfix';
+    }
+    for (const group of ['extract', 'inline', 'move', 'rewrite']) {
+        if (kind === `refactor.${group}` || kind?.startsWith(`refactor.${group}.`)) {
+            return group;
+        }
+    }
+    if (kind === 'refactor' || kind?.startsWith('refactor.')) {
+        return 'refactor';
+    }
+    if (kind === 'source' || kind?.startsWith('source.')) {
+        return 'source';
+    }
+    return 'other';
+}
+/*
+ * What a server answered, as the rows of a list. A bare command becomes an action of its own, one a server
+ * marked disabled is left out, and each group lists the preferred actions first, in the order the server gave.
+ */
+export function actionsOf(result, order = ACTION_GROUPS) {
+    const entries = (result ?? [])
+        .map((item) => (typeof item.command === 'string' ? { title: item.title, command: item } : item))
+        .filter((action) => action.disabled === undefined)
+        .map((action, index) => ({ id: String(index), action, group: groupOf(action.kind) }));
+    return order.flatMap((group) => {
+        const own = entries.filter((entry) => entry.group === group);
+        return [...own.filter((entry) => entry.action.isPreferred === true), ...own.filter((entry) => entry.action.isPreferred !== true)];
+    });
+}
+/* Entries from several requests as one list: the same order as a single answer, and an id of its own for each row. Two actions with a title and kind alike are one. */
+export function mergeEntries(lists) {
+    const seen = new Set();
+    const unique = lists.flat().filter((entry) => {
+        const key = `${entry.action.kind ?? ''}\0${entry.action.title}`;
+        if (seen.has(key)) {
+            return false;
+        }
+        seen.add(key);
+        return true;
+    });
+    return ACTION_GROUPS.flatMap((group) => {
+        const own = unique.filter((entry) => entry.group === group);
+        return [...own.filter((entry) => entry.action.isPreferred === true), ...own.filter((entry) => entry.action.isPreferred !== true)];
+    }).map((entry, index) => ({ ...entry, id: String(index) }));
+}
+/* Whether the lightbulb offers it: a source action such as organizing imports is a command of its own and never a hint. */
+export function isHint(entry) {
+    return entry.group !== 'source';
+}
+/* The problems of a line that are worth a fix: errors and warnings, errors first, in the order of the line. */
+export function fixableOnLine(diagnostics, line) {
+    return diagnostics
+        .filter((diagnostic) => (diagnostic.severity ?? 1) <= 2 && diagnostic.range.start.line <= line && diagnostic.range.end.line >= line)
+        .sort((left, right) => (left.severity ?? 1) - (right.severity ?? 1) || comparePositions(left.range.start, right.range.start));
+}
+function touches(range, target) {
+    return comparePositions(range.start, target.end) <= 0 && comparePositions(target.start, range.end) <= 0;
+}
+/* The problems an action may be about: the ones that overlap or touch the range it was asked for. */
+export function diagnosticsAt(diagnostics, range) {
+    return diagnostics.filter((diagnostic) => touches(diagnostic.range, range));
+}
+const PREVIEW_LINES = 3;
+function linesOf(text) {
+    return text.split(/\r\n|\r|\n/);
+}
+/* Null when the edit changes nothing, or creates or deletes a file, which a preview of lines cannot show. */
+export function previewOf(text, edit, uri) {
+    const entries = entriesOf(edit);
+    if (entries === null) {
+        return null;
+    }
+    const own = entries.get(uri);
+    const moves = renamesOf(edit).length;
+    const otherFiles = [...entries.keys()].filter((key) => key !== uri).length;
+    let removed = [];
+    let added = [];
+    if (own !== undefined) {
+        let after;
+        try {
+            after = applyTextEdits(text, own.flat());
+        }
+        catch {
+            return null;
+        }
+        const before = linesOf(text);
+        const next = linesOf(after);
+        let head = 0;
+        while (head < before.length && head < next.length && before[head] === next[head]) {
+            head++;
+        }
+        let tail = 0;
+        while (tail < before.length - head && tail < next.length - head && before[before.length - 1 - tail] === next[next.length - 1 - tail]) {
+            tail++;
+        }
+        removed = before.slice(head, before.length - tail);
+        added = next.slice(head, next.length - tail);
+    }
+    if (removed.length === 0 && added.length === 0 && otherFiles === 0 && moves === 0) {
+        return null;
+    }
+    const hiddenLines = Math.max(0, removed.length - PREVIEW_LINES) + Math.max(0, added.length - PREVIEW_LINES);
+    return { removed: removed.slice(0, PREVIEW_LINES), added: added.slice(0, PREVIEW_LINES), hiddenLines, otherFiles, moves };
+}

package/dist/code-actions.d.ts

@@ -0,0 +1,30 @@
+import { type ActionEntry } from './code-actions-model.ts';
+import type { Problem } from './diagnostics-model.ts';
+import type { EditorLanguage } from './editor-language.ts';
+import { type Timers } from './timers.ts';
+export declare class CodeActionsFeature {
+    private tell;
+    private readonly language;
+    private readonly refresher;
+    private asking;
+    private readonly resolved;
+    constructor(language: EditorLanguage, timers?: Timers);
+    get supported(): boolean;
+    open(): Promise<void>;
+    refactorThis(): Promise<void>;
+    quickFixFor(problem: Problem): Promise<void>;
+    organizeImports(): Promise<void>;
+    formatDocument(): Promise<void>;
+    list(only: readonly string[]): Promise<ActionEntry[] | null>;
+    private ask;
+    private request;
+    private requestWithLine;
+    private hint;
+    private resolve;
+    private preview;
+    private refusalOf;
+    apply(entry: ActionEntry): Promise<void>;
+    private startRename;
+    private fail;
+    private say;
+}

package/dist/code-actions.js

@@ -0,0 +1,326 @@
+import { ErrorCodes, LspError, StaleResultError } from '@adecore/lsp';
+import { ACTION_GROUPS, REFACTOR_GROUPS, actionsOf, diagnosticsAt, fixableOnLine, isHint, mergeEntries, previewOf } from './code-actions-model.js';
+import { Refresher } from './refresher.js';
+import { isShortcut } from './shortcut-keys.js';
+import { realTimers } from './timers.js';
+const METHOD = 'textDocument/codeAction';
+const PAUSE_MS = 250;
+const INVOKED = 1;
+const AUTOMATIC = 2;
+const TOAST_ID = 'language-action';
+/* How many problems of the line are asked for their fixes besides the caret's own request. */
+const LINE_PROBLEMS = 3;
+/* The command of the PHP server that asks the client to rename the name a refactor just wrote; the server answers it with nothing. */
+const INLINE_RENAME_COMMAND = 'php.rename';
+/* A server that would not make the action, with its reason. */
+class ActionRefused extends Error {
+}
+function isRefusal(error) {
+    return error instanceof LspError && error.code === ErrorCodes.InternalError;
+}
+/*
+ * What the language servers offer to do at the caret or the selection: a lightbulb in the gutter on the line
+ * that has something, a list under the caret (Mod+.) grouped by kind with the change an action would make
+ * shown under it, the Quick fix of a problem's card, and the commands that organize imports and format the file.
+ * An action is resolved before it is applied, since a server fills in its edit only when asked for it.
+ */
+export class CodeActionsFeature {
+    tell(kind, title) {
+        this.language.project.host.notify?.({ id: TOAST_ID, kind, title });
+    }
+    language;
+    refresher;
+    /* While a list is being asked for, the lightbulb waits: both are the same request and the newer one would cancel the older. */
+    asking = false;
+    resolved = new Map();
+    constructor(language, timers = realTimers) {
+        this.language = language;
+        const { editor } = language;
+        this.refresher = new Refresher((signal) => this.hint(signal), PAUSE_MS, timers);
+        const providers = language.onProvidersChanged(() => {
+            this.refresher.later();
+        });
+        const offs = [
+            editor.onCaret(() => {
+                editor.setGutterAction(null);
+                this.refresher.later();
+            }),
+            editor.onTextChange(() => editor.setGutterAction(null)),
+            editor.onGutterAction(() => void this.open()),
+            editor.onKeyDown((event) => {
+                if (isShortcut(this.language.shortcuts.codeActions, event)) {
+                    void this.open();
+                    return true;
+                }
+                if (isShortcut(this.language.shortcuts.refactorThis, event)) {
+                    void this.refactorThis();
+                    return true;
+                }
+                return false;
+            }),
+            language.diagnostics.onChange(() => this.refresher.later()),
+            providers
+        ];
+        language.onDispose(() => {
+            for (const off of offs) {
+                off();
+            }
+            this.refresher.dispose();
+            editor.setGutterAction(null);
+        });
+    }
+    get supported() {
+        return this.language.project.service.supports(METHOD, this.language.uri);
+    }
+    /* The list under the caret, or under the selection's start. */
+    open() {
+        const range = this.language.editor.getSelection();
+        return this.ask({ range, anchor: range.start, withLine: true });
+    }
+    /* Refactor This: only the refactorings, grouped by what they do, under the caret or the selection. */
+    refactorThis() {
+        const range = this.language.editor.getSelection();
+        return this.ask({ range, only: ['refactor'], anchor: range.start, groups: REFACTOR_GROUPS });
+    }
+    /* The quick fixes of one problem, under it, as the Quick fix button of its card asks. */
+    quickFixFor(problem) {
+        const { range } = problem.diagnostic;
+        return this.ask({ range, only: ['quickfix'], anchor: range.start, diagnostics: [problem.diagnostic] });
+    }
+    async organizeImports() {
+        const { editor } = this.language;
+        const everything = { start: { line: 0, character: 0 }, end: editor.positionAt(Number.MAX_SAFE_INTEGER) };
+        const entries = await this.request(everything, ['source.organizeImports'], INVOKED);
+        const entry = entries?.find((candidate) => candidate.action.kind?.startsWith('source.organizeImports') === true);
+        if (entry === undefined) {
+            this.tell('success', this.say(entries === null ? 'unavailable' : 'organized'));
+            return;
+        }
+        await this.apply(entry);
+    }
+    async formatDocument() {
+        const { editor, project, uri } = this.language;
+        if (!project.service.supports('textDocument/formatting', uri)) {
+            this.tell('error', this.say('noFormatter'));
+            return;
+        }
+        try {
+            const edits = await project.service.formatting(uri, { ...editor.getIndentation() });
+            if (edits !== null && edits.length > 0 && !editor.applyEdits(edits.map((edit) => ({ range: edit.range, text: edit.newText })))) {
+                this.tell('error', this.say('readOnly'));
+            }
+        }
+        catch (error) {
+            this.fail(error);
+        }
+    }
+    /* The actions of one kind for the selection, as entries a menu can list and `apply` runs. */
+    list(only) {
+        return this.supported
+            ? this.request(this.language.editor.getSelection(), only, AUTOMATIC, undefined, undefined, only.includes('refactor') ? REFACTOR_GROUPS : ACTION_GROUPS)
+            : Promise.resolve(null);
+    }
+    async ask(options) {
+        if (!this.supported) {
+            this.tell('error', this.say('unavailable'));
+            return;
+        }
+        // The press on a card or the gutter may have taken the focus, and the list answers to the editor's keys.
+        this.language.editor.focus();
+        this.asking = true;
+        let entries;
+        try {
+            entries = options.withLine
+                ? await this.requestWithLine(options.range, INVOKED)
+                : await this.request(options.range, options.only, INVOKED, undefined, options.diagnostics, options.groups);
+        }
+        finally {
+            this.asking = false;
+        }
+        if (entries === null) {
+            return;
+        }
+        if (entries.length === 0) {
+            this.tell('success', this.say('none'));
+            return;
+        }
+        const byId = new Map(entries.map((entry) => [entry.id, entry]));
+        const groups = (options.groups ?? ACTION_GROUPS).flatMap((group) => {
+            const rows = entries.filter((entry) => entry.group === group).map((entry) => ({ id: entry.id, label: entry.action.title, detail: '' }));
+            return rows.length === 0 ? [] : [{ title: this.say(`groups.${group}`), rows }];
+        });
+        this.language.completion.close();
+        this.language.pick.open({
+            anchor: options.anchor,
+            groups,
+            accept: (id) => {
+                const entry = byId.get(id);
+                if (entry !== undefined) {
+                    void this.apply(entry);
+                }
+            },
+            attempt: (id) => this.refusalOf(byId.get(id)),
+            preview: (id, signal) => this.preview(byId.get(id), signal)
+        });
+    }
+    /* Asks the servers; null when they could not answer, with the reason said aloud for a request a person made. */
+    async request(range, only, triggerKind, signal, about, order) {
+        const { project, uri, diagnostics } = this.language;
+        try {
+            const context = {
+                diagnostics: [
+                    ...(about ??
+                        diagnosticsAt(diagnostics.problems.map((problem) => problem.diagnostic), range))
+                ],
+                ...(only ? { only: [...only] } : {}),
+                triggerKind: triggerKind
+            };
+            const entries = actionsOf(await project.service.codeActions(uri, range, context, { signal }), order);
+            // A server may answer with more than the kinds asked for.
+            return only ? entries.filter((entry) => only.some((kind) => entry.action.kind === kind || entry.action.kind?.startsWith(`${kind}.`))) : entries;
+        }
+        catch (error) {
+            if (triggerKind === INVOKED) {
+                this.fail(error);
+            }
+            return null;
+        }
+    }
+    /*
+     * What the servers offer at the range, and when no problem touches it, the quick fixes of the problems
+     * elsewhere on its line too, since the fix of an error is wanted from anywhere on the line it is on.
+     */
+    async requestWithLine(range, triggerKind, signal) {
+        const entries = await this.request(range, undefined, triggerKind, signal);
+        if (entries === null || range.start.line !== range.end.line) {
+            return entries;
+        }
+        const all = this.language.diagnostics.problems.map((problem) => problem.diagnostic);
+        if (diagnosticsAt(all, range).length > 0) {
+            return entries;
+        }
+        const onLine = fixableOnLine(all, range.start.line).slice(0, LINE_PROBLEMS);
+        const fixes = await Promise.all(onLine.map((diagnostic) => this.request(diagnostic.range, ['quickfix'], triggerKind, signal, [diagnostic])));
+        return mergeEntries([entries, ...fixes.map((list) => list ?? [])]);
+    }
+    async hint(signal) {
+        const { editor } = this.language;
+        if (this.asking || !this.supported) {
+            editor.setGutterAction(null);
+            return;
+        }
+        const range = editor.getSelection();
+        const entries = await this.requestWithLine(range, AUTOMATIC, signal);
+        if (signal.aborted || this.asking) {
+            return;
+        }
+        editor.setGutterAction(entries?.some(isHint) === true ? { line: editor.getCaret().line, label: this.say('show') } : null);
+    }
+    async resolve(entry, signal) {
+        const known = this.resolved.get(entry);
+        if (known !== undefined) {
+            return known;
+        }
+        const { project, uri } = this.language;
+        const { action } = entry;
+        let result = action;
+        if (action.edit === undefined && project.service.providerOptions(METHOD, uri)?.resolveProvider === true) {
+            try {
+                result = await project.service.resolveCodeAction(uri, action, { signal });
+            }
+            catch (error) {
+                if (isRefusal(error)) {
+                    throw new ActionRefused(error.message);
+                }
+                // An action the server cannot resolve is still tried as it is, unless the text moved under it.
+                if (error instanceof StaleResultError) {
+                    throw error;
+                }
+            }
+        }
+        this.resolved.set(entry, result);
+        return result;
+    }
+    async preview(entry, signal) {
+        if (entry === undefined) {
+            return null;
+        }
+        let action;
+        try {
+            action = await this.resolve(entry, signal);
+        }
+        catch (error) {
+            if (error instanceof ActionRefused) {
+                return { removed: [], added: [], note: null, refusal: error.message };
+            }
+            throw error;
+        }
+        const { editor, uri } = this.language;
+        const found = action.edit === undefined ? null : previewOf(editor.getText(), action.edit, uri);
+        if (found === null) {
+            return null;
+        }
+        const notes = [
+            ...(found.hiddenLines > 0 ? [this.say('moreLines', { count: found.hiddenLines })] : []),
+            ...(found.otherFiles > 0 ? [this.say('otherFiles', { count: found.otherFiles })] : []),
+            ...(found.moves > 0 ? [this.say('moves', { count: found.moves })] : [])
+        ];
+        return { removed: found.removed, added: found.added, note: notes.length === 0 ? null : notes.join(' · ') };
+    }
+    /* Why a server would not make the action, or null when it will, which resolves it for `apply` to use. */
+    async refusalOf(entry) {
+        if (entry === undefined) {
+            return null;
+        }
+        try {
+            await this.resolve(entry);
+            return null;
+        }
+        catch (error) {
+            return error instanceof ActionRefused ? error.message : null;
+        }
+    }
+    /* Resolves the action, makes its edit as one undo step, and then runs its command. */
+    async apply(entry) {
+        const { editor, project, uri } = this.language;
+        try {
+            const action = await this.resolve(entry);
+            if (action.edit !== undefined) {
+                const result = await project.applyWorkspaceEdit(action.edit);
+                if (!result.applied) {
+                    this.tell('error', this.say('failed', { message: result.failureReason ?? this.say('refused') }));
+                    return;
+                }
+            }
+            if (action.command?.command === INLINE_RENAME_COMMAND) {
+                await this.startRename(action.command);
+            }
+            else if (action.command !== undefined) {
+                await project.service.executeCommand(uri, action.command);
+            }
+        }
+        catch (error) {
+            this.fail(error);
+        }
+        finally {
+            this.resolved.delete(entry);
+            editor.focus();
+        }
+    }
+    /* The name a refactor wrote is offered for a rename right where it stands, the way the platform does after an extraction. */
+    async startRename(command) {
+        const target = (command.arguments?.[0] ?? null);
+        if (target?.position !== undefined && target.textDocument?.uri === this.language.uri) {
+            this.language.editor.setCaret(target.position);
+            await this.language.rename.start();
+        }
+    }
+    fail(error) {
+        if (!(error instanceof StaleResultError)) {
+            this.tell('error', this.say('failed', { message: error instanceof Error ? error.message : String(error) }));
+        }
+    }
+    say(key, options) {
+        return this.language.project.i18n.t(`editor:language.actions.${key}`, options);
+    }
+}

package/dist/code-authors.d.ts

@@ -0,0 +1,18 @@
+import type { i18n } from 'i18next';
+import type { GitBlameCommit, GitBlameResult } from './host-types.ts';
+export declare const UNCOMMITTED = -1;
+export declare function mapBlame(blame: GitBlameResult, base: string, current: readonly string[]): Int32Array | null;
+export interface CodeAuthor {
+    readonly name: string;
+    readonly email: string;
+    readonly lines: number;
+}
+export interface CodeAuthorship {
+    readonly authors: readonly CodeAuthor[];
+    readonly uncommittedLines: number;
+    readonly modified: boolean;
+    readonly latest: GitBlameCommit | null;
+}
+export declare function shortName(name: string): string;
+export declare function authorshipOf(commits: readonly GitBlameCommit[], mapped: Int32Array, lines: readonly string[], from: number, to: number): CodeAuthorship;
+export declare function authorsText(authorship: CodeAuthorship, i18n: i18n): string;