@codingame/monaco-vscode-api 2.0.3 → 2.1.0

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

@@ -1024,11 +1024,11 @@ let NotebookCellList = class NotebookCellList extends WorkbenchList {
         if (styles.listHoverOutline) {
             content.push(`.monaco-list${suffix} > div.monaco-scrollable-element > .monaco-list-rows > .monaco-list-row:hover { outline: 1px dashed ${styles.listHoverOutline}; outline-offset: -1px; }`);
         }
-        if (styles.listDropBackground) {
+        if (styles.listDropOverBackground) {
             content.push(`
 				.monaco-list${suffix}.drop-target,
 				.monaco-list${suffix} > div.monaco-scrollable-element > .monaco-list-rows.drop-target,
-				.monaco-list${suffix} > div.monaco-scrollable-element > .monaco-list-row.drop-target { background-color: ${styles.listDropBackground} !important; color: inherit !important; }
+				.monaco-list${suffix} > div.monaco-scrollable-element > .monaco-list-row.drop-target { background-color: ${styles.listDropOverBackground} !important; color: inherit !important; }
 			`);
         }
         const newStyles = content.join('\n');

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

@@ -150,7 +150,8 @@ let BackLayerWebView = class BackLayerWebView extends Themable {
             renderOptions: {
                 lineLimit: this.options.outputLineLimit,
                 outputScrolling: this.options.outputScrolling,
-                outputWordWrap: this.options.outputWordWrap
+                outputWordWrap: this.options.outputWordWrap,
+                linkifyFilePaths: this.options.outputLinkifyFilePaths,
             }
         });
     }
@@ -190,7 +191,8 @@ let BackLayerWebView = class BackLayerWebView extends Themable {
         const renderOptions = {
             lineLimit: this.options.outputLineLimit,
             outputScrolling: this.options.outputScrolling,
-            outputWordWrap: this.options.outputWordWrap
+            outputWordWrap: this.options.outputWordWrap,
+            linkifyFilePaths: this.options.outputLinkifyFilePaths
         };
         const preloadScript = preloadsScriptStr({
             ...this.options,
@@ -400,10 +402,10 @@ let BackLayerWebView = class BackLayerWebView extends Themable {
     isResolved() {
         return !!this.webview;
     }
-    createWebview() {
+    createWebview(codeWindow) {
         const baseUrl = this.asWebviewUri(this.getNotebookBaseUri(), undefined);
         const htmlContent = this.generateContent(( baseUrl.toString()));
-        return this._initialize(htmlContent);
+        return this._initialize(htmlContent, codeWindow);
     }
     getNotebookBaseUri() {
         if (this.documentUri.scheme === Schemas.untitled) {
@@ -429,11 +431,11 @@ let BackLayerWebView = class BackLayerWebView extends Themable {
             dirname(( FileAccess.asFileUri('vs/loader.js'))),
         ];
     }
-    _initialize(content) {
+    _initialize(content, codeWindow) {
         if (!getWindow(this.element).document.body.contains(this.element)) {
             throw new Error('Element is already detached from the DOM tree');
         }
-        this.webview = this._createInset(this.webviewService, content);
+        this.webview = this._createInset(this.webviewService, content, codeWindow);
         this.webview.mountTo(this.element);
         this._register(this.webview);
         this._register(( new WebviewWindowDragMonitor(() => this.webview)));
@@ -530,7 +532,7 @@ let BackLayerWebView = class BackLayerWebView extends Themable {
                         const latestCell = this.notebookEditor.getCellByInfo(resolvedResult.cellInfo);
                         if (latestCell) {
                             latestCell.outputIsFocused = true;
-                            this.notebookEditor.focusNotebookCell(latestCell, 'output', { skipReveal: true });
+                            this.notebookEditor.focusNotebookCell(latestCell, 'output', { skipReveal: true, outputWebviewFocused: true });
                         }
                     }
                     break;
@@ -935,7 +937,7 @@ let BackLayerWebView = class BackLayerWebView extends Themable {
         await this.fileService.writeFile(newFileUri, buff);
         await this.openerService.open(newFileUri);
     }
-    _createInset(webviewService, content) {
+    _createInset(webviewService, content, codeWindow) {
         this.localResourceRootsCache = this._getResourceRootsCache();
         const webview = webviewService.createWebviewElement({
             origin: BackLayerWebView_1.getOriginStore(this.storageService).getOrigin(this.notebookViewType, undefined),
@@ -955,7 +957,8 @@ let BackLayerWebView = class BackLayerWebView extends Themable {
                 localResourceRoots: this.localResourceRootsCache,
             },
             extension: undefined,
-            providedViewType: 'notebook.output'
+            providedViewType: 'notebook.output',
+            codeWindow: codeWindow
         });
         webview.setHtml(content);
         webview.setContextKeyService(this.contextKeyService);

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

@@ -1,5 +1,7 @@
 async function webviewPreloads(ctx) {
     const $window = window;
+    const userAgent = navigator.userAgent;
+    const isChrome = (userAgent.indexOf('Chrome') >= 0);
     const textEncoder = ( new TextEncoder());
     const textDecoder = ( new TextDecoder());
     let currentOptions = ctx.options;
@@ -305,9 +307,9 @@ async function webviewPreloads(ctx) {
                 deltaX: event.deltaX,
                 deltaY: event.deltaY,
                 deltaZ: event.deltaZ,
-                wheelDelta: event.wheelDelta,
-                wheelDeltaX: event.wheelDeltaX,
-                wheelDeltaY: event.wheelDeltaY,
+                wheelDelta: event.wheelDelta && isChrome ? (event.wheelDelta / $window.devicePixelRatio) : event.wheelDelta,
+                wheelDeltaX: event.wheelDeltaX && isChrome ? (event.wheelDeltaX / $window.devicePixelRatio) : event.wheelDeltaX,
+                wheelDeltaY: event.wheelDeltaY && isChrome ? (event.wheelDeltaY / $window.devicePixelRatio) : event.wheelDeltaY,
                 detail: event.detail,
                 shiftKey: event.shiftKey,
                 type: event.type
@@ -1243,6 +1245,7 @@ async function webviewPreloads(ctx) {
                     get lineLimit() { return currentRenderOptions.lineLimit; },
                     get outputScrolling() { return currentRenderOptions.outputScrolling; },
                     get outputWordWrap() { return currentRenderOptions.outputWordWrap; },
+                    get linkifyFilePaths() { return currentRenderOptions.linkifyFilePaths; },
                 },
                 get onDidChangeSettings() { return settingChange.event; }
             };

package/vscode/src/vs/workbench/contrib/notebook/browser/viewModel/notebookViewModelImpl.js

@@ -543,6 +543,7 @@ let NotebookViewModel = class NotebookViewModel extends Disposable {
             if (handle !== undefined) {
                 const cell = this.getCellByHandle(handle);
                 cell?.deltaCellDecorations([id], []);
+                this._decorationIdToCellMap.delete(id);
             }
         });
         const result = [];

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

@@ -1,7 +1,8 @@
 import { __decorate, __param } from '../../../../../../../../external/tslib/tslib.es6.js';
 import { localizeWithPath } from '../../../../../nls.js';
-import { addDisposableListener, EventType, getWindow, clearNode, $ } from '../../../../../base/browser/dom.js';
+import { addDisposableListener, EventType, getWindow, clearNode } from '../../../../../base/browser/dom.js';
 import { StandardMouseEvent } from '../../../../../base/browser/mouseEvent.js';
+import { Emitter } from '../../../../../base/common/event.js';
 import { Disposable, DisposableStore } from '../../../../../base/common/lifecycle.js';
 import { Categories } from '../../../../../platform/action/common/actionCommonCategories.js';
 import { registerAction2, Action2, MenuId } from '../../../../../platform/actions/common/actions.js';
@@ -9,6 +10,10 @@ import { IConfigurationService } from '../../../../../platform/configuration/com
 import { ContextKeyExpr } from '../../../../../platform/contextkey/common/contextkey.js';
 import { IContextMenuService } from '../../../../../platform/contextview/browser/contextView.js';
 import { CellKind } from '../../common/notebookCommon.js';
+import { Delayer } from '../../../../../base/common/async.js';
+import { ThemeIcon } from '../../../../../base/common/themables.js';
+import { foldingCollapsedIcon, foldingExpandedIcon } from '../../../../../editor/contrib/folding/browser/foldingDecorations.js';
+import { FoldingController } from '../controller/foldingController.js';
 var NotebookStickyScroll_1;
 class ToggleNotebookStickyScroll extends Action2 {
     constructor() {
@@ -54,24 +59,39 @@ class ToggleNotebookStickyScroll extends Action2 {
     }
 }
 class NotebookStickyLine extends Disposable {
-    constructor(element, entry, notebookEditor) {
+    constructor(element, foldingIcon, header, entry, notebookEditor) {
         super();
         this.element = element;
+        this.foldingIcon = foldingIcon;
+        this.header = header;
         this.entry = entry;
         this.notebookEditor = notebookEditor;
-        this._register(addDisposableListener(this.element, EventType.CLICK, () => {
+        this._register(addDisposableListener(this.header, EventType.CLICK , () => {
             this.focusCell();
         }));
+        this._register(addDisposableListener(this.foldingIcon.domNode, EventType.CLICK , () => {
+            if (this.entry.cell.cellKind === CellKind.Markup) {
+                const currentFoldingState = this.entry.cell.foldingState;
+                this.toggleFoldRange(currentFoldingState);
+            }
+        }));
+    }
+    toggleFoldRange(currentState) {
+        const foldingController = this.notebookEditor.getContribution(FoldingController.id);
+        const index = this.entry.index;
+        const headerLevel = this.entry.level;
+        const newFoldingState = ((currentState === 2) ) ? 1  : 2 ;
+        foldingController.setFoldingStateUp(index, newFoldingState, headerLevel);
+        this.focusCell();
     }
     focusCell() {
         this.notebookEditor.focusNotebookCell(this.entry.cell, 'container');
         const cellScrollTop = this.notebookEditor.getAbsoluteTopOfElement(this.entry.cell);
-        const parentCount = this.getParentCount();
+        const parentCount = NotebookStickyLine.getParentCount(this.entry);
         this.notebookEditor.setScrollTop(cellScrollTop - (parentCount + 1.1) * 22);
     }
-    getParentCount() {
+    static getParentCount(entry) {
         let count = 0;
-        let entry = this.entry;
         while (entry.parent) {
             count++;
             entry = entry.parent;
@@ -79,16 +99,48 @@ class NotebookStickyLine extends Disposable {
         return count;
     }
 }
+class StickyFoldingIcon {
+    constructor(isCollapsed, dimension) {
+        this.isCollapsed = isCollapsed;
+        this.dimension = dimension;
+        this.domNode = document.createElement('div');
+        this.domNode.style.width = `${dimension}px`;
+        this.domNode.style.height = `${dimension}px`;
+        this.domNode.className = ThemeIcon.asClassName(isCollapsed ? foldingCollapsedIcon : foldingExpandedIcon);
+    }
+    setVisible(visible) {
+        this.domNode.style.cursor = visible ? 'pointer' : 'default';
+        this.domNode.style.opacity = visible ? '1' : '0';
+    }
+}
 let NotebookStickyScroll = NotebookStickyScroll_1 = class NotebookStickyScroll extends Disposable {
     getDomNode() {
         return this.domNode;
     }
     getCurrentStickyHeight() {
-        return this.currentStickyLines.size * 22;
+        let height = 0;
+        this.currentStickyLines.forEach((value) => {
+            if (value.rendered) {
+                height += 22;
+            }
+        });
+        return height;
     }
     setCurrentStickyLines(newStickyLines) {
         this.currentStickyLines = newStickyLines;
     }
+    compareStickyLineMaps(mapA, mapB) {
+        if (mapA.size !== mapB.size) {
+            return false;
+        }
+        for (const [key, value] of mapA) {
+            const otherValue = mapB.get(key);
+            if (!otherValue || value.rendered !== otherValue.rendered) {
+                return false;
+            }
+        }
+        return true;
+    }
     constructor(domNode, notebookEditor, notebookOutline, notebookCellList, _contextMenuService) {
         super();
         this.domNode = domNode;
@@ -98,15 +150,15 @@ let NotebookStickyScroll = NotebookStickyScroll_1 = class NotebookStickyScroll e
         this._contextMenuService = _contextMenuService;
         this._disposables = ( new DisposableStore());
         this.currentStickyLines = ( new Map());
-        if (this.notebookEditor.notebookOptions.getDisplayOptions().stickyScroll) {
+        this.filteredOutlineEntries = [];
+        this._onDidChangeNotebookStickyScroll = this._register(( new Emitter()));
+        this.onDidChangeNotebookStickyScroll = this._onDidChangeNotebookStickyScroll.event;
+        if (this.notebookEditor.notebookOptions.getDisplayOptions().stickyScrollEnabled) {
             this.init();
         }
         this._register(this.notebookEditor.notebookOptions.onDidChangeOptions((e) => {
-            if (e.stickyScroll) {
-                this.updateConfig();
-            }
-            if (e.globalToolbar) {
-                this.setTop();
+            if (e.stickyScrollEnabled || e.stickyScrollMode) {
+                this.updateConfig(e);
             }
         }));
         this._register(addDisposableListener(this.domNode, EventType.CONTEXT_MENU, async (event) => {
@@ -120,41 +172,47 @@ let NotebookStickyScroll = NotebookStickyScroll_1 = class NotebookStickyScroll e
             getAnchor: () => event,
         });
     }
-    updateConfig() {
-        if (this.notebookEditor.notebookOptions.getDisplayOptions().stickyScroll) {
-            this.init();
-        }
-        else {
-            this._disposables.clear();
-            this.disposeCurrentStickyLines();
-            clearNode(this.domNode);
-            this.updateDisplay();
-        }
-    }
-    setTop() {
-        if (this.notebookEditor.notebookOptions.getDisplayOptions().globalToolbar) {
-            this.domNode.style.top = '26px';
+    updateConfig(e) {
+        if (e.stickyScrollEnabled) {
+            if (this.notebookEditor.notebookOptions.getDisplayOptions().stickyScrollEnabled) {
+                this.init();
+            }
+            else {
+                this._disposables.clear();
+                this.notebookOutline.dispose();
+                this.disposeCurrentStickyLines();
+                clearNode(this.domNode);
+                this.updateDisplay();
+            }
         }
-        else {
-            this.domNode.style.top = '0px';
+        else if (e.stickyScrollMode && this.notebookEditor.notebookOptions.getDisplayOptions().stickyScrollEnabled) {
+            this.updateContent(computeContent(this.notebookEditor, this.notebookCellList, this.filteredOutlineEntries, this.getCurrentStickyHeight()));
         }
     }
     init() {
         this.notebookOutline.init();
-        this.initializeContent();
+        this.filteredOutlineEntries = this.notebookOutline.entries.filter(entry => entry.level !== 7);
+        this.updateContent(computeContent(this.notebookEditor, this.notebookCellList, this.filteredOutlineEntries, this.getCurrentStickyHeight()));
         this._disposables.add(this.notebookOutline.onDidChange(() => {
-            clearNode(this.domNode);
-            this.disposeCurrentStickyLines();
-            this.updateContent(computeContent(this.domNode, this.notebookEditor, this.notebookCellList, this.notebookOutline.entries));
+            this.filteredOutlineEntries = this.notebookOutline.entries.filter(entry => entry.level !== 7);
+            const recompute = computeContent(this.notebookEditor, this.notebookCellList, this.filteredOutlineEntries, this.getCurrentStickyHeight());
+            if (!this.compareStickyLineMaps(recompute, this.currentStickyLines)) {
+                this.updateContent(recompute);
+            }
         }));
         this._disposables.add(this.notebookEditor.onDidAttachViewModel(() => {
             this.notebookOutline.init();
-            this.initializeContent();
+            this.updateContent(computeContent(this.notebookEditor, this.notebookCellList, this.filteredOutlineEntries, this.getCurrentStickyHeight()));
         }));
         this._disposables.add(this.notebookEditor.onDidScroll(() => {
-            clearNode(this.domNode);
-            this.disposeCurrentStickyLines();
-            this.updateContent(computeContent(this.domNode, this.notebookEditor, this.notebookCellList, this.notebookOutline.entries));
+            const d = ( new Delayer(100));
+            d.trigger(() => {
+                d.dispose();
+                const recompute = computeContent(this.notebookEditor, this.notebookCellList, this.filteredOutlineEntries, this.getCurrentStickyHeight());
+                if (!this.compareStickyLineMaps(recompute, this.currentStickyLines)) {
+                    this.updateContent(recompute);
+                }
+            });
         }));
     }
     static getVisibleOutlineEntry(visibleIndex, notebookOutlineEntries) {
@@ -183,72 +241,30 @@ let NotebookStickyScroll = NotebookStickyScroll_1 = class NotebookStickyScroll e
         }
         return undefined;
     }
-    initializeContent() {
-        const visibleRange = this.notebookEditor.visibleRanges[0];
-        if (!visibleRange) {
-            return;
-        }
-        clearNode(this.domNode);
-        const editorScrollTop = this.notebookEditor.scrollTop;
-        let trackedEntry = undefined;
-        let sectionBottom = 0;
-        for (let i = visibleRange.start; i < visibleRange.end; i++) {
-            if (i === 0) {
-                this.updateDisplay();
-                this.setCurrentStickyLines(( new Map()));
-                return;
-            }
-            const cell = this.notebookEditor.cellAt(i);
-            if (!cell) {
-                return;
-            }
-            const nextCell = this.notebookEditor.cellAt(i + 1);
-            if (nextCell && i + 1 < visibleRange.end) {
-                if (nextCell.cellKind === CellKind.Markup) {
-                    sectionBottom = this.notebookCellList.getCellViewScrollBottom(cell);
-                    const entry = NotebookStickyScroll_1.getVisibleOutlineEntry(i, this.notebookOutline.entries);
-                    if (!entry) {
-                        return;
-                    }
-                    const newStickyHeight = NotebookStickyScroll_1.computeStickyHeight(entry);
-                    if (editorScrollTop + newStickyHeight < sectionBottom) {
-                        trackedEntry = entry;
-                        break;
-                    }
-                    else {
-                        continue;
-                    }
-                }
-            }
-            else {
-                sectionBottom = this.notebookEditor.scrollTop + this.notebookEditor.getLayoutInfo().scrollHeight;
-                trackedEntry = NotebookStickyScroll_1.getVisibleOutlineEntry(i, this.notebookOutline.entries);
-                break;
-            }
-        }
-        const linesToRender = Math.floor((sectionBottom - editorScrollTop) / 22);
-        let newMap = ( new Map());
-        newMap = NotebookStickyScroll_1.renderStickyLines(trackedEntry?.parent, this.domNode, linesToRender, newMap, this.notebookEditor);
-        this.setCurrentStickyLines(newMap);
-        this.updateDisplay();
-    }
     updateContent(newMap) {
+        clearNode(this.domNode);
+        this.disposeCurrentStickyLines();
+        this.renderStickyLines(newMap, this.domNode);
+        const oldStickyHeight = this.getCurrentStickyHeight();
         this.setCurrentStickyLines(newMap);
+        const sizeDelta = this.getCurrentStickyHeight() - oldStickyHeight;
+        if (sizeDelta !== 0) {
+            this._onDidChangeNotebookStickyScroll.fire(sizeDelta);
+        }
         this.updateDisplay();
     }
     updateDisplay() {
-        const hasSticky = this.currentStickyLines.size > 0;
+        const hasSticky = this.getCurrentStickyHeight() > 0;
         if (!hasSticky) {
             this.domNode.style.display = 'none';
         }
         else {
             this.domNode.style.display = 'block';
         }
-        this.setTop();
     }
     static computeStickyHeight(entry) {
         let height = 0;
-        if (entry.cell.cellKind === CellKind.Markup) {
+        if (entry.cell.cellKind === CellKind.Markup && entry.level !== 7) {
             height += 22;
         }
         while (entry.parent) {
@@ -257,8 +273,9 @@ let NotebookStickyScroll = NotebookStickyScroll_1 = class NotebookStickyScroll e
         }
         return height;
     }
-    static renderStickyLines(entry, containerElement, numLinesToRender, newMap, notebookEditor) {
+    static checkCollapsedStickyLines(entry, numLinesToRender, notebookEditor) {
         let currentEntry = entry;
+        const newMap = ( new Map());
         const elementsToRender = [];
         while (currentEntry) {
             if (currentEntry.level === 7) {
@@ -274,17 +291,38 @@ let NotebookStickyScroll = NotebookStickyScroll_1 = class NotebookStickyScroll e
             if (i >= numLinesToRender) {
                 break;
             }
-            containerElement.append(elementsToRender[i].element);
             newMap.set(elementsToRender[i].entry, { line: elementsToRender[i], rendered: true });
         }
-        containerElement.append($('div', { class: 'notebook-shadow' }));
         return newMap;
     }
+    renderStickyLines(stickyMap, containerElement) {
+        const reversedEntries = Array.from(stickyMap.entries()).reverse();
+        for (const [, value] of reversedEntries) {
+            if (!value.rendered) {
+                continue;
+            }
+            containerElement.append(value.line.element);
+        }
+    }
     static createStickyElement(entry, notebookEditor) {
         const stickyElement = document.createElement('div');
-        stickyElement.classList.add('notebook-sticky-scroll-line');
-        stickyElement.innerText = '#'.repeat(entry.level) + ' ' + entry.label;
-        return ( new NotebookStickyLine(stickyElement, entry, notebookEditor));
+        stickyElement.classList.add('notebook-sticky-scroll-element');
+        const indentMode = notebookEditor.notebookOptions.getLayoutConfiguration().stickyScrollMode;
+        if (indentMode === 'indented') {
+            stickyElement.style.paddingLeft = NotebookStickyLine.getParentCount(entry) * 10 + 'px';
+        }
+        let isCollapsed = false;
+        if (entry.cell.cellKind === CellKind.Markup) {
+            isCollapsed = entry.cell.foldingState === 2 ;
+        }
+        const stickyFoldingIcon = ( new StickyFoldingIcon(isCollapsed, 16));
+        stickyFoldingIcon.domNode.classList.add('notebook-sticky-scroll-folding-icon');
+        stickyFoldingIcon.setVisible(true);
+        const stickyHeader = document.createElement('div');
+        stickyHeader.classList.add('notebook-sticky-scroll-header');
+        stickyHeader.innerText = entry.label;
+        stickyElement.append(stickyFoldingIcon.domNode, stickyHeader);
+        return ( new NotebookStickyLine(stickyElement, stickyFoldingIcon, stickyHeader, entry, notebookEditor));
     }
     disposeCurrentStickyLines() {
         this.currentStickyLines.forEach((value) => {
@@ -294,88 +332,83 @@ let NotebookStickyScroll = NotebookStickyScroll_1 = class NotebookStickyScroll e
     dispose() {
         this._disposables.dispose();
         this.disposeCurrentStickyLines();
+        this.notebookOutline.dispose();
         super.dispose();
     }
 };
 NotebookStickyScroll = NotebookStickyScroll_1 = ( __decorate([
     ( __param(4, IContextMenuService))
 ], NotebookStickyScroll));
-function computeContent(domNode, notebookEditor, notebookCellList, notebookOutlineEntries) {
-    const editorScrollTop = notebookEditor.scrollTop;
+function computeContent(notebookEditor, notebookCellList, notebookOutlineEntries, renderedStickyHeight) {
+    const editorScrollTop = notebookEditor.scrollTop - renderedStickyHeight;
     const visibleRange = notebookEditor.visibleRanges[0];
     if (!visibleRange) {
         return ( new Map());
     }
-    let trackedEntry = undefined;
-    let sectionBottom = 0;
-    for (let i = visibleRange.start; i < visibleRange.end; i++) {
-        const cell = notebookEditor.cellAt(i);
+    if (visibleRange.start === 0) {
+        const firstCell = notebookEditor.cellAt(0);
+        const firstCellEntry = NotebookStickyScroll.getVisibleOutlineEntry(0, notebookOutlineEntries);
+        if (firstCell && firstCellEntry && firstCell.cellKind === CellKind.Markup && firstCellEntry.level !== 7) {
+            if (notebookEditor.scrollTop > 22) {
+                const newMap = NotebookStickyScroll.checkCollapsedStickyLines(firstCellEntry, 100, notebookEditor);
+                return newMap;
+            }
+        }
+    }
+    let cell;
+    let cellEntry;
+    const startIndex = visibleRange.start - 1;
+    for (let currentIndex = startIndex; currentIndex < visibleRange.end; currentIndex++) {
+        cell = notebookEditor.cellAt(currentIndex);
         if (!cell) {
             return ( new Map());
         }
-        const nextCell = notebookEditor.cellAt(i + 1);
-        if (cell.cellKind === CellKind.Markup) {
-            sectionBottom = notebookCellList.getCellViewScrollBottom(cell);
-            const entry = NotebookStickyScroll.getVisibleOutlineEntry(i, notebookOutlineEntries);
-            if (!entry) {
-                return ( new Map());
+        cellEntry = NotebookStickyScroll.getVisibleOutlineEntry(currentIndex, notebookOutlineEntries);
+        if (!cellEntry) {
+            return ( new Map());
+        }
+        const nextCell = notebookEditor.cellAt(currentIndex + 1);
+        if (!nextCell) {
+            const sectionBottom = notebookEditor.getLayoutInfo().scrollHeight;
+            const linesToRender = Math.floor((sectionBottom) / 22);
+            const newMap = NotebookStickyScroll.checkCollapsedStickyLines(cellEntry, linesToRender, notebookEditor);
+            return newMap;
+        }
+        const nextCellEntry = NotebookStickyScroll.getVisibleOutlineEntry(currentIndex + 1, notebookOutlineEntries);
+        if (!nextCellEntry) {
+            return ( new Map());
+        }
+        if (nextCell.cellKind === CellKind.Markup && nextCellEntry.level !== 7) {
+            const sectionBottom = notebookCellList.getCellViewScrollTop(nextCell);
+            const currentSectionStickyHeight = NotebookStickyScroll.computeStickyHeight(cellEntry);
+            const nextSectionStickyHeight = NotebookStickyScroll.computeStickyHeight(nextCellEntry);
+            if (editorScrollTop + currentSectionStickyHeight < sectionBottom) {
+                const linesToRender = Math.floor((sectionBottom - editorScrollTop) / 22);
+                const newMap = NotebookStickyScroll.checkCollapsedStickyLines(cellEntry, linesToRender, notebookEditor);
+                return newMap;
             }
-            if (!entry.parent) {
-                if (sectionBottom > editorScrollTop) {
-                    return ( new Map());
-                }
+            else if (nextSectionStickyHeight >= currentSectionStickyHeight) {
+                const newMap = NotebookStickyScroll.checkCollapsedStickyLines(nextCellEntry, 100, notebookEditor);
+                return newMap;
             }
-        }
-        if (nextCell && i + 1 < visibleRange.end) {
-            if (nextCell.cellKind === CellKind.Markup) {
-                sectionBottom = notebookCellList.getCellViewScrollBottom(cell);
-                const entry = NotebookStickyScroll.getVisibleOutlineEntry(i, notebookOutlineEntries);
-                if (!entry) {
-                    return ( new Map());
-                }
-                const currentSectionStickyHeight = NotebookStickyScroll.computeStickyHeight(entry);
-                if (editorScrollTop + currentSectionStickyHeight < sectionBottom) {
-                    const linesToRender = Math.floor((sectionBottom - editorScrollTop) / 22);
-                    let newMap = ( new Map());
-                    newMap = NotebookStickyScroll.renderStickyLines(entry, domNode, linesToRender, newMap, notebookEditor);
-                    return newMap;
-                }
-                let nextSectionEntry = undefined;
-                for (let j = 1; j < visibleRange.end - i; j++) {
-                    const cellCheck = notebookEditor.cellAt(i + j);
-                    if (cellCheck) {
-                        nextSectionEntry = NotebookStickyScroll.getVisibleOutlineEntry(i + j, notebookOutlineEntries);
-                        if (nextSectionEntry) {
-                            break;
-                        }
-                    }
-                }
-                const nextSectionStickyHeight = NotebookStickyScroll.computeStickyHeight(nextSectionEntry);
-                sectionBottom = notebookCellList.getCellViewScrollTop(nextSectionEntry.cell) - 10;
-                if (entry?.parent?.parent === nextSectionEntry?.parent) {
-                    const linesToRender = Math.floor((sectionBottom - editorScrollTop) / 22) + 100;
-                    let newMap = ( new Map());
-                    newMap = NotebookStickyScroll.renderStickyLines(nextSectionEntry?.parent, domNode, linesToRender, newMap, notebookEditor);
+            else if (nextSectionStickyHeight < currentSectionStickyHeight) {
+                const availableSpace = sectionBottom - editorScrollTop;
+                if (availableSpace >= nextSectionStickyHeight) {
+                    const linesToRender = Math.floor((availableSpace) / 22);
+                    const newMap = NotebookStickyScroll.checkCollapsedStickyLines(cellEntry, linesToRender, notebookEditor);
                     return newMap;
                 }
-                else if (Math.abs(currentSectionStickyHeight - nextSectionStickyHeight) > 22) {
-                    const linesToRender = (sectionBottom - editorScrollTop) / 22;
-                    let newMap = ( new Map());
-                    newMap = NotebookStickyScroll.renderStickyLines(entry?.parent, domNode, linesToRender, newMap, notebookEditor);
+                else {
+                    const newMap = NotebookStickyScroll.checkCollapsedStickyLines(nextCellEntry, 100, notebookEditor);
                     return newMap;
                 }
             }
         }
-        else {
-            sectionBottom = notebookEditor.getLayoutInfo().scrollHeight;
-            trackedEntry = NotebookStickyScroll.getVisibleOutlineEntry(i, notebookOutlineEntries);
-            const linesToRender = Math.floor((sectionBottom - editorScrollTop) / 22);
-            let newMap = ( new Map());
-            newMap = NotebookStickyScroll.renderStickyLines(trackedEntry?.parent, domNode, linesToRender, newMap, notebookEditor);
-            return newMap;
-        }
     }
-    return ( new Map());
+    const sectionBottom = notebookEditor.getLayoutInfo().scrollHeight;
+    const linesToRender = Math.floor((sectionBottom - editorScrollTop) / 22);
+    const newMap = NotebookStickyScroll.checkCollapsedStickyLines(cellEntry, linesToRender, notebookEditor);
+    return newMap;
 }
 registerAction2(ToggleNotebookStickyScroll);
 export { NotebookStickyLine, NotebookStickyScroll, ToggleNotebookStickyScroll, computeContent };

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

@@ -1,7 +1,7 @@
 import { __decorate, __param } from '../../../../../../../../external/tslib/tslib.es6.js';
 import { ActionViewItem } from '../../../../../base/browser/ui/actionbar/actionViewItems.js';
 import { Action } from '../../../../../base/common/actions.js';
-import { localizeWithPath } from '../../../../../nls.js';
+import { localize2WithPath, localizeWithPath } from '../../../../../nls.js';
 import { registerAction2, Action2, MenuId } from '../../../../../platform/actions/common/actions.js';
 import { ContextKeyExpr } from '../../../../../platform/contextkey/common/contextkey.js';
 import { ExtensionIdentifier } from '../../../../../platform/extensions/common/extensions.js';
@@ -37,11 +37,11 @@ registerAction2(class extends Action2 {
         super({
             id: SELECT_KERNEL_ID,
             category: NOTEBOOK_ACTIONS_CATEGORY,
-            title: { value: ( localizeWithPath(
+            title: ( localize2WithPath(
                 'vs/workbench/contrib/notebook/browser/viewParts/notebookKernelView',
                 'notebookActions.selectKernel',
-                "Select Notebook Kernel"
-            )), original: 'Select Notebook Kernel' },
+                'Select Notebook Kernel'
+            )),
             icon: selectKernelIcon,
             f1: true,
             precondition: NOTEBOOK_IS_ACTIVE_EDITOR,