@adecore/editor-react 0.23.1 → 0.24.1

package/src/editor-language.ts

@@ -1,5 +1,5 @@
 import { KEYMAP, type Keymap } from '@adecore/editor/keymap';
-import type { Editor, EditorPosition } from '@adecore/editor';
+import type { Editor, EditorKeyHandler, EditorPosition } from '@adecore/editor';
 import type { Location } from '@adecore/lsp';
 import { CallHierarchyFeature } from './call-hierarchy.ts';
 import { CodeActionsFeature } from './code-actions.ts';
@@ -13,6 +13,7 @@ import { FormatOnTypeFeature } from './format-on-type.ts';
 import { HighlightsFeature } from './highlights.ts';
 import { HistoryFeature } from './history.ts';
 import { HoverFeature } from './hover.ts';
+import { KeyDispatcher } from './key-priority.ts';
 import { NavigationFeature, locationRow } from './navigation.ts';
 import { PeekFeature } from './peek.ts';
 import { PickFeature } from './pick.ts';
@@ -73,6 +74,7 @@ export class EditorLanguage {
     readonly formatOnType: FormatOnTypeFeature;
     readonly renderedDocs: RenderedDocsFeature;
     private readonly disposers: Array<() => void> = [];
+    private readonly keys = new KeyDispatcher();
     private disposed = false;
 
     constructor(project: ProjectLanguage, editor: Editor, uri: string, languageId: string, timers: Timers = realTimers, options: EditorLanguageOptions = {}) {
@@ -83,6 +85,7 @@ export class EditorLanguage {
         this.project = project;
         this.languageId = languageId;
         this.document = project.acquire(uri, languageId, editor);
+        this.onDispose(editor.onKeyDown((event) => this.keys.dispatch(event)));
         this.pick = new PickFeature(this, timers);
         this.diagnostics = new DiagnosticsFeature(this);
         this.hover = new HoverFeature(this, timers);
@@ -177,6 +180,14 @@ export class EditorLanguage {
         };
     }
 
+    /*
+     * Lets `handler` see the editor's keys before every handler of a lower `priority`, the first to take a key
+     * winning. `KEY_PRIORITY` holds the features'; the default, 0, comes after all of them.
+     */
+    onKey(handler: EditorKeyHandler, priority = 0): () => void {
+        return this.keys.add(handler, priority);
+    }
+
     /* Runs `dispose` when the editor lets go of its document. */
     onDispose(dispose: () => void): void {
         this.disposers.push(dispose);

package/src/format-on-type.ts

@@ -26,12 +26,11 @@ function overlaps(edits: readonly TextEdit[]): boolean {
  * second caret, a read-only editor or a snippet session, whose tab stops an edit could move. An answer is applied
  * only while the text is exactly what it was asked about, and the caret where it was.
  *
- * The edits join the undo step of the typed character, so one undo takes both back. On by default where the server offers it; `configure(false)`
- * turns it off for a host that has a setting for it.
+ * The edits join the undo step of the typed character, so one undo takes both back. Off by default; a host enables it explicitly with `configure(true)`.
  */
 export class FormatOnTypeFeature {
     private readonly language: EditorLanguage;
-    private enabled = true;
+    private enabled = false;
     /* Raised by every change of the text, so an answer for an older text is told from the one for the text that is. */
     private revision = 0;
     private controller = new AbortController();

package/src/highlights.ts

@@ -1,4 +1,5 @@
 import type { DocumentHighlight } from '@adecore/lsp';
+import { KEY_PRIORITY } from './key-priority.ts';
 import type { EditorHighlight, EditorHighlightKind, EditorPosition, EditorRange } from '@adecore/editor';
 import { comparePositions, rangeHolds } from './diagnostics-model.ts';
 import { isIdentifierCharacter } from './completion-model.ts';
@@ -70,13 +71,13 @@ export class HighlightsFeature {
                 this.current = [];
                 this.refresher.later();
             }),
-            editor.onKeyDown((event) => {
+            language.onKey((event) => {
                 const next = isShortcut(this.language.shortcuts.nextHighlight, event);
                 if (!next && !isShortcut(this.language.shortcuts.previousHighlight, event)) {
                     return false;
                 }
                 return this.step(next ? 1 : -1);
-            })
+            }, KEY_PRIORITY.highlights)
         ];
         language.onDispose(() => {
             for (const off of offs) {

package/src/history.ts

@@ -1,4 +1,5 @@
 import type { EditorLanguage } from './editor-language.ts';
+import { KEY_PRIORITY } from './key-priority.ts';
 import type { Place } from './navigation-history.ts';
 import { isShortcut } from './shortcut-keys.ts';
 
@@ -8,7 +9,7 @@ export class HistoryFeature {
 
     constructor(language: EditorLanguage) {
         this.language = language;
-        const off = language.editor.onKeyDown((event) => {
+        const off = language.onKey((event) => {
             if (isShortcut(this.language.shortcuts.historyBack, event)) {
                 this.back();
                 return true;
@@ -22,7 +23,7 @@ export class HistoryFeature {
                 return true;
             }
             return false;
-        });
+        }, KEY_PRIORITY.history);
         language.onDispose(off);
     }
 

package/src/holder.ts

@@ -1,15 +1,16 @@
-export function createHolder<T>() {
+/* One value that an effect sets and a render reads through `useSyncExternalStore`, without a state update inside the effect. */
+export function createHolder<T>(): { get(): T | null; set(value: T | null): void; subscribe(listener: () => void): () => void } {
     let value: T | null = null;
     const listeners = new Set<() => void>();
     return {
         get: () => value,
-        set: (next: T | null) => {
+        set: (next) => {
             value = next;
-            for (const listener of listeners) {
+            for (const listener of [...listeners]) {
                 listener();
             }
         },
-        subscribe: (listener: () => void) => {
+        subscribe: (listener) => {
             listeners.add(listener);
             return () => {
                 listeners.delete(listener);

package/src/host-types.ts

@@ -4,6 +4,7 @@ import type { i18n } from 'i18next';
 import type { Keymap } from '@adecore/editor/keymap';
 import type { ProjectFiles } from './workspace-edit.ts';
 import type { Place } from './navigation-history.ts';
+import type { ProblemSource } from './project-problems.ts';
 
 export interface DiskText {
     text: string;
@@ -35,6 +36,8 @@ export interface RenameSuggestionsRequest {
     uri: string;
     languageId: string;
     name: string;
+    /* What the name belongs to, in words (`function`, `class`, `type parameter`), when the outline of the file lists it. */
+    kind?: string;
     context: string;
     uses: readonly string[];
 }
@@ -65,6 +68,8 @@ export interface LanguageHost {
     readonly panelBodyHeight?: number;
     /* A person finished resizing a peek or call hierarchy panel; the height is already within what the editor allows. */
     onPanelResize?(height: number): void;
+    /* Where `project.problems` reads its reports, such as a machine that also reports files no editor here holds; the service's diagnostics without one. */
+    readonly problemSource?: ProblemSource;
     openPlace?(place: Place): void;
     pathOfUri?(uri: string): string | null;
     serverNames?(uri: string): readonly string[];

package/src/hover.ts

@@ -1,4 +1,5 @@
 import type { EditorHover, EditorPosition, EditorRange } from '@adecore/editor';
+import { KEY_PRIORITY } from './key-priority.ts';
 import type { EditorLanguage } from './editor-language.ts';
 import { rangeHolds, type Problem } from './diagnostics-model.ts';
 import { hoverTextOf, isEmptyHover, locationsOf, type HoverText } from './hover-content.ts';
@@ -14,6 +15,11 @@ const HIDE_DELAY_MS = 250;
 const COUNT_DELAY_MS = 500;
 const TOAST_ID = 'language-hover';
 
+export interface HoverSettings {
+    /* Counts the references of the symbol on a card that stays up, which can be a search over the whole project; on unless false. */
+    readonly referenceCount?: boolean;
+}
+
 /*
  * The card under a character the pointer rests on: the problems there, and what the language servers
  * say about the symbol. It opens after the pointer has stayed a moment, stays while the pointer is on
@@ -28,6 +34,7 @@ export class HoverFeature {
     private hideTimer: unknown;
     private countTimer: unknown;
     private inCard = false;
+    private referenceCount = true;
     /* Counts every request, so an answer that arrives after the pointer moved on is dropped. */
     private request = 0;
     private lookup: AbortController | null = null;
@@ -62,17 +69,17 @@ export class HoverFeature {
                     this.hide();
                 }
             }),
-            editor.onKeyDown((event) => {
+            language.onKey((event) => {
                 if (isShortcut(this.language.shortcuts.quickInfo, event)) {
                     this.quickInfo();
                     return true;
                 }
-                if (event.key === 'Escape' && this.language.popups.getState().hover !== null && this.language.popups.getState().callHierarchy == null) {
+                if (event.key === 'Escape' && this.language.popups.getState().hover !== null && this.language.popups.getState().callHierarchy === null) {
                     this.hide();
                     return true;
                 }
                 return false;
-            })
+            }, KEY_PRIORITY.hover)
         ];
         language.onDispose(() => {
             for (const off of offs) {
@@ -82,6 +89,13 @@ export class HoverFeature {
         });
     }
 
+    configure(settings: HoverSettings): void {
+        this.referenceCount = settings.referenceCount !== false;
+        if (!this.referenceCount) {
+            this.timers.clear(this.countTimer);
+        }
+    }
+
     /* The pointer entered or left the card, which is where a link in it is clicked. */
     holdCard(inside: boolean): void {
         this.inCard = inside;
@@ -236,7 +250,7 @@ export class HoverFeature {
         }
         this.pinned = pinned;
         this.present(position, problems, info, problems[0]?.diagnostic.range ?? range);
-        if (info !== null) {
+        if (info !== null && this.referenceCount) {
             this.scheduleCount(position, request, controller.signal);
         }
     }
@@ -270,7 +284,7 @@ export class HoverFeature {
     /* How many places use the symbol, which can take a while in a large project and so arrives after the card does. */
     private async count(position: EditorPosition, key: string, request: number, signal: AbortSignal): Promise<void> {
         const { service } = this.language.project;
-        if (request !== this.request || !service.supports('textDocument/references', this.language.uri)) {
+        if (request !== this.request || !this.referenceCount || !service.supports('textDocument/references', this.language.uri)) {
             return;
         }
         const found = await service.references(this.language.uri, position, false, { signal }).catch(() => null);

package/src/index.ts

@@ -1,4 +1,6 @@
 export { EditorLanguage, type EditorLanguageOptions } from './editor-language.ts';
+export { KEY_PRIORITY } from './key-priority.ts';
+export { realTimers, type Timers } from './timers.ts';
 export { DEFAULT_RANGE_LINES, DEFAULT_RANGE_CHARACTERS, type SemanticTokensOptions } from './semantic-tokens.ts';
 export { ProjectLanguage, type FileOperationTarget } from './project-language.ts';
 export type { LanguageDocumentHandle } from './project-language.ts';
@@ -15,6 +17,7 @@ export { EditorView } from './EditorView.tsx';
 export { createHolder } from './holder.ts';
 export type { EditorViewProps } from './EditorView.tsx';
 export { LanguagePopups } from './LanguagePopups.tsx';
+export type { LanguagePopupsProps } from './LanguagePopups.tsx';
 export { AnchoredPopup } from './AnchoredPopup.tsx';
 export { HoverCard } from './HoverCard.tsx';
 export { CompletionPopup } from './CompletionPopup.tsx';
@@ -36,13 +39,14 @@ export type { EditorRendering } from './rendering-context.ts';
 export { FindReplace } from './FindReplace.tsx';
 export { ChangeReview } from './ChangeReview.tsx';
 export type { ChangeReviewProps } from './ChangeReview.tsx';
-export { ProjectProblems, countsOf, compareRows } from './project-problems.ts';
-export type { ProblemFile, ProblemRow } from './project-problems.ts';
+export { ProjectProblems, serviceProblems, countsOf, compareRows } from './project-problems.ts';
+export type { ProblemFile, ProblemRow, ProblemReport, ProblemSource } from './project-problems.ts';
 export { applyWorkspaceEdit, supportedResourceOperations } from './workspace-edit.ts';
 export type { ProjectFiles, StagedFile, WorkspaceEditHost } from './workspace-edit.ts';
 export { useProblemCounts } from './use-problem-counts.ts';
 export type { ProblemCounts } from './diagnostics.ts';
 export type { BlameSource, CodeVisionSettings } from './code-vision.ts';
+export type { HoverSettings } from './hover.ts';
 export type { Problem } from './diagnostics-model.ts';
 export type {
     PopupState,

package/src/key-priority.ts

@@ -0,0 +1,49 @@
+import type { EditorKeyHandler } from '@adecore/editor';
+
+/*
+ * Where each feature of an editor sees a key through `EditorLanguage.onKey`, the highest first. A hundred
+ * apart, so a handler of the app can stand between two features; 0, the default, comes after all of them.
+ */
+export const KEY_PRIORITY = {
+    pick: 1500,
+    diagnostics: 1400,
+    hover: 1300,
+    completion: 1200,
+    snippets: 1100,
+    signature: 1000,
+    highlights: 900,
+    codeActions: 800,
+    rename: 700,
+    navigation: 600,
+    peek: 500,
+    callHierarchy: 400,
+    symbolPicker: 300,
+    history: 200,
+    renderedDocs: 100
+} as const;
+
+interface Entry {
+    readonly handler: EditorKeyHandler;
+    readonly priority: number;
+}
+
+/* Hands a key to its handlers by priority until one takes it; of two of the same priority the one added first. */
+export class KeyDispatcher {
+    private readonly entries: Entry[] = [];
+
+    add(handler: EditorKeyHandler, priority: number): () => void {
+        const entry = { handler, priority };
+        const index = this.entries.findIndex((other) => other.priority < priority);
+        this.entries.splice(index === -1 ? this.entries.length : index, 0, entry);
+        return () => {
+            const at = this.entries.indexOf(entry);
+            if (at !== -1) {
+                this.entries.splice(at, 1);
+            }
+        };
+    }
+
+    dispatch(event: KeyboardEvent): boolean {
+        return [...this.entries].some((entry) => entry.handler(event));
+    }
+}

package/src/locales/en.json

@@ -178,7 +178,8 @@
             "details": "Details",
             "none": "No suggestions",
             "transformBusy": "Snippet transforms are busy; try again",
-            "transformFailed": "Snippet transform could not be applied"
+            "transformFailed": "Snippet transform could not be applied",
+            "failed": "Could not insert the suggestion: {{message}}"
         },
         "history": {
             "recent": "Recent locations"

package/src/locales/nl.json

@@ -178,7 +178,8 @@
             "details": "Details",
             "none": "Geen suggesties",
             "transformBusy": "Snippettransformaties zijn bezig; probeer het opnieuw",
-            "transformFailed": "Snippettransformatie kon niet worden toegepast"
+            "transformFailed": "Snippettransformatie kon niet worden toegepast",
+            "failed": "De suggestie kon niet worden ingevoegd: {{message}}"
         },
         "history": {
             "recent": "Recente plekken"

package/src/models.ts

@@ -37,6 +37,7 @@ export {
     markerOf,
     comparePositions,
     shiftPosition,
+    endOfInsertion,
     shiftRange,
     rangeHolds,
     problemsAt,
@@ -159,7 +160,6 @@ export {
     type InlineAnswer,
     parseAnswer,
     fitReplacement,
-    endOfInsertion,
     type DiffSegment,
     diffSegments,
     emphasisOf,

package/src/navigation.ts

@@ -1,4 +1,5 @@
 import { StaleResultError, fileUriToPath, type LanguageService, type Location, type LocationLink, type NavigationResult, type Range } from '@adecore/lsp';
+import { KEY_PRIORITY } from './key-priority.ts';
 import type { EditorPosition } from '@adecore/editor';
 import { basenameOf } from './paths.ts';
 import type { EditorLanguage } from './editor-language.ts';
@@ -76,14 +77,14 @@ export class NavigationFeature {
                 void this.go('definition', click.position);
                 return true;
             }),
-            editor.onKeyDown((event) => {
+            language.onKey((event) => {
                 const found = SHORTCUT_KINDS.find(([, name]) => isShortcut(this.language.shortcuts[name], event));
                 if (found === undefined) {
                     return false;
                 }
                 void this.go(found[0]);
                 return true;
-            })
+            }, KEY_PRIORITY.navigation)
         ];
         language.onDispose(() => {
             for (const off of offs) {

package/src/peek.ts

@@ -1,4 +1,5 @@
 import { StaleResultError, type Location, type Range } from '@adecore/lsp';
+import { KEY_PRIORITY } from './key-priority.ts';
 import type { EditorPosition } from '@adecore/editor';
 import type { EditorLanguage } from './editor-language.ts';
 import { uniquePlaces } from './navigation.ts';
@@ -45,7 +46,7 @@ export class PeekFeature {
         this.timers = timers;
         const { editor } = language;
         const offs = [
-            editor.onKeyDown((event) => {
+            language.onKey((event) => {
                 if (isShortcut(this.language.shortcuts.peekReferences, event)) {
                     void this.open();
                     return true;
@@ -55,7 +56,7 @@ export class PeekFeature {
                     return true;
                 }
                 return this.key(event);
-            }),
+            }, KEY_PRIORITY.peek),
             editor.onTextChange(() => this.close())
         ];
         language.onDispose(() => {

package/src/pick.ts

@@ -1,4 +1,5 @@
 import type { EditorPosition } from '@adecore/editor';
+import { KEY_PRIORITY } from './key-priority.ts';
 import type { EditorLanguage } from './editor-language.ts';
 import type { PickGroup, PickPreview } from './popups.ts';
 import { realTimers, type Timers } from './timers.ts';
@@ -45,7 +46,7 @@ export class PickFeature {
         this.timers = timers;
         const { editor } = language;
         const offs = [
-            editor.onKeyDown((event) => this.key(event)),
+            language.onKey((event) => this.key(event), KEY_PRIORITY.pick),
             editor.onTextChange(() => this.close()),
             editor.onCaret(() => this.close()),
             editor.onBlur(() => this.close())

package/src/popup-focus.ts

@@ -0,0 +1,17 @@
+import type { FocusEvent, MouseEvent } from 'react';
+
+/*
+ * The handlers for a popup list whose rows the keyboard never enters: the text it belongs to keeps the
+ * focus, and the active row is only `aria-activedescendant` or a highlight. Chromium reports that row as
+ * the focused element, so a tool that focuses it before it types would otherwise pull the keys out of the
+ * text. A press on the list moves no focus, and a row that gets it anyway hands it straight back.
+ */
+export function keepFocusOutOfList(focusBack: () => void): {
+    onMouseDown(event: MouseEvent): void;
+    onFocus(event: FocusEvent): void;
+} {
+    return {
+        onMouseDown: (event) => event.preventDefault(),
+        onFocus: () => focusBack()
+    };
+}

package/src/popups.ts

@@ -203,8 +203,7 @@ 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 callHierarchy: CallHierarchyView | null;
     readonly symbols: SymbolsView | null;
     readonly menu: MenuView | null;
     readonly authors: AuthorsView | null;

package/src/project-language.ts

@@ -3,7 +3,7 @@ import i18next, { type i18n } from 'i18next';
 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 { ProjectProblems, serviceProblems } from './project-problems.ts';
 import { applyWorkspaceEdit, type ProjectFiles } from './workspace-edit.ts';
 import type { LanguageHost } from './host-types.ts';
 import { relativeTo } from './paths.ts';
@@ -113,7 +113,7 @@ export class ProjectLanguage {
         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);
+        this.problems = new ProjectProblems(host.problemSource ?? serviceProblems(service, (uri) => this.pathOfLocation(uri) ?? uri));
     }
 
     /* Open panels of other editors of the project follow a resize. */
@@ -254,9 +254,10 @@ export class ProjectLanguage {
             void holder.sync.ready
                 .catch(() => undefined)
                 .then(() => {
-                    if (!this.holders.has(uri)) {
-                        return this.service.closeDocument(uri);
+                    if (this.holders.has(uri)) {
+                        return undefined;
                     }
+                    return this.service.closeDocument(uri);
                 })
                 .catch(() => undefined);
         } else if (holder.sync.editor === editor) {

package/src/project-problems.ts

@@ -24,24 +24,51 @@ export function compareRows(left: ProblemRow, right: ProblemRow): number {
     );
 }
 
+/* One report of a file's problems; `path` is a stored path, as `ProblemFile.path` is. */
+export interface ProblemReport {
+    readonly path: string;
+    readonly server: string;
+    readonly diagnostics: readonly Diagnostic[];
+}
+
+/* Hands every report to `listener` until the function it returns runs. */
+export type ProblemSource = (listener: (report: ProblemReport) => void) => () => void;
+
+/* The diagnostics a service reports, by the stored path `pathOf` gives each URI. */
+export function serviceProblems(service: LanguageService, pathOf: (uri: string) => string = (uri) => uri): ProblemSource {
+    return (listener) => {
+        const subscription = service.onDiagnostics((report) => listener({ path: pathOf(report.uri), server: report.source, diagnostics: report.diagnostics }));
+        return () => subscription.dispose();
+    };
+}
+
 /*
  * 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 {
     private readonly reports = new Map<string, Map<string, readonly Diagnostic[]>>();
+    private readonly files = new Map<string, ProblemFile>();
     private readonly listeners = new Set<() => void>();
     private readonly stop: () => void;
-    private snapshot: readonly ProblemFile[] = [];
+    /* The paths of `files` in order; null once a file came or went. */
+    private order: string[] | null = [];
+    /* Made on first read after a report, so a project nobody lists does no sorting. */
+    private snapshot: readonly ProblemFile[] | null = [];
 
-    constructor(service: LanguageService, pathOf: (uri: string) => string = (uri) => uri) {
-        const subscription = service.onDiagnostics((report) => this.report(pathOf(report.uri), report.source, report.diagnostics));
-        this.stop = () => subscription.dispose();
+    /* A service stands for `serviceProblems(service, pathOf)`. */
+    constructor(source: ProblemSource | LanguageService, pathOf?: (uri: string) => string) {
+        const listen = typeof source === 'function' ? source : serviceProblems(source, pathOf);
+        this.stop = listen((report) => this.report(report.path, report.server, report.diagnostics));
     }
 
     report(path: string, server: string, diagnostics: readonly Diagnostic[]): void {
         const kept = diagnostics.filter((diagnostic) => severityOf(diagnostic) !== 'hint');
         const servers = this.reports.get(path) ?? new Map<string, readonly Diagnostic[]>();
+        if (kept.length === 0 && !servers.has(server)) {
+            // A clean file reported clean again, as servers do after every edit.
+            return;
+        }
         if (kept.length === 0) {
             servers.delete(server);
         } else {
@@ -49,22 +76,30 @@ export class ProjectProblems {
         }
         if (servers.size === 0) {
             this.reports.delete(path);
+            this.files.delete(path);
+            this.order = null;
         } else {
+            if (!this.files.has(path)) {
+                this.order = null;
+            }
             this.reports.set(path, servers);
+            const rows = [...servers].flatMap(([name, list]) => list.map((diagnostic): ProblemRow => ({ diagnostic, server: name }))).sort(compareRows);
+            this.files.set(path, { path, rows });
         }
-        this.snapshot = [...this.reports]
-            .map(([file, byServer]): ProblemFile => ({
-                path: file,
-                rows: [...byServer].flatMap(([name, list]) => list.map((diagnostic): ProblemRow => ({ diagnostic, server: name }))).sort(compareRows)
-            }))
-            .sort((left, right) => left.path.localeCompare(right.path));
+        this.snapshot = null;
         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 = (): readonly ProblemFile[] => this.snapshot;
+    getSnapshot = (): readonly ProblemFile[] => {
+        if (this.snapshot === null) {
+            this.order ??= [...this.files.keys()].sort((left, right) => left.localeCompare(right));
+            this.snapshot = this.order.map((path) => this.files.get(path)!);
+        }
+        return this.snapshot;
+    };
 
     subscribe = (listener: () => void): (() => void) => {
         this.listeners.add(listener);

package/src/proposal-model.ts

@@ -139,15 +139,6 @@ export function fitReplacement(selected: string, replacement: string): string {
     return breaks === '\n' ? fitted : fitted.replace(/\n/g, breaks);
 }
 
-/* Where the caret stands after `text` was typed at `start`. */
-export function endOfInsertion(start: EditorPosition, text: string): EditorPosition {
-    const lines = text.split('\n');
-    if (lines.length === 1) {
-        return { line: start.line, character: start.character + text.length };
-    }
-    return { line: start.line + lines.length - 1, character: lines.at(-1)!.length };
-}
-
 /* One stretch of the proposal as the card draws it. */
 export interface DiffSegment {
     readonly kind: 'same' | 'added' | 'removed';