@theia/plugin-ext 1.61.0 → 1.62.0

package/src/main/browser/comments/comment-thread-widget.tsx

@@ -27,16 +27,20 @@ import * as React from '@theia/core/shared/react';
 import { MouseTargetType } from '@theia/editor/lib/browser';
 import { CommentsService } from './comments-service';
 import {
-    ActionMenuNode,
+    CommandMenu,
     CommandRegistry,
     CompoundMenuNode,
+    isObject,
+    DisposableCollection,
     MenuModelRegistry,
     MenuPath
 } from '@theia/core/lib/common';
-import { CommentsContextKeyService } from './comments-context-key-service';
+import { CommentsContext } from './comments-context';
 import { RefObject } from '@theia/core/shared/react';
 import * as monaco from '@theia/monaco-editor-core';
 import { createRoot, Root } from '@theia/core/shared/react-dom/client';
+import { CommentAuthorInformation } from '@theia/plugin';
+import { ContextKeyService } from '@theia/core/lib/browser/context-key-service';
 
 /*---------------------------------------------------------------------------------------------
  *  Copyright (c) Microsoft Corporation. All rights reserved.
@@ -64,7 +68,8 @@ export class CommentThreadWidget extends BaseWidget {
         private _commentThread: CommentThread,
         private commentService: CommentsService,
         protected readonly menus: MenuModelRegistry,
-        protected readonly contextKeyService: CommentsContextKeyService,
+        protected readonly commentsContext: CommentsContext,
+        protected readonly contextKeyService: ContextKeyService,
         protected readonly commands: CommandRegistry
     ) {
         super();
@@ -84,14 +89,9 @@ export class CommentThreadWidget extends BaseWidget {
                 return;
             }
         }));
-        this.contextKeyService.commentIsEmpty.set(true);
+        this.commentsContext.commentIsEmpty.set(true);
         this.toDispose.push(this.zoneWidget.editor.onMouseDown(e => this.onEditorMouseDown(e)));
-        this.toDispose.push(this.contextKeyService.onDidChange(() => {
-            const commentForm = this.commentFormRef.current;
-            if (commentForm) {
-                commentForm.update();
-            }
-        }));
+
         this.toDispose.push(this._commentThread.onDidChangeCanReply(_canReply => {
             const commentForm = this.commentFormRef.current;
             if (commentForm) {
@@ -102,9 +102,14 @@ export class CommentThreadWidget extends BaseWidget {
             this.update();
         }));
         this.contextMenu = this.menus.getMenu(COMMENT_THREAD_CONTEXT);
-        this.contextMenu.children.map(node => node instanceof ActionMenuNode && node.when).forEach(exp => {
-            if (typeof exp === 'string') {
-                this.contextKeyService.setExpression(exp);
+        this.contextMenu.children.forEach(node => {
+            if (node.onDidChange) {
+                this.toDispose.push(node.onDidChange(() => {
+                    const commentForm = this.commentFormRef.current;
+                    if (commentForm) {
+                        commentForm.update();
+                    }
+                }));
             }
         });
     }
@@ -288,6 +293,7 @@ export class CommentThreadWidget extends BaseWidget {
                     {this._commentThread.comments?.map((comment, index) => <ReviewComment
                         key={index}
                         contextKeyService={this.contextKeyService}
+                        commentsContext={this.commentsContext}
                         menus={this.menus}
                         comment={comment}
                         commentForm={this.commentFormRef}
@@ -296,6 +302,7 @@ export class CommentThreadWidget extends BaseWidget {
                     />)}
                 </div>
                 <CommentForm contextKeyService={this.contextKeyService}
+                    commentsContext={this.commentsContext}
                     commands={this.commands}
                     commentThread={this._commentThread}
                     menus={this.menus}
@@ -312,7 +319,8 @@ namespace CommentForm {
         menus: MenuModelRegistry,
         commentThread: CommentThread;
         commands: CommandRegistry;
-        contextKeyService: CommentsContextKeyService;
+        contextKeyService: ContextKeyService;
+        commentsContext: CommentsContext;
         widget: CommentThreadWidget;
     }
 
@@ -322,16 +330,16 @@ namespace CommentForm {
 }
 
 export class CommentForm<P extends CommentForm.Props = CommentForm.Props> extends React.Component<P, CommentForm.State> {
-    private readonly menu: CompoundMenuNode;
     private inputRef: RefObject<HTMLTextAreaElement> = React.createRef<HTMLTextAreaElement>();
     private inputValue: string = '';
     private readonly getInput = () => this.inputValue;
+    private toDisposeOnUnmount = new DisposableCollection();
     private readonly clearInput: () => void = () => {
         const input = this.inputRef.current;
         if (input) {
             this.inputValue = '';
             input.value = this.inputValue;
-            this.props.contextKeyService.commentIsEmpty.set(true);
+            this.props.commentsContext.commentIsEmpty.set(true);
         }
     };
 
@@ -364,11 +372,15 @@ export class CommentForm<P extends CommentForm.Props = CommentForm.Props> extend
         }, 100);
     }
 
+    override componentWillUnmount(): void {
+        this.toDisposeOnUnmount.dispose();
+    }
+
     private readonly onInput: (event: React.FormEvent) => void = (event: React.FormEvent) => {
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         const value = (event.target as any).value;
         if (this.inputValue.length === 0 || value.length === 0) {
-            this.props.contextKeyService.commentIsEmpty.set(value.length === 0);
+            this.props.commentsContext.commentIsEmpty.set(value.length === 0);
         }
         this.inputValue = value;
     };
@@ -383,48 +395,106 @@ export class CommentForm<P extends CommentForm.Props = CommentForm.Props> extend
         this.setState = newState => {
             setState(newState);
         };
-
-        this.menu = this.props.menus.getMenu(COMMENT_THREAD_CONTEXT);
-        this.menu.children.map(node => node instanceof ActionMenuNode && node.when).forEach(exp => {
-            if (typeof exp === 'string') {
-                this.props.contextKeyService.setExpression(exp);
-            }
-        });
     }
 
-    override render(): React.ReactNode {
-        const { commands, commentThread, contextKeyService } = this.props;
+    /**
+     * Renders the comment form with textarea, actions, and reply button.
+     *
+     * @returns The rendered comment form
+     */
+    protected renderCommentForm(): React.ReactNode {
+        const { commentThread, commentsContext, contextKeyService, menus } = this.props;
         const hasExistingComments = commentThread.comments && commentThread.comments.length > 0;
-        return commentThread.canReply ? <div className={'comment-form' + (this.state.expanded || commentThread.comments && commentThread.comments.length === 0 ? ' expand' : '')}>
-            <div className={'theia-comments-input-message-container'}>
-                <textarea className={'theia-comments-input-message theia-input'}
-                    spellCheck={false}
-                    placeholder={hasExistingComments ? 'Reply...' : 'Type a new comment'}
-                    onInput={this.onInput}
-                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                    onBlur={(event: any) => {
-                        if (event.target.value.length > 0) {
-                            return;
-                        }
-                        if (event.relatedTarget && event.relatedTarget.className === 'comments-button comments-text-button theia-button') {
-                            this.state = { expanded: false };
-                            return;
-                        }
-                        this.collapse();
-                    }}
-                    ref={this.inputRef}>
-                </textarea>
+
+        // Determine when to show the expanded form:
+        // - When state.expanded is true (user clicked the reply button)
+        // - When there are no existing comments (new thread)
+        const shouldShowExpanded = this.state.expanded || (commentThread.comments && commentThread.comments.length === 0);
+
+        return commentThread.canReply ? (
+            <div className={`comment-form${shouldShowExpanded ? ' expand' : ''}`}>
+                <div className={'theia-comments-input-message-container'}>
+                    <textarea className={'theia-comments-input-message theia-input'}
+                        spellCheck={false}
+                        placeholder={hasExistingComments ? 'Reply...' : 'Type a new comment'}
+                        onInput={this.onInput}
+                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                        onBlur={(event: any) => {
+                            if (event.target.value.length > 0) {
+                                return;
+                            }
+                            if (event.relatedTarget && event.relatedTarget.className === 'comments-button comments-text-button theia-button') {
+                                this.state = { expanded: false };
+                                return;
+                            }
+                            this.collapse();
+                        }}
+                        ref={this.inputRef}>
+                    </textarea>
+                </div>
+                <CommentActions menu={menus.getMenu(COMMENT_THREAD_CONTEXT)}
+                    menuPath={[]}
+                    contextKeyService={contextKeyService}
+                    commentsContext={commentsContext}
+                    commentThread={commentThread}
+                    getInput={this.getInput}
+                    clearInput={this.clearInput}
+                />
+                <button className={'review-thread-reply-button'} title={'Reply...'} onClick={this.expand}>Reply...</button>
             </div>
-            <CommentActions menu={this.menu}
-                contextKeyService={contextKeyService}
-                commands={commands}
-                commentThread={commentThread}
-                getInput={this.getInput}
-                clearInput={this.clearInput}
-            />
-            <button className={'review-thread-reply-button'} title={'Reply...'} onClick={this.expand}>Reply...</button>
-        </div> : null;
+        ) : null;
     }
+
+    /**
+     * Renders the author information section.
+     *
+     * @param authorInfo The author information to display
+     * @returns The rendered author information section
+     */
+    protected renderAuthorInfo(authorInfo: CommentAuthorInformation): React.ReactNode {
+        return (
+            <div className={'avatar-container'}>
+                {authorInfo.iconPath && (
+                    <img className={'avatar'} src={authorInfo.iconPath.toString()} />
+                )}
+            </div>
+        );
+    }
+
+    override render(): React.ReactNode {
+        const { commentThread } = this.props;
+
+        if (!commentThread.canReply) {
+            return null;
+        }
+
+        // If there's author info, wrap in a container with author info on the left
+        if (isCommentAuthorInformation(commentThread.canReply)) {
+            return (
+                <div className={'review-comment'}>
+                    {this.renderAuthorInfo(commentThread.canReply)}
+                    <div className={'review-comment-contents'}>
+                        <div className={'comment-title monaco-mouse-cursor-text'}>
+                            <strong className={'author'}>{commentThread.canReply.name}</strong>
+                        </div>
+                        {this.renderCommentForm()}
+                    </div>
+                </div>
+            );
+        }
+
+        // Otherwise, just return the comment form
+        return (
+            <div className={'review-comment'}>
+                <div className={'review-comment-contents'}>
+                    {this.renderCommentForm()}
+                </div>
+            </div>);
+    }
+}
+
+function isCommentAuthorInformation(item: unknown): item is CommentAuthorInformation {
+    return isObject(item) && 'name' in item;
 }
 
 namespace ReviewComment {
@@ -432,7 +502,8 @@ namespace ReviewComment {
         menus: MenuModelRegistry,
         comment: Comment;
         commentThread: CommentThread;
-        contextKeyService: CommentsContextKeyService;
+        contextKeyService: ContextKeyService;
+        commentsContext: CommentsContext;
         commands: CommandRegistry;
         commentForm: RefObject<CommentForm>;
     }
@@ -469,10 +540,10 @@ export class ReviewComment<P extends ReviewComment.Props = ReviewComment.Props>
     protected hideHover = () => this.setState({ hover: false });
 
     override render(): React.ReactNode {
-        const { comment, commentForm, contextKeyService, menus, commands, commentThread } = this.props;
+        const { comment, commentForm, contextKeyService, commentsContext, menus, commands, commentThread } = this.props;
         const commentUniqueId = comment.uniqueIdInThread;
         const { hover } = this.state;
-        contextKeyService.comment.set(comment.contextValue);
+        commentsContext.comment.set(comment.contextValue);
         return <div className={'review-comment'}
             tabIndex={-1}
             aria-label={`${comment.userName}, ${comment.body.value}`}
@@ -489,14 +560,18 @@ export class ReviewComment<P extends ReviewComment.Props = ReviewComment.Props>
                     <span className={'isPending'}>{comment.label}</span>
                     <div className={'theia-comments-inline-actions-container'}>
                         <div className={'theia-comments-inline-actions'} role={'toolbar'}>
-                            {hover && menus.getMenu(COMMENT_TITLE).children.map((node, index) => node instanceof ActionMenuNode &&
-                                <CommentsInlineAction key={index} {...{ node, commands, commentThread, commentUniqueId, contextKeyService }} />)}
+                            {hover && menus.getMenuNode(COMMENT_TITLE) && menus.getMenu(COMMENT_TITLE).children.map((node, index): React.ReactNode => CommandMenu.is(node) &&
+                                <CommentsInlineAction key={index} {...{
+                                    node, nodePath: [...COMMENT_TITLE, node.id], commands, commentThread, commentUniqueId,
+                                    contextKeyService, commentsContext
+                                }} />)}
                         </div>
                     </div>
                 </div>
                 <CommentBody value={comment.body.value}
                     isVisible={comment.mode === undefined || comment.mode === CommentMode.Preview} />
                 <CommentEditContainer contextKeyService={contextKeyService}
+                    commentsContext={commentsContext}
                     menus={menus}
                     comment={comment}
                     commentThread={commentThread}
@@ -540,7 +615,8 @@ export class CommentBody extends React.Component<CommentBody.Props> {
 
 namespace CommentEditContainer {
     export interface Props {
-        contextKeyService: CommentsContextKeyService
+        contextKeyService: ContextKeyService;
+        commentsContext: CommentsContext;
         menus: MenuModelRegistry,
         comment: Comment;
         commentThread: CommentThread;
@@ -572,7 +648,7 @@ export class CommentEditContainer extends React.Component<CommentEditContainer.P
     }
 
     override render(): React.ReactNode {
-        const { menus, comment, commands, commentThread, contextKeyService } = this.props;
+        const { menus, comment, commands, commentThread, contextKeyService, commentsContext } = this.props;
         if (!(comment.mode === CommentMode.Editing)) {
             return false;
         }
@@ -586,7 +662,7 @@ export class CommentEditContainer extends React.Component<CommentEditContainer.P
                 </div>
             </div>
             <div className={'form-actions'}>
-                {menus.getMenu(COMMENT_CONTEXT).children.map((node, index) => {
+                {menus.getMenu(COMMENT_CONTEXT).children.map((node, index): React.ReactNode => {
                     const onClick = () => {
                         commands.executeCommand(node.id, {
                             commentControlHandle: commentThread.controllerHandle,
@@ -595,8 +671,11 @@ export class CommentEditContainer extends React.Component<CommentEditContainer.P
                             text: this.inputRef.current ? this.inputRef.current.value : ''
                         });
                     };
-                    return node instanceof ActionMenuNode &&
-                        <CommentAction key={index} {...{ node, commands, onClick, contextKeyService }} />;
+                    return CommandMenu.is(node) &&
+                        <CommentAction key={index} {...{
+                            node, nodePath: [...COMMENT_CONTEXT, node.id], comment,
+                            commands, onClick, contextKeyService, commentsContext, commentThread
+                        }} />;
                 }
                 )}
             </div>
@@ -606,18 +685,23 @@ export class CommentEditContainer extends React.Component<CommentEditContainer.P
 
 namespace CommentsInlineAction {
     export interface Props {
-        node: ActionMenuNode;
+        nodePath: MenuPath,
+        node: CommandMenu;
         commentThread: CommentThread;
         commentUniqueId: number;
         commands: CommandRegistry;
-        contextKeyService: CommentsContextKeyService;
+        contextKeyService: ContextKeyService;
+        commentsContext: CommentsContext;
     }
 }
 
 export class CommentsInlineAction extends React.Component<CommentsInlineAction.Props> {
     override render(): React.ReactNode {
-        const { node, commands, contextKeyService, commentThread, commentUniqueId } = this.props;
-        if (node.when && !contextKeyService.match(node.when)) {
+        const { node, nodePath, commands, contextKeyService, commentThread, commentUniqueId } = this.props;
+        if (node.isVisible(nodePath, contextKeyService, undefined, {
+            thread: commentThread,
+            commentUniqueId
+        })) {
             return false;
         }
         return <div className='theia-comments-inline-action'>
@@ -625,9 +709,8 @@ export class CommentsInlineAction extends React.Component<CommentsInlineAction.P
                 title={node.label}
                 onClick={() => {
                     commands.executeCommand(node.id, {
-                        commentControlHandle: commentThread.controllerHandle,
-                        commentThreadHandle: commentThread.commentThreadHandle,
-                        commentUniqueId
+                        thread: commentThread,
+                        commentUniqueId: commentUniqueId
                     });
                 }} />
         </div>;
@@ -636,8 +719,9 @@ export class CommentsInlineAction extends React.Component<CommentsInlineAction.P
 
 namespace CommentActions {
     export interface Props {
-        contextKeyService: CommentsContextKeyService;
-        commands: CommandRegistry;
+        contextKeyService: ContextKeyService;
+        commentsContext: CommentsContext;
+        menuPath: MenuPath,
         menu: CompoundMenuNode;
         commentThread: CommentThread;
         getInput: () => string;
@@ -647,30 +731,34 @@ namespace CommentActions {
 
 export class CommentActions extends React.Component<CommentActions.Props> {
     override render(): React.ReactNode {
-        const { contextKeyService, commands, menu, commentThread, getInput, clearInput } = this.props;
+        const { contextKeyService, commentsContext, menuPath, menu, commentThread, getInput, clearInput } = this.props;
         return <div className={'form-actions'}>
-            {menu.children.map((node, index) => node instanceof ActionMenuNode &&
+            {menu.children.map((node, index) => CommandMenu.is(node) &&
                 <CommentAction key={index}
-                    commands={commands}
+                    nodePath={menuPath}
                     node={node}
                     onClick={() => {
-                        commands.executeCommand(node.id, {
-                            commentControlHandle: commentThread.controllerHandle,
-                            commentThreadHandle: commentThread.commentThreadHandle,
+                        node.run(
+                            [...menuPath, menu.id], {
+                            thread: commentThread,
                             text: getInput()
                         });
                         clearInput();
                     }}
+                    commentThread={commentThread}
                     contextKeyService={contextKeyService}
+                    commentsContext={commentsContext}
                 />)}
         </div>;
     }
 }
 namespace CommentAction {
     export interface Props {
-        contextKeyService: CommentsContextKeyService;
-        commands: CommandRegistry;
-        node: ActionMenuNode;
+        commentThread: CommentThread;
+        contextKeyService: ContextKeyService;
+        commentsContext: CommentsContext;
+        nodePath: MenuPath,
+        node: CommandMenu;
         onClick: () => void;
     }
 }
@@ -678,11 +766,15 @@ namespace CommentAction {
 export class CommentAction extends React.Component<CommentAction.Props> {
     override render(): React.ReactNode {
         const classNames = ['comments-button', 'comments-text-button', 'theia-button'];
-        const { node, commands, contextKeyService, onClick } = this.props;
-        if (node.when && !contextKeyService.match(node.when)) {
+        const { node, nodePath, contextKeyService, onClick, commentThread } = this.props;
+        if (!node.isVisible(nodePath, contextKeyService, undefined, {
+            thread: commentThread
+        })) {
             return false;
         }
-        const isEnabled = commands.isEnabled(node.command);
+        const isEnabled = node.isEnabled(nodePath, {
+            thread: commentThread
+        });
         if (!isEnabled) {
             classNames.push(DISABLED_CLASS);
         }

package/src/main/browser/comments/{comments-context-key-service.ts → comments-context.ts}

@@ -16,16 +16,13 @@
 
 import { injectable, inject, postConstruct } from '@theia/core/shared/inversify';
 import { ContextKeyService, ContextKey } from '@theia/core/lib/browser/context-key-service';
-import { Emitter } from '@theia/core/lib/common';
 
 @injectable()
-export class CommentsContextKeyService {
+export class CommentsContext {
 
     @inject(ContextKeyService)
     protected readonly contextKeyService: ContextKeyService;
     protected readonly contextKeys: Set<string> = new Set();
-    protected readonly onDidChangeEmitter = new Emitter<void>();
-    readonly onDidChange = this.onDidChangeEmitter.event;
     protected _commentIsEmpty: ContextKey<boolean>;
     protected _commentController: ContextKey<string | undefined>;
     protected _comment: ContextKey<string | undefined>;
@@ -48,21 +45,5 @@ export class CommentsContextKeyService {
         this._commentController = this.contextKeyService.createKey<string | undefined>('commentController', undefined);
         this._comment = this.contextKeyService.createKey<string | undefined>('comment', undefined);
         this._commentIsEmpty = this.contextKeyService.createKey<boolean>('commentIsEmpty', true);
-        this.contextKeyService.onDidChange(event => {
-            if (event.affects(this.contextKeys)) {
-                this.onDidChangeEmitter.fire();
-            }
-        });
     }
-
-    setExpression(expression: string): void {
-        this.contextKeyService.parseKeys(expression)?.forEach(key => {
-            this.contextKeys.add(key);
-        });
-    }
-
-    match(expression: string | undefined): boolean {
-        return !expression || this.contextKeyService.match(expression);
-    }
-
 }

package/src/main/browser/comments/comments-contribution.ts

@@ -24,9 +24,9 @@ import { CommentsService, CommentInfoMain } from './comments-service';
 import { CommentThread } from '../../../common/plugin-api-rpc-model';
 import { CommandRegistry, DisposableCollection, MenuModelRegistry } from '@theia/core/lib/common';
 import { URI } from '@theia/core/shared/vscode-uri';
-import { CommentsContextKeyService } from './comments-context-key-service';
 import { ContextKeyService } from '@theia/core/lib/browser/context-key-service';
 import { Uri } from '@theia/plugin';
+import { CommentsContext } from './comments-context';
 
 /*---------------------------------------------------------------------------------------------
  *  Copyright (c) Microsoft Corporation. All rights reserved.
@@ -43,7 +43,7 @@ export class CommentsContribution {
     private emptyThreadsToAddQueue: [number, EditorMouseEvent | undefined][] = [];
 
     @inject(MenuModelRegistry) protected readonly menus: MenuModelRegistry;
-    @inject(CommentsContextKeyService) protected readonly commentsContextKeyService: CommentsContextKeyService;
+    @inject(CommentsContext) protected readonly commentsContext: CommentsContext;
     @inject(ContextKeyService) protected readonly contextKeyService: ContextKeyService;
     @inject(CommandRegistry) protected readonly commands: CommandRegistry;
 
@@ -193,10 +193,10 @@ export class CommentsContribution {
         if (editor) {
             const provider = this.commentService.getCommentController(owner);
             if (provider) {
-                this.commentsContextKeyService.commentController.set(provider.id);
+                this.commentsContext.commentController.set(provider.id);
             }
-            const zoneWidget = new CommentThreadWidget(editor, owner, thread, this.commentService, this.menus, this.commentsContextKeyService, this.commands);
-            zoneWidget.display({ afterLineNumber: thread.range?.startLineNumber ?? 0, heightInLines: 5 }); // messages with no range are put on top of the editor
+            const zoneWidget = new CommentThreadWidget(editor, owner, thread, this.commentService, this.menus, this.commentsContext, this.contextKeyService, this.commands);
+            zoneWidget.display({ afterLineNumber: thread.range?.startLineNumber || 0, heightInLines: 5 });
             const currentEditor = this.getCurrentEditor();
             if (currentEditor) {
                 currentEditor.onDispose(() => zoneWidget.dispose());

package/src/main/browser/comments/comments-main.ts

@@ -40,6 +40,7 @@ import { RPCProtocol } from '../../../common/rpc-protocol';
 import { interfaces } from '@theia/core/shared/inversify';
 import { generateUuid } from '@theia/core/lib/common/uuid';
 import { CommentsContribution } from './comments-contribution';
+import { CommentAuthorInformation } from '@theia/plugin';
 
 /*---------------------------------------------------------------------------------------------
  *  Copyright (c) Microsoft Corporation. All rights reserved.
@@ -139,7 +140,7 @@ export class CommentThreadImpl implements CommentThread, Disposable {
     private readonly onDidChangeStateEmitter = new Emitter<CommentThreadState | undefined>();
     readonly onDidChangeState = this.onDidChangeStateEmitter.event;
 
-    private readonly onDidChangeCanReplyEmitter = new Emitter<boolean>();
+    private readonly onDidChangeCanReplyEmitter = new Emitter<boolean | CommentAuthorInformation>();
     readonly onDidChangeCanReply = this.onDidChangeCanReplyEmitter.event;
 
     private _isDisposed: boolean;
@@ -148,12 +149,12 @@ export class CommentThreadImpl implements CommentThread, Disposable {
         return this._isDisposed;
     }
 
-    private _canReply: boolean = true;
-    get canReply(): boolean {
+    private _canReply: boolean | CommentAuthorInformation = true;
+    get canReply(): boolean | CommentAuthorInformation {
         return this._canReply;
     }
 
-    set canReply(canReply: boolean) {
+    set canReply(canReply: boolean | CommentAuthorInformation) {
         this._canReply = canReply;
         this.onDidChangeCanReplyEmitter.fire(this._canReply);
     }

package/src/main/browser/custom-editors/custom-editor-opener.tsx

@@ -54,7 +54,11 @@ export class CustomEditorOpener implements OpenHandler {
         if (DiffUris.isDiffUri(uri)) {
             const [left, right] = DiffUris.decode(uri);
             if (this.matches(selector, right) && this.matches(selector, left)) {
-                priority = this.getPriority();
+                if (getDefaultHandler(right, this.preferenceService) === this.editor.viewType) {
+                    priority = defaultHandlerPriority;
+                } else {
+                    priority = this.getPriority();
+                }
             }
         } else if (this.matches(selector, uri)) {
             if (getDefaultHandler(uri, this.preferenceService) === this.editor.viewType) {