@codingame/monaco-vscode-extensions-service-override 1.83.8 → 1.83.9

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

@@ -0,0 +1,543 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import './media/panel.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 { basename } from 'monaco-editor/esm/vs/base/common/resources.js';
+import { isDiffEditor, isCodeEditor } from 'monaco-editor/esm/vs/editor/browser/editorBrowser.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { IThemeService } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
+import { CommentsModel, ResourceWithCommentThreads, CommentNode } from '../common/commentModel.js';
+import { ICommentService } from 'vscode/vscode/vs/workbench/contrib/comments/browser/commentService';
+import { IEditorService, SIDE_GROUP, ACTIVE_GROUP } from 'vscode/vscode/vs/workbench/services/editor/common/editorService';
+import { CommandsRegistry } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
+import { textLinkForeground, textLinkActiveForeground, focusBorder, textPreformatForeground } from 'monaco-editor/esm/vs/platform/theme/common/colorRegistry.js';
+import { ResourceLabels } from 'vscode/vscode/vs/workbench/browser/labels';
+import { COMMENTS_VIEW_ID, Filter, CommentsList, COMMENTS_VIEW_TITLE } from './commentsTreeViewer.js';
+import { ViewAction, FilterViewPane } from 'vscode/vscode/vs/workbench/browser/parts/views/viewPane';
+import { IViewsService, IViewDescriptorService } from 'vscode/vscode/vs/workbench/common/views';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { RawContextKey, ContextKeyExpr, IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { IContextMenuService } from 'monaco-editor/esm/vs/platform/contextview/browser/contextView.js';
+import { IKeybindingService } from 'monaco-editor/esm/vs/platform/keybinding/common/keybinding.js';
+import { IOpenerService } from 'monaco-editor/esm/vs/platform/opener/common/opener.js';
+import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
+import { IUriIdentityService } from 'monaco-editor/esm/vs/platform/uriIdentity/common/uriIdentity.js';
+import { registerAction2, MenuId } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
+import { Codicon } from 'monaco-editor/esm/vs/base/common/codicons.js';
+import { TextModel } from 'monaco-editor/esm/vs/editor/common/model/textModel.js';
+import { CommentsViewFilterFocusContextKey } from './comments.js';
+import { CommentsFilters } from './commentsViewActions.js';
+import { Memento } from 'vscode/vscode/vs/workbench/common/memento';
+import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
+import { FilterOptions } from './commentsFilterOptions.js';
+import { IActivityService, NumberBadge } from 'vscode/vscode/vs/workbench/services/activity/common/activity';
+import { CommentThreadState } from 'monaco-editor/esm/vs/editor/common/languages.js';
+import { MutableDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { Iterable } from 'monaco-editor/esm/vs/base/common/iterator.js';
+import { CommentController } from './commentsController.js';
+import { Range } from 'monaco-editor/esm/vs/editor/common/core/range.js';
+import { registerNavigableContainer } from 'vscode/vscode/vs/workbench/browser/actions/widgetNavigationCommands';
+
+const CONTEXT_KEY_HAS_COMMENTS = ( new RawContextKey('commentsView.hasComments', false));
+const CONTEXT_KEY_SOME_COMMENTS_EXPANDED = ( new RawContextKey('commentsView.someCommentsExpanded', false));
+const VIEW_STORAGE_ID = 'commentsViewState';
+function createResourceCommentsIterator(model) {
+    return ( Iterable.map(model.resourceCommentThreads, m => {
+        const CommentNodeIt = Iterable.from(m.commentThreads);
+        const children = ( Iterable.map(CommentNodeIt, r => ({ element: r })));
+        return { element: m, children };
+    }));
+}
+let CommentsPanel = class CommentsPanel extends FilterViewPane {
+    constructor(options, instantiationService, viewDescriptorService, editorService, configurationService, contextKeyService, contextMenuService, keybindingService, openerService, themeService, commentService, telemetryService, uriIdentityService, activityService, storageService) {
+        const stateMemento = ( new Memento(VIEW_STORAGE_ID, storageService));
+        const viewState = stateMemento.getMemento(1 , 1 );
+        super({
+            ...options,
+            filterOptions: {
+                placeholder: ( nls.localizeWithPath(
+                    'vs/workbench/contrib/comments/browser/commentsView',
+                    'comments.filter.placeholder',
+                    "Filter (e.g. text, author)"
+                )),
+                ariaLabel: ( nls.localizeWithPath(
+                    'vs/workbench/contrib/comments/browser/commentsView',
+                    'comments.filter.ariaLabel',
+                    "Filter comments"
+                )),
+                history: viewState['filterHistory'] || [],
+                text: viewState['filter'] || '',
+                focusContextKey: CommentsViewFilterFocusContextKey.key
+            }
+        }, keybindingService, contextMenuService, configurationService, contextKeyService, viewDescriptorService, instantiationService, openerService, themeService, telemetryService);
+        this.editorService = editorService;
+        this.commentService = commentService;
+        this.uriIdentityService = uriIdentityService;
+        this.activityService = activityService;
+        this.totalComments = 0;
+        this.totalUnresolved = 0;
+        this.activity = this._register(( new MutableDisposable()));
+        this.currentHeight = 0;
+        this.currentWidth = 0;
+        this.cachedFilterStats = undefined;
+        this.onDidChangeVisibility = this.onDidChangeBodyVisibility;
+        this.hasCommentsContextKey = CONTEXT_KEY_HAS_COMMENTS.bindTo(contextKeyService);
+        this.someCommentsExpandedContextKey = CONTEXT_KEY_SOME_COMMENTS_EXPANDED.bindTo(contextKeyService);
+        this.stateMemento = stateMemento;
+        this.viewState = viewState;
+        this.filters = this._register(( new CommentsFilters({
+            showResolved: this.viewState['showResolved'] !== false,
+            showUnresolved: this.viewState['showUnresolved'] !== false,
+        }, this.contextKeyService)));
+        this.filter = ( new Filter(( new FilterOptions(
+            this.filterWidget.getFilterText(),
+            this.filters.showResolved,
+            this.filters.showUnresolved
+        ))));
+        this._register(this.filters.onDidChange((event) => {
+            if (event.showResolved || event.showUnresolved) {
+                this.updateFilter();
+            }
+        }));
+        this._register(this.filterWidget.onDidChangeFilterText(() => this.updateFilter()));
+    }
+    updateBadge(unresolved) {
+        if (unresolved === this.totalUnresolved) {
+            return;
+        }
+        this.totalUnresolved = unresolved;
+        const message = ( nls.localizeWithPath(
+            'vs/workbench/contrib/comments/browser/commentsView',
+            'totalUnresolvedComments',
+            '{0} Unresolved Comments',
+            this.totalUnresolved
+        ));
+        this.activity.value = this.activityService.showViewActivity(this.id, { badge: ( new NumberBadge(this.totalUnresolved, () => message)) });
+    }
+    saveState() {
+        this.viewState['filter'] = this.filterWidget.getFilterText();
+        this.viewState['filterHistory'] = this.filterWidget.getHistory();
+        this.viewState['showResolved'] = this.filters.showResolved;
+        this.viewState['showUnresolved'] = this.filters.showUnresolved;
+        this.stateMemento.saveMemento();
+        super.saveState();
+    }
+    render() {
+        super.render();
+        this._register(registerNavigableContainer({
+            focusNotifiers: [this, this.filterWidget],
+            focusNextWidget: () => {
+                if (this.filterWidget.hasFocus()) {
+                    this.focus();
+                }
+            },
+            focusPreviousWidget: () => {
+                if (!this.filterWidget.hasFocus()) {
+                    this.focusFilter();
+                }
+            }
+        }));
+    }
+    focusFilter() {
+        this.filterWidget.focus();
+    }
+    clearFilterText() {
+        this.filterWidget.setFilterText('');
+    }
+    getFilterStats() {
+        if (!this.cachedFilterStats) {
+            this.cachedFilterStats = {
+                total: this.totalComments,
+                filtered: this.tree?.getVisibleItemCount() ?? 0
+            };
+        }
+        return this.cachedFilterStats;
+    }
+    updateFilter() {
+        this.filter.options = ( new FilterOptions(
+            this.filterWidget.getFilterText(),
+            this.filters.showResolved,
+            this.filters.showUnresolved
+        ));
+        this.tree?.filterComments();
+        this.cachedFilterStats = undefined;
+        const { total, filtered } = this.getFilterStats();
+        this.filterWidget.updateBadge(total === filtered || total === 0 ? undefined : ( nls.localizeWithPath(
+            'vs/workbench/contrib/comments/browser/commentsView',
+            'showing filtered results',
+            "Showing {0} of {1}",
+            filtered,
+            total
+        )));
+        this.filterWidget.checkMoreFilters(!this.filters.showResolved || !this.filters.showUnresolved);
+    }
+    renderBody(container) {
+        super.renderBody(container);
+        container.classList.add('comments-panel');
+        const domContainer = dom.append(container, dom.$('.comments-panel-container'));
+        this.treeContainer = dom.append(domContainer, dom.$('.tree-container'));
+        this.treeContainer.classList.add('file-icon-themable-tree', 'show-file-icons');
+        this.commentsModel = ( new CommentsModel());
+        this.cachedFilterStats = undefined;
+        this.createTree();
+        this.createMessageBox(domContainer);
+        this._register(this.commentService.onDidSetAllCommentThreads(this.onAllCommentsChanged, this));
+        this._register(this.commentService.onDidUpdateCommentThreads(this.onCommentsUpdated, this));
+        this._register(this.commentService.onDidDeleteDataProvider(this.onDataProviderDeleted, this));
+        const styleElement = dom.createStyleSheet(container);
+        this.applyStyles(styleElement);
+        this._register(this.themeService.onDidColorThemeChange(_ => this.applyStyles(styleElement)));
+        this._register(this.onDidChangeBodyVisibility(visible => {
+            if (visible) {
+                this.refresh();
+            }
+        }));
+        this.renderComments();
+    }
+    focus() {
+        if (this.tree && this.tree.getHTMLElement() === document.activeElement) {
+            return;
+        }
+        if (!this.commentsModel.hasCommentThreads() && this.messageBoxContainer) {
+            this.messageBoxContainer.focus();
+        }
+        else if (this.tree) {
+            this.tree.domFocus();
+        }
+    }
+    applyStyles(styleElement) {
+        const content = [];
+        const theme = this.themeService.getColorTheme();
+        const linkColor = theme.getColor(textLinkForeground);
+        if (linkColor) {
+            content.push(`.comments-panel .comments-panel-container a { color: ${linkColor}; }`);
+        }
+        const linkActiveColor = theme.getColor(textLinkActiveForeground);
+        if (linkActiveColor) {
+            content.push(`.comments-panel .comments-panel-container a:hover, a:active { color: ${linkActiveColor}; }`);
+        }
+        const focusColor = theme.getColor(focusBorder);
+        if (focusColor) {
+            content.push(`.comments-panel .comments-panel-container a:focus { outline-color: ${focusColor}; }`);
+        }
+        const codeTextForegroundColor = theme.getColor(textPreformatForeground);
+        if (codeTextForegroundColor) {
+            content.push(`.comments-panel .comments-panel-container .text code { color: ${codeTextForegroundColor}; }`);
+        }
+        styleElement.textContent = content.join('\n');
+    }
+    async renderComments() {
+        this.treeContainer.classList.toggle('hidden', !this.commentsModel.hasCommentThreads());
+        this.renderMessage();
+        await this.tree?.setChildren(null, createResourceCommentsIterator(this.commentsModel));
+    }
+    collapseAll() {
+        if (this.tree) {
+            this.tree.collapseAll();
+            this.tree.setSelection([]);
+            this.tree.setFocus([]);
+            this.tree.domFocus();
+            this.tree.focusFirst();
+        }
+    }
+    expandAll() {
+        if (this.tree) {
+            this.tree.expandAll();
+            this.tree.setSelection([]);
+            this.tree.setFocus([]);
+            this.tree.domFocus();
+            this.tree.focusFirst();
+        }
+    }
+    get hasRendered() {
+        return !!this.tree;
+    }
+    layoutBodyContent(height = this.currentHeight, width = this.currentWidth) {
+        if (this.messageBoxContainer) {
+            this.messageBoxContainer.style.height = `${height}px`;
+        }
+        this.tree?.layout(height, width);
+        this.currentHeight = height;
+        this.currentWidth = width;
+    }
+    createMessageBox(parent) {
+        this.messageBoxContainer = dom.append(parent, dom.$('.message-box-container'));
+        this.messageBoxContainer.setAttribute('tabIndex', '0');
+    }
+    renderMessage() {
+        this.messageBoxContainer.textContent = this.commentsModel.getMessage();
+        this.messageBoxContainer.classList.toggle('hidden', this.commentsModel.hasCommentThreads());
+    }
+    createTree() {
+        this.treeLabels = this._register(this.instantiationService.createInstance(ResourceLabels, this));
+        this.tree = this._register(this.instantiationService.createInstance(CommentsList, this.treeLabels, this.treeContainer, {
+            overrideStyles: { listBackground: this.getBackgroundColor() },
+            selectionNavigation: true,
+            filter: this.filter,
+            keyboardNavigationLabelProvider: {
+                getKeyboardNavigationLabel: (item) => {
+                    return undefined;
+                }
+            },
+            accessibilityProvider: {
+                getAriaLabel(element) {
+                    if (element instanceof CommentsModel) {
+                        return ( nls.localizeWithPath(
+                            'vs/workbench/contrib/comments/browser/commentsView',
+                            'rootCommentsLabel',
+                            "Comments for current workspace"
+                        ));
+                    }
+                    if (element instanceof ResourceWithCommentThreads) {
+                        return ( nls.localizeWithPath(
+                            'vs/workbench/contrib/comments/browser/commentsView',
+                            'resourceWithCommentThreadsLabel',
+                            "Comments in {0}, full path {1}",
+                            basename(element.resource),
+                            element.resource.fsPath
+                        ));
+                    }
+                    if (element instanceof CommentNode) {
+                        if (element.range) {
+                            return ( nls.localizeWithPath(
+                                'vs/workbench/contrib/comments/browser/commentsView',
+                                'resourceWithCommentLabel',
+                                "Comment from ${0} at line {1} column {2} in {3}, source: {4}",
+                                element.comment.userName,
+                                element.range.startLineNumber,
+                                element.range.startColumn,
+                                basename(element.resource),
+                                (typeof element.comment.body === 'string') ? element.comment.body : element.comment.body.value
+                            ));
+                        }
+                        else {
+                            return ( nls.localizeWithPath(
+                                'vs/workbench/contrib/comments/browser/commentsView',
+                                'resourceWithCommentLabelFile',
+                                "Comment from ${0} in {1}, source: {2}",
+                                element.comment.userName,
+                                basename(element.resource),
+                                (typeof element.comment.body === 'string') ? element.comment.body : element.comment.body.value
+                            ));
+                        }
+                    }
+                    return '';
+                },
+                getWidgetAriaLabel() {
+                    return COMMENTS_VIEW_TITLE;
+                }
+            }
+        }));
+        this._register(this.tree.onDidOpen(e => {
+            this.openFile(e.element, e.editorOptions.pinned, e.editorOptions.preserveFocus, e.sideBySide);
+        }));
+        this._register(this.tree.onDidChangeModel(() => {
+            this.updateSomeCommentsExpanded();
+        }));
+        this._register(this.tree.onDidChangeCollapseState(() => {
+            this.updateSomeCommentsExpanded();
+        }));
+    }
+    openFile(element, pinned, preserveFocus, sideBySide) {
+        if (!element) {
+            return false;
+        }
+        if (!(element instanceof ResourceWithCommentThreads || element instanceof CommentNode)) {
+            return false;
+        }
+        if (!this.commentService.isCommentingEnabled) {
+            this.commentService.enableCommenting(true);
+        }
+        const range = element instanceof ResourceWithCommentThreads ? element.commentThreads[0].range : element.range;
+        const activeEditor = this.editorService.activeTextEditorControl;
+        const currentActiveResources = isDiffEditor(activeEditor) ? [activeEditor.getOriginalEditor(), activeEditor.getModifiedEditor()]
+            : (activeEditor ? [activeEditor] : []);
+        for (const editor of currentActiveResources) {
+            const model = editor.getModel();
+            if ((model instanceof TextModel) && this.uriIdentityService.extUri.isEqual(element.resource, model.uri)) {
+                const threadToReveal = element instanceof ResourceWithCommentThreads ? element.commentThreads[0].threadId : element.threadId;
+                const commentToReveal = element instanceof ResourceWithCommentThreads ? element.commentThreads[0].comment.uniqueIdInThread : element.comment.uniqueIdInThread;
+                if (threadToReveal && isCodeEditor(editor)) {
+                    const controller = CommentController.get(editor);
+                    controller?.revealCommentThread(threadToReveal, commentToReveal, true, !preserveFocus);
+                }
+                return true;
+            }
+        }
+        const threadToReveal = element instanceof ResourceWithCommentThreads ? element.commentThreads[0].threadId : element.threadId;
+        const commentToReveal = element instanceof ResourceWithCommentThreads ? element.commentThreads[0].comment : element.comment;
+        this.editorService.openEditor({
+            resource: element.resource,
+            options: {
+                pinned: pinned,
+                preserveFocus: preserveFocus,
+                selection: range ?? ( new Range(1, 1, 1, 1))
+            }
+        }, sideBySide ? SIDE_GROUP : ACTIVE_GROUP).then(editor => {
+            if (editor) {
+                const control = editor.getControl();
+                if (threadToReveal && isCodeEditor(control)) {
+                    const controller = CommentController.get(control);
+                    controller?.revealCommentThread(threadToReveal, commentToReveal.uniqueIdInThread, true, !preserveFocus);
+                }
+            }
+        });
+        return true;
+    }
+    async refresh() {
+        if (!this.tree) {
+            return;
+        }
+        if (this.isVisible()) {
+            this.hasCommentsContextKey.set(this.commentsModel.hasCommentThreads());
+            this.treeContainer.classList.toggle('hidden', !this.commentsModel.hasCommentThreads());
+            this.cachedFilterStats = undefined;
+            this.renderMessage();
+            this.tree?.setChildren(null, createResourceCommentsIterator(this.commentsModel));
+            if (this.tree.getSelection().length === 0 && this.commentsModel.hasCommentThreads()) {
+                const firstComment = this.commentsModel.resourceCommentThreads[0].commentThreads[0];
+                if (firstComment) {
+                    this.tree.setFocus([firstComment]);
+                    this.tree.setSelection([firstComment]);
+                }
+            }
+        }
+    }
+    onAllCommentsChanged(e) {
+        this.cachedFilterStats = undefined;
+        this.commentsModel.setCommentThreads(e.ownerId, e.commentThreads);
+        this.totalComments += e.commentThreads.length;
+        let unresolved = 0;
+        for (const thread of e.commentThreads) {
+            if (thread.state === CommentThreadState.Unresolved) {
+                unresolved++;
+            }
+        }
+        this.updateBadge(unresolved);
+        this.refresh();
+    }
+    onCommentsUpdated(e) {
+        this.cachedFilterStats = undefined;
+        const didUpdate = this.commentsModel.updateCommentThreads(e);
+        this.totalComments += e.added.length;
+        this.totalComments -= e.removed.length;
+        let unresolved = 0;
+        for (const resource of this.commentsModel.resourceCommentThreads) {
+            for (const thread of resource.commentThreads) {
+                if (thread.threadState === CommentThreadState.Unresolved) {
+                    unresolved++;
+                }
+            }
+        }
+        this.updateBadge(unresolved);
+        if (didUpdate) {
+            this.refresh();
+        }
+    }
+    onDataProviderDeleted(owner) {
+        this.cachedFilterStats = undefined;
+        this.commentsModel.deleteCommentsByOwner(owner);
+        this.totalComments = 0;
+        this.refresh();
+    }
+    updateSomeCommentsExpanded() {
+        this.someCommentsExpandedContextKey.set(this.isSomeCommentsExpanded());
+    }
+    areAllCommentsExpanded() {
+        if (!this.tree) {
+            return false;
+        }
+        const navigator = this.tree.navigate();
+        while (navigator.next()) {
+            if (this.tree.isCollapsed(navigator.current())) {
+                return false;
+            }
+        }
+        return true;
+    }
+    isSomeCommentsExpanded() {
+        if (!this.tree) {
+            return false;
+        }
+        const navigator = this.tree.navigate();
+        while (navigator.next()) {
+            if (!this.tree.isCollapsed(navigator.current())) {
+                return true;
+            }
+        }
+        return false;
+    }
+};
+CommentsPanel = ( __decorate([
+    ( __param(1, IInstantiationService)),
+    ( __param(2, IViewDescriptorService)),
+    ( __param(3, IEditorService)),
+    ( __param(4, IConfigurationService)),
+    ( __param(5, IContextKeyService)),
+    ( __param(6, IContextMenuService)),
+    ( __param(7, IKeybindingService)),
+    ( __param(8, IOpenerService)),
+    ( __param(9, IThemeService)),
+    ( __param(10, ICommentService)),
+    ( __param(11, ITelemetryService)),
+    ( __param(12, IUriIdentityService)),
+    ( __param(13, IActivityService)),
+    ( __param(14, IStorageService))
+], CommentsPanel));
+CommandsRegistry.registerCommand({
+    id: 'workbench.action.focusCommentsPanel',
+    handler: async (accessor) => {
+        const viewsService = accessor.get(IViewsService);
+        viewsService.openView(COMMENTS_VIEW_ID, true);
+    }
+});
+registerAction2(class Collapse extends ViewAction {
+    constructor() {
+        super({
+            viewId: COMMENTS_VIEW_ID,
+            id: 'comments.collapse',
+            title: ( nls.localizeWithPath(
+                'vs/workbench/contrib/comments/browser/commentsView',
+                'collapseAll',
+                "Collapse All"
+            )),
+            f1: false,
+            icon: Codicon.collapseAll,
+            menu: {
+                id: MenuId.ViewTitle,
+                group: 'navigation',
+                when: ( ContextKeyExpr.and(( ContextKeyExpr.and(( ContextKeyExpr.equals('view', COMMENTS_VIEW_ID)), CONTEXT_KEY_HAS_COMMENTS)), CONTEXT_KEY_SOME_COMMENTS_EXPANDED)),
+                order: 100
+            }
+        });
+    }
+    runInView(_accessor, view) {
+        view.collapseAll();
+    }
+});
+registerAction2(class Expand extends ViewAction {
+    constructor() {
+        super({
+            viewId: COMMENTS_VIEW_ID,
+            id: 'comments.expand',
+            title: ( nls.localizeWithPath(
+                'vs/workbench/contrib/comments/browser/commentsView',
+                'expandAll',
+                "Expand All"
+            )),
+            f1: false,
+            icon: Codicon.expandAll,
+            menu: {
+                id: MenuId.ViewTitle,
+                group: 'navigation',
+                when: ( ContextKeyExpr.and(( ContextKeyExpr.and(( ContextKeyExpr.equals('view', COMMENTS_VIEW_ID)), CONTEXT_KEY_HAS_COMMENTS)), ContextKeyExpr.not(CONTEXT_KEY_SOME_COMMENTS_EXPANDED.key))),
+                order: 100
+            }
+        });
+    }
+    runInView(_accessor, view) {
+        view.expandAll();
+    }
+});
+
+export { CommentsPanel };