@jupyterlab/notebook 4.7.0-alpha.1 → 4.7.0-alpha.2

package/lib/widget.js

@@ -301,6 +301,12 @@ export class StaticNotebook extends WindowedList {
             this._contentVisibilityObserver = null;
         }
         super.dispose();
+        // Dispose cells that windowing modes may have detached from the layout.
+        for (const cell of this.cellsArray) {
+            cell.dispose();
+        }
+        this.cellsArray.length = 0;
+        this.viewModel.dispose();
     }
     onBeforeDetach(msg) {
         //  Disconnect the content-visibility observer
@@ -510,7 +516,7 @@ export class StaticNotebook extends WindowedList {
         for (const cell of cells) {
             this._insertCell(++index, cell);
         }
-        this._syncMarkdownCellTrust();
+        this._syncCellTrust();
         newValue.cells.changed.connect(this._onCellsChanged, this);
         newValue.metadataChanged.connect(this.onMetadataChanged, this);
         newValue.contentChanged.connect(this.onModelContentChanged, this);
@@ -562,7 +568,7 @@ export class StaticNotebook extends WindowedList {
         if (!this.model.sharedModel.cells.length) {
             this.addHeader();
         }
-        this._syncMarkdownCellTrust();
+        this._syncCellTrust();
         this.update();
     }
     /**
@@ -588,7 +594,7 @@ export class StaticNotebook extends WindowedList {
         widget.inViewportChanged.connect(this._onCellInViewportChanged, this);
         widget.addClass(NB_CELL_CLASS);
         ArrayExt.insert(this.cellsArray, index, widget);
-        this._syncMarkdownCellTrust(widget);
+        this._syncCellTrust(widget);
         this.onCellInserted(index, widget);
         this._scheduleCellRenderOnIdle();
     }
@@ -692,8 +698,8 @@ export class StaticNotebook extends WindowedList {
         this.onCellRemoved(index, widget);
         widget.dispose();
     }
-    _shouldTrustMarkdown() {
-        // Note: this returns false in a notebook without trsuted code cells;
+    _shouldTrustCell() {
+        // Note: this returns false in a notebook without trusted code cells;
         // This is intended since only Code cells carry trust status on disk.
         if (!this._notebookModel) {
             return false;
@@ -709,12 +715,18 @@ export class StaticNotebook extends WindowedList {
         }
         return hasCodeCell;
     }
-    _syncMarkdownCellTrust(cell) {
-        const trusted = this._shouldTrustMarkdown();
+    _syncCellTrust(cell) {
+        const trusted = this._shouldTrustCell();
         const trustHandler = this.rendermime.trustHandler;
         if (!trustHandler) {
             return;
         }
+        if (trusted) {
+            trustHandler.markTrusted(this.node);
+        }
+        else {
+            trustHandler.unmarkTrusted(this.node);
+        }
         const cells = cell ? [cell] : this.widgets;
         for (const widget of cells) {
             if (!(widget instanceof MarkdownCell)) {
@@ -730,7 +742,7 @@ export class StaticNotebook extends WindowedList {
     }
     _onCellStateChanged(model, args) {
         if (args.name === 'trusted') {
-            this._syncMarkdownCellTrust();
+            this._syncCellTrust();
         }
     }
     /**
@@ -827,7 +839,7 @@ export class StaticNotebook extends WindowedList {
     }
     _scheduleCellRenderOnIdle() {
         if (this.notebookConfig.windowingMode !== 'none' && !this.isDisposed) {
-            if (!this._idleCallBack) {
+            if (this._idleCallBack === null) {
                 this._idleCallBack = requestIdleCallback((deadline) => {
                     this._idleCallBack = null;
                     // In case of timeout, render for some time even if it means freezing the UI
@@ -908,7 +920,7 @@ export class StaticNotebook extends WindowedList {
             }
         }
         else {
-            if (this._idleCallBack) {
+            if (this._idleCallBack !== null) {
                 window.cancelIdleCallback(this._idleCallBack);
                 this._idleCallBack = null;
             }
@@ -1012,7 +1024,7 @@ export class StaticNotebook extends WindowedList {
                     this._contentVisibilityObserver.observe(cell.node);
                 });
             });
-        });
+        }, this);
     }
 }
 /**
@@ -1190,7 +1202,7 @@ class ScrollbarItem {
             else if (model.executionState == 'running') {
                 content = '[*]';
             }
-            else if (model.executionCount) {
+            else if (model.executionCount !== null) {
                 content = `[${model.executionCount}]`;
             }
             else {
@@ -2348,6 +2360,67 @@ export class Notebook extends StaticNotebook {
             });
         }
     }
+    /**
+     * Find the cell containing a node, traversing open shadow roots.
+     *
+     * Returned cell is `null` if the node is not in a cell of this notebook.
+     */
+    _cellContaining(node) {
+        let current = node;
+        while (current) {
+            const element = current instanceof Element ? current : current.parentElement;
+            if (element) {
+                const index = this._findCell(element);
+                if (index !== -1) {
+                    return this.widgets[index];
+                }
+            }
+            const root = (element !== null && element !== void 0 ? element : current).getRootNode();
+            current = root instanceof ShadowRoot ? root.host : null;
+        }
+        return null;
+    }
+    /**
+     * Whether a shift-click on `target` should be left to the browser to handle
+     * as an extension of the current text selection, rather than be turned into
+     * a cell range selection.
+     *
+     * This is the case when the click lands in a region of a cell whose text the
+     * browser selects - the output area of a code cell, or the rendered input of
+     * a rendered markdown cell - and the current selection starts in such a
+     * region too; see https://github.com/jupyterlab/jupyterlab/issues/4800. A
+     * click on a cell prompt, on cell chrome, or on a cell without such a region
+     * (an unrendered markdown cell, a code cell without outputs) always selects
+     * cells.
+     *
+     * #### Notes
+     * Only the anchor of the selection is considered, because a shift-click
+     * moves the focus and leaves the anchor in place. The anchor may sit in a
+     * different cell than the one clicked, which is what allows a selection to
+     * be extended across the outputs of several cells; and disregarding the
+     * focus keeps this working when a drag overshot the edge of an output and
+     * left the focus outside of it.
+     *
+     * This trade-off between extending the text selection and extending the cell
+     * selection can be adjusted in the future. For now the text selection wins to
+     * preserve the behaviour from before refactor that users may be accustomed to.
+     */
+    _isExtendingTextSelection(selection, targetCell, target) {
+        if (!selection || selection.isCollapsed) {
+            return false;
+        }
+        if (!Private.isInTextRegion(targetCell, target)) {
+            return false;
+        }
+        const { anchorNode } = selection;
+        // The selection usually starts in the very cell which was clicked, which
+        // can be checked without having to locate the cell of the anchor.
+        if (Private.isInTextRegion(targetCell, anchorNode)) {
+            return true;
+        }
+        const anchorCell = this._cellContaining(anchorNode);
+        return !!anchorCell && Private.isInTextRegion(anchorCell, anchorNode);
+    }
     /**
      * Find the cell index containing the target html element.
      *
@@ -2552,15 +2625,18 @@ export class Notebook extends StaticNotebook {
             this.deselectAll();
         }
         else if (targetArea === 'prompt' || targetArea === 'cell') {
-            // We don't want to prevent the default selection behavior
-            // if there is currently text selected in an output.
-            const hasSelection = ((_c = window.getSelection()) !== null && _c !== void 0 ? _c : '').toString() !== '';
             if (button === 0 &&
                 shiftKey &&
-                !hasSelection &&
-                !['INPUT', 'OPTION'].includes(target.tagName)) {
+                !['INPUT', 'OPTION'].includes(target.tagName) &&
+                // We don't want to prevent the default selection behavior when the
+                // user is extending a text selection into the clicked region.
+                !this._isExtendingTextSelection(window.getSelection(), widget, target)) {
                 // Prevent browser selecting text in prompt or output
                 event.preventDefault();
+                // Preventing the default also stops the browser from collapsing any
+                // text selection which is already there; drop it explicitly so that
+                // stale highlighted text is not left over the new cell selection.
+                (_c = window.getSelection()) === null || _c === void 0 ? void 0 : _c.removeAllRanges();
                 // Shift-click - extend selection
                 try {
                     this.extendContiguousSelectionTo(index);
@@ -2841,7 +2917,7 @@ export class Notebook extends StaticNotebook {
             const executionCount = activeCell.model
                 .executionCount;
             countString = ' ';
-            if (executionCount) {
+            if (executionCount !== null) {
                 countString = executionCount.toString();
             }
         }
@@ -3101,6 +3177,60 @@ var Private;
         }
     }
     Private.NotebookPanelLayout = NotebookPanelLayout;
+    /**
+     * Check whether `node` is `parent` or a descendant of it.
+     *
+     * Unlike `Node.contains()` this traverses out of open shadow roots, so a
+     * node rendered by a widget library which attaches a shadow root (such as
+     * Panel or Bokeh) is still recognised as belonging to its host subtree.
+     */
+    function containsDeep(parent, node) {
+        let current = node;
+        while (current) {
+            if (parent.contains(current)) {
+                return true;
+            }
+            const root = current.getRootNode();
+            current = root instanceof ShadowRoot ? root.host : null;
+        }
+        return false;
+    }
+    /**
+     * Whether a cell exposes an output area.
+     *
+     * #### Notes
+     * This is a structural check rather than `instanceof CodeCell` so that it
+     * still holds when a federated extension loads its own copy of
+     * `@jupyterlab/cells`.
+     */
+    function hasOutputArea(cell) {
+        return 'outputArea' in cell;
+    }
+    /**
+     * The regions of a cell whose text the browser, rather than the notebook,
+     * is responsible for selecting: the output area of a code cell and the
+     * rendered input of a cell which renders it, such as a rendered markdown
+     * cell.
+     */
+    function textRegionsOf(cell) {
+        var _a;
+        const regions = [];
+        if (hasOutputArea(cell)) {
+            regions.push(cell.outputArea.node);
+        }
+        const rendered = (_a = cell.inputArea) === null || _a === void 0 ? void 0 : _a.renderedInput;
+        if (rendered) {
+            regions.push(rendered.node);
+        }
+        return regions;
+    }
+    /**
+     * Whether a node is in a region of a cell whose text the browser selects.
+     */
+    function isInTextRegion(cell, node) {
+        return textRegionsOf(cell).some(region => containsDeep(region, node));
+    }
+    Private.isInTextRegion = isInTextRegion;
     /**
      * Create a cell drag image.
      */