dsh-diff-approval 0.21.0 → 0.22.1

package/lib/types/client/boundary.d.ts

@@ -0,0 +1,38 @@
+/**
+ * A crash inside the panel must not take the review away for the rest of the page.
+ *
+ * The slot renderer wraps every seat in its own boundary, but a crash there
+ * *abdicates* the entry: the footer row, the header button and the docked tab
+ * disappear for the life of the page, with nothing on screen to say why and no way
+ * back but a reload. This boundary keeps a failure inside our own tree instead —
+ * the entry stays registered, it says what happened, and one press retries the
+ * render — so a broken panel can never present as "the panel is gone" or as a
+ * blank surface with no explanation.
+ *
+ * @module dsh-diff-approval/client/boundary
+ */
+import { Component } from 'react';
+import type { ErrorInfo, ReactNode } from 'react';
+import type { Translator } from './locales.ts';
+/** Props of the boundary and of the face it shows in place of its children. */
+export interface PanelBoundaryProps {
+    /** The panel mount to keep contained. */
+    children?: ReactNode;
+    /** The panel's translator, for the failure note's copy. */
+    t: Translator;
+}
+/** State: whether a child has thrown since the last retry. */
+interface PanelBoundaryState {
+    failed: boolean;
+}
+/**
+ * Keep one panel mount's crash inside its own slot entry, with a visible note and
+ * a retry that re-renders it.
+ */
+export declare class PanelBoundary extends Component<PanelBoundaryProps, PanelBoundaryState> {
+    state: PanelBoundaryState;
+    static getDerivedStateFromError(): PanelBoundaryState;
+    componentDidCatch(error: unknown, info: ErrorInfo): void;
+    render(): ReactNode;
+}
+export {};

package/lib/types/client/composer-cover.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Pasting a copied reference into the composer, and where the caret goes.
+ *
+ * The reference lands in the draft whatever the panel is doing. The caret is a
+ * different question: the review panel can be over the composer, and moving the
+ * focus into a field the reader cannot see would take their next keystrokes with it.
+ * So the focus is asked for only when the composer is really visible.
+ *
+ * @module dsh-diff-approval/client/composer-cover
+ */
+/**
+ * Whether the review panel is covering the chat composer as it stands right now.
+ *
+ * Measured, not inferred from the presentation, because the cases do not line up one
+ * per mode:
+ * - floating with the composer edge left uncovered, the panel stops above the
+ *   composer — except when the window is too short for the panel's own minimum
+ *   height, and then it covers every edge, the composer's included (the phone case);
+ * - floating over an undocked ("hero") composer, the panel spans the conversation
+ *   and the composer sits inside it;
+ * - docked in the right sidebar, the composer is normally in the conversation column
+ *   beside the pane and stays visible — but a fullscreen sidebar spans the window,
+ *   and the panel inside it spans the window too.
+ * Whatever a layout does next, an overlap is an overlap, so this measures the two
+ * boxes and the fraction of the composer they share.
+ * @returns whether the panel covers more than {@link COMPOSER_COVERED_RATIO} of the
+ *   composer.
+ */
+export declare function composerCoveredByPanel(): boolean;
+/**
+ * Take the caret out of the composer when it is holding it.
+ *
+ * Declining to *move* the caret there is not enough on its own: the chord works with
+ * the caret wherever it is, and the caret is usually in the composer — someone who
+ * was typing, then selected a few lines in the diff with the mouse (a selection does
+ * not move the focus), would have the reference pasted into a composer they cannot
+ * see and their next keystrokes land in it. So a hidden composer loses the caret.
+ */
+export declare function leaveComposerCaret(): void;
+/**
+ * Append a copied reference to the composer's draft, and leave the caret there only
+ * when the composer is not behind the panel.
+ * @param appendDraft - writes the reference into the addressed session's draft.
+ * @param reference - the copied `(file:line)` reference.
+ */
+export declare function pasteReferenceIntoComposer(appendDraft: (reference: string) => void, reference: string): void;

package/lib/types/client/dock.d.ts

@@ -32,6 +32,17 @@ export declare const TOGGLE_PANEL_EVENT = "diff-approval:toggle-panel";
 /** The floating panel's own visibility, published on every change so a second
  *  entry can light up while the panel is open (`detail.open`). */
 export declare const PANEL_STATE_EVENT = "diff-approval:panel-state";
+/** Name a file for the panel to show, from a mount that is not the panel itself
+ *  (the produced-file chip): every mounted panel instance switches to it and lands
+ *  on its first change — the ask is "show me this diff", not "put me back where I
+ *  was". The file is also recorded as the last one, so an instance that only
+ *  appears afterwards (the docked tab) opens the same file the same way. */
+export declare const OPEN_PANEL_FILE_EVENT = "diff-approval:panel-file";
+/** Payload of {@link OPEN_PANEL_FILE_EVENT}. */
+export interface PanelFileDetail {
+    /** The pending entry to show. */
+    fileId: string;
+}
 /** Payload of {@link PANEL_STATE_EVENT}. */
 export interface PanelStateDetail {
     /** Whether the floating panel is showing right now. */
@@ -136,6 +147,16 @@ export interface DockHostContext {
  * @returns the state; `attach` reports availability and the tab's own visibility.
  */
 export declare function createDockState(): DockState;
+/**
+ * The tab body: the review panel, docked. The panel's content is one portaled
+ * block, so instead of restructuring it this hands it a host element of the
+ * sidebar's own making to portal into — the tab body owns the element it fills.
+ * @param props - the seat's runtime props, this plugin's face, and `useTabInfo`.
+ * @returns the host element and, once it exists, the docked panel inside it.
+ */
+/** Keeps a failure inside the tab from taking the app's tree down with it, and
+ *  from leaving the pane blank: {@link PanelBoundary} says what happened and can
+ *  re-render the panel without a reload. */
 export declare function DiffDockBody(props: DiffDockBodyProps): ReactNode;
 /**
  * The tab chip: the mode switch, then the panel's title with the pending count —

package/lib/types/client/locales.d.ts

@@ -144,6 +144,8 @@ export declare const zh: {
     'action.closeHint': string;
     'action.closeHintEsc': string;
     'action.summonHint': string;
+    'action.retry': string;
+    'panel.crashed': string;
     'status.kept': string;
     'status.reverted': string;
     'status.missing': string;
@@ -337,6 +339,8 @@ export declare const en: {
     'action.closeHint': string;
     'action.closeHintEsc': string;
     'action.summonHint': string;
+    'action.retry': string;
+    'panel.crashed': string;
     'status.kept': string;
     'status.reverted': string;
     'status.missing': string;

package/lib/types/client/panel-memory.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Where the review panel was left, for this page's lifetime.
+ *
+ * Closing the panel is not "done reviewing": reopening it should put the reader
+ * back on the file they were in, at the offset they were at. That is a fact about
+ * this visit rather than a stored preference, so it lives in module state — which
+ * also gives the two mounts that show the panel (the floating overlay and the
+ * docked tab) one shared memory, so switching presentation does not lose the
+ * place, and a reload starts clean.
+ *
+ * Keyed by session: two sessions have their own pending lists, and one session's
+ * panel must not resume another's file.
+ *
+ * @module dsh-diff-approval/client/panel-memory
+ */
+/**
+ * Remember that a session's panel was left showing one file, and where in it.
+ * @param sessionId - the session the panel was reviewing; nothing is recorded
+ *   without one.
+ * @param view - the pending entry that was open, and the code view's scrollTop.
+ *   An absent offset *forgets* any remembered place for that file, which is what
+ *   a caller that is about to open it at its first change wants: a mount that only
+ *   appears afterwards then lands there too, instead of on a stale offset.
+ */
+export declare function rememberPanelView(sessionId: string | undefined, view: {
+    fileId: string;
+    scrollTop?: number | undefined;
+}): void;
+/**
+ * The file a session's panel was last showing.
+ * @param sessionId - the session, if any.
+ * @returns the pending entry id, or undefined when that session's panel has never
+ *   closed on a file.
+ */
+export declare function lastPanelFile(sessionId: string | undefined): string | undefined;
+/**
+ * How far down one file was left, when it has been left before.
+ * @param sessionId - the session, if any.
+ * @param fileId - the pending entry id.
+ * @returns the remembered scrollTop, or undefined when there is none.
+ */
+export declare function panelFileOffset(sessionId: string | undefined, fileId: string): number | undefined;
+/**
+ * Forget every session's record. A page reload does this by itself; a test calls
+ * it to start from a clean page rather than inheriting the previous case's place.
+ */
+export declare function resetPanelMemory(): void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-diff-approval",
-  "version": "0.21.0",
+  "version": "0.22.1",
   "description": "DeepSeek Harness plugin: pending-edit review with whole-file diff and Keep/Revert",
   "packageManager": "pnpm@11.21.0",
   "author": "Wu Zhiwei",