@codingame/monaco-vscode-notebook-service-override 13.1.7 → 14.0.0

package/vscode/src/vs/workbench/contrib/notebook/browser/contrib/chatEdit/notebookCellDecorators.js

@@ -0,0 +1,536 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { DisposableStore, toDisposable, Disposable, dispose } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/arrays';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { autorunWithStore, autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/autorun';
+import { derived } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/derived';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
+import { observableFromEvent } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/utils';
+import { ChatEditingSessionState } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatEditingService';
+import { IChatEditingService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatEditingService.service';
+import { ThrottledDelayer } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { IEditorWorkerService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/editorWorker';
+import { ILanguageService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/languages/language';
+import { EditorOption } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/config/editorOptions';
+import { themeColorFromId } from '@codingame/monaco-vscode-api/vscode/vs/base/common/themables';
+import { RenderOptions, LineSource, renderLines } from '@codingame/monaco-vscode-api/vscode/vs/editor/browser/widget/diffEditor/components/diffEditorViewZones/renderLines';
+import { diffAddDecoration, diffWholeLineAddDecoration, diffDeleteDecoration } from '@codingame/monaco-vscode-api/vscode/vs/editor/browser/widget/diffEditor/registrations.contribution';
+import { TrackedRangeStickiness, MinimapPosition, OverviewRulerLane } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/model';
+import { ModelDecorationOptions } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/model/textModel';
+import { InlineDecoration, InlineDecorationType } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/viewModel';
+import { Range } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/range';
+import { tokenizeToString } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/languages/textToHtmlTokenizer';
+import { append, $ } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { createTrustedTypesPolicy } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/trustedTypes';
+import { splitLines } from '@codingame/monaco-vscode-api/vscode/vs/base/common/strings';
+import { DefaultLineHeight } from '@codingame/monaco-vscode-e4d0fd26-1b26-5583-b3f7-582e08d7b389-common/vscode/vs/workbench/contrib/notebook/browser/diff/diffElementViewModel';
+import { INotebookOriginalCellModelFactory } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/browser/contrib/chatEdit/notebookOriginalCellModelFactory.service';
+import { isEqual } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { overviewRulerModifiedForeground, minimapGutterModifiedBackground, overviewRulerAddedForeground, minimapGutterAddedBackground, overviewRulerDeletedForeground, minimapGutterDeletedBackground } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/scm/common/quickDiff';
+
+let NotebookCellDiffDecorator = class NotebookCellDiffDecorator extends DisposableStore {
+    constructor(notebookEditor, modifiedCell, originalCell, _chatEditingService, _editorWorkerService, originalCellModelFactory) {
+        super();
+        this.modifiedCell = modifiedCell;
+        this.originalCell = originalCell;
+        this._chatEditingService = _chatEditingService;
+        this._editorWorkerService = _editorWorkerService;
+        this.originalCellModelFactory = originalCellModelFactory;
+        this._viewZones = [];
+        this.throttledDecorator = ( new ThrottledDelayer(50));
+        this.perEditorDisposables = this.add(( new DisposableStore()));
+        const onDidChangeVisibleRanges = observableFromEvent(notebookEditor.onDidChangeVisibleRanges, () => notebookEditor.visibleRanges);
+        const editorObs = derived((r) => {
+            const visibleRanges = onDidChangeVisibleRanges.read(r);
+            const visibleCellHandles = ( ( visibleRanges.map(range => notebookEditor.getCellsInRange(range))).flat().map(c => c.handle));
+            if (!visibleCellHandles.includes(modifiedCell.handle)) {
+                return;
+            }
+            const editor = notebookEditor.codeEditors.find(item => item[0].handle === modifiedCell.handle)?.[1];
+            if (editor?.getModel() !== this.modifiedCell.textModel) {
+                return;
+            }
+            return editor;
+        });
+        this.add(autorunWithStore((r, store) => {
+            const editor = editorObs.read(r);
+            this.perEditorDisposables.clear();
+            if (editor) {
+                store.add(editor.onDidChangeModel(() => {
+                    this.perEditorDisposables.clear();
+                }));
+                store.add(editor.onDidChangeModelContent(() => {
+                    this.update(editor);
+                }));
+                store.add(editor.onDidChangeConfiguration((e) => {
+                    if (e.hasChanged(EditorOption.fontInfo) || e.hasChanged(EditorOption.lineHeight)) {
+                        this.update(editor);
+                    }
+                }));
+                this.update(editor);
+            }
+        }));
+        const shouldBeReadOnly = derived(this, r => {
+            const editor = editorObs.read(r);
+            if (!editor) {
+                return false;
+            }
+            const value = this._chatEditingService.currentEditingSessionObs.read(r);
+            if (!value || value.state.read(r) !== ChatEditingSessionState.StreamingEdits) {
+                return false;
+            }
+            return ( value.entries.read(r).some(e => isEqual(e.modifiedURI, editor.getModel()?.uri)));
+        });
+        let actualReadonly;
+        let actualDeco;
+        this.add(autorun((r) => {
+            const editor = editorObs.read(r);
+            if (!editor) {
+                return;
+            }
+            const value = shouldBeReadOnly.read(r);
+            if (value) {
+                actualReadonly ??= editor.getOption(EditorOption.readOnly);
+                actualDeco ??= editor.getOption(EditorOption.renderValidationDecorations);
+                editor.updateOptions({
+                    readOnly: true,
+                    renderValidationDecorations: 'off'
+                });
+            }
+            else {
+                if (actualReadonly !== undefined && actualDeco !== undefined) {
+                    editor.updateOptions({
+                        readOnly: actualReadonly,
+                        renderValidationDecorations: actualDeco
+                    });
+                    actualReadonly = undefined;
+                    actualDeco = undefined;
+                }
+            }
+        }));
+    }
+    update(editor) {
+        this.throttledDecorator.trigger(() => this._updateImpl(editor));
+    }
+    async _updateImpl(editor) {
+        if (this.isDisposed) {
+            return;
+        }
+        if (editor.getOption(EditorOption.inDiffEditor)) {
+            this.perEditorDisposables.clear();
+            return;
+        }
+        const model = editor.getModel();
+        if (!model || model !== this.modifiedCell.textModel) {
+            this.perEditorDisposables.clear();
+            return;
+        }
+        const originalModel = this.getOrCreateOriginalModel(editor);
+        if (!originalModel) {
+            this.perEditorDisposables.clear();
+            return;
+        }
+        const version = model.getVersionId();
+        const diff = await this._editorWorkerService.computeDiff(originalModel.uri, model.uri, { computeMoves: true, ignoreTrimWhitespace: false, maxComputationTimeMs: Number.MAX_SAFE_INTEGER }, 'advanced');
+        if (this.isDisposed) {
+            return;
+        }
+        if (diff && !diff.identical && originalModel && model === editor.getModel() && editor.getModel()?.getVersionId() === version) {
+            this._updateWithDiff(editor, originalModel, diff);
+        }
+        else {
+            this.perEditorDisposables.clear();
+        }
+    }
+    getOrCreateOriginalModel(editor) {
+        if (!this._originalModel) {
+            const model = editor.getModel();
+            if (!model) {
+                return;
+            }
+            this._originalModel = this.add(this.originalCellModelFactory.getOrCreate(model.uri, this.originalCell.getValue(), model.getLanguageId(), this.modifiedCell.cellKind)).object;
+        }
+        return this._originalModel;
+    }
+    _updateWithDiff(editor, originalModel, diff) {
+        if (areDiffsEqual(diff, this.diffForPreviouslyAppliedDecorators)) {
+            return;
+        }
+        this.perEditorDisposables.clear();
+        const decorations = editor.createDecorationsCollection();
+        this.perEditorDisposables.add(toDisposable(() => {
+            editor.changeViewZones((viewZoneChangeAccessor) => {
+                for (const id of this._viewZones) {
+                    viewZoneChangeAccessor.removeZone(id);
+                }
+            });
+            this._viewZones = [];
+            decorations.clear();
+            this.diffForPreviouslyAppliedDecorators = undefined;
+        }));
+        this.diffForPreviouslyAppliedDecorators = diff;
+        const chatDiffAddDecoration = ModelDecorationOptions.createDynamic({
+            ...diffAddDecoration,
+            stickiness: TrackedRangeStickiness.NeverGrowsWhenTypingAtEdges
+        });
+        const chatDiffWholeLineAddDecoration = ModelDecorationOptions.createDynamic({
+            ...diffWholeLineAddDecoration,
+            stickiness: TrackedRangeStickiness.NeverGrowsWhenTypingAtEdges,
+        });
+        const createOverviewDecoration = (overviewRulerColor, minimapColor) => {
+            return ModelDecorationOptions.createDynamic({
+                description: 'chat-editing-decoration',
+                overviewRuler: { color: themeColorFromId(overviewRulerColor), position: OverviewRulerLane.Left },
+                minimap: { color: themeColorFromId(minimapColor), position: MinimapPosition.Gutter },
+            });
+        };
+        const modifiedDecoration = createOverviewDecoration(overviewRulerModifiedForeground, minimapGutterModifiedBackground);
+        const addedDecoration = createOverviewDecoration(overviewRulerAddedForeground, minimapGutterAddedBackground);
+        const deletedDecoration = createOverviewDecoration(overviewRulerDeletedForeground, minimapGutterDeletedBackground);
+        editor.changeViewZones((viewZoneChangeAccessor) => {
+            for (const id of this._viewZones) {
+                viewZoneChangeAccessor.removeZone(id);
+            }
+            this._viewZones = [];
+            const modifiedDecorations = [];
+            const mightContainNonBasicASCII = originalModel?.mightContainNonBasicASCII();
+            const mightContainRTL = originalModel?.mightContainRTL();
+            const renderOptions = RenderOptions.fromEditor(editor);
+            for (const diffEntry of diff.changes) {
+                const originalRange = diffEntry.original;
+                if (originalModel) {
+                    originalModel.tokenization.forceTokenization(Math.max(1, originalRange.endLineNumberExclusive - 1));
+                }
+                const source = ( new LineSource(
+                    (originalRange.length && originalModel) ? originalRange.mapToLineArray(l => originalModel.tokenization.getLineTokens(l)) : [],
+                    [],
+                    mightContainNonBasicASCII,
+                    mightContainRTL
+                ));
+                const decorations = [];
+                for (const i of diffEntry.innerChanges || []) {
+                    decorations.push(( new InlineDecoration(
+                        i.originalRange.delta(-(diffEntry.original.startLineNumber - 1)),
+                        diffDeleteDecoration.className,
+                        InlineDecorationType.Regular
+                    )));
+                    modifiedDecorations.push({
+                        range: i.modifiedRange, options: chatDiffAddDecoration
+                    });
+                }
+                if (!diffEntry.modified.isEmpty) {
+                    modifiedDecorations.push({
+                        range: diffEntry.modified.toInclusiveRange(), options: chatDiffWholeLineAddDecoration
+                    });
+                }
+                if (diffEntry.original.isEmpty) {
+                    modifiedDecorations.push({
+                        range: diffEntry.modified.toInclusiveRange(),
+                        options: addedDecoration
+                    });
+                }
+                else if (diffEntry.modified.isEmpty) {
+                    modifiedDecorations.push({
+                        range: ( new Range(
+                            diffEntry.modified.startLineNumber - 1,
+                            1,
+                            diffEntry.modified.startLineNumber,
+                            1
+                        )),
+                        options: deletedDecoration
+                    });
+                }
+                else {
+                    modifiedDecorations.push({
+                        range: diffEntry.modified.toInclusiveRange(),
+                        options: modifiedDecoration
+                    });
+                }
+                const domNode = document.createElement('div');
+                domNode.className = 'chat-editing-original-zone view-lines line-delete monaco-mouse-cursor-text';
+                const result = renderLines(source, renderOptions, decorations, domNode);
+                const isCreatedContent = decorations.length === 1 && decorations[0].range.isEmpty() && decorations[0].range.startLineNumber === 1;
+                if (!isCreatedContent) {
+                    const viewZoneData = {
+                        afterLineNumber: diffEntry.modified.startLineNumber - 1,
+                        heightInLines: result.heightInLines,
+                        domNode,
+                        ordinal: 50000 + 2
+                    };
+                    this._viewZones.push(viewZoneChangeAccessor.addZone(viewZoneData));
+                }
+            }
+            decorations.set(modifiedDecorations);
+        });
+    }
+};
+NotebookCellDiffDecorator = ( __decorate([
+    ( __param(3, IChatEditingService)),
+    ( __param(4, IEditorWorkerService)),
+    ( __param(5, INotebookOriginalCellModelFactory))
+], NotebookCellDiffDecorator));
+class NotebookInsertedCellDecorator extends Disposable {
+    constructor(notebookEditor) {
+        super();
+        this.notebookEditor = notebookEditor;
+        this.decorators = this._register(( new DisposableStore()));
+    }
+    apply(diffInfo) {
+        const model = this.notebookEditor.textModel;
+        if (!model) {
+            return;
+        }
+        const cells = ( diffInfo.filter(diff => diff.type === 'insert').map((diff) => model.cells[diff.modifiedCellIndex]));
+        const ids = this.notebookEditor.deltaCellDecorations([], ( cells.map(cell => ({
+            handle: cell.handle,
+            options: { className: 'nb-insertHighlight', outputClassName: 'nb-insertHighlight' }
+        }))));
+        this.clear();
+        this.decorators.add(toDisposable(() => {
+            if (!this.notebookEditor.isDisposed) {
+                this.notebookEditor.deltaCellDecorations(ids, []);
+            }
+        }));
+    }
+    clear() {
+        this.decorators.clear();
+    }
+}
+const ttPolicy = createTrustedTypesPolicy('notebookChatEditController', { createHTML: value => value });
+let NotebookDeletedCellDecorator = class NotebookDeletedCellDecorator extends Disposable {
+    constructor(_notebookEditor, languageService) {
+        super();
+        this._notebookEditor = _notebookEditor;
+        this.languageService = languageService;
+        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;
+        }
+        const cells = this._notebookEditor.getCellsInRange({ start: info.previousIndex, end: info.previousIndex + 1 });
+        if (!cells.length) {
+            return;
+        }
+        const cell = cells[0];
+        const cellHeight = this._notebookEditor.getHeightOfElement(cell);
+        const top = this._notebookEditor.getAbsoluteTopOfElement(cell);
+        return top + cellHeight + info.offset;
+    }
+    apply(diffInfo, original) {
+        this.clear();
+        let currentIndex = 0;
+        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 = document.createElement('div');
+        const widgets = [];
+        const heights = await Promise.all(( cells.map(async (cell) => {
+            const widget = ( new NotebookDeletedCellWidget(
+                this._notebookEditor,
+                cell.cell.getValue(),
+                cell.cell.language,
+                rootContainer,
+                cell.originalIndex,
+                this.languageService
+            ));
+            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);
+            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);
+                    });
+                }
+            }));
+        });
+    }
+};
+NotebookDeletedCellDecorator = ( __decorate([
+    ( __param(1, ILanguageService))
+], NotebookDeletedCellDecorator));
+let NotebookDeletedCellWidget = class NotebookDeletedCellWidget extends Disposable {
+    constructor(_notebookEditor,
+    code, language, container, originalIndex, languageService) {
+        super();
+        this._notebookEditor = _notebookEditor;
+        this.code = code;
+        this.language = language;
+        this.originalIndex = originalIndex;
+        this.languageService = languageService;
+        this.container = append(container, document.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');
+        const container = append(rootContainer, $('.cell-inner-container'));
+        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(5, ILanguageService))
+], NotebookDeletedCellWidget));
+function areDiffsEqual(a, b) {
+    if (a && b) {
+        if (a.changes.length !== b.changes.length) {
+            return false;
+        }
+        if (a.moves.length !== b.moves.length) {
+            return false;
+        }
+        if (!areLineRangeMappinsEqual(a.changes, b.changes)) {
+            return false;
+        }
+        if (!( a.moves.some((move, i) => {
+            const bMove = b.moves[i];
+            if (!areLineRangeMappinsEqual(move.changes, bMove.changes)) {
+                return true;
+            }
+            if (move.lineRangeMapping.changedLineCount !== bMove.lineRangeMapping.changedLineCount) {
+                return true;
+            }
+            if (!move.lineRangeMapping.modified.equals(bMove.lineRangeMapping.modified)) {
+                return true;
+            }
+            if (!move.lineRangeMapping.original.equals(bMove.lineRangeMapping.original)) {
+                return true;
+            }
+            return false;
+        }))) {
+            return false;
+        }
+        return true;
+    }
+    else if (!a && !b) {
+        return true;
+    }
+    else {
+        return false;
+    }
+}
+function areLineRangeMappinsEqual(a, b) {
+    if (a.length !== b.length) {
+        return false;
+    }
+    if (( a.some((c, i) => {
+        const bChange = b[i];
+        if (c.changedLineCount !== bChange.changedLineCount) {
+            return true;
+        }
+        if ((c.innerChanges || []).length !== (bChange.innerChanges || []).length) {
+            return true;
+        }
+        if (( (c.innerChanges || []).some((innerC, innerIdx) => {
+            const bInnerC = bChange.innerChanges[innerIdx];
+            if (!innerC.modifiedRange.equalsRange(bInnerC.modifiedRange)) {
+                return true;
+            }
+            if (!innerC.originalRange.equalsRange(bInnerC.originalRange)) {
+                return true;
+            }
+            return false;
+        }))) {
+            return true;
+        }
+        return false;
+    }))) {
+        return false;
+    }
+    return true;
+}
+
+export { NotebookCellDiffDecorator, NotebookDeletedCellDecorator, NotebookDeletedCellWidget, NotebookInsertedCellDecorator };

package/vscode/src/vs/workbench/contrib/notebook/browser/contrib/chatEdit/notebookChatActionsOverlay.d.ts

@@ -0,0 +1,24 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { INotebookEditor } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/browser/notebookBrowser";
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { IModifiedFileEntry } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatEditingService";
+import { IChatEditingService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatEditingService.service";
+import { IEditorService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service";
+import { IObservable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/observable";
+import { CellDiffInfo } from "@codingame/monaco-vscode-e4d0fd26-1b26-5583-b3f7-582e08d7b389-common/vscode/vs/workbench/contrib/notebook/browser/diff/notebookDiffViewModel";
+import { INotebookDeletedCellDecorator } from "./notebookCellDecorators.js";
+export declare class NotebookChatActionsOverlayController extends Disposable {
+    private readonly notebookEditor;
+    private readonly _chatEditingService;
+    constructor(notebookEditor: INotebookEditor, cellDiffInfo: IObservable<CellDiffInfo[] | undefined>, deletedCellDecorator: INotebookDeletedCellDecorator, _chatEditingService: IChatEditingService, instantiationService: IInstantiationService);
+}
+export declare class NotebookChatActionsOverlay extends Disposable {
+    private readonly notebookEditor;
+    private readonly _editorService;
+    private readonly focusedDiff;
+    private readonly toolbarNode;
+    private added;
+    constructor(notebookEditor: INotebookEditor, entry: IModifiedFileEntry, cellDiffInfo: IObservable<CellDiffInfo[] | undefined>, nextEntry: IModifiedFileEntry, previousEntry: IModifiedFileEntry, deletedCellDecorator: INotebookDeletedCellDecorator, _editorService: IEditorService, instaService: IInstantiationService);
+    private show;
+    private hide;
+}