@adecore/editor-react 0.22.1 → 0.23.1

package/dist/call-hierarchy-model.d.ts

@@ -0,0 +1,52 @@
+import type { CallHierarchyIncomingCall, CallHierarchyItem, CallHierarchyOutgoingCall, Range } from '@adecore/lsp';
+export type CallDirection = 'incoming' | 'outgoing';
+export declare const CALL_LEVEL_LIMIT = 50;
+export type CallLoad = 'idle' | 'loading' | 'loaded' | 'failed';
+export interface CallNode {
+    readonly id: string;
+    readonly parent: string | null;
+    readonly level: number;
+    readonly item: CallHierarchyItem;
+    readonly sites: readonly Range[];
+    readonly siteUri: string | null;
+    readonly expanded: boolean;
+    readonly load: CallLoad;
+    readonly error: string | null;
+    readonly children: readonly string[];
+    readonly shown: number;
+}
+export type CallRow = {
+    readonly kind: 'node';
+    readonly id: string;
+    readonly level: number;
+    readonly item: CallHierarchyItem;
+    readonly expanded: boolean;
+    readonly load: CallLoad;
+    readonly sites: number;
+    readonly leaf: boolean;
+    readonly position: number;
+    readonly size: number;
+} | {
+    readonly kind: 'status';
+    readonly id: string;
+    readonly parent: string;
+    readonly level: number;
+    readonly status: 'loading' | 'empty' | 'failed';
+    readonly message: string | null;
+} | {
+    readonly kind: 'more';
+    readonly id: string;
+    readonly level: number;
+    readonly parent: string;
+    readonly hidden: number;
+};
+export declare function statusIdOf(parent: string): string;
+export declare function moreIdOf(parent: string): string;
+export declare function rootsOf(items: readonly CallHierarchyItem[]): CallNode[];
+export declare function childrenOf(direction: CallDirection, parent: CallNode, calls: readonly (CallHierarchyIncomingCall | CallHierarchyOutgoingCall)[]): CallNode[];
+export declare function rowsOf(nodes: ReadonlyMap<string, CallNode>, roots: readonly string[]): CallRow[];
+export declare function stepsOf(rows: readonly CallRow[]): CallRow[];
+export declare function targetOf(node: CallNode, site?: number): {
+    uri: string;
+    range: Range;
+};

package/dist/call-hierarchy-model.js

@@ -0,0 +1,93 @@
+/* The most calls of one level that are drawn at once; the rest wait behind a row that shows more. */
+export const CALL_LEVEL_LIMIT = 50;
+/* The id of the status line under a node. */
+export function statusIdOf(parent) {
+    return `${parent}:status`;
+}
+/* The id of the line that shows more calls under a node. */
+export function moreIdOf(parent) {
+    return `${parent}:more`;
+}
+/* The tree's roots, each one a symbol the server prepared. */
+export function rootsOf(items) {
+    return items.map((item, index) => ({
+        id: `r${index}`,
+        parent: null,
+        level: 1,
+        item,
+        sites: [],
+        siteUri: null,
+        expanded: true,
+        load: 'idle',
+        error: null,
+        children: [],
+        shown: 0
+    }));
+}
+/*
+ * The children of a node made from the calls a server returned, in the order the server gave them.
+ * The call sites of a caller are in its own file; those of a callee are in the file of the node that was asked about.
+ */
+export function childrenOf(direction, parent, calls) {
+    const entries = calls.map((call) => ({ item: 'from' in call ? call.from : call.to, sites: call.fromRanges }));
+    return entries.map((entry, index) => ({
+        id: `${parent.id}.${index}`,
+        parent: parent.id,
+        level: parent.level + 1,
+        item: entry.item,
+        sites: entry.sites,
+        siteUri: direction === 'incoming' ? entry.item.uri : parent.item.uri,
+        expanded: false,
+        load: 'idle',
+        error: null,
+        children: [],
+        shown: 0
+    }));
+}
+/* The lines the tree draws: every root, and under an expanded node its status, its calls and the row that shows more. */
+export function rowsOf(nodes, roots) {
+    const rows = [];
+    const visit = (id, position, size) => {
+        const node = nodes.get(id);
+        rows.push({
+            kind: 'node',
+            id,
+            level: node.level,
+            item: node.item,
+            expanded: node.expanded,
+            load: node.load,
+            sites: node.sites.length,
+            leaf: node.load === 'loaded' && node.children.length === 0,
+            position,
+            size
+        });
+        if (!node.expanded) {
+            return;
+        }
+        if (node.load === 'loading') {
+            rows.push({ kind: 'status', id: statusIdOf(id), parent: id, level: node.level + 1, status: 'loading', message: null });
+        }
+        else if (node.load === 'failed') {
+            rows.push({ kind: 'status', id: statusIdOf(id), parent: id, level: node.level + 1, status: 'failed', message: node.error });
+        }
+        else if (node.load === 'loaded' && node.children.length === 0) {
+            rows.push({ kind: 'status', id: statusIdOf(id), parent: id, level: node.level + 1, status: 'empty', message: null });
+        }
+        const shown = node.children.slice(0, node.shown);
+        shown.forEach((child, index) => visit(child, index + 1, node.children.length));
+        if (node.children.length > node.shown) {
+            rows.push({ kind: 'more', id: moreIdOf(id), level: node.level + 1, parent: id, hidden: node.children.length - node.shown });
+        }
+    };
+    roots.forEach((root, index) => visit(root, index + 1, roots.length));
+    return rows;
+}
+/* The rows a key can land on: symbols, and the row that shows more. */
+export function stepsOf(rows) {
+    return rows.filter((row) => row.kind !== 'status');
+}
+/* The place a node goes to: its first call site, or the symbol itself for a root. */
+export function targetOf(node, site = 0) {
+    const range = node.sites[site];
+    return range === undefined || node.siteUri === null ? { uri: node.item.uri, range: node.item.selectionRange } : { uri: node.siteUri, range };
+}

package/dist/call-hierarchy.d.ts

@@ -0,0 +1,42 @@
+import type { EditorPosition } from '@adecore/editor';
+import type { EditorLanguage } from './editor-language.ts';
+import { type CallDirection } from './call-hierarchy-model.ts';
+import { type Timers } from './timers.ts';
+export declare const CALL_HIERARCHY_HEIGHT: number;
+export declare class CallHierarchyFeature {
+    private readonly language;
+    private readonly timers;
+    private nodes;
+    private roots;
+    private prepared;
+    private direction;
+    private controller;
+    private epoch;
+    private previewEpoch;
+    private texts;
+    constructor(language: EditorLanguage, timers?: Timers);
+    get isOpen(): boolean;
+    get supported(): boolean;
+    open(position?: EditorPosition, direction?: CallDirection): Promise<void>;
+    close(): void;
+    setDirection(direction: CallDirection): void;
+    toggle(id: string): void;
+    retry(id: string): void;
+    showMore(parent: string): void;
+    select(id: string, site?: number): void;
+    stepSite(direction: 1 | -1): void;
+    go(id: string): void;
+    private reset;
+    private seed;
+    private mounted;
+    private patch;
+    private load;
+    private preview;
+    private hasAncestor;
+    private key;
+    private land;
+    private expandOrEnter;
+    private collapseOrLeave;
+    private tell;
+    private say;
+}

package/dist/call-hierarchy.js

@@ -0,0 +1,398 @@
+import { StaleResultError } from '@adecore/lsp';
+import { CALL_LEVEL_LIMIT, childrenOf, moreIdOf, rootsOf, rowsOf, statusIdOf, stepsOf, targetOf } from './call-hierarchy-model.js';
+import { PEEK_HEIGHT } from './peek.js';
+import { 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-call-hierarchy';
+const PREPARE = 'textDocument/prepareCallHierarchy';
+/* The row the panel stands in is as tall as a peek's, plus the segmented control that is a pixel taller than the peek's title bar. */
+export const CALL_HIERARCHY_HEIGHT = PEEK_HEIGHT + 2;
+const OWNER = 'call-hierarchy';
+/*
+ * The callers of the symbol at the caret, or the symbols it calls, as a tree between the lines of the file
+ * under the line the caret is on, with the code around the call that is active. A node asks the server for its
+ * own calls when it is opened, and a level shows its first calls with a row that brings the others.
+ * The editor keeps the keyboard: arrows move and open, Enter goes to the call, Escape closes, and the
+ * shortcut that opened the tree switches between callers and callees. Typing closes it.
+ */
+export class CallHierarchyFeature {
+    language;
+    timers;
+    nodes = new Map();
+    roots = [];
+    prepared = [];
+    direction = 'incoming';
+    controller = new AbortController();
+    /* Raised whenever the tree starts over or closes, so an answer for the tree that was never lands in the one that is. */
+    epoch = 0;
+    previewEpoch = 0;
+    texts = new Map();
+    constructor(language, timers = realTimers) {
+        this.language = language;
+        this.timers = timers;
+        const { editor } = language;
+        const offs = [
+            editor.onKeyDown((event) => {
+                if (isShortcut(this.language.shortcuts.callHierarchy, event)) {
+                    if (this.isOpen) {
+                        this.setDirection(this.direction === 'incoming' ? 'outgoing' : 'incoming');
+                    }
+                    else {
+                        void this.open();
+                    }
+                    return true;
+                }
+                return this.key(event);
+            }),
+            editor.onTextChange(() => this.close())
+        ];
+        language.onDispose(() => {
+            for (const off of offs) {
+                off();
+            }
+            this.close();
+        });
+    }
+    get isOpen() {
+        return (this.language.popups.getState().callHierarchy ?? null) !== null;
+    }
+    /* Whether a server of this document answers the three requests the tree is made of. */
+    get supported() {
+        const { project, uri } = this.language;
+        const { service } = project;
+        return (service.prepareCallHierarchy !== undefined &&
+            service.incomingCalls !== undefined &&
+            service.outgoingCalls !== undefined &&
+            service.supports(PREPARE, uri));
+    }
+    /* Opens the tree for the symbol at the position, on its callers unless told otherwise. */
+    async open(position = this.language.editor.getCaret(), direction = 'incoming') {
+        const { editor, project, uri } = this.language;
+        if (!this.supported) {
+            this.tell(this.say('unavailable'));
+            return;
+        }
+        this.close();
+        const epoch = this.epoch;
+        let items;
+        try {
+            items = await project.service.prepareCallHierarchy(uri, position, { signal: this.controller.signal });
+        }
+        catch (error) {
+            if (epoch === this.epoch && !(error instanceof StaleResultError)) {
+                this.tell(this.say('failed', { message: messageOf(error) }));
+            }
+            return;
+        }
+        if (epoch !== this.epoch) {
+            return;
+        }
+        if (items === null || items.length === 0) {
+            this.tell(this.say('none'));
+            return;
+        }
+        this.language.peek.close();
+        this.prepared = items;
+        this.direction = direction;
+        this.seed();
+        const active = this.roots[0];
+        this.language.popups.setState({
+            callHierarchy: { direction, container: null, name: items[0].name, rows: rowsOf(this.nodes, this.roots), active, site: 0, sites: 0, preview: null }
+        });
+        this.select(active);
+        // The editor draws a row once per id, so a tree opened over another needs an id of its own to get a container.
+        editor.setWidgets([{ id: `call-hierarchy-${epoch}`, line: position.line, height: CALL_HIERARCHY_HEIGHT, render: (container) => this.mounted(container) }], OWNER);
+        editor.focus();
+        for (const root of this.roots) {
+            void this.load(root);
+        }
+    }
+    close() {
+        this.reset();
+        if (this.language.popups.getState().callHierarchy == null) {
+            return;
+        }
+        this.language.popups.setState({ callHierarchy: null });
+        this.language.editor.setWidgets([], OWNER);
+        this.language.editor.setInputPopup(null);
+        this.language.editor.focus();
+    }
+    /* Starts the tree over from the same symbols for the other direction. */
+    setDirection(direction) {
+        const view = this.language.popups.getState().callHierarchy ?? null;
+        if (view === null || view.direction === direction) {
+            return;
+        }
+        this.reset();
+        this.direction = direction;
+        this.seed();
+        const active = this.roots[0];
+        this.language.popups.setState({
+            callHierarchy: { ...view, direction, rows: rowsOf(this.nodes, this.roots), active, site: 0, sites: 0, preview: null }
+        });
+        this.select(active);
+        for (const root of this.roots) {
+            void this.load(root);
+        }
+    }
+    /* Opens a node, asking the server for its calls the first time, or folds it away. */
+    toggle(id) {
+        const node = this.nodes.get(id);
+        if (node === undefined) {
+            return;
+        }
+        if (node.expanded) {
+            this.patch(id, { expanded: false });
+            const view = this.language.popups.getState().callHierarchy ?? null;
+            if (view !== null && this.hasAncestor(view.active, id)) {
+                this.select(id);
+            }
+            return;
+        }
+        this.patch(id, { expanded: true });
+        if (node.load === 'idle' || node.load === 'failed') {
+            void this.load(id);
+        }
+    }
+    /* Asks again for the calls of a node whose last try failed. */
+    retry(id) {
+        if (this.nodes.get(id)?.load === 'failed') {
+            void this.load(id);
+        }
+    }
+    /* Brings the next stretch of calls of a level. */
+    showMore(parent) {
+        const node = this.nodes.get(parent);
+        if (node === undefined) {
+            return;
+        }
+        this.patch(parent, { shown: Math.min(node.children.length, node.shown + CALL_LEVEL_LIMIT) });
+        const first = node.children[node.shown];
+        const view = this.language.popups.getState().callHierarchy ?? null;
+        // The row that offered more is gone once everything shows, so the selection moves on to what it brought.
+        if (first !== undefined && view?.active === moreIdOf(parent)) {
+            this.select(first);
+        }
+    }
+    /* Makes a row the active one and shows the code of its call. */
+    select(id, site = 0) {
+        const view = this.language.popups.getState().callHierarchy ?? null;
+        const node = this.nodes.get(id);
+        if (view === null || !view.rows.some((row) => row.id === id)) {
+            return;
+        }
+        const sites = node?.sites.length ?? view.sites;
+        const next = node === undefined ? view.site : Math.max(0, Math.min(Math.max(0, sites - 1), site));
+        this.language.popups.setState({ callHierarchy: { ...view, active: id, site: next, sites, preview: node === undefined ? view.preview : null } });
+        if (node !== undefined) {
+            void this.preview(node, next);
+        }
+    }
+    /* Steps through the places a call is made from when the active one has more than one. */
+    stepSite(direction) {
+        const view = this.language.popups.getState().callHierarchy ?? null;
+        if (view !== null && view.sites > 1) {
+            this.select(view.active, (view.site + direction + view.sites) % view.sites);
+        }
+    }
+    /* Goes to the call of a row, or to the symbol of a root, and closes the tree. */
+    go(id) {
+        const view = this.language.popups.getState().callHierarchy ?? null;
+        const node = this.nodes.get(id);
+        if (view === null || node === undefined) {
+            return;
+        }
+        const { uri, range } = targetOf(node, id === view.active ? view.site : 0);
+        this.close();
+        this.language.goTo({ uri, range });
+    }
+    reset() {
+        this.epoch++;
+        this.previewEpoch++;
+        this.controller.abort();
+        this.controller = new AbortController();
+        this.nodes = new Map();
+        this.roots = [];
+        this.texts = new Map();
+    }
+    seed() {
+        const roots = rootsOf(this.prepared);
+        this.roots = roots.map((root) => root.id);
+        this.nodes = new Map(roots.map((root) => [root.id, root]));
+    }
+    mounted(container) {
+        const view = this.language.popups.getState().callHierarchy ?? null;
+        if (view !== null && view.container !== container) {
+            this.language.popups.setState({ callHierarchy: { ...view, container } });
+            revealRow(this.timers, container);
+        }
+    }
+    patch(id, change) {
+        const node = this.nodes.get(id);
+        const view = this.language.popups.getState().callHierarchy ?? null;
+        if (node === undefined || view === null) {
+            return;
+        }
+        this.nodes.set(id, { ...node, ...change });
+        this.language.popups.setState({ callHierarchy: { ...view, rows: rowsOf(this.nodes, this.roots) } });
+    }
+    async load(id) {
+        const node = this.nodes.get(id);
+        if (node === undefined || node.load === 'loading') {
+            return;
+        }
+        const { service, i18n } = this.language.project;
+        const { uri, editor } = this.language;
+        const { direction, epoch } = this;
+        const options = { signal: this.controller.signal, parallel: true };
+        this.patch(id, { load: 'loading', error: null });
+        try {
+            const calls = direction === 'incoming' ? await service.incomingCalls(uri, node.item, options) : await service.outgoingCalls(uri, node.item, options);
+            if (epoch !== this.epoch) {
+                return;
+            }
+            const children = childrenOf(direction, node, calls ?? []);
+            for (const child of children) {
+                this.nodes.set(child.id, child);
+            }
+            this.patch(id, { load: 'loaded', children: children.map((child) => child.id), shown: Math.min(children.length, CALL_LEVEL_LIMIT) });
+            editor.announce(i18n.t(`editor:language.callHierarchy.announce.${direction}`, { count: children.length, name: node.item.name }));
+        }
+        catch (error) {
+            if (epoch !== this.epoch) {
+                return;
+            }
+            if (error instanceof StaleResultError) {
+                this.close();
+                return;
+            }
+            this.patch(id, { load: 'failed', error: messageOf(error) });
+        }
+    }
+    async preview(node, site) {
+        const { project } = this.language;
+        const epoch = ++this.previewEpoch;
+        const { uri, range } = targetOf(node, site);
+        let text = this.texts.get(uri);
+        if (text === undefined) {
+            try {
+                text = (await project.readText(uri)) ?? undefined;
+            }
+            catch {
+                // A file that cannot be read shows no code, as one that is no text file does.
+                text = undefined;
+            }
+            if (epoch !== this.previewEpoch) {
+                return;
+            }
+            if (text !== undefined) {
+                this.texts.set(uri, text);
+            }
+        }
+        const view = this.language.popups.getState().callHierarchy ?? null;
+        if (view === null || view.active !== node.id) {
+            return;
+        }
+        const snippet = text === undefined ? null : snippetOf(text, range.start.line, range);
+        this.language.popups.setState({ callHierarchy: { ...view, preview: snippet === null ? null : { ...snippet, uri } } });
+    }
+    /* Whether a row stands under a node; the `more` and `status` rows belong to the node they are about. */
+    hasAncestor(id, ancestor) {
+        const owner = [moreIdOf(''), statusIdOf('')]
+            .map((suffix) => (id.endsWith(suffix) ? id.slice(0, -suffix.length) : null))
+            .find((found) => found !== null);
+        if (owner !== undefined && owner !== null) {
+            return owner === ancestor || this.hasAncestor(owner, ancestor);
+        }
+        for (let node = this.nodes.get(id); node !== undefined && node.parent !== null; node = this.nodes.get(node.parent)) {
+            if (node.parent === ancestor) {
+                return true;
+            }
+        }
+        return false;
+    }
+    key(event) {
+        const view = this.language.popups.getState().callHierarchy ?? null;
+        if (view === null || event.metaKey || event.ctrlKey || event.altKey || event.shiftKey || event.isComposing) {
+            return false;
+        }
+        const steps = stepsOf(view.rows);
+        const index = steps.findIndex((row) => row.id === view.active);
+        const row = steps[index];
+        switch (event.key) {
+            case 'ArrowDown':
+                this.land(steps[Math.min(steps.length - 1, index + 1)]);
+                return true;
+            case 'ArrowUp':
+                this.land(steps[Math.max(0, index - 1)]);
+                return true;
+            case 'Home':
+                this.land(steps[0]);
+                return true;
+            case 'End':
+                this.land(steps.at(-1));
+                return true;
+            case 'ArrowRight':
+                this.expandOrEnter(row, steps[index + 1]);
+                return true;
+            case 'ArrowLeft':
+                this.collapseOrLeave(row);
+                return true;
+            case 'Enter':
+                if (row?.kind === 'more') {
+                    this.showMore(row.parent);
+                }
+                else if (row !== undefined) {
+                    this.go(row.id);
+                }
+                return true;
+            case 'Escape':
+                this.close();
+                return true;
+            default:
+                return false;
+        }
+    }
+    land(row) {
+        if (row !== undefined) {
+            this.select(row.id);
+        }
+    }
+    /* Right opens a closed node, tries a failed one again, and steps into an open one. */
+    expandOrEnter(row, next) {
+        if (row?.kind !== 'node') {
+            return;
+        }
+        if (!row.expanded) {
+            this.toggle(row.id);
+        }
+        else if (row.load === 'failed') {
+            this.retry(row.id);
+        }
+        else if (next !== undefined && next.level > row.level) {
+            this.land(next);
+        }
+    }
+    /* Left closes an open node and steps out of a closed one. */
+    collapseOrLeave(row) {
+        if (row === undefined) {
+            return;
+        }
+        if (row.kind === 'node' && row.expanded && !row.leaf) {
+            this.toggle(row.id);
+            return;
+        }
+        const parent = row.kind === 'node' ? (this.nodes.get(row.id)?.parent ?? null) : row.parent;
+        if (parent !== null) {
+            this.select(parent);
+        }
+    }
+    tell(title) {
+        this.language.project.host.notify?.({ id: TOAST_ID, kind: 'error', title });
+    }
+    say(key, options) {
+        return this.language.project.i18n.t(`editor:language.callHierarchy.${key}`, options);
+    }
+}

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

@@ -19,5 +19,7 @@ export interface EditPreview {
     readonly hiddenLines: number;
     readonly otherFiles: number;
     readonly moves: number;
+    readonly creates?: number;
+    readonly deletes?: number;
 }
 export declare function previewOf(text: string, edit: WorkspaceEdit, uri: string): EditPreview | null;

package/dist/code-actions-model.js

@@ -1,6 +1,6 @@
 import { applyTextEdits } from '@adecore/lsp';
 import { comparePositions } from './diagnostics-model.js';
-import { entriesOf, renamesOf } from './workspace-edit.js';
+import { resourceOperationsOf, textEntriesOf } from './workspace-edit.js';
 /* The order of the list under the caret: the fixes and the rewrites that are one keystroke away first, the refactorings after them. */
 export const ACTION_GROUPS = ['quickfix', 'rewrite', 'extract', 'inline', 'move', 'refactor', 'source', 'other'];
 /* The order of Refactor This: what changes the structure of the code first, the rewrites after it. */
@@ -75,15 +75,17 @@ const PREVIEW_LINES = 3;
 function linesOf(text) {
     return text.split(/\r\n|\r|\n/);
 }
-/* Null when the edit changes nothing, or deletes a file, which a preview of lines cannot show. A file it creates counts as another file. */
+/* Null when the edit changes nothing. A file it creates is counted under `creates` and not as another file; moves and deletes are counted apart. */
 export function previewOf(text, edit, uri) {
-    const entries = entriesOf(edit);
-    if (entries === null) {
-        return null;
-    }
+    const entries = textEntriesOf(edit);
+    const operations = resourceOperationsOf(edit);
+    const count = (kind) => operations.filter((operation) => operation.kind === kind).length;
+    const moves = count('rename');
+    const creates = count('create');
+    const deletes = count('delete');
     const own = entries.get(uri);
-    const moves = renamesOf(edit).length;
-    const otherFiles = [...entries.keys()].filter((key) => key !== uri).length;
+    const made = new Set(operations.filter((operation) => operation.kind === 'create').map((operation) => operation.uri));
+    const otherFiles = [...entries.keys()].filter((key) => key !== uri && !made.has(key)).length;
     let removed = [];
     let added = [];
     if (own !== undefined) {
@@ -107,9 +109,9 @@ export function previewOf(text, edit, uri) {
         removed = before.slice(head, before.length - tail);
         added = next.slice(head, next.length - tail);
     }
-    if (removed.length === 0 && added.length === 0 && otherFiles === 0 && moves === 0) {
+    if (removed.length === 0 && added.length === 0 && otherFiles === 0 && moves === 0 && creates === 0 && deletes === 0) {
         return null;
     }
     const hiddenLines = Math.max(0, removed.length - PREVIEW_LINES) + Math.max(0, added.length - PREVIEW_LINES);
-    return { removed: removed.slice(0, PREVIEW_LINES), added: added.slice(0, PREVIEW_LINES), hiddenLines, otherFiles, moves };
+    return { removed: removed.slice(0, PREVIEW_LINES), added: added.slice(0, PREVIEW_LINES), hiddenLines, otherFiles, moves, creates, deletes };
 }

package/dist/code-actions.js

@@ -261,7 +261,9 @@ export class CodeActionsFeature {
         const notes = [
             ...(found.hiddenLines > 0 ? [this.say('moreLines', { count: found.hiddenLines })] : []),
             ...(found.otherFiles > 0 ? [this.say('otherFiles', { count: found.otherFiles })] : []),
-            ...(found.moves > 0 ? [this.say('moves', { count: found.moves })] : [])
+            ...(found.moves > 0 ? [this.say('moves', { count: found.moves })] : []),
+            ...((found.creates ?? 0) > 0 ? [this.say('creates', { count: found.creates })] : []),
+            ...((found.deletes ?? 0) > 0 ? [this.say('deletes', { count: found.deletes })] : [])
         ];
         return { removed: found.removed, added: found.added, note: notes.length === 0 ? null : notes.join(' · ') };
     }