@codingame/monaco-vscode-api 32.0.2 → 33.0.3

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

@@ -0,0 +1,51 @@
+import { Disposable } from "../../../../../../base/common/lifecycle.js";
+import { ILanguageService } from "../../../../../../editor/common/languages/language.service.js";
+import { NotebookTextModel } from "@codingame/monaco-vscode-notebook-service-override/vscode/vs/workbench/contrib/notebook/common/model/notebookTextModel";
+import { CellDiffInfo } from "../notebookDiffViewModel.js";
+import { INotebookEditor } from "../../notebookBrowser.js";
+import { MenuId } from "../../../../../../platform/actions/common/actions.js";
+import { IInstantiationService } from "../../../../../../platform/instantiation/common/instantiation.js";
+import { IActionViewItemProvider } from "../../../../../../base/browser/ui/actionbar/actionbar.js";
+export interface INotebookDeletedCellDecorator {
+    getTop(deletedIndex: number): number | undefined;
+}
+export declare class NotebookDeletedCellDecorator extends Disposable implements INotebookDeletedCellDecorator {
+    private readonly _notebookEditor;
+    private readonly toolbar;
+    private readonly languageService;
+    private readonly instantiationService;
+    private readonly zoneRemover;
+    private readonly createdViewZones;
+    private readonly deletedCellInfos;
+    constructor(_notebookEditor: INotebookEditor, toolbar: {
+        menuId: MenuId;
+        className: string;
+        telemetrySource?: string;
+        argFactory: (deletedCellIndex: number) => any;
+        actionViewItemProvider?: IActionViewItemProvider;
+    } | undefined, languageService: ILanguageService, instantiationService: IInstantiationService);
+    getTop(deletedIndex: number): number | undefined;
+    reveal(deletedIndex: number): void;
+    apply(diffInfo: CellDiffInfo[], original: NotebookTextModel): void;
+    clear(): void;
+    private _createWidget;
+    private _createWidgetImpl;
+}
+export declare class NotebookDeletedCellWidget extends Disposable {
+    private readonly _notebookEditor;
+    private readonly _toolbarOptions;
+    private readonly code;
+    private readonly language;
+    private readonly _originalIndex;
+    private readonly languageService;
+    private readonly instantiationService;
+    private readonly container;
+    constructor(_notebookEditor: INotebookEditor, _toolbarOptions: {
+        menuId: MenuId;
+        className: string;
+        telemetrySource?: string;
+        argFactory: (deletedCellIndex: number) => any;
+        actionViewItemProvider?: IActionViewItemProvider;
+    } | undefined, code: string, language: string, container: HTMLElement, _originalIndex: number, languageService: ILanguageService, instantiationService: IInstantiationService);
+    render(): Promise<number>;
+}

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

@@ -0,0 +1,265 @@
+
+import { __decorate, __param } from '../../../../../../../../../external/tslib/tslib.es6.js';
+import { createTrustedTypesPolicy } from '../../../../../../base/browser/trustedTypes.js';
+import { Disposable, DisposableStore, toDisposable, dispose } from '../../../../../../base/common/lifecycle.js';
+import { splitLines } from '../../../../../../base/common/strings.js';
+import { EditorOption } from '../../../../../../editor/common/config/editorOptions.js';
+import { ILanguageService } from '../../../../../../editor/common/languages/language.service.js';
+import { tokenizeToString } from '../../../../../../editor/common/languages/textToHtmlTokenizer.js';
+import { DefaultLineHeight } from '../diffElementViewModel.js';
+import { NotebookOverviewRulerLane } from '../../notebookBrowser.js';
+import { createElement, append, $ } from '../../../../../../base/browser/dom.js';
+import { MenuWorkbenchToolBar, HiddenItemStrategy } from '../../../../../../platform/actions/browser/toolbar.js';
+import { IInstantiationService } from '../../../../../../platform/instantiation/common/instantiation.js';
+import { ServiceCollection } from '../../../../../../platform/instantiation/common/serviceCollection.js';
+import { IContextKeyService } from '../../../../../../platform/contextkey/common/contextkey.service.js';
+import { overviewRulerDeletedForeground } from '../../../../scm/common/quickDiff.js';
+
+const ttPolicy = createTrustedTypesPolicy("notebookRenderer", {
+    createHTML: value => value
+});
+let NotebookDeletedCellDecorator = class NotebookDeletedCellDecorator extends Disposable {
+    constructor(_notebookEditor, toolbar, languageService, instantiationService) {
+        super();
+        this._notebookEditor = _notebookEditor;
+        this.toolbar = toolbar;
+        this.languageService = languageService;
+        this.instantiationService = instantiationService;
+        this.zoneRemover = this._register(( new DisposableStore()));
+        this.createdViewZones = ( new Map());
+        this.deletedCellInfos = ( new Map());
+    }
+    getTop(deletedIndex) {
+        const info = this.deletedCellInfos.get(deletedIndex);
+        if (!info) {
+            return;
+        }
+        if (info.previousIndex === -1) {
+            return 0;
+        }
+        const cells = this._notebookEditor.getCellsInRange({
+            start: info.previousIndex,
+            end: info.previousIndex + 1
+        });
+        if (!cells.length) {
+            return this._notebookEditor.getLayoutInfo().height + info.offset;
+        }
+        const cell = cells[0];
+        const cellHeight = this._notebookEditor.getHeightOfElement(cell);
+        const top = this._notebookEditor.getAbsoluteTopOfElement(cell);
+        return top + cellHeight + info.offset;
+    }
+    reveal(deletedIndex) {
+        const top = this.getTop(deletedIndex);
+        if (typeof top === "number") {
+            this._notebookEditor.focusContainer();
+            this._notebookEditor.revealOffsetInCenterIfOutsideViewport(top);
+            const info = this.deletedCellInfos.get(deletedIndex);
+            if (info) {
+                const prevIndex = info.previousIndex === -1 ? 0 : info.previousIndex;
+                this._notebookEditor.setFocus({
+                    start: prevIndex,
+                    end: prevIndex
+                });
+                this._notebookEditor.setSelections([{
+                    start: prevIndex,
+                    end: prevIndex
+                }]);
+            }
+        }
+    }
+    apply(diffInfo, original) {
+        this.clear();
+        let currentIndex = -1;
+        const deletedCellsToRender = {
+            cells: [],
+            index: 0
+        };
+        diffInfo.forEach(diff => {
+            if (diff.type === "delete") {
+                const deletedCell = original.cells[diff.originalCellIndex];
+                if (deletedCell) {
+                    deletedCellsToRender.cells.push({
+                        cell: deletedCell,
+                        originalIndex: diff.originalCellIndex,
+                        previousIndex: currentIndex
+                    });
+                    deletedCellsToRender.index = currentIndex;
+                }
+            } else {
+                if (deletedCellsToRender.cells.length) {
+                    this._createWidget(deletedCellsToRender.index + 1, deletedCellsToRender.cells);
+                    deletedCellsToRender.cells.length = 0;
+                }
+                currentIndex = diff.modifiedCellIndex;
+            }
+        });
+        if (deletedCellsToRender.cells.length) {
+            this._createWidget(deletedCellsToRender.index + 1, deletedCellsToRender.cells);
+        }
+    }
+    clear() {
+        this.deletedCellInfos.clear();
+        this.zoneRemover.clear();
+    }
+    _createWidget(index, cells) {
+        this._createWidgetImpl(index, cells);
+    }
+    async _createWidgetImpl(index, cells) {
+        const rootContainer = createElement("div");
+        const widgets = [];
+        const heights = await Promise.all(( cells.map(async cell => {
+            const widget = ( new NotebookDeletedCellWidget(
+                this._notebookEditor,
+                this.toolbar,
+                cell.cell.getValue(),
+                cell.cell.language,
+                rootContainer,
+                cell.originalIndex,
+                this.languageService,
+                this.instantiationService
+            ));
+            widgets.push(widget);
+            const height = await widget.render();
+            this.deletedCellInfos.set(cell.originalIndex, {
+                height,
+                previousIndex: cell.previousIndex,
+                offset: 0
+            });
+            return height;
+        })));
+        Array.from(( this.deletedCellInfos.keys())).sort((a, b) => a - b).forEach(originalIndex => {
+            const previousDeletedCell = this.deletedCellInfos.get(originalIndex - 1);
+            if (previousDeletedCell) {
+                const deletedCell = this.deletedCellInfos.get(originalIndex);
+                if (deletedCell) {
+                    deletedCell.offset = previousDeletedCell.height + previousDeletedCell.offset;
+                }
+            }
+        });
+        const totalHeight = heights.reduce((prev, curr) => prev + curr, 0);
+        this._notebookEditor.changeViewZones(accessor => {
+            const notebookViewZone = {
+                afterModelPosition: index,
+                heightInPx: totalHeight + 4,
+                domNode: rootContainer
+            };
+            const id = accessor.addZone(notebookViewZone);
+            accessor.layoutZone(id);
+            this.createdViewZones.set(index, id);
+            const deletedCellOverviewRulereDecorationIds = this._notebookEditor.deltaCellDecorations([], [{
+                viewZoneId: id,
+                options: {
+                    overviewRuler: {
+                        color: overviewRulerDeletedForeground,
+                        position: NotebookOverviewRulerLane.Center
+                    }
+                }
+            }]);
+            this.zoneRemover.add(toDisposable(() => {
+                if (this.createdViewZones.get(index) === id) {
+                    this.createdViewZones.delete(index);
+                }
+                if (!this._notebookEditor.isDisposed) {
+                    this._notebookEditor.changeViewZones(accessor => {
+                        accessor.removeZone(id);
+                        dispose(widgets);
+                    });
+                    this._notebookEditor.deltaCellDecorations(deletedCellOverviewRulereDecorationIds, []);
+                }
+            }));
+        });
+    }
+};
+NotebookDeletedCellDecorator = ( __decorate([( __param(2, ILanguageService)), ( __param(3, IInstantiationService))], NotebookDeletedCellDecorator));
+let NotebookDeletedCellWidget = class NotebookDeletedCellWidget extends Disposable {
+    constructor(
+        _notebookEditor,
+        _toolbarOptions,
+        code,
+        language,
+        container,
+        _originalIndex,
+        languageService,
+        instantiationService
+    ) {
+        super();
+        this._notebookEditor = _notebookEditor;
+        this._toolbarOptions = _toolbarOptions;
+        this.code = code;
+        this.language = language;
+        this._originalIndex = _originalIndex;
+        this.languageService = languageService;
+        this.instantiationService = instantiationService;
+        this.container = append(container, createElement("div"));
+        this._register(toDisposable(() => {
+            container.removeChild(this.container);
+        }));
+    }
+    async render() {
+        const code = this.code;
+        const languageId = this.language;
+        const codeHtml = await tokenizeToString(this.languageService, code, languageId);
+        const fontInfo = this._notebookEditor.getBaseCellEditorOptions(languageId).value;
+        const fontFamilyVar = "--notebook-editor-font-family";
+        const fontSizeVar = "--notebook-editor-font-size";
+        const fontWeightVar = "--notebook-editor-font-weight";
+        const editor = ( this._notebookEditor.codeEditors.map(c => c[1])).find(c => c);
+        const layoutInfo = editor?.getOptions().get(EditorOption.layoutInfo);
+        const style = `` + `font-family: var(${fontFamilyVar});` + `font-weight: var(${fontWeightVar});` + `font-size: var(${fontSizeVar});` + fontInfo.lineHeight ? `line-height: ${fontInfo.lineHeight}px;` : "" + layoutInfo?.contentLeft ? `margin-left: ${layoutInfo}px;` : "" + `white-space: pre;`;
+        const rootContainer = this.container;
+        rootContainer.classList.add("code-cell-row");
+        if (this._toolbarOptions) {
+            const toolbar = createElement("div");
+            toolbar.className = this._toolbarOptions.className;
+            rootContainer.appendChild(toolbar);
+            const scopedInstaService = this._register(this.instantiationService.createChild(( new ServiceCollection([IContextKeyService, this._notebookEditor.scopedContextKeyService]))));
+            const toolbarWidget = scopedInstaService.createInstance(MenuWorkbenchToolBar, toolbar, this._toolbarOptions.menuId, {
+                telemetrySource: this._toolbarOptions.telemetrySource,
+                hiddenItemStrategy: HiddenItemStrategy.NoHide,
+                toolbarOptions: {
+                    primaryGroup: () => true
+                },
+                menuOptions: {
+                    renderShortTitle: true,
+                    arg: this._toolbarOptions.argFactory(this._originalIndex)
+                },
+                actionViewItemProvider: this._toolbarOptions.actionViewItemProvider
+            });
+            this._store.add(toolbarWidget);
+            toolbar.style.position = "absolute";
+            toolbar.style.right = "40px";
+            toolbar.style.zIndex = "10";
+            toolbar.classList.add("hover");
+        }
+        const container = append(rootContainer, $(".cell-inner-container"));
+        container.style.position = "relative";
+        const focusIndicatorLeft = append(container, $(
+            ".cell-focus-indicator.cell-focus-indicator-side.cell-focus-indicator-left"
+        ));
+        const cellContainer = append(container, $(".cell.code"));
+        append(focusIndicatorLeft, $("div.execution-count-label"));
+        const editorPart = append(cellContainer, $(".cell-editor-part"));
+        let editorContainer = append(editorPart, $(".cell-editor-container"));
+        editorContainer = append(editorContainer, $(".code", {
+            style
+        }));
+        if (fontInfo.fontFamily) {
+            editorContainer.style.setProperty(fontFamilyVar, fontInfo.fontFamily);
+        }
+        if (fontInfo.fontSize) {
+            editorContainer.style.setProperty(fontSizeVar, `${fontInfo.fontSize}px`);
+        }
+        if (fontInfo.fontWeight) {
+            editorContainer.style.setProperty(fontWeightVar, fontInfo.fontWeight);
+        }
+        editorContainer.innerHTML = (ttPolicy?.createHTML(codeHtml) || codeHtml);
+        const lineCount = splitLines(code).length;
+        const height = (lineCount * (fontInfo.lineHeight || DefaultLineHeight)) + 12 + 12;
+        const totalHeight = height + 16 + 16;
+        return totalHeight;
+    }
+};
+NotebookDeletedCellWidget = ( __decorate([( __param(6, ILanguageService)), ( __param(7, IInstantiationService))], NotebookDeletedCellWidget));
+
+export { NotebookDeletedCellDecorator, NotebookDeletedCellWidget };

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

@@ -0,0 +1,24 @@
+import { Disposable } from "../../../../../../base/common/lifecycle.js";
+import { IInstantiationService } from "../../../../../../platform/instantiation/common/instantiation.js";
+import { INotebookEditorWorkerService } from "../../../common/services/notebookWorkerService.service.js";
+import { INotebookEditorContribution, INotebookEditor } from "../../notebookBrowser.js";
+import { INotebookLoggingService } from "../../../common/notebookLoggingService.service.js";
+export declare class NotebookInlineDiffDecorationContribution extends Disposable implements INotebookEditorContribution {
+    private readonly notebookEditor;
+    private readonly notebookEditorWorkerService;
+    private readonly instantiationService;
+    private readonly logService;
+    static ID: string;
+    private previous?;
+    private insertedCellDecorator;
+    private deletedCellDecorator;
+    private readonly cellDecorators;
+    private cachedNotebookDiff?;
+    private listeners;
+    constructor(notebookEditor: INotebookEditor, notebookEditorWorkerService: INotebookEditorWorkerService, instantiationService: IInstantiationService, logService: INotebookLoggingService);
+    private clear;
+    dispose(): void;
+    private initialize;
+    private _update;
+    private updateCells;
+}

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

@@ -0,0 +1,185 @@
+
+import { __decorate, __param } from '../../../../../../../../../external/tslib/tslib.es6.js';
+import { Event } from '../../../../../../base/common/event.js';
+import { Disposable } from '../../../../../../base/common/lifecycle.js';
+import '../../../../../../base/common/observableInternal/index.js';
+import { IInstantiationService } from '../../../../../../platform/instantiation/common/instantiation.js';
+import { INotebookEditorWorkerService } from '../../../common/services/notebookWorkerService.service.js';
+import { registerNotebookContribution } from '../../notebookEditorExtensions.js';
+import { NotebookCellDiffDecorator } from './notebookCellDiffDecorator.js';
+import { NotebookDeletedCellDecorator } from './notebookDeletedCellDecorator.js';
+import { NotebookInsertedCellDecorator } from './notebookInsertedCellDecorator.js';
+import { INotebookLoggingService } from '../../../common/notebookLoggingService.service.js';
+import { computeDiff } from '../../../common/notebookDiff.js';
+import '../../../../../../platform/instantiation/common/extensions.js';
+import './notebookOriginalModelRefFactory.js';
+import './notebookOriginalCellModelFactory.js';
+import { autorun } from '../../../../../../base/common/observableInternal/reactions/autorun.js';
+
+let NotebookInlineDiffDecorationContribution = class NotebookInlineDiffDecorationContribution extends Disposable {
+    static {
+        this.ID = "workbench.notebook.inlineDiffDecoration";
+    }
+    constructor(
+        notebookEditor,
+        notebookEditorWorkerService,
+        instantiationService,
+        logService
+    ) {
+        super();
+        this.notebookEditor = notebookEditor;
+        this.notebookEditorWorkerService = notebookEditorWorkerService;
+        this.instantiationService = instantiationService;
+        this.logService = logService;
+        this.cellDecorators = ( new Map());
+        this.listeners = [];
+        this.logService.debug("inlineDiff", "Watching for previous model");
+        this._register(autorun(reader => {
+            this.previous = this.notebookEditor.notebookOptions.previousModelToCompare.read(reader);
+            if (this.previous) {
+                this.logService.debug("inlineDiff", "Previous model set");
+                if (this.notebookEditor.hasModel()) {
+                    this.initialize();
+                } else {
+                    this.logService.debug("inlineDiff", "Waiting for model to attach");
+                    this.listeners.push(
+                        Event.once(this.notebookEditor.onDidAttachViewModel)(() => this.initialize())
+                    );
+                }
+            }
+        }));
+    }
+    clear() {
+        this.listeners.forEach(l => l.dispose());
+        this.cellDecorators.forEach((v, cell) => {
+            v.dispose();
+            this.cellDecorators.delete(cell);
+        });
+        this.insertedCellDecorator?.dispose();
+        this.deletedCellDecorator?.dispose();
+        this.cachedNotebookDiff = undefined;
+        this.listeners = [];
+        this.logService.debug("inlineDiff", "Cleared decorations and listeners");
+    }
+    dispose() {
+        this.logService.debug("inlineDiff", "Disposing");
+        this.clear();
+        super.dispose();
+    }
+    initialize() {
+        this.clear();
+        if (!this.previous) {
+            return;
+        }
+        this.insertedCellDecorator = this.instantiationService.createInstance(NotebookInsertedCellDecorator, this.notebookEditor);
+        this.deletedCellDecorator = this.instantiationService.createInstance(NotebookDeletedCellDecorator, this.notebookEditor, undefined);
+        this._update();
+        const onVisibleChange = Event.debounce(
+            this.notebookEditor.onDidChangeVisibleRanges,
+            e => e,
+            100,
+            undefined,
+            undefined,
+            undefined,
+            this._store
+        );
+        this.listeners.push(onVisibleChange(() => this._update()));
+        this.listeners.push(this.notebookEditor.onDidChangeModel(() => this._update()));
+        if (this.notebookEditor.textModel) {
+            const onContentChange = Event.debounce(
+                this.notebookEditor.textModel.onDidChangeContent,
+                (_, event) => event,
+                100,
+                undefined,
+                undefined,
+                undefined,
+                this._store
+            );
+            const onOriginalContentChange = Event.debounce(
+                this.previous.onDidChangeContent,
+                (_, event) => event,
+                100,
+                undefined,
+                undefined,
+                undefined,
+                this._store
+            );
+            this.listeners.push(onContentChange(() => this._update()));
+            this.listeners.push(onOriginalContentChange(() => this._update()));
+        }
+        this.logService.debug("inlineDiff", "Initialized");
+    }
+    async _update() {
+        const current = this.notebookEditor.getViewModel()?.notebookDocument;
+        if (!this.previous || !current) {
+            this.logService.debug("inlineDiff", "Update skipped - no original or current document");
+            return;
+        }
+        if (!this.cachedNotebookDiff || this.cachedNotebookDiff.originalVersion !== this.previous.versionId || this.cachedNotebookDiff.version !== current.versionId) {
+            let diffInfo = {
+                cellDiffInfo: []
+            };
+            try {
+                const notebookDiff = await this.notebookEditorWorkerService.computeDiff(this.previous.uri, current.uri);
+                diffInfo = computeDiff(this.previous, current, notebookDiff);
+            } catch (e) {
+                this.logService.error("inlineDiff", "Error computing diff:\n" + e);
+                return;
+            }
+            this.cachedNotebookDiff = {
+                cellDiffInfo: diffInfo.cellDiffInfo,
+                originalVersion: this.previous.versionId,
+                version: current.versionId
+            };
+            this.insertedCellDecorator?.apply(diffInfo.cellDiffInfo);
+            this.deletedCellDecorator?.apply(diffInfo.cellDiffInfo, this.previous);
+        }
+        await this.updateCells(this.previous, current, this.cachedNotebookDiff.cellDiffInfo);
+    }
+    async updateCells(original, modified, cellDiffs) {
+        const validDiffDecorators = ( new Set());
+        cellDiffs.forEach(diff => {
+            if (diff.type === "modified") {
+                const modifiedCell = modified.cells[diff.modifiedCellIndex];
+                const originalCell = original.cells[diff.originalCellIndex];
+                const editor = this.notebookEditor.codeEditors.find(([vm]) => vm.handle === modifiedCell.handle)?.[1];
+                if (editor) {
+                    const currentDecorator = this.cellDecorators.get(modifiedCell);
+                    if ((currentDecorator?.modifiedCell !== modifiedCell || currentDecorator?.originalCell !== originalCell)) {
+                        currentDecorator?.dispose();
+                        const decorator = this.instantiationService.createInstance(
+                            NotebookCellDiffDecorator,
+                            this.notebookEditor,
+                            modifiedCell,
+                            originalCell,
+                            editor
+                        );
+                        this.cellDecorators.set(modifiedCell, decorator);
+                        validDiffDecorators.add(decorator);
+                        this._register(editor.onDidDispose(() => {
+                            decorator.dispose();
+                            if (this.cellDecorators.get(modifiedCell) === decorator) {
+                                this.cellDecorators.delete(modifiedCell);
+                            }
+                        }));
+                    } else if (currentDecorator) {
+                        validDiffDecorators.add(currentDecorator);
+                    }
+                }
+            }
+        });
+        this.cellDecorators.forEach((v, cell) => {
+            if (!( validDiffDecorators.has(v))) {
+                v.dispose();
+                this.cellDecorators.delete(cell);
+            }
+        });
+    }
+};
+NotebookInlineDiffDecorationContribution = ( __decorate([( __param(1, INotebookEditorWorkerService)), ( __param(2, IInstantiationService)), ( __param(3, INotebookLoggingService))], NotebookInlineDiffDecorationContribution));
+registerNotebookContribution(
+    NotebookInlineDiffDecorationContribution.ID,
+    NotebookInlineDiffDecorationContribution
+);
+
+export { NotebookInlineDiffDecorationContribution };

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

@@ -0,0 +1,28 @@
+import * as DOM from "../../../../../../base/browser/dom.js";
+import { CodeWindow } from "../../../../../../base/browser/window.js";
+import { Disposable } from "../../../../../../base/common/lifecycle.js";
+import { IInstantiationService } from "../../../../../../platform/instantiation/common/instantiation.js";
+import { NotebookTextModel } from "@codingame/monaco-vscode-notebook-service-override/vscode/vs/workbench/contrib/notebook/common/model/notebookTextModel";
+import { NotebookDiffEditorInput } from "@codingame/monaco-vscode-notebook-service-override/vscode/vs/workbench/contrib/notebook/common/notebookDiffEditorInput";
+import { INotebookEditorOptions } from "../../notebookBrowser.js";
+import { NotebookEditorWidget } from "../../notebookEditorWidget.js";
+import { NotebookOptions } from "../../notebookOptions.js";
+import { INotebookEditorService } from "../../services/notebookEditorService.service.js";
+export declare class NotebookInlineDiffWidget extends Disposable {
+    private readonly rootElement;
+    private readonly groupId;
+    private readonly window;
+    private readonly options;
+    private dimension;
+    private readonly instantiationService;
+    private readonly widgetService;
+    private widget;
+    private position;
+    get editorWidget(): NotebookEditorWidget | undefined;
+    constructor(rootElement: HTMLElement, groupId: number, window: CodeWindow, options: NotebookOptions, dimension: DOM.Dimension | undefined, instantiationService: IInstantiationService, widgetService: INotebookEditorService);
+    show(input: NotebookDiffEditorInput, model: NotebookTextModel | undefined, previousModel: NotebookTextModel | undefined, options: INotebookEditorOptions | undefined): Promise<void>;
+    hide(): void;
+    setLayout(dimension: DOM.Dimension, position: DOM.IDomPosition): void;
+    private createNotebookWidget;
+    dispose(): void;
+}

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

@@ -0,0 +1,104 @@
+
+import { __decorate, __param } from '../../../../../../../../../external/tslib/tslib.es6.js';
+import { setParentFlowTo } from '../../../../../../base/browser/dom.js';
+import { Disposable } from '../../../../../../base/common/lifecycle.js';
+import { EditorExtensionsRegistry } from '../../../../../../editor/browser/editorExtensions.js';
+import { MenuId } from '../../../../../../platform/actions/common/actions.js';
+import { IInstantiationService } from '../../../../../../platform/instantiation/common/instantiation.js';
+import { NotebookInlineDiffDecorationContribution } from './notebookInlineDiff.js';
+import { NotebookEditorExtensionsRegistry } from '../../notebookEditorExtensions.js';
+import { INotebookEditorService } from '../../services/notebookEditorService.service.js';
+
+let NotebookInlineDiffWidget = class NotebookInlineDiffWidget extends Disposable {
+    get editorWidget() {
+        return this.widget.value;
+    }
+    constructor(
+        rootElement,
+        groupId,
+        window,
+        options,
+        dimension,
+        instantiationService,
+        widgetService
+    ) {
+        super();
+        this.rootElement = rootElement;
+        this.groupId = groupId;
+        this.window = window;
+        this.options = options;
+        this.dimension = dimension;
+        this.instantiationService = instantiationService;
+        this.widgetService = widgetService;
+        this.widget = {
+            value: undefined
+        };
+    }
+    async show(input, model, previousModel, options) {
+        if (!this.widget.value) {
+            this.createNotebookWidget(input, this.groupId, this.rootElement);
+        }
+        if (this.dimension) {
+            this.widget.value?.layout(this.dimension, this.rootElement, this.position);
+        }
+        if (model) {
+            await this.widget.value?.setOptions({
+                ...options
+            });
+            this.widget.value?.notebookOptions.previousModelToCompare.set(previousModel, undefined);
+            await this.widget.value.setModel(model, options?.viewState);
+        }
+    }
+    hide() {
+        if (this.widget.value) {
+            this.widget.value.notebookOptions.previousModelToCompare.set(undefined, undefined);
+            this.widget.value.onWillHide();
+        }
+    }
+    setLayout(dimension, position) {
+        this.dimension = dimension;
+        this.position = position;
+    }
+    createNotebookWidget(input, groupId, rootElement) {
+        const contributions = NotebookEditorExtensionsRegistry.getSomeEditorContributions([NotebookInlineDiffDecorationContribution.ID]);
+        const menuIds = {
+            notebookToolbar: MenuId.NotebookToolbar,
+            cellTitleToolbar: MenuId.NotebookCellTitle,
+            cellDeleteToolbar: MenuId.NotebookCellDelete,
+            cellInsertToolbar: MenuId.NotebookCellBetween,
+            cellTopInsertToolbar: MenuId.NotebookCellListTop,
+            cellExecuteToolbar: MenuId.NotebookCellExecute,
+            cellExecutePrimary: undefined
+        };
+        const skipContributions = [
+            "editor.contrib.review",
+            "editor.contrib.floatingClickMenu",
+            "editor.contrib.dirtydiff",
+            "editor.contrib.testingOutputPeek",
+            "editor.contrib.testingDecorations",
+            "store.contrib.stickyScrollController",
+            "editor.contrib.findController",
+            "editor.contrib.emptyTextEditorHint"
+        ];
+        const cellEditorContributions = EditorExtensionsRegistry.getEditorContributions().filter(c => skipContributions.indexOf(c.id) === -1);
+        this.widget = this.instantiationService.invokeFunction(this.widgetService.retrieveWidget, groupId, input, {
+            contributions,
+            menuIds,
+            cellEditorContributions,
+            options: this.options
+        }, this.dimension, this.window);
+        if (this.rootElement && this.widget.value.getDomNode()) {
+            this.rootElement.setAttribute("aria-flowto", this.widget.value.getDomNode().id || "");
+            setParentFlowTo(this.widget.value.getDomNode(), this.rootElement);
+        }
+    }
+    dispose() {
+        super.dispose();
+        if (this.widget.value) {
+            this.widget.value.dispose();
+        }
+    }
+};
+NotebookInlineDiffWidget = ( __decorate([( __param(5, IInstantiationService)), ( __param(6, INotebookEditorService))], NotebookInlineDiffWidget));
+
+export { NotebookInlineDiffWidget };

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

@@ -0,0 +1,10 @@
+import { Disposable } from "../../../../../../base/common/lifecycle.js";
+import { CellDiffInfo } from "../notebookDiffViewModel.js";
+import { INotebookEditor } from "../../notebookBrowser.js";
+export declare class NotebookInsertedCellDecorator extends Disposable {
+    private readonly notebookEditor;
+    private readonly decorators;
+    constructor(notebookEditor: INotebookEditor);
+    apply(diffInfo: CellDiffInfo[]): void;
+    clear(): void;
+}