Do not trigger the save reminder or leave confirmation dialogue on empty and View Only notebooks (#202)

* Add a helper to identify empty notebooks

* Refactor `generateDefaultNotebookName` into utils

* No leave confirmation for view-only/empty notebooks

* Send save reminder toast on non-empty notebooks

* Add tests

* Fix lint

* Update Playwright Snapshots

* Partially revert "Update Playwright Snapshots"

This reverts commit 724ba17.

* Fix again

* Again, reset the reminder timer on manual save

* Distinguish b/w first and subsequent manual saves

* Fix order of saves and manual save counter up

* Don't trigger notifications on View Only notebooks

* Rename counter, add manual save marker, mandatory `onFire`

Co-Authored-By: Michał Krassowski <[email protected]>

* Make `onManualSave` non-optional

---------

Co-authored-by: github-actions[bot] <github-actions[bot]@users.noreply.github.com>
Co-authored-by: Michał Krassowski <[email protected]>

Author: 3 people

src/index.ts

@@ -19,7 +19,7 @@ import { Commands } from './commands';
 // import { competitions } from './pages/competitions';
 import { notebookPlugin } from './pages/notebook';
 // import { helpPlugin } from './pages/help';
-import { generateDefaultNotebookName } from './notebook-name';
+import { generateDefaultNotebookName, isNotebookEmpty } from './notebook-utils';
 import {
   IViewOnlyNotebookTracker,
   viewOnlyNotebookFactoryPlugin,
@@ -87,14 +87,22 @@ async function showShareDialog(sharingService: SharingService, notebookContent:
 async function handleNotebookSharing(
   notebookPanel: NotebookPanel | ViewOnlyNotebookPanel,
   sharingService: SharingService,
-  manual: boolean
+  manual: boolean,
+  onManualSave: () => void
 ) {
   const notebookContent = notebookPanel.context.model.toJSON() as INotebookContent;
 
   const isViewOnly = notebookContent.metadata?.isSharedNotebook === true;
   const sharedId = notebookContent.metadata?.sharedId as string | undefined;
   const defaultName = generateDefaultNotebookName();
 
+  // Mark that the user has performed at least one manual save in this session.
+  // We do this early in the manual flow for clarity; the local save already happened
+  // in the command handlers and this flag only affects reminder wording.
+  if (manual && !isViewOnly) {
+    onManualSave();
+  }
+
   try {
     if (isViewOnly) {
       // Skip CKHub sync for view-only notebooks
@@ -137,22 +145,6 @@ async function handleNotebookSharing(
   }
 }
 
-/**
- * Helper to start the save reminder timer. Clears any existing timer
- * and sets a new one to show the notification after 5 minutes.
- */
-function startSaveReminder(currentTimeout: number | null): number {
-  if (currentTimeout) {
-    window.clearTimeout(currentTimeout);
-  }
-  return window.setTimeout(() => {
-    Notification.info(
-      "It's been 5 minutes since you've been working on this notebook. Make sure to save the link to your notebook to edit your work later.",
-      { autoClose: 8000 }
-    );
-  }, 300 * 1000); // once after 5 minutes
-}
-
 /**
  * JUPYTEREVERYWHERE EXTENSION
  */
@@ -185,7 +177,7 @@ const plugin: JupyterFrontEndPlugin<void> = {
             // Skip auto-sync if it's a manual share.
             return;
           }
-          await handleNotebookSharing(widget, sharingService, false);
+          await handleNotebookSharing(widget, sharingService, false, () => {});
         }
       });
     });
@@ -296,9 +288,21 @@ const plugin: JupyterFrontEndPlugin<void> = {
       }
     });
 
+    // Track user time, and show a reminder to save the notebook once after
+    // five minutes of editing (i.e., once it becomes non-empty and dirty)
+    // using a toast notification.
+    let saveReminderTimeout: number | null = null;
+    let isSaveReminderScheduled = false; // a 5-minute timer is scheduled, but it hasn't fired yet
+    let hasShownSaveReminder = false; // we've already shown the toast once for this notebook
+    let hasManuallySaved = false; // whether the user has manually saved at least once in this session
+
     /**
      * Add custom Share notebook command
      */
+    const markManualSave = () => {
+      hasManuallySaved = true;
+    };
+
     commands.addCommand(Commands.shareNotebookCommand, {
       label: 'Share Notebook',
       execute: async () => {
@@ -318,7 +322,7 @@ const plugin: JupyterFrontEndPlugin<void> = {
           // Save the notebook before we share it.
           await notebookPanel.context.save();
 
-          await handleNotebookSharing(notebookPanel, sharingService, true);
+          await handleNotebookSharing(notebookPanel, sharingService, true, markManualSave);
         } catch (error) {
           console.error('Error in share command:', error);
         }
@@ -344,7 +348,7 @@ const plugin: JupyterFrontEndPlugin<void> = {
         }
         manuallySharing.add(panel);
         await panel.context.save();
-        await handleNotebookSharing(panel, sharingService, true);
+        await handleNotebookSharing(panel, sharingService, true, markManualSave);
       }
     });
 
@@ -476,25 +480,100 @@ const plugin: JupyterFrontEndPlugin<void> = {
         }
       }
     });
-    // Track user time, and show a reminder to save the notebook after
-    // five minutes using a toast notification.
-    // Then reset the timer when the notebook is saved manually.
-    let saveReminderTimeout: number | null = null;
+
+    /**
+     * Helper to start the save reminder timer. Clears any existing timer
+     * and sets a new one to show the notification after 5 minutes.
+     */
+    function startSaveReminder(currentTimeout: number | null, onFire: () => void): number {
+      if (currentTimeout) {
+        window.clearTimeout(currentTimeout);
+      }
+      return window.setTimeout(() => {
+        const message = hasManuallySaved
+          ? "It's been 5 minutes since you last saved this notebook. Make sure to save the link to your notebook to edit your work later."
+          : "It's been 5 minutes since you've been working on this notebook. Make sure to save the link to your notebook to edit your work later.";
+
+        Notification.info(message, { autoClose: 8000 });
+        onFire();
+      }, 300 * 1000); // once after 5 minutes
+    }
 
     tracker.widgetAdded.connect((_, panel) => {
       if (saveReminderTimeout) {
         window.clearTimeout(saveReminderTimeout);
+        saveReminderTimeout = null;
       }
+      isSaveReminderScheduled = false;
+      hasShownSaveReminder = false;
+
+      const maybeScheduleSaveReminder = () => {
+        if (hasShownSaveReminder) {
+          return;
+        }
+
+        const content = panel.context.model.toJSON() as INotebookContent;
+        // Skip for view-only notebooks
+        if (panel.context.model.readOnly || content.metadata?.isSharedNotebook === true) {
+          return;
+        }
+        // Schedule after the notebook becomes non-empty
+        if (isNotebookEmpty(content)) {
+          return;
+        }
+        if (isSaveReminderScheduled) {
+          return;
+        }
+
+        isSaveReminderScheduled = true;
+        saveReminderTimeout = startSaveReminder(saveReminderTimeout, () => {
+          hasShownSaveReminder = true;
+          isSaveReminderScheduled = false;
+        });
+      };
 
-      panel.context.ready.then(() => {
-        saveReminderTimeout = startSaveReminder(saveReminderTimeout);
+      // After the model is ready, check immediately and on any content change.
+      void panel.context.ready.then(() => {
+        // We cover the case where the notebook loads already non-empty, say,
+        // if the user uploads a notebook into the application.
+        maybeScheduleSaveReminder();
+        panel.context.model.contentChanged.connect(() => {
+          maybeScheduleSaveReminder(); // schedule when first content appears
+        });
 
+        // Reset the reminder timer whenever the user saves manually.
+        // We clear any pending timer and wait for the next edit (dirty state)
+        // to schedule a fresh 5-minute reminder.
         panel.context.saveState.connect((_, state) => {
           if (state === 'completed') {
-            saveReminderTimeout = startSaveReminder(saveReminderTimeout);
+            if (saveReminderTimeout) {
+              window.clearTimeout(saveReminderTimeout);
+              saveReminderTimeout = null;
+            }
+            isSaveReminderScheduled = false;
+            hasShownSaveReminder = false;
+            // Note: we do not reschedule here; it will be scheduled on the next content change
+            // once the notebook becomes dirty again.
           }
         });
       });
+
+      // If a view-only notebook is opened or becomes active, ensure no reminder can fire.
+      readonlyTracker.widgetAdded.connect(() => {
+        if (saveReminderTimeout) {
+          window.clearTimeout(saveReminderTimeout);
+          saveReminderTimeout = null;
+        }
+        isSaveReminderScheduled = false;
+        hasShownSaveReminder = false;
+      });
+
+      panel.disposed.connect(() => {
+        if (saveReminderTimeout) {
+          window.clearTimeout(saveReminderTimeout);
+          saveReminderTimeout = null;
+        }
+      });
     });
   }
 };

src/notebook-name.ts

@@ -0,0 +1,41 @@
+import type { INotebookContent, MultilineString } from '@jupyterlab/nbformat';
+
+const toText = (src?: MultilineString): string => (Array.isArray(src) ? src.join('') : (src ?? ''));
+
+/**
+ * Iterates over all cells of a notebook and returns true the notebook has no meaningful
+ * content. We consider a notebook "non-empty" if at least one cell has a populated
+ * non-whitespace source.
+ * @param nb - the notebook to check if it's empty
+ * @returns - a boolean indicating whether the notebook is empty or not.
+ */
+export function isNotebookEmpty(nb?: Partial<INotebookContent>): boolean {
+  const cells = nb?.cells ?? [];
+  if (cells.length === 0) {
+    return true;
+  }
+
+  for (const cell of cells) {
+    if (/\S/.test(toText(cell?.source as MultilineString | undefined))) {
+      return false;
+    }
+  }
+  return true;
+}
+
+/**
+ * Generates a default notebook name based on the current date and time.
+ *
+ * @returns A string representing the default notebook name, with
+ *          the format: "Notebook_YYYY-MM-DD_HH-MM-SS"
+ */
+export function generateDefaultNotebookName(): string {
+  const now = new Date();
+
+  const pad = (n: number) => n.toString().padStart(2, '0');
+
+  const date = `${now.getFullYear()}-${pad(now.getMonth() + 1)}-${pad(now.getDate())}`;
+  const time = `${pad(now.getHours())}-${pad(now.getMinutes())}-${pad(now.getSeconds())}`;
+
+  return `Notebook_${date}_${time}`;
+}

src/notebook-utils.ts

@@ -7,11 +7,21 @@ import { EverywhereIcons } from './icons';
 import { LEAVE_CONFIRMATION_TITLE, LeaveConfirmation } from './ui-components/LeaveConfirmation';
 import { Commands } from './commands';
 
+import { INotebookTracker } from '@jupyterlab/notebook';
+import { INotebookContent } from '@jupyterlab/nbformat';
+import { IViewOnlyNotebookTracker } from './view-only';
+import { isNotebookEmpty } from './notebook-utils';
+
 export const customSidebar: JupyterFrontEndPlugin<void> = {
   id: 'jupytereverywhere:sidebar',
   autoStart: true,
-  requires: [ILabShell],
-  activate: (app: JupyterFrontEnd, shell: ILabShell) => {
+  requires: [ILabShell, INotebookTracker, IViewOnlyNotebookTracker],
+  activate: (
+    app: JupyterFrontEnd,
+    shell: ILabShell,
+    tracker: INotebookTracker,
+    readonlyTracker: IViewOnlyNotebookTracker
+  ) => {
     // Overwrite behaviour of the sidebar panel
     const leftHandler = shell['_leftHandler'];
     const sidebar: TabBar<Widget> = leftHandler._sideBar;
@@ -31,7 +41,7 @@ export const customSidebar: JupyterFrontEndPlugin<void> = {
         if (newWidget && newWidget instanceof SidebarIcon) {
           const cancel = newWidget.execute();
           if (cancel) {
-            console.log('Attempting to revert to:', oldWidget.label);
+            console.log('Attempting to revert to:', oldWidget?.label);
             if (args.previousTitle) {
               const previousIndex = sidebar.titles.indexOf(oldWidget);
               if (previousIndex >= 0) {
@@ -54,26 +64,51 @@ export const customSidebar: JupyterFrontEndPlugin<void> = {
         icon: EverywhereIcons.logo,
         execute: () => {
           void (async () => {
-            const result = await showDialog({
-              title: LEAVE_CONFIRMATION_TITLE,
-              body: new LeaveConfirmation(),
-              buttons: [
-                Dialog.cancelButton({ label: 'Cancel' }),
-                Dialog.okButton({ label: 'Yes' })
-              ],
-              defaultButton: 0
-            });
+            const readOnlyNotebookPanel = readonlyTracker.currentWidget;
+            const notebookPanel = tracker.currentWidget;
 
-            if (result.button.label === 'Yes') {
-              try {
-                await app.commands.execute(Commands.shareNotebookCommand);
-              } catch (error) {
-                console.error(
-                  'Failed to share notebook before leaving to the Landing page:',
-                  error
-                );
-              }
+            // If a view-only notebook is open: skip dialog and go home,
+            // as we cannot save the notebook anyway + we can assume the
+            // user retrieved the URL from somewhere (either someone else's
+            // or their own notebook) to paste or share in the first place
+            if (readOnlyNotebookPanel) {
               window.location.href = '/index.html';
+              return;
+            }
+
+            // If we have a new notebook, decide based on emptiness.
+            if (notebookPanel) {
+              const content = notebookPanel.context.model.toJSON() as INotebookContent;
+              const empty = isNotebookEmpty(content);
+
+              if (empty) {
+                window.location.href = '/index.html';
+                return;
+              }
+
+              // Non-empty regular notebook -> confirm and optionally save/share
+              const result = await showDialog({
+                title: LEAVE_CONFIRMATION_TITLE,
+                body: new LeaveConfirmation(),
+                buttons: [
+                  Dialog.cancelButton({ label: 'Cancel' }),
+                  Dialog.okButton({ label: 'Yes' })
+                ],
+                defaultButton: 0
+              });
+
+              if (result.button.label === 'Yes') {
+                try {
+                  await app.commands.execute(Commands.shareNotebookCommand);
+                } catch (error) {
+                  console.error(
+                    'Failed to share notebook before leaving to the Landing page:',
+                    error
+                  );
+                }
+                window.location.href = '/index.html';
+              }
+              return;
             }
           })();
 

src/sidebar.ts

@@ -1,7 +1,7 @@
 import { ReactWidget } from '@jupyterlab/apputils';
 import React from 'react';
 
-import { generateDefaultNotebookName } from '../notebook-name';
+import { generateDefaultNotebookName } from '../notebook-utils';
 
 /**
  * Share dialog data interface.