@codingame/monaco-vscode-api 1.85.0 → 1.85.2

package/vscode/src/vs/workbench/contrib/codeEditor/browser/find/simpleFindWidget.js

@@ -0,0 +1,388 @@
+import './simpleFindWidget.css.js';
+import * as nls from 'monaco-editor/esm/vs/nls.js';
+import * as dom from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { Widget } from 'monaco-editor/esm/vs/base/browser/ui/widget.js';
+import { Delayer } from 'monaco-editor/esm/vs/base/common/async.js';
+import { FindReplaceState } from 'monaco-editor/esm/vs/editor/contrib/find/browser/findState.js';
+import { SimpleButton, findPreviousMatchIcon, findNextMatchIcon, NLS_MATCHES_LOCATION, NLS_NO_RESULTS } from 'monaco-editor/esm/vs/editor/contrib/find/browser/findWidget.js';
+import { ContextScopedFindInput } from 'monaco-editor/esm/vs/platform/history/browser/contextScopedHistoryWidget.js';
+import { widgetClose } from 'monaco-editor/esm/vs/platform/theme/common/iconRegistry.js';
+import { registerThemingParticipant } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
+import * as strings from 'monaco-editor/esm/vs/base/common/strings.js';
+import { showHistoryKeybindingHint } from 'monaco-editor/esm/vs/platform/history/browser/historyWidgetKeybindingHint.js';
+import { status } from 'monaco-editor/esm/vs/base/browser/ui/aria/aria.js';
+import { defaultInputBoxStyles, defaultToggleStyles } from 'monaco-editor/esm/vs/platform/theme/browser/defaultStyles.js';
+import { Sash } from 'monaco-editor/esm/vs/base/browser/ui/sash/sash.js';
+import { registerColor } from 'monaco-editor/esm/vs/platform/theme/common/colorRegistry.js';
+const NLS_FIND_INPUT_LABEL = ( nls.localizeWithPath(
+    'vs/workbench/contrib/codeEditor/browser/find/simpleFindWidget',
+    'label.find',
+    "Find"
+));
+const NLS_FIND_INPUT_PLACEHOLDER = ( nls.localizeWithPath(
+    'vs/workbench/contrib/codeEditor/browser/find/simpleFindWidget',
+    'placeholder.find',
+    "Find"
+));
+const NLS_PREVIOUS_MATCH_BTN_LABEL = ( nls.localizeWithPath(
+    'vs/workbench/contrib/codeEditor/browser/find/simpleFindWidget',
+    'label.previousMatchButton',
+    "Previous Match"
+));
+const NLS_NEXT_MATCH_BTN_LABEL = ( nls.localizeWithPath(
+    'vs/workbench/contrib/codeEditor/browser/find/simpleFindWidget',
+    'label.nextMatchButton',
+    "Next Match"
+));
+const NLS_CLOSE_BTN_LABEL = ( nls.localizeWithPath(
+    'vs/workbench/contrib/codeEditor/browser/find/simpleFindWidget',
+    'label.closeButton',
+    "Close"
+));
+const SIMPLE_FIND_WIDGET_INITIAL_WIDTH = 310;
+const MATCHES_COUNT_WIDTH = 73;
+class SimpleFindWidget extends Widget {
+    constructor(options, contextViewService, contextKeyService, _keybindingService) {
+        super();
+        this._keybindingService = _keybindingService;
+        this._isVisible = false;
+        this._foundMatch = false;
+        this._width = 0;
+        this.state = ( new FindReplaceState());
+        this._matchesLimit = options.matchesLimit ?? Number.MAX_SAFE_INTEGER;
+        this._findInput = this._register(( new ContextScopedFindInput(null, contextViewService, {
+            label: NLS_FIND_INPUT_LABEL,
+            placeholder: NLS_FIND_INPUT_PLACEHOLDER,
+            validation: (value) => {
+                if (value.length === 0 || !this._findInput.getRegex()) {
+                    return null;
+                }
+                try {
+                    return null;
+                }
+                catch (e) {
+                    this._foundMatch = false;
+                    this.updateButtons(this._foundMatch);
+                    return { content: e.message };
+                }
+            },
+            showCommonFindToggles: options.showCommonFindToggles,
+            appendCaseSensitiveLabel: options.appendCaseSensitiveActionId ? this._getKeybinding(options.appendCaseSensitiveActionId) : undefined,
+            appendRegexLabel: options.appendRegexActionId ? this._getKeybinding(options.appendRegexActionId) : undefined,
+            appendWholeWordsLabel: options.appendWholeWordsActionId ? this._getKeybinding(options.appendWholeWordsActionId) : undefined,
+            showHistoryHint: () => showHistoryKeybindingHint(_keybindingService),
+            inputBoxStyles: defaultInputBoxStyles,
+            toggleStyles: defaultToggleStyles
+        }, contextKeyService)));
+        this._updateHistoryDelayer = this._register(( new Delayer(500)));
+        this._register(this._findInput.onInput(async (e) => {
+            if (!options.checkImeCompletionState || !this._findInput.isImeSessionInProgress) {
+                this._foundMatch = this._onInputChanged();
+                if (options.showResultCount) {
+                    await this.updateResultCount();
+                }
+                this.updateButtons(this._foundMatch);
+                this.focusFindBox();
+                this._delayedUpdateHistory();
+            }
+        }));
+        this._findInput.setRegex(!!this.state.isRegex);
+        this._findInput.setCaseSensitive(!!this.state.matchCase);
+        this._findInput.setWholeWords(!!this.state.wholeWord);
+        this._register(this._findInput.onDidOptionChange(() => {
+            this.state.change({
+                isRegex: this._findInput.getRegex(),
+                wholeWord: this._findInput.getWholeWords(),
+                matchCase: this._findInput.getCaseSensitive()
+            }, true);
+        }));
+        this._register(this.state.onFindReplaceStateChange(() => {
+            this._findInput.setRegex(this.state.isRegex);
+            this._findInput.setWholeWords(this.state.wholeWord);
+            this._findInput.setCaseSensitive(this.state.matchCase);
+            this.findFirst();
+        }));
+        this.prevBtn = this._register(( new SimpleButton({
+            label: NLS_PREVIOUS_MATCH_BTN_LABEL + (options.previousMatchActionId ? this._getKeybinding(options.previousMatchActionId) : ''),
+            icon: findPreviousMatchIcon,
+            onTrigger: () => {
+                this.find(true);
+            }
+        })));
+        this.nextBtn = this._register(( new SimpleButton({
+            label: NLS_NEXT_MATCH_BTN_LABEL + (options.nextMatchActionId ? this._getKeybinding(options.nextMatchActionId) : ''),
+            icon: findNextMatchIcon,
+            onTrigger: () => {
+                this.find(false);
+            }
+        })));
+        const closeBtn = this._register(( new SimpleButton({
+            label: NLS_CLOSE_BTN_LABEL + (options.closeWidgetActionId ? this._getKeybinding(options.closeWidgetActionId) : ''),
+            icon: widgetClose,
+            onTrigger: () => {
+                this.hide();
+            }
+        })));
+        this._innerDomNode = document.createElement('div');
+        this._innerDomNode.classList.add('simple-find-part');
+        this._innerDomNode.appendChild(this._findInput.domNode);
+        this._innerDomNode.appendChild(this.prevBtn.domNode);
+        this._innerDomNode.appendChild(this.nextBtn.domNode);
+        this._innerDomNode.appendChild(closeBtn.domNode);
+        this._domNode = document.createElement('div');
+        this._domNode.classList.add('simple-find-part-wrapper');
+        this._domNode.appendChild(this._innerDomNode);
+        this.onkeyup(this._innerDomNode, e => {
+            if (e.equals(9 )) {
+                this.hide();
+                e.preventDefault();
+                return;
+            }
+        });
+        this._focusTracker = this._register(dom.trackFocus(this._innerDomNode));
+        this._register(this._focusTracker.onDidFocus(this._onFocusTrackerFocus.bind(this)));
+        this._register(this._focusTracker.onDidBlur(this._onFocusTrackerBlur.bind(this)));
+        this._findInputFocusTracker = this._register(dom.trackFocus(this._findInput.domNode));
+        this._register(this._findInputFocusTracker.onDidFocus(this._onFindInputFocusTrackerFocus.bind(this)));
+        this._register(this._findInputFocusTracker.onDidBlur(this._onFindInputFocusTrackerBlur.bind(this)));
+        this._register(dom.addDisposableListener(this._innerDomNode, 'click', (event) => {
+            event.stopPropagation();
+        }));
+        if (options?.showResultCount) {
+            this._domNode.classList.add('result-count');
+            this._matchesCount = document.createElement('div');
+            this._matchesCount.className = 'matchesCount';
+            this._findInput.domNode.insertAdjacentElement('afterend', this._matchesCount);
+            this._register(this._findInput.onDidChange(async () => {
+                await this.updateResultCount();
+            }));
+            this._register(this._findInput.onDidOptionChange(async () => {
+                this._foundMatch = this._onInputChanged();
+                await this.updateResultCount();
+                this.focusFindBox();
+                this._delayedUpdateHistory();
+            }));
+        }
+        let initialMinWidth = options?.initialWidth;
+        if (initialMinWidth) {
+            initialMinWidth = initialMinWidth < SIMPLE_FIND_WIDGET_INITIAL_WIDTH ? SIMPLE_FIND_WIDGET_INITIAL_WIDTH : initialMinWidth;
+            this._domNode.style.width = `${initialMinWidth}px`;
+        }
+        if (options?.enableSash) {
+            const _initialMinWidth = initialMinWidth ?? SIMPLE_FIND_WIDGET_INITIAL_WIDTH;
+            let originalWidth = _initialMinWidth;
+            const resizeSash = this._register(( new Sash(
+                this._innerDomNode,
+                this,
+                { orientation: 0 , size: 1 }
+            )));
+            this._register(resizeSash.onDidStart(() => {
+                originalWidth = parseFloat(dom.getComputedStyle(this._domNode).width);
+            }));
+            this._register(resizeSash.onDidChange((e) => {
+                const width = originalWidth + e.startX - e.currentX;
+                if (width < _initialMinWidth) {
+                    return;
+                }
+                this._domNode.style.width = `${width}px`;
+            }));
+            this._register(resizeSash.onDidReset(e => {
+                const currentWidth = parseFloat(dom.getComputedStyle(this._domNode).width);
+                if (currentWidth === _initialMinWidth) {
+                    this._domNode.style.width = '100%';
+                }
+                else {
+                    this._domNode.style.width = `${_initialMinWidth}px`;
+                }
+            }));
+        }
+    }
+    getVerticalSashLeft(_sash) {
+        return 0;
+    }
+    get inputValue() {
+        return this._findInput.getValue();
+    }
+    get focusTracker() {
+        return this._focusTracker;
+    }
+    _getKeybinding(actionId) {
+        const kb = this._keybindingService?.lookupKeybinding(actionId);
+        if (!kb) {
+            return '';
+        }
+        return ` (${kb.getLabel()})`;
+    }
+    dispose() {
+        super.dispose();
+        if (this._domNode && this._domNode.parentElement) {
+            this._domNode.parentElement.removeChild(this._domNode);
+        }
+    }
+    isVisible() {
+        return this._isVisible;
+    }
+    getDomNode() {
+        return this._domNode;
+    }
+    getFindInputDomNode() {
+        return this._findInput.domNode;
+    }
+    reveal(initialInput, animated = true) {
+        if (initialInput) {
+            this._findInput.setValue(initialInput);
+        }
+        if (this._isVisible) {
+            this._findInput.select();
+            return;
+        }
+        this._isVisible = true;
+        this.updateResultCount();
+        this.layout();
+        setTimeout(() => {
+            this._innerDomNode.classList.toggle('suppress-transition', !animated);
+            this._innerDomNode.classList.add('visible', 'visible-transition');
+            this._innerDomNode.setAttribute('aria-hidden', 'false');
+            this._findInput.select();
+            if (!animated) {
+                setTimeout(() => {
+                    this._innerDomNode.classList.remove('suppress-transition');
+                }, 0);
+            }
+        }, 0);
+    }
+    show(initialInput) {
+        if (initialInput && !this._isVisible) {
+            this._findInput.setValue(initialInput);
+        }
+        this._isVisible = true;
+        this.layout();
+        setTimeout(() => {
+            this._innerDomNode.classList.add('visible', 'visible-transition');
+            this._innerDomNode.setAttribute('aria-hidden', 'false');
+        }, 0);
+    }
+    hide(animated = true) {
+        if (this._isVisible) {
+            this._innerDomNode.classList.toggle('suppress-transition', !animated);
+            this._innerDomNode.classList.remove('visible-transition');
+            this._innerDomNode.setAttribute('aria-hidden', 'true');
+            setTimeout(() => {
+                this._isVisible = false;
+                this.updateButtons(this._foundMatch);
+                this._innerDomNode.classList.remove('visible', 'suppress-transition');
+            }, animated ? 200 : 0);
+        }
+    }
+    layout(width = this._width) {
+        this._width = width;
+        if (!this._isVisible) {
+            return;
+        }
+        if (this._matchesCount) {
+            let reducedFindWidget = false;
+            if (SIMPLE_FIND_WIDGET_INITIAL_WIDTH + MATCHES_COUNT_WIDTH + 28 >= width) {
+                reducedFindWidget = true;
+            }
+            this._innerDomNode.classList.toggle('reduced-find-widget', reducedFindWidget);
+        }
+    }
+    _delayedUpdateHistory() {
+        this._updateHistoryDelayer.trigger(this._updateHistory.bind(this));
+    }
+    _updateHistory() {
+        this._findInput.inputBox.addToHistory();
+    }
+    _getRegexValue() {
+        return this._findInput.getRegex();
+    }
+    _getWholeWordValue() {
+        return this._findInput.getWholeWords();
+    }
+    _getCaseSensitiveValue() {
+        return this._findInput.getCaseSensitive();
+    }
+    updateButtons(foundMatch) {
+        const hasInput = this.inputValue.length > 0;
+        this.prevBtn.setEnabled(this._isVisible && hasInput && foundMatch);
+        this.nextBtn.setEnabled(this._isVisible && hasInput && foundMatch);
+    }
+    focusFindBox() {
+        this.nextBtn.focus();
+        this._findInput.inputBox.focus();
+    }
+    async updateResultCount() {
+        if (!this._matchesCount) {
+            this.updateButtons(this._foundMatch);
+            return;
+        }
+        const count = await this._getResultCount();
+        this._matchesCount.innerText = '';
+        const showRedOutline = (this.inputValue.length > 0 && count?.resultCount === 0);
+        this._matchesCount.classList.toggle('no-results', showRedOutline);
+        let label = '';
+        if (count?.resultCount) {
+            let matchesCount = String(count.resultCount);
+            if (count.resultCount >= this._matchesLimit) {
+                matchesCount += '+';
+            }
+            let matchesPosition = String(count.resultIndex + 1);
+            if (matchesPosition === '0') {
+                matchesPosition = '?';
+            }
+            label = strings.format(NLS_MATCHES_LOCATION, matchesPosition, matchesCount);
+        }
+        else {
+            label = NLS_NO_RESULTS;
+        }
+        status(this._announceSearchResults(label, this.inputValue));
+        this._matchesCount.appendChild(document.createTextNode(label));
+        this._foundMatch = !!count && count.resultCount > 0;
+        this.updateButtons(this._foundMatch);
+    }
+    changeState(state) {
+        this.state.change(state, false);
+    }
+    _announceSearchResults(label, searchString) {
+        if (!searchString) {
+            return ( nls.localizeWithPath(
+                'vs/workbench/contrib/codeEditor/browser/find/simpleFindWidget',
+                'ariaSearchNoInput',
+                "Enter search input"
+            ));
+        }
+        if (label === NLS_NO_RESULTS) {
+            return searchString === ''
+                ? ( nls.localizeWithPath(
+                'vs/workbench/contrib/codeEditor/browser/find/simpleFindWidget',
+                'ariaSearchNoResultEmpty',
+                "{0} found",
+                label
+            ))
+                : ( nls.localizeWithPath(
+                'vs/workbench/contrib/codeEditor/browser/find/simpleFindWidget',
+                'ariaSearchNoResult',
+                "{0} found for '{1}'",
+                label,
+                searchString
+            ));
+        }
+        return ( nls.localizeWithPath(
+            'vs/workbench/contrib/codeEditor/browser/find/simpleFindWidget',
+            'ariaSearchNoResultWithLineNumNoCurrentMatch',
+            "{0} found for '{1}'",
+            label,
+            searchString
+        ));
+    }
+}
+const simpleFindWidgetSashBorder = registerColor('simpleFindWidget.sashBorder', { dark: '#454545', light: '#C8C8C8', hcDark: '#6FC3DF', hcLight: '#0F4A85' }, ( nls.localizeWithPath(
+    'vs/workbench/contrib/codeEditor/browser/find/simpleFindWidget',
+    'simpleFindWidget.sashBorder',
+    'Border color of the sash border.'
+)));
+registerThemingParticipant((theme, collector) => {
+    const resizeBorderBackground = theme.getColor(simpleFindWidgetSashBorder);
+    collector.addRule(`.monaco-workbench .simple-find-part .monaco-sash { background-color: ${resizeBorderBackground}; border-color: ${resizeBorderBackground} }`);
+});
+export { SimpleFindWidget, simpleFindWidgetSashBorder };

package/vscode/src/vs/workbench/contrib/codeEditor/browser/languageConfigurationExtensionPoint.js

@@ -1,7 +1,7 @@
 import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
 import * as nls from 'monaco-editor/esm/vs/nls.js';
 import { parse, getNodeType } from 'monaco-editor/esm/vs/base/common/json.js';
-import * as types from 'monaco-editor/esm/vs/base/common/types.js';
+import * as Types from 'monaco-editor/esm/vs/base/common/types.js';
 import { IndentAction } from 'monaco-editor/esm/vs/editor/common/languages/languageConfiguration.js';
 import { ILanguageConfigurationService } from 'monaco-editor/esm/vs/editor/common/languages/languageConfigurationRegistry.js';
 import { ILanguageService } from 'monaco-editor/esm/vs/editor/common/languages/language.js';
@@ -93,7 +93,7 @@ let LanguageConfigurationFileHandler = class LanguageConfigurationFileHandler ex
         if (typeof source === 'undefined') {
             return undefined;
         }
-        if (!types.isObject(source)) {
+        if (!Types.isObject(source)) {
             console.warn(`[${languageId}]: language configuration: expected \`comments\` to be an object.`);
             return undefined;
         }
@@ -160,7 +160,7 @@ let LanguageConfigurationFileHandler = class LanguageConfigurationFileHandler ex
                 result.push({ open: pair[0], close: pair[1] });
             }
             else {
-                if (!types.isObject(pair)) {
+                if (!Types.isObject(pair)) {
                     console.warn(`[${languageId}]: language configuration: expected \`autoClosingPairs[${i}]\` to be an array of two strings or an object.`);
                     continue;
                 }
@@ -205,7 +205,7 @@ let LanguageConfigurationFileHandler = class LanguageConfigurationFileHandler ex
                 result.push({ open: pair[0], close: pair[1] });
             }
             else {
-                if (!types.isObject(pair)) {
+                if (!Types.isObject(pair)) {
                     console.warn(`[${languageId}]: language configuration: expected \`surroundingPairs[${i}]\` to be an array of two strings or an object.`);
                     continue;
                 }
@@ -255,11 +255,11 @@ let LanguageConfigurationFileHandler = class LanguageConfigurationFileHandler ex
         let result = undefined;
         for (let i = 0, len = source.length; i < len; i++) {
             const onEnterRule = source[i];
-            if (!types.isObject(onEnterRule)) {
+            if (!Types.isObject(onEnterRule)) {
                 console.warn(`[${languageId}]: language configuration: expected \`onEnterRules[${i}]\` to be an object.`);
                 continue;
             }
-            if (!types.isObject(onEnterRule.action)) {
+            if (!Types.isObject(onEnterRule.action)) {
                 console.warn(`[${languageId}]: language configuration: expected \`onEnterRules[${i}].action\` to be an object.`);
                 continue;
             }
@@ -365,7 +365,7 @@ let LanguageConfigurationFileHandler = class LanguageConfigurationFileHandler ex
                 return undefined;
             }
         }
-        if (types.isObject(value)) {
+        if (Types.isObject(value)) {
             if (typeof value.pattern !== 'string') {
                 console.warn(`[${languageId}]: language configuration: expected \`${confPath}.pattern\` to be a string.`);
                 return undefined;

package/vscode/src/vs/workbench/contrib/comments/browser/commentColors.js

@@ -0,0 +1,61 @@
+import * as languages from 'monaco-editor/esm/vs/editor/common/languages.js';
+import { peekViewTitleBackground } from 'monaco-editor/esm/vs/editor/contrib/peekView/browser/peekView.js';
+import * as nls from 'monaco-editor/esm/vs/nls.js';
+import { registerColor, disabledForeground, contrastBorder, listFocusOutline, transparent } from 'monaco-editor/esm/vs/platform/theme/common/colorRegistry.js';
+const resolvedCommentViewIcon = registerColor('commentsView.resolvedIcon', { dark: disabledForeground, light: disabledForeground, hcDark: contrastBorder, hcLight: contrastBorder }, ( nls.localizeWithPath(
+    'vs/workbench/contrib/comments/browser/commentColors',
+    'resolvedCommentIcon',
+    'Icon color for resolved comments.'
+)));
+const unresolvedCommentViewIcon = registerColor('commentsView.unresolvedIcon', { dark: listFocusOutline, light: listFocusOutline, hcDark: contrastBorder, hcLight: contrastBorder }, ( nls.localizeWithPath(
+    'vs/workbench/contrib/comments/browser/commentColors',
+    'unresolvedCommentIcon',
+    'Icon color for unresolved comments.'
+)));
+registerColor('editorCommentsWidget.replyInputBackground', { dark: peekViewTitleBackground, light: peekViewTitleBackground, hcDark: peekViewTitleBackground, hcLight: peekViewTitleBackground }, ( nls.localizeWithPath(
+    'vs/workbench/contrib/comments/browser/commentColors',
+    'commentReplyInputBackground',
+    'Background color for comment reply input box.'
+)));
+const resolvedCommentBorder = registerColor('editorCommentsWidget.resolvedBorder', { dark: resolvedCommentViewIcon, light: resolvedCommentViewIcon, hcDark: contrastBorder, hcLight: contrastBorder }, ( nls.localizeWithPath(
+    'vs/workbench/contrib/comments/browser/commentColors',
+    'resolvedCommentBorder',
+    'Color of borders and arrow for resolved comments.'
+)));
+const unresolvedCommentBorder = registerColor('editorCommentsWidget.unresolvedBorder', { dark: unresolvedCommentViewIcon, light: unresolvedCommentViewIcon, hcDark: contrastBorder, hcLight: contrastBorder }, ( nls.localizeWithPath(
+    'vs/workbench/contrib/comments/browser/commentColors',
+    'unresolvedCommentBorder',
+    'Color of borders and arrow for unresolved comments.'
+)));
+registerColor('editorCommentsWidget.rangeBackground', { dark: ( transparent(unresolvedCommentBorder, .1)), light: ( transparent(unresolvedCommentBorder, .1)), hcDark: ( transparent(unresolvedCommentBorder, .1)), hcLight: ( transparent(unresolvedCommentBorder, .1)) }, ( nls.localizeWithPath(
+    'vs/workbench/contrib/comments/browser/commentColors',
+    'commentThreadRangeBackground',
+    'Color of background for comment ranges.'
+)));
+registerColor('editorCommentsWidget.rangeActiveBackground', { dark: ( transparent(unresolvedCommentBorder, .1)), light: ( transparent(unresolvedCommentBorder, .1)), hcDark: ( transparent(unresolvedCommentBorder, .1)), hcLight: ( transparent(unresolvedCommentBorder, .1)) }, ( nls.localizeWithPath(
+    'vs/workbench/contrib/comments/browser/commentColors',
+    'commentThreadActiveRangeBackground',
+    'Color of background for currently selected or hovered comment range.'
+)));
+const commentThreadStateBorderColors = ( new Map([
+    [languages.CommentThreadState.Unresolved, unresolvedCommentBorder],
+    [languages.CommentThreadState.Resolved, resolvedCommentBorder],
+]));
+const commentThreadStateIconColors = ( new Map([
+    [languages.CommentThreadState.Unresolved, unresolvedCommentViewIcon],
+    [languages.CommentThreadState.Resolved, resolvedCommentViewIcon],
+]));
+const commentThreadStateColorVar = '--comment-thread-state-color';
+const commentViewThreadStateColorVar = '--comment-view-thread-state-color';
+const commentThreadStateBackgroundColorVar = '--comment-thread-state-background-color';
+function getCommentThreadStateColor(state, theme, map) {
+    const colorId = (state !== undefined) ? map.get(state) : undefined;
+    return (colorId !== undefined) ? theme.getColor(colorId) : undefined;
+}
+function getCommentThreadStateBorderColor(state, theme) {
+    return getCommentThreadStateColor(state, theme, commentThreadStateBorderColors);
+}
+function getCommentThreadStateIconColor(state, theme) {
+    return getCommentThreadStateColor(state, theme, commentThreadStateIconColors);
+}
+export { commentThreadStateBackgroundColorVar, commentThreadStateColorVar, commentViewThreadStateColorVar, getCommentThreadStateBorderColor, getCommentThreadStateIconColor };

package/vscode/src/vs/workbench/contrib/comments/browser/commentFormActions.js

@@ -0,0 +1,49 @@
+import { Button } from 'monaco-editor/esm/vs/base/browser/ui/button/button.js';
+import { DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { defaultButtonStyles } from 'monaco-editor/esm/vs/platform/theme/browser/defaultStyles.js';
+class CommentFormActions {
+    constructor(container, actionHandler, maxActions) {
+        this.container = container;
+        this.actionHandler = actionHandler;
+        this.maxActions = maxActions;
+        this._buttonElements = [];
+        this._toDispose = ( new DisposableStore());
+        this._actions = [];
+    }
+    setActions(menu, hasOnlySecondaryActions = false) {
+        this._toDispose.clear();
+        this._buttonElements.forEach(b => b.remove());
+        this._buttonElements = [];
+        const groups = menu.getActions({ shouldForwardArgs: true });
+        let isPrimary = !hasOnlySecondaryActions;
+        for (const group of groups) {
+            const [, actions] = group;
+            this._actions = actions;
+            for (const action of actions) {
+                const button = ( new Button(this.container, { secondary: !isPrimary, ...defaultButtonStyles }));
+                isPrimary = false;
+                this._buttonElements.push(button.element);
+                this._toDispose.add(button);
+                this._toDispose.add(button.onDidClick(() => this.actionHandler(action)));
+                button.enabled = action.enabled;
+                button.label = action.label;
+                if ((this.maxActions !== undefined) && (this._buttonElements.length >= this.maxActions)) {
+                    console.warn(`An extension has contributed more than the allowable number of actions to a comments menu.`);
+                    return;
+                }
+            }
+        }
+    }
+    triggerDefaultAction() {
+        if (this._actions.length) {
+            const lastAction = this._actions[0];
+            if (lastAction.enabled) {
+                return this.actionHandler(lastAction);
+            }
+        }
+    }
+    dispose() {
+        this._toDispose.dispose();
+    }
+}
+export { CommentFormActions };