@codingame/monaco-vscode-api 1.79.0-next.0 → 1.79.1

package/dist/vscode/vs/workbench/browser/parts/editor/tabFocus.js

@@ -0,0 +1,77 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { TabFocus } from 'monaco-editor/esm/vs/editor/browser/config/tabFocus.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { IContextKeyService, RawContextKey } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { terminalTabFocusContextKey } from '../../../../platform/terminal/common/terminal.js';
+const editorTabFocusContextKey = ( new RawContextKey('editorTabFocusMode', false, true));
+let TabFocusMode = class TabFocusMode extends Disposable {
+    constructor(contextKeyService, configurationService) {
+        super();
+        this._onDidChange = this._register(( new Emitter()));
+        this.onDidChange = this._onDidChange.event;
+        this._editorContext = editorTabFocusContextKey.bindTo(contextKeyService);
+        this._terminalContext = terminalTabFocusContextKey.bindTo(contextKeyService);
+        const editorConfig = configurationService.getValue('editor.tabFocusMode');
+        const terminalConfig = configurationService.getValue("terminal.integrated.tabFocusMode" ) ?? editorConfig;
+        this._editorContext.set(editorConfig);
+        this._terminalContext.set(terminalConfig);
+        TabFocus.setTabFocusMode(editorConfig, "editorFocus" );
+        TabFocus.setTabFocusMode(terminalConfig, "terminalFocus" );
+        const viewKey = ( new Set());
+        viewKey.add('focusedView');
+        this._register(contextKeyService.onDidChangeContext((c) => {
+            if (c.affectsSome(viewKey)) {
+                const terminalFocus = contextKeyService.getContextKeyValue('focusedView') === 'terminal';
+                const context = terminalFocus ? "terminalFocus"  : "editorFocus" ;
+                if (this._previousViewContext === context) {
+                    return;
+                }
+                if (terminalFocus) {
+                    this._editorContext.reset();
+                }
+                else {
+                    this._terminalContext.reset();
+                }
+                this._previousViewContext = context;
+                this._onDidChange.fire();
+            }
+        }));
+        this._register(configurationService.onDidChangeConfiguration(e => {
+            if (e.affectsConfiguration('editor.tabFocusMode')) {
+                const editorConfig = configurationService.getValue('editor.tabFocusMode');
+                TabFocus.setTabFocusMode(editorConfig, "editorFocus" );
+                this._editorContext.set(editorConfig);
+                const terminalConfig = configurationService.getValue("terminal.integrated.tabFocusMode" );
+                if (terminalConfig === null) {
+                    configurationService.updateValue("terminal.integrated.tabFocusMode" , editorConfig);
+                    TabFocus.setTabFocusMode(editorConfig, "terminalFocus" );
+                    this._terminalContext.set(editorConfig);
+                }
+                this._onDidChange.fire();
+            }
+            else if (e.affectsConfiguration("terminal.integrated.tabFocusMode" )) {
+                const terminalConfig = configurationService.getValue("terminal.integrated.tabFocusMode" ) ?? configurationService.getValue('editor.tabFocusMode');
+                configurationService.updateValue("terminal.integrated.tabFocusMode" , terminalConfig);
+                TabFocus.setTabFocusMode(terminalConfig, "terminalFocus" );
+                this._terminalContext.set(terminalConfig);
+                this._onDidChange.fire();
+            }
+        }));
+        TabFocus.onDidChangeTabFocus(() => {
+            const focusedView = contextKeyService.getContextKeyValue('focusedView') === 'terminal' ? "terminalFocus"  : "editorFocus" ;
+            if (focusedView === "terminalFocus" ) {
+                this._terminalContext.set(TabFocus.getTabFocusMode(focusedView));
+            }
+            else {
+                this._editorContext.set(TabFocus.getTabFocusMode(focusedView));
+            }
+        });
+    }
+};
+TabFocusMode = ( __decorate([
+    ( __param(0, IContextKeyService)),
+    ( __param(1, IConfigurationService))
+], TabFocusMode));
+export { TabFocusMode, editorTabFocusContextKey };