jupyterlab-ipyflow 0.0.192 → 0.0.193

package/lib/index.js

@@ -1,6 +1,12 @@
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _IpyflowSessionState_instances, _IpyflowSessionState_computeTopoOrderIdxHelper, _IpyflowSessionState_computeTopoOrderIdx;
 import { ICommandPalette } from '@jupyterlab/apputils';
 import { CodeCell } from '@jupyterlab/cells';
-import { INotebookTracker, NotebookActions, } from '@jupyterlab/notebook';
+import { INotebookTracker } from '@jupyterlab/notebook';
 import _ from 'lodash';
 const waitingClass = 'waiting-cell';
 const readyClass = 'ready-cell';
@@ -15,11 +21,11 @@ const cleanup = new Event('cleanup');
 // ipyflow frontend state
 class IpyflowSessionState {
     constructor() {
+        _IpyflowSessionState_instances.add(this);
         this.comm = null;
         this.notebook = null;
         this.session = null;
         this.isIpyflowCommConnected = false;
-        this.executionScheduledCells = [];
         this.selectedCells = [];
         this.executedCells = new Set();
         this.dirtyCells = new Set();
@@ -65,6 +71,12 @@ class IpyflowSessionState {
             is_reactively_executing: this.isReactivelyExecuting,
         });
     }
+    isBatchReactive() {
+        var _a, _b, _c;
+        return (((_a = this.isIpyflowCommConnected) !== null && _a !== void 0 ? _a : false) &&
+            ((_b = this.settings) === null || _b === void 0 ? void 0 : _b.exec_mode) === 'reactive' &&
+            ((_c = this.settings) === null || _c === void 0 ? void 0 : _c.reactivity_mode) === 'batch');
+    }
     executeCells(cells) {
         if (cells.length === 0) {
             return;
@@ -83,11 +95,20 @@ class IpyflowSessionState {
                 }
                 if (++numFinished === cells.length) {
                     // wait a tick first to allow the disk changes to propagate up
+                    this.isReactivelyExecuting = false;
                     setTimeout(() => this.requestComputeExecSchedule(), 0);
                 }
             });
         }
     }
+    executeClosure(cells) {
+        if (cells.length === 0) {
+            return;
+        }
+        const cellIds = cells.map((cell) => cell.model.id);
+        const closureCells = this.computeTransitiveClosure(cellIds);
+        this.executeCells(closureCells);
+    }
     toggleReactivity() {
         if (this.settings.exec_mode === 'reactive') {
             this.settings.exec_mode = 'normal';
@@ -126,10 +147,21 @@ class IpyflowSessionState {
             (closure.size > prevClosureSize ||
                 !this.executedCells.has(cellId) ||
                 this.readyCells.has(cellId) ||
-                this.waitingCells.has(cellId))) {
+                this.waitingCells.has(cellId) ||
+                this.dirtyCells.has(cellId))) {
             closure.add(cellId);
         }
     }
+    cellIdsToCells(cellIds) {
+        const orderIdxById = this.settings.flow_order === 'any_order'
+            ? __classPrivateFieldGet(this, _IpyflowSessionState_instances, "m", _IpyflowSessionState_computeTopoOrderIdx).call(this)
+            : this.orderIdxById;
+        return cellIds
+            .filter((id) => this.cellsById[id] !== undefined)
+            .filter((id) => this.orderIdxById[id] !== undefined)
+            .sort((a, b) => orderIdxById[a] - orderIdxById[b])
+            .map((id) => this.cellsById[id]);
+    }
     computeTransitiveClosure(cellIds, inclusive = true, parents = false) {
         const closure = new Set();
         for (const cellId of cellIds) {
@@ -144,35 +176,43 @@ class IpyflowSessionState {
             for (const cellId of closure) {
                 this.computeTransitiveClosureHelper(closure, cellId, this.cellParents, true, true);
             }
-            // if (this.settings.flow_order === 'in_order') {
-            //   const minSeedPosition = Math.min(
-            //     ...cellIds.map((id) => this.orderIdxById[id])
-            //   );
-            //   for (const cellId of Array.from(closure)) {
-            //     const pos = this.orderIdxById[cellId];
-            //     if (pos === undefined) {
-            //       closure.delete(cellId);
-            //     } else if (pos < minSeedPosition) {
-            //       closure.delete(cellId);
-            //     }
-            //   }
-            // }
         }
         if (!inclusive) {
             for (const cellId of cellIds) {
                 closure.delete(cellId);
             }
         }
-        return Array.from(closure)
-            .filter((id) => this.cellsById[id] !== undefined)
-            .filter((id) => this.orderIdxById[id] !== undefined)
-            .sort((a, b) => this.orderIdxById[a] - this.orderIdxById[b])
-            .map((id) => this.cellsById[id]);
+        return this.cellIdsToCells(Array.from(closure));
     }
 }
+_IpyflowSessionState_instances = new WeakSet(), _IpyflowSessionState_computeTopoOrderIdxHelper = function _IpyflowSessionState_computeTopoOrderIdxHelper(cellId, orderedCellIds, seen) {
+    var _a, _b, _c;
+    if (seen.has(cellId) || ((_b = (_a = this.cellsById[cellId]) === null || _a === void 0 ? void 0 : _a.model) === null || _b === void 0 ? void 0 : _b.type) !== 'code') {
+        return;
+    }
+    seen.add(cellId);
+    for (const child of (_c = this.cellChildren[cellId]) !== null && _c !== void 0 ? _c : []) {
+        __classPrivateFieldGet(this, _IpyflowSessionState_instances, "m", _IpyflowSessionState_computeTopoOrderIdxHelper).call(this, child, orderedCellIds, seen);
+    }
+    orderedCellIds.unshift(cellId);
+}, _IpyflowSessionState_computeTopoOrderIdx = function _IpyflowSessionState_computeTopoOrderIdx() {
+    const orderedCellIds = [];
+    const seen = new Set();
+    for (const cellId of Object.keys(this.cellsById)) {
+        __classPrivateFieldGet(this, _IpyflowSessionState_instances, "m", _IpyflowSessionState_computeTopoOrderIdxHelper).call(this, cellId, orderedCellIds, seen);
+    }
+    const topoOrderIdx = {};
+    orderedCellIds.forEach((cellId, idx) => {
+        topoOrderIdx[cellId] = idx;
+    });
+    return topoOrderIdx;
+};
 const ipyflowState = {};
+const deferredCells = [];
 function initSessionState(session_id) {
-    ipyflowState[session_id] = new IpyflowSessionState();
+    const ipyflowSessionState = new IpyflowSessionState();
+    ipyflowState[session_id] = ipyflowSessionState;
+    window.ipyflow = ipyflowSessionState;
 }
 function resetSessionState(session_id) {
     delete ipyflowState[session_id];
@@ -195,6 +235,32 @@ const extension = {
     requires: [INotebookTracker, ICommandPalette],
     autoStart: true,
     activate: (app, notebooks, palette) => {
+        app.commands.addCommand('execute-stale', {
+            label: 'Execute Ready Cells',
+            isEnabled: () => true,
+            isVisible: () => true,
+            isToggled: () => false,
+            execute: () => {
+                var _a, _b;
+                const session = notebooks.currentWidget.sessionContext;
+                if (!session.isReady) {
+                    return;
+                }
+                const state = ((_a = ipyflowState[session.session.id]) !== null && _a !== void 0 ? _a : {});
+                if (!((_b = state.isIpyflowCommConnected) !== null && _b !== void 0 ? _b : false)) {
+                    return;
+                }
+                const cellIdsToExecute = Array.from(new Set([...state.dirtyCells, ...state.readyCells]));
+                let cellsToExecute;
+                if (state.settings.reactivity_mode === 'batch') {
+                    cellsToExecute = state.computeTransitiveClosure(cellIdsToExecute);
+                }
+                else {
+                    cellsToExecute = state.cellIdsToCells(cellIdsToExecute);
+                }
+                state.executeCells(cellsToExecute);
+            },
+        });
         app.commands.addCommand('alt-mode-execute', {
             label: 'Alt Mode Execute',
             isEnabled: () => true,
@@ -267,6 +333,11 @@ const extension = {
             keys: ['Ctrl Shift Enter'],
             selector: '.jp-Notebook',
         });
+        app.commands.addKeyBinding({
+            command: 'execute-stale',
+            keys: ['Space'],
+            selector: '.jp-Notebook.jp-mod-commandMode',
+        });
         palette.addItem({
             command: 'alt-mode-execute',
             category: 'execution',
@@ -328,13 +399,21 @@ const extension = {
             selector: '.jp-Notebook',
         });
         let runCellCommand;
+        let runCellAndSelectNextCommand;
+        let runMenuRunCommand;
         try {
             runCellCommand = app.commands._commands.get('notebook:run-cell');
+            runCellAndSelectNextCommand = app.commands._commands.get('notebook:run-cell-and-select-next');
+            runMenuRunCommand = app.commands._commands.get('runmenu:run');
         }
         catch (e) {
             runCellCommand = app.commands._commands['notebook:run-cell'];
+            runCellAndSelectNextCommand = app.commands._commands['notebook:run-cell-and-select-next'];
+            runMenuRunCommand = app.commands._commands['runmenu:run'];
         }
         const runCellCommandExecute = runCellCommand.execute;
+        const runCellAndSelectNextCommandExecute = runCellAndSelectNextCommand.execute;
+        const runMenuRunCommandExecute = runMenuRunCommand.execute;
         const getIpyflowState = () => {
             var _a;
             const session = notebooks.currentWidget.sessionContext;
@@ -344,30 +423,62 @@ const extension = {
             return ((_a = ipyflowState[session.session.id]) !== null && _a !== void 0 ? _a : {});
         };
         const isBatchReactive = () => {
-            var _a;
             const state = getIpyflowState();
-            const settings = state.settings;
-            return (((_a = state.isIpyflowCommConnected) !== null && _a !== void 0 ? _a : false) &&
-                (settings === null || settings === void 0 ? void 0 : settings.exec_mode) === 'reactive' &&
-                (settings === null || settings === void 0 ? void 0 : settings.reactivity_mode) === 'batch');
-        };
-        runCellCommand.execute = (...args) => {
-            if (isBatchReactive() &&
-                getIpyflowState().activeCell.model.type === 'code') {
-                app.commands.execute('notebook:enter-command-mode');
-            }
-            else {
-                runCellCommandExecute.call(runCellCommand, args);
-            }
+            return state.isBatchReactive();
         };
+        [
+            [runCellCommand, runCellCommandExecute, 'notebook:run-cell'],
+            [
+                runCellAndSelectNextCommand,
+                runCellAndSelectNextCommandExecute,
+                'notebook:run-cell-and-select-next',
+            ],
+            [runMenuRunCommand, runMenuRunCommandExecute, 'runmenu:run'],
+        ].forEach(([command, exec, commandId]) => {
+            command.execute = (...args) => {
+                var _a, _b, _c;
+                const state = getIpyflowState();
+                const nbpanel = notebooks.currentWidget;
+                const notebook = nbpanel.content;
+                const kernel = nbpanel.sessionContext.session.kernel.name;
+                if (kernel === 'ipyflow' && !((_a = state === null || state === void 0 ? void 0 : state.isIpyflowCommConnected) !== null && _a !== void 0 ? _a : false)) {
+                    for (const cell of notebook.widgets) {
+                        if (notebook.isSelectedOrActive(cell)) {
+                            cell.setPrompt('*');
+                            deferredCells.push(cell);
+                        }
+                    }
+                }
+                else if (isBatchReactive() &&
+                    ((_c = (_b = state === null || state === void 0 ? void 0 : state.activeCell) === null || _b === void 0 ? void 0 : _b.model) === null || _c === void 0 ? void 0 : _c.type) === 'code') {
+                    app.commands.execute('notebook:enter-command-mode');
+                    const lastCell = state.notebook.widgets[state.notebook.widgets.length - 1];
+                    const isExecutingLastCell = state.activeCell.model.id === lastCell.model.id;
+                    executeBatchReactive();
+                    if (['notebook:run-cell-and-select-next', 'runmenu:run'].includes(commandId)) {
+                        if (isExecutingLastCell) {
+                            app.commands.execute('notebook:insert-cell-below');
+                        }
+                        else {
+                            app.commands.execute('notebook:move-cursor-down');
+                        }
+                    }
+                }
+                else {
+                    exec.call(command, args);
+                    state.requestComputeExecSchedule();
+                }
+            };
+        });
         const executeBatchReactive = (skipFirst = false) => {
             var _a;
             const state = getIpyflowState();
             if ((_a = state.isIpyflowCommConnected) !== null && _a !== void 0 ? _a : false) {
-                let closureCellIds = state.executionScheduledCells;
-                state.executionScheduledCells = [];
-                if (closureCellIds.length === 0) {
-                    closureCellIds = [state.activeCell.model.id];
+                const closureCellIds = [];
+                for (const cell of state.notebook.widgets) {
+                    if (state.notebook.isSelectedOrActive(cell)) {
+                        closureCellIds.push(cell.model.id);
+                    }
                 }
                 let closure = state.computeTransitiveClosure(closureCellIds, true);
                 if (skipFirst) {
@@ -381,45 +492,9 @@ const extension = {
                 }
             }
         };
-        NotebookActions.executionScheduled.connect((_, args) => {
-            const notebook = notebooks === null || notebooks === void 0 ? void 0 : notebooks.currentWidget;
-            if ((notebook === null || notebook === void 0 ? void 0 : notebook.content) !== args.notebook) {
-                return;
-            }
-            if (!isBatchReactive()) {
-                return;
-            }
-            if (args.cell.model.type === 'code') {
-                const state = getIpyflowState();
-                state.executionScheduledCells.push(args.cell.model.id);
-            }
-        });
-        app.commands.commandExecuted.connect((_, args) => {
-            var _a;
-            if (args.id === 'notebook:run-cell') {
-                if (isBatchReactive()) {
-                    executeBatchReactive();
-                }
-                else {
-                    (_a = getIpyflowState()) === null || _a === void 0 ? void 0 : _a.requestComputeExecSchedule();
-                }
-            }
-            else if (['notebook:run-cell-and-select-next', 'runmenu:run'].includes(args.id)) {
-                const state = getIpyflowState();
-                const origActiveCell = state.activeCell;
-                try {
-                    state.activeCell = state.prevActiveCell;
-                    if (isBatchReactive()) {
-                        executeBatchReactive(true);
-                    }
-                    else {
-                        state === null || state === void 0 ? void 0 : state.requestComputeExecSchedule();
-                    }
-                }
-                finally {
-                    state.activeCell = origActiveCell;
-                }
-            }
+        notebooks.currentChanged.connect((_, nbPanel) => {
+            const session = nbPanel.sessionContext;
+            window.ipyflow = ipyflowState[session.session.id];
         });
         notebooks.widgetAdded.connect((sender, nbPanel) => {
             const session = nbPanel.sessionContext;
@@ -517,6 +592,7 @@ const clearCellState = (notebook) => {
         cell.node.classList.remove(readyClass);
         cell.node.classList.remove(readyMakingInputClass);
         cell.node.classList.remove(sliceClass);
+        cell.node.classList.remove(executeSliceClass);
         // clear any old event listeners
         const inputCollapser = getJpInputCollapser(cell.node);
         if (inputCollapser !== null) {
@@ -575,6 +651,7 @@ const connectToComm = (session, notebooks, notebook) => {
     const onContentChanged = _.debounce(() => {
         if (disconnected) {
             notebook.model.contentChanged.disconnect(onContentChanged);
+            notebook.model.cells.changed.disconnect(onContentChanged);
             return;
         }
         const cell_metadata_by_id = state.gatherCellMetadataAndContent();
@@ -796,10 +873,12 @@ const connectToComm = (session, notebooks, notebook) => {
         }
         if (payload.type === 'establish') {
             state.isIpyflowCommConnected = true;
+            refreshNodeMapping(notebook);
             notebook.activeCellChanged.connect(onActiveCellChange);
             notebook.activeCell.model.stateChanged.connect(onExecution);
             notifyActiveCell(notebook.activeCell.model);
             notebook.model.contentChanged.connect(onContentChanged);
+            notebook.model.cells.changed.connect(onContentChanged);
             state.requestComputeExecSchedule();
         }
         else if (payload.type === 'set_exec_mode') {
@@ -857,6 +936,16 @@ const connectToComm = (session, notebooks, notebook) => {
             state.lastExecutionHighlights = payload.highlights;
             const lastExecutedCellId = payload.last_executed_cell_id;
             state.executedReactiveReadyCells.add(lastExecutedCellId);
+            if (deferredCells.length > 0) {
+                const cells = deferredCells.splice(0, deferredCells.length);
+                if (state.isBatchReactive()) {
+                    state.executeClosure(cells);
+                }
+                else {
+                    state.executeCells(cells);
+                }
+                return;
+            }
             const last_execution_was_error = payload.last_execution_was_error;
             let doneReactivelyExecuting = false;
             if (last_execution_was_error) {

package/package.json

@@ -67,5 +67,5 @@
     "extension": true,
     "outputDir": "../../core/ipyflow/resources/labextension/"
   },
-  "version": "0.0.192"
+  "version": "0.0.193"
 }