xtralab 0.8.0 → 0.9.0

package/lib/git/diffSurface.d.ts

@@ -1,21 +1,6 @@
 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.
@@ -45,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
@@ -59,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
@@ -79,17 +78,27 @@ 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). */
+    /**
+     * Split vs unified layout for the textual/code file diff (host-controlled).
+     */
     diffStyle: DiffStyle;
     /**
      * Called whenever the availability of a rendered notebook view changes,
@@ -111,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;
 /**

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.
@@ -146,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, diffStyle, onNotebookAvailabilityChange, onFileDiffActiveChange, 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
@@ -330,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
@@ -343,7 +336,7 @@ export function DiffSurface(props) {
                     // 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

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,125 +1,79 @@
 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 { Widget } from '@lumino/widgets';
 import { DIFF_WIDGET_CSS_CLASS, type DiffStyle, type NotebookDiffViewMode } from './diffSurface';
-import { GitReference, IFileChange } from './tokens';
 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>;
-    /** The user's current split-vs-unified layout choice for file diffs. */
     get diffStyle(): DiffStyle;
-    /** Update the diff layout and persist it across sessions. */
     setDiffStyle(style: DiffStyle): void;
-    /** Emits whenever {@link diffStyle} changes. */
     get diffStyleChanged(): ISignal<this, DiffStyle>;
     /**
-     * Whether the textual/code file diff (the only view the split-vs-unified
-     * choice affects) is currently active. Set by the React content; the
-     * toolbar reads it to decide whether to show the Split/Unified selector.
+     * Whether the Split/Unified toolbar selector currently applies.
      */
     get fileDiffActive(): boolean;
     setFileDiffActive(value: boolean): void;
-    /** Emits whenever {@link fileDiffActive} changes. */
     get fileDiffActiveChanged(): ISignal<this, boolean>;
-    get pinned(): boolean;
-    pin(): void;
-    get pinnedChanged(): ISignal<this, boolean>;
-    setChange(change: IFileChange): void;
+    /**
+     * 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;
@@ -128,6 +82,15 @@ export declare class DiffContentWidget extends ReactWidget {
     private _diffStyleChanged;
     private _fileDiffActive;
     private _fileDiffActiveChanged;
-    private _pinned;
-    private _pinnedChanged;
+    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;