@codingame/monaco-vscode-api 1.85.0 → 1.85.1

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

@@ -0,0 +1,85 @@
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { Disposable, DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { deepClone } from 'monaco-editor/esm/vs/base/common/objects.js';
+class BaseCellEditorOptions extends Disposable {
+    static { this.fixedEditorOptions = {
+        scrollBeyondLastLine: false,
+        scrollbar: {
+            verticalScrollbarSize: 14,
+            horizontal: 'auto',
+            useShadows: true,
+            verticalHasArrows: false,
+            horizontalHasArrows: false,
+            alwaysConsumeMouseWheel: false
+        },
+        renderLineHighlightOnlyWhenFocus: true,
+        overviewRulerLanes: 0,
+        lineDecorationsWidth: 0,
+        folding: true,
+        fixedOverflowWidgets: true,
+        minimap: { enabled: false },
+        renderValidationDecorations: 'on',
+        lineNumbersMinChars: 3
+    }; }
+    get value() {
+        return this._value;
+    }
+    constructor(notebookEditor, notebookOptions, configurationService, language) {
+        super();
+        this.notebookEditor = notebookEditor;
+        this.notebookOptions = notebookOptions;
+        this.configurationService = configurationService;
+        this.language = language;
+        this._localDisposableStore = this._register(( new DisposableStore()));
+        this._onDidChange = this._register(( new Emitter()));
+        this.onDidChange = this._onDidChange.event;
+        this._register(configurationService.onDidChangeConfiguration(e => {
+            if (e.affectsConfiguration('editor') || e.affectsConfiguration('notebook')) {
+                this._recomputeOptions();
+            }
+        }));
+        this._register(notebookOptions.onDidChangeOptions(e => {
+            if (e.cellStatusBarVisibility || e.editorTopPadding || e.editorOptionsCustomizations) {
+                this._recomputeOptions();
+            }
+        }));
+        this._register(this.notebookEditor.onDidChangeModel(() => {
+            this._localDisposableStore.clear();
+            if (this.notebookEditor.hasModel()) {
+                this._localDisposableStore.add(this.notebookEditor.onDidChangeOptions(() => {
+                    this._recomputeOptions();
+                }));
+                this._recomputeOptions();
+            }
+        }));
+        if (this.notebookEditor.hasModel()) {
+            this._localDisposableStore.add(this.notebookEditor.onDidChangeOptions(() => {
+                this._recomputeOptions();
+            }));
+        }
+        this._value = this._computeEditorOptions();
+    }
+    _recomputeOptions() {
+        this._value = this._computeEditorOptions();
+        this._onDidChange.fire();
+    }
+    _computeEditorOptions() {
+        const editorOptions = deepClone(this.configurationService.getValue('editor', { overrideIdentifier: this.language }));
+        const editorOptionsOverrideRaw = this.notebookOptions.getDisplayOptions().editorOptionsCustomizations ?? {};
+        const editorOptionsOverride = {};
+        for (const key in editorOptionsOverrideRaw) {
+            if (key.indexOf('editor.') === 0) {
+                editorOptionsOverride[key.substring(7)] = editorOptionsOverrideRaw[key];
+            }
+        }
+        const computed = ( Object.freeze({
+            ...editorOptions,
+            ...BaseCellEditorOptions.fixedEditorOptions,
+            ...editorOptionsOverride,
+            ...{ padding: { top: 12, bottom: 12 } },
+            readOnly: this.notebookEditor.isReadOnly
+        }));
+        return computed;
+    }
+}
+export { BaseCellEditorOptions };

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

@@ -0,0 +1,47 @@
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { RENDERER_NOT_AVAILABLE } from '../../common/notebookCommon.js';
+let handle = 0;
+class CellOutputViewModel extends Disposable {
+    get model() {
+        return this._outputRawData;
+    }
+    get pickedMimeType() {
+        return this._pickedMimeType;
+    }
+    set pickedMimeType(value) {
+        this._pickedMimeType = value;
+    }
+    constructor(cellViewModel, _outputRawData, _notebookService) {
+        super();
+        this.cellViewModel = cellViewModel;
+        this._outputRawData = _outputRawData;
+        this._notebookService = _notebookService;
+        this._onDidResetRendererEmitter = this._register(( new Emitter()));
+        this.onDidResetRenderer = this._onDidResetRendererEmitter.event;
+        this.outputHandle = handle++;
+    }
+    hasMultiMimeType() {
+        if (this._outputRawData.outputs.length < 2) {
+            return false;
+        }
+        const firstMimeType = this._outputRawData.outputs[0].mime;
+        return ( this._outputRawData.outputs.some(output => output.mime !== firstMimeType));
+    }
+    resolveMimeTypes(textModel, kernelProvides) {
+        const mimeTypes = this._notebookService.getOutputMimeTypeInfo(textModel, kernelProvides, this.model);
+        const index = mimeTypes.findIndex(mimeType => mimeType.rendererId !== RENDERER_NOT_AVAILABLE && mimeType.isTrusted);
+        return [mimeTypes, Math.max(index, 0)];
+    }
+    resetRenderer() {
+        this._pickedMimeType = undefined;
+        this.model.bumpVersion();
+        this._onDidResetRendererEmitter.fire();
+    }
+    toRawJSON() {
+        return {
+            outputs: this._outputRawData.outputs,
+        };
+    }
+}
+export { CellOutputViewModel };

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

@@ -0,0 +1,40 @@
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+function rangesEqual(a, b) {
+    if (a.length !== b.length) {
+        return false;
+    }
+    for (let i = 0; i < a.length; i++) {
+        if (a[i].start !== b[i].start || a[i].end !== b[i].end) {
+            return false;
+        }
+    }
+    return true;
+}
+class NotebookCellSelectionCollection extends Disposable {
+    constructor() {
+        super(...arguments);
+        this._onDidChangeSelection = this._register(( new Emitter()));
+        this._primary = null;
+        this._selections = [];
+    }
+    get onDidChangeSelection() { return this._onDidChangeSelection.event; }
+    get selections() {
+        return this._selections;
+    }
+    get focus() {
+        return this._primary ?? { start: 0, end: 0 };
+    }
+    setState(primary, selections, forceEventEmit, source) {
+        const changed = primary !== this._primary || !rangesEqual(this._selections, selections);
+        this._primary = primary;
+        this._selections = selections;
+        if (changed || forceEventEmit) {
+            this._onDidChangeSelection.fire(source);
+        }
+    }
+    setSelections(selections, forceEventEmit, source) {
+        this.setState(this._primary, selections, forceEventEmit, source);
+    }
+}
+export { NotebookCellSelectionCollection };

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

@@ -0,0 +1,435 @@
+import { __decorate, __param } from '../../../../../../../../external/tslib/tslib.es6.js';
+import { Emitter, PauseableEmitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { dispose } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import * as UUID from 'monaco-editor/esm/vs/base/common/uuid.js';
+import { ICodeEditorService } from 'monaco-editor/esm/vs/editor/browser/services/codeEditorService.js';
+import { ITextModelService } from 'monaco-editor/esm/vs/editor/common/services/resolverService.js';
+import { PrefixSumComputer } from 'monaco-editor/esm/vs/editor/common/model/prefixSumComputer.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { IUndoRedoService } from 'monaco-editor/esm/vs/platform/undoRedo/common/undoRedo.js';
+import { CellLayoutState, CellEditState } from '../notebookBrowser.js';
+import { CellOutputViewModel } from './cellOutputViewModel.js';
+import { CellKind } from '../../common/notebookCommon.js';
+import { INotebookService } from '../../common/notebookService.js';
+import { BaseCellViewModel } from './baseCellViewModel.js';
+const outputDisplayLimit = 500;
+let CodeCellViewModel = class CodeCellViewModel extends BaseCellViewModel {
+    set editorHeight(height) {
+        if (this._editorHeight === height) {
+            return;
+        }
+        this._editorHeight = height;
+        this.layoutChange({ editorHeight: true }, 'CodeCellViewModel#editorHeight');
+    }
+    get editorHeight() {
+        throw new Error('editorHeight is write-only');
+    }
+    set chatHeight(height) {
+        if (this._chatHeight === height) {
+            return;
+        }
+        this._chatHeight = height;
+        this.layoutChange({ chatHeight: true }, 'CodeCellViewModel#chatHeight');
+    }
+    get chatHeight() {
+        return this._chatHeight;
+    }
+    set commentHeight(height) {
+        if (this._commentHeight === height) {
+            return;
+        }
+        this._commentHeight = height;
+        this.layoutChange({ commentHeight: true }, 'CodeCellViewModel#commentHeight');
+    }
+    get outputIsHovered() {
+        return this._hoveringOutput;
+    }
+    set outputIsHovered(v) {
+        this._hoveringOutput = v;
+        this._onDidChangeState.fire({ outputIsHoveredChanged: true });
+    }
+    get outputIsFocused() {
+        return this._focusOnOutput;
+    }
+    set outputIsFocused(v) {
+        this._focusOnOutput = v;
+        this._onDidChangeState.fire({ outputIsFocusedChanged: true });
+    }
+    get outputMinHeight() {
+        return this._outputMinHeight;
+    }
+    set outputMinHeight(newMin) {
+        this._outputMinHeight = newMin;
+    }
+    get layoutInfo() {
+        return this._layoutInfo;
+    }
+    get outputsViewModels() {
+        return this._outputViewModels;
+    }
+    constructor(viewType, model, initialNotebookLayoutInfo, viewContext, configurationService, _notebookService, modelService, undoRedoService, codeEditorService) {
+        super(viewType, model, UUID.generateUuid(), viewContext, configurationService, modelService, undoRedoService, codeEditorService);
+        this.viewContext = viewContext;
+        this._notebookService = _notebookService;
+        this.cellKind = CellKind.Code;
+        this._onLayoutInfoRead = this._register(( new Emitter()));
+        this.onLayoutInfoRead = this._onLayoutInfoRead.event;
+        this._onDidStartExecution = this._register(( new Emitter()));
+        this.onDidStartExecution = this._onDidStartExecution.event;
+        this._onDidStopExecution = this._register(( new Emitter()));
+        this.onDidStopExecution = this._onDidStopExecution.event;
+        this._onDidChangeOutputs = this._register(( new Emitter()));
+        this.onDidChangeOutputs = this._onDidChangeOutputs.event;
+        this._onDidRemoveOutputs = this._register(( new Emitter()));
+        this.onDidRemoveOutputs = this._onDidRemoveOutputs.event;
+        this._outputCollection = [];
+        this._outputsTop = null;
+        this._pauseableEmitter = this._register(( new PauseableEmitter()));
+        this.onDidChangeLayout = this._pauseableEmitter.event;
+        this._editorHeight = 0;
+        this._chatHeight = 0;
+        this._commentHeight = 0;
+        this._hoveringOutput = false;
+        this._focusOnOutput = false;
+        this._outputMinHeight = 0;
+        this._hasFindResult = this._register(( new Emitter()));
+        this.hasFindResult = this._hasFindResult.event;
+        this._outputViewModels = ( this.model.outputs.map(output => ( new CellOutputViewModel(this, output, this._notebookService))));
+        this._register(this.model.onDidChangeOutputs((splice) => {
+            const removedOutputs = [];
+            let outputLayoutChange = false;
+            for (let i = splice.start; i < splice.start + splice.deleteCount; i++) {
+                if (this._outputCollection[i] !== undefined && this._outputCollection[i] !== 0) {
+                    outputLayoutChange = true;
+                }
+            }
+            this._outputCollection.splice(splice.start, splice.deleteCount, ...( splice.newOutputs.map(() => 0)));
+            removedOutputs.push(...this._outputViewModels.splice(splice.start, splice.deleteCount, ...( splice.newOutputs.map(output => ( new CellOutputViewModel(this, output, this._notebookService))))));
+            this._outputsTop = null;
+            this._onDidChangeOutputs.fire(splice);
+            this._onDidRemoveOutputs.fire(removedOutputs);
+            if (outputLayoutChange) {
+                this.layoutChange({ outputHeight: true }, 'CodeCellViewModel#model.onDidChangeOutputs');
+            }
+            dispose(removedOutputs);
+        }));
+        this._outputCollection = ( new Array(this.model.outputs.length));
+        this._layoutInfo = {
+            fontInfo: initialNotebookLayoutInfo?.fontInfo || null,
+            editorHeight: 0,
+            editorWidth: initialNotebookLayoutInfo
+                ? this.viewContext.notebookOptions.computeCodeCellEditorWidth(initialNotebookLayoutInfo.width)
+                : 0,
+            chatHeight: 0,
+            statusBarHeight: 0,
+            commentHeight: 0,
+            outputContainerOffset: 0,
+            outputTotalHeight: 0,
+            outputShowMoreContainerHeight: 0,
+            outputShowMoreContainerOffset: 0,
+            totalHeight: this.computeTotalHeight(17, 0, 0, 0),
+            codeIndicatorHeight: 0,
+            outputIndicatorHeight: 0,
+            bottomToolbarOffset: 0,
+            layoutState: CellLayoutState.Uninitialized,
+            estimatedHasHorizontalScrolling: false
+        };
+    }
+    updateExecutionState(e) {
+        if (e.changed) {
+            this._onDidStartExecution.fire(e);
+        }
+        else {
+            this._onDidStopExecution.fire(e);
+        }
+    }
+    updateOptions(e) {
+        if (e.cellStatusBarVisibility || e.insertToolbarPosition || e.cellToolbarLocation) {
+            this.layoutChange({});
+        }
+    }
+    pauseLayout() {
+        this._pauseableEmitter.pause();
+    }
+    resumeLayout() {
+        this._pauseableEmitter.resume();
+    }
+    layoutChange(state, source) {
+        this._ensureOutputsTop();
+        const notebookLayoutConfiguration = this.viewContext.notebookOptions.getLayoutConfiguration();
+        const bottomToolbarDimensions = this.viewContext.notebookOptions.computeBottomToolbarDimensions(this.viewType);
+        const outputShowMoreContainerHeight = state.outputShowMoreContainerHeight ? state.outputShowMoreContainerHeight : this._layoutInfo.outputShowMoreContainerHeight;
+        const outputTotalHeight = Math.max(this._outputMinHeight, this.isOutputCollapsed ? notebookLayoutConfiguration.collapsedIndicatorHeight : this._outputsTop.getTotalSum());
+        const commentHeight = state.commentHeight ? this._commentHeight : this._layoutInfo.commentHeight;
+        const originalLayout = this.layoutInfo;
+        if (!this.isInputCollapsed) {
+            let newState;
+            let editorHeight;
+            let totalHeight;
+            let hasHorizontalScrolling = false;
+            const chatHeight = state.chatHeight ? this._chatHeight : this._layoutInfo.chatHeight;
+            if (!state.editorHeight && this._layoutInfo.layoutState === CellLayoutState.FromCache && !state.outputHeight) {
+                const estimate = this.estimateEditorHeight(state.font?.lineHeight ?? this._layoutInfo.fontInfo?.lineHeight);
+                editorHeight = estimate.editorHeight;
+                hasHorizontalScrolling = estimate.hasHorizontalScrolling;
+                totalHeight = this._layoutInfo.totalHeight;
+                newState = CellLayoutState.FromCache;
+            }
+            else if (state.editorHeight || this._layoutInfo.layoutState === CellLayoutState.Measured) {
+                editorHeight = this._editorHeight;
+                totalHeight = this.computeTotalHeight(this._editorHeight, outputTotalHeight, outputShowMoreContainerHeight, chatHeight);
+                newState = CellLayoutState.Measured;
+                hasHorizontalScrolling = this._layoutInfo.estimatedHasHorizontalScrolling;
+            }
+            else {
+                const estimate = this.estimateEditorHeight(state.font?.lineHeight ?? this._layoutInfo.fontInfo?.lineHeight);
+                editorHeight = estimate.editorHeight;
+                hasHorizontalScrolling = estimate.hasHorizontalScrolling;
+                totalHeight = this.computeTotalHeight(editorHeight, outputTotalHeight, outputShowMoreContainerHeight, chatHeight);
+                newState = CellLayoutState.Estimated;
+            }
+            const statusBarHeight = this.viewContext.notebookOptions.computeEditorStatusbarHeight(this.internalMetadata, this.uri);
+            const codeIndicatorHeight = editorHeight + statusBarHeight;
+            const outputIndicatorHeight = outputTotalHeight + outputShowMoreContainerHeight;
+            const outputContainerOffset = notebookLayoutConfiguration.editorToolbarHeight
+                + notebookLayoutConfiguration.cellTopMargin
+                + chatHeight
+                + editorHeight
+                + statusBarHeight;
+            const outputShowMoreContainerOffset = totalHeight
+                - bottomToolbarDimensions.bottomToolbarGap
+                - bottomToolbarDimensions.bottomToolbarHeight / 2
+                - outputShowMoreContainerHeight;
+            const bottomToolbarOffset = this.viewContext.notebookOptions.computeBottomToolbarOffset(totalHeight, this.viewType);
+            const editorWidth = state.outerWidth !== undefined
+                ? this.viewContext.notebookOptions.computeCodeCellEditorWidth(state.outerWidth)
+                : this._layoutInfo?.editorWidth;
+            this._layoutInfo = {
+                fontInfo: state.font ?? this._layoutInfo.fontInfo ?? null,
+                chatHeight,
+                editorHeight,
+                editorWidth,
+                statusBarHeight,
+                commentHeight,
+                outputContainerOffset,
+                outputTotalHeight,
+                outputShowMoreContainerHeight,
+                outputShowMoreContainerOffset,
+                totalHeight,
+                codeIndicatorHeight,
+                outputIndicatorHeight,
+                bottomToolbarOffset,
+                layoutState: newState,
+                estimatedHasHorizontalScrolling: hasHorizontalScrolling
+            };
+        }
+        else {
+            const codeIndicatorHeight = notebookLayoutConfiguration.collapsedIndicatorHeight;
+            const outputIndicatorHeight = outputTotalHeight + outputShowMoreContainerHeight;
+            const chatHeight = state.chatHeight ? this._chatHeight : this._layoutInfo.chatHeight;
+            const outputContainerOffset = notebookLayoutConfiguration.cellTopMargin + notebookLayoutConfiguration.collapsedIndicatorHeight;
+            const totalHeight = notebookLayoutConfiguration.cellTopMargin
+                + notebookLayoutConfiguration.collapsedIndicatorHeight
+                + notebookLayoutConfiguration.cellBottomMargin
+                + bottomToolbarDimensions.bottomToolbarGap
+                + chatHeight
+                + commentHeight
+                + outputTotalHeight + outputShowMoreContainerHeight;
+            const outputShowMoreContainerOffset = totalHeight
+                - bottomToolbarDimensions.bottomToolbarGap
+                - bottomToolbarDimensions.bottomToolbarHeight / 2
+                - outputShowMoreContainerHeight;
+            const bottomToolbarOffset = this.viewContext.notebookOptions.computeBottomToolbarOffset(totalHeight, this.viewType);
+            const editorWidth = state.outerWidth !== undefined
+                ? this.viewContext.notebookOptions.computeCodeCellEditorWidth(state.outerWidth)
+                : this._layoutInfo?.editorWidth;
+            this._layoutInfo = {
+                fontInfo: state.font ?? this._layoutInfo.fontInfo ?? null,
+                editorHeight: this._layoutInfo.editorHeight,
+                editorWidth,
+                chatHeight: chatHeight,
+                statusBarHeight: 0,
+                commentHeight,
+                outputContainerOffset,
+                outputTotalHeight,
+                outputShowMoreContainerHeight,
+                outputShowMoreContainerOffset,
+                totalHeight,
+                codeIndicatorHeight,
+                outputIndicatorHeight,
+                bottomToolbarOffset,
+                layoutState: this._layoutInfo.layoutState,
+                estimatedHasHorizontalScrolling: false
+            };
+        }
+        this._fireOnDidChangeLayout({
+            ...state,
+            totalHeight: this.layoutInfo.totalHeight !== originalLayout.totalHeight,
+            source,
+        });
+    }
+    _fireOnDidChangeLayout(state) {
+        this._pauseableEmitter.fire(state);
+    }
+    restoreEditorViewState(editorViewStates, totalHeight) {
+        super.restoreEditorViewState(editorViewStates);
+        if (totalHeight !== undefined && this._layoutInfo.layoutState !== CellLayoutState.Measured) {
+            this._layoutInfo = {
+                fontInfo: this._layoutInfo.fontInfo,
+                chatHeight: this._layoutInfo.chatHeight,
+                editorHeight: this._layoutInfo.editorHeight,
+                editorWidth: this._layoutInfo.editorWidth,
+                statusBarHeight: this.layoutInfo.statusBarHeight,
+                commentHeight: this.layoutInfo.commentHeight,
+                outputContainerOffset: this._layoutInfo.outputContainerOffset,
+                outputTotalHeight: this._layoutInfo.outputTotalHeight,
+                outputShowMoreContainerHeight: this._layoutInfo.outputShowMoreContainerHeight,
+                outputShowMoreContainerOffset: this._layoutInfo.outputShowMoreContainerOffset,
+                totalHeight: totalHeight,
+                codeIndicatorHeight: this._layoutInfo.codeIndicatorHeight,
+                outputIndicatorHeight: this._layoutInfo.outputIndicatorHeight,
+                bottomToolbarOffset: this._layoutInfo.bottomToolbarOffset,
+                layoutState: CellLayoutState.FromCache,
+                estimatedHasHorizontalScrolling: this._layoutInfo.estimatedHasHorizontalScrolling
+            };
+        }
+    }
+    getDynamicHeight() {
+        this._onLayoutInfoRead.fire();
+        return this._layoutInfo.totalHeight;
+    }
+    getHeight(lineHeight) {
+        if (this._layoutInfo.layoutState === CellLayoutState.Uninitialized) {
+            const estimate = this.estimateEditorHeight(lineHeight);
+            return this.computeTotalHeight(estimate.editorHeight, 0, 0, 0);
+        }
+        else {
+            return this._layoutInfo.totalHeight;
+        }
+    }
+    estimateEditorHeight(lineHeight = 20) {
+        let hasHorizontalScrolling = false;
+        const cellEditorOptions = this.viewContext.getBaseCellEditorOptions(this.language);
+        if (this.layoutInfo.fontInfo && cellEditorOptions.value.wordWrap === 'off') {
+            for (let i = 0; i < this.lineCount; i++) {
+                const max = this.textBuffer.getLineLastNonWhitespaceColumn(i + 1);
+                const estimatedWidth = max * (this.layoutInfo.fontInfo.typicalHalfwidthCharacterWidth + this.layoutInfo.fontInfo.letterSpacing);
+                if (estimatedWidth > this.layoutInfo.editorWidth) {
+                    hasHorizontalScrolling = true;
+                    break;
+                }
+            }
+        }
+        const verticalScrollbarHeight = hasHorizontalScrolling ? 12 : 0;
+        const editorPadding = this.viewContext.notebookOptions.computeEditorPadding(this.internalMetadata, this.uri);
+        const editorHeight = this.lineCount * lineHeight
+            + editorPadding.top
+            + editorPadding.bottom
+            + verticalScrollbarHeight;
+        return {
+            editorHeight,
+            hasHorizontalScrolling
+        };
+    }
+    computeTotalHeight(editorHeight, outputsTotalHeight, outputShowMoreContainerHeight, chatHeight) {
+        const layoutConfiguration = this.viewContext.notebookOptions.getLayoutConfiguration();
+        const { bottomToolbarGap } = this.viewContext.notebookOptions.computeBottomToolbarDimensions(this.viewType);
+        return layoutConfiguration.editorToolbarHeight
+            + layoutConfiguration.cellTopMargin
+            + chatHeight
+            + editorHeight
+            + this.viewContext.notebookOptions.computeEditorStatusbarHeight(this.internalMetadata, this.uri)
+            + this._commentHeight
+            + outputsTotalHeight
+            + outputShowMoreContainerHeight
+            + bottomToolbarGap
+            + layoutConfiguration.cellBottomMargin;
+    }
+    onDidChangeTextModelContent() {
+        if (this.getEditState() !== CellEditState.Editing) {
+            this.updateEditState(CellEditState.Editing, 'onDidChangeTextModelContent');
+            this._onDidChangeState.fire({ contentChanged: true });
+        }
+    }
+    onDeselect() {
+        this.updateEditState(CellEditState.Preview, 'onDeselect');
+    }
+    updateOutputShowMoreContainerHeight(height) {
+        this.layoutChange({ outputShowMoreContainerHeight: height }, 'CodeCellViewModel#updateOutputShowMoreContainerHeight');
+    }
+    updateOutputMinHeight(height) {
+        this.outputMinHeight = height;
+    }
+    unlockOutputHeight() {
+        this.outputMinHeight = 0;
+        this.layoutChange({ outputHeight: true });
+    }
+    updateOutputHeight(index, height, source) {
+        if (index >= this._outputCollection.length) {
+            throw new Error('Output index out of range!');
+        }
+        this._ensureOutputsTop();
+        if (height < 28 && this._outputViewModels[index].hasMultiMimeType()) {
+            height = 28;
+        }
+        this._outputCollection[index] = height;
+        if (this._outputsTop.setValue(index, height)) {
+            this.layoutChange({ outputHeight: true }, source);
+        }
+    }
+    getOutputOffsetInContainer(index) {
+        this._ensureOutputsTop();
+        if (index >= this._outputCollection.length) {
+            throw new Error('Output index out of range!');
+        }
+        return this._outputsTop.getPrefixSum(index - 1);
+    }
+    getOutputOffset(index) {
+        return this.layoutInfo.outputContainerOffset + this.getOutputOffsetInContainer(index);
+    }
+    spliceOutputHeights(start, deleteCnt, heights) {
+        this._ensureOutputsTop();
+        this._outputsTop.removeValues(start, deleteCnt);
+        if (heights.length) {
+            const values = ( new Uint32Array(heights.length));
+            for (let i = 0; i < heights.length; i++) {
+                values[i] = heights[i];
+            }
+            this._outputsTop.insertValues(start, values);
+        }
+        this.layoutChange({ outputHeight: true }, 'CodeCellViewModel#spliceOutputs');
+    }
+    _ensureOutputsTop() {
+        if (!this._outputsTop) {
+            const values = ( new Uint32Array(this._outputCollection.length));
+            for (let i = 0; i < this._outputCollection.length; i++) {
+                values[i] = this._outputCollection[i];
+            }
+            this._outputsTop = ( new PrefixSumComputer(values));
+        }
+    }
+    startFind(value, options) {
+        const matches = super.cellStartFind(value, options);
+        if (matches === null) {
+            return null;
+        }
+        return {
+            cell: this,
+            contentMatches: matches
+        };
+    }
+    dispose() {
+        super.dispose();
+        this._outputCollection = [];
+        this._outputsTop = null;
+        dispose(this._outputViewModels);
+    }
+};
+CodeCellViewModel = ( __decorate([
+    ( __param(4, IConfigurationService)),
+    ( __param(5, INotebookService)),
+    ( __param(6, ITextModelService)),
+    ( __param(7, IUndoRedoService)),
+    ( __param(8, ICodeEditorService))
+], CodeCellViewModel));
+export { CodeCellViewModel, outputDisplayLimit };

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

@@ -0,0 +1,31 @@
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { NotebookViewEventType } from '../notebookViewEvents.js';
+class NotebookEventDispatcher extends Disposable {
+    constructor() {
+        super(...arguments);
+        this._onDidChangeLayout = this._register(( new Emitter()));
+        this.onDidChangeLayout = this._onDidChangeLayout.event;
+        this._onDidChangeMetadata = this._register(( new Emitter()));
+        this.onDidChangeMetadata = this._onDidChangeMetadata.event;
+        this._onDidChangeCellState = this._register(( new Emitter()));
+        this.onDidChangeCellState = this._onDidChangeCellState.event;
+    }
+    emit(events) {
+        for (let i = 0, len = events.length; i < len; i++) {
+            const e = events[i];
+            switch (e.type) {
+                case NotebookViewEventType.LayoutChanged:
+                    this._onDidChangeLayout.fire(e);
+                    break;
+                case NotebookViewEventType.MetadataChanged:
+                    this._onDidChangeMetadata.fire(e);
+                    break;
+                case NotebookViewEventType.CellStateChanged:
+                    this._onDidChangeCellState.fire(e);
+                    break;
+            }
+        }
+    }
+}
+export { NotebookEventDispatcher };