@adecore/editor-react 0.22.1 → 0.23.1

package/dist/patch-layout.js

@@ -0,0 +1,304 @@
+import { parseHunkHeader } from '@adecore/merge';
+export const DEFAULT_PATCH_LIMITS = { maxLines: 50_000, maxCharacters: 4_000_000 };
+const OTHER = { role: 'other', old: null, new: null };
+const FILE_HEADER = { role: 'file-header', old: null, new: null };
+const HUNK_HEADER = { role: 'hunk-header', old: null, new: null };
+const NO_NEWLINE = { role: 'no-newline', old: null, new: null };
+const BINARY = { 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 )/;
+const ESCAPES = { 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) {
+    if (raw.length < 2 || !raw.startsWith('"') || !raw.endsWith('"')) {
+        return raw;
+    }
+    const bytes = [];
+    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) {
+    const tab = raw.indexOf('\t');
+    const name = unquote(tab === -1 ? raw : raw.slice(0, tab));
+    return name === '/dev/null' ? null : name;
+}
+function stripPrefix(path, prefix) {
+    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) {
+    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, git) {
+    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) {
+    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, limits) {
+    const lines = [];
+    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, limits = {}) {
+    const { lines: source, truncated } = linesOf(text, { ...DEFAULT_PATCH_LIMITS, ...limits });
+    const lines = [];
+    const sections = [];
+    let section;
+    let hunk;
+    let binaryData = false;
+    const seal = () => {
+        if (hunk !== undefined && (hunk.oldLeft > 0 || hunk.newLeft > 0)) {
+            hunk.layout.consistent = false;
+        }
+        hunk = undefined;
+    };
+    const open = (line, git) => {
+        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) => source[index].startsWith('--- ') && (source[index + 1]?.startsWith('+++ ') ?? false);
+    const push = (line, index) => {
+        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 = { 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) {
+    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, hunk, section) {
+    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, oldLine, newLine) {
+    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, line) {
+    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/dist/peek.d.ts

@@ -1,10 +1,12 @@
 import type { EditorPosition } from '@adecore/editor';
 import type { EditorLanguage } from './editor-language.ts';
 import type { PeekView } from './popups.ts';
+import { type Timers } from './timers.ts';
 export declare const PEEK_HEIGHT = 241;
 type PeekKind = PeekView['kind'];
 export declare class PeekFeature {
     private readonly language;
+    private readonly timers;
     private kind;
     private targets;
     private texts;
@@ -12,7 +14,7 @@ export declare class PeekFeature {
     private order;
     private line;
     private token;
-    constructor(language: EditorLanguage);
+    constructor(language: EditorLanguage, timers?: Timers);
     get isOpen(): boolean;
     open(position?: EditorPosition, kind?: PeekKind): Promise<void>;
     openDefinition(position?: EditorPosition): Promise<void>;

package/dist/peek.js

@@ -3,6 +3,7 @@ import { uniquePlaces } from './navigation.js';
 import { PEEK_READ_FILES, definitionSnippetOf, peekFilesOf, snippetOf } from './peek-model.js';
 import { isShortcut } from './shortcut-keys.js';
 import { messageOf } from './error-message.js';
+import { realTimers, revealRow } from './timers.js';
 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. */
 export const PEEK_HEIGHT = 241;
@@ -20,6 +21,7 @@ function placeKey(location) {
  */
 export class PeekFeature {
     language;
+    timers;
     kind = 'references';
     /* The whole declaration of each place of a definition peek, where the server gave it. */
     targets = new Map();
@@ -28,8 +30,9 @@ export class PeekFeature {
     order = [];
     line = 0;
     token = 0;
-    constructor(language) {
+    constructor(language, timers = realTimers) {
         this.language = language;
+        this.timers = timers;
         const { editor } = language;
         const offs = [
             editor.onKeyDown((event) => {
@@ -112,6 +115,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.
@@ -178,6 +182,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);
         }
     }
     key(event) {

package/dist/pick.d.ts

@@ -8,6 +8,7 @@ export interface PickSpec {
     readonly groups: readonly PickGroup[];
     readonly active?: string;
     accept(id: string): void;
+    onTab?(backwards: boolean): void;
     attempt?(id: string): Promise<string | null>;
     preview?(id: string, signal: AbortSignal): Promise<PickPreview | null>;
 }

package/dist/pick.js

@@ -125,9 +125,19 @@ 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/dist/popups.d.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';
 export interface HoverView {
     readonly anchor: EditorPosition;
     readonly position: EditorPosition;
@@ -20,6 +22,7 @@ export interface HoverInfo {
     readonly definition: Location | null;
     readonly word: string;
     readonly references: number | null;
+    readonly plain?: boolean;
 }
 export interface CompletionRow {
     readonly label: string;
@@ -90,6 +93,7 @@ export interface RenameView {
     readonly error: string | null;
     readonly name: string;
     readonly files: readonly RenameFileView[];
+    readonly operations?: readonly ResourceOperationView[];
     readonly suggestions: readonly string[];
 }
 export interface PeekView {
@@ -103,6 +107,18 @@ export interface PeekView {
         readonly uri: string;
     }) | null;
 }
+export interface CallHierarchyView {
+    readonly direction: CallDirection;
+    readonly container: HTMLElement | null;
+    readonly name: string;
+    readonly rows: readonly CallRow[];
+    readonly active: string;
+    readonly site: number;
+    readonly sites: number;
+    readonly preview: (PeekSnippet & {
+        readonly uri: string;
+    }) | null;
+}
 export interface SymbolsView {
     readonly file: string;
     readonly entries: readonly SymbolEntry[];
@@ -125,6 +141,7 @@ export interface PopupState {
     readonly pick: PickView | null;
     readonly rename: RenameView | null;
     readonly peek: PeekView | null;
+    readonly callHierarchy?: CallHierarchyView | null;
     readonly symbols: SymbolsView | null;
     readonly menu: MenuView | null;
     readonly authors: AuthorsView | null;

package/dist/popups.js

@@ -7,6 +7,7 @@ export function createPopupStore() {
         pick: null,
         rename: null,
         peek: null,
+        callHierarchy: null,
         symbols: null,
         menu: null,
         authors: null

package/dist/project-language.d.ts

@@ -10,6 +10,10 @@ export interface LanguageDocumentHandle {
     readonly ready: Promise<void>;
     release(): void;
 }
+export type FileOperationTarget = string | {
+    readonly path: string;
+    readonly directory?: boolean;
+};
 export declare class ProjectLanguage {
     readonly service: LanguageService;
     readonly host: LanguageHost;
@@ -19,12 +23,20 @@ export declare class ProjectLanguage {
     readonly history: NavigationHistory;
     private readonly holders;
     private readonly files;
+    panelBodyHeight: number;
+    private readonly panelListeners;
     private pendingCaret;
     private lastPlace;
     private disposed;
     constructor(service: LanguageService, host?: LanguageHost);
+    onPanelBodyChange(listener: (height: number) => void): () => void;
+    resizePanelBody(height: number): void;
     pathOfLocation(uri: string): string | null;
     applyWorkspaceEdit(edit: WorkspaceEdit): Promise<ApplyWorkspaceEditResult>;
+    willCreateFiles(targets: readonly FileOperationTarget[]): Promise<WorkspaceEdit | null>;
+    didCreateFiles(targets: readonly FileOperationTarget[]): Promise<void>;
+    willDeleteFiles(targets: readonly FileOperationTarget[]): Promise<WorkspaceEdit | null>;
+    didDeleteFiles(targets: readonly FileOperationTarget[]): Promise<void>;
     readText(uri: string): Promise<string | null>;
     openPlace(place: Place): void;
     noteCaret(place: Place): void;

package/dist/project-language.js

@@ -1,9 +1,11 @@
+import { disposeSnippetTransforms } from './snippet-transform-queue.js';
 import i18next, {} from 'i18next';
-import { fileUriToPath } from '@adecore/lsp';
+import { fileUriToPath, pathToFileUri } from '@adecore/lsp';
 import { NavigationHistory } from './navigation-history.js';
 import { ProjectProblems } from './project-problems.js';
 import { applyWorkspaceEdit } from './workspace-edit.js';
 import { relativeTo } from './paths.js';
+import { PANEL_BODY_HEIGHT } from './panel-size.js';
 /* Sends one editor's edits to the document, holding them until the document is open. */
 class DocumentSync {
     ready;
@@ -51,6 +53,12 @@ class DocumentSync {
         void this.service.changeDocument(this.uri, changes).catch(() => undefined);
     }
 }
+function filesOf(targets) {
+    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.
@@ -64,6 +72,9 @@ export class ProjectLanguage {
     history = new NavigationHistory();
     holders = new Map();
     files;
+    /* The body height of the peek and call hierarchy panels, shared by the editors of the project. */
+    panelBodyHeight;
+    panelListeners = new Set();
     pendingCaret = null;
     lastPlace = null;
     disposed = false;
@@ -73,8 +84,22 @@ 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) {
+        this.panelListeners.add(listener);
+        return () => this.panelListeners.delete(listener);
+    }
+    resizePanelBody(height) {
+        if (height === this.panelBodyHeight) {
+            return;
+        }
+        this.panelBodyHeight = height;
+        this.panelListeners.forEach((listener) => listener(height));
+        this.host.onPanelResize?.(height);
+    }
     pathOfLocation(uri) {
         if (this.host.pathOfUri !== undefined) {
             return this.host.pathOfUri(uri);
@@ -84,7 +109,31 @@ 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) {
-        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) => 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) {
+        return this.service.willCreateFiles?.(filesOf(targets)) ?? Promise.resolve(null);
+    }
+    /* Tells the servers that files were made, once they are. */
+    didCreateFiles(targets) {
+        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) {
+        return this.service.willDeleteFiles?.(filesOf(targets)) ?? Promise.resolve(null);
+    }
+    /* Tells the servers that files were deleted, once they are. */
+    didDeleteFiles(targets) {
+        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. */
     async readText(uri) {
@@ -179,6 +228,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/dist/refresher.d.ts

@@ -9,5 +9,6 @@ export declare class Refresher {
     constructor(run: (signal: AbortSignal) => Promise<void>, delay: number, timers?: Timers);
     later(): void;
     now(): void;
+    cancel(): void;
     dispose(): void;
 }

package/dist/refresher.js

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

package/dist/rename-model.d.ts

@@ -22,4 +22,4 @@ export interface RenameFile {
     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>;
+export declare function renamePreviewOf(edit: WorkspaceEdit, textOf: (uri: string) => Promise<string | null>): Promise<RenameFile[]>;

package/dist/rename-model.js

@@ -1,5 +1,5 @@
 import { isIdentifierCharacter } from './completion-model.js';
-import { entriesOf } from './workspace-edit.js';
+import { textEntriesOf } 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);
@@ -78,14 +78,10 @@ export function renameRowsOf(text, edits) {
         return { line: line + 1, before, after };
     });
 }
-/* Resource renames are omitted; create/delete operations refuse the text-only preview with 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, textOf) {
-    const entries = entriesOf(edit);
-    if (entries === null) {
-        return null;
-    }
     const files = [];
-    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()) });
     }