@adecore/editor-react 0.22.1 → 0.23.1

package/src/patch-layout.ts

@@ -0,0 +1,388 @@
+import { parseHunkHeader } from '@adecore/merge';
+
+export type PatchLineRole = 'file-header' | 'hunk-header' | 'context' | 'added' | 'removed' | 'no-newline' | 'binary' | 'other';
+
+export type PatchFileStatus = 'added' | 'deleted' | 'renamed' | 'copied' | 'modified' | 'binary';
+
+/* What a line of a patch is, and the one-based numbers it has in the files; null where the file has no such line. */
+export interface PatchLayoutLine {
+    readonly role: PatchLineRole;
+    readonly old: number | null;
+    readonly new: number | null;
+}
+
+export interface PatchHunkLayout {
+    /* Zero-based line of the `@@` header in the patch text. */
+    readonly line: number;
+    /* As the header says them, `oldStart` and `newStart` one-based. */
+    readonly oldStart: number;
+    readonly oldCount: number;
+    readonly newStart: number;
+    readonly newCount: number;
+    readonly section: string;
+    /* False when the lines under the header no longer add up to its counts, such as after an edit. */
+    readonly consistent: boolean;
+}
+
+export interface PatchFileLayout {
+    /* Null for `/dev/null`, or when the patch does not say. Quotes and prefixes such as `a/` are gone. */
+    readonly oldPath: string | null;
+    readonly newPath: string | null;
+    readonly status: PatchFileStatus;
+    /* Zero-based lines of the section in the patch text, `lastLine` included. */
+    readonly firstLine: number;
+    readonly lastLine: number;
+    readonly added: number;
+    readonly removed: number;
+    readonly hunks: readonly PatchHunkLayout[];
+}
+
+export interface PatchLayout {
+    /* One entry per line of the text, `split('\n')`, up to the limit. */
+    readonly lines: readonly PatchLayoutLine[];
+    readonly files: readonly PatchFileLayout[];
+    /* The text went past a limit: the lines after it have no role and no file. */
+    readonly truncated: boolean;
+}
+
+export interface PatchLimits {
+    /* Lines read before the layout stops; defaults to 50,000. */
+    readonly maxLines?: number;
+    /* Characters read before the layout stops; defaults to 4,000,000. */
+    readonly maxCharacters?: number;
+}
+
+export const DEFAULT_PATCH_LIMITS = { maxLines: 50_000, maxCharacters: 4_000_000 } as const;
+
+const OTHER: PatchLayoutLine = { role: 'other', old: null, new: null };
+const FILE_HEADER: PatchLayoutLine = { role: 'file-header', old: null, new: null };
+const HUNK_HEADER: PatchLayoutLine = { role: 'hunk-header', old: null, new: null };
+const NO_NEWLINE: PatchLayoutLine = { role: 'no-newline', old: null, new: null };
+const BINARY: PatchLayoutLine = { role: 'binary', old: null, new: null };
+
+const GIT_HEADERS =
+    /^(?:index |old mode |new mode |deleted file mode |new file mode |similarity index |dissimilarity index |rename from |rename to |copy from |copy to )/;
+
+type Mutable<T> = { -readonly [K in keyof T]: T[K] };
+
+interface Section {
+    oldPath: string | null;
+    newPath: string | null;
+    git: boolean;
+    /* Whether the `diff --git` line showed `a/X b/Y`, which is the only time `a/` and `b/` are not part of the path. */
+    prefixed: boolean;
+    created: boolean;
+    deleted: boolean;
+    renamed: boolean;
+    copied: boolean;
+    binary: boolean;
+    /* Whether `---` and `+++` named the files, which then beat the `diff --git` line. */
+    named: boolean;
+    firstLine: number;
+    lastLine: number;
+    added: number;
+    removed: number;
+    hunks: Mutable<PatchHunkLayout>[];
+}
+
+/* The hunk lines are being read into, with what its header still promises. */
+interface OpenHunk {
+    layout: Mutable<PatchHunkLayout>;
+    oldLeft: number;
+    newLeft: number;
+    oldNumber: number;
+    newNumber: number;
+}
+
+const ESCAPES: Readonly<Record<string, number>> = { a: 7, b: 8, f: 12, n: 10, r: 13, t: 9, v: 11, '"': 34, '\\': 92 };
+
+/* Reads a path as git writes it: bare, or in quotes with C escapes and octal bytes. */
+function unquote(raw: string): string {
+    if (raw.length < 2 || !raw.startsWith('"') || !raw.endsWith('"')) {
+        return raw;
+    }
+    const bytes: number[] = [];
+    const encoder = new TextEncoder();
+    const body = raw.slice(1, -1);
+    for (let i = 0; i < body.length; i++) {
+        if (body[i] !== '\\') {
+            const point = String.fromCodePoint(body.codePointAt(i)!);
+            bytes.push(...encoder.encode(point));
+            i += point.length - 1;
+            continue;
+        }
+        const octal = /^[0-3][0-7]{2}/.exec(body.slice(i + 1, i + 4));
+        const escaped = ESCAPES[body[i + 1] ?? ''];
+        if (octal !== null) {
+            bytes.push(Number.parseInt(octal[0], 8));
+            i += 3;
+        } else if (escaped !== undefined) {
+            bytes.push(escaped);
+            i++;
+        } else {
+            bytes.push(92);
+        }
+    }
+    return new TextDecoder().decode(new Uint8Array(bytes));
+}
+
+/* The name on a `---`, `+++`, `rename` or `copy` line: a timestamp after a tab goes, and `/dev/null` is no file. */
+function pathOf(raw: string): string | null {
+    const tab = raw.indexOf('\t');
+    const name = unquote(tab === -1 ? raw : raw.slice(0, tab));
+    return name === '/dev/null' ? null : name;
+}
+
+function stripPrefix(path: string | null, prefix: 'a/' | 'b/'): string | null {
+    return path !== null && path.startsWith(prefix) ? path.slice(2) : path;
+}
+
+/* The two names of a `diff --git a/x b/y` line; with spaces in an unquoted name, the split that gives both halves the same name wins. */
+function gitPaths(rest: string): { oldPath: string | null; newPath: string | null; prefixed: boolean } {
+    if (rest.startsWith('"')) {
+        const end = rest.indexOf('" ', 1);
+        if (end !== -1) {
+            const oldName = unquote(rest.slice(0, end + 1));
+            const newName = unquote(rest.slice(end + 2));
+            const prefixed = oldName.startsWith('a/') && newName.startsWith('b/');
+            return prefixed ? { oldPath: oldName.slice(2), newPath: newName.slice(2), prefixed } : { oldPath: oldName, newPath: newName, prefixed };
+        }
+    }
+    const middle = rest.indexOf(' b/');
+    if (rest.startsWith('a/') && middle !== -1) {
+        for (let at = middle; at !== -1; at = rest.indexOf(' b/', at + 1)) {
+            if (rest.slice(2, at) === rest.slice(at + 3)) {
+                return { oldPath: rest.slice(2, at), newPath: rest.slice(at + 3), prefixed: true };
+            }
+        }
+        return { oldPath: rest.slice(2, middle), newPath: unquote(rest.slice(middle + 3)), prefixed: true };
+    }
+    const split = rest.indexOf(' ');
+    return split === -1
+        ? { oldPath: unquote(rest), newPath: null, prefixed: false }
+        : { oldPath: unquote(rest.slice(0, split)), newPath: unquote(rest.slice(split + 1)), prefixed: false };
+}
+
+function emptySection(firstLine: number, git: boolean): Section {
+    return {
+        oldPath: null,
+        newPath: null,
+        git,
+        created: false,
+        deleted: false,
+        renamed: false,
+        copied: false,
+        binary: false,
+        firstLine,
+        lastLine: firstLine,
+        added: 0,
+        removed: 0,
+        hunks: [],
+        named: false,
+        prefixed: false
+    };
+}
+
+function statusOf(section: Section): PatchFileStatus {
+    if (section.binary) {
+        return 'binary';
+    }
+    if (section.created || (!section.git && section.oldPath === null && section.newPath !== null)) {
+        return 'added';
+    }
+    if (section.deleted || (!section.git && section.newPath === null && section.oldPath !== null)) {
+        return 'deleted';
+    }
+    if (section.renamed) {
+        return 'renamed';
+    }
+    return section.copied ? 'copied' : 'modified';
+}
+
+function linesOf(text: string, limits: Required<PatchLimits>): { lines: string[]; truncated: boolean } {
+    const lines: string[] = [];
+    let start = 0;
+    while (lines.length < limits.maxLines && start <= limits.maxCharacters) {
+        const end = text.indexOf('\n', start);
+        if (end === -1) {
+            lines.push(text.slice(start).replace(/\r$/, ''));
+            return { lines, truncated: false };
+        }
+        lines.push(text.slice(start, end).replace(/\r$/, ''));
+        start = end + 1;
+    }
+    // Stopping right after a final newline leaves nothing unread.
+    return { lines, truncated: start < text.length };
+}
+
+/*
+ * What every line of a patch is, with the file numbers of its lines and the files it touches. It reads
+ * git patches and plain `diff -u` output, tolerates a text that was edited so its hunks no longer add up
+ * (the hunk is marked inconsistent and the reading goes on) and never throws. Past the limits it stops
+ * and says so in `truncated`.
+ */
+export function patchLayoutOf(text: string, limits: PatchLimits = {}): PatchLayout {
+    const { lines: source, truncated } = linesOf(text, { ...DEFAULT_PATCH_LIMITS, ...limits });
+    const lines: PatchLayoutLine[] = [];
+    const sections: Section[] = [];
+    let section: Section | undefined;
+    let hunk: OpenHunk | undefined;
+    let binaryData = false;
+    const seal = (): void => {
+        if (hunk !== undefined && (hunk.oldLeft > 0 || hunk.newLeft > 0)) {
+            hunk.layout.consistent = false;
+        }
+        hunk = undefined;
+    };
+    const open = (line: number, git: boolean): Section => {
+        seal();
+        binaryData = false;
+        section = emptySection(line, git);
+        sections.push(section);
+        return section;
+    };
+    // A removed line can read `-- x`, so `---` starts a file only with `+++` under it.
+    const startsFile = (index: number): boolean => source[index]!.startsWith('--- ') && (source[index + 1]?.startsWith('+++ ') ?? false);
+    const push = (line: PatchLayoutLine, index: number): void => {
+        lines.push(line);
+        if (section !== undefined) {
+            section.lastLine = index;
+        }
+    };
+    for (let index = 0; index < source.length; index++) {
+        const line = source[index]!;
+        const remaining = hunk !== undefined && (hunk.oldLeft > 0 || hunk.newLeft > 0);
+        const gitStart = line.startsWith('diff --git ');
+        const header = line.startsWith('@@') ? parseHunkHeader(line) : undefined;
+        const fileStart = startsFile(index) && (!remaining || source[index + 2]?.startsWith('@@') === true);
+        if (remaining && !gitStart && header === undefined && !fileStart) {
+            if (isContent(line) || line === '' || line.startsWith('\\')) {
+                push(contentLine(line, hunk!, section!), index);
+            } else {
+                hunk!.layout.consistent = false;
+                push(OTHER, index);
+            }
+            continue;
+        }
+        if (gitStart) {
+            const created = open(index, true);
+            ({ oldPath: created.oldPath, newPath: created.newPath, prefixed: created.prefixed } = gitPaths(line.slice('diff --git '.length)));
+            push(FILE_HEADER, index);
+            continue;
+        }
+        if (fileStart) {
+            const reuse = section !== undefined && section.git && !section.named && section.hunks.length === 0;
+            const target = reuse ? section! : open(index, false);
+            seal();
+            nameSides(target, line, source[index + 1]!);
+            push(FILE_HEADER, index);
+            push(FILE_HEADER, index + 1);
+            index++;
+            continue;
+        }
+        if (header !== undefined) {
+            seal();
+            const target = section ?? open(index, false);
+            const layout: Mutable<PatchHunkLayout> = { line: index, ...header, consistent: true };
+            target.hunks.push(layout);
+            hunk = { layout, oldLeft: header.oldCount, newLeft: header.newCount, oldNumber: header.oldStart, newNumber: header.newStart };
+            push(HUNK_HEADER, index);
+            continue;
+        }
+        if (section === undefined) {
+            push(OTHER, index);
+        } else if (hunk !== undefined && line.startsWith('\\')) {
+            push(NO_NEWLINE, index);
+        } else if (hunk !== undefined && isContent(line) && line !== '-- ') {
+            // The counts ran out, so a line a person typed below the hunk extends it. The `-- ` of a mail signature does not.
+            hunk.layout.consistent = false;
+            push(contentLine(line, hunk, section), index);
+        } else if (hunk === undefined && section.git && GIT_HEADERS.test(line)) {
+            readGitHeader(section, line);
+            push(FILE_HEADER, index);
+        } else if (/^Binary files .* differ$/.test(line) || line === 'GIT binary patch') {
+            section.binary = true;
+            binaryData = line === 'GIT binary patch';
+            push(BINARY, index);
+        } else if (binaryData && line !== '') {
+            push(BINARY, index);
+        } else if (line === '') {
+            lines.push(OTHER);
+        } else {
+            push(OTHER, index);
+        }
+    }
+    seal();
+    return {
+        lines,
+        truncated,
+        files: sections.map((entry) => ({
+            oldPath: entry.oldPath,
+            newPath: entry.newPath,
+            status: statusOf(entry),
+            firstLine: entry.firstLine,
+            lastLine: entry.lastLine,
+            added: entry.added,
+            removed: entry.removed,
+            hunks: entry.hunks
+        }))
+    };
+}
+
+function isContent(line: string): boolean {
+    return line.startsWith('+') || line.startsWith('-') || line.startsWith(' ');
+}
+
+/* A line under a hunk header; an empty line is a context line whose space an editor trimmed. */
+function contentLine(line: string, hunk: OpenHunk, section: Section): PatchLayoutLine {
+    if (line.startsWith('\\')) {
+        return NO_NEWLINE;
+    }
+    const kind = line.startsWith('+') ? 'added' : line.startsWith('-') ? 'removed' : 'context';
+    const takesOld = kind !== 'added';
+    const takesNew = kind !== 'removed';
+    if ((takesOld && hunk.oldLeft === 0) || (takesNew && hunk.newLeft === 0)) {
+        hunk.layout.consistent = false;
+    }
+    if (kind === 'added') {
+        section.added++;
+    } else if (kind === 'removed') {
+        section.removed++;
+    }
+    const oldNumber = takesOld ? hunk.oldNumber++ : null;
+    const newNumber = takesNew ? hunk.newNumber++ : null;
+    hunk.oldLeft = takesOld ? Math.max(0, hunk.oldLeft - 1) : hunk.oldLeft;
+    hunk.newLeft = takesNew ? Math.max(0, hunk.newLeft - 1) : hunk.newLeft;
+    return { role: kind, old: oldNumber, new: newNumber };
+}
+
+function nameSides(section: Section, oldLine: string, newLine: string): void {
+    const oldName = pathOf(oldLine.slice(4));
+    const newName = pathOf(newLine.slice(4));
+    const prefixed = section.git ? section.prefixed : (oldName?.startsWith('a/') ?? false) && (newName?.startsWith('b/') ?? false);
+    section.oldPath = prefixed ? stripPrefix(oldName, 'a/') : oldName;
+    section.newPath = prefixed ? stripPrefix(newName, 'b/') : newName;
+    section.created ||= oldName === null;
+    section.deleted ||= newName === null;
+    section.named = true;
+}
+
+function readGitHeader(section: Section, line: string): void {
+    if (line.startsWith('new file mode ')) {
+        section.created = true;
+    } else if (line.startsWith('deleted file mode ')) {
+        section.deleted = true;
+    } else if (line.startsWith('rename from ')) {
+        section.renamed = true;
+        section.oldPath = pathOf(line.slice('rename from '.length));
+    } else if (line.startsWith('rename to ')) {
+        section.renamed = true;
+        section.newPath = pathOf(line.slice('rename to '.length));
+    } else if (line.startsWith('copy from ')) {
+        section.copied = true;
+        section.oldPath = pathOf(line.slice('copy from '.length));
+    } else if (line.startsWith('copy to ')) {
+        section.copied = true;
+        section.newPath = pathOf(line.slice('copy to '.length));
+    }
+}

package/src/peek.ts

@@ -6,6 +6,7 @@ import { PEEK_READ_FILES, definitionSnippetOf, peekFilesOf, snippetOf, type Peek
 import type { PeekView } from './popups.ts';
 import { isShortcut } from './shortcut-keys.ts';
 import { messageOf } from './error-message.ts';
+import { realTimers, revealRow, type Timers } from './timers.ts';
 
 const TOAST_ID = 'language-peek';
 /* The block as the panel draws it: a hatched band, the header, eight lines of code and a hatched band, until the editor has measured it. */
@@ -29,6 +30,7 @@ function placeKey(location: Location): string {
  */
 export class PeekFeature {
     private readonly language: EditorLanguage;
+    private readonly timers: Timers;
     private kind: PeekKind = 'references';
     /* The whole declaration of each place of a definition peek, where the server gave it. */
     private targets = new Map<string, Range>();
@@ -38,8 +40,9 @@ export class PeekFeature {
     private line = 0;
     private token = 0;
 
-    constructor(language: EditorLanguage) {
+    constructor(language: EditorLanguage, timers: Timers = realTimers) {
         this.language = language;
+        this.timers = timers;
         const { editor } = language;
         const offs = [
             editor.onKeyDown((event) => {
@@ -126,6 +129,7 @@ export class PeekFeature {
                 ? files[0]!.places[0]!
                 : (files.flatMap((file) => file.places).find((place) => !(place.location.uri === uri && place.line === position.line)) ?? files[0]!.places[0]!);
         this.line = position.line;
+        this.language.callHierarchy.close();
         this.language.popups.setState({ peek: { kind, container: null, files, active: first.id, collapsed: [], count: unique.length, preview: null } });
         this.select(first.id);
         // The editor draws a row once per id, so a peek opened over another needs an id of its own to get a container.
@@ -200,6 +204,7 @@ export class PeekFeature {
         const view = this.language.popups.getState().peek;
         if (view !== null && view.container !== container) {
             this.language.popups.setState({ peek: { ...view, container } });
+            revealRow(this.timers, container);
         }
     }
 

package/src/pick.ts

@@ -12,6 +12,8 @@ export interface PickSpec {
     /* The row the list opens on; the first one without it. */
     readonly active?: string;
     accept(id: string): void;
+    /* A list can hand Tab back to its surrounding workflow after it closes. */
+    onTab?(backwards: boolean): void;
     /*
      * Asked before the list closes on a row. A reason it cannot be taken keeps the list open with the reason
      * under it, the way a rename keeps its input; null lets the list close and `accept` run.
@@ -154,9 +156,18 @@ export class PickFeature {
                 this.activate(this.ids[this.ids.length - 1]!);
                 return true;
             case 'Enter':
-            case 'Tab':
                 this.choose(this.active);
                 return true;
+            case 'Tab': {
+                const spec = this.spec;
+                if (spec.onTab !== undefined) {
+                    this.close();
+                    spec.onTab(event.shiftKey);
+                } else {
+                    this.choose(this.active);
+                }
+                return true;
+            }
             case 'Escape':
                 this.close();
                 return true;

package/src/popups.ts

@@ -4,10 +4,12 @@ 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 { CallDirection, CallRow } from './call-hierarchy-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';
+import type { ResourceOperationView } from './workspace-edit.ts';
 
 /* What a hover card shows for the character under the pointer. */
 export interface HoverView {
@@ -29,6 +31,8 @@ export interface HoverInfo {
     readonly word: string;
     /* How many other places use the symbol, once a server has counted them. */
     readonly references: number | null;
+    /* Only the text: no footer for the definition and the references, which a card made of someone else's words has none of. */
+    readonly plain?: boolean;
 }
 
 /* One line of the suggestions list. */
@@ -132,6 +136,8 @@ export interface RenameView {
     readonly error: string | null;
     readonly name: string;
     readonly files: readonly RenameFileView[];
+    /* The files the rename makes, moves or deletes, listed in the preview next to the lines. */
+    readonly operations?: readonly ResourceOperationView[];
     /* Names the host suggests from how the symbol is used. They fill the input when chosen and never apply by themselves. */
     readonly suggestions: readonly string[];
 }
@@ -150,6 +156,21 @@ export interface PeekView {
     readonly preview: (PeekSnippet & { readonly uri: string }) | null;
 }
 
+/* The callers of a symbol, or the symbols it calls, as a tree between the lines of the file with the code of the active call. */
+export interface CallHierarchyView {
+    readonly direction: CallDirection;
+    /* The row the editor draws it in, which the editor makes again when it scrolls back into view. */
+    readonly container: HTMLElement | null;
+    /* The symbol the hierarchy was opened on. */
+    readonly name: string;
+    readonly rows: readonly CallRow[];
+    readonly active: string;
+    /* The call site of the active row that is shown, from zero, among `sites`. */
+    readonly site: number;
+    readonly sites: number;
+    readonly preview: (PeekSnippet & { readonly uri: string }) | null;
+}
+
 /* The picker that jumps to a symbol of the file, over the symbols the servers know in it. */
 export interface SymbolsView {
     /* The file's name, for the placeholder. */
@@ -182,6 +203,8 @@ export interface PopupState {
     readonly pick: PickView | null;
     readonly rename: RenameView | null;
     readonly peek: PeekView | null;
+    /* Optional so a host that builds a `PopupState` literal from before the call hierarchy still fits; absent reads as closed. */
+    readonly callHierarchy?: CallHierarchyView | null;
     readonly symbols: SymbolsView | null;
     readonly menu: MenuView | null;
     readonly authors: AuthorsView | null;
@@ -197,6 +220,7 @@ export function createPopupStore(): PopupStore {
         pick: null,
         rename: null,
         peek: null,
+        callHierarchy: null,
         symbols: null,
         menu: null,
         authors: null

package/src/project-language.ts

@@ -1,11 +1,13 @@
+import { disposeSnippetTransforms } from './snippet-transform-queue.ts';
 import i18next, { type i18n } from 'i18next';
-import { fileUriToPath, type ApplyWorkspaceEditResult, type ContentChange, type LanguageService, type WorkspaceEdit } from '@adecore/lsp';
+import { fileUriToPath, pathToFileUri, type ApplyWorkspaceEditResult, type ContentChange, 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 { applyWorkspaceEdit, type ProjectFiles } from './workspace-edit.ts';
 import type { LanguageHost } from './host-types.ts';
 import { relativeTo } from './paths.ts';
+import { PANEL_BODY_HEIGHT } from './panel-size.ts';
 
 export interface LanguageDocumentHandle {
     readonly uri: string;
@@ -73,6 +75,17 @@ interface Holder {
     languageId: string;
 }
 
+/* A file or folder for a file operation notification: a bare path is a file. */
+export type FileOperationTarget = string | { readonly path: string; readonly directory?: boolean };
+
+function filesOf(targets: readonly FileOperationTarget[]): Array<{ uri: string; directory: boolean }> {
+    return targets.map((target) => {
+        const { path, directory } =
+            typeof target === 'string' ? { path: target, directory: false } : { path: target.path, directory: target.directory === true };
+        return { uri: pathToFileUri(path), directory };
+    });
+}
+
 /*
  * 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.
@@ -86,6 +99,9 @@ export class ProjectLanguage {
     readonly history = new NavigationHistory();
     private readonly holders = new Map<string, Holder>();
     private readonly files: ProjectFiles | null;
+    /* The body height of the peek and call hierarchy panels, shared by the editors of the project. */
+    panelBodyHeight: number;
+    private readonly panelListeners = new Set<(height: number) => void>();
     private pendingCaret: Place | null = null;
     private lastPlace: Place | null = null;
     private disposed = false;
@@ -96,9 +112,25 @@ export class ProjectLanguage {
         this.i18n = host.i18n ?? i18next;
         this.folder = host.folder ?? '';
         this.files = host.files ?? null;
+        this.panelBodyHeight = host.panelBodyHeight ?? PANEL_BODY_HEIGHT;
         this.problems = new ProjectProblems(service, (uri) => this.pathOfLocation(uri) ?? uri);
     }
 
+    /* Open panels of other editors of the project follow a resize. */
+    onPanelBodyChange(listener: (height: number) => void): () => void {
+        this.panelListeners.add(listener);
+        return () => this.panelListeners.delete(listener);
+    }
+
+    resizePanelBody(height: number): void {
+        if (height === this.panelBodyHeight) {
+            return;
+        }
+        this.panelBodyHeight = height;
+        this.panelListeners.forEach((listener) => listener(height));
+        this.host.onPanelResize?.(height);
+    }
+
     pathOfLocation(uri: string): string | null {
         if (this.host.pathOfUri !== undefined) {
             return this.host.pathOfUri(uri);
@@ -109,7 +141,35 @@ export class ProjectLanguage {
 
     /* 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: WorkspaceEdit): Promise<ApplyWorkspaceEditResult> {
-        return applyWorkspaceEdit(edit, { editorOf: (uri) => this.holders.get(uri)?.editors[0], files: this.files });
+        const { service } = this;
+        return applyWorkspaceEdit(edit, {
+            editorOf: (uri) => this.holders.get(uri)?.editors[0],
+            files: this.files,
+            ...(service.versionOf === undefined ? {} : { versionOf: (uri: string) => service.versionOf!(uri) })
+        });
+    }
+
+    /*
+     * What the servers want changed before files are made, for a host that makes them outside a language server's
+     * edit: apply the edit with `applyWorkspaceEdit`, then make the files. Null when no server has anything to say.
+     */
+    willCreateFiles(targets: readonly FileOperationTarget[]): Promise<WorkspaceEdit | null> {
+        return this.service.willCreateFiles?.(filesOf(targets)) ?? Promise.resolve(null);
+    }
+
+    /* Tells the servers that files were made, once they are. */
+    didCreateFiles(targets: readonly FileOperationTarget[]): Promise<void> {
+        return this.service.didCreateFiles?.(filesOf(targets)) ?? Promise.resolve();
+    }
+
+    /* What the servers want changed before files are deleted, such as the references to them; null when no server has anything to say. */
+    willDeleteFiles(targets: readonly FileOperationTarget[]): Promise<WorkspaceEdit | null> {
+        return this.service.willDeleteFiles?.(filesOf(targets)) ?? Promise.resolve(null);
+    }
+
+    /* Tells the servers that files were deleted, once they are. */
+    didDeleteFiles(targets: readonly FileOperationTarget[]): Promise<void> {
+        return this.service.didDeleteFiles?.(filesOf(targets)) ?? Promise.resolve();
     }
 
     /* 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. */
@@ -211,6 +271,7 @@ export class ProjectLanguage {
             return;
         }
         this.disposed = true;
+        disposeSnippetTransforms(this);
         for (const [uri, holder] of this.holders) {
             holder.sync.dispose();
             void holder.sync.ready

package/src/refresher.ts

@@ -41,6 +41,12 @@ export class Refresher {
         });
     }
 
+    /* Drops the wait and the ask in flight, and keeps the refresher usable. */
+    cancel(): void {
+        this.timers.clear(this.timer);
+        this.controller?.abort();
+    }
+
     dispose(): void {
         this.disposed = true;
         this.timers.clear(this.timer);

package/src/rename-model.ts

@@ -1,7 +1,7 @@
 import type { EditorPosition, EditorRange } from '@adecore/editor';
 import type { Location, PrepareRenameResult, TextEdit, WorkspaceEdit } from '@adecore/lsp';
 import { isIdentifierCharacter } from './completion-model.ts';
-import { entriesOf } from './workspace-edit.ts';
+import { textEntriesOf } from './workspace-edit.ts';
 
 /* The identifier the caret is in or touches; null where there is none. */
 export function wordRangeAt(lineText: string, position: EditorPosition): EditorRange | null {
@@ -115,14 +115,10 @@ export function renameRowsOf(text: string, edits: readonly TextEdit[]): RenameRo
         });
 }
 
-/* Resource renames are omitted; create/delete operations refuse the text-only preview with null. */
-export async function renamePreviewOf(edit: WorkspaceEdit, textOf: (uri: string) => Promise<string | null>): Promise<RenameFile[] | null> {
-    const entries = entriesOf(edit);
-    if (entries === null) {
-        return null;
-    }
+/* The lines of the files an edit edits; the files it makes, moves or deletes are listed by `resourceOperationsOf`. */
+export async function renamePreviewOf(edit: WorkspaceEdit, textOf: (uri: string) => Promise<string | null>): Promise<RenameFile[]> {
     const files: RenameFile[] = [];
-    for (const [uri, list] of entries) {
+    for (const [uri, list] of textEntriesOf(edit)) {
         const text = await textOf(uri);
         files.push({ uri, rows: text === null ? [] : renameRowsOf(text, list.flat()) });
     }