@jupyterlab/notebook 4.6.0-rc.1 → 4.7.0-alpha.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jupyterlab/notebook",
-  "version": "4.6.0-rc.1",
+  "version": "4.7.0-alpha.0",
   "description": "JupyterLab - Notebook",
   "homepage": "https://github.com/jupyterlab/jupyterlab",
   "bugs": {
@@ -41,24 +41,25 @@
   },
   "dependencies": {
     "@jupyter/ydoc": "^4.0.0",
-    "@jupyterlab/apputils": "^4.7.0-rc.1",
-    "@jupyterlab/cells": "^4.6.0-rc.1",
-    "@jupyterlab/codeeditor": "^4.6.0-rc.1",
-    "@jupyterlab/codemirror": "^4.6.0-rc.1",
-    "@jupyterlab/coreutils": "^6.6.0-rc.1",
-    "@jupyterlab/docregistry": "^4.6.0-rc.1",
-    "@jupyterlab/documentsearch": "^4.6.0-rc.1",
-    "@jupyterlab/lsp": "^4.6.0-rc.1",
-    "@jupyterlab/markedparser-extension": "^4.6.0-rc.1",
-    "@jupyterlab/nbformat": "^4.6.0-rc.1",
-    "@jupyterlab/observables": "^5.6.0-rc.1",
-    "@jupyterlab/rendermime": "^4.6.0-rc.1",
-    "@jupyterlab/services": "^7.6.0-rc.1",
-    "@jupyterlab/settingregistry": "^4.6.0-rc.1",
-    "@jupyterlab/statusbar": "^4.6.0-rc.1",
-    "@jupyterlab/toc": "^6.6.0-rc.1",
-    "@jupyterlab/translation": "^4.6.0-rc.1",
-    "@jupyterlab/ui-components": "^4.6.0-rc.1",
+    "@jupyterlab/apputils": "^4.8.0-alpha.0",
+    "@jupyterlab/cells": "^4.7.0-alpha.0",
+    "@jupyterlab/codeeditor": "^4.7.0-alpha.0",
+    "@jupyterlab/codemirror": "^4.7.0-alpha.0",
+    "@jupyterlab/coreutils": "^6.7.0-alpha.0",
+    "@jupyterlab/docregistry": "^4.7.0-alpha.0",
+    "@jupyterlab/documentsearch": "^4.7.0-alpha.0",
+    "@jupyterlab/lsp": "^4.7.0-alpha.0",
+    "@jupyterlab/markedparser-extension": "^4.7.0-alpha.0",
+    "@jupyterlab/nbformat": "^4.7.0-alpha.0",
+    "@jupyterlab/observables": "^5.7.0-alpha.0",
+    "@jupyterlab/outputarea": "^4.7.0-alpha.0",
+    "@jupyterlab/rendermime": "^4.7.0-alpha.0",
+    "@jupyterlab/services": "^7.7.0-alpha.0",
+    "@jupyterlab/settingregistry": "^4.7.0-alpha.0",
+    "@jupyterlab/statusbar": "^4.7.0-alpha.0",
+    "@jupyterlab/toc": "^6.7.0-alpha.0",
+    "@jupyterlab/translation": "^4.7.0-alpha.0",
+    "@jupyterlab/ui-components": "^4.7.0-alpha.0",
     "@lumino/algorithm": "^2.0.4",
     "@lumino/commands": "^2.3.3",
     "@lumino/coreutils": "^2.2.2",
@@ -74,7 +75,7 @@
     "react": "^18.2.0"
   },
   "devDependencies": {
-    "@jupyterlab/testing": "^4.6.0-rc.1",
+    "@jupyterlab/testing": "^4.7.0-alpha.0",
     "@types/jest": "^29.2.0",
     "jest": "^29.2.0",
     "rimraf": "~5.0.5",

package/src/actions.tsx

@@ -603,15 +603,77 @@ export namespace NotebookActions {
       lastIndex = notebook.model.cells.length;
     }
 
-    if (shift > 0) {
-      notebook.moveCell(firstIndex, lastIndex, lastIndex - firstIndex);
-    } else {
-      notebook.moveCell(firstIndex, firstIndex + shift, lastIndex - firstIndex);
-    }
+    const toIndex = shift > 0 ? lastIndex : firstIndex + shift;
+    moveCells(notebook, firstIndex, toIndex, lastIndex - firstIndex);
 
     void Private.handleState(notebook, state, true);
   }
 
+  /**
+   * Move cells while preserving in-flight kernel futures.
+   *
+   * The underlying `jupyter-ydoc` `moveCells` implementation currently
+   * serializes cells to JSON and recreates them via a delete + insert
+   * transaction, which disposes any active kernel futures attached to the
+   * old widgets. This wrapper detaches futures before the move and
+   * reattaches them to the new widgets afterwards, and stores them in the
+   * undo stack so that undoing the move also restores execution state.
+   *
+   * @param notebook - The target notebook.
+   * @param from - Index of the first cell to move.
+   * @param to - Target index (as passed to `notebook.moveCell`).
+   * @param n - Number of cells to move.
+   */
+  export function moveCells(
+    notebook: Notebook,
+    from: number,
+    to: number,
+    n = 1
+  ): void {
+    if (!notebook.model) {
+      return;
+    }
+
+    // Mirror `Notebook.moveCell`'s bounding/no-op logic so that we do not
+    // capture futures or touch the undo stack when the move won't happen.
+    // Otherwise we could attach execution metadata to an unrelated previous
+    // undo item, corrupting subsequent undo behavior.
+    const boundedTo = Math.min(
+      notebook.model.cells.length - 1,
+      Math.max(0, to)
+    );
+    if (boundedTo === from) {
+      return;
+    }
+
+    // moveCells serializes cells to JSON and recreates widgets (delete+insert),
+    // which would dispose any in-flight futures. Capture them first.
+    const storedExecutions: Private.IStoredCellExecution[] = [];
+    notebook.widgets.slice(from, from + n).forEach(child => {
+      if (!(child instanceof CodeCell)) {
+        return;
+      }
+      const stored = Private.captureExecution(child);
+      if (stored) {
+        storedExecutions.push(stored);
+      }
+    });
+
+    notebook.moveCell(from, to, n);
+
+    // Immediately reconnect futures to the newly created widgets.
+    for (const stored of storedExecutions) {
+      Private.restoreExecution(notebook, stored);
+    }
+
+    // Store in the undo stack so that undoing the move can also restore state.
+    if (storedExecutions.length > 0) {
+      const undoManager = (notebook.model.sharedModel as YNotebook).undoManager;
+      const lastItem = undoManager.undoStack[undoManager.undoStack.length - 1];
+      lastItem?.meta.set(Private.CELL_EXECUTION_META_KEY, storedExecutions);
+    }
+  }
+
   /**
    * Move the selected cell(s) down.
    *
@@ -1530,6 +1592,19 @@ export namespace NotebookActions {
       switch (mode) {
         case 'below':
           index = notebook.activeCellIndex + 1;
+          // If the active cell is a collapsed markdown heading with children,
+          // insert after all the children, not just after the heading.
+          {
+            const activeCell = notebook.activeCell;
+            if (
+              activeCell instanceof MarkdownCell &&
+              activeCell.headingCollapsed &&
+              activeCell.numberChildNodes > 0
+            ) {
+              index =
+                notebook.activeCellIndex + activeCell.numberChildNodes + 1;
+            }
+          }
           break;
         case 'belowSelected':
           notebook.widgets.forEach((child, childIndex) => {
@@ -1537,7 +1612,24 @@ export namespace NotebookActions {
               index = childIndex + 1;
             }
           });
-
+          // If the last selected cell is a collapsed markdown heading with children,
+          // insert after all the children, not just after the heading.
+          {
+            const lastSelectedIndex = index - 1;
+            if (
+              lastSelectedIndex >= 0 &&
+              lastSelectedIndex < notebook.widgets.length
+            ) {
+              const widget = notebook.widgets[lastSelectedIndex];
+              if (
+                widget instanceof MarkdownCell &&
+                widget.headingCollapsed &&
+                widget.numberChildNodes > 0
+              ) {
+                index = lastSelectedIndex + widget.numberChildNodes + 1;
+              }
+            }
+          }
           break;
         case 'above':
           index = notebook.activeCellIndex;
@@ -1609,9 +1701,37 @@ export namespace NotebookActions {
     const state = Private.getState(notebook);
     notebook.mode = 'command';
 
+    const undoManager = (notebook.model.sharedModel as YNotebook).undoManager;
+
+    // For cells that will be MOVED by the undo (i.e. they still exist in the
+    // notebook at their current position), pre-capture their futures now before
+    // sharedModel.undo() destroys those widgets. This prevents OutputArea.dispose()
+    // from cancelling the future during the Y.js delete+insert that implements the move.
+    const topItem = undoManager.undoStack[undoManager.undoStack.length - 1];
+    const pendingExecutions = topItem?.meta.get(
+      Private.CELL_EXECUTION_META_KEY
+    ) as Private.IStoredCellExecution[] | undefined;
+    const preCaptured = new Map<string, Private.IStoredCellExecution>();
+    pendingExecutions?.forEach(stored => {
+      const cell = notebook.widgets.find(w => w.model.id === stored.cellId);
+      if (!(cell instanceof CodeCell)) {
+        return; // cell was deleted (not moved) — handled via stored future below
+      }
+      // Cell still present → move undo. Fresh capture protects the future.
+      const fresh = Private.captureExecution(cell) ?? {
+        ...stored,
+        isDone: () => true,
+        buffered: []
+      };
+      // The undo will roll the outputs back to their state at the time of
+      // the move; snapshot the current outputs so anything received since
+      // then can be re-applied after the undo.
+      fresh.outputs = cell.model.outputs.toJSON();
+      preCaptured.set(stored.cellId, fresh);
+    });
+
     // Capture execution context from the stack item being popped.
     let storedExecutions: Private.IStoredCellExecution[] | undefined;
-    const undoManager = (notebook.model.sharedModel as YNotebook).undoManager;
     const onStackItemPopped = ({
       stackItem
     }: {
@@ -1625,40 +1745,13 @@ export namespace NotebookActions {
     notebook.model.sharedModel.undo();
     undoManager.off('stack-item-popped', onStackItemPopped);
 
-    // Restore execution state on resurrected cell widgets.
-    storedExecutions?.forEach(({ cellId, future, isDone, buffered }) => {
-      const cell = notebook.widgets.find(w => w.model.id === cellId);
-      if (!(cell instanceof CodeCell)) {
-        return;
-      }
-      if (isDone()) {
-        // Execution finished or was interrupted before undo - ensure state is idle.
-        cell.model.executionState = 'idle';
-        return;
-      }
-      // Still running - reconnect the future so the cell receives remaining
-      // output and stdin requests (e.g. input()), and tracks the idle transition.
-      cell.outputArea.reattachFuture(future);
-      // Replay any IOPub messages that arrived while the future was detached.
-      // After reattachFuture, future.onIOPub routes to the new output area.
-      for (const msg of buffered) {
-        void future.onIOPub(msg);
-      }
-      // The original execute() call targeted the old cell widget, so it will
-      // not update executionCount/executionState on this resurrected cell.
-      // Drive the idle transition here instead.
-      const cellRef = cell;
-      void future.done.then(
-        reply => {
-          if (!cellRef.isDisposed) {
-            cellRef.model.executionCount = reply.content.execution_count;
-          }
-        },
-        () => {
-          if (!cellRef.isDisposed) {
-            cellRef.model.executionState = 'idle';
-          }
-        }
+    // Restore execution state on resurrected/moved cell widgets.
+    // For move-undo: use freshly pre-captured data (stored data is stale).
+    // For delete-undo: stored data has the futures captured at deletion time.
+    storedExecutions?.forEach(stored => {
+      Private.restoreExecution(
+        notebook,
+        preCaptured.get(stored.cellId) ?? stored
       );
     });
 
@@ -2568,6 +2661,15 @@ namespace Private {
   /** Key used to store cell execution state in Y.js undo stack item metadata. */
   export const CELL_EXECUTION_META_KEY = Symbol('cellExecutionState');
 
+  /**
+   * A kernel message that arrived while the future was detached, tagged with
+   * its channel so it can be dispatched to the right handler on replay.
+   */
+  export type IBufferedMessage =
+    | { channel: 'iopub'; msg: KernelMessage.IIOPubMessage }
+    | { channel: 'stdin'; msg: KernelMessage.IStdinMessage }
+    | { channel: 'reply'; msg: KernelMessage.IExecuteReplyMsg };
+
   export interface IStoredCellExecution {
     cellId: string;
     future: Kernel.IShellFuture<
@@ -2575,13 +2677,28 @@ namespace Private {
       KernelMessage.IExecuteReplyMsg
     >;
     isDone: () => boolean;
-    /** IOPub messages that arrived while the future was detached. */
-    buffered: KernelMessage.IIOPubMessage[];
+    /**
+     * Kernel messages (IOPub, stdin and reply) that arrived while the future
+     * was detached, in arrival order, so they can be replayed on reattach.
+     */
+    buffered: IBufferedMessage[];
+    /**
+     * Snapshot of the cell outputs to restore after an undo.
+     *
+     * The Y.js undo of a move (a delete + insert transaction) resurrects the
+     * cell as it was when the move happened, rolling back any output received
+     * since. Re-applying this snapshot after the undo prevents that loss.
+     */
+    outputs?: nbformat.IOutput[];
   }
 
   /**
-   * Detach the kernel future from a code cell, buffering any IOPub messages
-   * that arrive while it is detached so they can be replayed on reattach.
+   * Detach the kernel future from a code cell, buffering any messages that
+   * arrive while it is detached so they can be replayed on reattach.
+   *
+   * `detachFuture` clears the IOPub, stdin and reply handlers, so all three
+   * channels are buffered here; otherwise a message arriving during the
+   * detached window (e.g. an `input()` request on stdin) would be dropped.
    *
    * Returns null if the cell has no active future.
    */
@@ -2596,13 +2713,88 @@ namespace Private {
     void future.done.finally(() => {
       done = true;
     });
-    const buffered: KernelMessage.IIOPubMessage[] = [];
+    const buffered: IBufferedMessage[] = [];
     future.onIOPub = msg => {
-      buffered.push(msg);
+      buffered.push({ channel: 'iopub', msg });
+    };
+    future.onStdin = msg => {
+      buffered.push({ channel: 'stdin', msg });
+    };
+    future.onReply = msg => {
+      buffered.push({ channel: 'reply', msg });
     };
     return { cellId: cell.model.id, future, isDone: () => done, buffered };
   }
 
+  /**
+   * Reconnect a captured execution to the cell widget that now holds the model.
+   *
+   * Handles both the "still running" and "already finished" cases.
+   */
+  export function restoreExecution(
+    notebook: Notebook,
+    { cellId, future, isDone, buffered, outputs }: IStoredCellExecution
+  ): void {
+    const cell = notebook.widgets.find(w => w.model.id === cellId);
+    if (!(cell instanceof CodeCell)) {
+      return;
+    }
+    if (outputs && !JSONExt.deepEqual(outputs, cell.model.outputs.toJSON())) {
+      // Re-apply the output snapshot taken just before the undo: the Y.js
+      // undo rolled the outputs back to their state at the time of the
+      // undone action. Going through the output area model keeps the
+      // in-memory model and the shared model in sync (output changes are
+      // not tracked by the undo manager, so this does not pollute history).
+      cell.model.outputs.fromJSON(outputs);
+    }
+    // Reattach the future (without clearing existing outputs) and replay any
+    // messages buffered while it was detached, in arrival order. This is done
+    // whether or not the execution has already finished, so that final outputs
+    // (or a pending stdin request) that arrived while detached are not lost
+    // (e.g. if the kernel completed in the brief window during the undo).
+    cell.outputArea.reattachFuture(future);
+    for (const buf of buffered) {
+      switch (buf.channel) {
+        case 'iopub':
+          void future.onIOPub(buf.msg);
+          break;
+        case 'stdin':
+          void future.onStdin(buf.msg);
+          break;
+        case 'reply':
+          void future.onReply(buf.msg);
+          break;
+      }
+    }
+    if (isDone()) {
+      // The execution already finished (e.g. it completed or was interrupted
+      // during the undo). The resurrected cell may carry a stale 'running'
+      // state from its restored snapshot, so reset it synchronously rather
+      // than relying solely on the asynchronous `future.done` handler below.
+      cell.model.executionState = 'idle';
+    } else {
+      // Restore the running state on the recreated cell widget.
+      cell.model.executionState = 'running';
+    }
+    const cellRef = cell;
+    void future.done.then(
+      reply => {
+        if (!cellRef.isDisposed) {
+          // The future is authoritative for the prompt number; a snapshot
+          // taken before completion would be stale (still null). Setting a
+          // non-null execution count also flips the state back to 'idle'.
+          cellRef.model.executionCount = reply.content.execution_count;
+          cellRef.model.executionState = 'idle';
+        }
+      },
+      () => {
+        if (!cellRef.isDisposed) {
+          cellRef.model.executionState = 'idle';
+        }
+      }
+    );
+  }
+
   /**
    * Notebook cell executor
    */
@@ -2909,8 +3101,30 @@ namespace Private {
    * @returns A list of 0 or more selected cells
    */
   export function selectedCells(notebook: Notebook): nbformat.ICell[] {
-    return notebook.widgets
-      .filter(cell => notebook.isSelectedOrActive(cell))
+    const cellsToInclude = new Set<Cell>();
+
+    // Collect all selected/active cells and expand collapsed sections
+    for (let i = 0; i < notebook.widgets.length; i++) {
+      const cell = notebook.widgets[i];
+      if (notebook.isSelectedOrActive(cell)) {
+        cellsToInclude.add(cell);
+
+        // If this is a collapsed markdown cell, add all its children
+        if (
+          cell instanceof MarkdownCell &&
+          cell.headingCollapsed &&
+          cell.numberChildNodes > 0
+        ) {
+          for (let j = i + 1; j <= i + cell.numberChildNodes; j++) {
+            if (notebook.widgets[j]) {
+              cellsToInclude.add(notebook.widgets[j]);
+            }
+          }
+        }
+      }
+    }
+
+    return Array.from(cellsToInclude)
       .map(cell => cell.model.toJSON())
       .map(cellJSON => {
         if ((cellJSON.metadata as JSONObject).deletable !== undefined) {
@@ -3117,19 +3331,40 @@ namespace Private {
     const model = notebook.model!;
     const sharedModel = model.sharedModel;
     const toDelete: number[] = [];
+    const cellsToDeleteSet = new Set<number>();
 
     notebook.mode = 'command';
 
-    // Find the cells to delete.
+    // Find the cells to delete, expanding collapsed sections.
     notebook.widgets.forEach((child, index) => {
       const deletable = child.model.getMetadata('deletable') !== false;
 
       if (notebook.isSelectedOrActive(child) && deletable) {
-        toDelete.push(index);
+        cellsToDeleteSet.add(index);
         notebook.model?.deletedCells.push(child.model.id);
+
+        // If this is a collapsed markdown cell, mark all its children for deletion
+        if (
+          child instanceof MarkdownCell &&
+          child.headingCollapsed &&
+          child.numberChildNodes > 0
+        ) {
+          for (let j = index + 1; j <= index + child.numberChildNodes; j++) {
+            if (notebook.widgets[j]) {
+              const childDeletable =
+                notebook.widgets[j].model.getMetadata('deletable') !== false;
+              if (childDeletable) {
+                cellsToDeleteSet.add(j);
+                notebook.model?.deletedCells.push(notebook.widgets[j].model.id);
+              }
+            }
+          }
+        }
       }
     });
 
+    toDelete.push(...Array.from(cellsToDeleteSet).sort((a, b) => a - b));
+
     // If cells are not deletable, we may not have anything to delete.
     if (toDelete.length > 0) {
       // Detach futures before the transaction so dispose() does not cancel them.

package/src/panel.ts

@@ -1,7 +1,5 @@
 // Copyright (c) Jupyter Development Team.
 // Distributed under the terms of the Modified BSD License.
-/* eslint-disable @typescript-eslint/no-explicit-any */
-
 import type { ISessionContext } from '@jupyterlab/apputils';
 import { Dialog, Printing, showDialog } from '@jupyterlab/apputils';
 import { isMarkdownCellModel } from '@jupyterlab/cells';
@@ -191,7 +189,7 @@ export class NotebookPanel extends DocumentWidget<Notebook, INotebookModel> {
    * Handle a change in the kernel by updating the document metadata.
    */
   private _onKernelChanged(
-    sender: any,
+    sender: ISessionContext,
     args: Session.ISessionConnection.IKernelChangedArgs
   ): void {
     if (!this.model || !args.newValue) {

package/src/searchprovider.ts

@@ -1,7 +1,5 @@
 // Copyright (c) Jupyter Development Team.
 // Distributed under the terms of the Modified BSD License.
-/* eslint-disable @typescript-eslint/no-explicit-any */
-
 import { Dialog, showDialog } from '@jupyterlab/apputils';
 import type {
   CellSearchProvider,
@@ -66,7 +64,7 @@ export class NotebookSearchProvider extends SearchProvider<NotebookPanel> {
     this._filtersChanged.connect(this._setEnginesSelectionSearchMode, this);
   }
 
-  private _onNotebookStateChanged(_: Notebook, args: IChangedArgs<any>) {
+  private _onNotebookStateChanged(_: Notebook, args: IChangedArgs<unknown>) {
     if (args.name === 'mode') {
       // Delay the update to ensure that `document.activeElement` settled.
       window.setTimeout(() => {