Adding Accept and Reject All buttons for bulk changes.

Author: nakul-py

src/diff/base-unified-diff.ts

@@ -123,17 +123,20 @@ export abstract class BaseUnifiedDiffManager {
   /**
    * Accept all changes
    */
-  protected acceptAll(): void {
-    // simply accept the current state
+  public acceptAll(): void {
+    const sharedModel = this.getSharedModel();
+    this._originalSource = sharedModel.getSource();
+    this._newSource = this._originalSource;
     this._deactivate();
   }
 
   /**
    * Reject all changes
    */
-  protected rejectAll(): void {
+  public rejectAll(): void {
     const sharedModel = this.getSharedModel();
     sharedModel.setSource(this._originalSource);
+    this._newSource = this._originalSource;
     this._deactivate();
   }
 
@@ -172,9 +175,9 @@ export abstract class BaseUnifiedDiffManager {
   protected showActionButtons: boolean;
   protected acceptAllButton: ToolbarButton | null = null;
   protected rejectAllButton: ToolbarButton | null = null;
-  private _originalSource: string;
   private _newSource: string;
   private _isInitialized: boolean;
   private _isDisposed: boolean;
   private _diffCompartment: Compartment;
+  public _originalSource: string;
 }

src/diff/unified-cell.ts

@@ -33,9 +33,17 @@ export class UnifiedCellDiffManager extends BaseUnifiedDiffManager {
     super(options);
     this._cell = options.cell;
     this._cellFooterTracker = options.cellFooterTracker;
+    this._originalSource = options.originalSource ?? '';
     this.activate();
   }
 
+  /**
+   * Check if this cell still has pending changes
+   */
+  public hasPendingChanges(): boolean {
+    return this._originalSource !== this._cell.sharedModel.getSource();
+  }
+
   /**
    * Get the shared model for source manipulation
    */
@@ -51,6 +59,11 @@ export class UnifiedCellDiffManager extends BaseUnifiedDiffManager {
       return;
     }
 
+    if (!this.hasPendingChanges()) {
+      this.removeToolbarButtons();
+      return;
+    }
+
     const cellId = this._cell.id;
     const footer = this._cellFooterTracker.getFooter(cellId);
     if (!footer) {
@@ -59,19 +72,17 @@ export class UnifiedCellDiffManager extends BaseUnifiedDiffManager {
 
     this.acceptAllButton = new ToolbarButton({
       icon: checkIcon,
-      label: this.trans.__('Accept All'),
-      tooltip: this.trans.__('Accept all chunks'),
+      label: this.trans.__('Accept'),
+      tooltip: this.trans.__('Accept changes in this cell'),
       enabled: true,
-      className: 'jp-UnifiedDiff-acceptAll',
       onClick: () => this.acceptAll()
     });
 
     this.rejectAllButton = new ToolbarButton({
       icon: undoIcon,
-      label: this.trans.__('Reject All'),
-      tooltip: this.trans.__('Reject all chunks'),
+      label: this.trans.__('Reject'),
+      tooltip: this.trans.__('Reject changes in this cell'),
       enabled: true,
-      className: 'jp-UnifiedDiff-rejectAll',
       onClick: () => this.rejectAll()
     });
 

src/plugin.ts

@@ -19,6 +19,7 @@ import {
   UnifiedFileDiffManager
 } from './diff/unified-file';
 import { CodeMirrorEditor } from '@jupyterlab/codemirror';
+import { ToolbarButton } from '@jupyterlab/ui-components';
 
 /**
  * The translation namespace for the plugin.
@@ -63,6 +64,29 @@ export function findCell(
   return cell ?? null;
 }
 
+/**
+ * Registry for notebook-level diff managers
+ */
+const notebookDiffRegistry = new Map<string, UnifiedCellDiffManager[]>();
+
+let registerCellManager = (
+  notebookId: string,
+  manager: UnifiedCellDiffManager
+): void => {
+  if (!notebookDiffRegistry.has(notebookId)) {
+    notebookDiffRegistry.set(notebookId, []);
+  }
+  notebookDiffRegistry.get(notebookId)!.push(manager);
+};
+
+function getNotebookManagers(notebookId: string) {
+  return notebookDiffRegistry.get(notebookId) || [];
+}
+
+function clearNotebookManagers(notebookId: string) {
+  notebookDiffRegistry.delete(notebookId);
+}
+
 /**
  * Split cell diff plugin - shows side-by-side comparison
  */
@@ -283,8 +307,69 @@ const unifiedCellDiffPlugin: JupyterFrontEndPlugin<void> = {
           trans
         });
         cellDiffManagers.set(cell.id, manager);
+
+        registerCellManager(currentNotebook.id, manager);
       }
     });
+    notebookTracker.widgetAdded.connect((sender, notebookPanel) => {
+      const notebookId = notebookPanel.id;
+
+      let acceptAllButton: ToolbarButton | null = null;
+      let rejectAllButton: ToolbarButton | null = null;
+
+      function updateToolbar() {
+        const managers = getNotebookManagers(notebookId);
+
+        const anyPending = managers.some(m => m.hasPendingChanges());
+        if (!anyPending) {
+          if (acceptAllButton) {
+            acceptAllButton.dispose();
+          }
+          if (rejectAllButton) {
+            rejectAllButton.dispose();
+          }
+          acceptAllButton = null;
+          rejectAllButton = null;
+          return;
+        }
+
+        if (!acceptAllButton) {
+          acceptAllButton = new ToolbarButton({
+            label: trans.__('Accept All'),
+            className: 'accept-all-changes',
+            tooltip: trans.__('Accept all changes in this notebook'),
+            onClick: () => {
+              getNotebookManagers(notebookId).forEach(m => m.acceptAll());
+              updateToolbar();
+            }
+          });
+          notebookPanel.toolbar.addItem('accept-all-changes', acceptAllButton);
+        }
+
+        if (!rejectAllButton) {
+          rejectAllButton = new ToolbarButton({
+            label: trans.__('Reject All'),
+            className: 'reject-all-changes',
+            tooltip: trans.__('Reject all changes in this notebook'),
+            onClick: () => {
+              getNotebookManagers(notebookId).forEach(m => m.rejectAll());
+              updateToolbar();
+            }
+          });
+          notebookPanel.toolbar.addItem('reject-all-changes', rejectAllButton);
+        }
+      }
+
+      notebookPanel.disposed.connect(() => clearNotebookManagers(notebookId));
+      notebookPanel.node.addEventListener('diff-updated', updateToolbar);
+
+      const originalRegister = registerCellManager;
+      registerCellManager = (nid: string, manager: UnifiedCellDiffManager) => {
+        originalRegister(nid, manager);
+        const event = new Event('diff-updated');
+        notebookPanel.node.dispatchEvent(event);
+      };
+    });
   }
 };
 

style/base.css

@@ -77,3 +77,34 @@
   background-color: var(--jp-layout-color3);
   border-color: var(--jp-border-color1);
 }
+
+.jp-ToolbarButtonComponent.accept-all-changes {
+  background-color: #28a745;
+  cursor: pointer;
+  padding: 2px 8px;
+  border-radius: 4px;
+  font-size: 12px;
+  transition:
+    background-color 0.2s,
+    border-color 0.2s;
+}
+
+.jp-ToolbarButtonComponent.accept-all-changes:hover {
+  background-color: #058522;
+}
+
+.jp-ToolbarButtonComponent.reject-all-changes {
+  background-color: #dc3545;
+  cursor: pointer;
+  padding: 2px 8px;
+  border-radius: 4px;
+  font-size: 12px;
+  font-weight: bold;
+  transition:
+    background-color 0.2s,
+    border-color 0.2s;
+}
+
+.jp-ToolbarButtonComponent.reject-all-changes:hover {
+  background-color: #c82333;
+}