xtralab 0.7.0 → 0.9.0

package/lib/git/diffSurface.d.ts

@@ -1,26 +1,19 @@
 import * as React from 'react';
 import { IThemeManager } from '@jupyterlab/apputils';
 import { IRenderMimeRegistry } from '@jupyterlab/rendermime';
-/**
- * Shared diff rendering surface used by both diff hosts in this extension:
- *
- *   - the launcher dashboard's own `xtralab:git:open-diff` command
- *     (via {@link DiffContentWidget} in `diffWidget.tsx`), and
- *   - the `jupyterlab-git` diff providers registered into the upstream git
- *     panel (via `XtralabDiffWidget` in `diffProvider.tsx`).
- *
- * The surface is deliberately content-source agnostic: callers resolve the
- * old/new text however they like (xtralab's REST helper, or a
- * `Git.Diff.IModel`'s `content()` getters) and hand the resolved strings in.
- * Everything visual — the `@pierre/diffs` split view, the cell-by-cell
- * notebook view, the draggable column resizer, and the per-hunk discard
- * affordance — lives here so the two hosts stay pixel-identical.
- */
 /**
  * The CSS class added to the diff main-area widget. The selectors that
  * style the embedded `@pierre/diffs` viewer hang off this class.
  */
 export declare const DIFF_WIDGET_CSS_CLASS = "jp-xtralab-DiffWidget";
+/**
+ * Layout for textual/code diffs, forwarded to `@pierre/diffs` as its
+ * `diffStyle` option. `split` is the side-by-side old|new view; `unified`
+ * is the single-column inline view (what diffs.com calls "stacked").
+ */
+export type DiffStyle = 'split' | 'unified';
+export declare function readStoredDiffStyle(): DiffStyle;
+export declare function writeStoredDiffStyle(style: DiffStyle): void;
 /**
  * View modes available for `.ipynb` diffs. `notebook` is the cell-by-cell
  * rendered view; `json` is the raw nbformat JSON file diff, for inspecting
@@ -37,6 +30,10 @@ export declare function writeStoredNotebookViewMode(mode: NotebookDiffViewMode):
  * provided (lite, certain notebook configurations, …).
  */
 export declare function isDarkTheme(themeManager: IThemeManager | null): boolean;
+/**
+ * Whether the active JupyterLab theme should keep Pierre diff highlighting.
+ */
+export declare function isPierreTheme(themeManager: IThemeManager | null): boolean;
 /**
  * Optional per-hunk discard wiring. When supplied and `enabled`, each hunk
  * in a plain-text/code diff gets an inline "discard" button; clicking it
@@ -51,15 +48,25 @@ export interface IHunkDiscard {
     onAfterSave: () => void;
 }
 export interface IDiffSurfaceProps {
-    /** Whether the host is still resolving the file contents. */
+    /**
+     * Whether the host is still resolving the file contents.
+     */
     loading: boolean;
-    /** Fatal error message to show instead of a diff, or `null`. */
+    /**
+     * Fatal error message to show instead of a diff, or `null`.
+     */
     error: string | null;
-    /** Whether the file is binary (no textual diff is rendered). */
+    /**
+     * Whether the file is binary (no textual diff is rendered).
+     */
     isBinary: boolean;
-    /** Resolved old/reference text. Ignored while loading/binary/errored. */
+    /**
+     * Resolved old/reference text. Ignored while loading/binary/errored.
+     */
     oldText: string;
-    /** Resolved new/challenger text. Ignored while loading/binary/errored. */
+    /**
+     * Resolved new/challenger text. Ignored while loading/binary/errored.
+     */
     newText: string;
     /**
      * New-side path. Drives notebook detection and the `@pierre/diffs` file
@@ -71,21 +78,40 @@ export interface IDiffSurfaceProps {
      * to {@link newName} when the host does not track a previous path.
      */
     oldName?: string;
-    /** Whether to render with the dark `@pierre/diffs` theme. */
+    /**
+     * Whether to render with the dark `@pierre/diffs` theme.
+     */
     dark: boolean;
+    /**
+     * Whether the diff should keep Pierre's own syntax palette.
+     */
+    pierreTheme: boolean;
     /**
      * Rendermime registry used by the notebook view to render outputs and
      * markdown cells. May be `null` in stripped-down hosts; the notebook
      * diff falls back to a textual representation in that case.
      */
     rendermime: IRenderMimeRegistry | null;
-    /** Current rendered-vs-JSON choice for notebook diffs (host-controlled). */
+    /**
+     * Current rendered-vs-JSON choice for notebook diffs (host-controlled).
+     */
     notebookViewMode: NotebookDiffViewMode;
+    /**
+     * Split vs unified layout for the textual/code file diff (host-controlled).
+     */
+    diffStyle: DiffStyle;
     /**
      * Called whenever the availability of a rendered notebook view changes,
      * so the host can show/hide its Notebook/JSON toolbar toggle.
      */
     onNotebookAvailabilityChange?: (available: boolean) => void;
+    /**
+     * Called whenever the textual/code file diff (the only view the split vs
+     * unified choice affects) becomes the active view, so the host can
+     * show/hide its Split/Unified toolbar toggle. False for image, binary,
+     * rendered-notebook, loading and error states.
+     */
+    onFileDiffActiveChange?: (active: boolean) => void;
     /**
      * Called after each (re)computation of the diff with the number of hunks
      * (or `null` when no textual diff exists). Hosts use this to implement
@@ -94,12 +120,13 @@ export interface IDiffSurfaceProps {
     onMetadataChange?: (info: {
         hunkCount: number | null;
     }) => void;
-    /** Optional per-hunk discard wiring; omit for a read-only diff. */
+    /**
+     * Optional per-hunk discard wiring; omit for a read-only diff.
+     */
     hunkDiscard?: IHunkDiscard;
 }
 /**
- * The shared, content-source-agnostic diff renderer. See the module
- * docstring for the division of labor between this surface and its hosts.
+ * Shared renderer for text, notebook and image diffs.
  */
 export declare function DiffSurface(props: IDiffSurfaceProps): React.ReactElement;
 /**
@@ -113,3 +140,15 @@ export declare function NotebookViewModeControl(props: {
     available: boolean;
     onChange: (mode: NotebookDiffViewMode) => void;
 }): React.ReactElement;
+/**
+ * Segmented Split/Unified selector. Mirrors {@link NotebookViewModeControl}:
+ * hosts mount it into their own toolbar and drive its value/visibility from
+ * the same state they pass to {@link DiffSurface}. Only meaningful while the
+ * textual/code file diff is the active view, so `available` mirrors the
+ * surface's `onFileDiffActiveChange`.
+ */
+export declare function DiffStyleControl(props: {
+    diffStyle: DiffStyle;
+    available: boolean;
+    onChange: (style: DiffStyle) => void;
+}): React.ReactElement;

package/lib/git/diffSurface.js

@@ -4,21 +4,7 @@ import { FileDiff } from '@pierre/diffs/react';
 import { diffAcceptRejectHunk, parseDiffFromFile } from '@pierre/diffs';
 import { ImageDiffView, imageDataType } from './imageDiff';
 import { buildNotebookDiff, NotebookDiffView } from './notebookDiff';
-/**
- * Shared diff rendering surface used by both diff hosts in this extension:
- *
- *   - the launcher dashboard's own `xtralab:git:open-diff` command
- *     (via {@link DiffContentWidget} in `diffWidget.tsx`), and
- *   - the `jupyterlab-git` diff providers registered into the upstream git
- *     panel (via `XtralabDiffWidget` in `diffProvider.tsx`).
- *
- * The surface is deliberately content-source agnostic: callers resolve the
- * old/new text however they like (xtralab's REST helper, or a
- * `Git.Diff.IModel`'s `content()` getters) and hand the resolved strings in.
- * Everything visual — the `@pierre/diffs` split view, the cell-by-cell
- * notebook view, the draggable column resizer, and the per-hunk discard
- * affordance — lives here so the two hosts stay pixel-identical.
- */
+import { resolveDiffTheme } from './diffTheme';
 /**
  * The CSS class added to the diff main-area widget. The selectors that
  * style the embedded `@pierre/diffs` viewer hang off this class.
@@ -79,6 +65,27 @@ function writeStoredSplitRatio(ratio) {
         // See readStoredSplitRatio — best-effort persistence.
     }
 }
+const DIFF_STYLE_STORAGE_KEY = 'xtralab:diff-style';
+export function readStoredDiffStyle() {
+    try {
+        const raw = window.localStorage.getItem(DIFF_STYLE_STORAGE_KEY);
+        if (raw === 'split' || raw === 'unified') {
+            return raw;
+        }
+    }
+    catch (_a) {
+        // See readStoredSplitRatio — privacy-mode / sandboxed contexts can throw.
+    }
+    return 'split';
+}
+export function writeStoredDiffStyle(style) {
+    try {
+        window.localStorage.setItem(DIFF_STYLE_STORAGE_KEY, style);
+    }
+    catch (_a) {
+        // Best-effort.
+    }
+}
 const NOTEBOOK_DIFF_VIEW_MODE_STORAGE_KEY = 'xtralab:notebook-diff-view-mode';
 export function readStoredNotebookViewMode() {
     try {
@@ -125,11 +132,18 @@ export function isDarkTheme(themeManager) {
     return document.body.dataset.jpThemeLight === 'false';
 }
 /**
- * The shared, content-source-agnostic diff renderer. See the module
- * docstring for the division of labor between this surface and its hosts.
+ * Whether the active JupyterLab theme should keep Pierre diff highlighting.
+ */
+export function isPierreTheme(themeManager) {
+    var _a;
+    const theme = (_a = themeManager === null || themeManager === void 0 ? void 0 : themeManager.theme) !== null && _a !== void 0 ? _a : null;
+    return theme !== null && theme.toLowerCase().includes('pierre');
+}
+/**
+ * Shared renderer for text, notebook and image diffs.
  */
 export function DiffSurface(props) {
-    const { loading, error, isBinary, oldText, newText, newName, oldName, dark, rendermime, notebookViewMode, onNotebookAvailabilityChange, onMetadataChange, hunkDiscard } = props;
+    const { loading, error, isBinary, oldText, newText, newName, oldName, dark, pierreTheme, rendermime, notebookViewMode, diffStyle, onNotebookAvailabilityChange, onFileDiffActiveChange, onMetadataChange, hunkDiscard } = props;
     const hasContent = !loading && error === null && !isBinary;
     // Raster images take a dedicated `<img>`-based view instead of a
     // text/notebook diff; the host passes the two sides as base64 strings in
@@ -171,6 +185,19 @@ export function DiffSurface(props) {
             hunkCount: metadata !== null ? metadata.hunks.length : null
         });
     }, [onMetadataChange, metadata]);
+    // Decide which view to render. The notebook view requires a successful
+    // nbformat parse; if that failed, we only show the raw JSON file diff.
+    // Computed before the early returns below so the file-diff-active effect
+    // can depend on it without violating the rules of hooks.
+    const hasNotebookView = notebookDiff !== null;
+    const showNotebookView = hasNotebookView && notebookViewMode === 'notebook';
+    const showFileDiff = !showNotebookView && metadata !== null;
+    // The split vs unified choice only affects the textual/code file diff, so
+    // tell the host whether that view is active to drive its Split/Unified
+    // toolbar toggle.
+    React.useEffect(() => {
+        onFileDiffActiveChange === null || onFileDiffActiveChange === void 0 ? void 0 : onFileDiffActiveChange(showFileDiff);
+    }, [onFileDiffActiveChange, showFileDiff]);
     // Split ratio for the diff columns: fraction of width given to the
     // deletions (left) pane. Persisted across sessions so the user only
     // dials in their layout once.
@@ -283,11 +310,6 @@ export function DiffSurface(props) {
         return (React.createElement("div", { className: "jp-xtralab-DiffWidget-content" },
             React.createElement(ImageDiffView, { reference: oldText, challenger: newText, fileType: imageType })));
     }
-    // Decide which view to render. The notebook view requires a successful
-    // nbformat parse; if that failed, we only show the raw JSON file diff.
-    const hasNotebookView = notebookDiff !== null;
-    const showNotebookView = hasNotebookView && notebookViewMode === 'notebook';
-    const showFileDiff = !showNotebookView && metadata !== null;
     if (!showNotebookView && !showFileDiff) {
         return (React.createElement("div", { className: "jp-xtralab-DiffWidget-status" }, "No content to diff."));
     }
@@ -301,7 +323,7 @@ export function DiffSurface(props) {
     };
     return (React.createElement("div", { className: "jp-xtralab-DiffWidget-content" },
         React.createElement("div", { ref: wrapperRef, className: "jp-xtralab-DiffWidget-body" },
-            React.createElement("div", { className: "jp-xtralab-DiffWidget-scroll" }, showNotebookView && notebookDiff !== null ? (React.createElement(NotebookDiffView, { diff: notebookDiff, dark: dark, rendermime: rendermime })) : showFileDiff && metadata !== null ? (React.createElement(FileDiff, { fileDiff: metadata, lineAnnotations: lineAnnotations, renderAnnotation: renderAnnotation, style: hostStyle, 
+            React.createElement("div", { className: "jp-xtralab-DiffWidget-scroll" }, showNotebookView && notebookDiff !== null ? (React.createElement(NotebookDiffView, { diff: notebookDiff, dark: dark, pierreTheme: pierreTheme, rendermime: rendermime })) : showFileDiff && metadata !== null ? (React.createElement(FileDiff, { fileDiff: metadata, lineAnnotations: lineAnnotations, renderAnnotation: renderAnnotation, style: hostStyle, 
                 // Disable the worker pool: JupyterLab's webpack federation
                 // pipeline doesn't ship the library's
                 // `@pierre/diffs/worker/worker.js` file at a URL the worker
@@ -309,12 +331,12 @@ export function DiffSurface(props) {
                 // crashes on instantiation. Running on the main thread is
                 // fine for the small files git diffs typically operate on.
                 disableWorkerPool: true, options: {
-                    diffStyle: 'split',
+                    diffStyle,
                     // Drop the file header — the tab title already shows the
                     // file name and the panel header carries the change
                     // context.
                     disableFileHeader: true,
-                    theme: dark ? 'pierre-dark' : 'pierre-light',
+                    theme: resolveDiffTheme(dark, pierreTheme),
                     themeType: dark ? 'dark' : 'light',
                     // Inject the column-resize override into the shadow root
                     // via the library's `@layer unsafe` channel. Keeping the
@@ -323,7 +345,7 @@ export function DiffSurface(props) {
                     // changes.
                     unsafeCSS: SPLIT_RESIZE_CSS
                 } })) : null),
-            showFileDiff ? (React.createElement("div", { className: "jp-xtralab-DiffWidget-resizer", style: { left: `${leftPercent}%` }, role: "separator", "aria-orientation": "vertical", "aria-valuenow": Math.round(leftPercent), "aria-valuemin": Math.round(MIN_SPLIT_RATIO * 100), "aria-valuemax": Math.round(MAX_SPLIT_RATIO * 100), title: "Drag to resize the diff panes (double-click to reset)", onPointerDown: handleResizerPointerDown, onDoubleClick: handleResizerDoubleClick })) : null)));
+            showFileDiff && diffStyle === 'split' ? (React.createElement("div", { className: "jp-xtralab-DiffWidget-resizer", style: { left: `${leftPercent}%` }, role: "separator", "aria-orientation": "vertical", "aria-valuenow": Math.round(leftPercent), "aria-valuemin": Math.round(MIN_SPLIT_RATIO * 100), "aria-valuemax": Math.round(MAX_SPLIT_RATIO * 100), title: "Drag to resize the diff panes (double-click to reset)", onPointerDown: handleResizerPointerDown, onDoubleClick: handleResizerDoubleClick })) : null)));
 }
 /**
  * Segmented Notebook/JSON selector. Hosts mount this into whatever toolbar
@@ -340,3 +362,38 @@ export function NotebookViewModeControl(props) {
         React.createElement("button", { type: "button", role: "tab", "aria-selected": mode === 'notebook', "data-active": mode === 'notebook', className: "jp-xtralab-DiffWidget-segmentedButton", onClick: () => onChange('notebook') }, "Notebook"),
         React.createElement("button", { type: "button", role: "tab", "aria-selected": mode === 'json', "data-active": mode === 'json', className: "jp-xtralab-DiffWidget-segmentedButton", onClick: () => onChange('json') }, "JSON")));
 }
+/**
+ * Split / unified glyphs, inlined from the `@pierre/diffs` icon sprite
+ * (`diffs-icon-diff-split` / `diffs-icon-diff-unified`) so the toggle looks
+ * like the one on the library's own docs site without depending on the
+ * sprite sheet being injected into the document. `currentColor` lets the
+ * segmented-button styling drive the fill (including the active state).
+ */
+function DiffSplitIcon() {
+    return (React.createElement("svg", { viewBox: "0 0 16 16", fill: "currentColor", "aria-hidden": "true" },
+        React.createElement("path", { d: "M14 0H8.5v16H14a2 2 0 0 0 2-2V2a2 2 0 0 0-2-2m-1.5 6.5v1h1a.5.5 0 0 1 0 1h-1v1a.5.5 0 0 1-1 0v-1h-1a.5.5 0 0 1 0-1h1v-1a.5.5 0 0 1 1 0" }),
+        React.createElement("path", { d: "M2 0a2 2 0 0 0-2 2v12a2 2 0 0 0 2 2h5.5V0zm.5 7.5h3a.5.5 0 0 1 0 1h-3a.5.5 0 0 1 0-1", opacity: ".3" })));
+}
+function DiffUnifiedIcon() {
+    return (React.createElement("svg", { viewBox: "0 0 16 16", fill: "currentColor", "aria-hidden": "true" },
+        React.createElement("path", { fillRule: "evenodd", d: "M16 14a2 2 0 0 1-2 2H2a2 2 0 0 1-2-2V8.5h16zm-8-4a.5.5 0 0 0-.5.5v1h-1a.5.5 0 0 0 0 1h1v1a.5.5 0 0 0 1 0v-1h1a.5.5 0 0 0 0-1h-1v-1A.5.5 0 0 0 8 10", clipRule: "evenodd" }),
+        React.createElement("path", { fillRule: "evenodd", d: "M14 0a2 2 0 0 1 2 2v5.5H0V2a2 2 0 0 1 2-2zM6.5 3.5a.5.5 0 0 0 0 1h3a.5.5 0 0 0 0-1z", clipRule: "evenodd", opacity: ".4" })));
+}
+/**
+ * Segmented Split/Unified selector. Mirrors {@link NotebookViewModeControl}:
+ * hosts mount it into their own toolbar and drive its value/visibility from
+ * the same state they pass to {@link DiffSurface}. Only meaningful while the
+ * textual/code file diff is the active view, so `available` mirrors the
+ * surface's `onFileDiffActiveChange`.
+ */
+export function DiffStyleControl(props) {
+    const { diffStyle, available, onChange } = props;
+    if (!available) {
+        return React.createElement(React.Fragment, null);
+    }
+    return (React.createElement("div", { className: "jp-xtralab-DiffWidget-segmented", role: "tablist", "aria-label": "Diff view style" },
+        React.createElement("button", { type: "button", role: "tab", "aria-selected": diffStyle === 'split', "data-active": diffStyle === 'split', className: "jp-xtralab-DiffWidget-segmentedButton jp-xtralab-DiffWidget-segmentedButton-icon", title: "Split (side-by-side) view", "aria-label": "Split view", onClick: () => onChange('split') },
+            React.createElement(DiffSplitIcon, null)),
+        React.createElement("button", { type: "button", role: "tab", "aria-selected": diffStyle === 'unified', "data-active": diffStyle === 'unified', className: "jp-xtralab-DiffWidget-segmentedButton jp-xtralab-DiffWidget-segmentedButton-icon", title: "Unified (inline) view", "aria-label": "Unified view", onClick: () => onChange('unified') },
+            React.createElement(DiffUnifiedIcon, null))));
+}

package/lib/git/diffTheme.d.ts

@@ -0,0 +1,9 @@
+import { type DiffsThemeNames } from '@pierre/diffs';
+/**
+ * Shiki CSS-variable theme used for non-Pierre JupyterLab themes.
+ */
+export declare const JUPYTERLAB_DIFF_THEME: DiffsThemeNames;
+/**
+ * Choose Pierre's palette or the JupyterLab CSS-variable theme.
+ */
+export declare function resolveDiffTheme(dark: boolean, pierreTheme: boolean): DiffsThemeNames;

package/lib/git/diffTheme.js

@@ -0,0 +1,31 @@
+import { registerCustomCSSVariableTheme } from '@pierre/diffs';
+/**
+ * Shiki CSS-variable theme used for non-Pierre JupyterLab themes.
+ */
+export const JUPYTERLAB_DIFF_THEME = 'jupyterlab';
+/**
+ * Register a Shiki theme whose token colors read JupyterLab's editor
+ * variables. The values are CSS variables, so theme changes recolor the diff.
+ */
+registerCustomCSSVariableTheme(JUPYTERLAB_DIFF_THEME, {
+    foreground: 'var(--jp-content-font-color1)',
+    background: 'var(--jp-layout-color1)',
+    'token-keyword': 'var(--jp-mirror-editor-keyword-color)',
+    'token-string': 'var(--jp-mirror-editor-string-color)',
+    'token-string-expression': 'var(--jp-mirror-editor-string-2-color)',
+    'token-comment': 'var(--jp-mirror-editor-comment-color)',
+    'token-constant': 'var(--jp-mirror-editor-number-color)',
+    'token-function': 'var(--jp-mirror-editor-def-color)',
+    'token-parameter': 'var(--jp-mirror-editor-variable-color)',
+    'token-punctuation': 'var(--jp-mirror-editor-punctuation-color)',
+    'token-link': 'var(--jp-mirror-editor-link-color)'
+});
+/**
+ * Choose Pierre's palette or the JupyterLab CSS-variable theme.
+ */
+export function resolveDiffTheme(dark, pierreTheme) {
+    if (pierreTheme) {
+        return dark ? 'pierre-dark' : 'pierre-light';
+    }
+    return JUPYTERLAB_DIFF_THEME;
+}

package/lib/git/diffWidget.d.ts

@@ -1,114 +1,96 @@
 import * as React from 'react';
-import { IThemeManager, MainAreaWidget } from '@jupyterlab/apputils';
+import { IThemeManager } from '@jupyterlab/apputils';
+import { Git } from '@jupyterlab/git';
 import { IRenderMimeRegistry } from '@jupyterlab/rendermime';
 import { Contents } from '@jupyterlab/services';
 import { ReactWidget } from '@jupyterlab/ui-components';
 import { ISignal } from '@lumino/signaling';
-import { DIFF_WIDGET_CSS_CLASS, type NotebookDiffViewMode } from './diffSurface';
-import { GitReference, IFileChange } from './tokens';
+import { Widget } from '@lumino/widgets';
+import { DIFF_WIDGET_CSS_CLASS, type DiffStyle, type NotebookDiffViewMode } from './diffSurface';
 export { DIFF_WIDGET_CSS_CLASS };
-export declare const PREVIEW_DIFF_WIDGET_ID = "xtralab:diff:preview";
-export declare function pinnedDiffWidgetId(change: IFileChange): string;
 /**
- * Build the deterministic widget id used for a diff against a particular
- * file/group pair. Reused across plugin and command code so reopening a
- * diff for the same file reveals the existing tab instead of opening a
- * second one.
+ * `Git.Diff.IModel` plus optional xtralab-only metadata.
  */
-export declare function diffWidgetId(change: IFileChange): string;
+export interface IXtralabDiffModel extends Git.Diff.IModel {
+    isBinary?: boolean;
+    canDiscard?: boolean;
+    oldFilename?: string;
+}
 /**
- * Resolve the pair of git references whose `content` should appear on the
- * left and right side of the diff for a given file change. Mirrors VS
- * Code's source control diff: staged-side compares INDEX vs HEAD,
- * unstaged-side compares WORKING vs INDEX, and untracked files have no
- * "previous" version to compare against.
+ * Application-level services the diff model does not carry.
  */
-export declare function resolveReferences(change: IFileChange): {
-    oldRef: GitReference | null;
-    newRef: GitReference | null;
-};
-export interface IGitDiffWidgetOptions {
-    repoPath: string;
-    change: IFileChange;
-    themeManager: IThemeManager | null;
+export interface IXtralabDiffContext {
     contentsManager: Contents.IManager;
+    rendermime: IRenderMimeRegistry | null;
+    themeManager: IThemeManager | null;
+}
+/**
+ * Shared diff widget used by the launcher and by `jupyterlab-git`.
+ */
+export declare class XtralabDiffWidget extends ReactWidget implements Git.Diff.IDiffWidget {
+    constructor(model: Git.Diff.IModel, context: IXtralabDiffContext);
+    get model(): Git.Diff.IModel;
     /**
-     * Rendermime registry used by the notebook diff path to render outputs
-     * and markdown cells. May be `null` in stripped-down hosts; the notebook
-     * diff falls back to a textual representation in that case.
+     * Swap the rendered model when the launcher reuses its preview tab.
      */
-    rendermime: IRenderMimeRegistry | null;
+    setModel(model: IXtralabDiffModel): void;
     /**
-     * Called after a hunk-level operation mutates the working tree, so the
-     * surrounding plugin can refresh the changes panel.
+     * This renderer has no merge editor, so it never blocks mark-as-resolved.
      */
-    onChanged: () => void;
+    get isFileResolved(): boolean;
     /**
-     * Called when a post-discard reload finds no hunks left in the diff.
-     * Wired by {@link createGitDiffWidget} to close the host
-     * `MainAreaWidget` — there is nothing left to view, so the empty pane
-     * would just be visual noise.
+     * Return the content jupyterlab-git should save for mark-as-resolved.
      */
-    onEmpty?: () => void;
-    onPinned?: (widget: MainAreaWidget<DiffContentWidget>) => void;
-    pinned?: boolean;
-}
-/**
- * Build a `MainAreaWidget`-hosted diff viewer for a single file change.
- * Wrapping the `ReactWidget` in a `MainAreaWidget` is what gives it the
- * usual document chrome — toolbar slot, focus tracker integration, and
- * spinner-while-loading hooks — and matches the pattern used for other
- * read-only main-area widgets in the JupyterLab ecosystem.
- *
- * This is the launcher dashboard's own diff path
- * (`xtralab:git:open-diff`), kept independent of `jupyterlab-git`. The
- * actual diff rendering is delegated to the shared {@link DiffSurface};
- * `jupyterlab-git`'s panel reaches the same surface through the providers
- * registered in `diffProvider.tsx`.
- */
-export declare function createGitDiffWidget(options: IGitDiffWidgetOptions): MainAreaWidget<DiffContentWidget>;
-export declare function updateGitDiffWidget(widget: MainAreaWidget<DiffContentWidget>, change: IFileChange): void;
-/**
- * The actual React-rendered region of the diff viewer. Held in its own
- * `ReactWidget` so the surrounding `MainAreaWidget` can manage chrome
- * without React having to know about it.
- *
- * Owns the persistent UI state that the surrounding `MainAreaWidget`
- * toolbar needs to read and write (`notebookViewMode` and whether a
- * notebook view is even available for the current file). Storing this on
- * the widget — and exposing change signals — lets the toolbar widget and
- * the React content stay in sync without either side knowing about the
- * other.
- */
-export declare class DiffContentWidget extends ReactWidget {
-    constructor(options: IGitDiffWidgetOptions);
-    /** The change this widget renders, used by callers to identify the widget. */
-    get change(): IFileChange;
-    /** The user's current rendered-vs-JSON view choice for notebook diffs. */
+    getResolvedFile(): Promise<Partial<Contents.IModel>>;
+    /**
+     * Re-pull both sides of the model and re-render.
+     */
+    refresh(): Promise<void>;
     get notebookViewMode(): NotebookDiffViewMode;
-    /** Update the notebook view mode and persist it across sessions. */
     setNotebookViewMode(mode: NotebookDiffViewMode): void;
-    /** Emits whenever {@link notebookViewMode} changes. */
     get notebookViewModeChanged(): ISignal<this, NotebookDiffViewMode>;
-    /**
-     * Whether a rendered notebook view is currently available. Set by the
-     * React content once it has parsed the diff; the toolbar reads this to
-     * decide whether to show the view-mode selector.
-     */
     get hasNotebookView(): boolean;
     setHasNotebookView(value: boolean): void;
-    /** Emits whenever {@link hasNotebookView} changes. */
     get hasNotebookViewChanged(): ISignal<this, boolean>;
-    get pinned(): boolean;
-    pin(): void;
-    get pinnedChanged(): ISignal<this, boolean>;
-    setChange(change: IFileChange): void;
+    get diffStyle(): DiffStyle;
+    setDiffStyle(style: DiffStyle): void;
+    get diffStyleChanged(): ISignal<this, DiffStyle>;
+    /**
+     * Whether the Split/Unified toolbar selector currently applies.
+     */
+    get fileDiffActive(): boolean;
+    setFileDiffActive(value: boolean): void;
+    get fileDiffActiveChanged(): ISignal<this, boolean>;
+    /**
+     * Emitted when a post-discard reload leaves the diff with no hunks.
+     */
+    get emptied(): ISignal<this, void>;
+    notifyEmptied(): void;
+    settleRefresh(): void;
+    get reloadNonce(): number;
+    get context(): IXtralabDiffContext;
     protected render(): React.ReactElement;
-    private _options;
+    private _model;
+    private _context;
+    private _reloadNonce;
+    private _pendingRefresh;
     private _notebookViewMode;
     private _notebookViewModeChanged;
     private _hasNotebookView;
     private _hasNotebookViewChanged;
-    private _pinned;
-    private _pinnedChanged;
+    private _diffStyle;
+    private _diffStyleChanged;
+    private _fileDiffActive;
+    private _fileDiffActiveChanged;
+    private _emptied;
+}
+/**
+ * Structural toolbar type shared across host package boundaries.
+ */
+interface IDiffToolbar {
+    addItem(name: string, widget: Widget): boolean;
 }
+/**
+ * Mount the shared diff toolbar controls into a host-owned toolbar.
+ */
+export declare function addDiffToolbarItems(toolbar: IDiffToolbar, widget: XtralabDiffWidget): void;