@codingame/monaco-vscode-api 1.85.0-next.2 → 1.85.1

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

@@ -0,0 +1,59 @@
+import { __decorate, __param } from '../../../../../../../../../external/tslib/tslib.es6.js';
+import * as dom from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { Codicon } from 'monaco-editor/esm/vs/base/common/codicons.js';
+import { ThemeIcon } from 'monaco-editor/esm/vs/base/common/themables.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+import { IKeybindingService } from 'monaco-editor/esm/vs/platform/keybinding/common/keybinding.js';
+import { EXPAND_CELL_OUTPUT_COMMAND_ID } from '../../notebookBrowser.js';
+import { CellContentPart } from '../cellPart.js';
+const $ = dom.$;
+let CollapsedCellOutput = class CollapsedCellOutput extends CellContentPart {
+    constructor(notebookEditor, cellOutputCollapseContainer, keybindingService) {
+        super();
+        this.notebookEditor = notebookEditor;
+        const placeholder = dom.append(cellOutputCollapseContainer, $('span.expandOutputPlaceholder'));
+        placeholder.textContent = ( localizeWithPath(
+            'vs/workbench/contrib/notebook/browser/view/cellParts/collapsedCellOutput',
+            'cellOutputsCollapsedMsg',
+            "Outputs are collapsed"
+        ));
+        const expandIcon = dom.append(cellOutputCollapseContainer, $('span.expandOutputIcon'));
+        expandIcon.classList.add(...ThemeIcon.asClassNameArray(Codicon.more));
+        const keybinding = keybindingService.lookupKeybinding(EXPAND_CELL_OUTPUT_COMMAND_ID);
+        if (keybinding) {
+            placeholder.title = ( localizeWithPath(
+                'vs/workbench/contrib/notebook/browser/view/cellParts/collapsedCellOutput',
+                'cellExpandOutputButtonLabelWithDoubleClick',
+                "Double-click to expand cell output ({0})",
+                keybinding.getLabel()
+            ));
+            cellOutputCollapseContainer.title = ( localizeWithPath(
+                'vs/workbench/contrib/notebook/browser/view/cellParts/collapsedCellOutput',
+                'cellExpandOutputButtonLabel',
+                "Expand Cell Output (${0})",
+                keybinding.getLabel()
+            ));
+        }
+        dom.hide(cellOutputCollapseContainer);
+        this._register(dom.addDisposableListener(expandIcon, dom.EventType.CLICK, () => this.expand()));
+        this._register(dom.addDisposableListener(cellOutputCollapseContainer, dom.EventType.DBLCLICK, () => this.expand()));
+    }
+    expand() {
+        if (!this.currentCell) {
+            return;
+        }
+        if (!this.currentCell) {
+            return;
+        }
+        const textModel = this.notebookEditor.textModel;
+        const index = textModel.cells.indexOf(this.currentCell.model);
+        if (index < 0) {
+            return;
+        }
+        this.currentCell.isOutputCollapsed = !this.currentCell.isOutputCollapsed;
+    }
+};
+CollapsedCellOutput = ( __decorate([
+    ( __param(2, IKeybindingService))
+], CollapsedCellOutput));
+export { CollapsedCellOutput };

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

@@ -0,0 +1,67 @@
+import * as dom from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { Codicon } from 'monaco-editor/esm/vs/base/common/codicons.js';
+import { ThemeIcon } from 'monaco-editor/esm/vs/base/common/themables.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+import { FoldingController } from '../../controller/foldingController.js';
+import { CellEditState } from '../../notebookBrowser.js';
+import { CellContentPart } from '../cellPart.js';
+class FoldedCellHint extends CellContentPart {
+    constructor(_notebookEditor, _container) {
+        super();
+        this._notebookEditor = _notebookEditor;
+        this._container = _container;
+    }
+    didRenderCell(element) {
+        this.update(element);
+    }
+    update(element) {
+        if (!this._notebookEditor.hasModel()) {
+            return;
+        }
+        if (element.isInputCollapsed || element.getEditState() === CellEditState.Editing) {
+            dom.hide(this._container);
+        }
+        else if (element.foldingState === 2 ) {
+            const idx = this._notebookEditor.getViewModel().getCellIndex(element);
+            const length = this._notebookEditor.getViewModel().getFoldedLength(idx);
+            dom.reset(this._container, this.getHiddenCellsLabel(length), this.getHiddenCellHintButton(element));
+            dom.show(this._container);
+            const foldHintTop = element.layoutInfo.previewHeight;
+            this._container.style.top = `${foldHintTop}px`;
+        }
+        else {
+            dom.hide(this._container);
+        }
+    }
+    getHiddenCellsLabel(num) {
+        const label = num === 1 ?
+            ( localizeWithPath(
+                'vs/workbench/contrib/notebook/browser/view/cellParts/foldedCellHint',
+                'hiddenCellsLabel',
+                "1 cell hidden"
+            )) :
+            ( localizeWithPath(
+                'vs/workbench/contrib/notebook/browser/view/cellParts/foldedCellHint',
+                'hiddenCellsLabelPlural',
+                "{0} cells hidden",
+                num
+            ));
+        return dom.$('span.notebook-folded-hint-label', undefined, label);
+    }
+    getHiddenCellHintButton(element) {
+        const expandIcon = dom.$('span.cell-expand-part-button');
+        expandIcon.classList.add(...ThemeIcon.asClassNameArray(Codicon.more));
+        this._register(dom.addDisposableListener(expandIcon, dom.EventType.CLICK, () => {
+            const controller = this._notebookEditor.getContribution(FoldingController.id);
+            const idx = this._notebookEditor.getCellIndex(element);
+            if (typeof idx === 'number') {
+                controller.setFoldingStateDown(idx, 1 , 1);
+            }
+        }));
+        return expandIcon;
+    }
+    updateInternalLayoutNow(element) {
+        this.update(element);
+    }
+}
+export { FoldedCellHint };

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

@@ -0,0 +1,430 @@
+import { __decorate, __param } from '../../../../../../../../../external/tslib/tslib.es6.js';
+import * as dom from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { renderIcon } from 'monaco-editor/esm/vs/base/browser/ui/iconLabel/iconLabels.js';
+import { raceCancellation, disposableTimeout } from 'monaco-editor/esm/vs/base/common/async.js';
+import { CancellationTokenSource } from 'monaco-editor/esm/vs/base/common/cancellation.js';
+import { Codicon } from 'monaco-editor/esm/vs/base/common/codicons.js';
+import { ThemeIcon } from 'monaco-editor/esm/vs/base/common/themables.js';
+import { Disposable, DisposableStore, MutableDisposable, toDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { CodeEditorWidget } from 'monaco-editor/esm/vs/editor/browser/widget/codeEditorWidget.js';
+import { EditorContextKeys } from 'monaco-editor/esm/vs/editor/common/editorContextKeys.js';
+import { ILanguageService } from 'monaco-editor/esm/vs/editor/common/languages/language.js';
+import { tokenizeToStringSync } from 'monaco-editor/esm/vs/editor/common/languages/textToHtmlTokenizer.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+import { IAccessibilityService } from 'monaco-editor/esm/vs/platform/accessibility/common/accessibility.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { ServiceCollection } from 'monaco-editor/esm/vs/platform/instantiation/common/serviceCollection.js';
+import { IKeybindingService } from 'monaco-editor/esm/vs/platform/keybinding/common/keybinding.js';
+import { CellEditState, CellFocusMode, EXPAND_CELL_INPUT_COMMAND_ID } from '../../notebookBrowser.js';
+import { expandedIcon, collapsedIcon } from '../../notebookIcons.js';
+import { CellEditorOptions } from './cellEditorOptions.js';
+import { WordHighlighterContribution } from 'monaco-editor/esm/vs/editor/contrib/wordHighlighter/browser/wordHighlighter.js';
+let MarkupCell = class MarkupCell extends Disposable {
+    constructor(notebookEditor, viewCell, templateData, renderedEditors, accessibilityService, contextKeyService, instantiationService, languageService, configurationService, keybindingService) {
+        super();
+        this.notebookEditor = notebookEditor;
+        this.viewCell = viewCell;
+        this.templateData = templateData;
+        this.renderedEditors = renderedEditors;
+        this.accessibilityService = accessibilityService;
+        this.contextKeyService = contextKeyService;
+        this.instantiationService = instantiationService;
+        this.languageService = languageService;
+        this.configurationService = configurationService;
+        this.keybindingService = keybindingService;
+        this.editor = null;
+        this.localDisposables = this._register(( new DisposableStore()));
+        this.focusSwitchDisposable = this._register(( new MutableDisposable()));
+        this.editorDisposables = this._register(( new DisposableStore()));
+        this.constructDOM();
+        this.editorPart = templateData.editorPart;
+        this.cellEditorOptions = this._register(( new CellEditorOptions(
+            this.notebookEditor.getBaseCellEditorOptions(viewCell.language),
+            this.notebookEditor.notebookOptions,
+            this.configurationService
+        )));
+        this.cellEditorOptions.setLineNumbers(this.viewCell.lineNumbers);
+        this.editorOptions = this.cellEditorOptions.getValue(this.viewCell.internalMetadata, this.viewCell.uri);
+        this._register(toDisposable(() => renderedEditors.delete(this.viewCell)));
+        this.registerListeners();
+        this.templateData.cellParts.scheduleRenderCell(this.viewCell);
+        this._register(toDisposable(() => {
+            this.templateData.cellParts.unrenderCell(this.viewCell);
+        }));
+        this._register(this.accessibilityService.onDidChangeScreenReaderOptimized(() => {
+            this.viewUpdate();
+        }));
+        this.updateForHover();
+        this.updateForFocusModeChange();
+        this.foldingState = viewCell.foldingState;
+        this.layoutFoldingIndicator();
+        this.updateFoldingIconShowClass();
+        if (this.viewCell.layoutInfo.totalHeight > 0) {
+            this.relayoutCell();
+        }
+        this.applyDecorations();
+        this.viewUpdate();
+        this.layoutCellParts();
+        this._register(this.viewCell.onDidChangeLayout(() => {
+            this.layoutCellParts();
+        }));
+    }
+    layoutCellParts() {
+        this.templateData.cellParts.updateInternalLayoutNow(this.viewCell);
+    }
+    constructDOM() {
+        const id = `aria-markup-cell-${this.viewCell.id}`;
+        this.markdownAccessibilityContainer = this.templateData.cellContainer;
+        this.markdownAccessibilityContainer.id = id;
+        this.markdownAccessibilityContainer.style.height = '1px';
+        this.markdownAccessibilityContainer.style.overflow = 'hidden';
+        this.markdownAccessibilityContainer.style.position = 'absolute';
+        this.markdownAccessibilityContainer.style.top = '100000px';
+        this.markdownAccessibilityContainer.style.left = '10000px';
+        this.markdownAccessibilityContainer.ariaHidden = 'false';
+        this.templateData.rootContainer.setAttribute('aria-describedby', id);
+        this.templateData.container.classList.toggle('webview-backed-markdown-cell', true);
+    }
+    registerListeners() {
+        this._register(this.viewCell.onDidChangeState(e => {
+            this.templateData.cellParts.updateState(this.viewCell, e);
+        }));
+        this._register(this.viewCell.model.onDidChangeMetadata(() => {
+            this.viewUpdate();
+        }));
+        this._register(this.viewCell.onDidChangeState((e) => {
+            if (e.editStateChanged || e.contentChanged) {
+                this.viewUpdate();
+            }
+            if (e.focusModeChanged) {
+                this.updateForFocusModeChange();
+            }
+            if (e.foldingStateChanged) {
+                const foldingState = this.viewCell.foldingState;
+                if (foldingState !== this.foldingState) {
+                    this.foldingState = foldingState;
+                    this.layoutFoldingIndicator();
+                }
+            }
+            if (e.cellIsHoveredChanged) {
+                this.updateForHover();
+            }
+            if (e.inputCollapsedChanged) {
+                this.updateCollapsedState();
+                this.viewUpdate();
+            }
+            if (e.cellLineNumberChanged) {
+                this.cellEditorOptions.setLineNumbers(this.viewCell.lineNumbers);
+            }
+        }));
+        this._register(this.notebookEditor.notebookOptions.onDidChangeOptions(e => {
+            if (e.showFoldingControls) {
+                this.updateFoldingIconShowClass();
+            }
+        }));
+        this._register(this.viewCell.onDidChangeLayout((e) => {
+            const layoutInfo = this.editor?.getLayoutInfo();
+            if (e.outerWidth && this.viewCell.getEditState() === CellEditState.Editing && layoutInfo && layoutInfo.width !== this.viewCell.layoutInfo.editorWidth) {
+                this.onCellEditorWidthChange();
+            }
+        }));
+        this._register(this.cellEditorOptions.onDidChange(() => {
+            this.updateEditorOptions(this.cellEditorOptions.getUpdatedValue(this.viewCell.internalMetadata, this.viewCell.uri));
+        }));
+    }
+    updateCollapsedState() {
+        if (this.viewCell.isInputCollapsed) {
+            this.notebookEditor.hideMarkupPreviews([this.viewCell]);
+        }
+        else {
+            this.notebookEditor.unhideMarkupPreviews([this.viewCell]);
+        }
+    }
+    updateForHover() {
+        this.templateData.container.classList.toggle('markdown-cell-hover', this.viewCell.cellIsHovered);
+    }
+    updateForFocusModeChange() {
+        if (this.viewCell.focusMode === CellFocusMode.Editor) {
+            this.focusEditorIfNeeded();
+        }
+        this.templateData.container.classList.toggle('cell-editor-focus', this.viewCell.focusMode === CellFocusMode.Editor);
+    }
+    applyDecorations() {
+        this._register(this.viewCell.onCellDecorationsChanged((e) => {
+            e.added.forEach(options => {
+                if (options.className) {
+                    this.notebookEditor.deltaCellContainerClassNames(this.viewCell.id, [options.className], []);
+                }
+            });
+            e.removed.forEach(options => {
+                if (options.className) {
+                    this.notebookEditor.deltaCellContainerClassNames(this.viewCell.id, [], [options.className]);
+                }
+            });
+        }));
+        this.viewCell.getCellDecorations().forEach(options => {
+            if (options.className) {
+                this.notebookEditor.deltaCellContainerClassNames(this.viewCell.id, [options.className], []);
+            }
+        });
+    }
+    dispose() {
+        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();
+        }
+        this.viewCell.detachTextEditor();
+        super.dispose();
+    }
+    updateFoldingIconShowClass() {
+        const showFoldingIcon = this.notebookEditor.notebookOptions.getDisplayOptions().showFoldingControls;
+        this.templateData.foldingIndicator.classList.remove('mouseover', 'always');
+        this.templateData.foldingIndicator.classList.add(showFoldingIcon);
+    }
+    viewUpdate() {
+        if (this.viewCell.isInputCollapsed) {
+            this.viewUpdateCollapsed();
+        }
+        else if (this.viewCell.getEditState() === CellEditState.Editing) {
+            this.viewUpdateEditing();
+        }
+        else {
+            this.viewUpdatePreview();
+        }
+    }
+    viewUpdateCollapsed() {
+        dom.show(this.templateData.cellInputCollapsedContainer);
+        dom.hide(this.editorPart);
+        this.templateData.cellInputCollapsedContainer.innerText = '';
+        const markdownIcon = dom.append(this.templateData.cellInputCollapsedContainer, dom.$('span'));
+        markdownIcon.classList.add(...ThemeIcon.asClassNameArray(Codicon.markdown));
+        const element = dom.$('div');
+        element.classList.add('cell-collapse-preview');
+        const richEditorText = this.getRichText(this.viewCell.textBuffer, this.viewCell.language);
+        dom.safeInnerHtml(element, richEditorText);
+        this.templateData.cellInputCollapsedContainer.appendChild(element);
+        const expandIcon = dom.append(element, dom.$('span.expandInputIcon'));
+        expandIcon.classList.add(...ThemeIcon.asClassNameArray(Codicon.more));
+        const keybinding = this.keybindingService.lookupKeybinding(EXPAND_CELL_INPUT_COMMAND_ID);
+        if (keybinding) {
+            element.title = ( localizeWithPath(
+                'vs/workbench/contrib/notebook/browser/view/cellParts/markupCell',
+                'cellExpandInputButtonLabelWithDoubleClick',
+                "Double-click to expand cell input ({0})",
+                keybinding.getLabel()
+            ));
+            expandIcon.title = ( localizeWithPath(
+                'vs/workbench/contrib/notebook/browser/view/cellParts/markupCell',
+                'cellExpandInputButtonLabel',
+                "Expand Cell Input ({0})",
+                keybinding.getLabel()
+            ));
+        }
+        this.markdownAccessibilityContainer.ariaHidden = 'true';
+        this.templateData.container.classList.toggle('input-collapsed', true);
+        this.viewCell.renderedMarkdownHeight = 0;
+        this.viewCell.layoutChange({});
+    }
+    getRichText(buffer, language) {
+        return tokenizeToStringSync(this.languageService, buffer.getLineContent(1), language);
+    }
+    viewUpdateEditing() {
+        let editorHeight;
+        dom.show(this.editorPart);
+        this.markdownAccessibilityContainer.ariaHidden = 'true';
+        dom.hide(this.templateData.cellInputCollapsedContainer);
+        this.notebookEditor.hideMarkupPreviews([this.viewCell]);
+        this.templateData.container.classList.toggle('input-collapsed', false);
+        this.templateData.container.classList.toggle('markdown-cell-edit-mode', true);
+        if (this.editor && this.editor.hasModel()) {
+            editorHeight = this.editor.getContentHeight();
+            this.viewCell.attachTextEditor(this.editor);
+            this.focusEditorIfNeeded();
+            this.bindEditorListeners(this.editor);
+            this.editor.layout({
+                width: this.viewCell.layoutInfo.editorWidth,
+                height: editorHeight
+            });
+        }
+        else {
+            this.editorDisposables.clear();
+            const width = this.notebookEditor.notebookOptions.computeMarkdownCellEditorWidth(this.notebookEditor.getLayoutInfo().width);
+            const lineNum = this.viewCell.lineCount;
+            const lineHeight = this.viewCell.layoutInfo.fontInfo?.lineHeight || 17;
+            const editorPadding = this.notebookEditor.notebookOptions.computeEditorPadding(this.viewCell.internalMetadata, this.viewCell.uri);
+            editorHeight = Math.max(lineNum, 1) * lineHeight + editorPadding.top + editorPadding.bottom;
+            this.templateData.editorContainer.innerText = '';
+            const editorContextKeyService = this.contextKeyService.createScoped(this.templateData.editorPart);
+            EditorContextKeys.inCompositeEditor.bindTo(editorContextKeyService).set(true);
+            const editorInstaService = this.instantiationService.createChild(( new ServiceCollection([IContextKeyService, editorContextKeyService])));
+            this.editorDisposables.add(editorContextKeyService);
+            this.editor = this.editorDisposables.add(editorInstaService.createInstance(CodeEditorWidget, this.templateData.editorContainer, {
+                ...this.editorOptions,
+                dimension: {
+                    width: width,
+                    height: editorHeight
+                },
+            }, {
+                contributions: this.notebookEditor.creationOptions.cellEditorContributions
+            }));
+            this.templateData.currentEditor = this.editor;
+            this.editorDisposables.add(this.editor.onDidBlurEditorWidget(() => {
+                if (this.editor) {
+                    WordHighlighterContribution.get(this.editor)?.stopHighlighting();
+                }
+            }));
+            this.editorDisposables.add(this.editor.onDidFocusEditorWidget(() => {
+                if (this.editor) {
+                    WordHighlighterContribution.get(this.editor)?.restoreViewState(true);
+                }
+            }));
+            const cts = ( new CancellationTokenSource());
+            this.editorDisposables.add({ dispose() { cts.dispose(true); } });
+            raceCancellation(this.viewCell.resolveTextModel(), cts.token).then(model => {
+                if (!model) {
+                    return;
+                }
+                this.editor.setModel(model);
+                const realContentHeight = this.editor.getContentHeight();
+                if (realContentHeight !== editorHeight) {
+                    this.editor.layout({
+                        width: width,
+                        height: realContentHeight
+                    });
+                    editorHeight = realContentHeight;
+                }
+                this.viewCell.attachTextEditor(this.editor);
+                if (this.viewCell.getEditState() === CellEditState.Editing) {
+                    this.focusEditorIfNeeded();
+                }
+                this.bindEditorListeners(this.editor);
+                this.viewCell.editorHeight = editorHeight;
+            });
+        }
+        this.viewCell.editorHeight = editorHeight;
+        this.focusEditorIfNeeded();
+        this.renderedEditors.set(this.viewCell, this.editor);
+    }
+    viewUpdatePreview() {
+        this.viewCell.detachTextEditor();
+        dom.hide(this.editorPart);
+        dom.hide(this.templateData.cellInputCollapsedContainer);
+        this.markdownAccessibilityContainer.ariaHidden = 'false';
+        this.templateData.container.classList.toggle('input-collapsed', false);
+        this.templateData.container.classList.toggle('markdown-cell-edit-mode', false);
+        this.renderedEditors.delete(this.viewCell);
+        this.markdownAccessibilityContainer.innerText = '';
+        if (this.viewCell.renderedHtml) {
+            if (this.accessibilityService.isScreenReaderOptimized()) {
+                dom.safeInnerHtml(this.markdownAccessibilityContainer, this.viewCell.renderedHtml);
+            }
+            else {
+                dom.clearNode(this.markdownAccessibilityContainer);
+            }
+        }
+        this.notebookEditor.createMarkupPreview(this.viewCell);
+    }
+    focusEditorIfNeeded() {
+        if (this.viewCell.focusMode === CellFocusMode.Editor &&
+            (this.notebookEditor.hasEditorFocus() || this.notebookEditor.getDomNode().ownerDocument.activeElement === this.notebookEditor.getDomNode().ownerDocument.body)) {
+            if (!this.editor) {
+                return;
+            }
+            this.editor.focus();
+            const primarySelection = this.editor.getSelection();
+            if (!primarySelection) {
+                return;
+            }
+            this.notebookEditor.revealRangeInViewAsync(this.viewCell, primarySelection);
+        }
+    }
+    layoutEditor(dimension) {
+        this.editor?.layout(dimension);
+    }
+    onCellEditorWidthChange() {
+        const realContentHeight = this.editor.getContentHeight();
+        this.layoutEditor({
+            width: this.viewCell.layoutInfo.editorWidth,
+            height: realContentHeight
+        });
+    }
+    relayoutCell() {
+        this.notebookEditor.layoutNotebookCell(this.viewCell, this.viewCell.layoutInfo.totalHeight);
+        this.layoutFoldingIndicator();
+    }
+    updateEditorOptions(newValue) {
+        this.editorOptions = newValue;
+        this.editor?.updateOptions(this.editorOptions);
+    }
+    layoutFoldingIndicator() {
+        switch (this.foldingState) {
+            case 0 :
+                this.templateData.foldingIndicator.style.display = 'none';
+                this.templateData.foldingIndicator.innerText = '';
+                break;
+            case 2 :
+                this.templateData.foldingIndicator.style.display = '';
+                dom.reset(this.templateData.foldingIndicator, renderIcon(collapsedIcon));
+                break;
+            case 1 :
+                this.templateData.foldingIndicator.style.display = '';
+                dom.reset(this.templateData.foldingIndicator, renderIcon(expandedIcon));
+                break;
+        }
+    }
+    bindEditorListeners(editor) {
+        this.localDisposables.clear();
+        this.focusSwitchDisposable.clear();
+        this.localDisposables.add(editor.onDidContentSizeChange(e => {
+            if (e.contentHeightChanged) {
+                this.onCellEditorHeightChange(editor, e.contentHeight);
+            }
+        }));
+        this.localDisposables.add(editor.onDidChangeCursorSelection((e) => {
+            if (e.source === 'restoreState') {
+                return;
+            }
+            const selections = editor.getSelections();
+            if (selections?.length) {
+                const contentHeight = editor.getContentHeight();
+                const layoutContentHeight = this.viewCell.layoutInfo.editorHeight;
+                if (contentHeight !== layoutContentHeight) {
+                    this.onCellEditorHeightChange(editor, contentHeight);
+                }
+                const lastSelection = selections[selections.length - 1];
+                this.notebookEditor.revealRangeInViewAsync(this.viewCell, lastSelection);
+            }
+        }));
+        const updateFocusMode = () => this.viewCell.focusMode = editor.hasWidgetFocus() ? CellFocusMode.Editor : CellFocusMode.Container;
+        this.localDisposables.add(editor.onDidFocusEditorWidget(() => {
+            updateFocusMode();
+        }));
+        this.localDisposables.add(editor.onDidBlurEditorWidget(() => {
+            if (this.templateData.container.ownerDocument.activeElement?.contains(this.templateData.container)) {
+                this.focusSwitchDisposable.value = disposableTimeout(() => updateFocusMode(), 300);
+            }
+            else {
+                updateFocusMode();
+            }
+        }));
+        updateFocusMode();
+    }
+    onCellEditorHeightChange(editor, newHeight) {
+        const viewLayout = editor.getLayoutInfo();
+        this.viewCell.editorHeight = newHeight;
+        editor.layout({
+            width: viewLayout.width,
+            height: newHeight
+        });
+    }
+};
+MarkupCell = ( __decorate([
+    ( __param(4, IAccessibilityService)),
+    ( __param(5, IContextKeyService)),
+    ( __param(6, IInstantiationService)),
+    ( __param(7, ILanguageService)),
+    ( __param(8, IConfigurationService)),
+    ( __param(9, IKeybindingService))
+], MarkupCell));
+export { MarkupCell };

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

@@ -0,0 +1,54 @@
+import { CellFocusMode } from '../notebookBrowser.js';
+import { NotebookSetting, CellKind, NotebookCellExecutionState } from '../../common/notebookCommon.js';
+class NotebookCellAnchor {
+    constructor(notebookExecutionStateService, configurationService, scrollEvent) {
+        this.notebookExecutionStateService = notebookExecutionStateService;
+        this.configurationService = configurationService;
+        this.scrollEvent = scrollEvent;
+        this.stopAnchoring = false;
+    }
+    shouldAnchor(cellListView, focusedIndex, heightDelta, executingCellUri) {
+        if (cellListView.element(focusedIndex).focusMode === CellFocusMode.Editor) {
+            return true;
+        }
+        if (this.stopAnchoring) {
+            return false;
+        }
+        const newFocusBottom = cellListView.elementTop(focusedIndex) + cellListView.elementHeight(focusedIndex) + heightDelta;
+        const viewBottom = cellListView.renderHeight + cellListView.getScrollTop();
+        const focusStillVisible = viewBottom > newFocusBottom;
+        const anchorFocusedSetting = this.configurationService.getValue(NotebookSetting.anchorToFocusedCell);
+        const allowScrolling = this.configurationService.getValue(NotebookSetting.scrollToRevealCell) !== 'none';
+        const growing = heightDelta > 0;
+        const autoAnchor = allowScrolling && growing && !focusStillVisible && anchorFocusedSetting !== 'off';
+        if (autoAnchor || anchorFocusedSetting === 'on') {
+            this.watchAchorDuringExecution(executingCellUri);
+            return true;
+        }
+        return false;
+    }
+    watchAchorDuringExecution(executingCell) {
+        if (!this.executionWatcher && executingCell.cellKind === CellKind.Code) {
+            const executionState = this.notebookExecutionStateService.getCellExecution(executingCell.uri);
+            if (executionState && executionState.state === NotebookCellExecutionState.Executing) {
+                this.executionWatcher = executingCell.onDidStopExecution(() => {
+                    this.executionWatcher?.dispose();
+                    this.executionWatcher = undefined;
+                    this.scrollWatcher?.dispose();
+                    this.stopAnchoring = false;
+                });
+                this.scrollWatcher = this.scrollEvent((scrollEvent) => {
+                    if (scrollEvent.scrollTop < scrollEvent.oldScrollTop) {
+                        this.stopAnchoring = true;
+                        this.scrollWatcher?.dispose();
+                    }
+                });
+            }
+        }
+    }
+    dispose() {
+        this.executionWatcher?.dispose();
+        this.scrollWatcher?.dispose();
+    }
+}
+export { NotebookCellAnchor };