@codingame/monaco-vscode-api 2.2.2 → 3.0.0

package/vscode/src/vs/workbench/contrib/notebook/browser/viewParts/notebookEditorToolbar.js

@@ -5,8 +5,8 @@ import { ToolBar } from '../../../../../base/browser/ui/toolbar/toolbar.js';
 import { Separator } from '../../../../../base/common/actions.js';
 import { Emitter, Event } from '../../../../../base/common/event.js';
 import { Disposable } from '../../../../../base/common/lifecycle.js';
-import { MenuEntryActionViewItem } from '../../../../../platform/actions/browser/menuEntryActionViewItem.js';
-import { IMenuService, MenuItemAction, MenuId } from '../../../../../platform/actions/common/actions.js';
+import { MenuEntryActionViewItem, SubmenuEntryActionViewItem } from '../../../../../platform/actions/browser/menuEntryActionViewItem.js';
+import { MenuId, IMenuService, MenuItemAction, SubmenuItemAction } from '../../../../../platform/actions/common/actions.js';
 import { IConfigurationService } from '../../../../../platform/configuration/common/configuration.js';
 import { IContextMenuService } from '../../../../../platform/contextview/browser/contextView.js';
 import { IInstantiationService } from '../../../../../platform/instantiation/common/instantiation.js';
@@ -14,7 +14,7 @@ import { IKeybindingService } from '../../../../../platform/keybinding/common/ke
 import { SELECT_KERNEL_ID } from '../controller/coreActions.js';
 import { NOTEBOOK_EDITOR_ID, NotebookSetting } from '../../common/notebookCommon.js';
 import { NotebooKernelActionViewItem } from './notebookKernelView.js';
-import { ActionViewWithLabel } from '../view/cellParts/cellActionView.js';
+import { ActionViewWithLabel, UnifiedSubmenuActionView } from '../view/cellParts/cellActionView.js';
 import { IEditorService } from '../../../../services/editor/common/editorService.js';
 import { IWorkbenchAssignmentService } from '../../../../services/assignment/common/assignmentService.js';
 import { disposableTimeout } from '../../../../../base/common/async.js';
@@ -29,16 +29,27 @@ const ICON_ONLY_ACTION_WIDTH = 21;
 const TOGGLE_MORE_ACTION_WIDTH = 21;
 const ACTION_PADDING = 8;
 class WorkbenchAlwaysLabelStrategy {
-    constructor(notebookEditor, editorToolbar, instantiationService) {
+    constructor(notebookEditor, editorToolbar, goToMenu, instantiationService) {
         this.notebookEditor = notebookEditor;
         this.editorToolbar = editorToolbar;
+        this.goToMenu = goToMenu;
         this.instantiationService = instantiationService;
     }
     actionProvider(action) {
         if (action.id === SELECT_KERNEL_ID) {
             return this.instantiationService.createInstance(NotebooKernelActionViewItem, action, this.notebookEditor);
         }
-        return action instanceof MenuItemAction ? this.instantiationService.createInstance(ActionViewWithLabel, action, undefined) : undefined;
+        if (action instanceof MenuItemAction) {
+            return this.instantiationService.createInstance(ActionViewWithLabel, action, undefined);
+        }
+        if (action instanceof SubmenuItemAction && action.item.submenu.id === MenuId.NotebookCellExecuteGoTo.id) {
+            return this.instantiationService.createInstance(UnifiedSubmenuActionView, action, undefined, true, {
+                getActions: () => {
+                    return this.goToMenu.getActions().find(([group]) => group === 'navigation/execute')?.[1] ?? [];
+                }
+            }, this.actionProvider.bind(this));
+        }
+        return undefined;
     }
     calculateActions(leftToolbarContainerMaxWidth) {
         const initialPrimaryActions = this.editorToolbar.primaryActions;
@@ -51,16 +62,32 @@ class WorkbenchAlwaysLabelStrategy {
     }
 }
 class WorkbenchNeverLabelStrategy {
-    constructor(notebookEditor, editorToolbar, instantiationService) {
+    constructor(notebookEditor, editorToolbar, goToMenu, instantiationService) {
         this.notebookEditor = notebookEditor;
         this.editorToolbar = editorToolbar;
+        this.goToMenu = goToMenu;
         this.instantiationService = instantiationService;
     }
     actionProvider(action) {
         if (action.id === SELECT_KERNEL_ID) {
             return this.instantiationService.createInstance(NotebooKernelActionViewItem, action, this.notebookEditor);
         }
-        return action instanceof MenuItemAction ? this.instantiationService.createInstance(MenuEntryActionViewItem, action, undefined) : undefined;
+        if (action instanceof MenuItemAction) {
+            return this.instantiationService.createInstance(MenuEntryActionViewItem, action, undefined);
+        }
+        if (action instanceof SubmenuItemAction) {
+            if (action.item.submenu.id === MenuId.NotebookCellExecuteGoTo.id) {
+                return this.instantiationService.createInstance(UnifiedSubmenuActionView, action, undefined, false, {
+                    getActions: () => {
+                        return this.goToMenu.getActions().find(([group]) => group === 'navigation/execute')?.[1] ?? [];
+                    }
+                }, this.actionProvider.bind(this));
+            }
+            else {
+                return this.instantiationService.createInstance(SubmenuEntryActionViewItem, action, undefined);
+            }
+        }
+        return undefined;
     }
     calculateActions(leftToolbarContainerMaxWidth) {
         const initialPrimaryActions = this.editorToolbar.primaryActions;
@@ -73,9 +100,10 @@ class WorkbenchNeverLabelStrategy {
     }
 }
 class WorkbenchDynamicLabelStrategy {
-    constructor(notebookEditor, editorToolbar, instantiationService) {
+    constructor(notebookEditor, editorToolbar, goToMenu, instantiationService) {
         this.notebookEditor = notebookEditor;
         this.editorToolbar = editorToolbar;
+        this.goToMenu = goToMenu;
         this.instantiationService = instantiationService;
     }
     actionProvider(action) {
@@ -84,10 +112,35 @@ class WorkbenchDynamicLabelStrategy {
         }
         const a = this.editorToolbar.primaryActions.find(a => a.action.id === action.id);
         if (!a || a.renderLabel) {
-            return action instanceof MenuItemAction ? this.instantiationService.createInstance(ActionViewWithLabel, action, undefined) : undefined;
+            if (action instanceof MenuItemAction) {
+                return this.instantiationService.createInstance(ActionViewWithLabel, action, undefined);
+            }
+            if (action instanceof SubmenuItemAction && action.item.submenu.id === MenuId.NotebookCellExecuteGoTo.id) {
+                return this.instantiationService.createInstance(UnifiedSubmenuActionView, action, undefined, true, {
+                    getActions: () => {
+                        return this.goToMenu.getActions().find(([group]) => group === 'navigation/execute')?.[1] ?? [];
+                    }
+                }, this.actionProvider.bind(this));
+            }
+            return undefined;
         }
         else {
-            return action instanceof MenuItemAction ? this.instantiationService.createInstance(MenuEntryActionViewItem, action, undefined) : undefined;
+            if (action instanceof MenuItemAction) {
+                this.instantiationService.createInstance(MenuEntryActionViewItem, action, undefined);
+            }
+            if (action instanceof SubmenuItemAction) {
+                if (action.item.submenu.id === MenuId.NotebookCellExecuteGoTo.id) {
+                    return this.instantiationService.createInstance(UnifiedSubmenuActionView, action, undefined, false, {
+                        getActions: () => {
+                            return this.goToMenu.getActions().find(([group]) => group === 'navigation/execute')?.[1] ?? [];
+                        }
+                    }, this.actionProvider.bind(this));
+                }
+                else {
+                    return this.instantiationService.createInstance(SubmenuEntryActionViewItem, action, undefined);
+                }
+            }
+            return undefined;
         }
     }
     calculateActions(leftToolbarContainerMaxWidth) {
@@ -168,7 +221,7 @@ let NotebookEditorWorkbenchToolbar = class NotebookEditorWorkbenchToolbar extend
     }
     _registerNotebookActionsToolbar() {
         this._notebookGlobalActionsMenu = this._register(this.menuService.createMenu(this.notebookEditor.creationOptions.menuIds.notebookToolbar, this.contextKeyService));
-        this._register(this._notebookGlobalActionsMenu);
+        this._executeGoToActionsMenu = this._register(this.menuService.createMenu(MenuId.NotebookCellExecuteGoTo, this.contextKeyService));
         this._useGlobalToolbar = this.notebookOptions.getDisplayOptions().globalToolbar;
         this._renderLabel = this._convertConfiguration(this.configurationService.getValue(NotebookSetting.globalToolbarShowLabel));
         this._updateStrategy();
@@ -268,13 +321,28 @@ let NotebookEditorWorkbenchToolbar = class NotebookEditorWorkbenchToolbar extend
     _updateStrategy() {
         switch (this._renderLabel) {
             case RenderLabel.Always:
-                this._strategy = ( new WorkbenchAlwaysLabelStrategy(this.notebookEditor, this, this.instantiationService));
+                this._strategy = ( new WorkbenchAlwaysLabelStrategy(
+                    this.notebookEditor,
+                    this,
+                    this._executeGoToActionsMenu,
+                    this.instantiationService
+                ));
                 break;
             case RenderLabel.Never:
-                this._strategy = ( new WorkbenchNeverLabelStrategy(this.notebookEditor, this, this.instantiationService));
+                this._strategy = ( new WorkbenchNeverLabelStrategy(
+                    this.notebookEditor,
+                    this,
+                    this._executeGoToActionsMenu,
+                    this.instantiationService
+                ));
                 break;
             case RenderLabel.Dynamic:
-                this._strategy = ( new WorkbenchDynamicLabelStrategy(this.notebookEditor, this, this.instantiationService));
+                this._strategy = ( new WorkbenchDynamicLabelStrategy(
+                    this.notebookEditor,
+                    this,
+                    this._executeGoToActionsMenu,
+                    this.instantiationService
+                ));
                 break;
         }
     }

package/vscode/src/vs/workbench/contrib/notebook/browser/viewParts/notebookKernelQuickPickStrategy.js

@@ -450,7 +450,7 @@ let KernelPickerMRUStrategy = class KernelPickerMRUStrategy extends KernelPicker
                 return true;
             }
             else if (isGroupedKernelsPick(selectedKernelPickItem)) {
-                await this._selectOneKernel(notebook, selectedKernelPickItem.source, selectedKernelPickItem.kernels);
+                await this._selectOneKernel(notebook, selectedKernelPickItem.label, selectedKernelPickItem.kernels);
                 return true;
             }
             else if (isSourcePick(selectedKernelPickItem)) {

package/vscode/src/vs/workbench/contrib/notebook/browser/viewParts/notebookKernelView.js

@@ -148,7 +148,6 @@ let NotebooKernelActionViewItem = class NotebooKernelActionViewItem extends Acti
         if (this._kernelLabel) {
             this._kernelLabel.classList.add('kernel-label');
             this._kernelLabel.innerText = this._action.label;
-            this._kernelLabel.title = this._action.tooltip;
         }
     }
     _update() {

package/vscode/src/vs/workbench/contrib/notebook/browser/viewParts/notebookOverviewRuler.js

@@ -1,6 +1,7 @@
 import { __decorate, __param } from '../../../../../../../../external/tslib/tslib.es6.js';
-import { PixelRatio } from '../../../../../base/browser/browser.js';
+import { getWindow } from '../../../../../base/browser/dom.js';
 import { createFastDomNode } from '../../../../../base/browser/fastDomNode.js';
+import { PixelRatio } from '../../../../../base/browser/pixelRatio.js';
 import { Themable, IThemeService } from '../../../../../platform/theme/common/themeService.js';
 import { NotebookOverviewRulerLane } from '../notebookBrowser.js';
 let NotebookOverviewRuler = class NotebookOverviewRuler extends Themable {
@@ -16,7 +17,7 @@ let NotebookOverviewRuler = class NotebookOverviewRuler extends Themable {
         this._register(notebookEditor.onDidChangeDecorations(() => {
             this.layout();
         }));
-        this._register(PixelRatio.onDidChange(() => {
+        this._register(PixelRatio.getInstance(getWindow(this._domNode.domNode)).onDidChange(() => {
             this.layout();
         }));
     }
@@ -25,7 +26,7 @@ let NotebookOverviewRuler = class NotebookOverviewRuler extends Themable {
         const layoutInfo = this.notebookEditor.getLayoutInfo();
         const scrollHeight = layoutInfo.scrollHeight;
         const height = layoutInfo.height;
-        const ratio = PixelRatio.value;
+        const ratio = PixelRatio.getInstance(getWindow(this._domNode.domNode)).value;
         this._domNode.setWidth(width);
         this._domNode.setHeight(height);
         this._domNode.domNode.width = width * ratio;

package/vscode/src/vs/workbench/contrib/notebook/browser/viewParts/notebookTopCellToolbar.js

@@ -1,49 +1,108 @@
 import { __decorate, __param } from '../../../../../../../../external/tslib/tslib.es6.js';
-import { append, $ } from '../../../../../base/browser/dom.js';
-import { Disposable, DisposableStore } from '../../../../../base/common/lifecycle.js';
+import { $, clearNode } from '../../../../../base/browser/dom.js';
+import { Disposable, MutableDisposable, DisposableStore } from '../../../../../base/common/lifecycle.js';
 import { MenuWorkbenchToolBar } from '../../../../../platform/actions/browser/toolbar.js';
 import { MenuItemAction, IMenuService } from '../../../../../platform/actions/common/actions.js';
 import { IContextMenuService } from '../../../../../platform/contextview/browser/contextView.js';
 import { IInstantiationService } from '../../../../../platform/instantiation/common/instantiation.js';
 import { CodiconActionViewItem } from '../view/cellParts/cellActionView.js';
 let ListTopCellToolbar = class ListTopCellToolbar extends Disposable {
-    constructor(notebookEditor, contextKeyService, insertionIndicatorContainer, instantiationService, contextMenuService, menuService) {
+    constructor(notebookEditor, notebookOptions, instantiationService, contextMenuService, menuService) {
         super();
         this.notebookEditor = notebookEditor;
+        this.notebookOptions = notebookOptions;
         this.instantiationService = instantiationService;
         this.contextMenuService = contextMenuService;
         this.menuService = menuService;
+        this.viewZone = this._register(( new MutableDisposable()));
         this._modelDisposables = this._register(( new DisposableStore()));
-        this.topCellToolbar = append(insertionIndicatorContainer, $('.cell-list-top-cell-toolbar-container'));
-        this.toolbar = this._register(instantiationService.createInstance(MenuWorkbenchToolBar, this.topCellToolbar, this.notebookEditor.creationOptions.menuIds.cellTopInsertToolbar, {
-            actionViewItemProvider: action => {
-                if (action instanceof MenuItemAction) {
-                    const item = this.instantiationService.createInstance(CodiconActionViewItem, action, undefined);
-                    return item;
-                }
-                return undefined;
-            },
-            menuOptions: {
-                shouldForwardArgs: true
-            },
-            toolbarOptions: {
-                primaryGroup: (g) => /^inline/.test(g),
-            },
-            hiddenItemStrategy: 0 ,
+        this.topCellToolbarContainer = $('div');
+        this.topCellToolbar = $('.cell-list-top-cell-toolbar-container');
+        this.topCellToolbarContainer.appendChild(this.topCellToolbar);
+        this._register(this.notebookEditor.onDidAttachViewModel(() => {
+            this.updateTopToolbar();
         }));
-        this.toolbar.context = {
-            notebookEditor
-        };
-        this._register(this.notebookEditor.onDidChangeModel(() => {
-            this._modelDisposables.clear();
-            if (this.notebookEditor.hasModel()) {
-                this._modelDisposables.add(this.notebookEditor.onDidChangeViewCells(() => {
-                    this.updateClass();
-                }));
-                this.updateClass();
+        this._register(this.notebookOptions.onDidChangeOptions(e => {
+            if (e.insertToolbarAlignment || e.insertToolbarPosition || e.cellToolbarLocation) {
+                this.updateTopToolbar();
             }
         }));
-        this.updateClass();
+    }
+    updateTopToolbar() {
+        const layoutInfo = this.notebookOptions.getLayoutConfiguration();
+        this.viewZone.value = ( new DisposableStore());
+        if (layoutInfo.insertToolbarPosition === 'hidden' || layoutInfo.insertToolbarPosition === 'notebookToolbar') {
+            const height = this.notebookOptions.computeTopInsertToolbarHeight(this.notebookEditor.textModel?.viewType);
+            if (height !== 0) {
+                this.notebookEditor.changeViewZones(accessor => {
+                    const id = accessor.addZone({
+                        afterModelPosition: 0,
+                        heightInPx: height,
+                        domNode: $('div')
+                    });
+                    accessor.layoutZone(id);
+                    this.viewZone.value?.add({
+                        dispose: () => {
+                            if (!this.notebookEditor.isDisposed) {
+                                this.notebookEditor.changeViewZones(accessor => {
+                                    accessor.removeZone(id);
+                                });
+                            }
+                        }
+                    });
+                });
+            }
+            return;
+        }
+        this.notebookEditor.changeViewZones(accessor => {
+            const height = this.notebookOptions.computeTopInsertToolbarHeight(this.notebookEditor.textModel?.viewType);
+            const id = accessor.addZone({
+                afterModelPosition: 0,
+                heightInPx: height,
+                domNode: this.topCellToolbarContainer
+            });
+            accessor.layoutZone(id);
+            this.viewZone.value?.add({
+                dispose: () => {
+                    if (!this.notebookEditor.isDisposed) {
+                        this.notebookEditor.changeViewZones(accessor => {
+                            accessor.removeZone(id);
+                        });
+                    }
+                }
+            });
+            clearNode(this.topCellToolbar);
+            const toolbar = this.instantiationService.createInstance(MenuWorkbenchToolBar, this.topCellToolbar, this.notebookEditor.creationOptions.menuIds.cellTopInsertToolbar, {
+                actionViewItemProvider: action => {
+                    if (action instanceof MenuItemAction) {
+                        const item = this.instantiationService.createInstance(CodiconActionViewItem, action, undefined);
+                        return item;
+                    }
+                    return undefined;
+                },
+                menuOptions: {
+                    shouldForwardArgs: true
+                },
+                toolbarOptions: {
+                    primaryGroup: (g) => /^inline/.test(g),
+                },
+                hiddenItemStrategy: 0 ,
+            });
+            toolbar.context = {
+                notebookEditor: this.notebookEditor
+            };
+            this.viewZone.value?.add(toolbar);
+            this.viewZone.value?.add(this.notebookEditor.onDidChangeModel(() => {
+                this._modelDisposables.clear();
+                if (this.notebookEditor.hasModel()) {
+                    this._modelDisposables.add(this.notebookEditor.onDidChangeViewCells(() => {
+                        this.updateClass();
+                    }));
+                    this.updateClass();
+                }
+            }));
+            this.updateClass();
+        });
     }
     updateClass() {
         if (this.notebookEditor.hasModel() && this.notebookEditor.getLength() === 0) {
@@ -55,8 +114,8 @@ let ListTopCellToolbar = class ListTopCellToolbar extends Disposable {
     }
 };
 ListTopCellToolbar = ( __decorate([
-    ( __param(3, IInstantiationService)),
-    ( __param(4, IContextMenuService)),
-    ( __param(5, IMenuService))
+    ( __param(2, IInstantiationService)),
+    ( __param(3, IContextMenuService)),
+    ( __param(4, IMenuService))
 ], ListTopCellToolbar));
 export { ListTopCellToolbar };

package/vscode/src/vs/workbench/contrib/notebook/browser/viewParts/notebookViewZones.js

@@ -0,0 +1,136 @@
+import { createFastDomNode } from '../../../../../base/browser/fastDomNode.js';
+import { onUnexpectedError } from '../../../../../base/common/errors.js';
+import { Disposable } from '../../../../../base/common/lifecycle.js';
+const invalidFunc = () => { throw new Error(`Invalid notebook view zone change accessor`); };
+class NotebookViewZones extends Disposable {
+    constructor(listView, coordinator) {
+        super();
+        this.listView = listView;
+        this.coordinator = coordinator;
+        this.domNode = createFastDomNode(document.createElement('div'));
+        this.domNode.setClassName('view-zones');
+        this.domNode.setPosition('absolute');
+        this.domNode.setAttribute('role', 'presentation');
+        this.domNode.setAttribute('aria-hidden', 'true');
+        this.domNode.setWidth('100%');
+        this._zones = {};
+        this.listView.containerDomNode.appendChild(this.domNode.domNode);
+    }
+    changeViewZones(callback) {
+        let zonesHaveChanged = false;
+        const changeAccessor = {
+            addZone: (zone) => {
+                zonesHaveChanged = true;
+                return this._addZone(zone);
+            },
+            removeZone: (id) => {
+                zonesHaveChanged = true;
+                this._removeZone(id);
+            },
+            layoutZone: (id) => {
+                zonesHaveChanged = true;
+                this._layoutZone(id);
+            }
+        };
+        safeInvoke1Arg(callback, changeAccessor);
+        changeAccessor.addZone = invalidFunc;
+        changeAccessor.removeZone = invalidFunc;
+        changeAccessor.layoutZone = invalidFunc;
+        return zonesHaveChanged;
+    }
+    onCellsChanged(e) {
+        const splices = e.splices.slice().reverse();
+        splices.forEach(splice => {
+            const [start, deleted, newCells] = splice;
+            const fromIndex = start;
+            const toIndex = start + deleted;
+            for (const id in this._zones) {
+                const zone = this._zones[id].zone;
+                const cellBeforeWhitespaceIndex = zone.afterModelPosition - 1;
+                if (cellBeforeWhitespaceIndex >= fromIndex && cellBeforeWhitespaceIndex < toIndex) {
+                    zone.afterModelPosition = fromIndex;
+                    this._updateWhitespace(this._zones[id]);
+                }
+                else if (cellBeforeWhitespaceIndex >= toIndex) {
+                    const insertLength = newCells.length;
+                    const offset = insertLength - deleted;
+                    zone.afterModelPosition += offset;
+                    this._updateWhitespace(this._zones[id]);
+                }
+            }
+        });
+    }
+    onHiddenRangesChange() {
+        for (const id in this._zones) {
+            this._updateWhitespace(this._zones[id]);
+        }
+    }
+    _updateWhitespace(zone) {
+        const whitespaceId = zone.whitespaceId;
+        const viewPosition = this.coordinator.convertModelIndexToViewIndex(zone.zone.afterModelPosition);
+        const isInHiddenArea = this._isInHiddenRanges(zone.zone);
+        zone.isInHiddenArea = isInHiddenArea;
+        this.listView.changeOneWhitespace(whitespaceId, viewPosition, isInHiddenArea ? 0 : zone.zone.heightInPx);
+    }
+    layout() {
+        for (const id in this._zones) {
+            this._layoutZone(id);
+        }
+    }
+    _addZone(zone) {
+        const viewPosition = this.coordinator.convertModelIndexToViewIndex(zone.afterModelPosition);
+        const whitespaceId = this.listView.insertWhitespace(viewPosition, zone.heightInPx);
+        const isInHiddenArea = this._isInHiddenRanges(zone);
+        const myZone = {
+            whitespaceId: whitespaceId,
+            zone: zone,
+            domNode: createFastDomNode(zone.domNode),
+            isInHiddenArea: isInHiddenArea
+        };
+        this._zones[whitespaceId] = myZone;
+        myZone.domNode.setPosition('absolute');
+        myZone.domNode.domNode.style.width = '100%';
+        myZone.domNode.setDisplay('none');
+        myZone.domNode.setAttribute('notebook-view-zone', whitespaceId);
+        this.domNode.appendChild(myZone.domNode);
+        return whitespaceId;
+    }
+    _removeZone(id) {
+        this.listView.removeWhitespace(id);
+        delete this._zones[id];
+    }
+    _layoutZone(id) {
+        const zoneWidget = this._zones[id];
+        if (!zoneWidget) {
+            return;
+        }
+        this._updateWhitespace(this._zones[id]);
+        const isInHiddenArea = this._isInHiddenRanges(zoneWidget.zone);
+        if (isInHiddenArea) {
+            zoneWidget.domNode.setDisplay('none');
+        }
+        else {
+            const top = this.listView.getWhitespacePosition(zoneWidget.whitespaceId);
+            zoneWidget.domNode.setTop(top);
+            zoneWidget.domNode.setDisplay('block');
+            zoneWidget.domNode.setHeight(zoneWidget.zone.heightInPx);
+        }
+    }
+    _isInHiddenRanges(zone) {
+        const afterIndex = zone.afterModelPosition;
+        return !this.coordinator.modelIndexIsVisible(afterIndex);
+    }
+    dispose() {
+        super.dispose();
+        this._zones = {};
+    }
+}
+function safeInvoke1Arg(func, arg1) {
+    try {
+        return func(arg1);
+    }
+    catch (e) {
+        onUnexpectedError(e);
+    }
+}
+export { NotebookViewZones };

package/vscode/src/vs/workbench/contrib/notebook/common/notebookEditorInput.js

@@ -295,4 +295,9 @@ function isCompositeNotebookEditorInput(thing) {
         && Array.isArray(thing.editorInputs)
         && (thing.editorInputs.every(input => input instanceof NotebookEditorInput));
 }
-export { NotebookEditorInput, isCompositeNotebookEditorInput };
+function isNotebookEditorInput(thing) {
+    return !!thing
+        && typeof thing === 'object'
+        && thing instanceof NotebookEditorInput;
+}
+export { NotebookEditorInput, isCompositeNotebookEditorInput, isNotebookEditorInput };

package/vscode/src/vs/workbench/contrib/notebook/common/notebookRange.js

@@ -36,7 +36,7 @@ function reduceCellRanges(ranges) {
     if (!first) {
         return [];
     }
-    return sorted.reduce((prev, curr) => {
+    const reduced = sorted.reduce((prev, curr) => {
         const last = prev[prev.length - 1];
         if (last.end >= curr.start) {
             last.end = Math.max(last.end, curr.end);
@@ -46,6 +46,10 @@ function reduceCellRanges(ranges) {
         }
         return prev;
     }, [first]);
+    if (reduced.length > 1) {
+        return reduced.filter(range => !(range.start === range.end && range.start === 0));
+    }
+    return reduced;
 }
 function cellRangesEqual(a, b) {
     a = reduceCellRanges(a);