@opensumi/ide-core-browser 2.12.1-next-079c1930

package/lib/keybinding/keybinding.js

@@ -0,0 +1,720 @@
+"use strict";
+var KeybindingRegistryImpl_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NO_KEYBINDING_NAME = exports.KeybindingRegistryImpl = exports.KeybindingService = exports.keybindingServicePath = exports.KeybindingRegistry = exports.KeybindingContribution = exports.KeybindingsResultCollection = exports.Keybinding = exports.KeybindingWeight = exports.KeybindingScope = void 0;
+const tslib_1 = require("tslib");
+const di_1 = require("@opensumi/di");
+const ide_core_common_1 = require("@opensumi/ide-core-common");
+const keys_1 = require("../keyboard/keys");
+const keyboard_layout_service_1 = require("../keyboard/keyboard-layout-service");
+const context_key_1 = require("../context-key");
+const services_1 = require("../services");
+var KeybindingScope;
+(function (KeybindingScope) {
+    KeybindingScope[KeybindingScope["DEFAULT"] = 0] = "DEFAULT";
+    KeybindingScope[KeybindingScope["USER"] = 1] = "USER";
+    KeybindingScope[KeybindingScope["WORKSPACE"] = 2] = "WORKSPACE";
+    KeybindingScope[KeybindingScope["END"] = 3] = "END";
+})(KeybindingScope = exports.KeybindingScope || (exports.KeybindingScope = {}));
+// ref: https://github.com/Microsoft/vscode/blob/97fc588e65bedcb1113baeddd2f67237e52c8c63/src/vs/platform/keybinding/common/keybindingsRegistry.ts#L56
+// 快捷键第一优先级，在开天中将对该值 * 100 作为快捷键的优先级参数 priority
+var KeybindingWeight;
+(function (KeybindingWeight) {
+    KeybindingWeight[KeybindingWeight["Default"] = 0] = "Default";
+    KeybindingWeight[KeybindingWeight["EditorCore"] = 1] = "EditorCore";
+    KeybindingWeight[KeybindingWeight["EditorContrib"] = 100] = "EditorContrib";
+    KeybindingWeight[KeybindingWeight["WorkbenchContrib"] = 200] = "WorkbenchContrib";
+    KeybindingWeight[KeybindingWeight["BuiltinExtension"] = 300] = "BuiltinExtension";
+    KeybindingWeight[KeybindingWeight["ExternalExtension"] = 400] = "ExternalExtension";
+})(KeybindingWeight = exports.KeybindingWeight || (exports.KeybindingWeight = {}));
+(function (KeybindingScope) {
+    KeybindingScope.length = KeybindingScope.END - KeybindingScope.DEFAULT;
+})(KeybindingScope = exports.KeybindingScope || (exports.KeybindingScope = {}));
+var Keybinding;
+(function (Keybinding) {
+    /**
+     * 返回带有绑定的字符串表达式
+     * 仅序列化关键的快捷键及command
+     * 在快捷时被使用
+     *
+     * @param binding 按键绑定的字符串表达式.
+     */
+    function stringify(binding) {
+        const copy = {
+            command: binding.command,
+            keybinding: binding.keybinding,
+        };
+        return JSON.stringify(copy);
+    }
+    Keybinding.stringify = stringify;
+    // 判断一个对象是否为Keybinding对象
+    function is(arg) {
+        return !!arg && arg === Object(arg) && 'command' in arg && 'keybinding' in arg;
+    }
+    Keybinding.is = is;
+})(Keybinding = exports.Keybinding || (exports.Keybinding = {}));
+var KeybindingsResultCollection;
+(function (KeybindingsResultCollection) {
+    class KeybindingsResult {
+        constructor() {
+            this.full = [];
+            this.partial = [];
+            this.shadow = [];
+        }
+        /**
+         * 合并KeybindingsResult至this
+         *
+         * @param other
+         * @return this
+         */
+        merge(other) {
+            this.full.push(...other.full);
+            this.partial.push(...other.partial);
+            this.shadow.push(...other.shadow);
+            return this;
+        }
+        /**
+         * 返回一个新的过滤后的 KeybindingsResult
+         *
+         * @param fn 过滤函数
+         * @return KeybindingsResult
+         */
+        filter(fn) {
+            const result = new KeybindingsResult();
+            result.full = this.full.filter(fn);
+            result.partial = this.partial.filter(fn);
+            result.shadow = this.shadow.filter(fn);
+            return result;
+        }
+    }
+    KeybindingsResultCollection.KeybindingsResult = KeybindingsResult;
+})(KeybindingsResultCollection = exports.KeybindingsResultCollection || (exports.KeybindingsResultCollection = {}));
+exports.KeybindingContribution = Symbol('KeybindingContribution');
+exports.KeybindingRegistry = Symbol('KeybindingRegistry');
+exports.keybindingServicePath = '/services/keybindings';
+exports.KeybindingService = Symbol('KeybindingService');
+let KeybindingRegistryImpl = KeybindingRegistryImpl_1 = class KeybindingRegistryImpl {
+    constructor() {
+        this.keymaps = [...Array(KeybindingScope.length)].map(() => []);
+        this.keySequence = [];
+        this.convertKeySequence = [];
+        this.modifierKeySequence = [];
+        this.keybindingsChanged = new ide_core_common_1.Emitter();
+    }
+    async initialize() {
+        await this.keyboardLayoutService.initialize();
+        this.keyboardLayoutService.onKeyboardLayoutChanged(() => {
+            this.clearResolvedKeybindings();
+        });
+        // 从模块中获取的KeybindingContribution
+        for (const contribution of this.keybindingContributionProvider.getContributions()) {
+            contribution.registerKeybindings(this);
+        }
+    }
+    /**
+     * 由于不同的键盘布局发生更改时触发的事件。
+     */
+    get onKeybindingsChanged() {
+        return this.keybindingsChanged.event;
+    }
+    /**
+     * 注册默认 Keybinding, 支持指定作用域
+     * @param binding
+     */
+    registerKeybinding(binding, scope = KeybindingScope.DEFAULT) {
+        return this.doRegisterKeybinding(binding, scope);
+    }
+    /**
+     * 注册默认 Keybindings, 支持指定作用域
+     * @param bindings
+     */
+    registerKeybindings(bindings, scope = KeybindingScope.DEFAULT) {
+        return this.doRegisterKeybindings(bindings, scope);
+    }
+    /**
+     * 用于转换monaco内置的RawContextKey
+     * @param when
+     */
+    convertMonacoWhen(when) {
+        if (!when) {
+            return '';
+        }
+        if (typeof when === 'string') {
+            return when;
+        }
+        return when.serialize();
+    }
+    unregisterKeybinding(keyOrBinding, scope = KeybindingScope.DEFAULT) {
+        const key = Keybinding.is(keyOrBinding) ? keyOrBinding.keybinding : keyOrBinding;
+        const keymap = this.keymaps[scope];
+        let bindings;
+        // 当传入的keybinding存在when条件时，严格匹配
+        if (Keybinding.is(keyOrBinding) && !!keyOrBinding.when) {
+            bindings = keymap.filter((el) => this.isKeybindingEqual(el.keybinding, keyOrBinding.keybinding) && this.isKeybindingWhenEqual(el.when, keyOrBinding.when));
+        }
+        else {
+            bindings = keymap.filter((el) => this.isKeybindingEqual(el.keybinding, key));
+        }
+        bindings.forEach((binding) => {
+            const idx = keymap.indexOf(binding);
+            if (idx >= 0) {
+                keymap.splice(idx, 1);
+            }
+        });
+    }
+    // 判断两个when是否相等
+    isKeybindingWhenEqual(when1, when2) {
+        return this.convertMonacoWhen(when1) === this.convertMonacoWhen(when2);
+    }
+    // 判断两个快捷键是否相等
+    // 如 ⌘ 默认等价于 cmd， ctrlcmd
+    isKeybindingEqual(preKeybinding, nextKeybinding) {
+        return this.acceleratorForSequenceKeyString(preKeybinding) === this.acceleratorForSequenceKeyString(nextKeybinding);
+    }
+    // 解析快捷键字符串为统一的结果
+    acceleratorForSequenceKeyString(key) {
+        const keyCodeStrings = key.split(' ');
+        const keySequence = keyCodeStrings.map((key) => keys_1.KeyCode.parse(key));
+        return this.acceleratorForSequence(keySequence, '+').join(' ');
+    }
+    /**
+     * 执行注册多个Keybinding
+     * @param bindings
+     * @param scope
+     */
+    doRegisterKeybindings(bindings, scope = KeybindingScope.DEFAULT) {
+        const toDispose = new ide_core_common_1.Disposable();
+        for (const binding of bindings) {
+            toDispose.addDispose(this.doRegisterKeybinding(binding, scope));
+        }
+        return toDispose;
+    }
+    /**
+     * 执行注册单个Keybinding
+     * @param binding
+     * @param scope
+     */
+    doRegisterKeybinding(binding, scope = KeybindingScope.DEFAULT) {
+        try {
+            this.resolveKeybinding(binding, true);
+            this.keymaps[scope].unshift(binding);
+        }
+        catch (error) {
+            this.logger.warn(`Could not register keybinding:\n  ${Keybinding.stringify(binding)}\n${error}`);
+        }
+        this.keybindingsChanged.fire({ affectsCommands: [binding.command] });
+        return {
+            dispose: () => {
+                this.unregisterKeybinding(binding, scope);
+            },
+        };
+    }
+    /**
+     * 通过调用KeyboardLayoutService来设置给定的ResolvedKeybinding中的`resolved`属性。
+     * @param binding
+     */
+    resolveKeybinding(binding, disableCache) {
+        if (!binding.resolved || disableCache) {
+            const sequence = keys_1.KeySequence.parse(binding.keybinding);
+            binding.resolved = sequence.map((code) => this.keyboardLayoutService.resolveKeyCode(code));
+        }
+        return binding.resolved;
+    }
+    /**
+     * 清除已注册的Keybinding中所有`resolved`属性，以便调用KeyboardLayoutService再次为他们赋值
+     * 当用户的键盘布局发生变化时，执行该方法
+     */
+    clearResolvedKeybindings() {
+        for (let i = KeybindingScope.DEFAULT; i < KeybindingScope.END; i++) {
+            const bindings = this.keymaps[i];
+            for (const binding of bindings) {
+                const bd = binding;
+                bd.resolved = undefined;
+            }
+        }
+    }
+    /**
+     * 检查Keybindings列表中的keySequence冲突
+     * @param bindings
+     * @param binding
+     */
+    containsKeybinding(bindings, binding) {
+        const bindingKeySequence = this.resolveKeybinding(binding);
+        const collisions = this.getKeySequenceCollisions(bindings, bindingKeySequence)
+            .filter((b) => b.when === binding.when);
+        if (collisions.full.length > 0) {
+            this.logger.warn('Collided keybinding is ignored; ', Keybinding.stringify(binding), ' collided with ', collisions.full.map((b) => Keybinding.stringify(b)).join(', '));
+            return true;
+        }
+        if (collisions.partial.length > 0) {
+            this.logger.warn('Shadowing keybinding is ignored; ', Keybinding.stringify(binding), ' shadows ', collisions.partial.map((b) => Keybinding.stringify(b)).join(', '));
+            return true;
+        }
+        if (collisions.shadow.length > 0) {
+            this.logger.warn('Shadowed keybinding is ignored; ', Keybinding.stringify(binding), ' would be shadowed by ', collisions.shadow.map((b) => Keybinding.stringify(b)).join(', '));
+            return true;
+        }
+        return false;
+    }
+    /**
+     * 检查Keybindings列表中的keySequence冲突
+     * 直接返回错误信息，无错误则返回空字符串
+     * @param bindings
+     * @param binding
+     */
+    validateKeybinding(bindings, binding) {
+        const bindingKeySequence = this.resolveKeybinding(binding);
+        const collisions = this.getKeySequenceCollisions(bindings, bindingKeySequence)
+            .filter((b) => b.when === binding.when);
+        if (collisions.full.length > 0) {
+            const collision = collisions.full[0];
+            const command = this.commandRegistry.getCommand(collision.command);
+            return (0, ide_core_common_1.formatLocalize)('keymaps.keybinding.full.collide', `${command ? (command === null || command === void 0 ? void 0 : command.label) || command.id : collision.command}${collision.when ? `{${collision.when}}` : collision.when}`);
+        }
+        if (collisions.partial.length > 0) {
+            const collision = collisions.partial[0];
+            const command = this.commandRegistry.getCommand(collision.command);
+            return (0, ide_core_common_1.formatLocalize)('keymaps.keybinding.partial.collide', `${command ? (command === null || command === void 0 ? void 0 : command.label) || command.id : collision.command}${collision.when ? `{${collision.when}}` : collision.when}`);
+        }
+        if (collisions.shadow.length > 0) {
+            const collision = collisions.shadow[0];
+            const command = this.commandRegistry.getCommand(collision.command);
+            return (0, ide_core_common_1.formatLocalize)('keymaps.keybinding.shadow.collide', `${command ? (command === null || command === void 0 ? void 0 : command.label) || command.id : collision.command}${collision.when ? `{${collision.when}}` : collision.when}`);
+        }
+        return '';
+    }
+    /**
+     * 检查在特定Scope下是否包含该Keybinding
+     *
+     * @param binding
+     * @param scope
+     */
+    containsKeybindingInScope(binding, scope = KeybindingScope.USER) {
+        return this.containsKeybinding(this.keymaps[scope], binding);
+    }
+    /**
+     * 检查在特定Scope下是否包含该Keybinding
+     * 返回冲突信息
+     * 无冲突返回空字符串
+     * @param binding
+     * @param scope
+     */
+    validateKeybindingInScope(binding, scope = KeybindingScope.USER) {
+        return this.validateKeybinding(this.keymaps[scope], binding);
+    }
+    /**
+     * 返回用户可见的Keybinding数据
+     * @param keybinding
+     * @param separator
+     */
+    acceleratorFor(keybinding, separator = ' ') {
+        const bindingKeySequence = this.resolveKeybinding(keybinding);
+        return this.acceleratorForSequence(bindingKeySequence, separator);
+    }
+    /**
+     * 从KeySequence中返回用户可见的Keybinding
+     * @param keySequence
+     * @param separator
+     */
+    acceleratorForSequence(keySequence, separator = ' ') {
+        return keySequence.map((keyCode) => this.acceleratorForKeyCode(keyCode, separator));
+    }
+    acceleratorForKeyString(keyString, separator = ' ') {
+        const keyCode = keys_1.KeyCode.parse(keyString);
+        return this.acceleratorForKeyCode(keyCode, separator);
+    }
+    /**
+     * 将字符串转化为首字母大写
+     * @param str 字符串
+     */
+    capitalizeFirstLetter(str) {
+        return str.replace(/^\S/, function (s) { return s.toUpperCase(); });
+    }
+    /**
+     * 返回用户可读的组合按键指令文本 （带修饰符）
+     * @param keyCode
+     * @param separator
+     */
+    acceleratorForKeyCode(keyCode, separator = ' ') {
+        const keyCodeResult = [];
+        if (keyCode.ctrl) {
+            keyCodeResult.push(this.capitalizeFirstLetter(keys_1.SpecialCases.CTRL));
+        }
+        if (keyCode.alt) {
+            keyCodeResult.push(this.capitalizeFirstLetter(keys_1.SpecialCases.ALT));
+        }
+        if (keyCode.shift) {
+            keyCodeResult.push(this.capitalizeFirstLetter(keys_1.SpecialCases.SHIFT));
+        }
+        if (keyCode.meta) {
+            if (ide_core_common_1.isOSX) {
+                keyCodeResult.push(keys_1.SpecialCases.MACMETA);
+            }
+            else {
+                keyCodeResult.push(this.capitalizeFirstLetter(keys_1.SpecialCases.META));
+            }
+        }
+        if (keyCode.key) {
+            keyCodeResult.push(this.acceleratorForKey(keyCode.key));
+        }
+        return keyCodeResult.join(separator);
+    }
+    /**
+     * 根据Key返回可读文本
+     * @param key
+     */
+    acceleratorForKey(key) {
+        if (ide_core_common_1.isOSX) {
+            if (key === keys_1.Key.ARROW_LEFT) {
+                return keys_1.SpecialCases.ARROW_LEFT;
+            }
+            if (key === keys_1.Key.ARROW_RIGHT) {
+                return keys_1.SpecialCases.ARROW_RIGHT;
+            }
+            if (key === keys_1.Key.ARROW_UP) {
+                return keys_1.SpecialCases.ARROW_UP;
+            }
+            if (key === keys_1.Key.ARROW_DOWN) {
+                return keys_1.SpecialCases.ARROW_DOWN;
+            }
+            if (key === keys_1.Key.BACKSPACE) {
+                return keys_1.SpecialCases.BACKSPACE;
+            }
+            if (key === keys_1.Key.ENTER) {
+                return keys_1.SpecialCases.ENTER;
+            }
+        }
+        const keyString = this.keyboardLayoutService.getKeyboardCharacter(key);
+        if (key.keyCode >= keys_1.Key.KEY_A.keyCode && key.keyCode <= keys_1.Key.KEY_Z.keyCode ||
+            key.keyCode >= keys_1.Key.F1.keyCode && key.keyCode <= keys_1.Key.F24.keyCode) {
+            return keyString.toUpperCase();
+        }
+        else if (keyString.length > 1) {
+            return keyString.charAt(0).toUpperCase() + keyString.slice(1);
+        }
+        else if (keyString === ' ') {
+            // 空格需要额外使用特殊字符进行展示，否则直接输出 `' '` 会比较疑惑
+            return keys_1.SpecialCases.SPACE.charAt(0).toUpperCase() + keys_1.SpecialCases.SPACE.slice(1);
+        }
+        else {
+            return keyString;
+        }
+    }
+    /**
+     * 查找绑定列表中的键序列的冲突（无错误，是否冲突都会返回结果）
+     * @param bindings
+     * @param candidate
+     */
+    getKeySequenceCollisions(bindings, candidate) {
+        const result = new KeybindingsResultCollection.KeybindingsResult();
+        for (const binding of bindings) {
+            try {
+                const bindingKeySequence = this.resolveKeybinding(binding);
+                const compareResult = keys_1.KeySequence.compare(candidate, bindingKeySequence);
+                switch (compareResult) {
+                    case keys_1.KeySequence.CompareResult.FULL: {
+                        result.full.push(binding);
+                        break;
+                    }
+                    case keys_1.KeySequence.CompareResult.PARTIAL: {
+                        result.partial.push(binding);
+                        break;
+                    }
+                    case keys_1.KeySequence.CompareResult.SHADOW: {
+                        result.shadow.push(binding);
+                        break;
+                    }
+                }
+            }
+            catch (error) {
+                this.logger.warn(error);
+            }
+        }
+        return result;
+    }
+    /**
+     * 获取与KeySequence完全匹配或部分匹配的键绑定列表
+     * 列表按优先级排序 （见sortKeybindingsByPriority方法）
+     * @param keySequence
+     */
+    getKeybindingsForKeySequence(keySequence, event) {
+        const result = new KeybindingsResultCollection.KeybindingsResult();
+        for (let scope = KeybindingScope.END; --scope >= KeybindingScope.DEFAULT;) {
+            const matches = this.getKeySequenceCollisions(this.keymaps[scope], keySequence);
+            matches.full = matches.full
+                .sort(this.sortKeybindingsByPriority);
+            matches.partial = matches.partial
+                .sort(this.sortKeybindingsByPriority);
+            result.merge(matches);
+        }
+        // 如果组合键不可用，去掉组合键的功能
+        const partial = result.partial.filter((binding) => this.isEnabled(binding, event));
+        result.partial = partial;
+        return result;
+    }
+    /**
+     * 获取与commandId相关联的键绑定
+     * @param commandId
+     */
+    getKeybindingsForCommand(commandId) {
+        const result = [];
+        for (let scope = KeybindingScope.END - 1; scope >= KeybindingScope.DEFAULT; scope--) {
+            this.keymaps[scope].forEach((binding) => {
+                const command = this.commandRegistry.getCommand(binding.command);
+                if (command) {
+                    if (command.id === commandId) {
+                        result.push(Object.assign(Object.assign({}, binding), { scope }));
+                    }
+                }
+            });
+            if (result.length > 0) {
+                return result;
+            }
+        }
+        return result;
+    }
+    /**
+     * 返回在特定Scope下与commandId关联的键值对列表
+     * @param scope
+     * @param commandId
+     */
+    getScopedKeybindingsForCommand(scope, commandId) {
+        const result = [];
+        if (scope >= KeybindingScope.END) {
+            return [];
+        }
+        this.keymaps[scope].forEach((binding) => {
+            const command = this.commandRegistry.getCommand(binding.command);
+            if (command && command.id === commandId) {
+                result.push(binding);
+            }
+        });
+        return result;
+    }
+    /**
+     * 按优先级顺序对键值绑定进行排序
+     *
+     * 具有When判定的键绑定比没有的优先级更高
+     * 当均具备 when 时，采用 priority 进行优先级判断
+     * @param keybindings
+     */
+    sortKeybindingsByPriority(a, b) {
+        if (a.when && !b.when) {
+            return -1;
+        }
+        if (!a.when && b.when) {
+            return 1;
+        }
+        const compA = (0, ide_core_common_1.isUndefined)(a.priority) ? KeybindingWeight.Default : a.priority;
+        const compB = (0, ide_core_common_1.isUndefined)(b.priority) ? KeybindingWeight.Default : b.priority;
+        return compB - compA;
+    }
+    isActive(binding) {
+        // passthrough命令始终处于活动状态 （无法在命令注册表中找到））
+        if (this.isPseudoCommand(binding.command)) {
+            return true;
+        }
+        const command = this.commandRegistry.getCommand(binding.command);
+        return !!command && !!this.commandRegistry.getActiveHandler(command.id);
+    }
+    /**
+     * 只有在没有上下文（全局上下文）或者我们处于该上下文中时才执行
+     * @param binding
+     * @param event
+     */
+    isEnabled(binding, event) {
+        if (binding.when && !this.whenContextService.match(binding.when, event && event.target)) {
+            return false;
+        }
+        return true;
+    }
+    /**
+     * 判断是否为PASSTHROUGH_PSEUDO_COMMAND
+     * @param commandId
+     */
+    isPseudoCommand(commandId) {
+        return commandId === KeybindingRegistryImpl_1.PASSTHROUGH_PSEUDO_COMMAND;
+    }
+    /**
+     * 重置所有Scope下的键绑定（仅保留映射的默认键绑定）
+     */
+    resetKeybindings() {
+        for (let i = KeybindingScope.DEFAULT + 1; i < KeybindingScope.END; i++) {
+            this.keymaps[i] = [];
+        }
+    }
+    /**
+     * 用于处理诸如 Shift + Shift, Ctrl + Ctrl, Alt + Alt 等快捷键
+     * 参考： https://github.com/microsoft/vscode/pull/115190
+     *
+     * @param event 键盘事件
+     */
+    resolveModifierKey(event) {
+        if (event.defaultPrevented) {
+            return;
+        }
+        if (this.modifierKeySequenceTimer) {
+            clearTimeout(this.modifierKeySequenceTimer);
+        }
+        const keyCode = keys_1.KeyCode.createKeyCode(event);
+        // 当传入的 KeyCode 不是修饰符时，不处理
+        if (!keyCode.isModifierOnly()) {
+            return;
+        }
+        this.modifierKeySequence.push(keyCode);
+        const bindings = this.getKeybindingsForKeySequence(this.modifierKeySequence, event);
+        if (this.tryKeybindingExecution(bindings.full, event)) {
+            this.modifierKeySequence = [];
+        }
+        else if (bindings.partial.length > 0) {
+            // 堆积 modifierKeySequence, 用于实现组合键
+            event.preventDefault();
+            event.stopPropagation();
+            this.modifierKeySequenceTimer = setTimeout(() => {
+                this.modifierKeySequence = [];
+            }, KeybindingRegistryImpl_1.MODIFIER_KEYSEQUENCE_TIMEOUT);
+        }
+        else {
+            this.modifierKeySequence = [];
+        }
+    }
+    /**
+     * 执行匹配键盘事件的命令
+     *
+     * @param event 键盘事件
+     */
+    run(event) {
+        if (event.defaultPrevented) {
+            return;
+        }
+        if (this.keySequenceTimer) {
+            clearTimeout(this.keySequenceTimer);
+        }
+        const keyCode = keys_1.KeyCode.createKeyCode(event);
+        // 当传入的 KeyCode 仅为修饰符，忽略，等待下次输入
+        if (keyCode.isModifierOnly()) {
+            return;
+        }
+        this.keyboardLayoutService.validateKeyCode(keyCode);
+        this.keySequence.push(keyCode);
+        const bindings = this.getKeybindingsForKeySequence(this.keySequence, event);
+        if (this.tryKeybindingExecution(bindings.full, event)) {
+            this.keySequence = [];
+            this.statusBar.removeElement('keybinding-status');
+        }
+        else if (bindings.partial.length > 0) {
+            // 堆积keySequence, 用于实现组合键
+            event.preventDefault();
+            event.stopPropagation();
+            this.statusBar.addElement('keybinding-status', {
+                text: (0, ide_core_common_1.formatLocalize)('keybinding.combination.tip', this.acceleratorForSequence(this.keySequence, '+')),
+                alignment: services_1.StatusBarAlignment.LEFT,
+                priority: 2,
+            });
+            this.keySequenceTimer = setTimeout(() => {
+                this.keySequence = [];
+                this.statusBar.removeElement('keybinding-status');
+            }, KeybindingRegistryImpl_1.KEYSEQUENCE_TIMEOUT);
+        }
+        else {
+            this.keySequence = [];
+            this.statusBar.removeElement('keybinding-status');
+        }
+    }
+    /**
+    * 返回快捷键文本
+    *
+    * @param event 键盘事件
+    */
+    convert(event, separator = ' ') {
+        const keyCode = keys_1.KeyCode.createKeyCode(event);
+        // 当传入的Keycode仅为修饰符，返回上次输出结果
+        if (keyCode.isModifierOnly()) {
+            return this.acceleratorForSequence(this.convertKeySequence, '+').join(separator);
+        }
+        this.keyboardLayoutService.validateKeyCode(keyCode);
+        if (this.convertKeySequence.length <= 1) {
+            this.convertKeySequence.push(keyCode);
+        }
+        else {
+            this.convertKeySequence = [keyCode];
+        }
+        return this.acceleratorForSequence(this.convertKeySequence, '+').join(separator);
+    }
+    /**
+     * 清空键盘事件队列
+     */
+    clearConvert() {
+        this.convertKeySequence = [];
+    }
+    /**
+     * 尝试执行Keybinding
+     * @param bindings
+     * @param event
+     * @return 命令执行成功时返回true，否则为false
+     */
+    tryKeybindingExecution(bindings, event) {
+        if (bindings.length === 0) {
+            return false;
+        }
+        for (const binding of bindings) {
+            if (this.isEnabled(binding, event)) {
+                if (this.isPseudoCommand(binding.command)) {
+                    // 让事件冒泡
+                    return true;
+                }
+                else {
+                    const command = this.commandRegistry.getCommand(binding.command);
+                    if (command) {
+                        this.commandService.executeCommand(command.id, binding.args)
+                            .catch((err) => this.logger.error('Failed to execute command:', err, binding.command));
+                        /* 如果键绑定在上下文中但命令是可用状态下我们仍然在这里停止处理  */
+                        event.preventDefault();
+                        event.stopPropagation();
+                        return true;
+                    }
+                }
+                return false;
+            }
+        }
+        return false;
+    }
+};
+// 该伪命令用于让事件冒泡，使事件不被Keybinding消费掉
+KeybindingRegistryImpl.PASSTHROUGH_PSEUDO_COMMAND = 'passthrough';
+KeybindingRegistryImpl.KEYSEQUENCE_TIMEOUT = 5000;
+KeybindingRegistryImpl.MODIFIER_KEYSEQUENCE_TIMEOUT = 300;
+(0, tslib_1.__decorate)([
+    (0, di_1.Autowired)(keyboard_layout_service_1.KeyboardLayoutService),
+    (0, tslib_1.__metadata)("design:type", keyboard_layout_service_1.KeyboardLayoutService)
+], KeybindingRegistryImpl.prototype, "keyboardLayoutService", void 0);
+(0, tslib_1.__decorate)([
+    (0, di_1.Autowired)(exports.KeybindingContribution),
+    (0, tslib_1.__metadata)("design:type", Object)
+], KeybindingRegistryImpl.prototype, "keybindingContributionProvider", void 0);
+(0, tslib_1.__decorate)([
+    (0, di_1.Autowired)(ide_core_common_1.CommandRegistry),
+    (0, tslib_1.__metadata)("design:type", Object)
+], KeybindingRegistryImpl.prototype, "commandRegistry", void 0);
+(0, tslib_1.__decorate)([
+    (0, di_1.Autowired)(ide_core_common_1.CommandService),
+    (0, tslib_1.__metadata)("design:type", Object)
+], KeybindingRegistryImpl.prototype, "commandService", void 0);
+(0, tslib_1.__decorate)([
+    (0, di_1.Autowired)(ide_core_common_1.ILogger),
+    (0, tslib_1.__metadata)("design:type", Object)
+], KeybindingRegistryImpl.prototype, "logger", void 0);
+(0, tslib_1.__decorate)([
+    (0, di_1.Autowired)(context_key_1.IContextKeyService),
+    (0, tslib_1.__metadata)("design:type", Object)
+], KeybindingRegistryImpl.prototype, "whenContextService", void 0);
+(0, tslib_1.__decorate)([
+    (0, di_1.Autowired)(services_1.IStatusBarService),
+    (0, tslib_1.__metadata)("design:type", Object)
+], KeybindingRegistryImpl.prototype, "statusBar", void 0);
+KeybindingRegistryImpl = KeybindingRegistryImpl_1 = (0, tslib_1.__decorate)([
+    (0, di_1.Injectable)()
+], KeybindingRegistryImpl);
+exports.KeybindingRegistryImpl = KeybindingRegistryImpl;
+exports.NO_KEYBINDING_NAME = 'no_keybinding';
+//# sourceMappingURL=keybinding.js.map