@codingame/monaco-vscode-api 1.78.8 → 1.79.0

package/dist/vscode/vs/workbench/contrib/interactiveSession/browser/interactiveSessionListRenderer.js

@@ -0,0 +1,622 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import * as dom from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { renderIcon } from 'monaco-editor/esm/vs/base/browser/ui/iconLabel/iconLabels.js';
+import { IntervalTimer } from 'monaco-editor/esm/vs/base/common/async.js';
+import { Codicon } from 'monaco-editor/esm/vs/base/common/codicons.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { MarkdownString } from 'monaco-editor/esm/vs/base/common/htmlContent.js';
+import { Disposable, DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { ResourceMap } from 'monaco-editor/esm/vs/base/common/map.js';
+import { FileAccess } from 'monaco-editor/esm/vs/base/common/network.js';
+import { ThemeIcon } from 'monaco-editor/esm/vs/base/common/themables.js';
+import { withNullAsUndefined } from 'monaco-editor/esm/vs/base/common/types.js';
+import { EditorExtensionsRegistry } from 'monaco-editor/esm/vs/editor/browser/editorExtensions.js';
+import { CodeEditorWidget } from 'monaco-editor/esm/vs/editor/browser/widget/codeEditorWidget.js';
+import { EDITOR_FONT_DEFAULTS } from 'monaco-editor/esm/vs/editor/common/config/editorOptions.js';
+import { Range } from 'monaco-editor/esm/vs/editor/common/core/range.js';
+import { ILanguageService } from 'monaco-editor/esm/vs/editor/common/languages/language.js';
+import { PLAINTEXT_LANGUAGE_ID } from 'monaco-editor/esm/vs/editor/common/languages/modesRegistry.js';
+import { IModelService } from 'monaco-editor/esm/vs/editor/common/services/model.js';
+import { BracketMatchingController } from 'monaco-editor/esm/vs/editor/contrib/bracketMatching/browser/bracketMatching.js';
+import { ContextMenuController } from 'monaco-editor/esm/vs/editor/contrib/contextmenu/browser/contextmenu.js';
+import { MarkdownRenderer } from 'monaco-editor/esm/vs/editor/contrib/markdownRenderer/browser/markdownRenderer.js';
+import { ViewportSemanticTokensContribution } from 'monaco-editor/esm/vs/editor/contrib/semanticTokens/browser/viewportSemanticTokens.js';
+import { SmartSelectController } from 'monaco-editor/esm/vs/editor/contrib/smartSelect/browser/smartSelect.js';
+import { WordHighlighterContribution } from 'monaco-editor/esm/vs/editor/contrib/wordHighlighter/browser/wordHighlighter.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { MenuEntryActionViewItem } from 'monaco-editor/esm/vs/platform/actions/browser/menuEntryActionViewItem.js';
+import { MenuWorkbenchToolBar } from 'monaco-editor/esm/vs/platform/actions/browser/toolbar.js';
+import { MenuId, MenuItemAction } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
+import { ICommandService } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { ServiceCollection } from 'monaco-editor/esm/vs/platform/instantiation/common/serviceCollection.js';
+import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { defaultButtonStyles } from 'monaco-editor/esm/vs/platform/theme/browser/defaultStyles.js';
+import { MenuPreventer } from '../../codeEditor/browser/menuPreventer.js';
+import { SelectionClipboardContributionID } from '../../codeEditor/browser/selectionClipboard.js';
+import { getSimpleEditorOptions } from '../../codeEditor/browser/simpleEditorOptions.js';
+import { InteractiveSessionFollowups } from './interactiveSessionFollowups.js';
+import { CONTEXT_RESPONSE_HAS_PROVIDER_ID, CONTEXT_RESPONSE_VOTE } from '../common/interactiveSessionContextKeys.js';
+import { InteractiveSessionVoteDirection, IInteractiveSessionService } from '../common/interactiveSessionService.js';
+import { isResponseVM, isRequestVM, isWelcomeVM } from '../common/interactiveSessionViewModel.js';
+import { getNWords } from '../common/interactiveSessionWordCounter.js';
+const $ = dom.$;
+let InteractiveListItemRenderer = class InteractiveListItemRenderer extends Disposable {
+    constructor(editorOptions, delegate, instantiationService, configService, logService, commandService, contextKeyService, interactiveSessionService) {
+        super();
+        this.editorOptions = editorOptions;
+        this.delegate = delegate;
+        this.instantiationService = instantiationService;
+        this.configService = configService;
+        this.logService = logService;
+        this.commandService = commandService;
+        this.contextKeyService = contextKeyService;
+        this.interactiveSessionService = interactiveSessionService;
+        this._onDidClickFollowup = this._register(( new Emitter()));
+        this.onDidClickFollowup = this._onDidClickFollowup.event;
+        this._onDidChangeItemHeight = this._register(( new Emitter()));
+        this.onDidChangeItemHeight = this._onDidChangeItemHeight.event;
+        this._currentLayoutWidth = 0;
+        this._isVisible = true;
+        this.renderer = this.instantiationService.createInstance(MarkdownRenderer, {});
+        this._editorPool = this._register(this.instantiationService.createInstance(EditorPool, this.editorOptions));
+    }
+    get templateId() {
+        return InteractiveListItemRenderer.ID;
+    }
+    traceLayout(method, message) {
+        {
+            this.logService.trace(`InteractiveListItemRenderer#${method}: ${message}`);
+        }
+    }
+    progressiveRenderEnabled() {
+        return !this.configService.getValue('interactive.experimental.disableProgressiveRendering');
+    }
+    getProgressiveRenderRate(element) {
+        const configuredRate = this.configService.getValue('interactive.experimental.progressiveRenderingRate');
+        if (typeof configuredRate === 'number') {
+            return configuredRate;
+        }
+        if (element.isComplete) {
+            return 60;
+        }
+        if (element.contentUpdateTimings && element.contentUpdateTimings.impliedWordLoadRate) {
+            const rateBoost = 1.5;
+            return element.contentUpdateTimings.impliedWordLoadRate * rateBoost;
+        }
+        return 8;
+    }
+    setVisible(visible) {
+        this._isVisible = visible;
+    }
+    layout(width) {
+        this._currentLayoutWidth = width - 40;
+        this._editorPool.inUse.forEach(editor => {
+            editor.layout(this._currentLayoutWidth);
+        });
+    }
+    renderTemplate(container) {
+        const templateDisposables = ( new DisposableStore());
+        const rowContainer = dom.append(container, $('.interactive-item-container'));
+        const header = dom.append(rowContainer, $('.header'));
+        const user = dom.append(header, $('.user'));
+        const avatar = dom.append(user, $('.avatar'));
+        const username = dom.append(user, $('h3.username'));
+        const value = dom.append(rowContainer, $('.value'));
+        const elementDisposables = ( new DisposableStore());
+        const contextKeyService = templateDisposables.add(this.contextKeyService.createScoped(rowContainer));
+        const scopedInstantiationService = this.instantiationService.createChild(( new ServiceCollection([IContextKeyService, contextKeyService])));
+        const titleToolbar = templateDisposables.add(scopedInstantiationService.createInstance(MenuWorkbenchToolBar, header, MenuId.InteractiveSessionTitle, {
+            menuOptions: {
+                shouldForwardArgs: true
+            },
+            actionViewItemProvider: (action, options) => {
+                if (action instanceof MenuItemAction) {
+                    return scopedInstantiationService.createInstance(InteractiveSessionVoteButton, action, options);
+                }
+                return undefined;
+            }
+        }));
+        const template = { avatar, username, value, rowContainer, elementDisposables, titleToolbar, templateDisposables, contextKeyService };
+        return template;
+    }
+    renderElement(node, index, templateData) {
+        const { element } = node;
+        const kind = isRequestVM(element) ? 'request' :
+            isResponseVM(element) ? 'response' :
+                'welcome';
+        this.traceLayout('renderElement', `${kind}, index=${index}`);
+        CONTEXT_RESPONSE_HAS_PROVIDER_ID.bindTo(templateData.contextKeyService).set(isResponseVM(element) && !!element.providerResponseId);
+        if (isResponseVM(element)) {
+            CONTEXT_RESPONSE_VOTE.bindTo(templateData.contextKeyService).set(element.vote === InteractiveSessionVoteDirection.Up ? 'up' : element.vote === InteractiveSessionVoteDirection.Down ? 'down' : '');
+        }
+        else {
+            CONTEXT_RESPONSE_VOTE.bindTo(templateData.contextKeyService).set('');
+        }
+        templateData.titleToolbar.context = element;
+        templateData.rowContainer.classList.toggle('interactive-request', isRequestVM(element));
+        templateData.rowContainer.classList.toggle('interactive-response', isResponseVM(element));
+        templateData.rowContainer.classList.toggle('interactive-welcome', isWelcomeVM(element));
+        templateData.rowContainer.classList.toggle('filtered-response', !!(isResponseVM(element) && element.errorDetails?.responseIsFiltered));
+        templateData.username.textContent = element.username;
+        if (element.avatarIconUri) {
+            const avatarIcon = dom.$('img.icon');
+            avatarIcon.src = ( FileAccess.uriToBrowserUri(element.avatarIconUri).toString(true));
+            templateData.avatar.replaceChildren(avatarIcon);
+        }
+        else {
+            const defaultIcon = isRequestVM(element) ? Codicon.account : Codicon.hubot;
+            const avatarIcon = dom.$(ThemeIcon.asCSSSelector(defaultIcon));
+            templateData.avatar.replaceChildren(avatarIcon);
+        }
+        if (isResponseVM(element) && index === this.delegate.getListLength() - 1 && !element.isPlaceholder && (!element.isComplete || element.renderData) && this.progressiveRenderEnabled()) {
+            this.traceLayout('renderElement', `start progressive render ${kind}, index=${index}`);
+            const progressiveRenderingDisposables = templateData.elementDisposables.add(( new DisposableStore()));
+            const timer = templateData.elementDisposables.add(( new IntervalTimer()));
+            const runProgressiveRender = (initial) => {
+                try {
+                    if (this.doNextProgressiveRender(element, index, templateData, !!initial, progressiveRenderingDisposables)) {
+                        timer.cancel();
+                    }
+                }
+                catch (err) {
+                    timer.cancel();
+                    throw err;
+                }
+            };
+            timer.cancelAndSet(runProgressiveRender, 50);
+            runProgressiveRender(true);
+        }
+        else if (isResponseVM(element)) {
+            this.basicRenderElement(element.response.value, element, index, templateData);
+        }
+        else if (isRequestVM(element)) {
+            this.basicRenderElement(element.messageText, element, index, templateData);
+        }
+        else {
+            this.renderWelcomeMessage(element, templateData);
+        }
+    }
+    basicRenderElement(markdownValue, element, index, templateData) {
+        const fillInIncompleteTokens = isResponseVM(element) && (!element.isComplete || element.isCanceled || element.errorDetails?.responseIsFiltered || element.errorDetails?.responseIsIncomplete);
+        const result = this.renderMarkdown(( new MarkdownString(markdownValue)), element, templateData.elementDisposables, templateData, fillInIncompleteTokens);
+        dom.clearNode(templateData.value);
+        templateData.value.appendChild(result.element);
+        templateData.elementDisposables.add(result);
+        if (isResponseVM(element) && element.errorDetails?.message) {
+            const icon = element.errorDetails.responseIsFiltered ? Codicon.info : Codicon.error;
+            const errorDetails = dom.append(templateData.value, $('.interactive-response-error-details', undefined, renderIcon(icon)));
+            errorDetails.appendChild($('span', undefined, element.errorDetails.message));
+        }
+        if (isResponseVM(element) && element.commandFollowups?.length) {
+            const followupsContainer = dom.append(templateData.value, $('.interactive-response-followups'));
+            templateData.elementDisposables.add(( new InteractiveSessionFollowups(
+                followupsContainer,
+                element.commandFollowups,
+                defaultButtonStyles,
+                followup => {
+                    this.interactiveSessionService.notifyUserAction({
+                        providerId: element.providerId,
+                        action: {
+                            kind: 'command',
+                            command: followup
+                        }
+                    });
+                    return this.commandService.executeCommand(followup.commandId, ...(followup.args ?? []));
+                }
+            )));
+        }
+    }
+    renderWelcomeMessage(element, templateData) {
+        dom.clearNode(templateData.value);
+        const slashCommands = this.delegate.getSlashCommands();
+        for (const item of element.content) {
+            if (Array.isArray(item)) {
+                templateData.elementDisposables.add(( new InteractiveSessionFollowups(
+                    templateData.value,
+                    item,
+                    undefined,
+                    followup => this._onDidClickFollowup.fire(followup)
+                )));
+            }
+            else {
+                const result = this.renderMarkdown(item, element, templateData.elementDisposables, templateData);
+                for (const codeElement of result.element.querySelectorAll('code')) {
+                    if (codeElement.textContent && slashCommands.find(command => codeElement.textContent === `/${command.command}`)) {
+                        codeElement.classList.add('interactive-slash-command');
+                    }
+                }
+                templateData.value.appendChild(result.element);
+                templateData.elementDisposables.add(result);
+            }
+        }
+    }
+    doNextProgressiveRender(element, index, templateData, isInRenderElement, disposables) {
+        if (!this._isVisible) {
+            return true;
+        }
+        disposables.clear();
+        let isFullyRendered = false;
+        if (element.isCanceled) {
+            this.traceLayout('runProgressiveRender', `canceled, index=${index}`);
+            element.renderData = undefined;
+            this.basicRenderElement(element.response.value, element, index, templateData);
+            isFullyRendered = true;
+        }
+        else {
+            const renderValue = this.getWordsForProgressiveRender(element);
+            isFullyRendered = !!element.renderData?.isFullyRendered;
+            if (isFullyRendered) {
+                this.traceLayout('runProgressiveRender', `end progressive render, index=${index}`);
+                if (element.isComplete) {
+                    this.traceLayout('runProgressiveRender', `and disposing renderData, response is complete, index=${index}`);
+                    element.renderData = undefined;
+                }
+                else {
+                    this.traceLayout('runProgressiveRender', `Rendered all available words, but model is not complete.`);
+                }
+                disposables.clear();
+                this.basicRenderElement(element.response.value, element, index, templateData);
+            }
+            else if (renderValue) {
+                element.renderData = {
+                    renderedWordCount: renderValue.actualWordCount,
+                    lastRenderTime: Date.now(),
+                    isFullyRendered: renderValue.isFullString
+                };
+                const plusCursor = renderValue.value.match(/```\s*$/) ?
+                    renderValue.value :
+                    renderValue.value + ` ${InteractiveListItemRenderer.cursorCharacter}`;
+                const result = this.renderMarkdown(( new MarkdownString(plusCursor)), element, disposables, templateData, true);
+                dom.clearNode(templateData.value);
+                templateData.value.appendChild(result.element);
+                disposables.add(result);
+            }
+            else {
+                return false;
+            }
+        }
+        const height = templateData.rowContainer.offsetHeight;
+        element.currentRenderedHeight = height;
+        if (!isInRenderElement) {
+            this._onDidChangeItemHeight.fire({ element, height: templateData.rowContainer.offsetHeight });
+        }
+        return !!isFullyRendered;
+    }
+    renderMarkdown(markdown, element, disposables, templateData, fillInIncompleteTokens = false) {
+        const disposablesList = [];
+        let codeBlockIndex = 0;
+        const slashCommands = this.delegate.getSlashCommands();
+        const usedSlashCommand = slashCommands.find(s => markdown.value.startsWith(`/${s.command} `));
+        const toRender = usedSlashCommand ? markdown.value.slice(usedSlashCommand.command.length + 2) : markdown.value;
+        markdown = ( new MarkdownString(toRender));
+        const result = this.renderer.render(markdown, {
+            fillInIncompleteTokens,
+            codeBlockRendererSync: (languageId, text) => {
+                const ref = this.renderCodeBlock({ languageId, text, codeBlockIndex: codeBlockIndex++, element, parentContextKeyService: templateData.contextKeyService }, disposables);
+                disposables.add(ref.object.onDidChangeContentHeight(() => {
+                    ref.object.layout(this._currentLayoutWidth);
+                    this._onDidChangeItemHeight.fire({ element, height: templateData.rowContainer.offsetHeight });
+                }));
+                disposablesList.push(ref);
+                return ref.object.element;
+            }
+        });
+        if (usedSlashCommand) {
+            const slashCommandElement = $('span.interactive-slash-command', { title: usedSlashCommand.detail }, `/${usedSlashCommand.command} `);
+            if (result.element.firstChild?.nodeName.toLowerCase() === 'p') {
+                result.element.firstChild.insertBefore(slashCommandElement, result.element.firstChild.firstChild);
+            }
+            else {
+                result.element.insertBefore($('p', undefined, slashCommandElement), result.element.firstChild);
+            }
+        }
+        disposablesList.reverse().forEach(d => disposables.add(d));
+        return result;
+    }
+    renderCodeBlock(data, disposables) {
+        const ref = this._editorPool.get();
+        const editorInfo = ref.object;
+        editorInfo.render(data, this._currentLayoutWidth);
+        return ref;
+    }
+    getWordsForProgressiveRender(element) {
+        const renderData = element.renderData ?? { renderedWordCount: 0, lastRenderTime: 0 };
+        const rate = this.getProgressiveRenderRate(element);
+        const numWordsToRender = renderData.lastRenderTime === 0 ?
+            1 :
+            renderData.renderedWordCount +
+                Math.floor((Date.now() - renderData.lastRenderTime) / 1000 * rate);
+        if (numWordsToRender === renderData.renderedWordCount) {
+            return undefined;
+        }
+        return getNWords(element.response.value, numWordsToRender);
+    }
+    disposeElement(node, index, templateData) {
+        templateData.elementDisposables.clear();
+    }
+    disposeTemplate(templateData) {
+        templateData.templateDisposables.dispose();
+    }
+};
+InteractiveListItemRenderer.cursorCharacter = '\u258c';
+InteractiveListItemRenderer.ID = 'item';
+InteractiveListItemRenderer = ( __decorate([
+    ( __param(2, IInstantiationService)),
+    ( __param(3, IConfigurationService)),
+    ( __param(4, ILogService)),
+    ( __param(5, ICommandService)),
+    ( __param(6, IContextKeyService)),
+    ( __param(7, IInteractiveSessionService))
+], InteractiveListItemRenderer));
+let InteractiveSessionListDelegate = class InteractiveSessionListDelegate {
+    constructor(logService) {
+        this.logService = logService;
+    }
+    _traceLayout(method, message) {
+        {
+            this.logService.trace(`InteractiveSessionListDelegate#${method}: ${message}`);
+        }
+    }
+    getHeight(element) {
+        const kind = isRequestVM(element) ? 'request' : 'response';
+        const height = ('currentRenderedHeight' in element ? element.currentRenderedHeight : undefined) ?? 200;
+        this._traceLayout('getHeight', `${kind}, height=${height}`);
+        return height;
+    }
+    getTemplateId(element) {
+        return InteractiveListItemRenderer.ID;
+    }
+    hasDynamicHeight(element) {
+        return true;
+    }
+};
+InteractiveSessionListDelegate = ( __decorate([
+    ( __param(0, ILogService))
+], InteractiveSessionListDelegate));
+class InteractiveSessionAccessibilityProvider {
+    getWidgetRole() {
+        return 'list';
+    }
+    getRole(element) {
+        return 'listitem';
+    }
+    getWidgetAriaLabel() {
+        return ( localize('interactiveSession', "Interactive Session"));
+    }
+    getAriaLabel(element) {
+        if (isRequestVM(element)) {
+            return element.messageText;
+        }
+        if (isResponseVM(element)) {
+            return element.response.value;
+        }
+        if (isWelcomeVM(element)) {
+            return ( element.content.map(c => 'value' in c ? c.value : ( c.map(followup => followup.message)).join('\n'))).join('\n');
+        }
+        return '';
+    }
+}
+const codeBlockInfosByModelUri = ( new ResourceMap());
+const defaultCodeblockPadding = 10;
+let CodeBlockPart = class CodeBlockPart extends Disposable {
+    constructor(options, instantiationService, contextKeyService, languageService, modelService) {
+        super();
+        this.options = options;
+        this.languageService = languageService;
+        this.modelService = modelService;
+        this._onDidChangeContentHeight = this._register(( new Emitter()));
+        this.onDidChangeContentHeight = this._onDidChangeContentHeight.event;
+        this.currentScrollWidth = 0;
+        this.element = $('.interactive-result-editor-wrapper');
+        this.contextKeyService = this._register(contextKeyService.createScoped(this.element));
+        const scopedInstantiationService = instantiationService.createChild(( new ServiceCollection([IContextKeyService, this.contextKeyService])));
+        this.toolbar = this._register(scopedInstantiationService.createInstance(MenuWorkbenchToolBar, this.element, MenuId.InteractiveSessionCodeBlock, {
+            menuOptions: {
+                shouldForwardArgs: true
+            }
+        }));
+        const editorElement = dom.append(this.element, $('.interactive-result-editor'));
+        this.editor = this._register(scopedInstantiationService.createInstance(CodeEditorWidget, editorElement, {
+            ...getSimpleEditorOptions(),
+            readOnly: true,
+            lineNumbers: 'off',
+            selectOnLineNumbers: true,
+            scrollBeyondLastLine: false,
+            lineDecorationsWidth: 8,
+            dragAndDrop: false,
+            padding: { top: defaultCodeblockPadding, bottom: defaultCodeblockPadding },
+            mouseWheelZoom: false,
+            scrollbar: {
+                alwaysConsumeMouseWheel: false
+            },
+            ...this.getEditorOptionsFromConfig()
+        }, {
+            isSimpleWidget: true,
+            contributions: EditorExtensionsRegistry.getSomeEditorContributions([
+                MenuPreventer.ID,
+                SelectionClipboardContributionID,
+                ContextMenuController.ID,
+                WordHighlighterContribution.ID,
+                ViewportSemanticTokensContribution.ID,
+                BracketMatchingController.ID,
+                SmartSelectController.ID,
+            ])
+        }));
+        this._register(this.options.onDidChange(() => {
+            this.editor.updateOptions(this.getEditorOptionsFromConfig());
+        }));
+        this._register(this.editor.onDidScrollChange(e => {
+            this.currentScrollWidth = e.scrollWidth;
+        }));
+        this._register(this.editor.onDidContentSizeChange(e => {
+            if (e.contentHeightChanged) {
+                this._onDidChangeContentHeight.fire(e.contentHeight);
+            }
+        }));
+        this._register(this.editor.onDidBlurEditorWidget(() => {
+            WordHighlighterContribution.get(this.editor)?.stopHighlighting();
+        }));
+        this._register(this.editor.onDidFocusEditorWidget(() => {
+            WordHighlighterContribution.get(this.editor)?.restoreViewState(true);
+        }));
+        const vscodeLanguageId = this.languageService.getLanguageIdByLanguageName('javascript');
+        this.textModel = this._register(this.modelService.createModel('', this.languageService.createById(vscodeLanguageId), undefined));
+        this.editor.setModel(this.textModel);
+    }
+    updatePaddingForLayout() {
+        const horizontalScrollbarVisible = this.currentScrollWidth > this.editor.getLayoutInfo().contentWidth;
+        const scrollbarHeight = this.editor.getLayoutInfo().horizontalScrollbarHeight;
+        const bottomPadding = horizontalScrollbarVisible ?
+            Math.max(defaultCodeblockPadding - scrollbarHeight, 2) :
+            defaultCodeblockPadding;
+        this.editor.updateOptions({ padding: { top: defaultCodeblockPadding, bottom: bottomPadding } });
+    }
+    getEditorOptionsFromConfig() {
+        return {
+            wordWrap: this.options.configuration.resultEditor.wordWrap,
+            fontLigatures: this.options.configuration.resultEditor.fontLigatures,
+            bracketPairColorization: this.options.configuration.resultEditor.bracketPairColorization,
+            fontFamily: this.options.configuration.resultEditor.fontFamily === 'default' ?
+                EDITOR_FONT_DEFAULTS.fontFamily :
+                this.options.configuration.resultEditor.fontFamily,
+            fontSize: this.options.configuration.resultEditor.fontSize,
+            fontWeight: this.options.configuration.resultEditor.fontWeight,
+            lineHeight: this.options.configuration.resultEditor.lineHeight,
+        };
+    }
+    layout(width) {
+        const realContentHeight = this.editor.getContentHeight();
+        const editorBorder = 2;
+        this.editor.layout({ width: width - editorBorder, height: realContentHeight });
+        this.updatePaddingForLayout();
+    }
+    render(data, width) {
+        this.contextKeyService.updateParent(data.parentContextKeyService);
+        if (this.options.configuration.resultEditor.wordWrap === 'on') {
+            this.layout(width);
+        }
+        const text = this.fixCodeText(data.text, data.languageId);
+        this.setText(text);
+        const vscodeLanguageId = withNullAsUndefined(this.languageService.getLanguageIdByLanguageName(data.languageId));
+        this.setLanguage(vscodeLanguageId);
+        this.layout(width);
+        if (isResponseVM(data.element) && data.element.providerResponseId) {
+            codeBlockInfosByModelUri.set(this.textModel.uri, {
+                providerId: data.element.providerId,
+                responseId: data.element.providerResponseId,
+                codeBlockIndex: data.codeBlockIndex
+            });
+        }
+        else {
+            codeBlockInfosByModelUri.delete(this.textModel.uri);
+        }
+        this.toolbar.context = {
+            code: data.text,
+            codeBlockIndex: data.codeBlockIndex,
+            element: data.element,
+            languageId: vscodeLanguageId
+        };
+    }
+    fixCodeText(text, languageId) {
+        if (languageId === 'php') {
+            if (!text.trim().startsWith('<')) {
+                return `<?php\n${text}\n?>`;
+            }
+        }
+        return text;
+    }
+    setText(newText) {
+        let currentText = this.textModel.getLinesContent().join('\n');
+        if (newText === currentText) {
+            return;
+        }
+        let removedChars = 0;
+        if (currentText.endsWith(` ${InteractiveListItemRenderer.cursorCharacter}`)) {
+            removedChars = 2;
+        }
+        else if (currentText.endsWith(InteractiveListItemRenderer.cursorCharacter)) {
+            removedChars = 1;
+        }
+        if (removedChars > 0) {
+            currentText = currentText.slice(0, currentText.length - removedChars);
+        }
+        if (newText.startsWith(currentText)) {
+            const text = newText.slice(currentText.length);
+            const lastLine = this.textModel.getLineCount();
+            const lastCol = this.textModel.getLineMaxColumn(lastLine);
+            const insertAtCol = lastCol - removedChars;
+            this.textModel.applyEdits([{ range: ( new Range(lastLine, insertAtCol, lastLine, lastCol)), text }]);
+        }
+        else {
+            this.textModel.setValue(newText);
+        }
+    }
+    setLanguage(vscodeLanguageId) {
+        this.textModel.setLanguage(vscodeLanguageId ?? PLAINTEXT_LANGUAGE_ID);
+    }
+};
+CodeBlockPart = ( __decorate([
+    ( __param(1, IInstantiationService)),
+    ( __param(2, IContextKeyService)),
+    ( __param(3, ILanguageService)),
+    ( __param(4, IModelService))
+], CodeBlockPart));
+let EditorPool = class EditorPool extends Disposable {
+    get inUse() {
+        return this._pool.inUse;
+    }
+    constructor(options, instantiationService) {
+        super();
+        this.options = options;
+        this.instantiationService = instantiationService;
+        this._pool = this._register(( new ResourcePool(() => this.editorFactory())));
+    }
+    editorFactory() {
+        return this.instantiationService.createInstance(CodeBlockPart, this.options);
+    }
+    get() {
+        const object = this._pool.get();
+        return {
+            object,
+            dispose: () => this._pool.release(object)
+        };
+    }
+};
+EditorPool = ( __decorate([
+    ( __param(1, IInstantiationService))
+], EditorPool));
+class ResourcePool extends Disposable {
+    get inUse() {
+        return this._inUse;
+    }
+    constructor(_itemFactory) {
+        super();
+        this._itemFactory = _itemFactory;
+        this.pool = [];
+        this._inUse = ( new Set());
+    }
+    get() {
+        if (this.pool.length > 0) {
+            const item = this.pool.pop();
+            this._inUse.add(item);
+            return item;
+        }
+        const item = this._register(this._itemFactory());
+        this._inUse.add(item);
+        return item;
+    }
+    release(item) {
+        this._inUse.delete(item);
+        this.pool.push(item);
+    }
+}
+class InteractiveSessionVoteButton extends MenuEntryActionViewItem {
+    render(container) {
+        super.render(container);
+        container.classList.toggle('checked', this.action.checked);
+    }
+}
+export { InteractiveListItemRenderer, InteractiveSessionAccessibilityProvider, InteractiveSessionListDelegate, codeBlockInfosByModelUri };