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

package/lib/actions.d.ts

@@ -159,6 +159,22 @@ export declare namespace NotebookActions {
      * The new cell will be the active cell.
      */
     function insertBelow(notebook: Notebook): void;
+    /**
+     * 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.
+     */
+    function moveCells(notebook: Notebook, from: number, to: number, n?: number): void;
     /**
      * Move the selected cell(s) down.
      *

package/lib/actions.js

@@ -481,14 +481,62 @@ export class NotebookActions {
         else {
             lastIndex = notebook.model.cells.length;
         }
-        if (shift > 0) {
-            notebook.moveCell(firstIndex, lastIndex, 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.
+     */
+    function moveCells(notebook, from, to, n = 1) {
+        if (!notebook.model) {
+            return;
         }
-        else {
-            notebook.moveCell(firstIndex, firstIndex + shift, lastIndex - firstIndex);
+        // 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 = [];
+        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.undoManager;
+            const lastItem = undoManager.undoStack[undoManager.undoStack.length - 1];
+            lastItem === null || lastItem === void 0 ? void 0 : lastItem.meta.set(Private.CELL_EXECUTION_META_KEY, storedExecutions);
         }
-        void Private.handleState(notebook, state, true);
     }
+    NotebookActions.moveCells = moveCells;
     /**
      * Move the selected cell(s) down.
      *
@@ -1221,6 +1269,17 @@ export class 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) => {
@@ -1228,6 +1287,20 @@ export class 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;
@@ -1285,47 +1358,46 @@ export class NotebookActions {
         }
         const state = Private.getState(notebook);
         notebook.mode = 'command';
+        const undoManager = notebook.model.sharedModel.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 === null || topItem === void 0 ? void 0 : topItem.meta.get(Private.CELL_EXECUTION_META_KEY);
+        const preCaptured = new Map();
+        pendingExecutions === null || pendingExecutions === void 0 ? void 0 : pendingExecutions.forEach(stored => {
+            var _a;
+            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 = (_a = Private.captureExecution(cell)) !== null && _a !== void 0 ? _a : {
+                ...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;
-        const undoManager = notebook.model.sharedModel.undoManager;
         const onStackItemPopped = ({ stackItem }) => {
             storedExecutions = stackItem.meta.get(Private.CELL_EXECUTION_META_KEY);
         };
         undoManager.on('stack-item-popped', onStackItemPopped);
         notebook.model.sharedModel.undo();
         undoManager.off('stack-item-popped', onStackItemPopped);
-        // Restore execution state on resurrected cell widgets.
-        storedExecutions === null || storedExecutions === void 0 ? void 0 : 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 === null || storedExecutions === void 0 ? void 0 : storedExecutions.forEach(stored => {
+            var _a;
+            Private.restoreExecution(notebook, (_a = preCaptured.get(stored.cellId)) !== null && _a !== void 0 ? _a : stored);
         });
         notebook.deselectAll();
         void Private.handleState(notebook, state);
@@ -2120,8 +2192,12 @@ var Private;
     /** Key used to store cell execution state in Y.js undo stack item metadata. */
     Private.CELL_EXECUTION_META_KEY = Symbol('cellExecutionState');
     /**
-     * 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.
      */
@@ -2136,11 +2212,81 @@ var Private;
         });
         const buffered = [];
         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 };
     }
     Private.captureExecution = captureExecution;
+    /**
+     * Reconnect a captured execution to the cell widget that now holds the model.
+     *
+     * Handles both the "still running" and "already finished" cases.
+     */
+    function restoreExecution(notebook, { cellId, future, isDone, buffered, outputs }) {
+        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';
+            }
+        });
+    }
+    Private.restoreExecution = restoreExecution;
     /**
      * A signal that emits whenever a cell completes execution.
      */
@@ -2337,8 +2483,25 @@ var Private;
      * @returns A list of 0 or more selected cells
      */
     function selectedCells(notebook) {
-        return notebook.widgets
-            .filter(cell => notebook.isSelectedOrActive(cell))
+        const cellsToInclude = new Set();
+        // 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.deletable !== undefined) {
@@ -2522,16 +2685,32 @@ var Private;
         const model = notebook.model;
         const sharedModel = model.sharedModel;
         const toDelete = [];
+        const cellsToDeleteSet = new Set();
         notebook.mode = 'command';
-        // Find the cells to delete.
+        // Find the cells to delete, expanding collapsed sections.
         notebook.widgets.forEach((child, index) => {
-            var _a;
+            var _a, _b;
             const deletable = child.model.getMetadata('deletable') !== false;
             if (notebook.isSelectedOrActive(child) && deletable) {
-                toDelete.push(index);
+                cellsToDeleteSet.add(index);
                 (_a = notebook.model) === null || _a === void 0 ? void 0 : _a.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);
+                                (_b = notebook.model) === null || _b === void 0 ? void 0 : _b.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.