@codingame/monaco-vscode-a793b3ee-7ba9-5176-a019-30ec806fdd95-common 20.0.0

package/vscode/src/vs/workbench/contrib/inlineChat/browser/inlineChatStrategies.js

@@ -0,0 +1,456 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { WindowIntervalTimer, createElement } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { themeColorFromId, ThemeIcon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/themables';
+import { StableEditorScrollState } from '@codingame/monaco-vscode-api/vscode/vs/editor/browser/stableEditorScroll';
+import { RenderOptions, LineSource, renderLines } from '@codingame/monaco-vscode-api/vscode/vs/editor/browser/widget/diffEditor/components/diffEditorViewZones/renderLines';
+import { LineRange } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/ranges/lineRange';
+import { Range } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/range';
+import { MinimapPosition, OverviewRulerLane, TrackedRangeStickiness } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/model';
+import { ModelDecorationOptions } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/model/textModel';
+import { IEditorWorkerService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/editorWorker.service';
+import { IContextKeyService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service';
+import { Progress } from '@codingame/monaco-vscode-api/vscode/vs/platform/progress/common/progress';
+import { SaveReason } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/editor';
+import { countWords } from '@codingame/monaco-vscode-c2deffc4-ad68-5e63-8f95-9b89e0fc6898-common/vscode/vs/workbench/contrib/chat/common/chatWordCounter';
+import { HunkState } from './inlineChatSession.js';
+import { minimapInlineChatDiffInserted, overviewRulerInlineChatDiffInserted, CTX_INLINE_CHAT_CHANGE_HAS_DIFF, CTX_INLINE_CHAT_CHANGE_SHOWS_DIFF, MENU_INLINE_CHAT_ZONE, ACTION_TOGGLE_DIFF, InlineChatConfigKeys } from '@codingame/monaco-vscode-e28ac690-06d5-5ee9-92d1-02df70296354-common/vscode/vs/workbench/contrib/inlineChat/common/inlineChat';
+import { assertType } from '@codingame/monaco-vscode-api/vscode/vs/base/common/types';
+import { asProgressiveEdit, performAsyncTextEdit } from '@codingame/monaco-vscode-e28ac690-06d5-5ee9-92d1-02df70296354-common/vscode/vs/workbench/contrib/inlineChat/browser/utils';
+import { IAccessibilityService } from '@codingame/monaco-vscode-api/vscode/vs/platform/accessibility/common/accessibility.service';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { ITextFileService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/textfile/common/textfiles.service';
+import { Schemas } from '@codingame/monaco-vscode-api/vscode/vs/base/common/network';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { DefaultChatTextEditor } from '@codingame/monaco-vscode-e28ac690-06d5-5ee9-92d1-02df70296354-common/vscode/vs/workbench/contrib/chat/browser/codeBlockPart';
+import { isEqual } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { Iterable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/iterator';
+import { ConflictActionsFactory } from '@codingame/monaco-vscode-6db1b967-5327-5c5c-8c17-bd92774c0fb2-common/vscode/vs/workbench/contrib/mergeEditor/browser/view/conflictActions';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { MenuItemAction } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions';
+import { IMenuService } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions.service';
+import { InlineDecoration, InlineDecorationType } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/viewModel/inlineDecorations';
+import { observableValue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableValue';
+
+var HunkAction;
+(function (HunkAction) {
+    HunkAction[HunkAction["Accept"] = 0] = "Accept";
+    HunkAction[HunkAction["Discard"] = 1] = "Discard";
+    HunkAction[HunkAction["MoveNext"] = 2] = "MoveNext";
+    HunkAction[HunkAction["MovePrev"] = 3] = "MovePrev";
+    HunkAction[HunkAction["ToggleDiff"] = 4] = "ToggleDiff";
+})(HunkAction || (HunkAction = {}));
+let LiveStrategy = class LiveStrategy {
+    constructor(_session, _editor, _zone, _showOverlayToolbar, contextKeyService, _editorWorkerService, _accessibilityService, _configService, _menuService, _contextService, _textFileService, _instaService) {
+        this._session = _session;
+        this._editor = _editor;
+        this._zone = _zone;
+        this._showOverlayToolbar = _showOverlayToolbar;
+        this._editorWorkerService = _editorWorkerService;
+        this._accessibilityService = _accessibilityService;
+        this._configService = _configService;
+        this._menuService = _menuService;
+        this._contextService = _contextService;
+        this._textFileService = _textFileService;
+        this._instaService = _instaService;
+        this._decoInsertedText = ModelDecorationOptions.register({
+            description: 'inline-modified-line',
+            className: 'inline-chat-inserted-range-linehighlight',
+            isWholeLine: true,
+            overviewRuler: {
+                position: OverviewRulerLane.Full,
+                color: themeColorFromId(overviewRulerInlineChatDiffInserted),
+            },
+            minimap: {
+                position: MinimapPosition.Inline,
+                color: themeColorFromId(minimapInlineChatDiffInserted),
+            }
+        });
+        this._decoInsertedTextRange = ModelDecorationOptions.register({
+            description: 'inline-chat-inserted-range-linehighlight',
+            className: 'inline-chat-inserted-range',
+            stickiness: TrackedRangeStickiness.NeverGrowsWhenTypingAtEdges,
+        });
+        this._store = ( new DisposableStore());
+        this._onDidAccept = this._store.add(( new Emitter()));
+        this._onDidDiscard = this._store.add(( new Emitter()));
+        this._editCount = 0;
+        this._hunkData = ( new Map());
+        this.onDidAccept = this._onDidAccept.event;
+        this.onDidDiscard = this._onDidDiscard.event;
+        this._ctxCurrentChangeHasDiff = CTX_INLINE_CHAT_CHANGE_HAS_DIFF.bindTo(contextKeyService);
+        this._ctxCurrentChangeShowsDiff = CTX_INLINE_CHAT_CHANGE_SHOWS_DIFF.bindTo(contextKeyService);
+        this._progressiveEditingDecorations = this._editor.createDecorationsCollection();
+        this._lensActionsFactory = this._store.add(( new ConflictActionsFactory(this._editor)));
+    }
+    dispose() {
+        this._resetDiff();
+        this._store.dispose();
+    }
+    _resetDiff() {
+        this._ctxCurrentChangeHasDiff.reset();
+        this._ctxCurrentChangeShowsDiff.reset();
+        this._zone.widget.updateStatus('');
+        this._progressiveEditingDecorations.clear();
+        for (const data of ( this._hunkData.values())) {
+            data.remove();
+        }
+    }
+    async apply() {
+        this._resetDiff();
+        if (this._editCount > 0) {
+            this._editor.pushUndoStop();
+        }
+        await this._doApplyChanges(true);
+    }
+    cancel() {
+        this._resetDiff();
+        return this._session.hunkData.discardAll();
+    }
+    async makeChanges(edits, obs, undoStopBefore) {
+        return this._makeChanges(edits, obs, undefined, undefined, undoStopBefore);
+    }
+    async makeProgressiveChanges(edits, obs, opts, undoStopBefore) {
+        const progress = ( new Progress(edits => {
+            const newLines = ( new Set());
+            for (const edit of edits) {
+                LineRange.fromRange(edit.range).forEach(line => newLines.add(line));
+            }
+            const existingRanges = ( this._progressiveEditingDecorations.getRanges().map(LineRange.fromRange));
+            for (const existingRange of existingRanges) {
+                existingRange.forEach(line => newLines.delete(line));
+            }
+            const newDecorations = [];
+            for (const line of newLines) {
+                newDecorations.push({ range: ( new Range(line, 1, line, Number.MAX_VALUE)), options: this._decoInsertedText });
+            }
+            this._progressiveEditingDecorations.append(newDecorations);
+        }));
+        return this._makeChanges(edits, obs, opts, progress, undoStopBefore);
+    }
+    async _makeChanges(edits, obs, opts, progress, undoStopBefore) {
+        if (undoStopBefore) {
+            this._editor.pushUndoStop();
+        }
+        this._editCount++;
+        if (opts) {
+            const durationInSec = opts.duration / 1000;
+            for (const edit of edits) {
+                const wordCount = countWords(edit.text ?? '');
+                const speed = wordCount / durationInSec;
+                const asyncEdit = asProgressiveEdit(( new WindowIntervalTimer(this._zone.domNode)), edit, speed, opts.token);
+                await performAsyncTextEdit(this._session.textModelN, asyncEdit, progress, obs);
+            }
+        }
+        else {
+            obs.start();
+            this._session.textModelN.pushEditOperations(null, edits, (undoEdits) => {
+                progress?.report(undoEdits);
+                return null;
+            });
+            obs.stop();
+        }
+    }
+    performHunkAction(hunk, action) {
+        const displayData = this._findDisplayData(hunk);
+        if (!displayData) {
+            if (action === HunkAction.Accept) {
+                this._onDidAccept.fire();
+            }
+            else if (action === HunkAction.Discard) {
+                this._onDidDiscard.fire();
+            }
+            return;
+        }
+        if (action === HunkAction.Accept) {
+            displayData.acceptHunk();
+        }
+        else if (action === HunkAction.Discard) {
+            displayData.discardHunk();
+        }
+        else if (action === HunkAction.MoveNext) {
+            displayData.move(true);
+        }
+        else if (action === HunkAction.MovePrev) {
+            displayData.move(false);
+        }
+        else if (action === HunkAction.ToggleDiff) {
+            displayData.toggleDiff?.();
+        }
+    }
+    _findDisplayData(hunkInfo) {
+        let result;
+        if (hunkInfo) {
+            result = this._hunkData.get(hunkInfo);
+        }
+        if (!result && this._zone.position) {
+            const zoneLine = this._zone.position.lineNumber;
+            let distance = Number.MAX_SAFE_INTEGER;
+            for (const candidate of ( this._hunkData.values())) {
+                if (candidate.hunk.getState() !== HunkState.Pending) {
+                    continue;
+                }
+                const hunkRanges = candidate.hunk.getRangesN();
+                if (hunkRanges.length === 0) {
+                    continue;
+                }
+                const myDistance = zoneLine <= hunkRanges[0].startLineNumber
+                    ? hunkRanges[0].startLineNumber - zoneLine
+                    : zoneLine - hunkRanges[0].endLineNumber;
+                if (myDistance < distance) {
+                    distance = myDistance;
+                    result = candidate;
+                }
+            }
+        }
+        if (!result) {
+            result = Iterable.first(Iterable.filter(( this._hunkData.values()), candidate => candidate.hunk.getState() === HunkState.Pending));
+        }
+        return result;
+    }
+    async renderChanges() {
+        this._progressiveEditingDecorations.clear();
+        const renderHunks = () => {
+            let widgetData;
+            changeDecorationsAndViewZones(this._editor, (decorationsAccessor, viewZoneAccessor) => {
+                const keysNow = ( new Set(( this._hunkData.keys())));
+                widgetData = undefined;
+                for (const hunkData of this._session.hunkData.getInfo()) {
+                    keysNow.delete(hunkData);
+                    const hunkRanges = hunkData.getRangesN();
+                    let data = this._hunkData.get(hunkData);
+                    if (!data) {
+                        const decorationIds = [];
+                        for (let i = 0; i < hunkRanges.length; i++) {
+                            decorationIds.push(decorationsAccessor.addDecoration(hunkRanges[i], i === 0
+                                ? this._decoInsertedText
+                                : this._decoInsertedTextRange));
+                        }
+                        const acceptHunk = () => {
+                            hunkData.acceptChanges();
+                            renderHunks();
+                        };
+                        const discardHunk = () => {
+                            hunkData.discardChanges();
+                            renderHunks();
+                        };
+                        const mightContainNonBasicASCII = this._session.textModel0.mightContainNonBasicASCII();
+                        const mightContainRTL = this._session.textModel0.mightContainRTL();
+                        const renderOptions = RenderOptions.fromEditor(this._editor);
+                        const originalRange = hunkData.getRanges0()[0];
+                        const source = ( new LineSource(
+                            LineRange.fromRangeInclusive(originalRange).mapToLineArray(l => this._session.textModel0.tokenization.getLineTokens(l)),
+                            [],
+                            mightContainNonBasicASCII,
+                            mightContainRTL
+                        ));
+                        const domNode = createElement('div');
+                        domNode.className = 'inline-chat-original-zone2';
+                        const result = renderLines(source, renderOptions, [( new InlineDecoration(( new Range(originalRange.startLineNumber, 1, originalRange.startLineNumber, 1)), '', InlineDecorationType.Regular))], domNode);
+                        const viewZoneData = {
+                            afterLineNumber: -1,
+                            heightInLines: result.heightInLines,
+                            domNode,
+                            ordinal: 50000 + 2
+                        };
+                        const toggleDiff = () => {
+                            const scrollState = StableEditorScrollState.capture(this._editor);
+                            changeDecorationsAndViewZones(this._editor, (_decorationsAccessor, viewZoneAccessor) => {
+                                assertType(data);
+                                if (!data.diffViewZoneId) {
+                                    const [hunkRange] = hunkData.getRangesN();
+                                    viewZoneData.afterLineNumber = hunkRange.startLineNumber - 1;
+                                    data.diffViewZoneId = viewZoneAccessor.addZone(viewZoneData);
+                                }
+                                else {
+                                    viewZoneAccessor.removeZone(data.diffViewZoneId);
+                                    data.diffViewZoneId = undefined;
+                                }
+                            });
+                            this._ctxCurrentChangeShowsDiff.set(typeof data?.diffViewZoneId === 'string');
+                            scrollState.restore(this._editor);
+                        };
+                        let lensActions;
+                        const lensActionsViewZoneIds = [];
+                        if (this._showOverlayToolbar && hunkData.getState() === HunkState.Pending) {
+                            lensActions = ( new DisposableStore());
+                            const menu = this._menuService.createMenu(MENU_INLINE_CHAT_ZONE, this._contextService);
+                            const makeActions = () => {
+                                const actions = [];
+                                const tuples = menu.getActions({ arg: hunkData });
+                                for (const [, group] of tuples) {
+                                    for (const item of group) {
+                                        if (item instanceof MenuItemAction) {
+                                            let text = item.label;
+                                            if (item.id === ACTION_TOGGLE_DIFF) {
+                                                text = item.checked ? 'Hide Changes' : 'Show Changes';
+                                            }
+                                            else if (ThemeIcon.isThemeIcon(item.item.icon)) {
+                                                text = `$(${item.item.icon.id}) ${text}`;
+                                            }
+                                            actions.push({
+                                                text,
+                                                tooltip: item.tooltip,
+                                                action: async () => item.run(),
+                                            });
+                                        }
+                                    }
+                                }
+                                return actions;
+                            };
+                            const obs = observableValue(this, makeActions());
+                            lensActions.add(menu.onDidChange(() => obs.set(makeActions(), undefined)));
+                            lensActions.add(menu);
+                            lensActions.add(this._lensActionsFactory.createWidget(viewZoneAccessor, hunkRanges[0].startLineNumber - 1, obs, lensActionsViewZoneIds));
+                        }
+                        const remove = () => {
+                            changeDecorationsAndViewZones(this._editor, (decorationsAccessor, viewZoneAccessor) => {
+                                assertType(data);
+                                for (const decorationId of data.decorationIds) {
+                                    decorationsAccessor.removeDecoration(decorationId);
+                                }
+                                if (data.diffViewZoneId) {
+                                    viewZoneAccessor.removeZone(data.diffViewZoneId);
+                                }
+                                data.decorationIds = [];
+                                data.diffViewZoneId = undefined;
+                                data.lensActionsViewZoneIds?.forEach(viewZoneAccessor.removeZone);
+                                data.lensActionsViewZoneIds = undefined;
+                            });
+                            lensActions?.dispose();
+                        };
+                        const move = (next) => {
+                            const keys = Array.from(( this._hunkData.keys()));
+                            const idx = keys.indexOf(hunkData);
+                            const nextIdx = (idx + (next ? 1 : -1) + keys.length) % keys.length;
+                            if (nextIdx !== idx) {
+                                const nextData = this._hunkData.get(keys[nextIdx]);
+                                this._zone.updatePositionAndHeight(nextData?.position);
+                                renderHunks();
+                            }
+                        };
+                        const zoneLineNumber = this._zone.position?.lineNumber ?? this._editor.getPosition().lineNumber;
+                        const myDistance = zoneLineNumber <= hunkRanges[0].startLineNumber
+                            ? hunkRanges[0].startLineNumber - zoneLineNumber
+                            : zoneLineNumber - hunkRanges[0].endLineNumber;
+                        data = {
+                            hunk: hunkData,
+                            decorationIds,
+                            diffViewZoneId: '',
+                            diffViewZone: viewZoneData,
+                            lensActionsViewZoneIds,
+                            distance: myDistance,
+                            position: hunkRanges[0].getStartPosition().delta(-1),
+                            acceptHunk,
+                            discardHunk,
+                            toggleDiff: !hunkData.isInsertion() ? toggleDiff : undefined,
+                            remove,
+                            move,
+                        };
+                        this._hunkData.set(hunkData, data);
+                    }
+                    else if (hunkData.getState() !== HunkState.Pending) {
+                        data.remove();
+                    }
+                    else {
+                        const zoneLineNumber = this._zone.position?.lineNumber ?? this._editor.getPosition().lineNumber;
+                        const modifiedRangeNow = hunkRanges[0];
+                        data.position = modifiedRangeNow.getStartPosition().delta(-1);
+                        data.distance = zoneLineNumber <= modifiedRangeNow.startLineNumber
+                            ? modifiedRangeNow.startLineNumber - zoneLineNumber
+                            : zoneLineNumber - modifiedRangeNow.endLineNumber;
+                    }
+                    if (hunkData.getState() === HunkState.Pending && (!widgetData || data.distance < widgetData.distance)) {
+                        widgetData = data;
+                    }
+                }
+                for (const key of keysNow) {
+                    const data = this._hunkData.get(key);
+                    if (data) {
+                        this._hunkData.delete(key);
+                        data.remove();
+                    }
+                }
+            });
+            if (widgetData) {
+                this._zone.reveal(widgetData.position);
+                const mode = this._configService.getValue(InlineChatConfigKeys.AccessibleDiffView);
+                if (mode === 'on' || mode === 'auto' && this._accessibilityService.isScreenReaderOptimized()) {
+                    this._zone.widget.showAccessibleHunk(this._session, widgetData.hunk);
+                }
+                this._ctxCurrentChangeHasDiff.set(Boolean(widgetData.toggleDiff));
+            }
+            else if (this._hunkData.size > 0) {
+                let oneAccepted = false;
+                for (const hunkData of this._session.hunkData.getInfo()) {
+                    if (hunkData.getState() === HunkState.Accepted) {
+                        oneAccepted = true;
+                        break;
+                    }
+                }
+                if (oneAccepted) {
+                    this._onDidAccept.fire();
+                }
+                else {
+                    this._onDidDiscard.fire();
+                }
+            }
+            return widgetData;
+        };
+        return renderHunks()?.position;
+    }
+    getWholeRangeDecoration() {
+        return [];
+    }
+    async _doApplyChanges(ignoreLocal) {
+        const untitledModels = [];
+        const editor = this._instaService.createInstance(DefaultChatTextEditor);
+        for (const request of this._session.chatModel.getRequests()) {
+            if (!request.response?.response) {
+                continue;
+            }
+            for (const item of request.response.response.value) {
+                if (item.kind !== 'textEditGroup') {
+                    continue;
+                }
+                if (ignoreLocal && isEqual(item.uri, this._session.textModelN.uri)) {
+                    continue;
+                }
+                await editor.apply(request.response, item, undefined);
+                if (item.uri.scheme === Schemas.untitled) {
+                    const untitled = this._textFileService.untitled.get(item.uri);
+                    if (untitled) {
+                        untitledModels.push(untitled);
+                    }
+                }
+            }
+        }
+        for (const untitledModel of untitledModels) {
+            if (!untitledModel.isDisposed()) {
+                await untitledModel.resolve();
+                await untitledModel.save({ reason: SaveReason.EXPLICIT });
+            }
+        }
+    }
+};
+LiveStrategy = ( __decorate([
+    ( __param(4, IContextKeyService)),
+    ( __param(5, IEditorWorkerService)),
+    ( __param(6, IAccessibilityService)),
+    ( __param(7, IConfigurationService)),
+    ( __param(8, IMenuService)),
+    ( __param(9, IContextKeyService)),
+    ( __param(10, ITextFileService)),
+    ( __param(11, IInstantiationService))
+], LiveStrategy));
+function changeDecorationsAndViewZones(editor, callback) {
+    editor.changeDecorations(decorationsAccessor => {
+        editor.changeViewZones(viewZoneAccessor => {
+            callback(decorationsAccessor, viewZoneAccessor);
+        });
+    });
+}
+
+export { HunkAction, LiveStrategy };

package/vscode/src/vs/workbench/contrib/inlineChat/browser/inlineChatZoneWidget.d.ts

@@ -0,0 +1,40 @@
+import { ICodeEditor } from "@codingame/monaco-vscode-api/vscode/vs/editor/browser/editorBrowser";
+import { Position } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/core/position";
+import { Range } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/core/range";
+import { ZoneWidget } from "@codingame/monaco-vscode-api/vscode/vs/editor/contrib/zoneWidget/browser/zoneWidget";
+import { IContextKeyService } from "@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service";
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
+import { IChatWidgetViewOptions } from "@codingame/monaco-vscode-b994942c-360d-5b68-8a33-77d4bde6b714-common/vscode/vs/workbench/contrib/chat/browser/chat";
+import { IChatWidgetLocationOptions } from "@codingame/monaco-vscode-e28ac690-06d5-5ee9-92d1-02df70296354-common/vscode/vs/workbench/contrib/chat/browser/chatWidget";
+import { INotebookEditor } from "@codingame/monaco-vscode-670aae94-7f88-54d7-90ea-6fcbef423557-common/vscode/vs/workbench/contrib/notebook/browser/notebookBrowser";
+import { EditorBasedInlineChatWidget } from "@codingame/monaco-vscode-e28ac690-06d5-5ee9-92d1-02df70296354-common/vscode/vs/workbench/contrib/inlineChat/browser/inlineChatWidget";
+export declare class InlineChatZoneWidget extends ZoneWidget {
+    private readonly _instaService;
+    private _logService;
+    private static readonly _options;
+    readonly widget: EditorBasedInlineChatWidget;
+    private readonly _scrollUp;
+    private readonly _ctxCursorPosition;
+    private _dimension?;
+    private notebookEditor?;
+    constructor(location: IChatWidgetLocationOptions, options: IChatWidgetViewOptions | undefined, editors: {
+        editor: ICodeEditor;
+        notebookEditor?: INotebookEditor;
+    }, _instaService: IInstantiationService, _logService: ILogService, contextKeyService: IContextKeyService);
+    protected _fillContainer(container: HTMLElement): void;
+    protected _doLayout(heightInPixel: number): void;
+    private _computeHeight;
+    protected _getResizeBounds(): {
+        minLines: number;
+        maxLines: number;
+    };
+    protected _onWidth(_widthInPixel: number): void;
+    show(position: Position): void;
+    private _updatePadding;
+    reveal(position: Position): void;
+    updatePositionAndHeight(position: Position): void;
+    private _createZoneAndScrollRestoreFn;
+    protected revealRange(range: Range, isLastLine: boolean): void;
+    hide(): void;
+}