@codingame/monaco-vscode-api 32.0.2 → 33.0.3

package/vscode/src/vs/workbench/contrib/notebook/browser/diff/diffElementOutputs.d.ts

@@ -0,0 +1,50 @@
+import { Disposable, DisposableStore } from "../../../../../base/common/lifecycle.js";
+import { DiffElementCellViewModelBase } from "./diffElementViewModel.js";
+import { DiffSide, INotebookTextDiffEditor } from "./notebookDiffEditorBrowser.js";
+import { ICellOutputViewModel, IInsetRenderOutput } from "../notebookBrowser.js";
+import { NotebookTextModel } from "@codingame/monaco-vscode-notebook-service-override/vscode/vs/workbench/contrib/notebook/common/model/notebookTextModel";
+import { INotebookService } from "../../common/notebookService.service.js";
+import { DiffNestedCellViewModel } from "./diffNestedCellViewModel.js";
+import { IQuickInputService } from "../../../../../platform/quickinput/common/quickInput.service.js";
+export declare class OutputElement extends Disposable {
+    private _notebookEditor;
+    private _notebookTextModel;
+    private _notebookService;
+    private _quickInputService;
+    private _diffElementViewModel;
+    private _diffSide;
+    private _nestedCell;
+    private _outputContainer;
+    readonly output: ICellOutputViewModel;
+    readonly resizeListener: DisposableStore;
+    domNode: HTMLElement;
+    renderResult?: IInsetRenderOutput;
+    constructor(_notebookEditor: INotebookTextDiffEditor, _notebookTextModel: NotebookTextModel, _notebookService: INotebookService, _quickInputService: IQuickInputService, _diffElementViewModel: DiffElementCellViewModelBase, _diffSide: DiffSide, _nestedCell: DiffNestedCellViewModel, _outputContainer: HTMLElement, output: ICellOutputViewModel);
+    render(index: number, beforeElement?: HTMLElement): void;
+    private _renderMissingRenderer;
+    private _renderSearchForMimetype;
+    private _renderMessage;
+    private pickActiveMimeTypeRenderer;
+    private generateRendererInfo;
+    getCellOutputCurrentIndex(): number;
+    updateHeight(index: number, height: number): void;
+    getOutputOffsetInContainer(index: number): number;
+    getOutputOffsetInCell(index: number): number;
+}
+export declare class OutputContainer extends Disposable {
+    private _editor;
+    private _notebookTextModel;
+    private _diffElementViewModel;
+    private _nestedCellViewModel;
+    private _diffSide;
+    private _outputContainer;
+    private _notebookService;
+    private readonly _quickInputService;
+    private _outputEntries;
+    constructor(_editor: INotebookTextDiffEditor, _notebookTextModel: NotebookTextModel, _diffElementViewModel: DiffElementCellViewModelBase, _nestedCellViewModel: DiffNestedCellViewModel, _diffSide: DiffSide, _outputContainer: HTMLElement, _notebookService: INotebookService, _quickInputService: IQuickInputService);
+    private _updateOutputs;
+    render(): void;
+    showOutputs(): void;
+    hideOutputs(): void;
+    private _renderOutput;
+}

package/vscode/src/vs/workbench/contrib/notebook/browser/diff/diffElementOutputs.js

@@ -0,0 +1,314 @@
+
+import { __decorate, __param } from '../../../../../../../../external/tslib/tslib.es6.js';
+import { createElement, $, addStandardDisposableListener, addDisposableListener, EventType, append } from '../../../../../base/browser/dom.js';
+import { localize } from '../../../../../nls.js';
+import { Disposable, DisposableStore } from '../../../../../base/common/lifecycle.js';
+import { SideBySideDiffElementViewModel } from './diffElementViewModel.js';
+import { DiffSide } from './notebookDiffEditorBrowser.js';
+import { RenderOutputType } from '../notebookBrowser.js';
+import { INotebookService } from '../../common/notebookService.service.js';
+import { ThemeIcon } from '../../../../../base/common/themables.js';
+import { mimetypeIcon } from '../notebookIcons.js';
+import { StandardKeyboardEvent } from '../../../../../base/browser/keyboardEvent.js';
+import { KeyCode } from '../../../../../base/common/keyCodes.js';
+import { IQuickInputService } from '../../../../../platform/quickinput/common/quickInput.service.js';
+
+class OutputElement extends Disposable {
+    constructor(
+        _notebookEditor,
+        _notebookTextModel,
+        _notebookService,
+        _quickInputService,
+        _diffElementViewModel,
+        _diffSide,
+        _nestedCell,
+        _outputContainer,
+        output
+    ) {
+        super();
+        this._notebookEditor = _notebookEditor;
+        this._notebookTextModel = _notebookTextModel;
+        this._notebookService = _notebookService;
+        this._quickInputService = _quickInputService;
+        this._diffElementViewModel = _diffElementViewModel;
+        this._diffSide = _diffSide;
+        this._nestedCell = _nestedCell;
+        this._outputContainer = _outputContainer;
+        this.output = output;
+        this.resizeListener = this._register(( new DisposableStore()));
+    }
+    render(index, beforeElement) {
+        const outputItemDiv = createElement("div");
+        let result = undefined;
+        const [mimeTypes, pick] = this.output.resolveMimeTypes(this._notebookTextModel, undefined);
+        const pickedMimeTypeRenderer = this.output.pickedMimeType || mimeTypes[pick];
+        if (mimeTypes.length > 1) {
+            outputItemDiv.style.position = "relative";
+            const mimeTypePicker = $(".multi-mimetype-output");
+            mimeTypePicker.classList.add(...ThemeIcon.asClassNameArray(mimetypeIcon));
+            mimeTypePicker.tabIndex = 0;
+            mimeTypePicker.title = ( localize(
+                11792,
+                "Choose a different output mimetype, available mimetypes: {0}",
+                ( mimeTypes.map(mimeType => mimeType.mimeType)).join(", ")
+            ));
+            outputItemDiv.appendChild(mimeTypePicker);
+            this.resizeListener.add(
+                addStandardDisposableListener(mimeTypePicker, "mousedown", async e => {
+                    if (e.leftButton) {
+                        e.preventDefault();
+                        e.stopPropagation();
+                        await this.pickActiveMimeTypeRenderer(this._notebookTextModel, this.output);
+                    }
+                })
+            );
+            this.resizeListener.add(
+                (addDisposableListener(mimeTypePicker, EventType.KEY_DOWN, async e => {
+                    const event = ( new StandardKeyboardEvent(e));
+                    if ((event.equals(KeyCode.Enter) || event.equals(KeyCode.Space))) {
+                        e.preventDefault();
+                        e.stopPropagation();
+                        await this.pickActiveMimeTypeRenderer(this._notebookTextModel, this.output);
+                    }
+                }))
+            );
+        }
+        const innerContainer = $(".output-inner-container");
+        append(outputItemDiv, innerContainer);
+        if (mimeTypes.length !== 0) {
+            const renderer = this._notebookService.getRendererInfo(pickedMimeTypeRenderer.rendererId);
+            result = renderer ? {
+                type: RenderOutputType.Extension,
+                renderer,
+                source: this.output,
+                mimeType: pickedMimeTypeRenderer.mimeType
+            } : this._renderMissingRenderer(this.output, pickedMimeTypeRenderer.mimeType);
+            this.output.pickedMimeType = pickedMimeTypeRenderer;
+        }
+        this.domNode = outputItemDiv;
+        this.renderResult = result;
+        if (!result) {
+            return;
+        }
+        if (beforeElement) {
+            this._outputContainer.insertBefore(outputItemDiv, beforeElement);
+        } else {
+            this._outputContainer.appendChild(outputItemDiv);
+        }
+        this._notebookEditor.createOutput(
+            this._diffElementViewModel,
+            this._nestedCell,
+            result,
+            () => this.getOutputOffsetInCell(index),
+            this._diffElementViewModel instanceof SideBySideDiffElementViewModel ? this._diffSide : this._diffElementViewModel.type === "insert" ? DiffSide.Modified : DiffSide.Original
+        );
+    }
+    _renderMissingRenderer(viewModel, preferredMimeType) {
+        if (!viewModel.model.outputs.length) {
+            return this._renderMessage(viewModel, ( localize(11793, "Cell has no output")));
+        }
+        if (!preferredMimeType) {
+            const mimeTypes = ( viewModel.model.outputs.map(op => op.mime));
+            const mimeTypesMessage = mimeTypes.join(", ");
+            return this._renderMessage(viewModel, ( localize(
+                11794,
+                "No renderer could be found for output. It has the following mimetypes: {0}",
+                mimeTypesMessage
+            )));
+        }
+        return this._renderSearchForMimetype(viewModel, preferredMimeType);
+    }
+    _renderSearchForMimetype(viewModel, mimeType) {
+        const query = `@tag:notebookRenderer ${mimeType}`;
+        const p = $(
+            "p",
+            undefined,
+            `No renderer could be found for mimetype "${mimeType}", but one might be available on the Marketplace.`
+        );
+        const a = $("a", {
+            href: `command:workbench.extensions.search?%22${query}%22`,
+            class: "monaco-button monaco-text-button",
+            tabindex: 0,
+            role: "button",
+            style: "padding: 8px; text-decoration: none; color: rgb(255, 255, 255); background-color: rgb(14, 99, 156); max-width: 200px;"
+        }, `Search Marketplace`);
+        return {
+            type: RenderOutputType.Html,
+            source: viewModel,
+            htmlContent: p.outerHTML + a.outerHTML
+        };
+    }
+    _renderMessage(viewModel, message) {
+        const el = $("p", undefined, message);
+        return {
+            type: RenderOutputType.Html,
+            source: viewModel,
+            htmlContent: el.outerHTML
+        };
+    }
+    async pickActiveMimeTypeRenderer(notebookTextModel, viewModel) {
+        const [mimeTypes, currIndex] = viewModel.resolveMimeTypes(notebookTextModel, undefined);
+        const items = ( mimeTypes.filter(mimeType => mimeType.isTrusted).map((mimeType, index) => ({
+            label: mimeType.mimeType,
+            id: mimeType.mimeType,
+            index: index,
+            picked: index === currIndex,
+            detail: this.generateRendererInfo(mimeType.rendererId),
+            description: index === currIndex ? ( localize(11795, "Currently Active")) : undefined
+        })));
+        const disposables = ( new DisposableStore());
+        const picker = disposables.add(this._quickInputService.createQuickPick());
+        picker.items = items;
+        picker.activeItems = items.filter(item => !!item.picked);
+        picker.placeholder = items.length !== mimeTypes.length ? ( localize(
+            11796,
+            "Select mimetype to render for current output. Rich mimetypes are available only when the notebook is trusted"
+        )) : ( localize(11797, "Select mimetype to render for current output"));
+        const pick = await ( new Promise(resolve => {
+            disposables.add(picker.onDidAccept(() => {
+                resolve(
+                    picker.selectedItems.length === 1 ? picker.selectedItems[0].index : undefined
+                );
+                disposables.dispose();
+            }));
+            picker.show();
+        }));
+        if (pick === undefined) {
+            return;
+        }
+        if (pick !== currIndex) {
+            const index = this._nestedCell.outputsViewModels.indexOf(viewModel);
+            const nextElement = this.domNode.nextElementSibling;
+            this.resizeListener.clear();
+            const element = this.domNode;
+            if (element) {
+                element.remove();
+                this._notebookEditor.removeInset(this._diffElementViewModel, this._nestedCell, viewModel, this._diffSide);
+            }
+            viewModel.pickedMimeType = mimeTypes[pick];
+            this.render(index, nextElement);
+        }
+    }
+    generateRendererInfo(renderId) {
+        const renderInfo = this._notebookService.getRendererInfo(renderId);
+        if (renderInfo) {
+            const displayName = renderInfo.displayName !== "" ? renderInfo.displayName : renderInfo.id;
+            return `${displayName} (${renderInfo.extensionId.value})`;
+        }
+        return localize(11798, "built-in");
+    }
+    getCellOutputCurrentIndex() {
+        return this._diffElementViewModel.getNestedCellViewModel(this._diffSide).outputs.indexOf(this.output.model);
+    }
+    updateHeight(index, height) {
+        this._diffElementViewModel.updateOutputHeight(this._diffSide, index, height);
+    }
+    getOutputOffsetInContainer(index) {
+        return this._diffElementViewModel.getOutputOffsetInContainer(this._diffSide, index);
+    }
+    getOutputOffsetInCell(index) {
+        return this._diffElementViewModel.getOutputOffsetInCell(this._diffSide, index);
+    }
+}
+let OutputContainer = class OutputContainer extends Disposable {
+    constructor(
+        _editor,
+        _notebookTextModel,
+        _diffElementViewModel,
+        _nestedCellViewModel,
+        _diffSide,
+        _outputContainer,
+        _notebookService,
+        _quickInputService
+    ) {
+        super();
+        this._editor = _editor;
+        this._notebookTextModel = _notebookTextModel;
+        this._diffElementViewModel = _diffElementViewModel;
+        this._nestedCellViewModel = _nestedCellViewModel;
+        this._diffSide = _diffSide;
+        this._outputContainer = _outputContainer;
+        this._notebookService = _notebookService;
+        this._quickInputService = _quickInputService;
+        this._outputEntries = ( new Map());
+        this._register(this._diffElementViewModel.onDidLayoutChange(() => {
+            this._outputEntries.forEach((value, key) => {
+                const index = _nestedCellViewModel.outputs.indexOf(key.model);
+                if (index >= 0) {
+                    const top = this._diffElementViewModel.getOutputOffsetInContainer(this._diffSide, index);
+                    value.domNode.style.top = `${top}px`;
+                }
+            });
+        }));
+        this._register(this._nestedCellViewModel.textModel.onDidChangeOutputs(splice => {
+            this._updateOutputs(splice);
+        }));
+    }
+    _updateOutputs(splice) {
+        const removedKeys = [];
+        this._outputEntries.forEach((value, key) => {
+            if (this._nestedCellViewModel.outputsViewModels.indexOf(key) < 0) {
+                removedKeys.push(key);
+                value.domNode.remove();
+                this._editor.removeInset(this._diffElementViewModel, this._nestedCellViewModel, key, this._diffSide);
+            }
+        });
+        removedKeys.forEach(key => {
+            this._outputEntries.get(key)?.dispose();
+            this._outputEntries.delete(key);
+        });
+        let prevElement = undefined;
+        const outputsToRender = this._nestedCellViewModel.outputsViewModels;
+        outputsToRender.reverse().forEach(output => {
+            if (( this._outputEntries.has(output))) {
+                prevElement = this._outputEntries.get(output).domNode;
+                return;
+            }
+            const currIndex = this._nestedCellViewModel.outputsViewModels.indexOf(output);
+            this._renderOutput(output, currIndex, prevElement);
+            prevElement = this._outputEntries.get(output)?.domNode;
+        });
+    }
+    render() {
+        for (let index = 0; index < this._nestedCellViewModel.outputsViewModels.length; index++) {
+            const currOutput = this._nestedCellViewModel.outputsViewModels[index];
+            this._renderOutput(currOutput, index, undefined);
+        }
+    }
+    showOutputs() {
+        for (let index = 0; index < this._nestedCellViewModel.outputsViewModels.length; index++) {
+            const currOutput = this._nestedCellViewModel.outputsViewModels[index];
+            this._editor.showInset(
+                this._diffElementViewModel,
+                currOutput.cellViewModel,
+                currOutput,
+                this._diffSide
+            );
+        }
+    }
+    hideOutputs() {
+        this._outputEntries.forEach((outputElement, cellOutputViewModel) => {
+            this._editor.hideInset(this._diffElementViewModel, this._nestedCellViewModel, cellOutputViewModel);
+        });
+    }
+    _renderOutput(currOutput, index, beforeElement) {
+        if (!( this._outputEntries.has(currOutput))) {
+            this._outputEntries.set(currOutput, ( new OutputElement(
+                this._editor,
+                this._notebookTextModel,
+                this._notebookService,
+                this._quickInputService,
+                this._diffElementViewModel,
+                this._diffSide,
+                this._nestedCellViewModel,
+                this._outputContainer,
+                currOutput
+            )));
+        }
+        const renderElement = this._outputEntries.get(currOutput);
+        renderElement.render(index, beforeElement);
+    }
+};
+OutputContainer = ( __decorate([( __param(6, INotebookService)), ( __param(7, IQuickInputService))], OutputContainer));
+
+export { OutputContainer, OutputElement };

package/vscode/src/vs/workbench/contrib/notebook/browser/diff/diffElementViewModel.d.ts

@@ -0,0 +1,258 @@
+import { Emitter } from "../../../../../base/common/event.js";
+import { Disposable } from "../../../../../base/common/lifecycle.js";
+import { URI } from "../../../../../base/common/uri.js";
+import { FontInfo } from "../../../../../editor/common/config/fontInfo.js";
+import * as editorCommon from "../../../../../editor/common/editorCommon.js";
+import { DiffNestedCellViewModel } from "./diffNestedCellViewModel.js";
+import { NotebookDiffEditorEventDispatcher } from "./eventDispatcher.js";
+import { CellDiffViewModelLayoutChangeEvent, DiffSide, IDiffElementLayoutInfo } from "./notebookDiffEditorBrowser.js";
+import { IGenericCellViewModel } from "../notebookBrowser.js";
+import { NotebookLayoutInfo } from "../notebookViewEvents.js";
+import { NotebookCellTextModel } from "../../common/model/notebookCellTextModel.js";
+import { NotebookTextModel } from "@codingame/monaco-vscode-notebook-service-override/vscode/vs/workbench/contrib/notebook/common/model/notebookTextModel";
+import { ICellOutput, INotebookTextModel, IOutputDto, IOutputItemDto } from "../../common/notebookCommon.js";
+import { INotebookService } from "../../common/notebookService.service.js";
+import { IConfigurationService } from "../../../../../platform/configuration/common/configuration.service.js";
+import { IDiffEditorHeightCalculatorService } from "./editorHeightCalculator.js";
+import { NotebookDocumentMetadataTextModel } from "../../common/model/notebookMetadataTextModel.js";
+export declare const HeightOfHiddenLinesRegionInDiffEditor = 24;
+export declare const DefaultLineHeight = 17;
+export declare enum PropertyFoldingState {
+    Expanded = 0,
+    Collapsed = 1
+}
+export declare const OUTPUT_EDITOR_HEIGHT_MAGIC = 1440;
+type ILayoutInfoDelta0 = {
+    [K in keyof IDiffElementLayoutInfo]?: number;
+};
+interface ILayoutInfoDelta extends ILayoutInfoDelta0 {
+    rawOutputHeight?: number;
+    recomputeOutput?: boolean;
+}
+export type IDiffElementViewModelBase = DiffElementCellViewModelBase | DiffElementPlaceholderViewModel | NotebookDocumentMetadataViewModel;
+export declare abstract class DiffElementViewModelBase extends Disposable {
+    readonly mainDocumentTextModel: INotebookTextModel;
+    readonly editorEventDispatcher: NotebookDiffEditorEventDispatcher;
+    readonly initData: {
+        metadataStatusHeight: number;
+        outputStatusHeight: number;
+        fontInfo: FontInfo | undefined;
+    };
+    protected _layoutInfoEmitter: Emitter<CellDiffViewModelLayoutChangeEvent>;
+    onDidLayoutChange: import("../../../../../base/common/event.js").Event<CellDiffViewModelLayoutChangeEvent>;
+    abstract renderOutput: boolean;
+    constructor(mainDocumentTextModel: INotebookTextModel, editorEventDispatcher: NotebookDiffEditorEventDispatcher, initData: {
+        metadataStatusHeight: number;
+        outputStatusHeight: number;
+        fontInfo: FontInfo | undefined;
+    });
+    abstract layoutChange(): void;
+    abstract getHeight(lineHeight: number): number;
+    abstract get totalHeight(): number;
+}
+export declare class DiffElementPlaceholderViewModel extends DiffElementViewModelBase {
+    readonly type: "placeholder";
+    hiddenCells: DiffElementCellViewModelBase[];
+    protected _unfoldHiddenCells: Emitter<void>;
+    onUnfoldHiddenCells: import("../../../../../base/common/event.js").Event<void>;
+    renderOutput: boolean;
+    constructor(mainDocumentTextModel: INotebookTextModel, editorEventDispatcher: NotebookDiffEditorEventDispatcher, initData: {
+        metadataStatusHeight: number;
+        outputStatusHeight: number;
+        fontInfo: FontInfo | undefined;
+    });
+    get totalHeight(): number;
+    getHeight(_: number): number;
+    layoutChange(): void;
+    showHiddenCells(): void;
+}
+export declare class NotebookDocumentMetadataViewModel extends DiffElementViewModelBase {
+    readonly originalDocumentTextModel: INotebookTextModel;
+    readonly modifiedDocumentTextModel: INotebookTextModel;
+    readonly type: "unchangedMetadata" | "modifiedMetadata";
+    private readonly editorHeightCalculator;
+    readonly originalMetadata: NotebookDocumentMetadataTextModel;
+    readonly modifiedMetadata: NotebookDocumentMetadataTextModel;
+    cellFoldingState: PropertyFoldingState;
+    protected _layoutInfo: IDiffElementLayoutInfo;
+    renderOutput: boolean;
+    set editorHeight(height: number);
+    get editorHeight(): number;
+    set editorMargin(margin: number);
+    get editorMargin(): number;
+    get layoutInfo(): IDiffElementLayoutInfo;
+    get totalHeight(): number;
+    private _sourceEditorViewState;
+    constructor(originalDocumentTextModel: INotebookTextModel, modifiedDocumentTextModel: INotebookTextModel, type: "unchangedMetadata" | "modifiedMetadata", editorEventDispatcher: NotebookDiffEditorEventDispatcher, initData: {
+        metadataStatusHeight: number;
+        outputStatusHeight: number;
+        fontInfo: FontInfo | undefined;
+    }, notebookService: INotebookService, editorHeightCalculator: IDiffEditorHeightCalculatorService);
+    computeHeights(): Promise<void>;
+    layoutChange(): void;
+    protected _layout(delta: ILayoutInfoDelta): void;
+    getHeight(lineHeight: number): number;
+    private _computeTotalHeight;
+    computeInputEditorHeight(_lineHeight: number): number;
+    private _fireLayoutChangeEvent;
+    getComputedCellContainerWidth(layoutInfo: NotebookLayoutInfo, diffEditor: boolean, fullWidth: boolean): number;
+    getSourceEditorViewState(): editorCommon.ICodeEditorViewState | editorCommon.IDiffEditorViewState | null;
+    saveSpirceEditorViewState(viewState: editorCommon.ICodeEditorViewState | editorCommon.IDiffEditorViewState | null): void;
+}
+export declare abstract class DiffElementCellViewModelBase extends DiffElementViewModelBase {
+    readonly type: "unchanged" | "insert" | "delete" | "modified";
+    readonly index: number;
+    private readonly configurationService;
+    readonly diffEditorHeightCalculator: IDiffEditorHeightCalculatorService;
+    cellFoldingState: PropertyFoldingState;
+    metadataFoldingState: PropertyFoldingState;
+    outputFoldingState: PropertyFoldingState;
+    protected _stateChangeEmitter: Emitter<{
+        renderOutput: boolean;
+    }>;
+    onDidStateChange: import("../../../../../base/common/event.js").Event<{
+        renderOutput: boolean;
+    }>;
+    protected _layoutInfo: IDiffElementLayoutInfo;
+    displayIconToHideUnmodifiedCells?: boolean;
+    private _hideUnchangedCells;
+    onHideUnchangedCells: import("../../../../../base/common/event.js").Event<void>;
+    hideUnchangedCells(): void;
+    set rawOutputHeight(height: number);
+    get rawOutputHeight(): number;
+    set outputStatusHeight(height: number);
+    get outputStatusHeight(): number;
+    set outputMetadataHeight(height: number);
+    get outputMetadataHeight(): number;
+    set editorHeight(height: number);
+    get editorHeight(): number;
+    set editorMargin(margin: number);
+    get editorMargin(): number;
+    set metadataStatusHeight(height: number);
+    get metadataStatusHeight(): number;
+    set metadataHeight(height: number);
+    get metadataHeight(): number;
+    private _renderOutput;
+    set renderOutput(value: boolean);
+    get renderOutput(): boolean;
+    get layoutInfo(): IDiffElementLayoutInfo;
+    get totalHeight(): number;
+    protected get ignoreOutputs(): boolean;
+    protected get ignoreMetadata(): boolean;
+    private _sourceEditorViewState;
+    private _outputEditorViewState;
+    private _metadataEditorViewState;
+    readonly original: DiffNestedCellViewModel | undefined;
+    readonly modified: DiffNestedCellViewModel | undefined;
+    constructor(mainDocumentTextModel: INotebookTextModel, original: NotebookCellTextModel | undefined, modified: NotebookCellTextModel | undefined, type: "unchanged" | "insert" | "delete" | "modified", editorEventDispatcher: NotebookDiffEditorEventDispatcher, initData: {
+        metadataStatusHeight: number;
+        outputStatusHeight: number;
+        fontInfo: FontInfo | undefined;
+    }, notebookService: INotebookService, index: number, configurationService: IConfigurationService, diffEditorHeightCalculator: IDiffEditorHeightCalculatorService);
+    layoutChange(): void;
+    private _estimateEditorHeight;
+    protected _layout(delta: ILayoutInfoDelta): void;
+    getHeight(lineHeight: number): number;
+    private _computeTotalHeight;
+    computeInputEditorHeight(lineHeight: number): number;
+    private _getOutputTotalHeight;
+    private _fireLayoutChangeEvent;
+    abstract checkIfInputModified(): false | {
+        reason: string | undefined;
+    };
+    abstract checkIfOutputsModified(): false | {
+        reason: string | undefined;
+    };
+    abstract checkMetadataIfModified(): false | {
+        reason: string | undefined;
+    };
+    abstract isOutputEmpty(): boolean;
+    abstract getRichOutputTotalHeight(): number;
+    abstract getCellByUri(cellUri: URI): IGenericCellViewModel;
+    abstract getOutputOffsetInCell(diffSide: DiffSide, index: number): number;
+    abstract getOutputOffsetInContainer(diffSide: DiffSide, index: number): number;
+    abstract updateOutputHeight(diffSide: DiffSide, index: number, height: number): void;
+    abstract getNestedCellViewModel(diffSide: DiffSide): DiffNestedCellViewModel;
+    getComputedCellContainerWidth(layoutInfo: NotebookLayoutInfo, diffEditor: boolean, fullWidth: boolean): number;
+    getOutputEditorViewState(): editorCommon.ICodeEditorViewState | editorCommon.IDiffEditorViewState | null;
+    saveOutputEditorViewState(viewState: editorCommon.ICodeEditorViewState | editorCommon.IDiffEditorViewState | null): void;
+    getMetadataEditorViewState(): editorCommon.ICodeEditorViewState | editorCommon.IDiffEditorViewState | null;
+    saveMetadataEditorViewState(viewState: editorCommon.ICodeEditorViewState | editorCommon.IDiffEditorViewState | null): void;
+    getSourceEditorViewState(): editorCommon.ICodeEditorViewState | editorCommon.IDiffEditorViewState | null;
+    saveSpirceEditorViewState(viewState: editorCommon.ICodeEditorViewState | editorCommon.IDiffEditorViewState | null): void;
+}
+export declare class SideBySideDiffElementViewModel extends DiffElementCellViewModelBase {
+    readonly otherDocumentTextModel: NotebookTextModel;
+    get originalDocument(): NotebookTextModel;
+    get modifiedDocument(): INotebookTextModel;
+    readonly original: DiffNestedCellViewModel;
+    readonly modified: DiffNestedCellViewModel;
+    readonly type: "unchanged" | "modified";
+    /**
+     * The height of the editor when the unchanged lines are collapsed.
+     */
+    private editorHeightWithUnchangedLinesCollapsed?;
+    constructor(mainDocumentTextModel: NotebookTextModel, otherDocumentTextModel: NotebookTextModel, original: NotebookCellTextModel, modified: NotebookCellTextModel, type: "unchanged" | "modified", editorEventDispatcher: NotebookDiffEditorEventDispatcher, initData: {
+        metadataStatusHeight: number;
+        outputStatusHeight: number;
+        fontInfo: FontInfo | undefined;
+    }, notebookService: INotebookService, configurationService: IConfigurationService, index: number, diffEditorHeightCalculator: IDiffEditorHeightCalculatorService);
+    checkIfInputModified(): false | {
+        reason: string | undefined;
+    };
+    checkIfOutputsModified(): false | {
+        reason: string | undefined;
+        kind: OutputComparison;
+    };
+    checkMetadataIfModified(): false | {
+        reason: undefined;
+    };
+    updateOutputHeight(diffSide: DiffSide, index: number, height: number): void;
+    getOutputOffsetInContainer(diffSide: DiffSide, index: number): number;
+    getOutputOffsetInCell(diffSide: DiffSide, index: number): number;
+    isOutputEmpty(): boolean;
+    getRichOutputTotalHeight(): number;
+    getNestedCellViewModel(diffSide: DiffSide): DiffNestedCellViewModel;
+    getCellByUri(cellUri: URI): IGenericCellViewModel;
+    computeInputEditorHeight(lineHeight: number): number;
+    private computeModifiedInputEditorHeight;
+    private computeModifiedMetadataEditorHeight;
+    computeEditorHeights(): Promise<void>;
+}
+export declare class SingleSideDiffElementViewModel extends DiffElementCellViewModelBase {
+    readonly otherDocumentTextModel: NotebookTextModel;
+    get cellViewModel(): DiffNestedCellViewModel;
+    get originalDocument(): NotebookTextModel | INotebookTextModel;
+    get modifiedDocument(): NotebookTextModel | INotebookTextModel;
+    readonly type: "insert" | "delete";
+    constructor(mainDocumentTextModel: NotebookTextModel, otherDocumentTextModel: NotebookTextModel, original: NotebookCellTextModel | undefined, modified: NotebookCellTextModel | undefined, type: "insert" | "delete", editorEventDispatcher: NotebookDiffEditorEventDispatcher, initData: {
+        metadataStatusHeight: number;
+        outputStatusHeight: number;
+        fontInfo: FontInfo | undefined;
+    }, notebookService: INotebookService, configurationService: IConfigurationService, diffEditorHeightCalculator: IDiffEditorHeightCalculatorService, index: number);
+    checkIfInputModified(): false | {
+        reason: string | undefined;
+    };
+    getNestedCellViewModel(diffSide: DiffSide): DiffNestedCellViewModel;
+    checkIfOutputsModified(): false | {
+        reason: string | undefined;
+    };
+    checkMetadataIfModified(): false | {
+        reason: string | undefined;
+    };
+    updateOutputHeight(diffSide: DiffSide, index: number, height: number): void;
+    getOutputOffsetInContainer(diffSide: DiffSide, index: number): number;
+    getOutputOffsetInCell(diffSide: DiffSide, index: number): number;
+    isOutputEmpty(): boolean;
+    getRichOutputTotalHeight(): number;
+    getCellByUri(cellUri: URI): IGenericCellViewModel;
+}
+export declare enum OutputComparison {
+    Unchanged = 0,
+    Metadata = 1,
+    Other = 2
+}
+export declare function outputEqual(a: ICellOutput, b: ICellOutput): OutputComparison;
+export declare function getStreamOutputData(outputs: IOutputItemDto[]): string | null;
+export declare function getFormattedOutputJSON(outputs: IOutputDto[]): string;
+export {};