jupyterlab-ipyflow 0.0.173 → 0.0.174

package/lib/index.js

@@ -2,7 +2,6 @@ import { ICommandPalette } from '@jupyterlab/apputils';
 import { CodeCell } from '@jupyterlab/cells';
 import { INotebookTracker } from '@jupyterlab/notebook';
 import _ from 'lodash';
-const IPYFLOW_KERNEL_NAME = 'ipyflow';
 const waitingClass = 'waiting-cell';
 const readyClass = 'ready-cell';
 const readyMakingClass = 'ready-making-cell';
@@ -10,44 +9,32 @@ const readyMakingInputClass = 'ready-making-input-cell';
 const linkedWaitingClass = 'linked-waiting';
 const linkedReadyMakerClass = 'linked-ready-maker';
 const cleanup = new Event('cleanup');
-// ipyflow frontend state
-let dirtyCells = new Set();
-let waitingCells = new Set();
-let readyCells = new Set();
-let waiterLinks = {};
-let readyMakerLinks = {};
-let activeCell = null;
-let activeCellId = null;
-let cellsById = {};
-let cellModelsById = {};
-let orderIdxById = {};
-let cellPendingExecution = null;
-let lastExecutionMode = null;
-let isReactivelyExecuting = false;
-let isAltModeExecuting = false;
-let lastExecutionHighlights = null;
-let executedReactiveReadyCells = new Set();
-let newReadyCells = new Set();
-let forcedReactiveCells = new Set();
-function resetState() {
-    dirtyCells = new Set();
-    waitingCells = new Set();
-    readyCells = new Set();
-    waiterLinks = {};
-    readyMakerLinks = {};
-    activeCell = null;
-    activeCellId = null;
-    cellsById = {};
-    cellModelsById = {};
-    orderIdxById = {};
-    cellPendingExecution = null;
-    lastExecutionMode = null;
-    isReactivelyExecuting = false;
-    isAltModeExecuting = false;
-    lastExecutionHighlights = null;
-    executedReactiveReadyCells = new Set();
-    newReadyCells = new Set();
-    forcedReactiveCells = new Set();
+const ipyflowState = {};
+function initSessionState(session_id) {
+    ipyflowState[session_id] = {
+        isIpyflowCommConnected: false,
+        dirtyCells: new Set(),
+        waitingCells: new Set(),
+        readyCells: new Set(),
+        waiterLinks: {},
+        readyMakerLinks: {},
+        activeCell: null,
+        activeCellId: null,
+        cellsById: {},
+        cellModelsById: {},
+        orderIdxById: {},
+        cellPendingExecution: null,
+        lastExecutionMode: null,
+        isReactivelyExecuting: false,
+        isAltModeExecuting: false,
+        lastExecutionHighlights: null,
+        executedReactiveReadyCells: new Set(),
+        newReadyCells: new Set(),
+        forcedReactiveCells: new Set(),
+    };
+}
+function resetSessionState(session_id) {
+    delete ipyflowState[session_id];
 }
 /**
  * Initialization data for the jupyterlab-ipyflow extension.
@@ -63,17 +50,19 @@ const extension = {
             isVisible: () => true,
             isToggled: () => false,
             execute: () => {
+                var _a, _b;
                 const session = notebooks.currentWidget.sessionContext;
                 if (!session.isReady) {
                     return;
                 }
-                if (session.session.kernel.name !== IPYFLOW_KERNEL_NAME) {
+                const state = ((_a = ipyflowState[session.session.id]) !== null && _a !== void 0 ? _a : {});
+                if (!((_b = state.isIpyflowCommConnected) !== null && _b !== void 0 ? _b : false)) {
                     app.commands.execute('notebook:enter-command-mode');
                     CodeCell.execute(notebooks.activeCell, session);
                 }
                 else if (notebooks.activeCell.model.type === 'code') {
                     app.commands.execute('notebook:enter-command-mode');
-                    if (isAltModeExecuting) {
+                    if (state.isAltModeExecuting) {
                         // run the toggle twice to get to the same exec mode, but with updated timestamp
                         session.session.kernel
                             .requestExecute({
@@ -94,7 +83,7 @@ const extension = {
                         });
                     }
                     else {
-                        isAltModeExecuting = true;
+                        state.isAltModeExecuting = true;
                         session.session.kernel
                             .requestExecute({
                             code: '%flow toggle-reactivity-until-next-reset',
@@ -143,27 +132,44 @@ const extension = {
         });
         notebooks.widgetAdded.connect((sender, nbPanel) => {
             const session = nbPanel.sessionContext;
+            let commDisconnectHandler = () => resetSessionState(session.session.id);
+            const registerCommTarget = () => {
+                session.session.kernel.registerCommTarget('ipyflow-client', (comm, _open_msg) => {
+                    comm.onMsg = (msg) => {
+                        var _a;
+                        const payload = msg.content.data;
+                        if (!((_a = payload.success) !== null && _a !== void 0 ? _a : true)) {
+                            return;
+                        }
+                        if (payload.type === 'unestablish') {
+                            commDisconnectHandler();
+                        }
+                        else if (payload.type === 'establish') {
+                            commDisconnectHandler();
+                            commDisconnectHandler = connectToComm(session, nbPanel.content);
+                        }
+                    };
+                    commDisconnectHandler();
+                    commDisconnectHandler = connectToComm(session, nbPanel.content);
+                });
+            };
             session.ready.then(() => {
                 clearCellState(nbPanel.content);
-                let commDisconnectHandler = resetState;
-                if (session.session.kernel.name === IPYFLOW_KERNEL_NAME) {
-                    session.ready.then(() => {
-                        commDisconnectHandler = connectToComm(session, nbPanel.content);
-                    });
-                }
+                registerCommTarget();
+                commDisconnectHandler();
+                commDisconnectHandler = connectToComm(session, nbPanel.content);
                 session.kernelChanged.connect((_, args) => {
                     if (args.newValue == null) {
                         return;
                     }
-                    resetState();
                     clearCellState(nbPanel.content);
                     commDisconnectHandler();
-                    commDisconnectHandler = resetState;
-                    if (args.newValue.name === IPYFLOW_KERNEL_NAME) {
-                        session.ready.then(() => {
-                            commDisconnectHandler = connectToComm(session, nbPanel.content);
-                        });
-                    }
+                    resetSessionState(session.session.id);
+                    commDisconnectHandler = () => resetSessionState(session.session.id);
+                    session.ready.then(() => {
+                        registerCommTarget();
+                        commDisconnectHandler = connectToComm(session, nbPanel.content);
+                    });
                 });
             });
         });
@@ -212,16 +218,6 @@ const addWaitingOutputInteractions = (elem, linkedInputClass) => {
     addWaitingOutputInteraction(getJpOutputCollapser(elem), getJpInputCollapser(elem), 'mouseover', 'add', linkedInputClass);
     addWaitingOutputInteraction(getJpOutputCollapser(elem), getJpInputCollapser(elem), 'mouseout', 'remove', linkedInputClass);
 };
-const refreshNodeMapping = (notebook) => {
-    cellsById = {};
-    cellModelsById = {};
-    orderIdxById = {};
-    notebook.widgets.forEach((cell, idx) => {
-        cellsById[cell.model.id] = cell.node;
-        cellModelsById[cell.model.id] = cell.model;
-        orderIdxById[cell.model.id] = idx;
-    });
-};
 const clearCellState = (notebook) => {
     notebook.widgets.forEach((cell) => {
         cell.node.classList.remove(waitingClass);
@@ -264,9 +260,10 @@ const addUnsafeCellInteraction = (elem, linkedElems, cellsById, collapserFun, ev
     attachCleanupListener(elem, evt, listener);
 };
 const connectToComm = (session, notebook) => {
-    resetState();
-    activeCell = notebook.activeCell;
-    activeCellId = activeCell.model.id;
+    initSessionState(session.session.id);
+    const state = ipyflowState[session.session.id];
+    state.activeCell = notebook.activeCell;
+    state.activeCellId = state.activeCell.model.id;
     const comm = session.session.kernel.createComm('ipyflow');
     let disconnected = false;
     const gatherCellMetadataAndContent = () => {
@@ -297,7 +294,7 @@ const connectToComm = (session, notebook) => {
             type: 'compute_exec_schedule',
             executed_cell_id: cell === null || cell === void 0 ? void 0 : cell.id,
             cell_metadata_by_id,
-            is_reactively_executing: isReactivelyExecuting,
+            is_reactively_executing: state.isReactivelyExecuting,
         });
     };
     const onExecution = (cell, args) => {
@@ -330,6 +327,16 @@ const connectToComm = (session, notebook) => {
         };
         comm.send(payload);
     };
+    const refreshNodeMapping = (notebook) => {
+        state.cellsById = {};
+        state.cellModelsById = {};
+        state.orderIdxById = {};
+        notebook.widgets.forEach((cell, idx) => {
+            state.cellsById[cell.model.id] = cell.node;
+            state.cellModelsById[cell.model.id] = cell.model;
+            state.orderIdxById[cell.model.id] = idx;
+        });
+    };
     const onActiveCellChange = (nb, cell) => {
         if (notebook !== nb) {
             return;
@@ -339,34 +346,33 @@ const connectToComm = (session, notebook) => {
             return;
         }
         notifyActiveCell(cell.model);
-        if (activeCell !== null && activeCell.model !== null) {
-            if (activeCell.model.isDirty) {
-                dirtyCells.add(activeCellId);
+        if (state.activeCell !== null && state.activeCell.model !== null) {
+            if (state.activeCell.model.isDirty) {
+                state.dirtyCells.add(state.activeCellId);
             }
             else {
-                dirtyCells.delete(activeCellId);
+                state.dirtyCells.delete(state.activeCellId);
             }
-            activeCell.model.stateChanged.disconnect(onExecution, activeCell.model.stateChanged);
+            state.activeCell.model.stateChanged.disconnect(onExecution, state.activeCell.model.stateChanged);
         }
-        activeCell = cell;
-        activeCellId = cell.model.id;
-        if (activeCell === null ||
-            activeCell.model === null ||
-            activeCell.model.type !== 'code') {
+        state.activeCell = cell;
+        state.activeCellId = cell.model.id;
+        if (state.activeCell === null ||
+            state.activeCell.model === null ||
+            state.activeCell.model.type !== 'code') {
             return;
         }
-        activeCell.model.stateChanged.connect(onExecution);
-        notifyActiveCell(activeCell.model);
-        if (dirtyCells.has(activeCellId)) {
-            const activeCellModel = activeCell.model;
+        state.activeCell.model.stateChanged.connect(onExecution);
+        notifyActiveCell(state.activeCell.model);
+        if (state.dirtyCells.has(state.activeCellId)) {
+            const activeCellModel = state.activeCell.model;
             if (activeCellModel._setDirty !== undefined) {
                 activeCellModel._setDirty(true);
             }
         }
         refreshNodeMapping(notebook);
-        updateOneCellUI(activeCellId);
+        updateOneCellUI(state.activeCellId);
     };
-    notebook.activeCellChanged.connect(onActiveCellChange);
     const actionUpdatePairs = [
         {
             action: 'mouseover',
@@ -378,7 +384,7 @@ const connectToComm = (session, notebook) => {
         },
     ];
     const updateOneCellUI = (id) => {
-        const model = cellModelsById[id];
+        const model = state.cellModelsById[id];
         if (model.type !== 'code') {
             return;
         }
@@ -386,88 +392,90 @@ const connectToComm = (session, notebook) => {
         if (codeModel.executionCount == null) {
             return;
         }
-        const elem = cellsById[id];
-        if (waitingCells.has(id)) {
+        const elem = state.cellsById[id];
+        if (state.waitingCells.has(id)) {
             elem.classList.add(waitingClass);
             elem.classList.add(readyClass);
             elem.classList.remove(readyMakingInputClass);
             addWaitingOutputInteractions(elem, linkedWaitingClass);
         }
-        else if (readyCells.has(id)) {
+        else if (state.readyCells.has(id)) {
             elem.classList.add(readyMakingInputClass);
             elem.classList.add(readyClass);
             addWaitingOutputInteractions(elem, linkedReadyMakerClass);
         }
-        if (lastExecutionMode === 'reactive') {
+        if (state.lastExecutionMode === 'reactive') {
             return;
         }
-        if (Object.prototype.hasOwnProperty.call(waiterLinks, id)) {
+        if (Object.prototype.hasOwnProperty.call(state.waiterLinks, id)) {
             actionUpdatePairs.forEach(({ action, update }) => {
-                addUnsafeCellInteraction(getJpInputCollapser(elem), waiterLinks[id], cellsById, getJpInputCollapser, action, update, waitingCells);
-                addUnsafeCellInteraction(getJpOutputCollapser(elem), waiterLinks[id], cellsById, getJpInputCollapser, action, update, waitingCells);
+                addUnsafeCellInteraction(getJpInputCollapser(elem), state.waiterLinks[id], state.cellsById, getJpInputCollapser, action, update, state.waitingCells);
+                addUnsafeCellInteraction(getJpOutputCollapser(elem), state.waiterLinks[id], state.cellsById, getJpInputCollapser, action, update, state.waitingCells);
             });
         }
-        if (Object.prototype.hasOwnProperty.call(readyMakerLinks, id)) {
-            if (!waitingCells.has(id)) {
+        if (Object.prototype.hasOwnProperty.call(state.readyMakerLinks, id)) {
+            if (!state.waitingCells.has(id)) {
                 elem.classList.add(readyMakingClass);
                 elem.classList.add(readyClass);
             }
             actionUpdatePairs.forEach(({ action, update }) => {
-                addUnsafeCellInteraction(getJpInputCollapser(elem), readyMakerLinks[id], cellsById, getJpInputCollapser, action, update, waitingCells);
-                addUnsafeCellInteraction(getJpInputCollapser(elem), readyMakerLinks[id], cellsById, getJpOutputCollapser, action, update, waitingCells);
+                addUnsafeCellInteraction(getJpInputCollapser(elem), state.readyMakerLinks[id], state.cellsById, getJpInputCollapser, action, update, state.waitingCells);
+                addUnsafeCellInteraction(getJpInputCollapser(elem), state.readyMakerLinks[id], state.cellsById, getJpOutputCollapser, action, update, state.waitingCells);
             });
         }
     };
     const updateUI = (notebook) => {
         clearCellState(notebook);
-        if (lastExecutionHighlights === 'none') {
+        if (state.lastExecutionHighlights === 'none') {
             return;
         }
         refreshNodeMapping(notebook);
-        for (const [id] of Object.entries(cellsById)) {
+        for (const [id] of Object.entries(state.cellsById)) {
             updateOneCellUI(id);
         }
     };
     comm.onMsg = (msg) => {
         var _a, _b;
         const payload = msg.content.data;
-        if (disconnected || !((_a = payload.success) !== null && _a !== void 0 ? _a : false)) {
+        if (disconnected || !((_a = payload.success) !== null && _a !== void 0 ? _a : true)) {
             return;
         }
         if (payload.type === 'establish') {
+            state.isIpyflowCommConnected = true;
+            notebook.activeCellChanged.connect(onActiveCellChange);
             notebook.activeCell.model.stateChanged.connect(onExecution);
             notifyActiveCell(notebook.activeCell.model);
             notebook.model.contentChanged.connect(onContentChanged);
             requestComputeExecSchedule();
         }
         else if (payload.type === 'set_exec_mode') {
-            isAltModeExecuting = false;
-            lastExecutionMode = payload.exec_mode;
+            state.isAltModeExecuting = false;
+            state.lastExecutionMode = payload.exec_mode;
         }
         else if (payload.type === 'compute_exec_schedule') {
-            waitingCells = new Set(payload.waiting_cells);
-            readyCells = new Set(payload.ready_cells);
-            newReadyCells = new Set([
-                ...newReadyCells,
+            state.waitingCells = new Set(payload.waiting_cells);
+            state.readyCells = new Set(payload.ready_cells);
+            state.newReadyCells = new Set([
+                ...state.newReadyCells,
                 ...payload.new_ready_cells,
             ]);
-            forcedReactiveCells = new Set([
-                ...forcedReactiveCells,
+            state.forcedReactiveCells = new Set([
+                ...state.forcedReactiveCells,
                 ...payload.forced_reactive_cells,
             ]);
-            waiterLinks = payload.waiter_links;
-            readyMakerLinks = payload.ready_maker_links;
-            cellPendingExecution = null;
+            state.waiterLinks = payload.waiter_links;
+            state.readyMakerLinks = payload.ready_maker_links;
+            state.cellPendingExecution = null;
             const exec_mode = payload.exec_mode;
-            isReactivelyExecuting =
-                isReactivelyExecuting ||
+            state.isReactivelyExecuting =
+                state.isReactivelyExecuting ||
                     ((_b = payload === null || payload === void 0 ? void 0 : payload.is_reactively_executing) !== null && _b !== void 0 ? _b : false);
             const flow_order = payload.flow_order;
             const exec_schedule = payload.exec_schedule;
-            lastExecutionMode = exec_mode;
-            lastExecutionHighlights = payload.highlights;
+            state.lastExecutionMode = exec_mode;
+            state.lastExecutionHighlights = payload.highlights;
             const lastExecutedCellId = payload.last_executed_cell_id;
-            executedReactiveReadyCells.add(lastExecutedCellId);
+            state.executedReactiveReadyCells.add(lastExecutedCellId);
             const last_execution_was_error = payload.last_execution_was_error;
             if (!last_execution_was_error) {
                 let lastExecutedCellIdSeen = false;
@@ -479,19 +487,19 @@ const connectToComm = (session, notebook) => {
                         }
                     }
                     if (cell.model.type !== 'code' ||
-                        executedReactiveReadyCells.has(cell.model.id)) {
+                        state.executedReactiveReadyCells.has(cell.model.id)) {
                         continue;
                     }
-                    if (!newReadyCells.has(cell.model.id)) {
+                    if (!state.newReadyCells.has(cell.model.id)) {
                         continue;
                     }
-                    if (!forcedReactiveCells.has(cell.model.id) &&
+                    if (!state.forcedReactiveCells.has(cell.model.id) &&
                         exec_mode !== 'reactive') {
                         continue;
                     }
                     const codeCell = cell;
-                    if (cellPendingExecution === null) {
-                        cellPendingExecution = codeCell;
+                    if (state.cellPendingExecution === null) {
+                        state.cellPendingExecution = codeCell;
                         // break early if using one of the order-based semantics
                         if (flow_order === 'in_order' || exec_schedule === 'strict') {
                             break;
@@ -501,34 +509,34 @@ const connectToComm = (session, notebook) => {
                         // pass
                     }
                     else if (codeCell.model.executionCount <
-                        cellPendingExecution.model.executionCount) {
+                        state.cellPendingExecution.model.executionCount) {
                         // otherwise, execute in order of earliest execution counter
-                        cellPendingExecution = codeCell;
+                        state.cellPendingExecution = codeCell;
                     }
                 }
             }
-            if (cellPendingExecution === null) {
-                if (isReactivelyExecuting) {
-                    if (lastExecutionHighlights === 'reactive') {
-                        readyCells = executedReactiveReadyCells;
+            if (state.cellPendingExecution === null) {
+                if (state.isReactivelyExecuting) {
+                    if (state.lastExecutionHighlights === 'reactive') {
+                        state.readyCells = state.executedReactiveReadyCells;
                     }
                     comm.send({
                         type: 'reactivity_cleanup',
                     });
                 }
-                forcedReactiveCells = new Set();
-                newReadyCells = new Set();
-                executedReactiveReadyCells = new Set();
+                state.forcedReactiveCells = new Set();
+                state.newReadyCells = new Set();
+                state.executedReactiveReadyCells = new Set();
                 updateUI(notebook);
-                isReactivelyExecuting = false;
-                if (lastExecutionMode === 'reactive') {
-                    isAltModeExecuting = false;
+                state.isReactivelyExecuting = false;
+                if (state.lastExecutionMode === 'reactive') {
+                    state.isAltModeExecuting = false;
                 }
             }
             else {
-                isReactivelyExecuting = true;
-                onActiveCellChange(notebook, cellPendingExecution);
-                CodeCell.execute(cellPendingExecution, session);
+                state.isReactivelyExecuting = true;
+                onActiveCellChange(notebook, state.cellPendingExecution);
+                CodeCell.execute(state.cellPendingExecution, session);
             }
         }
     };
@@ -537,8 +545,10 @@ const connectToComm = (session, notebook) => {
     });
     // return a disconnection handle
     return () => {
+        comm.dispose();
         disconnected = true;
-        resetState();
+        state.isIpyflowCommConnected = false;
+        resetSessionState(session.session.id);
     };
 };
 export default extension;

package/package.json

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