jupyterlab-ipyflow 0.0.87 → 0.0.90

package/lib/index.js

@@ -48,17 +48,17 @@ const extension = {
         });
     }
 };
-const staleClass = 'stale-cell';
-const freshClass = 'fresh-cell';
-const refresherClass = 'refresher-cell';
-const refresherInputClass = 'refresher-input-cell';
-const linkedStaleClass = 'linked-stale';
-const linkedRefresherClass = 'linked-refresher';
+const waitingClass = 'waiting-cell';
+const readyClass = 'ready-cell';
+const readyMakingClass = 'ready-making-cell';
+const readyMakingInputClass = 'ready-making-input-cell';
+const linkedWaitingClass = 'linked-waiting';
+const linkedReadyMakerClass = 'linked-ready-maker';
 let dirtyCells = new Set();
-let staleCells = new Set();
-let freshCells = new Set();
-let staleLinks = {};
-let refresherLinks = {};
+let waitingCells = new Set();
+let readyCells = new Set();
+let waiterLinks = {};
+let readyMakerLinks = {};
 let activeCell = null;
 let activeCellId = null;
 let cellsById = {};
@@ -66,10 +66,15 @@ let orderIdxById = {};
 let cellPendingExecution = null;
 let lastExecutionMode = null;
 let lastExecutionHighlightsEnabled = null;
-let executedReactiveFreshCells = new Set();
-let newFreshCells = new Set();
+let executedReactiveReadyCells = new Set();
+let newReadyCells = new Set();
 let forcedReactiveCells = new Set();
 const cleanup = new Event('cleanup');
+const resetReactiveState = () => {
+    newReadyCells = new Set();
+    forcedReactiveCells = new Set();
+    executedReactiveReadyCells = new Set();
+};
 const getJpInputCollapser = (elem) => {
     if (elem === null || elem === undefined) {
         return null;
@@ -98,7 +103,7 @@ const attachCleanupListener = (elem, evt, listener) => {
     elem.addEventListener(evt, listener);
     elem.addEventListener('cleanup', cleanupListener);
 };
-const addStaleOutputInteraction = (elem, linkedElem, evt, add_or_remove, css) => {
+const addWaitingOutputInteraction = (elem, linkedElem, evt, add_or_remove, css) => {
     if (elem === null || linkedElem === null) {
         return;
     }
@@ -107,11 +112,11 @@ const addStaleOutputInteraction = (elem, linkedElem, evt, add_or_remove, css) =>
     };
     attachCleanupListener(elem, evt, listener);
 };
-const addStaleOutputInteractions = (elem, linkedInputClass) => {
-    addStaleOutputInteraction(getJpInputCollapser(elem), getJpOutputCollapser(elem), 'mouseover', 'add', linkedStaleClass);
-    addStaleOutputInteraction(getJpInputCollapser(elem), getJpOutputCollapser(elem), 'mouseout', 'remove', linkedStaleClass);
-    addStaleOutputInteraction(getJpOutputCollapser(elem), getJpInputCollapser(elem), 'mouseover', 'add', linkedInputClass);
-    addStaleOutputInteraction(getJpOutputCollapser(elem), getJpInputCollapser(elem), 'mouseout', 'remove', linkedInputClass);
+const addWaitingOutputInteractions = (elem, linkedInputClass) => {
+    addWaitingOutputInteraction(getJpInputCollapser(elem), getJpOutputCollapser(elem), 'mouseover', 'add', linkedWaitingClass);
+    addWaitingOutputInteraction(getJpInputCollapser(elem), getJpOutputCollapser(elem), 'mouseout', 'remove', linkedWaitingClass);
+    addWaitingOutputInteraction(getJpOutputCollapser(elem), getJpInputCollapser(elem), 'mouseover', 'add', linkedInputClass);
+    addWaitingOutputInteraction(getJpOutputCollapser(elem), getJpInputCollapser(elem), 'mouseout', 'remove', linkedInputClass);
 };
 const refreshNodeMapping = (notebook) => {
     cellsById = {};
@@ -123,34 +128,34 @@ const refreshNodeMapping = (notebook) => {
 };
 const clearCellState = (notebook) => {
     notebook.widgets.forEach((cell, idx) => {
-        cell.node.classList.remove(staleClass);
-        cell.node.classList.remove(refresherClass);
-        cell.node.classList.remove(freshClass);
-        cell.node.classList.remove(refresherInputClass);
+        cell.node.classList.remove(waitingClass);
+        cell.node.classList.remove(readyMakingClass);
+        cell.node.classList.remove(readyClass);
+        cell.node.classList.remove(readyMakingInputClass);
         // clear any old event listeners
         const inputCollapser = getJpInputCollapser(cell.node);
         if (inputCollapser !== null) {
-            inputCollapser.firstElementChild.classList.remove(linkedStaleClass);
-            inputCollapser.firstElementChild.classList.remove(linkedRefresherClass);
+            inputCollapser.firstElementChild.classList.remove(linkedWaitingClass);
+            inputCollapser.firstElementChild.classList.remove(linkedReadyMakerClass);
             inputCollapser.dispatchEvent(cleanup);
         }
         const outputCollapser = getJpOutputCollapser(cell.node);
         if (outputCollapser !== null) {
-            outputCollapser.firstElementChild.classList.remove(linkedStaleClass);
-            outputCollapser.firstElementChild.classList.remove(linkedRefresherClass);
+            outputCollapser.firstElementChild.classList.remove(linkedWaitingClass);
+            outputCollapser.firstElementChild.classList.remove(linkedReadyMakerClass);
             outputCollapser.dispatchEvent(cleanup);
         }
     });
 };
-const addUnsafeCellInteraction = (elem, linkedElems, cellsById, collapserFun, evt, add_or_remove, staleCells) => {
+const addUnsafeCellInteraction = (elem, linkedElems, cellsById, collapserFun, evt, add_or_remove, waitingCells) => {
     if (elem === null) {
         return;
     }
     const listener = () => {
         for (const linkedId of linkedElems) {
-            let css = linkedRefresherClass;
-            if (staleCells.has(linkedId)) {
-                css = linkedStaleClass;
+            let css = linkedReadyMakerClass;
+            if (waitingCells.has(linkedId)) {
+                css = linkedWaitingClass;
             }
             const collapser = collapserFun(cellsById[linkedId]);
             if (collapser === null || collapser.firstElementChild === null) {
@@ -174,17 +179,20 @@ const connectToComm = (session, notebook) => {
             return;
         }
         const order_index_by_cell_id = {};
+        const content_by_cell_id = {};
         notebook.widgets.forEach((itercell, idx) => {
             order_index_by_cell_id[itercell.model.id] = idx;
+            content_by_cell_id[itercell.model.id] = itercell.model.value.text;
             if (itercell.model.id === cell.id) {
-                itercell.node.classList.remove(freshClass);
-                itercell.node.classList.remove(refresherInputClass);
+                itercell.node.classList.remove(readyClass);
+                itercell.node.classList.remove(readyMakingInputClass);
             }
         });
         const payload = {
-            type: 'cell_freshness',
+            type: 'compute_exec_schedule',
             executed_cell_id: cell.id,
             order_index_by_cell_id: order_index_by_cell_id,
+            content_by_cell_id: content_by_cell_id,
         };
         comm.send(payload).done.then(() => {
             if (cellPendingExecution !== null) {
@@ -192,12 +200,10 @@ const connectToComm = (session, notebook) => {
             }
             else {
                 if (lastExecutionMode === 'reactive') {
-                    freshCells = executedReactiveFreshCells;
+                    readyCells = executedReactiveReadyCells;
                     updateUI(notebook);
                 }
-                newFreshCells = new Set();
-                forcedReactiveCells = new Set();
-                executedReactiveFreshCells = new Set();
+                resetReactiveState();
                 comm.send({
                     type: 'reactivity_cleanup',
                 });
@@ -264,36 +270,36 @@ const connectToComm = (session, notebook) => {
     ];
     const updateOneCellUI = (id) => {
         const elem = cellsById[id];
-        if (staleCells.has(id)) {
-            elem.classList.add(staleClass);
-            elem.classList.add(freshClass);
-            elem.classList.remove(refresherInputClass);
-            addStaleOutputInteractions(elem, linkedStaleClass);
+        if (waitingCells.has(id)) {
+            elem.classList.add(waitingClass);
+            elem.classList.add(readyClass);
+            elem.classList.remove(readyMakingInputClass);
+            addWaitingOutputInteractions(elem, linkedWaitingClass);
         }
-        else if (freshCells.has(id)) {
-            elem.classList.add(refresherInputClass);
+        else if (readyCells.has(id)) {
+            elem.classList.add(readyMakingInputClass);
             if (lastExecutionMode === 'normal') {
-                elem.classList.add(freshClass);
-                addStaleOutputInteractions(elem, linkedRefresherClass);
+                elem.classList.add(readyClass);
+                addWaitingOutputInteractions(elem, linkedReadyMakerClass);
             }
         }
         if (lastExecutionMode === 'reactive') {
             return;
         }
-        if (staleLinks.hasOwnProperty(id)) {
+        if (waiterLinks.hasOwnProperty(id)) {
             actionUpdatePairs.forEach(({ action, update }) => {
-                addUnsafeCellInteraction(getJpInputCollapser(elem), staleLinks[id], cellsById, getJpInputCollapser, action, update, staleCells);
-                addUnsafeCellInteraction(getJpOutputCollapser(elem), staleLinks[id], cellsById, getJpInputCollapser, action, update, staleCells);
+                addUnsafeCellInteraction(getJpInputCollapser(elem), waiterLinks[id], cellsById, getJpInputCollapser, action, update, waitingCells);
+                addUnsafeCellInteraction(getJpOutputCollapser(elem), waiterLinks[id], cellsById, getJpInputCollapser, action, update, waitingCells);
             });
         }
-        if (refresherLinks.hasOwnProperty(id)) {
-            if (!staleCells.has(id)) {
-                elem.classList.add(refresherClass);
-                elem.classList.add(freshClass);
+        if (readyMakerLinks.hasOwnProperty(id)) {
+            if (!waitingCells.has(id)) {
+                elem.classList.add(readyMakingClass);
+                elem.classList.add(readyClass);
             }
             actionUpdatePairs.forEach(({ action, update }) => {
-                addUnsafeCellInteraction(getJpInputCollapser(elem), refresherLinks[id], cellsById, getJpInputCollapser, action, update, staleCells);
-                addUnsafeCellInteraction(getJpInputCollapser(elem), refresherLinks[id], cellsById, getJpOutputCollapser, action, update, staleCells);
+                addUnsafeCellInteraction(getJpInputCollapser(elem), readyMakerLinks[id], cellsById, getJpInputCollapser, action, update, waitingCells);
+                addUnsafeCellInteraction(getJpInputCollapser(elem), readyMakerLinks[id], cellsById, getJpOutputCollapser, action, update, waitingCells);
             });
         }
     };
@@ -315,44 +321,51 @@ const connectToComm = (session, notebook) => {
             notebook.activeCell.model.stateChanged.connect(onExecution);
             notifyActiveCell(notebook.activeCell.model);
         }
-        else if (msg.content.data['type'] === 'cell_freshness') {
-            staleCells = new Set(msg.content.data['stale_cells']);
-            freshCells = new Set(msg.content.data['fresh_cells']);
-            newFreshCells = new Set([...newFreshCells, ...msg.content.data['new_fresh_cells']]);
+        else if (msg.content.data['type'] === 'compute_exec_schedule') {
+            waitingCells = new Set(msg.content.data['waiting_cells']);
+            readyCells = new Set(msg.content.data['ready_cells']);
+            newReadyCells = new Set([...newReadyCells, ...msg.content.data['new_ready_cells']]);
             forcedReactiveCells = new Set([...forcedReactiveCells, ...msg.content.data['forced_reactive_cells']]);
-            staleLinks = msg.content.data['stale_links'];
-            refresherLinks = msg.content.data['refresher_links'];
+            waiterLinks = msg.content.data['waiter_links'];
+            readyMakerLinks = msg.content.data['ready_maker_links'];
             cellPendingExecution = null;
             const exec_mode = msg.content.data['exec_mode'];
             const flow_order = msg.content.data['flow_order'];
             const exec_schedule = msg.content.data['exec_schedule'];
             lastExecutionMode = exec_mode;
             lastExecutionHighlightsEnabled = msg.content.data['highlights_enabled'];
-            executedReactiveFreshCells.add(msg.content.data['last_executed_cell_id']);
-            let found = false;
-            notebook.widgets.forEach(cell => {
-                if (found || cell.model.type !== 'code' || executedReactiveFreshCells.has(cell.model.id)) {
-                    return;
+            executedReactiveReadyCells.add(msg.content.data['last_executed_cell_id']);
+            for (const cell of notebook.widgets) {
+                if (cell.model.type !== 'code' || executedReactiveReadyCells.has(cell.model.id)) {
+                    continue;
                 }
-                if ((exec_mode === 'reactive' && newFreshCells.has(cell.model.id)) || forcedReactiveCells.has(cell.model.id)) {
-                    const codeCell = cell;
-                    if (cellPendingExecution === null) {
-                        cellPendingExecution = codeCell;
-                        // break early if using one of the order-based semantics
-                        found = (flow_order === 'in_order' || exec_schedule === 'strict');
+                if (!forcedReactiveCells.has(cell.model.id)) {
+                    if (exec_mode !== 'reactive' || !newReadyCells.has(cell.model.id)) {
+                        continue;
                     }
-                    else if (codeCell.model.executionCount !== null && codeCell.model.executionCount < cellPendingExecution.model.executionCount) {
-                        // otherwise, execute in order of earliest execution counter
-                        cellPendingExecution = codeCell;
+                }
+                const codeCell = cell;
+                if (cellPendingExecution === null) {
+                    cellPendingExecution = codeCell;
+                    // break early if using one of the order-based semantics
+                    if (flow_order === 'in_order' || exec_schedule === 'strict') {
+                        break;
                     }
                 }
-            });
+                else if (codeCell.model.executionCount == null) {
+                    // pass
+                }
+                else if (codeCell.model.executionCount < cellPendingExecution.model.executionCount) {
+                    // otherwise, execute in order of earliest execution counter
+                    cellPendingExecution = codeCell;
+                }
+            }
             if (cellPendingExecution === null) {
-                newFreshCells = new Set();
-                forcedReactiveCells = new Set();
+                resetReactiveState();
                 updateUI(notebook);
             }
             else {
+                onActiveCellChange(notebook, cellPendingExecution);
                 clearCellState(notebook);
             }
         }

package/package.json

@@ -65,5 +65,5 @@
     "extension": true,
     "outputDir": "../../core/ipyflow/resources/labextension/"
   },
-  "version": "0.0.87"
+  "version": "0.0.90"
 }

package/style/index.css

@@ -1,64 +1,64 @@
 :root {
-  --stale-color: rgb(254,0,82);
-  --refresher-color: rgb(0,197,158);
+  --waiting-color: rgb(254,0,82);
+  --ready-making-color: rgb(0,197,158);
 }
 
-.stale-cell .jp-InputCollapser {
-  border: 1px solid var(--stale-color);
+.waiting-cell .jp-InputCollapser {
+  border: 1px solid var(--waiting-color);
 }
 
-.stale-cell.jp-mod-selected .jp-Collapser-child {
-  background-color: var(--stale-color);
+.waiting-cell.jp-mod-selected .jp-Collapser-child {
+  background-color: var(--waiting-color);
 }
 
-.stale-cell .jp-Collapser:hover > .jp-Collapser-child {
-  background-color: var(--stale-color);
+.waiting-cell .jp-Collapser:hover > .jp-Collapser-child {
+  background-color: var(--waiting-color);
 }
 
-.jp-Collapser-child.linked-stale {
-  background-color: var(--stale-color);
+.jp-Collapser-child.linked-waiting {
+  background-color: var(--waiting-color);
   opacity: 0.6;
 }
 
-.refresher-cell .jp-InputCollapser {
-  border: 1px solid var(--refresher-color);
+.ready-making-cell .jp-InputCollapser {
+  border: 1px solid var(--ready-making-color);
 }
 
-.refresher-cell.jp-mod-selected .jp-Collapser-child {
-  background-color: var(--refresher-color);
+.ready-making-cell.jp-mod-selected .jp-Collapser-child {
+  background-color: var(--ready-making-color);
 }
 
-.refresher-cell .jp-Collapser:hover > .jp-Collapser-child {
-  background-color: var(--refresher-color);
+.ready-making-cell .jp-Collapser:hover > .jp-Collapser-child {
+  background-color: var(--ready-making-color);
 }
 
-.jp-Collapser-child.linked-refresher {
-  background-color: var(--refresher-color);
+.jp-Collapser-child.linked-ready-maker {
+  background-color: var(--ready-making-color);
   opacity: 0.6;
 }
 
 /* put input / output cells later since they should take precedence */
 
-.fresh-cell .jp-OutputCollapser {
-  border: 1px solid var(--stale-color);
+.ready-cell .jp-OutputCollapser {
+  border: 1px solid var(--waiting-color);
 }
 
-.fresh-cell.jp-mod-selected .jp-OutputCollapser .jp-Collapser-child {
-  background-color: var(--stale-color);
+.ready-cell.jp-mod-selected .jp-OutputCollapser .jp-Collapser-child {
+  background-color: var(--waiting-color);
 }
 
-.fresh-cell .jp-OutputCollapser:hover > .jp-Collapser-child {
-  background-color: var(--stale-color);
+.ready-cell .jp-OutputCollapser:hover > .jp-Collapser-child {
+  background-color: var(--waiting-color);
 }
 
-.refresher-input-cell .jp-InputCollapser {
-  border: 1px solid var(--refresher-color);
+.ready-making-input-cell .jp-InputCollapser {
+  border: 1px solid var(--ready-making-color);
 }
 
-.refresher-input-cell.jp-mod-selected .jp-InputCollapser .jp-Collapser-child {
-  background-color: var(--refresher-color);
+.ready-making-input-cell.jp-mod-selected .jp-InputCollapser .jp-Collapser-child {
+  background-color: var(--ready-making-color);
 }
 
-.refresher-input-cell .jp-InputCollapser:hover > .jp-Collapser-child {
-  background-color: var(--refresher-color);
+.ready-making-input-cell .jp-InputCollapser:hover > .jp-Collapser-child {
+  background-color: var(--ready-making-color);
 }