@codingame/monaco-vscode-api 2.2.2 → 3.1.0

package/vscode/src/vs/workbench/contrib/notebook/browser/view/cellParts/cellActionView.js

@@ -1,6 +1,14 @@
+import { __decorate, __param } from '../../../../../../../../../external/tslib/tslib.es6.js';
 import { renderLabelWithIcons } from '../../../../../../base/browser/ui/iconLabel/iconLabels.js';
 import { reset } from '../../../../../../base/browser/dom.js';
-import { MenuEntryActionViewItem } from '../../../../../../platform/actions/browser/menuEntryActionViewItem.js';
+import { MenuEntryActionViewItem, SubmenuEntryActionViewItem } from '../../../../../../platform/actions/browser/menuEntryActionViewItem.js';
+import { MenuItemAction } from '../../../../../../platform/actions/common/actions.js';
+import { IContextMenuService } from '../../../../../../platform/contextview/browser/contextView.js';
+import { IKeybindingService } from '../../../../../../platform/keybinding/common/keybinding.js';
+import { IThemeService } from '../../../../../../platform/theme/common/themeService.js';
+import { ThemeIcon } from '../../../../../../base/common/themables.js';
+import { setupCustomHover } from '../../../../../../base/browser/ui/iconLabel/iconLabelHover.js';
+import { getDefaultHoverDelegate } from '../../../../../../base/browser/ui/hover/hoverDelegate.js';
 class CodiconActionViewItem extends MenuEntryActionViewItem {
     updateLabel() {
         if (this.options.label && this.label) {
@@ -20,8 +28,59 @@ class ActionViewWithLabel extends MenuEntryActionViewItem {
         if (this._actionLabel) {
             this._actionLabel.classList.add('notebook-label');
             this._actionLabel.innerText = this._action.label;
-            this._actionLabel.title = this._action.tooltip.length ? this._action.tooltip : this._action.label;
         }
     }
 }
-export { ActionViewWithLabel, CodiconActionViewItem };
+let UnifiedSubmenuActionView = class UnifiedSubmenuActionView extends SubmenuEntryActionViewItem {
+    constructor(action, options, renderLabel, subActionProvider, subActionViewItemProvider, _keybindingService, _contextMenuService, _themeService) {
+        super(action, options, _keybindingService, _contextMenuService, _themeService);
+        this.renderLabel = renderLabel;
+        this.subActionProvider = subActionProvider;
+        this.subActionViewItemProvider = subActionViewItemProvider;
+    }
+    render(container) {
+        super.render(container);
+        container.classList.add('notebook-action-view-item');
+        this._actionLabel = document.createElement('a');
+        container.appendChild(this._actionLabel);
+        const hoverDelegate = this.options.hoverDelegate ?? getDefaultHoverDelegate('element');
+        this._hover = this._register(setupCustomHover(hoverDelegate, this._actionLabel, ''));
+        this.updateLabel();
+    }
+    updateLabel() {
+        const actions = this.subActionProvider.getActions();
+        if (this._actionLabel) {
+            const primaryAction = actions[0];
+            if (primaryAction && primaryAction instanceof MenuItemAction) {
+                const element = this.element;
+                if (element && primaryAction.item.icon && ThemeIcon.isThemeIcon(primaryAction.item.icon)) {
+                    const iconClasses = ThemeIcon.asClassNameArray(primaryAction.item.icon);
+                    element.classList.forEach((cl) => {
+                        if (cl.startsWith('codicon-')) {
+                            element.classList.remove(cl);
+                        }
+                    });
+                    element.classList.add(...iconClasses);
+                }
+                if (this.renderLabel) {
+                    this._actionLabel.classList.add('notebook-label');
+                    this._actionLabel.innerText = this._action.label;
+                    this._hover?.update(primaryAction.tooltip.length ? primaryAction.tooltip : primaryAction.label);
+                }
+            }
+            else {
+                if (this.renderLabel) {
+                    this._actionLabel.classList.add('notebook-label');
+                    this._actionLabel.innerText = this._action.label;
+                    this._hover?.update(this._action.tooltip.length ? this._action.tooltip : this._action.label);
+                }
+            }
+        }
+    }
+};
+UnifiedSubmenuActionView = ( __decorate([
+    ( __param(5, IKeybindingService)),
+    ( __param(6, IContextMenuService)),
+    ( __param(7, IThemeService))
+], UnifiedSubmenuActionView));
+export { ActionViewWithLabel, CodiconActionViewItem, UnifiedSubmenuActionView };

package/vscode/src/vs/workbench/contrib/notebook/browser/view/cellParts/cellEditorOptions.js

@@ -11,6 +11,33 @@ import { NOTEBOOK_EDITOR_FOCUSED, NOTEBOOK_CELL_LINE_NUMBERS } from '../../../co
 import { CellContentPart } from '../cellPart.js';
 import { NOTEBOOK_EDITOR_ID } from '../../../common/notebookCommon.js';
 class CellEditorOptions extends CellContentPart {
+    set tabSize(value) {
+        if (this._tabSize !== value) {
+            this._tabSize = value;
+            this._onDidChange.fire();
+        }
+    }
+    get tabSize() {
+        return this._tabSize;
+    }
+    set indentSize(value) {
+        if (this._indentSize !== value) {
+            this._indentSize = value;
+            this._onDidChange.fire();
+        }
+    }
+    get indentSize() {
+        return this._indentSize;
+    }
+    set insertSpaces(value) {
+        if (this._insertSpaces !== value) {
+            this._insertSpaces = value;
+            this._onDidChange.fire();
+        }
+    }
+    get insertSpaces() {
+        return this._insertSpaces;
+    }
     constructor(base, notebookOptions, configurationService) {
         super();
         this.base = base;
@@ -35,6 +62,19 @@ class CellEditorOptions extends CellContentPart {
     }
     _computeEditorOptions() {
         const value = this.base.value;
+        const cellEditorOverridesRaw = this.notebookOptions.getDisplayOptions().editorOptionsCustomizations;
+        const indentSize = cellEditorOverridesRaw['editor.indentSize'];
+        if (indentSize !== undefined) {
+            this.indentSize = indentSize;
+        }
+        const insertSpaces = cellEditorOverridesRaw['editor.insertSpaces'];
+        if (insertSpaces !== undefined) {
+            this.insertSpaces = insertSpaces;
+        }
+        const tabSize = cellEditorOverridesRaw['editor.tabSize'];
+        if (tabSize !== undefined) {
+            this.tabSize = tabSize;
+        }
         let cellRenderLineNumber = value.lineNumbers;
         switch (this._lineNumbers) {
             case 'inherit':

package/vscode/src/vs/workbench/contrib/notebook/browser/view/cellParts/cellOutput.js

@@ -115,6 +115,7 @@ let CellOutputElement = class CellOutputElement extends Disposable {
     render(previousSibling) {
         const index = this.viewCell.outputsViewModels.indexOf(this.output);
         if (this.viewCell.isOutputCollapsed || !this.notebookEditor.hasModel()) {
+            this.cellOutputContainer.flagAsStale();
             return undefined;
         }
         const notebookUri = CellUri.parse(this.viewCell.uri)?.notebook;
@@ -127,15 +128,18 @@ let CellOutputElement = class CellOutputElement extends Disposable {
             this.viewCell.updateOutputHeight(index, 0, 'CellOutputElement#noMimeType');
             return undefined;
         }
-        const pickedMimeTypeRenderer = mimeTypes[pick];
-        const innerContainer = this._generateInnerOutputContainer(previousSibling, pickedMimeTypeRenderer);
+        const selectedPresentation = mimeTypes[pick];
+        let renderer = this.notebookService.getRendererInfo(selectedPresentation.rendererId);
+        if (!renderer && selectedPresentation.mimeType.indexOf('text/') > -1) {
+            renderer = this.notebookService.getRendererInfo('vscode.builtin-renderer');
+        }
+        const innerContainer = this._generateInnerOutputContainer(previousSibling, selectedPresentation);
         this._attachToolbar(innerContainer, notebookTextModel, this.notebookEditor.activeKernel, index, mimeTypes);
         this.renderedOutputContainer = append(innerContainer, $('.rendered-output'));
-        const renderer = this.notebookService.getRendererInfo(pickedMimeTypeRenderer.rendererId);
         this.renderResult = renderer
-            ? { type: 1 , renderer, source: this.output, mimeType: pickedMimeTypeRenderer.mimeType }
-            : this._renderMissingRenderer(this.output, pickedMimeTypeRenderer.mimeType);
-        this.output.pickedMimeType = pickedMimeTypeRenderer;
+            ? { type: 1 , renderer, source: this.output, mimeType: selectedPresentation.mimeType }
+            : this._renderMissingRenderer(this.output, selectedPresentation.mimeType);
+        this.output.pickedMimeType = selectedPresentation;
         if (!this.renderResult) {
             this.viewCell.updateOutputHeight(index, 0, 'CellOutputElement#renderResultUndefined');
             return undefined;
@@ -390,6 +394,7 @@ let CellOutputContainer = class CellOutputContainer extends CellContentPart {
         this._notebookExecutionStateService = _notebookExecutionStateService;
         this.instantiationService = instantiationService;
         this._outputEntries = [];
+        this._hasStaleOutputs = false;
         this._outputHeightTimer = null;
         this._register(viewCell.onDidStartExecution(() => {
             viewCell.updateOutputMinHeight(viewCell.layoutInfo.outputTotalHeight);
@@ -425,6 +430,9 @@ let CellOutputContainer = class CellOutputContainer extends CellContentPart {
             this._relayoutCell();
         }
     }
+    flagAsStale() {
+        this._hasStaleOutputs = true;
+    }
     _doRender() {
         if (this.viewCell.outputsViewModels.length > 0) {
             if (this.viewCell.layoutInfo.outputTotalHeight !== 0) {
@@ -456,6 +464,12 @@ let CellOutputContainer = class CellOutputContainer extends CellContentPart {
         }
     }
     viewUpdateShowOutputs(initRendering) {
+        if (this._hasStaleOutputs) {
+            this._hasStaleOutputs = false;
+            this._outputEntries.forEach(entry => {
+                entry.element.rerender();
+            });
+        }
         for (let index = 0; index < this._outputEntries.length; index++) {
             const viewHandler = this._outputEntries[index];
             const outputEntry = viewHandler.element;

package/vscode/src/vs/workbench/contrib/notebook/browser/view/cellParts/cellToolbars.js

@@ -121,8 +121,8 @@ let CellTitleToolbarPart = class CellTitleToolbarPart extends CellOverlayPart {
             return this._view;
         }
         const toolbar = this._register(this.instantiationService.createInstance(WorkbenchToolBar, this.toolbarContainer, {
-            actionViewItemProvider: action => {
-                return createActionViewItem(this.instantiationService, action);
+            actionViewItemProvider: (action, options) => {
+                return createActionViewItem(this.instantiationService, action, options);
             },
             renderDropdownAsChildElement: true
         }));
@@ -215,8 +215,8 @@ function createDeleteToolbar(accessor, container, elementClass) {
     const instantiationService = accessor.get(IInstantiationService);
     const toolbar = ( new ToolBar(container, contextMenuService, {
         getKeyBinding: action => keybindingService.lookupKeybinding(action.id),
-        actionViewItemProvider: action => {
-            return createActionViewItem(instantiationService, action);
+        actionViewItemProvider: (action, options) => {
+            return createActionViewItem(instantiationService, action, options);
         },
         renderDropdownAsChildElement: true
     }));

package/vscode/src/vs/workbench/contrib/notebook/browser/view/cellParts/chat/cellChatPart.js

@@ -1,45 +1,21 @@
-import { __decorate, __param } from '../../../../../../../../../../external/tslib/tslib.es6.js';
-import { IInstantiationService } from '../../../../../../../platform/instantiation/common/instantiation.js';
 import { CellContentPart } from '../../cellPart.js';
-import { NotebookCellChatController } from './cellChatController.js';
-import './cellChatActions.js';
-import { IConfigurationService } from '../../../../../../../platform/configuration/common/configuration.js';
-import { NotebookSetting } from '../../../../common/notebookCommon.js';
-let CellChatPart = class CellChatPart extends CellContentPart {
+class CellChatPart extends CellContentPart {
     get activeCell() {
         return this.currentCell;
     }
-    constructor(_notebookEditor, _partContainer, _instantiationService, _configurationService) {
+    constructor(_notebookEditor, _partContainer) {
         super();
-        this._notebookEditor = _notebookEditor;
-        this._partContainer = _partContainer;
-        this._instantiationService = _instantiationService;
-        this._configurationService = _configurationService;
     }
     didRenderCell(element) {
-        this._controller?.dispose();
-        const enabled = this._configurationService.getValue(NotebookSetting.cellChat);
-        if (enabled) {
-            this._controller = this._instantiationService.createInstance(NotebookCellChatController, this._notebookEditor, this, element, this._partContainer);
-        }
         super.didRenderCell(element);
     }
     unrenderCell(element) {
-        this._controller?.dispose();
-        this._controller = undefined;
         super.unrenderCell(element);
     }
     updateInternalLayoutNow(element) {
-        this._controller?.layout();
     }
     dispose() {
-        this._controller?.dispose();
-        this._controller = undefined;
         super.dispose();
     }
-};
-CellChatPart = ( __decorate([
-    ( __param(2, IInstantiationService)),
-    ( __param(3, IConfigurationService))
-], CellChatPart));
+}
 export { CellChatPart };

package/vscode/src/vs/workbench/contrib/notebook/browser/view/cellParts/codeCell.js

@@ -33,13 +33,13 @@ let CodeCell = class CodeCell extends Disposable {
         this.languageService = languageService;
         this.configurationService = configurationService;
         this._isDisposed = false;
-        const cellEditorOptions = this._register(( new CellEditorOptions(
+        this._cellEditorOptions = this._register(( new CellEditorOptions(
             this.notebookEditor.getBaseCellEditorOptions(viewCell.language),
             this.notebookEditor.notebookOptions,
             this.configurationService
         )));
         this._outputContainerRenderer = this.instantiationService.createInstance(CellOutputContainer, notebookEditor, viewCell, templateData, { limit: outputDisplayLimit });
-        this.cellParts = this._register(templateData.cellParts.concatContentPart([cellEditorOptions, this._outputContainerRenderer], getWindow(notebookEditor.getDomNode())));
+        this.cellParts = this._register(templateData.cellParts.concatContentPart([this._cellEditorOptions, this._outputContainerRenderer], getWindow(notebookEditor.getDomNode())));
         const editorHeight = this.calculateInitEditorHeight();
         this.initializeEditor(editorHeight);
         this._renderedInputCollapseState = false;
@@ -96,9 +96,25 @@ let CodeCell = class CodeCell extends Disposable {
         this.updateForCollapseState();
         this._register(Event.runAndSubscribe(viewCell.onDidChangeOutputs, this.updateForOutputs.bind(this)));
         this._register(Event.runAndSubscribe(viewCell.onDidChangeLayout, this.updateForLayout.bind(this)));
-        cellEditorOptions.setLineNumbers(this.viewCell.lineNumbers);
-        this._register(cellEditorOptions.onDidChange(() => templateData.editor.updateOptions(cellEditorOptions.getUpdatedValue(this.viewCell.internalMetadata, this.viewCell.uri))));
-        templateData.editor.updateOptions(cellEditorOptions.getUpdatedValue(this.viewCell.internalMetadata, this.viewCell.uri));
+        this._cellEditorOptions.setLineNumbers(this.viewCell.lineNumbers);
+        templateData.editor.updateOptions(this._cellEditorOptions.getUpdatedValue(this.viewCell.internalMetadata, this.viewCell.uri));
+    }
+    updateCodeCellOptions(templateData) {
+        templateData.editor.updateOptions(this._cellEditorOptions.getUpdatedValue(this.viewCell.internalMetadata, this.viewCell.uri));
+        const cts = ( new CancellationTokenSource());
+        this._register({ dispose() { cts.dispose(true); } });
+        raceCancellation(this.viewCell.resolveTextModel(), cts.token).then(model => {
+            if (this._isDisposed) {
+                return;
+            }
+            if (model) {
+                model.updateOptions({
+                    indentSize: this._cellEditorOptions.indentSize,
+                    tabSize: this._cellEditorOptions.tabSize,
+                    insertSpaces: this._cellEditorOptions.insertSpaces,
+                });
+            }
+        });
     }
     updateForLayout() {
         this._pendingLayout?.dispose();
@@ -136,6 +152,11 @@ let CodeCell = class CodeCell extends Disposable {
             if (model && this.templateData.editor) {
                 this._reigsterModelListeners(model);
                 this.templateData.editor.setModel(model);
+                model.updateOptions({
+                    indentSize: this._cellEditorOptions.indentSize,
+                    tabSize: this._cellEditorOptions.tabSize,
+                    insertSpaces: this._cellEditorOptions.insertSpaces,
+                });
                 this.viewCell.attachTextEditor(this.templateData.editor, this.viewCell.layoutInfo.estimatedHasHorizontalScrolling);
                 const focusEditorIfNeeded = () => {
                     if (this.notebookEditor.getActiveCell() === this.viewCell &&
@@ -152,6 +173,7 @@ let CodeCell = class CodeCell extends Disposable {
                 }
                 focusEditorIfNeeded();
             }
+            this._register(this._cellEditorOptions.onDidChange(() => this.updateCodeCellOptions(this.templateData)));
         });
     }
     updateForOutputs() {
@@ -165,7 +187,7 @@ let CodeCell = class CodeCell extends Disposable {
         const isReadonly = this.notebookEditor.isReadOnly;
         const padding = this.notebookEditor.notebookOptions.computeEditorPadding(this.viewCell.internalMetadata, this.viewCell.uri);
         const options = editor.getOptions();
-        if (options.get(90 ) !== isReadonly || options.get(83 ) !== padding) {
+        if (options.get(91 ) !== isReadonly || options.get(84 ) !== padding) {
             editor.updateOptions({ readOnly: this.notebookEditor.isReadOnly, padding: this.notebookEditor.notebookOptions.computeEditorPadding(this.viewCell.internalMetadata, this.viewCell.uri) });
         }
     }

package/vscode/src/vs/workbench/contrib/notebook/browser/view/cellParts/markupCell.js

@@ -38,6 +38,7 @@ let MarkupCell = class MarkupCell extends Disposable {
         this.localDisposables = this._register(( new DisposableStore()));
         this.focusSwitchDisposable = this._register(( new MutableDisposable()));
         this.editorDisposables = this._register(( new DisposableStore()));
+        this._isDisposed = false;
         this.constructDOM();
         this.editorPart = templateData.editorPart;
         this.cellEditorOptions = this._register(( new CellEditorOptions(
@@ -130,9 +131,27 @@ let MarkupCell = class MarkupCell extends Disposable {
                 this.onCellEditorWidthChange();
             }
         }));
-        this._register(this.cellEditorOptions.onDidChange(() => {
-            this.updateEditorOptions(this.cellEditorOptions.getUpdatedValue(this.viewCell.internalMetadata, this.viewCell.uri));
-        }));
+        this._register(this.cellEditorOptions.onDidChange(() => this.updateMarkupCellOptions()));
+    }
+    updateMarkupCellOptions() {
+        this.updateEditorOptions(this.cellEditorOptions.getUpdatedValue(this.viewCell.internalMetadata, this.viewCell.uri));
+        if (this.editor) {
+            this.editor.updateOptions(this.cellEditorOptions.getUpdatedValue(this.viewCell.internalMetadata, this.viewCell.uri));
+            const cts = ( new CancellationTokenSource());
+            this._register({ dispose() { cts.dispose(true); } });
+            raceCancellation(this.viewCell.resolveTextModel(), cts.token).then(model => {
+                if (this._isDisposed) {
+                    return;
+                }
+                if (model) {
+                    model.updateOptions({
+                        indentSize: this.cellEditorOptions.indentSize,
+                        tabSize: this.cellEditorOptions.tabSize,
+                        insertSpaces: this.cellEditorOptions.insertSpaces,
+                    });
+                }
+            });
+        }
     }
     updateCollapsedState() {
         if (this.viewCell.isInputCollapsed) {
@@ -171,6 +190,7 @@ let MarkupCell = class MarkupCell extends Disposable {
         });
     }
     dispose() {
+        this._isDisposed = true;
         if (this.notebookEditor.getActiveCell() === this.viewCell && this.viewCell.focusMode === CellFocusMode.Editor && (this.notebookEditor.hasEditorFocus() || this.notebookEditor.getDomNode().ownerDocument.activeElement === this.notebookEditor.getDomNode().ownerDocument.body)) {
             this.notebookEditor.focusContainer();
         }
@@ -286,6 +306,11 @@ let MarkupCell = class MarkupCell extends Disposable {
                     return;
                 }
                 this.editor.setModel(model);
+                model.updateOptions({
+                    indentSize: this.cellEditorOptions.indentSize,
+                    tabSize: this.cellEditorOptions.tabSize,
+                    insertSpaces: this.cellEditorOptions.insertSpaces,
+                });
                 const realContentHeight = this.editor.getContentHeight();
                 if (realContentHeight !== editorHeight) {
                     this.editor.layout({

package/vscode/src/vs/workbench/contrib/notebook/browser/view/notebookCellList.js

@@ -18,6 +18,7 @@ import { IInstantiationService } from '../../../../../platform/instantiation/com
 import { NotebookCellListView } from './notebookCellListView.js';
 import { INotebookExecutionStateService } from '../../common/notebookExecutionStateService.js';
 import { NotebookCellAnchor } from './notebookCellAnchor.js';
+import { NotebookViewZones } from '../viewParts/notebookViewZones.js';
 function getVisibleCells(cells, hiddenRanges) {
     if (!hiddenRanges.length) {
         return cells;
@@ -211,7 +212,9 @@ let NotebookCellList = class NotebookCellList extends WorkbenchList {
         }));
     }
     createListView(container, virtualDelegate, renderers, viewOptions) {
-        return ( new NotebookCellListView(container, virtualDelegate, renderers, viewOptions));
+        const listView = ( new NotebookCellListView(container, virtualDelegate, renderers, viewOptions));
+        this.viewZones = ( new NotebookViewZones(listView, this));
+        return listView;
     }
     attachWebview(element) {
         element.style.top = `-${NOTEBOOK_WEBVIEW_BOUNDARY}px`;
@@ -245,6 +248,7 @@ let NotebookCellList = class NotebookCellList extends WorkbenchList {
             if (this._isDisposed) {
                 return;
             }
+            this.viewZones.onCellsChanged(e);
             const currentRanges = ( this._hiddenRangeIds.map(id => this._viewModel.getTrackedRange(id))).filter(range => range !== null);
             const newVisibleViewCells = getVisibleCells(this._viewModel.viewCells, currentRanges);
             const oldVisibleViewCells = [];
@@ -333,6 +337,8 @@ let NotebookCellList = class NotebookCellList extends WorkbenchList {
             }
             if (!hasDifference) {
                 this._updateHiddenRangePrefixSum(newRanges);
+                this.viewZones.onHiddenRangesChange();
+                this.viewZones.layout();
                 return false;
             }
         }
@@ -342,9 +348,11 @@ let NotebookCellList = class NotebookCellList extends WorkbenchList {
         )).filter(id => id !== null);
         this._hiddenRangeIds = hiddenAreaIds;
         this._updateHiddenRangePrefixSum(newRanges);
+        this.viewZones.onHiddenRangesChange();
         if (triggerViewUpdate) {
             this.updateHiddenAreasInView(oldRanges, newRanges);
         }
+        this.viewZones.layout();
         return true;
     }
     _updateHiddenRangePrefixSum(newRanges) {
@@ -398,6 +406,7 @@ let NotebookCellList = class NotebookCellList extends WorkbenchList {
         if (!selectionsLeft.length && this._viewModel.viewCells.length) {
             this._viewModel.updateSelectionsState({ kind: SelectionStateType.Index, focus: { start: 0, end: 1 }, selections: [{ start: 0, end: 1 }] });
         }
+        this.viewZones.layout();
     }
     getModelIndex(cell) {
         const viewIndex = this.indexOf(cell);
@@ -429,6 +438,30 @@ let NotebookCellList = class NotebookCellList extends WorkbenchList {
             return viewIndexInfo.index;
         }
     }
+    convertModelIndexToViewIndex(modelIndex) {
+        if (!this.hiddenRangesPrefixSum) {
+            return modelIndex;
+        }
+        if (modelIndex >= this.hiddenRangesPrefixSum.getTotalSum()) {
+            return Math.min(this.length, this.hiddenRangesPrefixSum.getTotalSum());
+        }
+        return this.hiddenRangesPrefixSum.getIndexOf(modelIndex).index;
+    }
+    modelIndexIsVisible(modelIndex) {
+        if (!this.hiddenRangesPrefixSum) {
+            return true;
+        }
+        const viewIndexInfo = this.hiddenRangesPrefixSum.getIndexOf(modelIndex);
+        if (viewIndexInfo.remainder !== 0) {
+            if (modelIndex >= this.hiddenRangesPrefixSum.getTotalSum()) {
+                return true;
+            }
+            return false;
+        }
+        else {
+            return true;
+        }
+    }
     _getVisibleRangesFromIndex(topViewIndex, topModelIndex, bottomViewIndex, bottomModelIndex) {
         const stack = [];
         const ranges = [];
@@ -752,18 +785,18 @@ let NotebookCellList = class NotebookCellList extends WorkbenchList {
         const elementTop = this.view.elementTop(viewIndex);
         const element = this.view.element(viewIndex);
         if (element.editorAttached) {
-            this._revealRangeCommon(viewIndex, range, false, false);
+            this._revealRangeCommon(viewIndex, range);
         }
         else {
             const elementHeight = this.view.elementHeight(viewIndex);
-            let upwards = false;
+            let alignHint = undefined;
             if (elementTop + elementHeight <= scrollTop) {
                 this.view.setScrollTop(elementTop);
-                upwards = false;
+                alignHint = 'top';
             }
             else if (elementTop >= wrapperBottom) {
                 this.view.setScrollTop(elementTop - this.view.renderHeight / 2);
-                upwards = true;
+                alignHint = 'bottom';
             }
             const editorAttachedPromise = ( new Promise((resolve, reject) => {
                 element.onDidChangeEditorAttachState(() => {
@@ -771,7 +804,7 @@ let NotebookCellList = class NotebookCellList extends WorkbenchList {
                 });
             }));
             return editorAttachedPromise.then(() => {
-                this._revealRangeCommon(viewIndex, range, true, upwards);
+                this._revealRangeCommon(viewIndex, range, alignHint);
             });
         }
     }
@@ -825,7 +858,7 @@ let NotebookCellList = class NotebookCellList extends WorkbenchList {
             }
         }
     }
-    _revealRangeCommon(viewIndex, range, newlyCreated, alignToBottom) {
+    _revealRangeCommon(viewIndex, range, alignHint) {
         const element = this.view.element(viewIndex);
         const scrollTop = this.getViewScrollTop();
         const wrapperBottom = this.getViewScrollBottom();
@@ -843,13 +876,11 @@ let NotebookCellList = class NotebookCellList extends WorkbenchList {
         else if (positionTop > wrapperBottom) {
             this.view.setScrollTop(scrollTop + positionTop - wrapperBottom + 30);
         }
-        else if (newlyCreated) {
-            if (alignToBottom) {
-                this.view.setScrollTop(scrollTop + positionTop - wrapperBottom + 30);
-            }
-            else {
-                this.view.setScrollTop(positionTop - 30);
-            }
+        else if (alignHint === 'bottom') {
+            this.view.setScrollTop(scrollTop + positionTop - wrapperBottom + 30);
+        }
+        else if (alignHint === 'top') {
+            this.view.setScrollTop(positionTop - 30);
         }
         element.revealRangeInCenter(range);
     }
@@ -868,6 +899,13 @@ let NotebookCellList = class NotebookCellList extends WorkbenchList {
             }
         }
     }
+    revealOffsetInCenterIfOutsideViewport(offset) {
+        const scrollTop = this.getViewScrollTop();
+        const wrapperBottom = this.getViewScrollBottom();
+        if (offset < scrollTop || offset > wrapperBottom) {
+            this.view.setScrollTop(offset - this.view.renderHeight / 2);
+        }
+    }
     _revealInCenterIfOutsideViewport(viewIndex) {
         this._revealInternal(viewIndex, true, 1 );
     }
@@ -912,20 +950,32 @@ let NotebookCellList = class NotebookCellList extends WorkbenchList {
                 });
             }
             this.view.updateElementHeight(index, size, anchorElementIndex);
+            this.viewZones.layout();
             return;
         }
         if (anchorElementIndex !== null) {
-            return this.view.updateElementHeight(index, size, anchorElementIndex);
+            this.view.updateElementHeight(index, size, anchorElementIndex);
+            this.viewZones.layout();
+            return;
         }
         const focused = this.getFocus();
         const focus = focused.length ? focused[0] : null;
         if (focus) {
             const heightDelta = size - this.view.elementHeight(index);
             if (this._notebookCellAnchor.shouldAnchor(this.view, focus, heightDelta, this.element(index))) {
-                return this.view.updateElementHeight(index, size, focus);
+                this.view.updateElementHeight(index, size, focus);
+                this.viewZones.layout();
+                return;
             }
         }
-        return this.view.updateElementHeight(index, size, null);
+        this.view.updateElementHeight(index, size, null);
+        this.viewZones.layout();
+        return;
+    }
+    changeViewZones(callback) {
+        if (this.viewZones.changeViewZones(callback)) {
+            this.viewZones.layout();
+        }
     }
     domFocus() {
         const focused = this.getFocusedElements()[0];
@@ -938,7 +988,16 @@ let NotebookCellList = class NotebookCellList extends WorkbenchList {
         }
         super.domFocus();
     }
-    focusContainer() {
+    focusContainer(clearSelection) {
+        if (clearSelection) {
+            this._viewModel?.updateSelectionsState({
+                kind: SelectionStateType.Handle,
+                primary: null,
+                selections: []
+            }, 'view');
+            this.setFocus([], undefined, true);
+            this.setSelection([], undefined, true);
+        }
         super.domFocus();
     }
     getViewScrollTop() {
@@ -1058,6 +1117,7 @@ let NotebookCellList = class NotebookCellList extends WorkbenchList {
         this._viewModelStore.dispose();
         this._localDisposableStore.dispose();
         this._notebookCellAnchor.dispose();
+        this.viewZones.dispose();
         super.dispose();
         this._previousFocusedElements = [];
         this._viewModel = null;