@theia/keymaps 1.42.1 → 1.43.1

package/src/browser/keybindings-widget.tsx

@@ -20,14 +20,15 @@ import * as fuzzy from '@theia/core/shared/fuzzy';
 import { injectable, inject, postConstruct, unmanaged } from '@theia/core/shared/inversify';
 import { Emitter, Event } from '@theia/core/lib/common/event';
 import { CommandRegistry, Command } from '@theia/core/lib/common/command';
+import { Keybinding } from '@theia/core/lib/common/keybinding';
 import { ReactWidget } from '@theia/core/lib/browser/widgets/react-widget';
 import {
     KeybindingRegistry, SingleTextInputDialog, KeySequence, ConfirmDialog, Message, KeybindingScope,
-    SingleTextInputDialogProps, Key, ScopedKeybinding, codicon, StatefulWidget, Widget
+    SingleTextInputDialogProps, Key, ScopedKeybinding, codicon, StatefulWidget, Widget, ContextMenuRenderer, SELECTED_CLASS
 } from '@theia/core/lib/browser';
 import { KeymapsService } from './keymaps-service';
 import { AlertMessage } from '@theia/core/lib/browser/widgets/alert-message';
-import { DisposableCollection, isOSX } from '@theia/core';
+import { DisposableCollection, isOSX, isObject } from '@theia/core';
 import { nls } from '@theia/core/lib/common/nls';
 
 /**
@@ -47,6 +48,19 @@ export interface KeybindingItem {
     visible?: boolean;
 }
 
+export namespace KeybindingItem {
+    export function is(arg: unknown): arg is KeybindingItem {
+        return isObject(arg) && 'command' in arg && 'labels' in arg;
+    }
+
+    export function keybinding(item: KeybindingItem): Keybinding {
+        return item.keybinding ?? {
+            command: item.command.id,
+            keybinding: ''
+        };
+    }
+}
+
 export interface RenderableLabel {
     readonly value: string;
     segments?: RenderableStringSegment[];
@@ -84,8 +98,17 @@ export class KeybindingWidget extends ReactWidget implements StatefulWidget {
     @inject(KeymapsService)
     protected readonly keymapsService: KeymapsService;
 
+    @inject(ContextMenuRenderer)
+    protected readonly contextMenuRenderer: ContextMenuRenderer;
+
     static readonly ID = 'keybindings.view.widget';
     static readonly LABEL = nls.localizeByDefault('Keyboard Shortcuts');
+    static readonly CONTEXT_MENU = ['keybinding-context-menu'];
+    static readonly COPY_MENU = [...KeybindingWidget.CONTEXT_MENU, 'a_copy'];
+    static readonly EDIT_MENU = [...KeybindingWidget.CONTEXT_MENU, 'b_edit'];
+    static readonly ADD_MENU = [...KeybindingWidget.CONTEXT_MENU, 'c_add'];
+    static readonly REMOVE_MENU = [...KeybindingWidget.CONTEXT_MENU, 'd_remove'];
+    static readonly SHOW_MENU = [...KeybindingWidget.CONTEXT_MENU, 'e_show'];
 
     /**
      * The list of all available keybindings.
@@ -164,14 +187,14 @@ export class KeybindingWidget extends ReactWidget implements StatefulWidget {
      * Determine if there currently is a search term.
      * @returns `true` if a search term is present.
      */
-    public hasSearch(): boolean {
+    hasSearch(): boolean {
         return !!this.query.length;
     }
 
     /**
      * Clear the search and reset the view.
      */
-    public clearSearch(): void {
+    clearSearch(): void {
         const search = this.findSearchField();
         if (search) {
             search.value = '';
@@ -180,6 +203,23 @@ export class KeybindingWidget extends ReactWidget implements StatefulWidget {
         }
     }
 
+    /**
+     * Show keybinding items with the same key sequence as the given item.
+     * @param item the keybinding item
+     */
+    showSameKeybindings(item: KeybindingItem): void {
+        const keybinding = item.keybinding;
+        if (keybinding) {
+            const search = this.findSearchField();
+            if (search) {
+                const query = `"${this.keybindingRegistry.acceleratorFor(keybinding, '+', true).join(' ')}"`;
+                search.value = query;
+                this.query = query;
+                this.doSearchKeybindings();
+            }
+        }
+    }
+
     protected override onActivateRequest(msg: Message): void {
         super.onActivateRequest(msg);
         this.focusInputField();
@@ -192,13 +232,27 @@ export class KeybindingWidget extends ReactWidget implements StatefulWidget {
         this.onDidUpdateEmitter.fire(undefined);
         const searchField = this.findSearchField();
         this.query = searchField ? searchField.value.trim().toLocaleLowerCase() : '';
-        const queryItems = this.query.split(/[+\s]/);
+        let query = this.query;
+        const startsWithQuote = query.startsWith('"');
+        const endsWithQuote = query.endsWith('"');
+        const matchKeybindingOnly = startsWithQuote && endsWithQuote;
+        if (startsWithQuote) {
+            query = query.slice(1);
+        }
+        if (endsWithQuote) {
+            query = query.slice(0, -1);
+        }
+        const queryItems = query.split(/[+\s]/);
         this.items.forEach(item => {
             let matched = !this.query;
-            matched = this.formatAndMatchCommand(item) || matched;
-            matched = this.formatAndMatchKeybinding(item, queryItems) || matched;
-            matched = this.formatAndMatchContext(item) || matched;
-            matched = this.formatAndMatchSource(item) || matched;
+            if (!matchKeybindingOnly) {
+                matched = this.formatAndMatchCommand(item) || matched;
+            }
+            matched = this.formatAndMatchKeybinding(item, queryItems, matchKeybindingOnly) || matched;
+            if (!matchKeybindingOnly) {
+                matched = this.formatAndMatchContext(item) || matched;
+                matched = this.formatAndMatchSource(item) || matched;
+            }
             item.visible = matched;
         });
         this.update();
@@ -209,7 +263,7 @@ export class KeybindingWidget extends ReactWidget implements StatefulWidget {
         return Boolean(item.labels.command.segments);
     }
 
-    protected formatAndMatchKeybinding(item: KeybindingItem, queryItems: string[]): boolean {
+    protected formatAndMatchKeybinding(item: KeybindingItem, queryItems: string[], exactMatch?: boolean): boolean {
         if (item.keybinding) {
             const unmatchedTerms = queryItems.filter(Boolean);
             const segments = this.keybindingRegistry.resolveKeybinding(item.keybinding).reduce<RenderableStringSegment[]>((collection, code, codeIndex) => {
@@ -232,7 +286,13 @@ export class KeybindingWidget extends ReactWidget implements StatefulWidget {
                 return collection;
             }, []);
             item.labels.keybinding = { value: item.labels.keybinding.value, segments };
-            return !unmatchedTerms.length;
+            if (unmatchedTerms.length) {
+                return false;
+            }
+            if (exactMatch) {
+                return !segments.some(segment => segment.key && !segment.match);
+            }
+            return true;
         }
         item.labels.keybinding = { value: '' };
         return false;
@@ -364,7 +424,9 @@ export class KeybindingWidget extends ReactWidget implements StatefulWidget {
     protected renderRow(item: KeybindingItem, index: number): React.ReactNode {
         const { command, keybinding } = item;
         // TODO get rid of array functions in event handlers
-        return <tr className='kb-item-row' key={index} onDoubleClick={() => this.editKeybinding(item)}>
+        return <tr className='kb-item-row' key={index} onDoubleClick={event => this.handleItemDoubleClick(item, index, event)}
+            onClick={event => this.handleItemClick(item, index, event)}
+            onContextMenu={event => this.handleItemContextMenu(item, index, event)}>
             <td className='kb-actions'>
                 {this.renderActions(item)}
             </td>
@@ -383,6 +445,37 @@ export class KeybindingWidget extends ReactWidget implements StatefulWidget {
         </tr>;
     }
 
+    protected handleItemClick(item: KeybindingItem, index: number, event: React.MouseEvent<HTMLElement>): void {
+        event.preventDefault();
+        this.selectItem(item, index, event.currentTarget);
+    }
+
+    protected handleItemDoubleClick(item: KeybindingItem, index: number, event: React.MouseEvent<HTMLElement>): void {
+        event.preventDefault();
+        this.selectItem(item, index, event.currentTarget);
+        this.editKeybinding(item);
+    }
+
+    protected handleItemContextMenu(item: KeybindingItem, index: number, event: React.MouseEvent<HTMLElement>): void {
+        event.preventDefault();
+        this.selectItem(item, index, event.currentTarget);
+        this.contextMenuRenderer.render({
+            menuPath: KeybindingWidget.CONTEXT_MENU,
+            anchor: event.nativeEvent,
+            args: [item, this]
+        });
+    }
+
+    protected selectItem(item: KeybindingItem, index: number, element: HTMLElement): void {
+        if (!element.classList.contains(SELECTED_CLASS)) {
+            const selected = element.parentElement?.getElementsByClassName(SELECTED_CLASS)[0];
+            if (selected) {
+                selected.classList.remove(SELECTED_CLASS);
+            }
+            element.classList.add(SELECTED_CLASS);
+        }
+    }
+
     /**
      * Render the actions container with action icons.
      * @param item the keybinding item for the row.
@@ -408,7 +501,7 @@ export class KeybindingWidget extends ReactWidget implements StatefulWidget {
      * @param item the keybinding item for the row.
      */
     protected renderReset(item: KeybindingItem): React.ReactNode {
-        return (item.keybinding && item.keybinding.scope === KeybindingScope.USER)
+        return this.canResetKeybinding(item)
             ? <a title='Reset Keybinding' href='#' onClick={e => {
                 e.preventDefault();
                 this.resetKeybinding(item);
@@ -572,22 +665,74 @@ export class KeybindingWidget extends ReactWidget implements StatefulWidget {
      * Prompt users to update the keybinding for the given command.
      * @param item the keybinding item.
      */
-    protected editKeybinding(item: KeybindingItem): void {
+    editKeybinding(item: KeybindingItem): void {
         const command = item.command.id;
         const oldKeybinding = item.keybinding;
         const dialog = new EditKeybindingDialog({
-            title: nls.localize('theia/keymaps/editKeybindingTitle', 'Edit Keybinding for {0}', command),
+            title: nls.localize('theia/keymaps/editKeybindingTitle', 'Edit Keybinding for {0}', item.labels.command.value),
             maxWidth: 400,
             initialValue: oldKeybinding?.keybinding,
             validate: newKeybinding => this.validateKeybinding(command, oldKeybinding?.keybinding, newKeybinding),
-        }, this.keymapsService, item);
+        }, this.keymapsService, item, this.canResetKeybinding(item));
+        dialog.open().then(async keybinding => {
+            if (keybinding && keybinding !== oldKeybinding?.keybinding) {
+                await this.keymapsService.setKeybinding({
+                    ...oldKeybinding,
+                    command,
+                    keybinding
+                }, oldKeybinding);
+            }
+        });
+    }
+
+    /**
+     * Prompt users to update when expression for the given keybinding.
+     * @param item the keybinding item
+     */
+    editWhenExpression(item: KeybindingItem): void {
+        const keybinding = item.keybinding;
+        if (!keybinding) {
+            return;
+        }
+        const dialog = new SingleTextInputDialog({
+            title: nls.localize('theia/keymaps/editWhenExpressionTitle', 'Edit When Expression for {0}', item.labels.command.value),
+            maxWidth: 400,
+            initialValue: keybinding.when
+        });
+        dialog.open().then(async when => {
+            if (when === undefined) {
+                return; // cancelled by the user
+            }
+            if (when !== (keybinding.when ?? '')) {
+                if (when === '') {
+                    when = undefined;
+                }
+                await this.keymapsService.setKeybinding({
+                    ...keybinding,
+                    when
+                }, keybinding);
+            }
+        });
+    }
+
+    /**
+     * Prompt users to add a keybinding for the given command.
+     * @param item the keybinding item
+     */
+    addKeybinding(item: KeybindingItem): void {
+        const command = item.command.id;
+        const dialog = new SingleTextInputDialog({
+            title: nls.localize('theia/keymaps/addKeybindingTitle', 'Add Keybinding for {0}', item.labels.command.value),
+            maxWidth: 400,
+            validate: newKeybinding => this.validateKeybinding(command, undefined, newKeybinding),
+        });
         dialog.open().then(async keybinding => {
             if (keybinding) {
                 await this.keymapsService.setKeybinding({
                     ...item.keybinding,
                     command,
                     keybinding
-                }, oldKeybinding);
+                }, undefined);
             }
         });
     }
@@ -618,13 +763,21 @@ export class KeybindingWidget extends ReactWidget implements StatefulWidget {
      * Reset the keybinding to its default value.
      * @param item the keybinding item.
      */
-    protected async resetKeybinding(item: KeybindingItem): Promise<void> {
+    async resetKeybinding(item: KeybindingItem): Promise<void> {
         const confirmed = await this.confirmResetKeybinding(item);
         if (confirmed) {
             this.keymapsService.removeKeybinding(item.command.id);
         }
     }
 
+    /**
+     * Whether the keybinding can be reset to its default value.
+     * @param item the keybinding item
+     */
+    canResetKeybinding(item: KeybindingItem): boolean {
+        return item.keybinding?.scope === KeybindingScope.USER || this.keymapsService.hasKeybinding('-' + item.command.id);
+    }
+
     /**
      * Validate the provided keybinding value against its previous value.
      * @param command the command label.
@@ -745,12 +898,13 @@ class EditKeybindingDialog extends SingleTextInputDialog {
     constructor(
         @inject(SingleTextInputDialogProps) props: SingleTextInputDialogProps,
         @inject(KeymapsService) protected readonly keymapsService: KeymapsService,
-        item: KeybindingItem
+        item: KeybindingItem,
+        canReset: boolean
     ) {
         super(props);
         this.item = item;
         // Add the `Reset` button if the command currently has a custom keybinding.
-        if (this.item.keybinding && this.item.keybinding.scope === KeybindingScope.USER) {
+        if (canReset) {
             this.appendResetButton();
         }
     }
@@ -796,5 +950,4 @@ class EditKeybindingDialog extends SingleTextInputDialog {
     protected reset(): void {
         this.keymapsService.removeKeybinding(this.item.command.id);
     }
-
 }

package/src/browser/keymaps-frontend-contribution.ts

@@ -23,10 +23,12 @@ import {
     MenuModelRegistry
 } from '@theia/core/lib/common';
 import { AbstractViewContribution, codicon, Widget } from '@theia/core/lib/browser';
+import { ClipboardService } from '@theia/core/lib/browser/clipboard-service';
 import { CommonCommands, CommonMenus } from '@theia/core/lib/browser/common-frontend-contribution';
 import { KeymapsService } from './keymaps-service';
+import { Keybinding } from '@theia/core/lib/common/keybinding';
 import { KeybindingRegistry } from '@theia/core/lib/browser/keybinding';
-import { KeybindingWidget } from './keybindings-widget';
+import { KeybindingItem, KeybindingWidget } from './keybindings-widget';
 import { TabBarToolbarContribution, TabBarToolbarRegistry } from '@theia/core/lib/browser/shell/tab-bar-toolbar';
 import { nls } from '@theia/core/lib/common/nls';
 
@@ -49,6 +51,51 @@ export namespace KeymapsCommands {
         id: 'keymaps.clearSearch',
         iconClass: codicon('clear-all')
     };
+    export const COPY_KEYBINDING = Command.toLocalizedCommand({
+        id: 'keymaps:keybinding.copy',
+        category: CommonCommands.PREFERENCES_CATEGORY,
+        label: 'Copy Keybinding'
+    }, 'theia/keymaps/keybinding/copy', CommonCommands.PREFERENCES_CATEGORY_KEY);
+    export const COPY_COMMAND_ID = Command.toLocalizedCommand({
+        id: 'keymaps:keybinding.copyCommandId',
+        category: CommonCommands.PREFERENCES_CATEGORY,
+        label: 'Copy Keybinding Command ID'
+    }, 'theia/keymaps/keybinding/copyCommandId', CommonCommands.PREFERENCES_CATEGORY_KEY);
+    export const COPY_COMMAND_TITLE = Command.toLocalizedCommand({
+        id: 'keymaps:keybinding.copyCommandTitle',
+        category: CommonCommands.PREFERENCES_CATEGORY,
+        label: 'Copy Keybinding Command Title'
+    }, 'theia/keymaps/keybinding/copyCommandTitle', CommonCommands.PREFERENCES_CATEGORY_KEY);
+    export const EDIT_KEYBINDING = Command.toLocalizedCommand({
+        id: 'keymaps:keybinding.edit',
+        category: CommonCommands.PREFERENCES_CATEGORY,
+        label: 'Edit Keybinding...'
+    }, 'theia/keymaps/keybinding/edit', CommonCommands.PREFERENCES_CATEGORY_KEY);
+    export const EDIT_WHEN_EXPRESSION = Command.toLocalizedCommand({
+        id: 'keymaps:keybinding.editWhenExpression',
+        category: CommonCommands.PREFERENCES_CATEGORY,
+        label: 'Edit Keybinding When Expression...'
+    }, 'theia/keymaps/keybinding/editWhenExpression', CommonCommands.PREFERENCES_CATEGORY_KEY);
+    export const ADD_KEYBINDING = Command.toDefaultLocalizedCommand({
+        id: 'keymaps:keybinding.add',
+        category: CommonCommands.PREFERENCES_CATEGORY,
+        label: 'Add Keybinding...'
+    });
+    export const REMOVE_KEYBINDING = Command.toDefaultLocalizedCommand({
+        id: 'keymaps:keybinding.remove',
+        category: CommonCommands.PREFERENCES_CATEGORY,
+        label: 'Remove Keybinding'
+    });
+    export const RESET_KEYBINDING = Command.toDefaultLocalizedCommand({
+        id: 'keymaps:keybinding.reset',
+        category: CommonCommands.PREFERENCES_CATEGORY,
+        label: 'Reset Keybinding'
+    });
+    export const SHOW_SAME = Command.toDefaultLocalizedCommand({
+        id: 'keymaps:keybinding.showSame',
+        category: CommonCommands.PREFERENCES_CATEGORY,
+        label: 'Show Same Keybindings'
+    });
 }
 
 @injectable()
@@ -57,6 +104,9 @@ export class KeymapsFrontendContribution extends AbstractViewContribution<Keybin
     @inject(KeymapsService)
     protected readonly keymaps: KeymapsService;
 
+    @inject(ClipboardService)
+    protected readonly clipboard: ClipboardService;
+
     constructor() {
         super({
             widgetId: KeybindingWidget.ID,
@@ -86,6 +136,53 @@ export class KeymapsFrontendContribution extends AbstractViewContribution<Keybin
             isVisible: w => this.withWidget(w, () => true),
             execute: w => this.withWidget(w, widget => widget.clearSearch()),
         });
+        commands.registerCommand(KeymapsCommands.COPY_KEYBINDING, {
+            isEnabled: (...args) => this.withItem(() => true, ...args),
+            isVisible: (...args) => this.withItem(() => true, ...args),
+            execute: (...args) => this.withItem(item => this.clipboard.writeText(
+                JSON.stringify(Keybinding.apiObjectify(KeybindingItem.keybinding(item)), undefined, '  ')
+            ), ...args)
+        });
+        commands.registerCommand(KeymapsCommands.COPY_COMMAND_ID, {
+            isEnabled: (...args) => this.withItem(() => true, ...args),
+            isVisible: (...args) => this.withItem(() => true, ...args),
+            execute: (...args) => this.withItem(item => this.clipboard.writeText(item.command.id), ...args)
+        });
+        commands.registerCommand(KeymapsCommands.COPY_COMMAND_TITLE, {
+            isEnabled: (...args) => this.withItem(item => !!item.command.label, ...args),
+            isVisible: (...args) => this.withItem(() => true, ...args),
+            execute: (...args) => this.withItem(item => this.clipboard.writeText(item.command.label!), ...args)
+        });
+        commands.registerCommand(KeymapsCommands.EDIT_KEYBINDING, {
+            isEnabled: (...args) => this.withWidgetItem(() => true, ...args),
+            isVisible: (...args) => this.withWidgetItem(() => true, ...args),
+            execute: (...args) => this.withWidgetItem((item, widget) => widget.editKeybinding(item), ...args)
+        });
+        commands.registerCommand(KeymapsCommands.EDIT_WHEN_EXPRESSION, {
+            isEnabled: (...args) => this.withWidgetItem(item => !!item.keybinding, ...args),
+            isVisible: (...args) => this.withWidgetItem(() => true, ...args),
+            execute: (...args) => this.withWidgetItem((item, widget) => widget.editWhenExpression(item), ...args)
+        });
+        commands.registerCommand(KeymapsCommands.ADD_KEYBINDING, {
+            isEnabled: (...args) => this.withWidgetItem(item => !!item.keybinding, ...args),
+            isVisible: (...args) => this.withWidgetItem(item => !!item.keybinding, ...args),
+            execute: (...args) => this.withWidgetItem((item, widget) => widget.addKeybinding(item), ...args)
+        });
+        commands.registerCommand(KeymapsCommands.REMOVE_KEYBINDING, {
+            isEnabled: (...args) => this.withItem(item => !!item.keybinding, ...args),
+            isVisible: (...args) => this.withItem(() => true, ...args),
+            execute: (...args) => this.withItem(item => this.keymaps.unsetKeybinding(item.keybinding!), ...args)
+        });
+        commands.registerCommand(KeymapsCommands.RESET_KEYBINDING, {
+            isEnabled: (...args) => this.withWidgetItem((item, widget) => widget.canResetKeybinding(item), ...args),
+            isVisible: (...args) => this.withWidgetItem(() => true, ...args),
+            execute: (...args) => this.withWidgetItem((item, widget) => widget.resetKeybinding(item), ...args)
+        });
+        commands.registerCommand(KeymapsCommands.SHOW_SAME, {
+            isEnabled: (...args) => this.withWidgetItem(item => !!item.keybinding, ...args),
+            isVisible: (...args) => this.withWidgetItem(() => true, ...args),
+            execute: (...args) => this.withWidgetItem((item, widget) => widget.showSameKeybindings(item), ...args)
+        });
     }
 
     override registerMenus(menus: MenuModelRegistry): void {
@@ -94,10 +191,55 @@ export class KeymapsFrontendContribution extends AbstractViewContribution<Keybin
             label: nls.localizeByDefault('Keyboard Shortcuts'),
             order: 'a20'
         });
-        menus.registerMenuAction(CommonMenus.SETTINGS_OPEN, {
+        menus.registerMenuAction(CommonMenus.MANAGE_SETTINGS, {
             commandId: KeymapsCommands.OPEN_KEYMAPS.id,
             label: nls.localizeByDefault('Keyboard Shortcuts'),
-            order: 'a20'
+            order: 'a30'
+        });
+        menus.registerMenuAction(KeybindingWidget.COPY_MENU, {
+            commandId: KeymapsCommands.COPY_KEYBINDING.id,
+            label: nls.localizeByDefault('Copy'),
+            order: 'a'
+        });
+        menus.registerMenuAction(KeybindingWidget.COPY_MENU, {
+            commandId: KeymapsCommands.COPY_COMMAND_ID.id,
+            label: nls.localizeByDefault('Copy Command ID'),
+            order: 'b'
+        });
+        menus.registerMenuAction(KeybindingWidget.COPY_MENU, {
+            commandId: KeymapsCommands.COPY_COMMAND_TITLE.id,
+            label: nls.localizeByDefault('Copy Command Title'),
+            order: 'c'
+        });
+        menus.registerMenuAction(KeybindingWidget.EDIT_MENU, {
+            commandId: KeymapsCommands.EDIT_KEYBINDING.id,
+            label: nls.localize('theia/keymaps/editKeybinding', 'Edit Keybinding...'),
+            order: 'a'
+        });
+        menus.registerMenuAction(KeybindingWidget.EDIT_MENU, {
+            commandId: KeymapsCommands.EDIT_WHEN_EXPRESSION.id,
+            label: nls.localize('theia/keymaps/editWhenExpression', 'Edit When Expression...'),
+            order: 'b'
+        });
+        menus.registerMenuAction(KeybindingWidget.ADD_MENU, {
+            commandId: KeymapsCommands.ADD_KEYBINDING.id,
+            label: nls.localizeByDefault('Add Keybinding...'),
+            order: 'a'
+        });
+        menus.registerMenuAction(KeybindingWidget.REMOVE_MENU, {
+            commandId: KeymapsCommands.REMOVE_KEYBINDING.id,
+            label: nls.localizeByDefault('Remove Keybinding'),
+            order: 'a'
+        });
+        menus.registerMenuAction(KeybindingWidget.REMOVE_MENU, {
+            commandId: KeymapsCommands.RESET_KEYBINDING.id,
+            label: nls.localizeByDefault('Reset Keybinding'),
+            order: 'b'
+        });
+        menus.registerMenuAction(KeybindingWidget.SHOW_MENU, {
+            commandId: KeymapsCommands.SHOW_SAME.id,
+            label: nls.localizeByDefault('Show Same Keybindings'),
+            order: 'a'
         });
     }
 
@@ -135,4 +277,20 @@ export class KeymapsFrontendContribution extends AbstractViewContribution<Keybin
         }
         return false;
     }
+
+    protected withItem<T>(fn: (item: KeybindingItem, ...rest: unknown[]) => T, ...args: unknown[]): T | false {
+        const [item] = args;
+        if (KeybindingItem.is(item)) {
+            return fn(item, args.slice(1));
+        }
+        return false;
+    }
+
+    protected withWidgetItem<T>(fn: (item: KeybindingItem, widget: KeybindingWidget, ...rest: unknown[]) => T, ...args: unknown[]): T | false {
+        const [item, widget] = args;
+        if (widget instanceof KeybindingWidget && widget.id === KeybindingWidget.ID && KeybindingItem.is(item)) {
+            return fn(item, widget, args.slice(2));
+        }
+        return false;
+    }
 }

package/src/browser/keymaps-service.ts

@@ -128,62 +128,62 @@ export class KeymapsService {
      */
     async setKeybinding(newKeybinding: Keybinding, oldKeybinding: ScopedKeybinding | undefined): Promise<void> {
         return this.updateKeymap(() => {
-            let newAdded = false;
-            let isOldKeybindingDisabled = false;
-            let addedDisabledEntry = false;
-            const keybindings = [];
-            for (let keybinding of this.keybindingRegistry.getKeybindingsByScope(KeybindingScope.USER)) {
-                // search for the old keybinding and modify it
-                if (oldKeybinding && Keybinding.equals(keybinding, oldKeybinding, false, true)) {
-                    newAdded = true;
-                    keybinding = {
-                        ...keybinding,
-                        keybinding: newKeybinding.keybinding
-                    };
-                }
-
-                // we have an disabled entry for the same command and the oldKeybinding
-                if (oldKeybinding?.keybinding &&
-                    Keybinding.equals(keybinding, { ...newKeybinding, keybinding: oldKeybinding.keybinding, command: '-' + newKeybinding.command }, false, true)) {
-                    isOldKeybindingDisabled = true;
-                }
-                keybindings.push(keybinding);
-            }
-            if (!newAdded) {
-                keybindings.push({
-                    command: newKeybinding.command,
-                    keybinding: newKeybinding.keybinding,
-                    context: newKeybinding.context,
-                    when: newKeybinding.when,
-                    args: newKeybinding.args
-                });
-                newAdded = true;
+            const keybindings: Keybinding[] = [...this.keybindingRegistry.getKeybindingsByScope(KeybindingScope.USER)];
+            if (!oldKeybinding) {
+                Keybinding.addKeybinding(keybindings, newKeybinding);
+                return keybindings;
+            } else if (oldKeybinding.scope === KeybindingScope.DEFAULT) {
+                Keybinding.addKeybinding(keybindings, newKeybinding);
+                const disabledBinding = {
+                    ...oldKeybinding,
+                    command: '-' + oldKeybinding.command
+                };
+                Keybinding.addKeybinding(keybindings, disabledBinding);
+                return keybindings;
+            } else if (Keybinding.replaceKeybinding(keybindings, oldKeybinding, newKeybinding)) {
+                return keybindings;
             }
-            // we want to add a disabled entry for the old keybinding only when we are modifying the default value
-            if (!isOldKeybindingDisabled && oldKeybinding?.scope === KeybindingScope.DEFAULT) {
+        });
+    }
+
+    /**
+     * Unset the given keybinding in the JSON.
+     * If the given keybinding has a default scope, it will be disabled in the JSON.
+     * Otherwise, it will be removed from the JSON.
+     * @param keybinding the keybinding to unset
+     */
+    unsetKeybinding(keybinding: ScopedKeybinding): Promise<void> {
+        return this.updateKeymap(() => {
+            const keybindings = this.keybindingRegistry.getKeybindingsByScope(KeybindingScope.USER);
+            if (keybinding.scope === KeybindingScope.DEFAULT) {
+                const result: Keybinding[] = [...keybindings];
                 const disabledBinding = {
-                    command: '-' + newKeybinding.command,
-                    // TODO key: oldKeybinding, see https://github.com/eclipse-theia/theia/issues/6879
-                    keybinding: oldKeybinding.keybinding,
-                    context: newKeybinding.context,
-                    when: newKeybinding.when,
-                    args: newKeybinding.args
+                    ...keybinding,
+                    command: '-' + keybinding.command
                 };
-                // Add disablement of the old keybinding if it isn't already disabled in the list to avoid duplicate disabled entries
-                if (!keybindings.some(binding => Keybinding.equals(binding, disabledBinding, false, true))) {
-                    keybindings.push(disabledBinding);
+                Keybinding.addKeybinding(result, disabledBinding);
+                return result;
+            } else {
+                const filtered = keybindings.filter(a => !Keybinding.equals(a, keybinding, false, true));
+                if (filtered.length !== keybindings.length) {
+                    return filtered;
                 }
-                isOldKeybindingDisabled = true;
-                addedDisabledEntry = true;
-            }
-            if (newAdded || addedDisabledEntry) {
-                return keybindings;
             }
         });
     }
 
     /**
-     * Remove the given keybinding with the given command id from the JSON.
+     * Whether there is a keybinding with the given command id in the JSON.
+     * @param commandId the keybinding command id
+     */
+    hasKeybinding(commandId: string): boolean {
+        const keybindings = this.keybindingRegistry.getKeybindingsByScope(KeybindingScope.USER);
+        return keybindings.some(a => a.command === commandId);
+    }
+
+    /**
+     * Remove the keybindings with the given command id from the JSON.
+     * This includes disabled keybindings.
      * @param commandId the keybinding command id.
      */
     removeKeybinding(commandId: string): Promise<void> {