@codingame/monaco-vscode-api 2.2.2 → 3.1.0

package/vscode/src/vs/workbench/contrib/notebook/browser/controller/notebookIndentationActions.js

@@ -0,0 +1,234 @@
+import { localizeWithPath } from '../../../../../nls.js';
+import { DisposableStore } from '../../../../../base/common/lifecycle.js';
+import { IBulkEditService, ResourceTextEdit } from '../../../../../editor/browser/services/bulkEditService.js';
+import { Range } from '../../../../../editor/common/core/range.js';
+import { ITextModelService } from '../../../../../editor/common/services/resolverService.js';
+import { registerAction2, Action2 } from '../../../../../platform/actions/common/actions.js';
+import { IConfigurationService } from '../../../../../platform/configuration/common/configuration.js';
+import { ILogService } from '../../../../../platform/log/common/log.js';
+import { IQuickInputService } from '../../../../../platform/quickinput/common/quickInput.js';
+import { INotebookEditorService } from '../services/notebookEditorService.js';
+import { NotebookSetting } from '../../common/notebookCommon.js';
+import { isNotebookEditorInput } from '../../common/notebookEditorInput.js';
+import { IEditorService } from '../../../../services/editor/common/editorService.js';
+class NotebookIndentUsingTabs extends Action2 {
+    static { this.ID = 'notebook.action.indentUsingTabs'; }
+    constructor() {
+        super({
+            id: NotebookIndentUsingTabs.ID,
+            title: ( localizeWithPath(
+                'vs/workbench/contrib/notebook/browser/controller/notebookIndentationActions',
+                'indentUsingTabs',
+                "Indent Using Tabs"
+            )),
+            precondition: undefined,
+        });
+    }
+    run(accessor, ...args) {
+        changeNotebookIndentation(accessor, false, false);
+    }
+}
+class NotebookIndentUsingSpaces extends Action2 {
+    static { this.ID = 'notebook.action.indentUsingSpaces'; }
+    constructor() {
+        super({
+            id: NotebookIndentUsingSpaces.ID,
+            title: ( localizeWithPath(
+                'vs/workbench/contrib/notebook/browser/controller/notebookIndentationActions',
+                'indentUsingSpaces',
+                "Indent Using Spaces"
+            )),
+            precondition: undefined,
+        });
+    }
+    run(accessor, ...args) {
+        changeNotebookIndentation(accessor, true, false);
+    }
+}
+class NotebookChangeTabDisplaySize extends Action2 {
+    static { this.ID = 'notebook.action.changeTabDisplaySize'; }
+    constructor() {
+        super({
+            id: NotebookChangeTabDisplaySize.ID,
+            title: ( localizeWithPath(
+                'vs/workbench/contrib/notebook/browser/controller/notebookIndentationActions',
+                'changeTabDisplaySize',
+                "Change Tab Display Size"
+            )),
+            precondition: undefined,
+        });
+    }
+    run(accessor, ...args) {
+        changeNotebookIndentation(accessor, true, true);
+    }
+}
+class NotebookIndentationToSpacesAction extends Action2 {
+    static { this.ID = 'notebook.action.convertIndentationToSpaces'; }
+    constructor() {
+        super({
+            id: NotebookIndentationToSpacesAction.ID,
+            title: ( localizeWithPath(
+                'vs/workbench/contrib/notebook/browser/controller/notebookIndentationActions',
+                'convertIndentationToSpaces',
+                "Convert Indentation to Spaces"
+            )),
+            precondition: undefined,
+        });
+    }
+    run(accessor, ...args) {
+        convertNotebookIndentation(accessor, true);
+    }
+}
+class NotebookIndentationToTabsAction extends Action2 {
+    static { this.ID = 'notebook.action.convertIndentationToTabs'; }
+    constructor() {
+        super({
+            id: NotebookIndentationToTabsAction.ID,
+            title: ( localizeWithPath(
+                'vs/workbench/contrib/notebook/browser/controller/notebookIndentationActions',
+                'convertIndentationToTabs',
+                "Convert Indentation to Tabs"
+            )),
+            precondition: undefined,
+        });
+    }
+    run(accessor, ...args) {
+        convertNotebookIndentation(accessor, false);
+    }
+}
+function changeNotebookIndentation(accessor, insertSpaces, displaySizeOnly) {
+    const editorService = accessor.get(IEditorService);
+    const configurationService = accessor.get(IConfigurationService);
+    const notebookEditorService = accessor.get(INotebookEditorService);
+    const quickInputService = accessor.get(IQuickInputService);
+    const activeInput = editorService.activeEditorPane?.input;
+    const isNotebook = isNotebookEditorInput(activeInput);
+    if (!isNotebook) {
+        return;
+    }
+    const notebookEditor = notebookEditorService.retrieveExistingWidgetFromURI(activeInput.resource)?.value;
+    if (!notebookEditor) {
+        return;
+    }
+    const picks = ( [1, 2, 3, 4, 5, 6, 7, 8].map(n => ({
+        id: ( n.toString()),
+        label: ( n.toString()),
+    })));
+    const initialConfig = configurationService.getValue(NotebookSetting.cellEditorOptionsCustomizations);
+    const initialInsertSpaces = initialConfig['editor.insertSpaces'];
+    delete initialConfig['editor.indentSize'];
+    delete initialConfig['editor.tabSize'];
+    delete initialConfig['editor.insertSpaces'];
+    setTimeout(() => {
+        quickInputService.pick(picks, { placeHolder: ( localizeWithPath(
+            'vs/workbench/contrib/notebook/browser/controller/notebookIndentationActions',
+            { key: 'selectTabWidth', comment: ['Tab corresponds to the tab key'] },
+            "Select Tab Size for Current File"
+        )) }).then(pick => {
+            if (pick) {
+                const pickedVal = parseInt(pick.label, 10);
+                if (displaySizeOnly) {
+                    configurationService.updateValue(NotebookSetting.cellEditorOptionsCustomizations, {
+                        ...initialConfig,
+                        'editor.tabSize': pickedVal,
+                        'editor.indentSize': pickedVal,
+                        'editor.insertSpaces': initialInsertSpaces
+                    });
+                }
+                else {
+                    configurationService.updateValue(NotebookSetting.cellEditorOptionsCustomizations, {
+                        ...initialConfig,
+                        'editor.tabSize': pickedVal,
+                        'editor.indentSize': pickedVal,
+                        'editor.insertSpaces': insertSpaces
+                    });
+                }
+            }
+        });
+    }, 50 );
+}
+function convertNotebookIndentation(accessor, tabsToSpaces) {
+    const editorService = accessor.get(IEditorService);
+    const configurationService = accessor.get(IConfigurationService);
+    const logService = accessor.get(ILogService);
+    const textModelService = accessor.get(ITextModelService);
+    const notebookEditorService = accessor.get(INotebookEditorService);
+    const bulkEditService = accessor.get(IBulkEditService);
+    const activeInput = editorService.activeEditorPane?.input;
+    const isNotebook = isNotebookEditorInput(activeInput);
+    if (!isNotebook) {
+        return;
+    }
+    const notebookTextModel = notebookEditorService.retrieveExistingWidgetFromURI(activeInput.resource)?.value?.textModel;
+    if (!notebookTextModel) {
+        return;
+    }
+    const disposable = ( new DisposableStore());
+    try {
+        Promise.all(( notebookTextModel.cells.map(async (cell) => {
+            const ref = await textModelService.createModelReference(cell.uri);
+            disposable.add(ref);
+            const textEditorModel = ref.object.textEditorModel;
+            const modelOpts = cell.textModel?.getOptions();
+            if (!modelOpts) {
+                return;
+            }
+            const edits = getIndentationEditOperations(textEditorModel, modelOpts.tabSize, tabsToSpaces);
+            bulkEditService.apply(edits, { label: ( localizeWithPath(
+                'vs/workbench/contrib/notebook/browser/controller/notebookIndentationActions',
+                'convertIndentation',
+                "Convert Indentation"
+            )), code: 'undoredo.convertIndentation', });
+        }))).then(() => {
+            const initialConfig = configurationService.getValue(NotebookSetting.cellEditorOptionsCustomizations);
+            const initialIndentSize = initialConfig['editor.indentSize'];
+            const initialTabSize = initialConfig['editor.tabSize'];
+            delete initialConfig['editor.indentSize'];
+            delete initialConfig['editor.tabSize'];
+            delete initialConfig['editor.insertSpaces'];
+            configurationService.updateValue(NotebookSetting.cellEditorOptionsCustomizations, {
+                ...initialConfig,
+                'editor.tabSize': initialTabSize,
+                'editor.indentSize': initialIndentSize,
+                'editor.insertSpaces': tabsToSpaces
+            });
+            disposable.dispose();
+        });
+    }
+    catch {
+        logService.error('Failed to convert indentation to spaces for notebook cells.');
+    }
+}
+function getIndentationEditOperations(model, tabSize, tabsToSpaces) {
+    if (model.getLineCount() === 1 && model.getLineMaxColumn(1) === 1) {
+        return [];
+    }
+    let spaces = '';
+    for (let i = 0; i < tabSize; i++) {
+        spaces += ' ';
+    }
+    const spacesRegExp = ( new RegExp(spaces, 'gi'));
+    const edits = [];
+    for (let lineNumber = 1, lineCount = model.getLineCount(); lineNumber <= lineCount; lineNumber++) {
+        let lastIndentationColumn = model.getLineFirstNonWhitespaceColumn(lineNumber);
+        if (lastIndentationColumn === 0) {
+            lastIndentationColumn = model.getLineMaxColumn(lineNumber);
+        }
+        if (lastIndentationColumn === 1) {
+            continue;
+        }
+        const originalIndentationRange = ( new Range(lineNumber, 1, lineNumber, lastIndentationColumn));
+        const originalIndentation = model.getValueInRange(originalIndentationRange);
+        const newIndentation = (tabsToSpaces
+            ? originalIndentation.replace(/\t/ig, spaces)
+            : originalIndentation.replace(spacesRegExp, '\t'));
+        edits.push(( new ResourceTextEdit(model.uri, { range: originalIndentationRange, text: newIndentation })));
+    }
+    return edits;
+}
+registerAction2(NotebookIndentUsingSpaces);
+registerAction2(NotebookIndentUsingTabs);
+registerAction2(NotebookChangeTabDisplaySize);
+registerAction2(NotebookIndentationToSpacesAction);
+registerAction2(NotebookIndentationToTabsAction);
+export { NotebookChangeTabDisplaySize, NotebookIndentUsingSpaces, NotebookIndentUsingTabs, NotebookIndentationToSpacesAction, NotebookIndentationToTabsAction };

package/vscode/src/vs/workbench/contrib/notebook/browser/notebookEditor.js

@@ -1,6 +1,5 @@
 import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
 import { append, $, isAncestorOfActiveElement, getWindowById, setParentFlowTo } from '../../../../base/browser/dom.js';
-import { mainWindow } from '../../../../base/browser/window.js';
 import { toAction } from '../../../../base/common/actions.js';
 import { timeout } from '../../../../base/common/async.js';
 import { Emitter } from '../../../../base/common/event.js';
@@ -155,7 +154,7 @@ let NotebookEditor = class NotebookEditor extends EditorPane {
             this._inputListener.value = input.onDidChangeCapabilities(() => this._onDidChangeInputCapabilities(input));
             this._widgetDisposableStore.clear();
             this._widget.value?.onWillHide();
-            this._widget = this._instantiationService.invokeFunction(this._notebookWidgetService.retrieveWidget, group, input, undefined, this._pagePosition?.dimension, getWindowById(group.windowId)?.window ?? mainWindow);
+            this._widget = this._instantiationService.invokeFunction(this._notebookWidgetService.retrieveWidget, group, input, undefined, this._pagePosition?.dimension, getWindowById(group.windowId, true).window);
             if (this._rootElement && this._widget.value.getDomNode()) {
                 this._rootElement.setAttribute('aria-flowto', this._widget.value.getDomNode().id || '');
                 setParentFlowTo(this._widget.value.getDomNode(), this._rootElement);

package/vscode/src/vs/workbench/contrib/notebook/browser/notebookEditorWidget.js

@@ -13,8 +13,7 @@ import './media/notebookCellOutput.css.js';
 import './media/notebookEditorStickyScroll.css.js';
 import './media/notebookKernelActionViewItem.css.js';
 import './media/notebookOutline.css.js';
-import { PixelRatio } from '../../../../base/browser/browser.js';
-import { append, createStyleSheet, addStandardDisposableGenericMouseDownListener, addStandardDisposableGenericMouseUpListener, trackFocus, scheduleAtNextAnimationFrame, getWindow, runWhenWindowIdle, size, isAncestorOfActiveElement, $ as $$1 } from '../../../../base/browser/dom.js';
+import { getWindow, append, createStyleSheet, addStandardDisposableGenericMouseDownListener, addStandardDisposableGenericMouseUpListener, trackFocus, scheduleAtNextAnimationFrame, runWhenWindowIdle, size, isAncestorOfActiveElement, $ as $$1 } from '../../../../base/browser/dom.js';
 import { mainWindow } from '../../../../base/browser/window.js';
 import { SequencerByKey, DeferredPromise } from '../../../../base/common/async.js';
 import { Color, RGBA } from '../../../../base/common/color.js';
@@ -81,6 +80,8 @@ import { CopyPasteController } from '../../../../editor/contrib/dropOrPasteInto/
 import { NotebookStickyScroll } from './viewParts/notebookEditorStickyScroll.js';
 import { NotebookCellOutlineProvider } from './viewModel/notebookOutlineProvider.js';
 import { IKeybindingService } from '../../../../platform/keybinding/common/keybinding.js';
+import { PixelRatio } from '../../../../base/browser/pixelRatio.js';
+import { ICodeEditorService } from '../../../../editor/browser/services/codeEditorService.js';
 const $ = $$1;
 function getDefaultNotebookCreationOptions() {
     const skipContributions = [
@@ -144,7 +145,7 @@ let NotebookEditorWidget = class NotebookEditorWidget extends Disposable {
     get notebookOptions() {
         return this._notebookOptions;
     }
-    constructor(creationOptions, dimension, instantiationService, editorGroupsService, notebookRendererMessaging, notebookEditorService, notebookKernelService, _notebookService, configurationService, contextKeyService, layoutService, contextMenuService, telemetryService, notebookExecutionService, notebookExecutionStateService, editorProgressService, logService, keybindingService) {
+    constructor(creationOptions, dimension, instantiationService, editorGroupsService, notebookRendererMessaging, notebookEditorService, notebookKernelService, _notebookService, configurationService, contextKeyService, layoutService, contextMenuService, telemetryService, notebookExecutionService, notebookExecutionStateService, editorProgressService, logService, keybindingService, codeEditorService) {
         super();
         this.creationOptions = creationOptions;
         this.notebookRendererMessaging = notebookRendererMessaging;
@@ -177,6 +178,8 @@ let NotebookEditorWidget = class NotebookEditorWidget extends Disposable {
         this.onDidScroll = this._onDidScroll.event;
         this._onDidChangeActiveCell = this._register(( new Emitter()));
         this.onDidChangeActiveCell = this._onDidChangeActiveCell.event;
+        this._onDidChangeFocus = this._register(( new Emitter()));
+        this.onDidChangeFocus = this._onDidChangeFocus.event;
         this._onDidChangeSelection = this._register(( new Emitter()));
         this.onDidChangeSelection = this._onDidChangeSelection.event;
         this._onDidChangeVisibleRanges = this._register(( new Emitter()));
@@ -227,14 +230,25 @@ let NotebookEditorWidget = class NotebookEditorWidget extends Disposable {
         this._dimension = dimension;
         this.isEmbedded = creationOptions.isEmbedded ?? false;
         this._readOnly = creationOptions.isReadOnly ?? false;
-        this._notebookOptions = creationOptions.options ?? ( new NotebookOptions(this.configurationService, notebookExecutionStateService, this._readOnly));
+        this._notebookOptions = creationOptions.options ?? ( new NotebookOptions(
+            this.creationOptions?.codeWindow ?? mainWindow,
+            this.configurationService,
+            notebookExecutionStateService,
+            codeEditorService,
+            this._readOnly
+        ));
         this._register(this._notebookOptions);
-        this._viewContext = ( new ViewContext(this._notebookOptions, ( new NotebookEventDispatcher()), language => this.getBaseCellEditorOptions(language)));
+        const eventDispatcher = this._register(( new NotebookEventDispatcher()));
+        this._viewContext = ( new ViewContext(
+            this._notebookOptions,
+            eventDispatcher,
+            language => this.getBaseCellEditorOptions(language)
+        ));
         this._register(this._viewContext.eventDispatcher.onDidChangeCellState(e => {
             this._onDidChangeCellState.fire(e);
         }));
         this._overlayContainer = document.createElement('div');
-        this.scopedContextKeyService = contextKeyService.createScoped(this._overlayContainer);
+        this.scopedContextKeyService = this._register(contextKeyService.createScoped(this._overlayContainer));
         this.instantiationService = instantiationService.createChild(( new ServiceCollection([IContextKeyService, this.scopedContextKeyService])));
         this._register(_notebookService.onDidChangeOutputRenderers(() => {
             this._updateOutputRenderers();
@@ -445,7 +459,8 @@ let NotebookEditorWidget = class NotebookEditorWidget extends Disposable {
     }
     _generateFontInfo() {
         const editorOptions = this.configurationService.getValue('editor');
-        this._fontInfo = FontMeasurements.readFontInfo(BareFontInfo.createFromRawSettings(editorOptions, PixelRatio.value));
+        const targetWindow = getWindow(this.getDomNode());
+        this._fontInfo = FontMeasurements.readFontInfo(targetWindow, BareFontInfo.createFromRawSettings(editorOptions, PixelRatio.getInstance(targetWindow).value));
     }
     _createBody(parent) {
         this._notebookTopToolbarContainer = document.createElement('div');
@@ -579,11 +594,11 @@ let NotebookEditorWidget = class NotebookEditorWidget extends Disposable {
         }
         if (insertToolbarPosition === 'betweenCells' || insertToolbarPosition === 'both') {
             styleSheets.push(`.monaco-workbench .notebookOverlay > .cell-list-container > .monaco-list > .monaco-scrollable-element > .monaco-list-rows > .monaco-list-row .cell-bottom-toolbar-container { display: flex; }`);
-            styleSheets.push(`.monaco-workbench .notebookOverlay > .cell-list-container > .monaco-list > .monaco-scrollable-element > .monaco-list-rows > .cell-list-top-cell-toolbar-container { display: flex; }`);
+            styleSheets.push(`.monaco-workbench .notebookOverlay > .cell-list-container > .monaco-list > .monaco-scrollable-element > .monaco-list-rows > .view-zones .cell-list-top-cell-toolbar-container { display: flex; }`);
         }
         else {
             styleSheets.push(`.monaco-workbench .notebookOverlay > .cell-list-container > .monaco-list > .monaco-scrollable-element > .monaco-list-rows > .monaco-list-row .cell-bottom-toolbar-container { display: none; }`);
-            styleSheets.push(`.monaco-workbench .notebookOverlay > .cell-list-container > .monaco-list > .monaco-scrollable-element > .monaco-list-rows > .cell-list-top-cell-toolbar-container { display: none; }`);
+            styleSheets.push(`.monaco-workbench .notebookOverlay > .cell-list-container > .monaco-list > .monaco-scrollable-element > .monaco-list-rows > .view-zones .cell-list-top-cell-toolbar-container { display: none; }`);
         }
         if (insertToolbarAlignment === 'left') {
             styleSheets.push(`
@@ -654,7 +669,7 @@ let NotebookEditorWidget = class NotebookEditorWidget extends Disposable {
 			}
 		`);
         styleSheets.push(`.monaco-workbench .notebookOverlay > .cell-list-container > .monaco-list > .monaco-scrollable-element > .monaco-list-rows > .monaco-list-row .cell-bottom-toolbar-container .monaco-toolbar { height: ${bottomToolbarHeight}px }`);
-        styleSheets.push(`.monaco-workbench .notebookOverlay > .cell-list-container > .monaco-list > .monaco-scrollable-element > .monaco-list-rows > .cell-list-top-cell-toolbar-container .monaco-toolbar { height: ${bottomToolbarHeight}px }`);
+        styleSheets.push(`.monaco-workbench .notebookOverlay > .cell-list-container > .monaco-list > .monaco-scrollable-element > .monaco-list-rows > .view-zones .cell-list-top-cell-toolbar-container .monaco-toolbar { height: ${bottomToolbarHeight}px }`);
         styleSheets.push(`.monaco-workbench .notebookOverlay.cell-title-toolbar-right > .cell-list-container > .monaco-list > .monaco-scrollable-element > .monaco-list-rows > .monaco-list-row .cell-title-toolbar {
 			right: ${cellRightMargin + 26}px;
 		}
@@ -690,7 +705,7 @@ let NotebookEditorWidget = class NotebookEditorWidget extends Disposable {
         renderers.forEach(renderer => {
             this._register(renderer);
         });
-        this._listDelegate = this.instantiationService.createInstance(NotebookCellListDelegate);
+        this._listDelegate = this.instantiationService.createInstance(NotebookCellListDelegate, getWindow(this.getDomNode()));
         this._register(this._listDelegate);
         const createNotebookAriaLabel = () => {
             const keybinding = this.keybindingService.lookupKeybinding("editor.action.accessibilityHelp" )?.getLabel();
@@ -725,7 +740,7 @@ let NotebookEditorWidget = class NotebookEditorWidget extends Disposable {
             multipleSelectionSupport: true,
             selectionNavigation: true,
             typeNavigationEnabled: true,
-            paddingTop: this._notebookOptions.computeTopInsertToolbarHeight(this.viewModel?.viewType),
+            paddingTop: 0,
             paddingBottom: 0,
             transformOptimization: false,
             initialSize: this._dimension,
@@ -766,7 +781,7 @@ let NotebookEditorWidget = class NotebookEditorWidget extends Disposable {
         this._listViewInfoAccessor = ( new ListViewInfoAccessor(this._list));
         this._register(this._listViewInfoAccessor);
         this._register(combinedDisposable(...renderers));
-        this._listTopCellToolbar = this._register(this.instantiationService.createInstance(ListTopCellToolbar, this, this.scopedContextKeyService, this._list.rowsContainer));
+        this._listTopCellToolbar = this._register(this.instantiationService.createInstance(ListTopCellToolbar, this, this.notebookOptions));
         this._webviewTransparentCover = append(this._list.rowsContainer, $('.webview-cover'));
         this._webviewTransparentCover.style.display = 'none';
         this._register(addStandardDisposableGenericMouseDownListener(this._overlayContainer, (e) => {
@@ -792,6 +807,7 @@ let NotebookEditorWidget = class NotebookEditorWidget extends Disposable {
         this._register(this._list.onDidChangeFocus(_e => {
             this._onDidChangeActiveEditor.fire(this);
             this._onDidChangeActiveCell.fire();
+            this._onDidChangeFocus.fire();
             this._cursorNavMode.set(false);
         }));
         this._register(this._list.onContextMenu(e => {
@@ -895,14 +911,11 @@ let NotebookEditorWidget = class NotebookEditorWidget extends Disposable {
     }
     async setModel(textModel, viewState, perf) {
         if (this.viewModel === undefined || !this.viewModel.equal(textModel)) {
-            const oldTopInsertToolbarHeight = this._notebookOptions.computeTopInsertToolbarHeight(this.viewModel?.viewType);
             const oldBottomToolbarDimensions = this._notebookOptions.computeBottomToolbarDimensions(this.viewModel?.viewType);
             this._detachModel();
             await this._attachModel(textModel, viewState, perf);
-            const newTopInsertToolbarHeight = this._notebookOptions.computeTopInsertToolbarHeight(this.viewModel?.viewType);
             const newBottomToolbarDimensions = this._notebookOptions.computeBottomToolbarDimensions(this.viewModel?.viewType);
-            if (oldTopInsertToolbarHeight !== newTopInsertToolbarHeight
-                || oldBottomToolbarDimensions.bottomToolbarGap !== newBottomToolbarDimensions.bottomToolbarGap
+            if (oldBottomToolbarDimensions.bottomToolbarGap !== newBottomToolbarDimensions.bottomToolbarGap
                 || oldBottomToolbarDimensions.bottomToolbarHeight !== newBottomToolbarDimensions.bottomToolbarHeight) {
                 this._styleElement?.remove();
                 this._createLayoutStyles();
@@ -1455,15 +1468,14 @@ let NotebookEditorWidget = class NotebookEditorWidget extends Disposable {
         this._position = position;
         const newBodyHeight = this.getBodyHeight(dimension.height) - this.getLayoutInfo().stickyHeight;
         size(this._body, dimension.width, newBodyHeight);
-        const topInserToolbarHeight = this._notebookOptions.computeTopInsertToolbarHeight(this.viewModel?.viewType);
         const newCellListHeight = newBodyHeight;
         if (this._list.getRenderHeight() < newCellListHeight) {
-            this._list.updateOptions({ paddingBottom: this._allowScrollBeyondLastLine() ? Math.max(0, (newCellListHeight - 50)) : 0, paddingTop: topInserToolbarHeight });
+            this._list.updateOptions({ paddingBottom: this._allowScrollBeyondLastLine() ? Math.max(0, (newCellListHeight - 50)) : 0, paddingTop: 0 });
             this._list.layout(newCellListHeight, dimension.width);
         }
         else {
             this._list.layout(newCellListHeight, dimension.width);
-            this._list.updateOptions({ paddingBottom: this._allowScrollBeyondLastLine() ? Math.max(0, (newCellListHeight - 50)) : 0, paddingTop: topInserToolbarHeight });
+            this._list.updateOptions({ paddingBottom: this._allowScrollBeyondLastLine() ? Math.max(0, (newCellListHeight - 50)) : 0, paddingTop: 0 });
         }
         this._overlayContainer.style.visibility = 'visible';
         this._overlayContainer.style.display = 'block';
@@ -1553,12 +1565,12 @@ let NotebookEditorWidget = class NotebookEditorWidget extends Disposable {
             }
         }
     }
-    focusContainer() {
+    focusContainer(clearSelection = false) {
         if (this._webviewFocused) {
             this._webview?.focusWebview();
         }
         else {
-            this._list.focusContainer();
+            this._list.focusContainer(clearSelection);
         }
     }
     onWillHide() {
@@ -1642,6 +1654,9 @@ let NotebookEditorWidget = class NotebookEditorWidget extends Disposable {
     getAbsoluteTopOfElement(cell) {
         return this._list.getCellViewScrollTop(cell);
     }
+    getHeightOfElement(cell) {
+        return this._list.elementHeight(cell);
+    }
     scrollToBottom() {
         this._list.scrollToBottom();
     }
@@ -1687,6 +1702,9 @@ let NotebookEditorWidget = class NotebookEditorWidget extends Disposable {
     revealCellOffsetInCenter(cell, offset) {
         return this._list.revealCellOffsetInCenter(cell, offset);
     }
+    revealOffsetInCenterIfOutsideViewport(offset) {
+        return this._list.revealOffsetInCenterIfOutsideViewport(offset);
+    }
     getViewIndexByModelIndex(index) {
         if (!this._listViewInfoAccessor) {
             return -1;
@@ -1729,6 +1747,9 @@ let NotebookEditorWidget = class NotebookEditorWidget extends Disposable {
     changeModelDecorations(callback) {
         return this.viewModel?.changeModelDecorations(callback) || null;
     }
+    changeViewZones(callback) {
+        this._list.changeViewZones(callback);
+    }
     async _loadKernelPreloads() {
         if (!this.hasModel()) {
             return;
@@ -1847,6 +1868,7 @@ let NotebookEditorWidget = class NotebookEditorWidget extends Disposable {
         if (this._isDisposed) {
             return;
         }
+        cell.focusedOutputId = undefined;
         if (focusItem === 'editor') {
             this.focusElement(cell);
             this._list.focusView();
@@ -1889,6 +1911,7 @@ let NotebookEditorWidget = class NotebookEditorWidget extends Disposable {
             this._webview.focusOutput(focusElementId, options?.altOutputId, options?.outputWebviewFocused || this._webviewFocused);
             cell.updateEditState(CellEditState.Preview, 'focusNotebookCell');
             cell.focusMode = CellFocusMode.Output;
+            cell.focusedOutputId = options?.outputId;
             if (!options?.skipReveal) {
                 this.revealInCenterIfOutsideViewport(cell);
             }
@@ -2220,7 +2243,7 @@ let NotebookEditorWidget = class NotebookEditorWidget extends Disposable {
     }
     async updateOutput(cell, output, offset) {
         this._insetModifyQueueByOutputId.queue(output.source.model.outputId, async () => {
-            if (this._isDisposed || !this._webview) {
+            if (this._isDisposed || !this._webview || cell.isOutputCollapsed) {
                 return;
             }
             if (!this._webview.isResolved()) {
@@ -2499,7 +2522,8 @@ NotebookEditorWidget = ( __decorate([
     ( __param(14, INotebookExecutionStateService)),
     ( __param(15, IEditorProgressService)),
     ( __param(16, INotebookLoggingService)),
-    ( __param(17, IKeybindingService))
+    ( __param(17, IKeybindingService)),
+    ( __param(18, ICodeEditorService))
 ], NotebookEditorWidget));
 registerZIndex(ZIndex.Base, 5, 'notebook-progress-bar');
 registerZIndex(ZIndex.Base, 10, 'notebook-list-insertion-indicator');

package/vscode/src/vs/workbench/contrib/notebook/browser/notebookOptions.js

@@ -1,20 +1,10 @@
-import { PixelRatio } from '../../../../base/browser/browser.js';
+import { PixelRatio } from '../../../../base/browser/pixelRatio.js';
 import { Emitter } from '../../../../base/common/event.js';
 import { Disposable } from '../../../../base/common/lifecycle.js';
 import { FontMeasurements } from '../../../../editor/browser/config/fontMeasurements.js';
 import { BareFontInfo } from '../../../../editor/common/config/fontInfo.js';
 import { NotebookSetting } from '../common/notebookCommon.js';
 const SCROLLABLE_ELEMENT_PADDING_TOP = 18;
-let EDITOR_TOP_PADDING = 12;
-const editorTopPaddingChangeEmitter = ( new Emitter());
-const EditorTopPaddingChangeEvent = editorTopPaddingChangeEmitter.event;
-function updateEditorTopPadding(top) {
-    EDITOR_TOP_PADDING = top;
-    editorTopPaddingChangeEmitter.fire();
-}
-function getEditorTopPadding() {
-    return EDITOR_TOP_PADDING;
-}
 const OutputInnerContainerTopPadding = 4;
 const defaultConfigConstants = ( Object.freeze({
     codeCellLeftMargin: 28,
@@ -35,14 +25,17 @@ const compactConfigConstants = ( Object.freeze({
     focusIndicatorLeftMargin: 4
 }));
 class NotebookOptions extends Disposable {
-    constructor(configurationService, notebookExecutionStateService, isReadonly, overrides) {
+    constructor(targetWindow, configurationService, notebookExecutionStateService, codeEditorService, isReadonly, overrides) {
         super();
+        this.targetWindow = targetWindow;
         this.configurationService = configurationService;
         this.notebookExecutionStateService = notebookExecutionStateService;
+        this.codeEditorService = codeEditorService;
         this.isReadonly = isReadonly;
         this.overrides = overrides;
         this._onDidChangeOptions = this._register(( new Emitter()));
         this.onDidChangeOptions = this._onDidChangeOptions.event;
+        this._editorTopPadding = 12;
         const showCellStatusBar = this.configurationService.getValue(NotebookSetting.showCellStatusBar);
         const globalToolbar = overrides?.globalToolbar ?? this.configurationService.getValue(NotebookSetting.globalToolbar) ?? true;
         const stickyScrollEnabled = overrides?.stickyScrollEnabled ?? this.configurationService.getValue(NotebookSetting.stickyScrollEnabled) ?? false;
@@ -101,6 +94,7 @@ class NotebookOptions extends Disposable {
         const outputWordWrap = this.configurationService.getValue(NotebookSetting.outputWordWrap);
         const outputLineLimit = this.configurationService.getValue(NotebookSetting.textOutputLineLimit) ?? 30;
         const linkifyFilePaths = this.configurationService.getValue(NotebookSetting.LinkifyOutputFilePaths) ?? true;
+        const editorTopPadding = this._computeEditorTopPadding();
         this._layoutConfiguration = {
             ...(compactView ? compactConfigConstants : defaultConfigConstants),
             cellTopMargin: 6,
@@ -110,7 +104,7 @@ class NotebookOptions extends Disposable {
             cellOutputPadding: 8,
             markdownPreviewPadding: 8,
             editorToolbarHeight: 0,
-            editorTopPadding: EDITOR_TOP_PADDING,
+            editorTopPadding: editorTopPadding,
             editorBottomPadding: 4,
             editorBottomPaddingWithoutStatusBar: 12,
             collapsedIndicatorHeight: 28,
@@ -145,12 +139,6 @@ class NotebookOptions extends Disposable {
         this._register(this.configurationService.onDidChangeConfiguration(e => {
             this._updateConfiguration(e);
         }));
-        this._register(EditorTopPaddingChangeEvent(() => {
-            const configuration = Object.assign({}, this._layoutConfiguration);
-            configuration.editorTopPadding = getEditorTopPadding();
-            this._layoutConfiguration = configuration;
-            this._onDidChangeOptions.fire({ editorTopPadding: true });
-        }));
     }
     updateOptions(isReadonly) {
         if (this.isReadonly !== isReadonly) {
@@ -165,6 +153,48 @@ class NotebookOptions extends Disposable {
             });
         }
     }
+    _computeEditorTopPadding() {
+        let decorationTriggeredAdjustment = false;
+        const updateEditorTopPadding = (top) => {
+            this._editorTopPadding = top;
+            const configuration = Object.assign({}, this._layoutConfiguration);
+            configuration.editorTopPadding = this._editorTopPadding;
+            this._layoutConfiguration = configuration;
+            this._onDidChangeOptions.fire({ editorTopPadding: true });
+        };
+        const decorationCheckSet = ( new Set());
+        const onDidAddDecorationType = (e) => {
+            if (decorationTriggeredAdjustment) {
+                return;
+            }
+            if (( decorationCheckSet.has(e))) {
+                return;
+            }
+            try {
+                const options = this.codeEditorService.resolveDecorationOptions(e, true);
+                if (options.afterContentClassName || options.beforeContentClassName) {
+                    const cssRules = this.codeEditorService.resolveDecorationCSSRules(e);
+                    if (cssRules !== null) {
+                        for (let i = 0; i < cssRules.length; i++) {
+                            if ((cssRules[i].selectorText.endsWith('::after') || cssRules[i].selectorText.endsWith('::after'))
+                                && cssRules[i].cssText.indexOf('top:') > -1) {
+                                const editorOptions = this.configurationService.getValue('editor');
+                                updateEditorTopPadding(BareFontInfo.createFromRawSettings(editorOptions, PixelRatio.getInstance(this.targetWindow).value).lineHeight + 2);
+                                decorationTriggeredAdjustment = true;
+                                break;
+                            }
+                        }
+                    }
+                }
+                decorationCheckSet.add(e);
+            }
+            catch (_ex) {
+            }
+        };
+        this._register(this.codeEditorService.onDecorationTypeRegistered(onDidAddDecorationType));
+        this.codeEditorService.listDecorationTypes().forEach(onDidAddDecorationType);
+        return this._editorTopPadding;
+    }
     _migrateDeprecatedSetting(deprecatedKey, key) {
         const deprecatedSetting = this.configurationService.inspect(deprecatedKey);
         if (deprecatedSetting.application !== undefined) {
@@ -196,7 +226,7 @@ class NotebookOptions extends Disposable {
         const minimumLineHeight = 9;
         if (lineHeight === 0) {
             const editorOptions = this.configurationService.getValue('editor');
-            const fontInfo = FontMeasurements.readFontInfo(BareFontInfo.createFromRawSettings(editorOptions, PixelRatio.value));
+            const fontInfo = FontMeasurements.readFontInfo(this.targetWindow, BareFontInfo.createFromRawSettings(editorOptions, PixelRatio.getInstance(this.targetWindow).value));
             lineHeight = fontInfo.lineHeight;
         }
         else if (lineHeight < minimumLineHeight) {
@@ -510,7 +540,7 @@ class NotebookOptions extends Disposable {
     }
     computeEditorPadding(internalMetadata, cellUri) {
         return {
-            top: getEditorTopPadding(),
+            top: this._editorTopPadding,
             bottom: this.statusBarIsVisible(internalMetadata, cellUri)
                 ? this._layoutConfiguration.editorBottomPadding
                 : this._layoutConfiguration.editorBottomPaddingWithoutStatusBar
@@ -581,4 +611,4 @@ class NotebookOptions extends Disposable {
         };
     }
 }
-export { NotebookOptions, OutputInnerContainerTopPadding, getEditorTopPadding, updateEditorTopPadding };
+export { NotebookOptions, OutputInnerContainerTopPadding };