@codingame/monaco-vscode-chat-service-override 3.2.3 → 4.1.0

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

@@ -1,72 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { illegalState } from 'vscode/vscode/vs/base/common/errors';
-import { DisposableStore } from 'vscode/vscode/vs/base/common/lifecycle';
-import { Schemas } from 'vscode/vscode/vs/base/common/network';
-import { isEqual } from 'vscode/vscode/vs/base/common/resources';
-import { InlineChatController } from 'vscode/vscode/vs/workbench/contrib/inlineChat/browser/inlineChatController';
-import { IInlineChatSessionService } from 'vscode/vscode/vs/workbench/contrib/inlineChat/browser/inlineChatSessionService';
-import { INotebookEditorService } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/services/notebookEditorService';
-import { CellUri } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookCommon';
-
-let InlineChatNotebookContribution = class InlineChatNotebookContribution {
-    constructor(sessionService, notebookEditorService) {
-        this._store = ( new DisposableStore());
-        this._store.add(sessionService.registerSessionKeyComputer(Schemas.vscodeNotebookCell, {
-            getComparisonKey: (editor, uri) => {
-                const data = CellUri.parse(uri);
-                if (!data) {
-                    throw illegalState('Expected notebook cell uri');
-                }
-                let fallback;
-                for (const notebookEditor of notebookEditorService.listNotebookEditors()) {
-                    if (notebookEditor.hasModel() && isEqual(notebookEditor.textModel.uri, data.notebook)) {
-                        const candidate = `<notebook>${notebookEditor.getId()}#${uri}`;
-                        if (!fallback) {
-                            fallback = candidate;
-                        }
-                        if (notebookEditor.codeEditors.find((tuple) => tuple[1] === editor)) {
-                            return candidate;
-                        }
-                    }
-                }
-                if (fallback) {
-                    return fallback;
-                }
-                throw illegalState('Expected notebook editor');
-            }
-        }));
-        this._store.add(sessionService.onWillStartSession(newSessionEditor => {
-            const candidate = CellUri.parse(newSessionEditor.getModel().uri);
-            if (!candidate) {
-                return;
-            }
-            for (const notebookEditor of notebookEditorService.listNotebookEditors()) {
-                if (isEqual(notebookEditor.textModel?.uri, candidate.notebook)) {
-                    let found = false;
-                    const editors = [];
-                    for (const [, codeEditor] of notebookEditor.codeEditors) {
-                        editors.push(codeEditor);
-                        found = codeEditor === newSessionEditor || found;
-                    }
-                    if (found) {
-                        for (const editor of editors) {
-                            if (editor !== newSessionEditor) {
-                                InlineChatController.get(editor)?.finishExistingSession();
-                            }
-                        }
-                        break;
-                    }
-                }
-            }
-        }));
-    }
-    dispose() {
-        this._store.dispose();
-    }
-};
-InlineChatNotebookContribution = ( __decorate([
-    ( __param(0, IInlineChatSessionService)),
-    ( __param(1, INotebookEditorService))
-], InlineChatNotebookContribution));
-
-export { InlineChatNotebookContribution };

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

@@ -1,236 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { Queue, raceCancellation } from 'vscode/vscode/vs/base/common/async';
-import { DisposableStore, MutableDisposable, dispose, combinedDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
-import { isCodeEditor } from 'vscode/vscode/vs/editor/browser/editorBrowser';
-import { localizeWithPath } from 'vscode/vscode/vs/nls';
-import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration';
-import { IInlineChatSessionService } from 'vscode/vscode/vs/workbench/contrib/inlineChat/browser/inlineChatSessionService';
-import { IEditorGroupsService } from 'vscode/vscode/vs/workbench/services/editor/common/editorGroupsService';
-import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService';
-import { IFilesConfigurationService } from 'vscode/vscode/vs/workbench/services/filesConfiguration/common/filesConfigurationService';
-import { ITextFileService } from 'vscode/vscode/vs/workbench/services/textfile/common/textfiles';
-import { Iterable } from 'vscode/vscode/vs/base/common/iterator';
-import { Schemas } from 'vscode/vscode/vs/base/common/network';
-import { CellUri } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookCommon';
-import { getNotebookEditorFromEditorPane } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/notebookBrowser';
-import { compare } from 'vscode/vscode/vs/base/common/strings';
-import { IWorkingCopyFileService } from 'vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyFileService';
-import { ILogService } from 'vscode/vscode/vs/platform/log/common/log';
-import { Event } from 'vscode/vscode/vs/base/common/event';
-import { InlineChatController } from 'vscode/vscode/vs/workbench/contrib/inlineChat/browser/inlineChatController';
-
-let InlineChatSavingServiceImpl = class InlineChatSavingServiceImpl {
-    constructor(_fileConfigService, _editorGroupService, _textFileService, _editorService, _inlineChatSessionService, _configService, _workingCopyFileService, _logService) {
-        this._fileConfigService = _fileConfigService;
-        this._editorGroupService = _editorGroupService;
-        this._textFileService = _textFileService;
-        this._editorService = _editorService;
-        this._inlineChatSessionService = _inlineChatSessionService;
-        this._configService = _configService;
-        this._workingCopyFileService = _workingCopyFileService;
-        this._logService = _logService;
-        this._store = ( new DisposableStore());
-        this._saveParticipant = this._store.add(( new MutableDisposable()));
-        this._sessionData = ( new Map());
-        this._store.add(Event.any(_inlineChatSessionService.onDidEndSession, _inlineChatSessionService.onDidStashSession)(e => {
-            this._sessionData.get(e.session)?.dispose();
-        }));
-    }
-    dispose() {
-        this._store.dispose();
-        dispose(( this._sessionData.values()));
-    }
-    markChanged(session) {
-        if (!( this._sessionData.has(session))) {
-            let uri = session.targetUri;
-            if (uri.scheme === Schemas.vscodeNotebookCell) {
-                const data = CellUri.parse(uri);
-                if (!data) {
-                    return;
-                }
-                uri = data?.notebook;
-            }
-            if (this._sessionData.size === 0) {
-                this._installSaveParticpant();
-            }
-            const saveConfigOverride = this._fileConfigService.disableAutoSave(uri);
-            this._sessionData.set(session, {
-                resourceUri: uri,
-                groupCandidate: this._editorGroupService.activeGroup,
-                session,
-                dispose: () => {
-                    saveConfigOverride.dispose();
-                    this._sessionData.delete(session);
-                    if (this._sessionData.size === 0) {
-                        this._saveParticipant.clear();
-                    }
-                }
-            });
-        }
-    }
-    _installSaveParticpant() {
-        const queue = ( new Queue());
-        const d1 = this._textFileService.files.addSaveParticipant({
-            participate: (model, ctx, progress, token) => {
-                return queue.queue(() => this._participate(ctx.savedFrom ?? model.textEditorModel?.uri, ctx.reason, progress, token));
-            }
-        });
-        const d2 = this._workingCopyFileService.addSaveParticipant({
-            participate: (workingCopy, ctx, progress, token) => {
-                return queue.queue(() => this._participate(ctx.savedFrom ?? workingCopy.resource, ctx.reason, progress, token));
-            }
-        });
-        this._saveParticipant.value = combinedDisposable(d1, d2, queue);
-    }
-    async _participate(uri, reason, progress, token) {
-        if (reason !== 1 ) {
-            return;
-        }
-        if (!this._configService.getValue("inlineChat.acceptedOrDiscardBeforeSave" )) {
-            return;
-        }
-        const sessions = ( new Map());
-        for (const [session, data] of this._sessionData) {
-            if (uri?.toString() === ( data.resourceUri.toString())) {
-                sessions.set(session, data);
-            }
-        }
-        if (sessions.size === 0) {
-            return;
-        }
-        progress.report({
-            message: sessions.size === 1
-                ? ( localizeWithPath(
-                'vs/workbench/contrib/inlineChat/browser/inlineChatSavingServiceImpl',
-                'inlineChat',
-                "Waiting for Inline Chat changes to be Accepted or Discarded..."
-            ))
-                : ( localizeWithPath(
-                'vs/workbench/contrib/inlineChat/browser/inlineChatSavingServiceImpl',
-                'inlineChat.N',
-                "Waiting for Inline Chat changes in {0} editors to be Accepted or Discarded...",
-                sessions.size
-            ))
-        });
-        const { groups, orphans } = this._getGroupsAndOrphans(( sessions.values()));
-        const editorsOpenedAndSessionsEnded = this._openAndWait(groups, token).then(() => {
-            if (token.isCancellationRequested) {
-                return;
-            }
-            return this._openAndWait(( Iterable.map(orphans, s => [this._editorGroupService.activeGroup, s])), token);
-        });
-        const allSessionsEnded = this._whenSessionsEnded(Iterable.concat(( groups.map(tuple => tuple[1])), orphans), token);
-        await Promise.race([allSessionsEnded, editorsOpenedAndSessionsEnded]);
-    }
-    _getGroupsAndOrphans(sessions) {
-        const groupByEditor = ( new Map());
-        for (const group of this._editorGroupService.getGroups(1 )) {
-            const candidate = group.activeEditorPane?.getControl();
-            if (isCodeEditor(candidate)) {
-                groupByEditor.set(candidate, group);
-            }
-        }
-        const groups = [];
-        const orphans = ( new Set());
-        for (const data of sessions) {
-            const editor = this._inlineChatSessionService.getCodeEditor(data.session);
-            const group = groupByEditor.get(editor);
-            if (group) {
-                groups.push([group, data]);
-            }
-            else if (this._editorGroupService.groups.includes(data.groupCandidate)) {
-                groups.push([data.groupCandidate, data]);
-            }
-            else {
-                orphans.add(data);
-            }
-        }
-        return { groups, orphans };
-    }
-    async _openAndWait(groups, token) {
-        const dataByGroup = ( new Map());
-        for (const [group, data] of groups) {
-            let array = dataByGroup.get(group);
-            if (!array) {
-                array = [];
-                dataByGroup.set(group, array);
-            }
-            array.push(data);
-        }
-        for (const [group, array] of dataByGroup) {
-            if (token.isCancellationRequested) {
-                break;
-            }
-            array.sort((a, b) => compare(( a.session.targetUri.toString()), ( b.session.targetUri.toString())));
-            for (const data of array) {
-                const input = { resource: data.resourceUri };
-                const pane = await this._editorService.openEditor(input, group);
-                let editor;
-                if (data.session.targetUri.scheme === Schemas.vscodeNotebookCell) {
-                    const notebookEditor = getNotebookEditorFromEditorPane(pane);
-                    const uriData = CellUri.parse(data.session.targetUri);
-                    if (notebookEditor && notebookEditor.hasModel() && uriData) {
-                        const cell = notebookEditor.getCellByHandle(uriData.handle);
-                        if (cell) {
-                            await notebookEditor.revealRangeInCenterIfOutsideViewportAsync(cell, data.session.wholeRange.value);
-                        }
-                        const tuple = notebookEditor.codeEditors.find(tuple => tuple[1].getModel()?.uri.toString() === ( data.session.targetUri.toString()));
-                        editor = tuple?.[1];
-                    }
-                }
-                else {
-                    if (isCodeEditor(pane?.getControl())) {
-                        editor = pane.getControl();
-                    }
-                }
-                if (!editor) {
-                    break;
-                }
-                this._inlineChatSessionService.moveSession(data.session, editor);
-                InlineChatController.get(editor)?.showSaveHint();
-                this._logService.info('WAIT for session to end', editor.getId(), ( data.session.targetUri.toString()));
-                await this._whenSessionsEnded(Iterable.single(data), token);
-            }
-        }
-    }
-    async _whenSessionsEnded(iterable, token) {
-        const sessions = ( new Map());
-        for (const item of iterable) {
-            sessions.set(item.session, item);
-        }
-        if (sessions.size === 0) {
-            return;
-        }
-        let listener;
-        const whenEnded = ( new Promise(resolve => {
-            listener = Event.any(this._inlineChatSessionService.onDidEndSession, this._inlineChatSessionService.onDidStashSession)(e => {
-                const data = sessions.get(e.session);
-                if (data) {
-                    data.dispose();
-                    sessions.delete(e.session);
-                    if (sessions.size === 0) {
-                        resolve();
-                    }
-                }
-            });
-        }));
-        try {
-            await raceCancellation(whenEnded, token);
-        }
-        finally {
-            listener?.dispose();
-        }
-    }
-};
-InlineChatSavingServiceImpl = ( __decorate([
-    ( __param(0, IFilesConfigurationService)),
-    ( __param(1, IEditorGroupsService)),
-    ( __param(2, ITextFileService)),
-    ( __param(3, IEditorService)),
-    ( __param(4, IInlineChatSessionService)),
-    ( __param(5, IConfigurationService)),
-    ( __param(6, IWorkingCopyFileService)),
-    ( __param(7, ILogService))
-], InlineChatSavingServiceImpl));
-
-export { InlineChatSavingServiceImpl };

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

@@ -1,223 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { Emitter, Event } from 'vscode/vscode/vs/base/common/event';
-import { IInlineChatService } from 'vscode/vscode/vs/workbench/contrib/inlineChat/common/inlineChat';
-import { Range } from 'vscode/vscode/vs/editor/common/core/range';
-import { ITelemetryService } from 'vscode/vscode/vs/platform/telemetry/common/telemetry';
-import { IModelService } from 'vscode/vscode/vs/editor/common/services/model';
-import { ITextModelService } from 'vscode/vscode/vs/editor/common/services/resolverService';
-import { DisposableStore, toDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
-import { createTextBufferFactoryFromSnapshot } from 'vscode/vscode/vs/editor/common/model/textModel';
-import { ILogService } from 'vscode/vscode/vs/platform/log/common/log';
-import { Iterable } from 'vscode/vscode/vs/base/common/iterator';
-import { raceCancellation } from 'vscode/vscode/vs/base/common/async';
-import { Session, SessionWholeRange, HunkData, StashedSession } from 'vscode/vscode/vs/workbench/contrib/inlineChat/browser/inlineChatSession';
-import { IEditorWorkerService } from 'vscode/vscode/vs/editor/common/services/editorWorker';
-import { Schemas } from 'vscode/vscode/vs/base/common/network';
-import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
-import { generateUuid } from 'vscode/vscode/vs/base/common/uuid';
-import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService';
-import { UntitledTextEditorInput } from 'vscode/vscode/vs/workbench/services/untitled/common/untitledTextEditorInput';
-import { DEFAULT_EDITOR_ASSOCIATION } from 'vscode/vscode/vs/workbench/common/editor';
-
-let InlineChatSessionServiceImpl = class InlineChatSessionServiceImpl {
-    constructor(_inlineChatService, _telemetryService, _modelService, _textModelService, _editorWorkerService, _logService, _instaService, _editorService) {
-        this._inlineChatService = _inlineChatService;
-        this._telemetryService = _telemetryService;
-        this._modelService = _modelService;
-        this._textModelService = _textModelService;
-        this._editorWorkerService = _editorWorkerService;
-        this._logService = _logService;
-        this._instaService = _instaService;
-        this._editorService = _editorService;
-        this._onWillStartSession = ( new Emitter());
-        this.onWillStartSession = this._onWillStartSession.event;
-        this._onDidMoveSession = ( new Emitter());
-        this.onDidMoveSession = this._onDidMoveSession.event;
-        this._onDidEndSession = ( new Emitter());
-        this.onDidEndSession = this._onDidEndSession.event;
-        this._onDidStashSession = ( new Emitter());
-        this.onDidStashSession = this._onDidStashSession.event;
-        this._sessions = ( new Map());
-        this._keyComputers = ( new Map());
-        this._recordings = [];
-    }
-    dispose() {
-        this._onWillStartSession.dispose();
-        this._onDidEndSession.dispose();
-        this._sessions.forEach(x => x.store.dispose());
-        this._sessions.clear();
-    }
-    async createSession(editor, options, token) {
-        const provider = Iterable.first(this._inlineChatService.getAllProvider());
-        if (!provider) {
-            this._logService.trace('[IE] NO provider found');
-            return undefined;
-        }
-        this._onWillStartSession.fire(editor);
-        const textModel = editor.getModel();
-        const selection = editor.getSelection();
-        let rawSession;
-        try {
-            rawSession = await raceCancellation(Promise.resolve(provider.prepareInlineChatSession(textModel, selection, token)), token);
-        }
-        catch (error) {
-            this._logService.error('[IE] FAILED to prepare session', provider.debugName);
-            this._logService.error(error);
-            return undefined;
-        }
-        if (!rawSession) {
-            this._logService.trace('[IE] NO session', provider.debugName);
-            return undefined;
-        }
-        this._logService.trace('[IE] NEW session', provider.debugName);
-        this._logService.trace(`[IE] creating NEW session for ${editor.getId()}, ${provider.debugName}`);
-        const store = ( new DisposableStore());
-        store.add(this._inlineChatService.onDidChangeProviders(e => {
-            if (e.removed === provider) {
-                this._logService.trace(`[IE] provider GONE for ${editor.getId()}, ${provider.debugName}`);
-                this._releaseSession(session, true);
-            }
-        }));
-        const id = generateUuid();
-        const targetUri = textModel.uri;
-        let textModelN;
-        if (options.editMode === "preview" ) {
-            textModelN = store.add(this._modelService.createModel(createTextBufferFactoryFromSnapshot(textModel.createSnapshot()), { languageId: textModel.getLanguageId(), onDidChange: Event.None }, targetUri.with({ scheme: Schemas.vscode, authority: 'inline-chat', path: '', query: ( ( new URLSearchParams({ id, 'textModelN': '' })).toString()) })));
-        }
-        else {
-            store.add((await this._textModelService.createModelReference(textModel.uri)));
-            textModelN = textModel;
-        }
-        const textModel0 = store.add(this._modelService.createModel(createTextBufferFactoryFromSnapshot(textModel.createSnapshot()), { languageId: textModel.getLanguageId(), onDidChange: Event.None }, targetUri.with({ scheme: Schemas.vscode, authority: 'inline-chat', path: '', query: ( ( new URLSearchParams({ id, 'textModel0': '' })).toString()) }), true));
-        if (targetUri.scheme === Schemas.untitled) {
-            store.add(this._editorService.onDidCloseEditor(() => {
-                if (!this._editorService.isOpened({ resource: targetUri, typeId: UntitledTextEditorInput.ID, editorId: DEFAULT_EDITOR_ASSOCIATION.id })) {
-                    this._releaseSession(session, true);
-                }
-            }));
-        }
-        let wholeRange = options.wholeRange;
-        if (!wholeRange) {
-            wholeRange = rawSession.wholeRange ? Range.lift(rawSession.wholeRange) : editor.getSelection();
-        }
-        if (token.isCancellationRequested) {
-            store.dispose();
-            return undefined;
-        }
-        const session = ( new Session(
-            options.editMode,
-            targetUri,
-            textModel0,
-            textModelN,
-            provider,
-            rawSession,
-            store.add(( new SessionWholeRange(textModelN, wholeRange))),
-            store.add(( new HunkData(this._editorWorkerService, textModel0, textModelN)))
-        ));
-        const key = this._key(editor, session.targetUri);
-        if (( this._sessions.has(key))) {
-            store.dispose();
-            throw new Error(`Session already stored for ${key}`);
-        }
-        this._sessions.set(key, { session, editor, store });
-        return session;
-    }
-    moveSession(session, target) {
-        const newKey = this._key(target, session.targetUri);
-        const existing = this._sessions.get(newKey);
-        if (existing) {
-            if (existing.session !== session) {
-                throw new Error(`Cannot move session because the target editor already/still has one`);
-            }
-            else {
-                return;
-            }
-        }
-        let found = false;
-        for (const [oldKey, data] of this._sessions) {
-            if (data.session === session) {
-                found = true;
-                this._sessions.delete(oldKey);
-                this._sessions.set(newKey, { ...data, editor: target });
-                this._logService.trace(`[IE] did MOVE session for ${data.editor.getId()} to NEW EDITOR ${target.getId()}, ${session.provider.debugName}`);
-                this._onDidMoveSession.fire({ session, editor: target });
-                break;
-            }
-        }
-        if (!found) {
-            throw new Error(`Cannot move session because it is not stored`);
-        }
-    }
-    releaseSession(session) {
-        this._releaseSession(session, false);
-    }
-    _releaseSession(session, byServer) {
-        let tuple;
-        for (const candidate of this._sessions) {
-            if (candidate[1].session === session) {
-                tuple = candidate;
-                break;
-            }
-        }
-        if (!tuple) {
-            return;
-        }
-        this._keepRecording(session);
-        this._telemetryService.publicLog2('interactiveEditor/session', session.asTelemetryData());
-        const [key, value] = tuple;
-        this._sessions.delete(key);
-        this._logService.trace(`[IE] did RELEASED session for ${value.editor.getId()}, ${session.provider.debugName}`);
-        this._onDidEndSession.fire({ editor: value.editor, session, endedByExternalCause: byServer });
-        value.store.dispose();
-    }
-    stashSession(session, editor, undoCancelEdits) {
-        this._keepRecording(session);
-        const result = this._instaService.createInstance(StashedSession, editor, session, undoCancelEdits);
-        this._onDidStashSession.fire({ editor, session });
-        this._logService.trace(`[IE] did STASH session for ${editor.getId()}, ${session.provider.debugName}`);
-        return result;
-    }
-    getCodeEditor(session) {
-        for (const [, data] of this._sessions) {
-            if (data.session === session) {
-                return data.editor;
-            }
-        }
-        throw new Error('session not found');
-    }
-    getSession(editor, uri) {
-        const key = this._key(editor, uri);
-        return this._sessions.get(key)?.session;
-    }
-    _key(editor, uri) {
-        const item = this._keyComputers.get(uri.scheme);
-        return item
-            ? item.getComparisonKey(editor, uri)
-            : `${editor.getId()}@${( uri.toString())}`;
-    }
-    registerSessionKeyComputer(scheme, value) {
-        this._keyComputers.set(scheme, value);
-        return toDisposable(() => this._keyComputers.delete(scheme));
-    }
-    _keepRecording(session) {
-        const newLen = this._recordings.unshift(session.asRecording());
-        if (newLen > 5) {
-            this._recordings.pop();
-        }
-    }
-    recordings() {
-        return this._recordings;
-    }
-};
-InlineChatSessionServiceImpl = ( __decorate([
-    ( __param(0, IInlineChatService)),
-    ( __param(1, ITelemetryService)),
-    ( __param(2, IModelService)),
-    ( __param(3, ITextModelService)),
-    ( __param(4, IEditorWorkerService)),
-    ( __param(5, ILogService)),
-    ( __param(6, IInstantiationService)),
-    ( __param(7, IEditorService))
-], InlineChatSessionServiceImpl));
-
-export { InlineChatSessionServiceImpl };

package/vscode/src/vs/workbench/contrib/inlineChat/common/inlineChatServiceImpl.js

@@ -1,33 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { toDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
-import { Emitter } from 'vscode/vscode/vs/base/common/event';
-import { LinkedList } from 'vscode/vscode/vs/base/common/linkedList';
-import { IContextKeyService } from 'vscode/vscode/vs/platform/contextkey/common/contextkey';
-import { CTX_INLINE_CHAT_HAS_PROVIDER } from 'vscode/vscode/vs/workbench/contrib/inlineChat/common/inlineChat';
-
-let InlineChatServiceImpl = class InlineChatServiceImpl {
-    constructor(contextKeyService) {
-        this._onDidChangeProviders = ( new Emitter());
-        this._entries = ( new LinkedList());
-        this.onDidChangeProviders = this._onDidChangeProviders.event;
-        this._ctxHasProvider = CTX_INLINE_CHAT_HAS_PROVIDER.bindTo(contextKeyService);
-    }
-    addProvider(provider) {
-        const rm = this._entries.push(provider);
-        this._ctxHasProvider.set(true);
-        this._onDidChangeProviders.fire({ added: provider });
-        return toDisposable(() => {
-            rm();
-            this._ctxHasProvider.set(this._entries.size > 0);
-            this._onDidChangeProviders.fire({ removed: provider });
-        });
-    }
-    getAllProvider() {
-        return [...this._entries].reverse();
-    }
-};
-InlineChatServiceImpl = ( __decorate([
-    ( __param(0, IContextKeyService))
-], InlineChatServiceImpl));
-
-export { InlineChatServiceImpl };