dsh-diff-approval 0.21.0 → 0.22.0

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/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.0",
   "description": "DeepSeek Harness plugin: pending-edit review with whole-file diff and Keep/Revert",
   "packageManager": "pnpm@11.21.0",
   "author": "Wu Zhiwei",