@opensumi/ide-keymaps 2.12.1-next-079c1930

package/lib/browser/keymaps.service.js

@@ -0,0 +1,671 @@
+"use strict";
+var KeymapService_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KeymapService = void 0;
+const tslib_1 = require("tslib");
+const di_1 = require("@opensumi/di");
+const mobx_1 = require("mobx");
+const ide_core_browser_1 = require("@opensumi/ide-core-browser");
+const keymaps_parser_1 = require("./keymaps-parser");
+const fuzzy = (0, tslib_1.__importStar)(require("fuzzy"));
+const common_1 = require("../common");
+const ide_preferences_1 = require("@opensumi/ide-preferences");
+const ide_file_service_1 = require("@opensumi/ide-file-service");
+const progress_1 = require("@opensumi/ide-core-browser/lib/progress");
+let KeymapService = KeymapService_1 = class KeymapService {
+    constructor() {
+        this.keymapChangeEmitter = new ide_core_browser_1.Emitter();
+        this.convertKeySequence = [];
+        this.toUnregisterUserKeybindingMap = new Map();
+        this.toRestoreDefaultKeybindingMap = new Map();
+        this.searchDelayer = new ide_core_browser_1.ThrottledDelayer(KeymapService_1.DEFAULT_SEARCH_DELAY);
+        this.disposableCollection = new ide_core_browser_1.DisposableCollection();
+        /**
+         * fuzzy搜索参数，pre及post用于包裹搜索结果
+         * @protected
+         * @memberof KeymapService
+         */
+        this.fuzzyOptions = {
+            pre: '<match>',
+            post: '</match>',
+        };
+        this.keybindings = [];
+        /**
+         * 设置快捷键
+         * @param {Keybinding} keybindings
+         * @returns {Promise<void>}
+         * @memberof KeymapsService
+         */
+        this.setKeybinding = (keybinding) => {
+            this.progressService.withProgress({
+                location: ide_core_browser_1.ProgressLocation.Notification,
+            }, (progress) => {
+                return new Promise(async (resolve, reject) => {
+                    progress.report({ message: (0, ide_core_browser_1.localize)('keymaps.keybinding.loading'), increment: 0, total: 100 });
+                    const keybindings = this.storeKeybindings || [];
+                    let updated = false;
+                    for (const kb of keybindings) {
+                        const item = {
+                            when: kb.when,
+                            command: kb.command,
+                            keybinding: kb.key,
+                        };
+                        if (kb.command === keybinding.command) {
+                            updated = true;
+                            this.unregisterUserKeybinding(item);
+                            kb.key = keybinding.keybinding;
+                            this.registerUserKeybinding(Object.assign(Object.assign({}, item), { priority: ide_core_browser_1.KeybindingWeight.WorkbenchContrib * 100 }));
+                        }
+                    }
+                    if (!updated) {
+                        const defaultBinding = this.keybindings.find((kb) => kb.id === keybinding.command && this.getRaw(kb.when) === keybinding.when);
+                        if (defaultBinding && defaultBinding.keybinding) {
+                            this.unregisterDefaultKeybinding({
+                                when: this.getRaw(defaultBinding.when),
+                                command: defaultBinding.id,
+                                keybinding: this.getRaw(defaultBinding.keybinding),
+                            });
+                        }
+                        // 不能额外传入keybinding的resolved值
+                        const item = {
+                            when: this.getWhen(keybinding),
+                            command: keybinding.command,
+                            key: keybinding.keybinding,
+                        };
+                        keybindings.push(item);
+                        this.registerUserKeybinding(keybinding);
+                    }
+                    // 后置存储流程
+                    this.saveKeybinding(keybindings).then(() => {
+                        resolve(undefined);
+                        progress.report({ message: (0, ide_core_browser_1.localize)('keymaps.keybinding.success'), increment: 99 });
+                    }).catch((e) => {
+                        reject(e);
+                        progress.report({ message: (0, ide_core_browser_1.localize)('keymaps.keybinding.fail'), increment: 99 });
+                    }).finally(() => {
+                        setTimeout(() => {
+                            // 3s 后再隐藏进度条
+                            progress.report({ increment: 100 });
+                        }, 3000);
+                    });
+                });
+            }, () => { });
+        };
+        this.covert = (event) => {
+            return this.keybindingService.convert(event, ' ');
+        };
+        this.clearCovert = () => {
+            return this.keybindingService.clearConvert();
+        };
+        /**
+         * 移除给定ID的快捷键绑定
+         * @param {string} commandId
+         * @returns {Promise<void>}
+         * @memberof KeymapsService
+         */
+        this.resetKeybinding = async (item) => {
+            if (!this.resource) {
+                return;
+            }
+            const keymaps = this.storeKeybindings;
+            const filtered = keymaps.filter((a) => a.command !== item.command);
+            this.unregisterUserKeybinding(item);
+            this.restoreDefaultKeybinding(item);
+            this.saveKeybinding(filtered);
+        };
+        this.fixed = async () => {
+            this.commandService.executeCommand(ide_core_browser_1.EDITOR_COMMANDS.OPEN_RESOURCE.id, new ide_core_browser_1.URI().withScheme(common_1.KEYMAPS_SCHEME), { preview: false });
+        };
+        /**
+         * 搜索快捷键
+         */
+        this.searchKeybindings = (search) => {
+            this.currentSearchValue = search;
+            // throttle
+            if (!this.searchDelayer.isTriggered) {
+                this.searchDelayer.cancel();
+            }
+            this.searchDelayer.trigger(async () => {
+                this.doSearchKeybindings(this.currentSearchValue);
+            });
+        };
+        /**
+         * 模糊搜索匹配的快捷键
+         * @protected
+         */
+        this.doSearchKeybindings = (search) => {
+            const items = this.getKeybindingItems();
+            const result = [];
+            items.forEach((item) => {
+                const keys = ['command', 'keybinding', 'when', 'context', 'source'];
+                let matched = false;
+                for (const key of keys) {
+                    const str = item[key];
+                    if (str) {
+                        const fuzzyMatch = fuzzy.match(search, str, this.fuzzyOptions);
+                        if (fuzzyMatch) {
+                            item[key] = fuzzyMatch.rendered;
+                            matched = true;
+                        }
+                        else {
+                            // 匹配到的快捷键会有不同的显示优先级
+                            // 排序
+                            if (key === 'keybinding') {
+                                const queryItems = search.split('+');
+                                // 处理组合键
+                                const tempItems = str.split(' ');
+                                // 存储空格字符串
+                                const spaceIndexArr = [0];
+                                let bindingItems = [];
+                                if (tempItems.length > 1) {
+                                    tempItems.forEach((tItem) => {
+                                        const tKeys = tItem.split('+');
+                                        spaceIndexArr.push(tKeys.length + spaceIndexArr[-1]);
+                                        bindingItems.push(...tKeys);
+                                    });
+                                }
+                                else {
+                                    bindingItems = str.split('+');
+                                }
+                                spaceIndexArr.shift();
+                                const renderedResult = [...bindingItems];
+                                let matchCounter = 0;
+                                queryItems.forEach((queryItem) => {
+                                    let keyFuzzyMatch = { rendered: '', score: 0 };
+                                    let keyIndex = -1;
+                                    if (str) {
+                                        bindingItems.forEach((bindingItem) => {
+                                            // 通过用户输入匹配所有快捷键字段
+                                            const tempFuzzyMatch = fuzzy.match(queryItem, bindingItem, this.fuzzyOptions);
+                                            // 选择匹配度的匹配项
+                                            if (tempFuzzyMatch && tempFuzzyMatch.score > keyFuzzyMatch.score) {
+                                                keyFuzzyMatch = tempFuzzyMatch;
+                                                // 获取在快捷键数组中对应的位置
+                                                keyIndex = renderedResult.indexOf(bindingItem);
+                                            }
+                                        });
+                                        const keyRendered = keyFuzzyMatch.rendered;
+                                        if (keyRendered) {
+                                            if (keyIndex > -1) {
+                                                renderedResult[keyIndex] = keyRendered;
+                                            }
+                                            // 在快捷键数组中移除匹配过的快捷键
+                                            bindingItems.splice(keyIndex, 1, '');
+                                            matchCounter += 1;
+                                        }
+                                    }
+                                });
+                                if (matchCounter === queryItems.length) {
+                                    // 处理组合键的渲染
+                                    if (spaceIndexArr.length > 0) {
+                                        const chordRenderedResult = '';
+                                        renderedResult.forEach((resultKey, index) => {
+                                            if (index === 0) {
+                                                chordRenderedResult.concat(resultKey);
+                                            }
+                                            else if (spaceIndexArr.indexOf(index) !== -1) {
+                                                chordRenderedResult.concat(' ' + resultKey);
+                                            }
+                                            else {
+                                                chordRenderedResult.concat('+' + resultKey);
+                                            }
+                                        });
+                                        item[key] = chordRenderedResult;
+                                    }
+                                    item[key] = renderedResult.join('+');
+                                    matched = true;
+                                }
+                            }
+                        }
+                    }
+                }
+                if (matched) {
+                    result.push(item);
+                }
+            });
+            this.keybindings = result;
+        };
+        /**
+         * 验证快捷键是否可用
+         * @memberof KeymapService
+         */
+        this.validateKeybinding = (keybindingItem, keybinding) => {
+            if (!keybinding) {
+                return (0, ide_core_browser_1.localize)('keymaps.keybinding.require');
+            }
+            try {
+                const binding = {
+                    command: keybindingItem.command,
+                    when: keybindingItem.when,
+                    keybinding,
+                };
+                if (keybindingItem.keybinding === keybinding) {
+                    return ' ';
+                }
+                return this.keybindingRegistry.validateKeybindingInScope(binding);
+            }
+            catch (error) {
+                return error;
+            }
+        };
+        this.detectKeybindings = (keybindingItem, keybinding) => {
+            if (!keybinding) {
+                return [];
+            }
+            try {
+                if (keybindingItem.keybinding === keybinding) {
+                    return [];
+                }
+                // 可能匹配了高亮结果，需要还原部分数据
+                const keybindings = this.keybindings.filter((kb) => this.getRaw(kb.keybinding) === keybinding);
+                // 只返回全匹配快捷键，不返回包含关系快捷键（包含关系会在保存前提示冲突）
+                if (keybindings.length > 0) {
+                    return keybindings.map((binding) => {
+                        const command = this.commandRegistry.getCommand(this.getRaw(binding.command));
+                        const isUserKeybinding = this.storeKeybindings.find((kb) => command && kb.command === command.id);
+                        binding.when = this.getRaw(binding.when);
+                        binding.keybinding = this.getRaw(binding.keybinding);
+                        return {
+                            id: command ? command.id : this.getRaw(binding.command),
+                            command: (command ? command.label || command.id : binding.command) || '',
+                            when: this.keybindingService.convertMonacoWhen(binding.when),
+                            keybinding: this.getRaw(binding.keybinding),
+                            source: isUserKeybinding ? this.getScope(ide_core_browser_1.KeybindingScope.USER) : this.getScope(ide_core_browser_1.KeybindingScope.DEFAULT),
+                        };
+                    });
+                }
+            }
+            catch (error) {
+                this.logger.error(error);
+            }
+            return [];
+        };
+    }
+    get onDidKeymapChanges() {
+        return this.keymapChangeEmitter.event;
+    }
+    get storeKeybindings() {
+        return this._storeKeybindings && this._storeKeybindings.map((keybinding) => (Object.assign(Object.assign({}, keybinding), { command: this.getValidateCommand(keybinding.command), 
+            // 保持对旧版 keybinding 格式兼容
+            key: keybinding.key || keybinding.keybinding })));
+    }
+    set storeKeybindings(value) {
+        this._storeKeybindings = value;
+    }
+    async init() {
+        const keymapUrl = KeymapService_1.KEYMAP_FILE_URI.toString();
+        this.resource = await this.filesystem.getFileStat(keymapUrl);
+        // 如果不存在，则默认创建一个空文件
+        // 集成测有可能后置才会同步这个配置，如果不创建好不方便 watch
+        if (!this.resource) {
+            this.resource = await this.filesystem.createFile(keymapUrl, {
+                content: JSON.stringify([]),
+            });
+        }
+        await this.reconcile();
+        const watcher = await this.filesystem.watchFileChanges(KeymapService_1.KEYMAP_FILE_URI);
+        this.disposableCollection.push(watcher);
+        watcher.onFilesChanged(() => {
+            // 快捷键绑定文件内容变化，重新更新快捷键信息
+            this.reconcile();
+        });
+    }
+    async openResource() {
+        if (!this.resource || !this.resource.uri) {
+            return;
+        }
+        const fsPath = await this.resource.uri;
+        if (!fsPath) {
+            return;
+        }
+        const exist = await this.filesystem.access(fsPath);
+        if (!exist) {
+            const fileStat = await this.filesystem.createFile(fsPath);
+            const stat = await this.filesystem.setContent(fileStat, '{\n}');
+            this.resource = stat || undefined;
+        }
+        if (fsPath) {
+            this.commandService.executeCommand(ide_core_browser_1.EDITOR_COMMANDS.OPEN_RESOURCE.id, new ide_core_browser_1.URI(fsPath), { preview: false });
+        }
+    }
+    disposeRegistedKeybinding() {
+        for (const [, value] of this.toUnregisterUserKeybindingMap) {
+            value.dispose();
+        }
+        for (const [, value] of this.toRestoreDefaultKeybindingMap) {
+            value.dispose();
+        }
+    }
+    dispose() {
+        this.disposeRegistedKeybinding();
+        this.disposableCollection.dispose();
+    }
+    /**
+     * 因为 monaco.edtior.* 替换为 editor.* 为了兼容在 storage 里存量的数据，需要兼容一下
+     * @param command
+     */
+    getValidateCommand(command) {
+        return command.replace(/^monaco.editor/, 'editor');
+    }
+    /**
+     * 重新加载并设置Keymap定义的快捷键
+     * @param keybindings
+     */
+    async reconcile(keybindings) {
+        const keymap = keybindings ? keybindings.slice(0) : await this.parseKeybindings();
+        const bindings = keymap.map((kb) => {
+            // 清洗存入keymap数据
+            return {
+                when: kb.when,
+                command: this.getValidateCommand(kb.command),
+                keybinding: kb.key || kb.keybinding,
+            };
+        });
+        const added = [];
+        const removed = [];
+        // 重新注册快捷键前取消注册先前的快捷键
+        this.disposeRegistedKeybinding();
+        bindings.forEach((kb) => {
+            if (kb.command.startsWith('-')) {
+                removed.push(kb);
+            }
+            else {
+                added.push(kb);
+            }
+        });
+        // 卸载快捷键的语法仅对默认快捷键生效，故这里不需要进行额外操作
+        added.map((kb) => {
+            this.unregisterDefaultKeybinding(kb, true);
+            this.registerUserKeybinding(kb);
+        });
+        // 卸载默认快捷键
+        removed.map((kb) => {
+            // 去除开头的 '-' 便于查找默认快捷键
+            kb.command = kb.command.slice(1);
+            this.unregisterDefaultKeybinding(kb, true);
+        });
+        this.updateKeybindings();
+    }
+    unregisterUserKeybinding(kb) {
+        const key = this.toUniqueKey(kb);
+        if (this.toUnregisterUserKeybindingMap.has(key)) {
+            const disposeable = this.toUnregisterUserKeybindingMap.get(key);
+            disposeable === null || disposeable === void 0 ? void 0 : disposeable.dispose();
+            this.toUnregisterUserKeybindingMap.delete(key);
+        }
+    }
+    registerUserKeybinding(kb) {
+        const key = this.toUniqueKey(kb);
+        this.toUnregisterUserKeybindingMap.set(key, this.keybindingRegistry.registerKeybinding(kb, ide_core_browser_1.KeybindingScope.USER));
+    }
+    unregisterDefaultKeybinding(kd, fromUserScope = false) {
+        if (fromUserScope) {
+            // 当卸载默认快捷键的操作是从用户快捷键初始化时操作的时候
+            // 此时需要找到command下对应keybindings中when及快捷键匹配的快捷键进行卸载
+            const keybindings = this.keybindingRegistry.getKeybindingsForCommand(kd.command);
+            keybindings.map((rawKd) => {
+                const targetKd = Object.assign(Object.assign({}, kd), { keybinding: rawKd.keybinding });
+                this.keybindingRegistry.unregisterKeybinding(targetKd);
+                const key = this.toUniqueKey(kd);
+                // 存储可恢复默认快捷键注册的函数
+                this.toRestoreDefaultKeybindingMap.set(key, ide_core_browser_1.Disposable.create(() => {
+                    this.keybindingRegistry.registerKeybinding(targetKd);
+                }));
+            });
+        }
+        else {
+            // 当直接从快捷键编辑面板直接修改默认快捷键的时候
+            // 由于卸载是定向的快捷键，有明确的快捷键，不需要进行command对应到快捷键的查找，可直接卸载
+            this.keybindingRegistry.unregisterKeybinding(kd);
+            const key = this.toUniqueKey(kd);
+            // 存储可恢复默认快捷键注册的函数
+            this.toRestoreDefaultKeybindingMap.set(key, ide_core_browser_1.Disposable.create(() => {
+                this.keybindingRegistry.registerKeybinding(kd);
+            }));
+        }
+    }
+    restoreDefaultKeybinding(kb) {
+        const key = this.toUniqueKey(kb);
+        const restore = this.toRestoreDefaultKeybindingMap.get(key);
+        restore === null || restore === void 0 ? void 0 : restore.dispose();
+    }
+    toUniqueKey(kb) {
+        return `${kb.command}${kb.when ? `-${kb.when}` : '-'}${kb.keybinding ? `-${kb.keybinding}` : '-'}`;
+    }
+    /**
+     * 更新keybindings列表
+     */
+    updateKeybindings() {
+        if (this.currentSearchValue) {
+            this.doSearchKeybindings(this.currentSearchValue);
+        }
+        else {
+            this.keybindings = this.getKeybindingItems();
+        }
+        this.keymapChangeEmitter.fire();
+    }
+    /**
+     * 解析快捷键数据
+     * @protected
+     * @returns {Promise<Keybinding[]>}
+     * @memberof KeymapsService
+     */
+    async parseKeybindings() {
+        try {
+            const resource = await this.resource;
+            if (!resource) {
+                return [];
+            }
+            const { content } = await this.filesystem.readFile(resource.uri);
+            this.storeKeybindings = this.parser.parse(content.toString());
+        }
+        catch (error) {
+            this.logger.warn(`ParseKeybindings fail: ${error.stack}`);
+            this.storeKeybindings = [];
+        }
+        return this.storeKeybindings;
+    }
+    async saveKeybinding(keymaps) {
+        this.storeKeybindings = keymaps;
+        this.updateKeybindings();
+        if (!this.resource) {
+            this.resource = await this.filesystem.createFile(KeymapService_1.KEYMAP_FILE_URI.toString());
+        }
+        // 更新当前文件资源
+        const stat = await this.filesystem.setContent(this.resource, JSON.stringify(keymaps, undefined, 2));
+        this.resource = stat || undefined;
+    }
+    /**
+     * 从keymaps.json获取快捷键列表
+     * @returns {Promise<Keybinding[]>}
+     * @memberof KeymapsService
+     */
+    async getKeybindings() {
+        return this.storeKeybindings.map((keymap) => ({
+            command: keymap.command,
+            keybinding: keymap.key,
+            when: keymap.when,
+            args: keymap.args,
+        }));
+    }
+    /**
+     * 打开快捷键面板
+     * @protected
+     * @returns {Promise<void>}
+     * @memberof KeymapService
+     */
+    async open() {
+        this.commandService.executeCommand(ide_core_browser_1.EDITOR_COMMANDS.OPEN_RESOURCE.id, new ide_core_browser_1.URI().withScheme(common_1.KEYMAPS_SCHEME), { preview: true });
+    }
+    getWhen(keybinding) {
+        if (!keybinding) {
+            return '';
+        }
+        return this.keybindingService.convertMonacoWhen(keybinding.when);
+    }
+    /**
+     * 获取可读的作用域
+     * @param {KeybindingScope} scope
+     * @returns
+     * @memberof KeymapService
+     */
+    getScope(scope) {
+        if (scope === ide_core_browser_1.KeybindingScope.DEFAULT) {
+            return (0, ide_core_browser_1.localize)('keymaps.source.default');
+        }
+        else if (scope === ide_core_browser_1.KeybindingScope.USER) {
+            return (0, ide_core_browser_1.localize)('keymaps.source.user');
+        }
+        else if (scope === ide_core_browser_1.KeybindingScope.WORKSPACE) {
+            return (0, ide_core_browser_1.localize)('keymaps.source.workspace');
+        }
+        else {
+            return '';
+        }
+    }
+    /**
+     * 获取所有快捷键项
+     * @returns {KeybindingItem[]}
+     * @memberof KeymapService
+     */
+    getKeybindingItems() {
+        const commands = this.commandRegistry.getCommands();
+        const items = [];
+        for (const command of commands) {
+            const keybindings = this.keybindingRegistry.getKeybindingsForCommand(command.id);
+            if (!keybindings || !keybindings.length) {
+                // 针对带有label的Command，在快捷键面板上添加可配置按钮
+                if (command.label) {
+                    items.push({
+                        id: command.id,
+                        command: command.label,
+                        hasCommandLabel: true,
+                    });
+                }
+            }
+            else {
+                keybindings.forEach((kd) => {
+                    let item;
+                    if (this.storeKeybindings) {
+                        const isUserKeybinding = this.storeKeybindings.find((kb) => command && kb.command === command.id);
+                        item = {
+                            id: command.id,
+                            command: command.label || command.id,
+                            keybinding: isUserKeybinding ? isUserKeybinding.key : kd ? this.keybindingRegistry.acceleratorFor(kd, '+').join(' ') : '',
+                            when: isUserKeybinding ? this.getWhen(isUserKeybinding) : this.getWhen((keybindings && kd)),
+                            source: isUserKeybinding ? this.getScope(ide_core_browser_1.KeybindingScope.USER) : this.getScope(ide_core_browser_1.KeybindingScope.DEFAULT),
+                            hasCommandLabel: !!command.label,
+                        };
+                    }
+                    else {
+                        item = {
+                            id: command.id,
+                            command: command.label || command.id,
+                            keybinding: (keybindings && kd) ? this.keybindingRegistry.acceleratorFor(kd, '+').join(' ') : '',
+                            when: this.getWhen((keybindings && kd)),
+                            source: (keybindings && kd && typeof kd.scope !== 'undefined')
+                                ? this.getScope(kd.scope) : '',
+                            hasCommandLabel: !!command.label,
+                        };
+                    }
+                    items.push(item);
+                });
+            }
+        }
+        // 获取排序后的列表
+        const sorted = items.sort((a, b) => this.compareItem(a, b));
+        // 获取定义了快捷键的列表
+        const keyItems = sorted.filter((a) => !!a.keybinding);
+        const otherItems = sorted.filter((a) => !a.keybinding && a.hasCommandLabel);
+        // 让带有 Label 的快捷键命令排序靠前
+        const withLabelItems = keyItems.filter((keybinding) => keybinding.hasCommandLabel);
+        const withoutLabelItems = keyItems.filter((keybinding) => !keybinding.hasCommandLabel);
+        return [...withLabelItems, ...withoutLabelItems, ...otherItems];
+    }
+    // 字典排序
+    compareItem(a, b) {
+        if (a && b) {
+            if (a.source === b.source) {
+                return (a.command.toLowerCase()).localeCompare(b.command.toLowerCase());
+            }
+            else if (a.source === this.getScope(ide_core_browser_1.KeybindingScope.USER)) {
+                return -1;
+            }
+            else {
+                return 1;
+            }
+        }
+        return 0;
+    }
+    /**
+     * 获取被fuzzy替换的原始值
+     * @param {string} keybinding
+     */
+    getRaw(keybinding) {
+        if (!keybinding) {
+            return '';
+        }
+        return keybinding.replace(new RegExp(/<(\/)?match>/ig), '');
+    }
+};
+KeymapService.DEFAULT_SEARCH_DELAY = 500;
+KeymapService.KEYMAP_FILE_URI = new ide_core_browser_1.URI().withScheme(ide_preferences_1.USER_STORAGE_SCHEME).withPath(common_1.KEYMAPS_FILE_NAME);
+(0, tslib_1.__decorate)([
+    (0, di_1.Autowired)(ide_core_browser_1.KeybindingRegistry),
+    (0, tslib_1.__metadata)("design:type", Object)
+], KeymapService.prototype, "keyBindingRegistry", void 0);
+(0, tslib_1.__decorate)([
+    (0, di_1.Autowired)(keymaps_parser_1.KeymapsParser),
+    (0, tslib_1.__metadata)("design:type", keymaps_parser_1.KeymapsParser)
+], KeymapService.prototype, "parser", void 0);
+(0, tslib_1.__decorate)([
+    (0, di_1.Autowired)(ide_core_browser_1.CommandService),
+    (0, tslib_1.__metadata)("design:type", Object)
+], KeymapService.prototype, "commandService", void 0);
+(0, tslib_1.__decorate)([
+    (0, di_1.Autowired)(ide_core_browser_1.CommandRegistry),
+    (0, tslib_1.__metadata)("design:type", Object)
+], KeymapService.prototype, "commandRegistry", void 0);
+(0, tslib_1.__decorate)([
+    (0, di_1.Autowired)(ide_core_browser_1.KeybindingRegistry),
+    (0, tslib_1.__metadata)("design:type", Object)
+], KeymapService.prototype, "keybindingRegistry", void 0);
+(0, tslib_1.__decorate)([
+    (0, di_1.Autowired)(ide_core_browser_1.KeybindingService),
+    (0, tslib_1.__metadata)("design:type", Object)
+], KeymapService.prototype, "keybindingService", void 0);
+(0, tslib_1.__decorate)([
+    (0, di_1.Autowired)(ide_file_service_1.IFileServiceClient),
+    (0, tslib_1.__metadata)("design:type", Object)
+], KeymapService.prototype, "filesystem", void 0);
+(0, tslib_1.__decorate)([
+    (0, di_1.Autowired)(ide_core_browser_1.ILogger),
+    (0, tslib_1.__metadata)("design:type", Object)
+], KeymapService.prototype, "logger", void 0);
+(0, tslib_1.__decorate)([
+    (0, di_1.Autowired)(progress_1.IProgressService),
+    (0, tslib_1.__metadata)("design:type", Object)
+], KeymapService.prototype, "progressService", void 0);
+(0, tslib_1.__decorate)([
+    mobx_1.observable.shallow,
+    (0, tslib_1.__metadata)("design:type", Array)
+], KeymapService.prototype, "keybindings", void 0);
+(0, tslib_1.__decorate)([
+    mobx_1.action,
+    (0, tslib_1.__metadata)("design:type", Function),
+    (0, tslib_1.__metadata)("design:paramtypes", []),
+    (0, tslib_1.__metadata)("design:returntype", void 0)
+], KeymapService.prototype, "updateKeybindings", null);
+(0, tslib_1.__decorate)([
+    mobx_1.action,
+    (0, tslib_1.__metadata)("design:type", Object)
+], KeymapService.prototype, "searchKeybindings", void 0);
+(0, tslib_1.__decorate)([
+    mobx_1.action,
+    (0, tslib_1.__metadata)("design:type", Object)
+], KeymapService.prototype, "doSearchKeybindings", void 0);
+KeymapService = KeymapService_1 = (0, tslib_1.__decorate)([
+    (0, di_1.Injectable)()
+], KeymapService);
+exports.KeymapService = KeymapService;
+//# sourceMappingURL=keymaps.service.js.map