@codingame/monaco-vscode-api 33.0.3 → 33.0.5

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

@@ -1,51 +0,0 @@
-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

@@ -1,265 +0,0 @@
-
-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

@@ -1,24 +0,0 @@
-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

@@ -1,185 +0,0 @@
-
-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

@@ -1,28 +0,0 @@
-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

@@ -1,104 +0,0 @@
-
-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

@@ -1,10 +0,0 @@
-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;
-}