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

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

@@ -0,0 +1,564 @@
+import { PixelRatio } from 'monaco-editor/esm/vs/base/browser/browser.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { FontMeasurements } from 'monaco-editor/esm/vs/editor/browser/config/fontMeasurements.js';
+import { BareFontInfo } from 'monaco-editor/esm/vs/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,
+    cellRunGutter: 32,
+    markdownCellTopMargin: 8,
+    markdownCellBottomMargin: 8,
+    markdownCellLeftMargin: 0,
+    markdownCellGutter: 32,
+    focusIndicatorLeftMargin: 4
+}));
+const compactConfigConstants = ( Object.freeze({
+    codeCellLeftMargin: 8,
+    cellRunGutter: 36,
+    markdownCellTopMargin: 6,
+    markdownCellBottomMargin: 6,
+    markdownCellLeftMargin: 8,
+    markdownCellGutter: 36,
+    focusIndicatorLeftMargin: 4
+}));
+class NotebookOptions extends Disposable {
+    constructor(configurationService, notebookExecutionStateService, isReadonly, overrides) {
+        super();
+        this.configurationService = configurationService;
+        this.notebookExecutionStateService = notebookExecutionStateService;
+        this.isReadonly = isReadonly;
+        this.overrides = overrides;
+        this._onDidChangeOptions = this._register(( new Emitter()));
+        this.onDidChangeOptions = this._onDidChangeOptions.event;
+        const showCellStatusBar = this.configurationService.getValue(NotebookSetting.showCellStatusBar);
+        const globalToolbar = overrides?.globalToolbar ?? this.configurationService.getValue(NotebookSetting.globalToolbar) ?? true;
+        const stickyScroll = overrides?.stickyScroll ?? this.configurationService.getValue(NotebookSetting.stickyScroll) ?? false;
+        const consolidatedOutputButton = this.configurationService.getValue(NotebookSetting.consolidatedOutputButton) ?? true;
+        const consolidatedRunButton = this.configurationService.getValue(NotebookSetting.consolidatedRunButton) ?? false;
+        const dragAndDropEnabled = overrides?.dragAndDropEnabled ?? this.configurationService.getValue(NotebookSetting.dragAndDropEnabled) ?? true;
+        const cellToolbarLocation = this.configurationService.getValue(NotebookSetting.cellToolbarLocation) ?? { 'default': 'right' };
+        const cellToolbarInteraction = overrides?.cellToolbarInteraction ?? this.configurationService.getValue(NotebookSetting.cellToolbarVisibility);
+        const compactView = this.configurationService.getValue(NotebookSetting.compactView) ?? true;
+        const focusIndicator = this._computeFocusIndicatorOption();
+        const insertToolbarPosition = this._computeInsertToolbarPositionOption(this.isReadonly);
+        const insertToolbarAlignment = this._computeInsertToolbarAlignmentOption();
+        const showFoldingControls = this._computeShowFoldingControlsOption();
+        const fontSize = this.configurationService.getValue('editor.fontSize');
+        const markupFontSize = this.configurationService.getValue(NotebookSetting.markupFontSize);
+        const editorOptionsCustomizations = this.configurationService.getValue(NotebookSetting.cellEditorOptionsCustomizations);
+        const interactiveWindowCollapseCodeCells = this.configurationService.getValue(NotebookSetting.interactiveWindowCollapseCodeCells);
+        let outputLineHeightSettingValue;
+        const deprecatedOutputLineHeightSetting = this.configurationService.getValue(NotebookSetting.outputLineHeightDeprecated);
+        if (deprecatedOutputLineHeightSetting !== undefined) {
+            this._migrateDeprecatedSetting(NotebookSetting.outputLineHeightDeprecated, NotebookSetting.outputLineHeight);
+            outputLineHeightSettingValue = deprecatedOutputLineHeightSetting;
+        }
+        else {
+            outputLineHeightSettingValue = this.configurationService.getValue(NotebookSetting.outputLineHeight);
+        }
+        let outputFontSize;
+        const deprecatedOutputFontSizeSetting = this.configurationService.getValue(NotebookSetting.outputFontSizeDeprecated);
+        if (deprecatedOutputFontSizeSetting !== undefined) {
+            this._migrateDeprecatedSetting(NotebookSetting.outputFontSizeDeprecated, NotebookSetting.outputFontSize);
+            outputFontSize = deprecatedOutputFontSizeSetting;
+        }
+        else {
+            outputFontSize = this.configurationService.getValue(NotebookSetting.outputFontSize) || fontSize;
+        }
+        let outputFontFamily;
+        const deprecatedOutputFontFamilySetting = this.configurationService.getValue(NotebookSetting.outputFontFamilyDeprecated);
+        if (deprecatedOutputFontFamilySetting !== undefined) {
+            this._migrateDeprecatedSetting(NotebookSetting.outputFontFamilyDeprecated, NotebookSetting.outputFontFamily);
+            outputFontFamily = deprecatedOutputFontFamilySetting;
+        }
+        else {
+            outputFontFamily = this.configurationService.getValue(NotebookSetting.outputFontFamily);
+        }
+        let outputScrolling;
+        const deprecatedOutputScrollingSetting = this.configurationService.getValue(NotebookSetting.outputScrollingDeprecated);
+        if (deprecatedOutputScrollingSetting !== undefined) {
+            this._migrateDeprecatedSetting(NotebookSetting.outputScrollingDeprecated, NotebookSetting.outputScrolling);
+            outputScrolling = deprecatedOutputScrollingSetting;
+        }
+        else {
+            outputScrolling = this.configurationService.getValue(NotebookSetting.outputScrolling);
+        }
+        const outputLineHeight = this._computeOutputLineHeight(outputLineHeightSettingValue, outputFontSize);
+        const outputWordWrap = this.configurationService.getValue(NotebookSetting.outputWordWrap);
+        const outputLineLimit = this.configurationService.getValue(NotebookSetting.textOutputLineLimit) ?? 30;
+        this._layoutConfiguration = {
+            ...(compactView ? compactConfigConstants : defaultConfigConstants),
+            cellTopMargin: 6,
+            cellBottomMargin: 6,
+            cellRightMargin: 16,
+            cellStatusBarHeight: 22,
+            cellOutputPadding: 8,
+            markdownPreviewPadding: 8,
+            editorToolbarHeight: 0,
+            editorTopPadding: EDITOR_TOP_PADDING,
+            editorBottomPadding: 4,
+            editorBottomPaddingWithoutStatusBar: 12,
+            collapsedIndicatorHeight: 28,
+            showCellStatusBar,
+            globalToolbar,
+            stickyScroll,
+            consolidatedOutputButton,
+            consolidatedRunButton,
+            dragAndDropEnabled,
+            cellToolbarLocation,
+            cellToolbarInteraction,
+            compactView,
+            focusIndicator,
+            insertToolbarPosition,
+            insertToolbarAlignment,
+            showFoldingControls,
+            fontSize,
+            outputFontSize,
+            outputFontFamily,
+            outputLineHeight,
+            markupFontSize,
+            editorOptionsCustomizations,
+            focusIndicatorGap: 3,
+            interactiveWindowCollapseCodeCells,
+            markdownFoldHintHeight: 22,
+            outputScrolling: outputScrolling,
+            outputWordWrap: outputWordWrap,
+            outputLineLimit: outputLineLimit
+        };
+        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) {
+            this.isReadonly = isReadonly;
+            this._updateConfiguration({
+                affectsConfiguration(configuration) {
+                    return configuration === NotebookSetting.insertToolbarLocation;
+                },
+                source: 7 ,
+                affectedKeys: ( new Set([NotebookSetting.insertToolbarLocation])),
+                change: { keys: [NotebookSetting.insertToolbarLocation], overrides: [] },
+                sourceConfig: undefined
+            });
+        }
+    }
+    _migrateDeprecatedSetting(deprecatedKey, key) {
+        const deprecatedSetting = this.configurationService.inspect(deprecatedKey);
+        if (deprecatedSetting.application !== undefined) {
+            this.configurationService.updateValue(deprecatedKey, undefined, 1 );
+            this.configurationService.updateValue(key, deprecatedSetting.application.value, 1 );
+        }
+        if (deprecatedSetting.user !== undefined) {
+            this.configurationService.updateValue(deprecatedKey, undefined, 2 );
+            this.configurationService.updateValue(key, deprecatedSetting.user.value, 2 );
+        }
+        if (deprecatedSetting.userLocal !== undefined) {
+            this.configurationService.updateValue(deprecatedKey, undefined, 3 );
+            this.configurationService.updateValue(key, deprecatedSetting.userLocal.value, 3 );
+        }
+        if (deprecatedSetting.userRemote !== undefined) {
+            this.configurationService.updateValue(deprecatedKey, undefined, 4 );
+            this.configurationService.updateValue(key, deprecatedSetting.userRemote.value, 4 );
+        }
+        if (deprecatedSetting.workspace !== undefined) {
+            this.configurationService.updateValue(deprecatedKey, undefined, 5 );
+            this.configurationService.updateValue(key, deprecatedSetting.workspace.value, 5 );
+        }
+        if (deprecatedSetting.workspaceFolder !== undefined) {
+            this.configurationService.updateValue(deprecatedKey, undefined, 6 );
+            this.configurationService.updateValue(key, deprecatedSetting.workspaceFolder.value, 6 );
+        }
+    }
+    _computeOutputLineHeight(lineHeight, outputFontSize) {
+        const minimumLineHeight = 8;
+        if (lineHeight === 0) {
+            const editorOptions = this.configurationService.getValue('editor');
+            const fontInfo = FontMeasurements.readFontInfo(BareFontInfo.createFromRawSettings(editorOptions, PixelRatio.value));
+            lineHeight = fontInfo.lineHeight;
+        }
+        else if (lineHeight < minimumLineHeight) {
+            let fontSize = outputFontSize;
+            if (fontSize === 0) {
+                fontSize = this.configurationService.getValue('editor.fontSize');
+            }
+            lineHeight = lineHeight * fontSize;
+        }
+        lineHeight = Math.round(lineHeight);
+        if (lineHeight < minimumLineHeight) {
+            lineHeight = minimumLineHeight;
+        }
+        return lineHeight;
+    }
+    _updateConfiguration(e) {
+        const cellStatusBarVisibility = e.affectsConfiguration(NotebookSetting.showCellStatusBar);
+        const cellToolbarLocation = e.affectsConfiguration(NotebookSetting.cellToolbarLocation);
+        const cellToolbarInteraction = e.affectsConfiguration(NotebookSetting.cellToolbarVisibility);
+        const compactView = e.affectsConfiguration(NotebookSetting.compactView);
+        const focusIndicator = e.affectsConfiguration(NotebookSetting.focusIndicator);
+        const insertToolbarPosition = e.affectsConfiguration(NotebookSetting.insertToolbarLocation);
+        const insertToolbarAlignment = e.affectsConfiguration(NotebookSetting.experimentalInsertToolbarAlignment);
+        const globalToolbar = e.affectsConfiguration(NotebookSetting.globalToolbar);
+        const stickyScroll = e.affectsConfiguration(NotebookSetting.stickyScroll);
+        const consolidatedOutputButton = e.affectsConfiguration(NotebookSetting.consolidatedOutputButton);
+        const consolidatedRunButton = e.affectsConfiguration(NotebookSetting.consolidatedRunButton);
+        const showFoldingControls = e.affectsConfiguration(NotebookSetting.showFoldingControls);
+        const dragAndDropEnabled = e.affectsConfiguration(NotebookSetting.dragAndDropEnabled);
+        const fontSize = e.affectsConfiguration('editor.fontSize');
+        const outputFontSize = e.affectsConfiguration(NotebookSetting.outputFontSize);
+        const markupFontSize = e.affectsConfiguration(NotebookSetting.markupFontSize);
+        const fontFamily = e.affectsConfiguration('editor.fontFamily');
+        const outputFontFamily = e.affectsConfiguration(NotebookSetting.outputFontFamily);
+        const editorOptionsCustomizations = e.affectsConfiguration(NotebookSetting.cellEditorOptionsCustomizations);
+        const interactiveWindowCollapseCodeCells = e.affectsConfiguration(NotebookSetting.interactiveWindowCollapseCodeCells);
+        const outputLineHeight = e.affectsConfiguration(NotebookSetting.outputLineHeight);
+        const outputScrolling = e.affectsConfiguration(NotebookSetting.outputScrolling);
+        const outputWordWrap = e.affectsConfiguration(NotebookSetting.outputWordWrap);
+        if (!cellStatusBarVisibility
+            && !cellToolbarLocation
+            && !cellToolbarInteraction
+            && !compactView
+            && !focusIndicator
+            && !insertToolbarPosition
+            && !insertToolbarAlignment
+            && !globalToolbar
+            && !stickyScroll
+            && !consolidatedOutputButton
+            && !consolidatedRunButton
+            && !showFoldingControls
+            && !dragAndDropEnabled
+            && !fontSize
+            && !outputFontSize
+            && !markupFontSize
+            && !fontFamily
+            && !outputFontFamily
+            && !editorOptionsCustomizations
+            && !interactiveWindowCollapseCodeCells
+            && !outputLineHeight
+            && !outputScrolling
+            && !outputWordWrap) {
+            return;
+        }
+        let configuration = Object.assign({}, this._layoutConfiguration);
+        if (cellStatusBarVisibility) {
+            configuration.showCellStatusBar = this.configurationService.getValue(NotebookSetting.showCellStatusBar);
+        }
+        if (cellToolbarLocation) {
+            configuration.cellToolbarLocation = this.configurationService.getValue(NotebookSetting.cellToolbarLocation) ?? { 'default': 'right' };
+        }
+        if (cellToolbarInteraction && !this.overrides?.cellToolbarInteraction) {
+            configuration.cellToolbarInteraction = this.configurationService.getValue(NotebookSetting.cellToolbarVisibility);
+        }
+        if (focusIndicator) {
+            configuration.focusIndicator = this._computeFocusIndicatorOption();
+        }
+        if (compactView) {
+            const compactViewValue = this.configurationService.getValue(NotebookSetting.compactView) ?? true;
+            configuration = Object.assign(configuration, {
+                ...(compactViewValue ? compactConfigConstants : defaultConfigConstants),
+            });
+            configuration.compactView = compactViewValue;
+        }
+        if (insertToolbarAlignment) {
+            configuration.insertToolbarAlignment = this._computeInsertToolbarAlignmentOption();
+        }
+        if (insertToolbarPosition) {
+            configuration.insertToolbarPosition = this._computeInsertToolbarPositionOption(this.isReadonly);
+        }
+        if (globalToolbar && this.overrides?.globalToolbar === undefined) {
+            configuration.globalToolbar = this.configurationService.getValue(NotebookSetting.globalToolbar) ?? true;
+        }
+        if (stickyScroll && this.overrides?.stickyScroll === undefined) {
+            configuration.stickyScroll = this.configurationService.getValue(NotebookSetting.stickyScroll) ?? false;
+        }
+        if (consolidatedOutputButton) {
+            configuration.consolidatedOutputButton = this.configurationService.getValue(NotebookSetting.consolidatedOutputButton) ?? true;
+        }
+        if (consolidatedRunButton) {
+            configuration.consolidatedRunButton = this.configurationService.getValue(NotebookSetting.consolidatedRunButton) ?? true;
+        }
+        if (showFoldingControls) {
+            configuration.showFoldingControls = this._computeShowFoldingControlsOption();
+        }
+        if (dragAndDropEnabled) {
+            configuration.dragAndDropEnabled = this.configurationService.getValue(NotebookSetting.dragAndDropEnabled) ?? true;
+        }
+        if (fontSize) {
+            configuration.fontSize = this.configurationService.getValue('editor.fontSize');
+        }
+        if (outputFontSize || fontSize) {
+            configuration.outputFontSize = this.configurationService.getValue(NotebookSetting.outputFontSize) || configuration.fontSize;
+        }
+        if (markupFontSize) {
+            configuration.markupFontSize = this.configurationService.getValue(NotebookSetting.markupFontSize);
+        }
+        if (outputFontFamily) {
+            configuration.outputFontFamily = this.configurationService.getValue(NotebookSetting.outputFontFamily);
+        }
+        if (editorOptionsCustomizations) {
+            configuration.editorOptionsCustomizations = this.configurationService.getValue(NotebookSetting.cellEditorOptionsCustomizations);
+        }
+        if (interactiveWindowCollapseCodeCells) {
+            configuration.interactiveWindowCollapseCodeCells = this.configurationService.getValue(NotebookSetting.interactiveWindowCollapseCodeCells);
+        }
+        if (outputLineHeight || fontSize || outputFontSize) {
+            const lineHeight = this.configurationService.getValue(NotebookSetting.outputLineHeight);
+            configuration.outputLineHeight = this._computeOutputLineHeight(lineHeight, configuration.outputFontSize);
+        }
+        if (outputWordWrap) {
+            configuration.outputWordWrap = this.configurationService.getValue(NotebookSetting.outputWordWrap);
+        }
+        if (outputScrolling) {
+            configuration.outputScrolling = this.configurationService.getValue(NotebookSetting.outputScrolling);
+        }
+        this._layoutConfiguration = ( Object.freeze(configuration));
+        this._onDidChangeOptions.fire({
+            cellStatusBarVisibility,
+            cellToolbarLocation,
+            cellToolbarInteraction,
+            compactView,
+            focusIndicator,
+            insertToolbarPosition,
+            insertToolbarAlignment,
+            globalToolbar,
+            stickyScroll,
+            showFoldingControls,
+            consolidatedOutputButton,
+            consolidatedRunButton,
+            dragAndDropEnabled,
+            fontSize,
+            outputFontSize,
+            markupFontSize,
+            fontFamily,
+            outputFontFamily,
+            editorOptionsCustomizations,
+            interactiveWindowCollapseCodeCells,
+            outputLineHeight,
+            outputScrolling,
+            outputWordWrap
+        });
+    }
+    _computeInsertToolbarPositionOption(isReadOnly) {
+        return isReadOnly ? 'hidden' : this.configurationService.getValue(NotebookSetting.insertToolbarLocation) ?? 'both';
+    }
+    _computeInsertToolbarAlignmentOption() {
+        return this.configurationService.getValue(NotebookSetting.experimentalInsertToolbarAlignment) ?? 'center';
+    }
+    _computeShowFoldingControlsOption() {
+        return this.configurationService.getValue(NotebookSetting.showFoldingControls) ?? 'mouseover';
+    }
+    _computeFocusIndicatorOption() {
+        return this.configurationService.getValue(NotebookSetting.focusIndicator) ?? 'gutter';
+    }
+    getCellCollapseDefault() {
+        return this._layoutConfiguration.interactiveWindowCollapseCodeCells === 'never' ?
+            {
+                codeCell: {
+                    inputCollapsed: false
+                }
+            } : {
+            codeCell: {
+                inputCollapsed: true
+            }
+        };
+    }
+    getLayoutConfiguration() {
+        return this._layoutConfiguration;
+    }
+    getDisplayOptions() {
+        return this._layoutConfiguration;
+    }
+    getCellEditorContainerLeftMargin() {
+        const { codeCellLeftMargin, cellRunGutter } = this._layoutConfiguration;
+        return codeCellLeftMargin + cellRunGutter;
+    }
+    computeCollapsedMarkdownCellHeight(viewType) {
+        const { bottomToolbarGap } = this.computeBottomToolbarDimensions(viewType);
+        return this._layoutConfiguration.markdownCellTopMargin
+            + this._layoutConfiguration.collapsedIndicatorHeight
+            + bottomToolbarGap
+            + this._layoutConfiguration.markdownCellBottomMargin;
+    }
+    computeBottomToolbarOffset(totalHeight, viewType) {
+        const { bottomToolbarGap, bottomToolbarHeight } = this.computeBottomToolbarDimensions(viewType);
+        return totalHeight
+            - bottomToolbarGap
+            - bottomToolbarHeight / 2;
+    }
+    computeCodeCellEditorWidth(outerWidth) {
+        return outerWidth - (this._layoutConfiguration.codeCellLeftMargin
+            + this._layoutConfiguration.cellRunGutter
+            + this._layoutConfiguration.cellRightMargin);
+    }
+    computeMarkdownCellEditorWidth(outerWidth) {
+        return outerWidth
+            - this._layoutConfiguration.markdownCellGutter
+            - this._layoutConfiguration.markdownCellLeftMargin
+            - this._layoutConfiguration.cellRightMargin;
+    }
+    computeStatusBarHeight() {
+        return this._layoutConfiguration.cellStatusBarHeight;
+    }
+    _computeBottomToolbarDimensions(compactView, insertToolbarPosition, insertToolbarAlignment, cellToolbar) {
+        if (insertToolbarAlignment === 'left' || cellToolbar !== 'hidden') {
+            return {
+                bottomToolbarGap: 18,
+                bottomToolbarHeight: 18
+            };
+        }
+        if (insertToolbarPosition === 'betweenCells' || insertToolbarPosition === 'both') {
+            return compactView ? {
+                bottomToolbarGap: 12,
+                bottomToolbarHeight: 20
+            } : {
+                bottomToolbarGap: 20,
+                bottomToolbarHeight: 20
+            };
+        }
+        else {
+            return {
+                bottomToolbarGap: 0,
+                bottomToolbarHeight: 0
+            };
+        }
+    }
+    computeBottomToolbarDimensions(viewType) {
+        const configuration = this._layoutConfiguration;
+        const cellToolbarPosition = this.computeCellToolbarLocation(viewType);
+        const { bottomToolbarGap, bottomToolbarHeight } = this._computeBottomToolbarDimensions(configuration.compactView, configuration.insertToolbarPosition, configuration.insertToolbarAlignment, cellToolbarPosition);
+        return {
+            bottomToolbarGap,
+            bottomToolbarHeight
+        };
+    }
+    computeCellToolbarLocation(viewType) {
+        const cellToolbarLocation = this._layoutConfiguration.cellToolbarLocation;
+        if (typeof cellToolbarLocation === 'string') {
+            if (cellToolbarLocation === 'left' || cellToolbarLocation === 'right' || cellToolbarLocation === 'hidden') {
+                return cellToolbarLocation;
+            }
+        }
+        else {
+            if (viewType) {
+                const notebookSpecificSetting = cellToolbarLocation[viewType] ?? cellToolbarLocation['default'];
+                let cellToolbarLocationForCurrentView = 'right';
+                switch (notebookSpecificSetting) {
+                    case 'left':
+                        cellToolbarLocationForCurrentView = 'left';
+                        break;
+                    case 'right':
+                        cellToolbarLocationForCurrentView = 'right';
+                        break;
+                    case 'hidden':
+                        cellToolbarLocationForCurrentView = 'hidden';
+                        break;
+                    default:
+                        cellToolbarLocationForCurrentView = 'right';
+                        break;
+                }
+                return cellToolbarLocationForCurrentView;
+            }
+        }
+        return 'right';
+    }
+    computeTopInsertToolbarHeight(viewType) {
+        if (this._layoutConfiguration.insertToolbarPosition === 'betweenCells' || this._layoutConfiguration.insertToolbarPosition === 'both') {
+            return SCROLLABLE_ELEMENT_PADDING_TOP;
+        }
+        const cellToolbarLocation = this.computeCellToolbarLocation(viewType);
+        if (cellToolbarLocation === 'left' || cellToolbarLocation === 'right') {
+            return SCROLLABLE_ELEMENT_PADDING_TOP;
+        }
+        return 0;
+    }
+    computeEditorPadding(internalMetadata, cellUri) {
+        return {
+            top: getEditorTopPadding(),
+            bottom: this.statusBarIsVisible(internalMetadata, cellUri)
+                ? this._layoutConfiguration.editorBottomPadding
+                : this._layoutConfiguration.editorBottomPaddingWithoutStatusBar
+        };
+    }
+    computeEditorStatusbarHeight(internalMetadata, cellUri) {
+        return this.statusBarIsVisible(internalMetadata, cellUri) ? this.computeStatusBarHeight() : 0;
+    }
+    statusBarIsVisible(internalMetadata, cellUri) {
+        const exe = this.notebookExecutionStateService.getCellExecution(cellUri);
+        if (this._layoutConfiguration.showCellStatusBar === 'visible') {
+            return true;
+        }
+        else if (this._layoutConfiguration.showCellStatusBar === 'visibleAfterExecute') {
+            return typeof internalMetadata.lastRunSuccess === 'boolean' || exe !== undefined;
+        }
+        else {
+            return false;
+        }
+    }
+    computeWebviewOptions() {
+        return {
+            outputNodePadding: this._layoutConfiguration.cellOutputPadding,
+            outputNodeLeftPadding: this._layoutConfiguration.cellOutputPadding,
+            previewNodePadding: this._layoutConfiguration.markdownPreviewPadding,
+            markdownLeftMargin: this._layoutConfiguration.markdownCellGutter + this._layoutConfiguration.markdownCellLeftMargin,
+            leftMargin: this._layoutConfiguration.codeCellLeftMargin,
+            rightMargin: this._layoutConfiguration.cellRightMargin,
+            runGutter: this._layoutConfiguration.cellRunGutter,
+            dragAndDropEnabled: this._layoutConfiguration.dragAndDropEnabled,
+            fontSize: this._layoutConfiguration.fontSize,
+            outputFontSize: this._layoutConfiguration.outputFontSize,
+            outputFontFamily: this._layoutConfiguration.outputFontFamily,
+            markupFontSize: this._layoutConfiguration.markupFontSize,
+            outputLineHeight: this._layoutConfiguration.outputLineHeight,
+            outputScrolling: this._layoutConfiguration.outputScrolling,
+            outputWordWrap: this._layoutConfiguration.outputWordWrap,
+            outputLineLimit: this._layoutConfiguration.outputLineLimit,
+        };
+    }
+    computeDiffWebviewOptions() {
+        return {
+            outputNodePadding: this._layoutConfiguration.cellOutputPadding,
+            outputNodeLeftPadding: 0,
+            previewNodePadding: this._layoutConfiguration.markdownPreviewPadding,
+            markdownLeftMargin: 0,
+            leftMargin: 32,
+            rightMargin: 0,
+            runGutter: 0,
+            dragAndDropEnabled: false,
+            fontSize: this._layoutConfiguration.fontSize,
+            outputFontSize: this._layoutConfiguration.outputFontSize,
+            outputFontFamily: this._layoutConfiguration.outputFontFamily,
+            markupFontSize: this._layoutConfiguration.markupFontSize,
+            outputLineHeight: this._layoutConfiguration.outputLineHeight,
+            outputScrolling: this._layoutConfiguration.outputScrolling,
+            outputWordWrap: this._layoutConfiguration.outputWordWrap,
+            outputLineLimit: this._layoutConfiguration.outputLineLimit,
+        };
+    }
+    computeIndicatorPosition(totalHeight, foldHintHeight, viewType) {
+        const { bottomToolbarGap } = this.computeBottomToolbarDimensions(viewType);
+        return {
+            bottomIndicatorTop: totalHeight - bottomToolbarGap - this._layoutConfiguration.cellBottomMargin - foldHintHeight,
+            verticalIndicatorHeight: totalHeight - bottomToolbarGap - foldHintHeight
+        };
+    }
+}
+export { NotebookOptions, OutputInnerContainerTopPadding, getEditorTopPadding, updateEditorTopPadding };

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

@@ -0,0 +1,27 @@
+var NotebookViewEventType;
+( (function(NotebookViewEventType) {
+    NotebookViewEventType[NotebookViewEventType["LayoutChanged"] = 1] = "LayoutChanged";
+    NotebookViewEventType[NotebookViewEventType["MetadataChanged"] = 2] = "MetadataChanged";
+    NotebookViewEventType[NotebookViewEventType["CellStateChanged"] = 3] = "CellStateChanged";
+})(NotebookViewEventType || (NotebookViewEventType = {})));
+class NotebookLayoutChangedEvent {
+    constructor(source, value) {
+        this.source = source;
+        this.value = value;
+        this.type = NotebookViewEventType.LayoutChanged;
+    }
+}
+class NotebookMetadataChangedEvent {
+    constructor(source) {
+        this.source = source;
+        this.type = NotebookViewEventType.MetadataChanged;
+    }
+}
+class NotebookCellStateChangedEvent {
+    constructor(source, cell) {
+        this.source = source;
+        this.cell = cell;
+        this.type = NotebookViewEventType.CellStateChanged;
+    }
+}
+export { NotebookCellStateChangedEvent, NotebookLayoutChangedEvent, NotebookMetadataChangedEvent, NotebookViewEventType };