zidane-ui 9.0.4 → 9.1.3

package/src/files/useCodeReview.tsx

@@ -1,177 +0,0 @@
-/**
- * Selection, comment draft and right-click menu for one code view.
- *
- * Interaction model (same on Files and Diffs):
- *   - click a line number to select it; drag or shift-click extends the
- *     range; Esc clears. The selection just sits there, highlighted.
- *   - the gutter "+" (pierre's utility button, shown on hover / at the end
- *     of the selection) opens the comment draft for that range.
- *   - right-click opens a menu for what is under the cursor: a text
- *     selection, the selected range, or the hovered line. "Add to chat"
- *     sends the excerpt as a composer attachment; "Comment" opens the
- *     draft; "Copy" copies the excerpt. Extra items (file-level actions)
- *     can be appended by the caller.
- *
- * The hook is view-agnostic: the caller supplies `excerptOf(range)` and
- * turns `draft` into the annotation shape its view expects.
- */
-import { useCallback, useEffect, useState, type MouseEvent as ReactMouseEvent, type ReactNode } from 'react';
-
-import type { SelectedLineRange } from '../code/editor/DiffView';
-import { RowActionsMenu, type RowActionItem } from '../components/RowActionsMenu';
-import { attachmentName, languageFor, rangeLabel, serializeCodeSnippet, serializeReviewComment } from './code-excerpt';
-import { resolveCodeMenuTarget, type CodeMenuTarget } from './code-menu';
-import { noChatItem } from './file-actions';
-import type { FilesLabels } from './headless/labels';
-import type { FilesChatTarget } from './headless/view';
-import { ReviewDraft } from './ReviewDraft';
-import { useFilesLabels } from './useFilesLabels';
-
-export interface CodeReviewOptions {
-  filePath: string;
-  kind: 'file' | 'diff';
-  excerptOf: (range: SelectedLineRange) => string;
-  /** Appended after the code items in the context menu (copy path, open in editor...). */
-  extraItems?: readonly RowActionItem[];
-  /**
-   * The chat receiving this view's scope: "Add to chat" and comments go
-   * there. Without one they are shown disabled and the gutter "+" does
-   * nothing (callers drop it: see `canComment`).
-   */
-  chat: FilesChatTarget | null;
-}
-
-export interface CodeReview {
-  selected: SelectedLineRange | null;
-  draft: SelectedLineRange | null;
-  /** Wire to the view's `onSelectionEnd`. */
-  onSelectionEnd: (range: SelectedLineRange | null) => void;
-  /** Wire to the view's `onGutterAction` (only while `canComment`). */
-  openDraft: (range: SelectedLineRange) => void;
-  /** Comments have somewhere to go (a composer receives the scope). */
-  canComment: boolean;
-  /** Wire to the view's host `onContextMenu`. */
-  onContextMenu: (e: ReactMouseEvent) => void;
-  /** Render inside the view's `renderAnnotation`. */
-  draftNode: ReactNode;
-  /** Render once next to the view. */
-  menuNode: ReactNode;
-}
-
-async function copyText(text: string): Promise<void> {
-  try {
-    await navigator.clipboard.writeText(text);
-  } catch (err) {
-    console.error('[zidane-ui] clipboard write failed', err);
-  }
-}
-
-function describe(target: CodeMenuTarget, labels: FilesLabels): string {
-  return target.kind === 'text' ? labels.filesSelection : rangeLabel(target.range);
-}
-
-export function useCodeReview({ filePath, kind, excerptOf, extraItems, chat }: CodeReviewOptions): CodeReview {
-  const labels = useFilesLabels();
-  const [selected, setSelected] = useState<SelectedLineRange | null>(null);
-  const [draft, setDraft] = useState<SelectedLineRange | null>(null);
-  const [menu, setMenu] = useState<{ target: CodeMenuTarget; at: { x: number; y: number } } | null>(null);
-
-  const clear = useCallback(() => {
-    setDraft(null);
-    setSelected(null);
-  }, []);
-
-  // Esc drops the selection (the draft's textarea handles its own Esc first).
-  useEffect(() => {
-    if (!selected) return undefined;
-    const onKey = (e: KeyboardEvent) => {
-      if (e.key === 'Escape' && !(e.target instanceof HTMLTextAreaElement)) clear();
-    };
-    document.addEventListener('keydown', onKey);
-    return () => document.removeEventListener('keydown', onKey);
-  }, [selected, clear]);
-
-  const language = languageFor(filePath);
-  const excerptForTarget = (t: CodeMenuTarget) => (t.kind === 'text' ? t.text : excerptOf(t.range));
-
-  const addToChat = (to: FilesChatTarget, t: CodeMenuTarget) => {
-    const label = t.kind === 'text' ? null : rangeLabel(t.range);
-    const body = serializeCodeSnippet({ filePath, rangeLabel: label, excerpt: excerptForTarget(t), language });
-    to.attach(attachmentName('snippet', filePath, label), body);
-  };
-
-  const openDraft = useCallback(
-    (range: SelectedLineRange) => {
-      setSelected(range);
-      if (chat) setDraft(range);
-    },
-    [chat],
-  );
-  // The composer went away with a comment half-written: nowhere to send it.
-  useEffect(() => {
-    // eslint-disable-next-line react-hooks/set-state-in-effect -- follows a new input once, as the desktop app measured it
-    if (!chat) setDraft(null);
-  }, [chat]);
-
-  const submitDraft = (text: string) => {
-    if (!draft || !chat || !text.trim()) return;
-    const body = serializeReviewComment({
-      kind,
-      filePath,
-      rangeLabel: rangeLabel(draft),
-      excerpt: excerptOf(draft),
-      language,
-      text,
-    });
-    chat.attach(attachmentName('comment', filePath, rangeLabel(draft)), body);
-    clear();
-  };
-
-  const onContextMenu = (e: ReactMouseEvent) => {
-    const target = resolveCodeMenuTarget(e.nativeEvent.composedPath(), selected);
-    if (!target && !extraItems?.length) return;
-    e.preventDefault();
-    if (target) setMenu({ target, at: { x: e.clientX, y: e.clientY } });
-    else setMenu({ target: { kind: 'text', text: '' }, at: { x: e.clientX, y: e.clientY } });
-  };
-
-  const items: RowActionItem[] = [];
-  if (menu && !(menu.target.kind === 'text' && menu.target.text === '')) {
-    const t = menu.target;
-    const what = describe(t, labels);
-    items.push(
-      chat
-        ? { id: 'chat', label: labels.filesAddWhatToChat(what), shortcut: 'a', onSelect: () => addToChat(chat, t) }
-        : noChatItem('chat', labels.filesAddWhatToChat(what), labels),
-      ...(t.kind === 'text'
-        ? []
-        : [
-            chat
-              ? { id: 'comment', label: labels.filesCommentOn(what), shortcut: 'm', onSelect: () => openDraft(t.range) }
-              : noChatItem('comment', labels.filesCommentOn(what), labels),
-          ]),
-      {
-        id: 'copy',
-        label: labels.filesCopyWhat(what),
-        shortcut: 'c',
-        onSelect: () => void copyText(excerptForTarget(t)),
-      },
-    );
-  }
-  if (extraItems?.length) items.push(...extraItems);
-
-  return {
-    selected,
-    draft,
-    onSelectionEnd: setSelected,
-    openDraft,
-    canComment: chat !== null,
-    onContextMenu,
-    draftNode: draft ? (
-      <ReviewDraft label={rangeLabel(draft)} excerpt={excerptOf(draft)} onSubmit={submitDraft} onCancel={clear} />
-    ) : null,
-    menuNode: (
-      <RowActionsMenu open={menu !== null} position={menu?.at ?? null} onClose={() => setMenu(null)} items={items} />
-    ),
-  };
-}

package/src/files/useDiagnostics.ts

@@ -1,59 +0,0 @@
-/**
- * Diagnostics for one file from the project's own tools (main-side runner,
- * cached by mtime). Re-runs when the file on disk changes (`mtimeMs`), per
- * the Editor setting: `open` = every change, once a burst of them settles,
- * `save` = only after our own saves. Off entirely when the mode is `off`
- * or the file has no tool.
- */
-import { useMemo, useState } from 'react';
-
-import { useEditorPrefs, useFilesHost } from './FilesProvider';
-import type { Diagnostic, DiagnosticsResult } from './headless/host';
-import { useDiagnosticsRun } from './useDiagnosticsRun';
-
-export interface Diagnostics {
-  /** null while the first run is in flight (or diagnostics are off). A new version of the file keeps the last findings until it lands, a rerun clears them. */
-  items: Diagnostic[] | null;
-  ran: string[];
-  failed: DiagnosticsResult['failed'];
-  running: boolean;
-  enabled: boolean;
-  rerun: () => void;
-}
-
-export function useDiagnostics(
-  cwd: string | null,
-  path: string | null,
-  mtimeMs: number | null,
-  savedAt: number,
-): Diagnostics {
-  const ed = useEditorPrefs();
-  const run = useFilesHost().diagnostics;
-  const [tick, setTick] = useState(0);
-  const paths = useMemo(() => (path === null ? [] : [path]), [path]);
-  const open = ed.diagnosticsRun === 'open';
-  const { enabled, result, pending } = useDiagnosticsRun(cwd, paths, {
-    // `open`: any on-disk change re-runs. `save`: only our saves (savedAt) and manual reruns.
-    version: String(open ? mtimeMs : savedAt),
-    settle: open,
-    // The viewed file is open in its language server, which reports what the project-wide checks would.
-    lsp: ed.diagnostics === 'lsp',
-    rerun: tick,
-  });
-
-  return {
-    items: result?.diagnostics ?? null,
-    ran: result?.ran ?? [],
-    failed: result?.failed ?? [],
-    running: pending,
-    enabled,
-    rerun: () => {
-      if (cwd && run) {
-        run
-          .invalidate(cwd)
-          .catch(() => undefined)
-          .then(() => setTick((t) => t + 1));
-      } else setTick((t) => t + 1);
-    },
-  };
-}

package/src/files/useDiagnosticsRun.ts

@@ -1,86 +0,0 @@
-/**
- * The runner call both diagnostics hooks share (`useDiagnostics`,
- * `useFilesDiagnostics`): one run per request, aborted when the request
- * changes or the view goes, so the backend can stop a run nobody waits on;
- * an answer for an older request is never shown. A new `version` of the
- * same files waits {@link SETTLE_MS} when `settle` is on, so a burst of
- * on-disk changes (an agent editing) runs once, when it settles. Until the
- * new answer lands, the last one for the same files stays on screen, marked
- * `pending` (as editors do), instead of blanking on every change.
- */
-import { useEffect, useMemo, useRef, useState } from 'react';
-
-import { useEditorPrefs, useFilesHost } from './FilesProvider';
-import type { DiagnosticsResult } from './headless/host';
-
-/** How long a burst of versions must stay quiet before the check runs. */
-export const SETTLE_MS = 500;
-
-const IPC_FAILED: DiagnosticsResult = { diagnostics: [], ran: [], failed: [{ id: '*', reason: 'ipc' }] };
-
-/** What to check besides the files. */
-export interface DiagnosticsRunRequest {
-  /** The files' version: an on-disk change, a save, a new edit. */
-  version: string;
-  /** Wait for a burst of versions to settle. */
-  settle: boolean;
-  /** The files are open in a language server, which reports what the project-wide checks would. */
-  lsp: boolean;
-  /** Bumped to check again (a manual rerun); never waits. */
-  rerun?: number;
-}
-
-/**
- * The findings for `paths`: the answer for `request.version`, else (`pending`) the last one for the same
- * files while the new check runs; null before the first answer (or when diagnostics are off).
- *
- * @param cwd - The folder; null: off.
- * @param paths - The files, relative to it; none: off.
- * @param request - The version, whether to let it settle, the language-server flag, the rerun count.
- */
-export function useDiagnosticsRun(
-  cwd: string | null,
-  paths: readonly string[],
-  request: DiagnosticsRunRequest,
-): { enabled: boolean; result: DiagnosticsResult | null; pending: boolean } {
-  const ed = useEditorPrefs();
-  const run = useFilesHost().diagnostics;
-  const enabled = ed.diagnostics !== 'off' && run !== undefined && cwd !== null && paths.length > 0;
-  const pathKey = useMemo(() => [...paths].sort().join('\0'), [paths]);
-  const subject = `${cwd}\0${pathKey}\0${request.lsp}\0${request.rerun ?? 0}\0${ed.diagnosticsDisabled.join(',')}`;
-  const key = enabled ? `${subject}\0${request.version}` : '';
-  const [state, setState] = useState<{ key: string; subject: string; result: DiagnosticsResult } | null>(null);
-  // The subject of the last run that started: only a new version of it waits to settle.
-  const started = useRef<string | null>(null);
-
-  useEffect(() => {
-    if (!enabled || !run || !cwd) return;
-    const controller = new AbortController();
-    const { signal } = controller;
-    const timer = setTimeout(
-      () => {
-        started.current = subject;
-        run
-          .run(cwd, [...paths], {
-            disabled: [...ed.diagnosticsDisabled],
-            timeoutMs: ed.diagnosticsTimeoutS * 1000,
-            lsp: request.lsp,
-            signal,
-          })
-          .catch(() => IPC_FAILED)
-          .then((result) => {
-            if (!signal.aborted) setState({ key, subject, result });
-          });
-      },
-      request.settle && started.current === subject ? SETTLE_MS : 0,
-    );
-    return () => {
-      clearTimeout(timer);
-      controller.abort();
-    };
-    // eslint-disable-next-line react-hooks/exhaustive-deps -- `key` folds every input that should re-run
-  }, [key]);
-
-  const held = enabled && state?.subject === subject ? state : null;
-  return { enabled, result: held?.result ?? null, pending: enabled && held?.key !== key };
-}

package/src/files/useEntryActions.ts

@@ -1,280 +0,0 @@
-/**
- * The Files tab's entry actions over `FilesHost.entries`: what the tree's
- * in-place rename and create, its drags and drops, its menu, its keys
- * (⌘C / ⌘X / ⌘V, ⌘⌫ / Delete) and the editor's drops run. The tree shows a
- * rename, a move or a new entry at once; this does it on the host, moves the
- * open tabs with it, then refreshes the listing once. A refusal undoes what
- * the tree showed (`resync`) and says why (`notice`).
- */
-import { useCallback, useMemo, useRef, useState, type KeyboardEvent, type RefObject } from 'react';
-
-import { useOptionalConfirm } from '../app/useConfirm';
-import type { FileTreeControl, FileTreeEditing } from '../code/editor/FileTree';
-import type { FileEntryMenu } from './file-actions';
-import {
-  droppedItems,
-  entryRefusalText,
-  inFolder,
-  nameOf,
-  parentOf,
-  topLevelPaths,
-  type EntryClipboard,
-} from './headless/entries';
-import type { FilesEntries, FilesEntryResult } from './headless/host';
-import type { FilesLabels } from './headless/labels';
-import type { OpenFiles } from './useOpenFiles';
-
-/** Inputs of {@link useEntryActions}. */
-export interface EntryActionsInput {
-  /** The folder; `null`: none. */
-  cwd: string | null;
-  /** The host's entry actions; absent (or switched off): nothing is offered. */
-  entries: FilesEntries | undefined;
-  /** The tree's handle (in-place naming, resync, reveal). */
-  tree: RefObject<FileTreeControl | null>;
-  /** The open tabs (they follow moves and removals; a new file opens). */
-  files: Pick<OpenFiles, 'show' | 'moved' | 'removed'>;
-  /** Re-reads the listing. */
-  refresh: () => Promise<void>;
-  /** The tree's selected row (a folder ends with `/`). */
-  selected: string | null;
-  labels: FilesLabels;
-}
-
-/** What {@link useEntryActions} gives the tab. */
-export interface EntryActions {
-  /** The tree's editing handlers (stable); absent without entries. */
-  editing: FileTreeEditing | undefined;
-  /** The menu's entry rows; absent without entries. */
-  menu: FileEntryMenu | undefined;
-  /** The toolbar's New file / New folder, in the selected folder (or the selected file's); absent without entries. */
-  newEntry: ((kind: 'file' | 'folder') => void) | undefined;
-  /** Files dropped on the editor: brought into the root, the first file opened. */
-  dropOnEditor: ((data: DataTransfer) => void) | undefined;
-  /** The tree's keys: cut, copy, paste, delete. */
-  onTreeKeyDown: (e: KeyboardEvent<HTMLElement>) => void;
-  /** The last refusal, worded; `null` when there is none. */
-  notice: string | null;
-  dismissNotice: () => void;
-}
-
-/** A key pressed while typing (the rename box, the search box) is the field's, not the tree's. */
-function typing(e: KeyboardEvent<HTMLElement>): boolean {
-  const origin = e.nativeEvent.composedPath()[0];
-  return (
-    origin instanceof HTMLElement && (origin.isContentEditable || /^(INPUT|TEXTAREA|SELECT)$/.test(origin.tagName))
-  );
-}
-
-/**
- * The entry actions of one Files tab.
- *
- * @param input - The folder, the host's entries, the tree, the open tabs and the listing's refresh.
- */
-export function useEntryActions(input: EntryActionsInput): EntryActions {
-  const { cwd, entries, tree, files, refresh, selected, labels } = input;
-  const confirm = useOptionalConfirm();
-  const [notice, setNotice] = useState<string | null>(null);
-  const [clipboard, setClipboard] = useState<EntryClipboard | null>(null);
-  // The latest inputs, for the stable handlers the memoised tree holds.
-  const latest = useRef({ cwd, entries, files, refresh, selected, labels, confirm, clipboard });
-  // eslint-disable-next-line react-hooks/refs -- a latest-value ref: written in render, read by callbacks and effects
-  latest.current = { cwd, entries, files, refresh, selected, labels, confirm, clipboard };
-
-  /** Runs host actions in order (stopping at the first refusal), then refreshes once. */
-  const run = useCallback(
-    async (actions: readonly ((cwd: string, host: FilesEntries) => Promise<FilesEntryResult>)[]) => {
-      const { cwd: at, entries: host, refresh: reread, labels: words } = latest.current;
-      if (!at || !host) return [];
-      const done: Extract<FilesEntryResult, { ok: true }>[] = [];
-      for (const action of actions) {
-        let result: FilesEntryResult;
-        try {
-          result = await action(at, host);
-        } catch (error) {
-          result = { ok: false, reason: 'denied', message: error instanceof Error ? error.message : String(error) };
-        }
-        if (!result.ok) {
-          setNotice(entryRefusalText(result.reason, words));
-          tree.current?.resync();
-          break;
-        }
-        done.push(result);
-      }
-      if (done.length === actions.length) setNotice(null);
-      await reread();
-      return done;
-    },
-    [tree],
-  );
-
-  const enabled = !!entries && !!cwd;
-
-  const create = useCallback(
-    async (path: string, kind: 'file' | 'folder') => {
-      const [made] = await run([(at, host) => host.create(at, path, kind === 'folder' ? 'dir' : 'file')]);
-      if (made && kind === 'file') latest.current.files.show(made.path);
-    },
-    [run],
-  );
-
-  const moveTo = useCallback(
-    async (paths: readonly string[], toDir: string, copy: boolean) => {
-      const picked = topLevelPaths(paths).filter((p) => copy || parentOf(p) !== toDir);
-      const done = await run(
-        picked.map((from) =>
-          copy
-            ? (at, host) => host.copy(at, from, toDir)
-            : (at, host) => host.move(at, from, inFolder(toDir, nameOf(from))),
-        ),
-      );
-      if (!copy) done.forEach((result, i) => latest.current.files.moved(picked[i]!, result.path));
-      return done;
-    },
-    [run],
-  );
-
-  const editing = useMemo<FileTreeEditing | undefined>(
-    () =>
-      enabled
-        ? {
-            onRename: (from, to) => {
-              void run([(at, host) => host.move(at, from, to)]).then(([moved]) => {
-                if (moved) latest.current.files.moved(from, moved.path);
-              });
-            },
-            onCreate: (path, kind) => void create(path, kind),
-            onMove: (paths, toDir, copy) => void moveTo(paths, toDir, copy),
-            onDropFiles: (toDir, data) => {
-              const items = droppedItems(data);
-              const { cwd: at, entries: host } = latest.current;
-              if (!at || !host || items.length === 0) return;
-              void host.importFiles(at, toDir, items).then(async (result) => {
-                setNotice(result.ok ? null : entryRefusalText(result.reason, latest.current.labels));
-                await latest.current.refresh();
-                if (result.paths[0]) tree.current?.revealSoon(result.paths[0]);
-              });
-            },
-            onError: () => setNotice(latest.current.labels.filesEntryExists),
-          }
-        : undefined,
-    [enabled, run, create, moveTo, tree],
-  );
-
-  const remove = useCallback(
-    async (paths: readonly string[]) => {
-      const { cwd: at, entries: host, confirm: ask, labels: words } = latest.current;
-      if (!at || !host || !ask || paths.length === 0) return;
-      const trash = host.removal(at) === 'trash';
-      const ok = await ask({
-        title: words.filesDeleteTitle(nameOf(paths[0]!), paths.length),
-        message: trash ? words.filesDeleteToTrash : words.filesDeletePermanent,
-        confirmLabel: trash ? words.filesMoveToTrash : words.filesDeleteConfirm,
-        destructive: true,
-      });
-      if (!ok) return;
-      const picked = topLevelPaths(paths);
-      const done = await run(picked.map((path) => (c, h) => h.remove(c, path)));
-      for (const result of done) latest.current.files.removed(result.path);
-    },
-    [run],
-  );
-
-  const paste = useCallback(
-    async (dir: string) => {
-      const clip = latest.current.clipboard;
-      if (!clip || clip.cwd !== latest.current.cwd) return;
-      const done = await moveTo(clip.paths, dir, clip.mode === 'copy');
-      // A cut pastes once; a copy can paste again.
-      if (clip.mode === 'cut' && done.length > 0) setClipboard(null);
-      if (done[0]) tree.current?.revealSoon(done[0].path);
-    },
-    [moveTo, tree],
-  );
-
-  const canPaste = clipboard !== null && clipboard.cwd === cwd;
-  const menu = useMemo<FileEntryMenu | undefined>(
-    () =>
-      enabled
-        ? {
-            create: (dir, kind) => {
-              tree.current?.startCreate(dir, kind, kind === 'folder' ? labels.filesNewFolder : labels.filesNewFile);
-            },
-            rename: (path) => void tree.current?.startRename(path),
-            duplicate: (path) => {
-              void run([(at, host) => host.copy(at, path, parentOf(path))]).then(([copy]) => {
-                if (copy) tree.current?.revealSoon(copy.path);
-              });
-            },
-            clip: (path, mode) => setClipboard({ mode, cwd: latest.current.cwd ?? '', paths: [path] }),
-            ...(canPaste ? { paste: (dir: string) => void paste(dir) } : {}),
-            ...(confirm ? { remove: (path: string) => void remove([path]) } : {}),
-          }
-        : undefined,
-    [enabled, canPaste, confirm, labels, run, paste, remove, tree],
-  );
-
-  /** The selected row's folder (a folder itself, else its parent; the root with none). */
-  const selectedDir = (): string => {
-    const at = latest.current.selected;
-    if (!at) return '';
-    return at.endsWith('/') ? at.slice(0, -1) : parentOf(at);
-  };
-
-  const newEntry = useMemo(
-    () =>
-      enabled
-        ? (kind: 'file' | 'folder') =>
-            void tree.current?.startCreate(
-              selectedDir(),
-              kind,
-              kind === 'folder' ? labels.filesNewFolder : labels.filesNewFile,
-            )
-        : undefined,
-    [enabled, labels, tree],
-  );
-
-  const dropOnEditor = useMemo(
-    () =>
-      enabled
-        ? (data: DataTransfer) => {
-            const items = droppedItems(data);
-            const { cwd: at, entries: host } = latest.current;
-            if (!at || !host || items.length === 0) return;
-            void host.importFiles(at, '', items).then(async (result) => {
-              setNotice(result.ok ? null : entryRefusalText(result.reason, latest.current.labels));
-              await latest.current.refresh();
-              // One file opens; anything else is shown in the tree.
-              const first = result.paths[0];
-              if (!first) return;
-              if (items.length === 1 && !items[0]!.entry?.isDirectory) latest.current.files.show(first);
-              else tree.current?.revealSoon(first);
-            });
-          }
-        : undefined,
-    [enabled, tree],
-  );
-
-  const onTreeKeyDown = useCallback(
-    (e: KeyboardEvent<HTMLElement>) => {
-      const at = latest.current.selected;
-      if (!enabled || typing(e) || e.altKey) return;
-      const mod = e.metaKey || e.ctrlKey;
-      const path = at ? at.replace(/\/$/, '') : null;
-      const key = e.key.toLowerCase();
-      if (mod && (key === 'c' || key === 'x') && path) {
-        setClipboard({ mode: key === 'x' ? 'cut' : 'copy', cwd: latest.current.cwd ?? '', paths: [path] });
-      } else if (mod && key === 'v' && latest.current.clipboard) {
-        void paste(selectedDir());
-      } else if (((mod && e.key === 'Backspace') || e.key === 'Delete') && path && latest.current.confirm) {
-        void remove([path]);
-      } else return;
-      e.preventDefault();
-      e.stopPropagation();
-    },
-    [enabled, paste, remove],
-  );
-
-  const dismissNotice = useCallback(() => setNotice(null), []);
-  return { editing, menu, newEntry, dropOnEditor, onTreeKeyDown, notice, dismissNotice };
-}

package/src/files/useFilesDiagnostics.ts

@@ -1,51 +0,0 @@
-/**
- * Diagnostics for a set of files at once (the Diffs tab's file list): one
- * runner call, counts per path. Re-runs when the list changes, and when
- * `version` does once a burst of new versions settles. Off when the Editor
- * setting is off.
- */
-import { useMemo, useRef } from 'react';
-
-import { countBySeverity } from '../code/editor/diagnostics';
-import type { Diagnostic } from './headless/host';
-import { useDiagnosticsRun } from './useDiagnosticsRun';
-
-export type SeverityCounts = ReturnType<typeof countBySeverity>;
-
-/**
- * `version` is a number or string. Arrays (and other objects) are accepted
- * for robustness: each new identity counts as a new version, so an array
- * never stringifies to "[object Object]" and pins the key.
- */
-export type DiagnosticsVersion = number | string | null | undefined | readonly unknown[] | object;
-
-export function useFilesDiagnostics(
-  cwd: string | null,
-  paths: readonly string[],
-  version: DiagnosticsVersion,
-): ReadonlyMap<string, SeverityCounts> | null {
-  const { result } = useDiagnosticsRun(cwd, paths, {
-    version: useVersionKey(version),
-    settle: true,
-    // These files are not open in a language server: the project-wide checks run for them.
-    lsp: false,
-  });
-
-  return useMemo(() => {
-    if (!result) return null;
-    const byPath = new Map<string, Diagnostic[]>();
-    for (const d of result.diagnostics) byPath.set(d.path, [...(byPath.get(d.path) ?? []), d]);
-    return new Map([...byPath].map(([p, items]) => [p, countBySeverity(items)]));
-  }, [result]);
-}
-
-/** Primitive versions pass through; an object version becomes `length:counter`, bumped per new identity. */
-export function useVersionKey(version: DiagnosticsVersion): string {
-  const last = useRef<{ value: unknown; counter: number }>({ value: version, counter: 0 });
-  if (version === null || version === undefined || typeof version !== 'object') return String(version);
-  // eslint-disable-next-line react-hooks/refs -- a latest-value ref: written in render, read by callbacks and effects
-  if (last.current.value !== version) last.current = { value: version, counter: last.current.counter + 1 };
-  const length = Array.isArray(version) ? version.length : 0;
-  // eslint-disable-next-line react-hooks/refs -- a latest-value ref: written in render, read by callbacks and effects
-  return `${length}:${last.current.counter}`;
-}

package/src/files/useFilesLabels.ts

@@ -1,14 +0,0 @@
-/**
- * The Files and Diffs tabs' labels: the defaults, overridable through
- * `<LabelsProvider>` or `FilesProvider`'s `labels`.
- */
-import { useMemo } from 'react';
-
-import { useLabels } from '../labels';
-import { DEFAULT_FILES_LABELS, type FilesLabels } from './headless/labels';
-
-/** Returns the Files and Diffs tabs' strings: the defaults merged with any overrides given to `FilesProvider` or `LabelsProvider`. */
-export function useFilesLabels(): FilesLabels {
-  const overrides = useLabels() as Partial<FilesLabels>;
-  return useMemo(() => ({ ...DEFAULT_FILES_LABELS, ...overrides }), [overrides]);
-}