@codingame/monaco-vscode-keybindings-service-override 4.1.0 → 4.1.1

package/vscode/src/vs/workbench/services/commands/common/commandService.js

@@ -0,0 +1,79 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
+import { CommandsRegistry } from 'vscode/vscode/vs/platform/commands/common/commands';
+import { IExtensionService } from 'vscode/vscode/vs/workbench/services/extensions/common/extensions';
+import { Emitter, Event } from 'vscode/vscode/vs/base/common/event';
+import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import { ILogService } from 'vscode/vscode/vs/platform/log/common/log';
+import { timeout } from 'vscode/vscode/vs/base/common/async';
+
+let CommandService = class CommandService extends Disposable {
+    constructor(_instantiationService, _extensionService, _logService) {
+        super();
+        this._instantiationService = _instantiationService;
+        this._extensionService = _extensionService;
+        this._logService = _logService;
+        this._extensionHostIsReady = false;
+        this._onWillExecuteCommand = this._register(( new Emitter()));
+        this.onWillExecuteCommand = this._onWillExecuteCommand.event;
+        this._onDidExecuteCommand = ( new Emitter());
+        this.onDidExecuteCommand = this._onDidExecuteCommand.event;
+        this._extensionService.whenInstalledExtensionsRegistered().then(value => this._extensionHostIsReady = value);
+        this._starActivation = null;
+    }
+    _activateStar() {
+        if (!this._starActivation) {
+            this._starActivation = Promise.race([
+                this._extensionService.activateByEvent(`*`),
+                timeout(30000)
+            ]);
+        }
+        return this._starActivation;
+    }
+    async executeCommand(id, ...args) {
+        this._logService.trace('CommandService#executeCommand', id);
+        const activationEvent = `onCommand:${id}`;
+        const commandIsRegistered = !!CommandsRegistry.getCommand(id);
+        if (commandIsRegistered) {
+            if (this._extensionService.activationEventIsDone(activationEvent)) {
+                return this._tryExecuteCommand(id, args);
+            }
+            if (!this._extensionHostIsReady) {
+                this._extensionService.activateByEvent(activationEvent);
+                return this._tryExecuteCommand(id, args);
+            }
+            await this._extensionService.activateByEvent(activationEvent);
+            return this._tryExecuteCommand(id, args);
+        }
+        await Promise.all([
+            this._extensionService.activateByEvent(activationEvent),
+            Promise.race([
+                this._activateStar(),
+                Event.toPromise(Event.filter(CommandsRegistry.onDidRegisterCommand, e => e === id))
+            ]),
+        ]);
+        return this._tryExecuteCommand(id, args);
+    }
+    _tryExecuteCommand(id, args) {
+        const command = CommandsRegistry.getCommand(id);
+        if (!command) {
+            return Promise.reject(( new Error(`command '${id}' not found`)));
+        }
+        try {
+            this._onWillExecuteCommand.fire({ commandId: id, args });
+            const result = this._instantiationService.invokeFunction(command.handler, ...args);
+            this._onDidExecuteCommand.fire({ commandId: id, args });
+            return Promise.resolve(result);
+        }
+        catch (err) {
+            return Promise.reject(err);
+        }
+    }
+};
+CommandService = ( __decorate([
+    ( __param(0, IInstantiationService)),
+    ( __param(1, IExtensionService)),
+    ( __param(2, ILogService))
+], CommandService));
+
+export { CommandService };