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

package/dist/popups.d.ts

@@ -0,0 +1,133 @@
+import { type StoreApi } from 'zustand';
+import type { EditorPosition, EditorRange, EditorRect } from '@adecore/editor';
+import type { Location } from '@adecore/lsp';
+import type { CodeAuthorship } from './code-authors.ts';
+import type { Problem } from './diagnostics-model.ts';
+import type { PeekFile, PeekSnippet } from './peek-model.ts';
+import type { ActionEntry } from './code-actions-model.ts';
+import type { SymbolEntry } from './symbol-picker-model.ts';
+import type { HoverText } from './hover-content.ts';
+import type { SignatureViewModel } from './signature-model.ts';
+export interface HoverView {
+    readonly anchor: EditorPosition;
+    readonly position: EditorPosition;
+    readonly subject: EditorRange;
+    readonly problems: readonly Problem[];
+    readonly info: HoverInfo | null;
+}
+export interface HoverInfo {
+    readonly text: HoverText;
+    readonly definition: Location | null;
+    readonly word: string;
+    readonly references: number | null;
+}
+export interface CompletionRow {
+    readonly label: string;
+    readonly kind: number | undefined;
+    readonly detail: string;
+    readonly description: string;
+    readonly matches: readonly number[];
+    readonly deprecated: boolean;
+}
+export interface CompletionDocs {
+    readonly source: string;
+    readonly text: HoverText;
+}
+export interface CompletionView {
+    readonly anchor: EditorPosition;
+    readonly rows: readonly CompletionRow[];
+    readonly active: number;
+    readonly detailsOpen: boolean;
+    readonly docs: CompletionDocs | null;
+    readonly server: string;
+    readonly highlightLanguage: string;
+}
+export interface SignatureView {
+    readonly anchor: EditorPosition;
+    readonly model: SignatureViewModel;
+}
+export interface PickRow {
+    readonly id: string;
+    readonly label: string;
+    readonly detail: string;
+    readonly path?: boolean;
+}
+export interface PickGroup {
+    readonly title: string | null;
+    readonly rows: readonly PickRow[];
+}
+export interface PickPreview {
+    readonly removed: readonly string[];
+    readonly added: readonly string[];
+    readonly note: string | null;
+    readonly refusal?: string;
+}
+export interface PickView {
+    readonly anchor: EditorPosition;
+    readonly groups: readonly PickGroup[];
+    readonly active: string;
+    readonly preview: PickPreview | null;
+    readonly title: string | null;
+}
+export interface RenameFileView {
+    readonly uri: string;
+    readonly rows: readonly {
+        readonly line: number;
+        readonly before: string;
+        readonly after: string;
+    }[];
+}
+export interface RenameView {
+    readonly phase: 'input' | 'preview';
+    readonly range: EditorRange;
+    readonly original: string;
+    readonly placeholder: string;
+    readonly occurrences: {
+        readonly count: number;
+        readonly files: number;
+    } | null;
+    readonly busy: boolean;
+    readonly error: string | null;
+    readonly name: string;
+    readonly files: readonly RenameFileView[];
+    readonly suggestions: readonly string[];
+}
+export interface PeekView {
+    readonly kind: 'references' | 'definitions';
+    readonly container: HTMLElement | null;
+    readonly files: readonly PeekFile[];
+    readonly active: string;
+    readonly collapsed: readonly string[];
+    readonly count: number;
+    readonly preview: (PeekSnippet & {
+        readonly uri: string;
+    }) | null;
+}
+export interface SymbolsView {
+    readonly file: string;
+    readonly entries: readonly SymbolEntry[];
+}
+export interface MenuView {
+    readonly x: number;
+    readonly y: number;
+    readonly refactors: readonly ActionEntry[];
+}
+export interface AuthorsView {
+    readonly anchor: EditorRect;
+    readonly name: string;
+    readonly authorship: CodeAuthorship;
+    readonly openCommit: (() => void) | null;
+}
+export interface PopupState {
+    readonly hover: HoverView | null;
+    readonly completion: CompletionView | null;
+    readonly signature: SignatureView | null;
+    readonly pick: PickView | null;
+    readonly rename: RenameView | null;
+    readonly peek: PeekView | null;
+    readonly symbols: SymbolsView | null;
+    readonly menu: MenuView | null;
+    readonly authors: AuthorsView | null;
+}
+export type PopupStore = StoreApi<PopupState>;
+export declare function createPopupStore(): PopupStore;

package/dist/popups.js

@@ -0,0 +1,14 @@
+import { createStore } from 'zustand';
+export function createPopupStore() {
+    return createStore(() => ({
+        hover: null,
+        completion: null,
+        signature: null,
+        pick: null,
+        rename: null,
+        peek: null,
+        symbols: null,
+        menu: null,
+        authors: null
+    }));
+}

package/dist/project-language.d.ts

@@ -0,0 +1,36 @@
+import { type i18n } from 'i18next';
+import { type ApplyWorkspaceEditResult, type LanguageService, type WorkspaceEdit } from '@adecore/lsp';
+import type { Editor, EditorPosition } from '@adecore/editor';
+import { NavigationHistory, type Place } from './navigation-history.ts';
+import { ProjectProblems } from './project-problems.ts';
+import type { LanguageHost } from './host-types.ts';
+export interface LanguageDocumentHandle {
+    readonly uri: string;
+    readonly service: LanguageService;
+    readonly ready: Promise<void>;
+    release(): void;
+}
+export declare class ProjectLanguage {
+    readonly service: LanguageService;
+    readonly host: LanguageHost;
+    readonly i18n: i18n;
+    readonly folder: string;
+    readonly problems: ProjectProblems;
+    readonly history: NavigationHistory;
+    private readonly holders;
+    private readonly files;
+    private pendingCaret;
+    private lastPlace;
+    private disposed;
+    constructor(service: LanguageService, host?: LanguageHost);
+    pathOfLocation(uri: string): string | null;
+    applyWorkspaceEdit(edit: WorkspaceEdit): Promise<ApplyWorkspaceEditResult>;
+    readText(uri: string): Promise<string | null>;
+    openPlace(place: Place): void;
+    noteCaret(place: Place): void;
+    jumpTo(place: Place): void;
+    takeCaret(uri: string, line: number): EditorPosition | null;
+    acquire(uri: string, languageId: string, editor: Editor): LanguageDocumentHandle;
+    private release;
+    dispose(): void;
+}

package/dist/project-language.js

@@ -0,0 +1,190 @@
+import i18next, {} from 'i18next';
+import { fileUriToPath } from '@adecore/lsp';
+import { NavigationHistory } from './navigation-history.js';
+import { ProjectProblems } from './project-problems.js';
+import { applyWorkspaceEdit } from './workspace-edit.js';
+class DocumentSync {
+    ready;
+    pending = [];
+    opened = false;
+    disposed = false;
+    stop;
+    service;
+    uri;
+    editor;
+    constructor(service, uri, languageId, editor) {
+        this.service = service;
+        this.uri = uri;
+        this.editor = editor;
+        this.stop = editor.onTextChange((change) => this.changed(change.changes));
+        this.ready = service.openDocument({ uri, languageId, text: editor.getText() }).then(() => {
+            this.opened = true;
+            if (!this.disposed) {
+                this.flush();
+            }
+        });
+        // A failed open is also a document nothing can be asked of; the features' own requests say so.
+        this.ready.catch(() => undefined);
+    }
+    changed(changes) {
+        this.pending.push(...changes);
+        if (this.opened) {
+            this.flush();
+        }
+    }
+    flush() {
+        if (this.pending.length === 0) {
+            return;
+        }
+        const changes = this.pending;
+        this.pending = [];
+        void this.service.changeDocument(this.uri, changes).catch(() => undefined);
+    }
+    dispose() {
+        this.disposed = true;
+        this.pending = [];
+        this.stop();
+    }
+    get text() {
+        return this.editor.getText();
+    }
+}
+/*
+ * A shared language service and document ownership for the editors of a project. Two editors on the same
+ * file hold one document, and only the first one sends changes, since both would report the same edit.
+ */
+export class ProjectLanguage {
+    service;
+    host;
+    i18n;
+    folder;
+    problems;
+    history = new NavigationHistory();
+    holders = new Map();
+    files;
+    pendingCaret = null;
+    lastPlace = null;
+    disposed = false;
+    constructor(service, host = {}) {
+        this.service = service;
+        this.host = host;
+        this.i18n = host.i18n ?? i18next;
+        this.folder = host.folder ?? '';
+        this.files = host.files ?? null;
+        this.problems = new ProjectProblems(service, (uri) => this.pathOfLocation(uri) ?? uri);
+    }
+    pathOfLocation(uri) {
+        if (this.host.pathOfUri !== undefined) {
+            return this.host.pathOfUri(uri);
+        }
+        const path = fileUriToPath(uri);
+        return path !== null && this.folder !== '' && path.startsWith(`${this.folder}/`) ? path.slice(this.folder.length + 1) : path;
+    }
+    /* Makes an edit of a language server: an open document takes it as one undo step and any other file gets an unsaved draft. */
+    applyWorkspaceEdit(edit) {
+        return applyWorkspaceEdit(edit, { editorOf: (uri) => this.holders.get(uri)?.editors[0], files: this.files });
+    }
+    /* The text of a file as it stands now: an open document's, else a draft's or the machine's; null when it is no text file. */
+    async readText(uri) {
+        const open = this.holders.get(uri)?.sync.text;
+        if (open !== undefined) {
+            return open;
+        }
+        const path = fileUriToPath(uri);
+        return path === null || this.files === null ? null : ((await this.files.read(path))?.text ?? null);
+    }
+    /*
+     * Opens the file of a place on its line. A file opens on a line only, so the column is kept here until the editor
+     * that shows the line asks for it with `takeCaret`.
+     */
+    openPlace(place) {
+        this.pendingCaret = place;
+        this.host.openPlace?.(place);
+    }
+    /* Where an editor's caret stands now, so a jump from a surface without an editor, such as the Problems panel, still knows what it left. */
+    noteCaret(place) {
+        this.lastPlace = place;
+    }
+    /* Opens a place from outside any editor and remembers the caret that was last seen. */
+    jumpTo(place) {
+        if (this.lastPlace !== null) {
+            this.history.record(this.lastPlace);
+        }
+        this.openPlace(place);
+    }
+    /* The column an opened place waits for, once the editor of its file has put its caret on the line; each place is asked for once. */
+    takeCaret(uri, line) {
+        const pending = this.pendingCaret;
+        if (pending === null || pending.uri !== uri || pending.position.line !== line) {
+            return null;
+        }
+        this.pendingCaret = null;
+        return pending.position;
+    }
+    /* Opens `uri` for the editor, or joins the editors that already hold it. */
+    acquire(uri, languageId, editor) {
+        if (this.disposed) {
+            throw new Error('The project language is disposed');
+        }
+        let holder = this.holders.get(uri);
+        if (holder === undefined) {
+            holder = { editors: [], sync: new DocumentSync(this.service, uri, languageId, editor), languageId };
+            this.holders.set(uri, holder);
+        }
+        holder.editors.push(editor);
+        let released = false;
+        return {
+            uri,
+            service: this.service,
+            get ready() {
+                return holder.sync.ready;
+            },
+            release: () => {
+                if (!released) {
+                    released = true;
+                    this.release(uri, editor);
+                }
+            }
+        };
+    }
+    release(uri, editor) {
+        const holder = this.holders.get(uri);
+        if (holder === undefined) {
+            return;
+        }
+        holder.editors.splice(holder.editors.indexOf(editor), 1);
+        const next = holder.editors[0];
+        if (next === undefined) {
+            holder.sync.dispose();
+            this.holders.delete(uri);
+            void holder.sync.ready
+                .catch(() => undefined)
+                .then(() => {
+                if (!this.holders.has(uri)) {
+                    return this.service.closeDocument(uri);
+                }
+            })
+                .catch(() => undefined);
+        }
+        else if (holder.sync.editor === editor) {
+            // The editor that sent the changes is gone; the next one takes over and opens the document with its own text.
+            holder.sync.dispose();
+            holder.sync = new DocumentSync(this.service, uri, holder.languageId, next);
+        }
+    }
+    dispose() {
+        if (this.disposed) {
+            return;
+        }
+        this.disposed = true;
+        for (const [uri, holder] of this.holders) {
+            holder.sync.dispose();
+            void holder.sync.ready
+                .catch(() => undefined)
+                .then(() => this.service.closeDocument(uri))
+                .catch(() => undefined);
+        }
+        this.holders.clear();
+        this.problems.dispose();
+    }
+}

package/dist/project-problems.d.ts

@@ -0,0 +1,24 @@
+import type { Diagnostic } from '@adecore/lsp';
+import type { LanguageService } from '@adecore/lsp';
+import type { ProblemCounts } from './diagnostics.ts';
+export interface ProblemRow {
+    readonly diagnostic: Diagnostic;
+    readonly server: string;
+}
+export interface ProblemFile {
+    readonly path: string;
+    readonly rows: readonly ProblemRow[];
+}
+export declare function compareRows(left: ProblemRow, right: ProblemRow): number;
+export declare class ProjectProblems {
+    private readonly reports;
+    private readonly listeners;
+    private readonly stop;
+    private snapshot;
+    constructor(service: LanguageService, pathOf?: (uri: string) => string);
+    report(path: string, server: string, diagnostics: readonly Diagnostic[]): void;
+    getSnapshot: () => readonly ProblemFile[];
+    subscribe: (listener: () => void) => (() => void);
+    dispose(): void;
+}
+export declare function countsOf(files: readonly ProblemFile[]): ProblemCounts;

package/dist/project-problems.js

@@ -0,0 +1,63 @@
+import { comparePositions, severityOf } from './diagnostics-model.js';
+const SEVERITY_ORDER = { error: 0, warning: 1, info: 2, hint: 3 };
+/* Worst first, then in the order of the file. */
+export function compareRows(left, right) {
+    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 {
+    reports = new Map();
+    listeners = new Set();
+    stop;
+    snapshot = [];
+    constructor(service, pathOf = (uri) => uri) {
+        const subscription = service.onDiagnostics((report) => this.report(pathOf(report.uri), report.source, report.diagnostics));
+        this.stop = () => subscription.dispose();
+    }
+    report(path, server, diagnostics) {
+        const kept = diagnostics.filter((diagnostic) => severityOf(diagnostic) !== 'hint');
+        const servers = this.reports.get(path) ?? new Map();
+        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]) => ({
+            path: file,
+            rows: [...byServer].flatMap(([name, list]) => list.map((diagnostic) => ({ 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 = () => this.snapshot;
+    subscribe = (listener) => {
+        this.listeners.add(listener);
+        return () => {
+            this.listeners.delete(listener);
+        };
+    };
+    dispose() {
+        this.stop();
+        this.listeners.clear();
+    }
+}
+export function countsOf(files) {
+    const rows = files.flatMap((file) => file.rows);
+    const count = (severity) => rows.filter((row) => (row.diagnostic.severity ?? 1) === severity).length;
+    return { error: count(1), warning: count(2), info: count(3) };
+}

package/dist/proposal-model.d.ts

@@ -0,0 +1,36 @@
+import type { EditorPosition, EditorRange } from '@adecore/editor';
+export interface LineSpan {
+    readonly startLine: number;
+    readonly endLine: number;
+}
+export declare function lineSpanOf(range: EditorRange): LineSpan;
+export declare function isEmptyRange(range: EditorRange): boolean;
+export declare function inlineRangeOf(selection: EditorRange, lineLength: (line: number) => number): EditorRange;
+export interface InlineProblem {
+    readonly line: number;
+    readonly severity: 'error' | 'warning' | 'info' | 'hint';
+    readonly message: string;
+    readonly code: string;
+}
+export declare function problemsOnLines<T extends {
+    range: EditorRange;
+}>(diagnostics: readonly T[], span: LineSpan, describe: (diagnostic: T) => Omit<InlineProblem, 'line'>): InlineProblem[];
+export interface InlineAnswer {
+    readonly replacement: string | null;
+    readonly rest: string;
+}
+export declare function parseAnswer(text: string): InlineAnswer;
+export declare function fitReplacement(selected: string, replacement: string): string;
+export declare function endOfInsertion(start: EditorPosition, text: string): EditorPosition;
+export interface DiffSegment {
+    readonly kind: 'same' | 'added' | 'removed';
+    readonly text: string;
+    readonly firstLine?: number;
+    readonly replaces?: string;
+}
+export declare function diffSegments(selected: string, proposal: string, startLine: number): DiffSegment[];
+export declare function emphasisOf(segment: DiffSegment): Array<Array<[number, number]>> | undefined;
+export declare function offsetOf(text: string, position: EditorPosition): number | null;
+export declare function textInRange(text: string, range: EditorRange): string | null;
+export declare function replaceRange(text: string, range: EditorRange, replacement: string): string | null;
+export declare function locateSelection(text: string, range: EditorRange, selected: string): EditorRange | null;