@codingame/monaco-vscode-keybindings-service-override 1.83.8 → 1.83.10-next.0

package/vscode/src/vs/workbench/browser/contextkeys.js

@@ -0,0 +1,251 @@
+import { __decorate, __param } from '../../../../../external/tslib/tslib.es6.js';
+import { Event } from 'monaco-editor/esm/vs/base/common/event.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { setConstant, IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { IsMacContext, IsLinuxContext, IsWindowsContext, IsWebContext, IsMacNativeContext, IsIOSContext, IsMobileContext, IsDevelopmentContext, ProductQualityContext, InputFocusedContext } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkeys.js';
+import { RemoteNameContext, VirtualWorkspaceContext, TemporaryWorkspaceContext, HasWebFileSystemAccess, EmbedderIdentifierContext, ActiveEditorContext, ActiveEditorReadonlyContext, ActiveEditorCanToggleReadonlyContext, ActiveEditorCanRevertContext, ActiveEditorCanSplitInGroupContext, ActiveEditorAvailableEditorIdsContext, EditorsVisibleContext, TextCompareEditorVisibleContext, TextCompareEditorActiveContext, SideBySideEditorActiveContext, ActiveEditorGroupEmptyContext, ActiveEditorGroupIndexContext, ActiveEditorGroupLastContext, ActiveEditorGroupLockedContext, MultipleEditorGroupsContext, DirtyWorkingCopiesContext, WorkbenchStateContext, WorkspaceFolderCountContext, OpenFolderWorkspaceSupportContext, EmptyWorkspaceSupportContext, EnterMultiRootWorkspaceSupportContext, SplitEditorsVertically, IsFullscreenContext, InEditorZenModeContext, IsCenteredLayoutContext, EditorAreaVisibleContext, EditorTabsVisibleContext, SideBarVisibleContext, PanelPositionContext, PanelVisibleContext, PanelMaximizedContext, PanelAlignmentContext, AuxiliaryBarVisibleContext, applyAvailableEditorIds } from 'vscode/vscode/vs/workbench/common/contextkeys';
+import { TEXT_DIFF_EDITOR_ID, SIDE_BY_SIDE_EDITOR_ID, EditorResourceAccessor, SideBySideEditor } from 'vscode/vscode/vs/workbench/common/editor';
+import { addDisposableListener, EventType, trackFocus } from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { preferredSideBySideGroupDirection, IEditorGroupsService } from 'vscode/vscode/vs/workbench/services/editor/common/editorGroupsService';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { IWorkbenchEnvironmentService } from 'vscode/vscode/vs/workbench/services/environment/common/environmentService';
+import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService';
+import { isTemporaryWorkspace, IWorkspaceContextService } from 'monaco-editor/esm/vs/platform/workspace/common/workspace.js';
+import { positionToString, IWorkbenchLayoutService } from 'vscode/vscode/vs/workbench/services/layout/browser/layoutService';
+import { getRemoteName } from 'monaco-editor/esm/vs/platform/remote/common/remoteHosts.js';
+import { getVirtualWorkspaceScheme } from 'vscode/vscode/vs/platform/workspace/common/virtualWorkspace';
+import { IWorkingCopyService } from 'vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyService';
+import { isNative } from 'monaco-editor/esm/vs/base/common/platform.js';
+import { IEditorResolverService } from 'vscode/vscode/vs/workbench/services/editor/common/editorResolverService';
+import { IPaneCompositePartService } from 'vscode/vscode/vs/workbench/services/panecomposite/browser/panecomposite';
+import { WebFileSystemAccess } from 'monaco-editor/esm/vs/platform/files/browser/webFileSystemAccess.js';
+import { IProductService } from 'monaco-editor/esm/vs/platform/product/common/productService.js';
+import { IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
+
+let WorkbenchContextKeysHandler = class WorkbenchContextKeysHandler extends Disposable {
+    constructor(contextKeyService, contextService, configurationService, environmentService, productService, editorService, editorResolverService, editorGroupService, layoutService, paneCompositeService, workingCopyService, fileService) {
+        super();
+        this.contextKeyService = contextKeyService;
+        this.contextService = contextService;
+        this.configurationService = configurationService;
+        this.environmentService = environmentService;
+        this.productService = productService;
+        this.editorService = editorService;
+        this.editorResolverService = editorResolverService;
+        this.editorGroupService = editorGroupService;
+        this.layoutService = layoutService;
+        this.paneCompositeService = paneCompositeService;
+        this.workingCopyService = workingCopyService;
+        this.fileService = fileService;
+        IsMacContext.bindTo(this.contextKeyService);
+        IsLinuxContext.bindTo(this.contextKeyService);
+        IsWindowsContext.bindTo(this.contextKeyService);
+        IsWebContext.bindTo(this.contextKeyService);
+        IsMacNativeContext.bindTo(this.contextKeyService);
+        IsIOSContext.bindTo(this.contextKeyService);
+        IsMobileContext.bindTo(this.contextKeyService);
+        RemoteNameContext.bindTo(this.contextKeyService).set(getRemoteName(this.environmentService.remoteAuthority) || '');
+        this.virtualWorkspaceContext = VirtualWorkspaceContext.bindTo(this.contextKeyService);
+        this.temporaryWorkspaceContext = TemporaryWorkspaceContext.bindTo(this.contextKeyService);
+        this.updateWorkspaceContextKeys();
+        HasWebFileSystemAccess.bindTo(this.contextKeyService).set(WebFileSystemAccess.supported(window));
+        const isDevelopment = !this.environmentService.isBuilt || this.environmentService.isExtensionDevelopment;
+        IsDevelopmentContext.bindTo(this.contextKeyService).set(isDevelopment);
+        setConstant(IsDevelopmentContext.key, isDevelopment);
+        ProductQualityContext.bindTo(this.contextKeyService).set(this.productService.quality || '');
+        EmbedderIdentifierContext.bindTo(this.contextKeyService).set(productService.embedderIdentifier);
+        this.activeEditorContext = ActiveEditorContext.bindTo(this.contextKeyService);
+        this.activeEditorIsReadonly = ActiveEditorReadonlyContext.bindTo(this.contextKeyService);
+        this.activeEditorCanToggleReadonly = ActiveEditorCanToggleReadonlyContext.bindTo(this.contextKeyService);
+        this.activeEditorCanRevert = ActiveEditorCanRevertContext.bindTo(this.contextKeyService);
+        this.activeEditorCanSplitInGroup = ActiveEditorCanSplitInGroupContext.bindTo(this.contextKeyService);
+        this.activeEditorAvailableEditorIds = ActiveEditorAvailableEditorIdsContext.bindTo(this.contextKeyService);
+        this.editorsVisibleContext = EditorsVisibleContext.bindTo(this.contextKeyService);
+        this.textCompareEditorVisibleContext = TextCompareEditorVisibleContext.bindTo(this.contextKeyService);
+        this.textCompareEditorActiveContext = TextCompareEditorActiveContext.bindTo(this.contextKeyService);
+        this.sideBySideEditorActiveContext = SideBySideEditorActiveContext.bindTo(this.contextKeyService);
+        this.activeEditorGroupEmpty = ActiveEditorGroupEmptyContext.bindTo(this.contextKeyService);
+        this.activeEditorGroupIndex = ActiveEditorGroupIndexContext.bindTo(this.contextKeyService);
+        this.activeEditorGroupLast = ActiveEditorGroupLastContext.bindTo(this.contextKeyService);
+        this.activeEditorGroupLocked = ActiveEditorGroupLockedContext.bindTo(this.contextKeyService);
+        this.multipleEditorGroupsContext = MultipleEditorGroupsContext.bindTo(this.contextKeyService);
+        this.dirtyWorkingCopiesContext = DirtyWorkingCopiesContext.bindTo(this.contextKeyService);
+        this.dirtyWorkingCopiesContext.set(this.workingCopyService.hasDirty);
+        this.inputFocusedContext = InputFocusedContext.bindTo(this.contextKeyService);
+        this.workbenchStateContext = WorkbenchStateContext.bindTo(this.contextKeyService);
+        this.updateWorkbenchStateContextKey();
+        this.workspaceFolderCountContext = WorkspaceFolderCountContext.bindTo(this.contextKeyService);
+        this.updateWorkspaceFolderCountContextKey();
+        this.openFolderWorkspaceSupportContext = OpenFolderWorkspaceSupportContext.bindTo(this.contextKeyService);
+        this.openFolderWorkspaceSupportContext.set(isNative || typeof this.environmentService.remoteAuthority === 'string');
+        this.emptyWorkspaceSupportContext = EmptyWorkspaceSupportContext.bindTo(this.contextKeyService);
+        this.emptyWorkspaceSupportContext.set(isNative || typeof this.environmentService.remoteAuthority === 'string');
+        this.enterMultiRootWorkspaceSupportContext = EnterMultiRootWorkspaceSupportContext.bindTo(this.contextKeyService);
+        this.enterMultiRootWorkspaceSupportContext.set(isNative || typeof this.environmentService.remoteAuthority === 'string');
+        this.splitEditorsVerticallyContext = SplitEditorsVertically.bindTo(this.contextKeyService);
+        this.updateSplitEditorsVerticallyContext();
+        this.isFullscreenContext = IsFullscreenContext.bindTo(this.contextKeyService);
+        this.inZenModeContext = InEditorZenModeContext.bindTo(this.contextKeyService);
+        this.isCenteredLayoutContext = IsCenteredLayoutContext.bindTo(this.contextKeyService);
+        this.editorAreaVisibleContext = EditorAreaVisibleContext.bindTo(this.contextKeyService);
+        this.editorTabsVisibleContext = EditorTabsVisibleContext.bindTo(this.contextKeyService);
+        this.sideBarVisibleContext = SideBarVisibleContext.bindTo(this.contextKeyService);
+        this.panelPositionContext = PanelPositionContext.bindTo(this.contextKeyService);
+        this.panelPositionContext.set(positionToString(this.layoutService.getPanelPosition()));
+        this.panelVisibleContext = PanelVisibleContext.bindTo(this.contextKeyService);
+        this.panelVisibleContext.set(this.layoutService.isVisible("workbench.parts.panel" ));
+        this.panelMaximizedContext = PanelMaximizedContext.bindTo(this.contextKeyService);
+        this.panelMaximizedContext.set(this.layoutService.isPanelMaximized());
+        this.panelAlignmentContext = PanelAlignmentContext.bindTo(this.contextKeyService);
+        this.panelAlignmentContext.set(this.layoutService.getPanelAlignment());
+        this.auxiliaryBarVisibleContext = AuxiliaryBarVisibleContext.bindTo(this.contextKeyService);
+        this.auxiliaryBarVisibleContext.set(this.layoutService.isVisible("workbench.parts.auxiliarybar" ));
+        this.registerListeners();
+    }
+    registerListeners() {
+        this.editorGroupService.whenReady.then(() => {
+            this.updateEditorAreaContextKeys();
+            this.updateEditorContextKeys();
+        });
+        this._register(this.editorService.onDidActiveEditorChange(() => this.updateEditorContextKeys()));
+        this._register(this.editorService.onDidVisibleEditorsChange(() => this.updateEditorContextKeys()));
+        this._register(this.editorGroupService.onDidAddGroup(() => this.updateEditorContextKeys()));
+        this._register(this.editorGroupService.onDidRemoveGroup(() => this.updateEditorContextKeys()));
+        this._register(this.editorGroupService.onDidChangeGroupIndex(() => this.updateEditorContextKeys()));
+        this._register(this.editorGroupService.onDidChangeActiveGroup(() => this.updateEditorGroupContextKeys()));
+        this._register(this.editorGroupService.onDidChangeGroupLocked(() => this.updateEditorGroupContextKeys()));
+        this._register(this.editorGroupService.onDidChangeEditorPartOptions(() => this.updateEditorAreaContextKeys()));
+        this._register(addDisposableListener(window, EventType.FOCUS_IN, () => this.updateInputContextKeys(), true));
+        this._register(this.contextService.onDidChangeWorkbenchState(() => this.updateWorkbenchStateContextKey()));
+        this._register(this.contextService.onDidChangeWorkspaceFolders(() => {
+            this.updateWorkspaceFolderCountContextKey();
+            this.updateWorkspaceContextKeys();
+        }));
+        this._register(this.configurationService.onDidChangeConfiguration(e => {
+            if (e.affectsConfiguration('workbench.editor.openSideBySideDirection')) {
+                this.updateSplitEditorsVerticallyContext();
+            }
+        }));
+        this._register(this.layoutService.onDidChangeZenMode(enabled => this.inZenModeContext.set(enabled)));
+        this._register(this.layoutService.onDidChangeFullscreen(fullscreen => this.isFullscreenContext.set(fullscreen)));
+        this._register(this.layoutService.onDidChangeCenteredLayout(centered => this.isCenteredLayoutContext.set(centered)));
+        this._register(this.layoutService.onDidChangePanelPosition(position => this.panelPositionContext.set(position)));
+        this._register(this.layoutService.onDidChangePanelAlignment(alignment => this.panelAlignmentContext.set(alignment)));
+        this._register(this.paneCompositeService.onDidPaneCompositeClose(() => this.updateSideBarContextKeys()));
+        this._register(this.paneCompositeService.onDidPaneCompositeOpen(() => this.updateSideBarContextKeys()));
+        this._register(this.layoutService.onDidChangePartVisibility(() => {
+            this.editorAreaVisibleContext.set(this.layoutService.isVisible("workbench.parts.editor" ));
+            this.panelVisibleContext.set(this.layoutService.isVisible("workbench.parts.panel" ));
+            this.panelMaximizedContext.set(this.layoutService.isPanelMaximized());
+            this.auxiliaryBarVisibleContext.set(this.layoutService.isVisible("workbench.parts.auxiliarybar" ));
+        }));
+        this._register(this.workingCopyService.onDidChangeDirty(workingCopy => this.dirtyWorkingCopiesContext.set(workingCopy.isDirty() || this.workingCopyService.hasDirty)));
+    }
+    updateEditorAreaContextKeys() {
+        this.editorTabsVisibleContext.set(!!this.editorGroupService.partOptions.showTabs);
+    }
+    updateEditorContextKeys() {
+        const activeEditorPane = this.editorService.activeEditorPane;
+        const visibleEditorPanes = this.editorService.visibleEditorPanes;
+        this.textCompareEditorActiveContext.set(activeEditorPane?.getId() === TEXT_DIFF_EDITOR_ID);
+        this.textCompareEditorVisibleContext.set(( visibleEditorPanes.some(editorPane => editorPane.getId() === TEXT_DIFF_EDITOR_ID)));
+        this.sideBySideEditorActiveContext.set(activeEditorPane?.getId() === SIDE_BY_SIDE_EDITOR_ID);
+        if (visibleEditorPanes.length > 0) {
+            this.editorsVisibleContext.set(true);
+        }
+        else {
+            this.editorsVisibleContext.reset();
+        }
+        if (!this.editorService.activeEditor) {
+            this.activeEditorGroupEmpty.set(true);
+        }
+        else {
+            this.activeEditorGroupEmpty.reset();
+        }
+        this.updateEditorGroupContextKeys();
+        if (activeEditorPane) {
+            this.activeEditorContext.set(activeEditorPane.getId());
+            this.activeEditorCanRevert.set(!activeEditorPane.input.hasCapability(4 ));
+            this.activeEditorCanSplitInGroup.set(activeEditorPane.input.hasCapability(32 ));
+            applyAvailableEditorIds(this.activeEditorAvailableEditorIds, activeEditorPane.input, this.editorResolverService);
+            this.activeEditorIsReadonly.set(!!activeEditorPane.input.isReadonly());
+            const primaryEditorResource = EditorResourceAccessor.getOriginalUri(activeEditorPane.input, { supportSideBySide: SideBySideEditor.PRIMARY });
+            this.activeEditorCanToggleReadonly.set(!!primaryEditorResource && this.fileService.hasProvider(primaryEditorResource) && !this.fileService.hasCapability(primaryEditorResource, 2048 ));
+        }
+        else {
+            this.activeEditorContext.reset();
+            this.activeEditorIsReadonly.reset();
+            this.activeEditorCanToggleReadonly.reset();
+            this.activeEditorCanRevert.reset();
+            this.activeEditorCanSplitInGroup.reset();
+            this.activeEditorAvailableEditorIds.reset();
+        }
+    }
+    updateEditorGroupContextKeys() {
+        const groupCount = this.editorGroupService.count;
+        if (groupCount > 1) {
+            this.multipleEditorGroupsContext.set(true);
+        }
+        else {
+            this.multipleEditorGroupsContext.reset();
+        }
+        const activeGroup = this.editorGroupService.activeGroup;
+        this.activeEditorGroupIndex.set(activeGroup.index + 1);
+        this.activeEditorGroupLast.set(activeGroup.index === groupCount - 1);
+        this.activeEditorGroupLocked.set(activeGroup.isLocked);
+    }
+    updateInputContextKeys() {
+        function activeElementIsInput() {
+            return !!document.activeElement && (document.activeElement.tagName === 'INPUT' || document.activeElement.tagName === 'TEXTAREA');
+        }
+        const isInputFocused = activeElementIsInput();
+        this.inputFocusedContext.set(isInputFocused);
+        if (isInputFocused) {
+            const tracker = trackFocus(document.activeElement);
+            Event.once(tracker.onDidBlur)(() => {
+                this.inputFocusedContext.set(activeElementIsInput());
+                tracker.dispose();
+            });
+        }
+    }
+    updateWorkbenchStateContextKey() {
+        this.workbenchStateContext.set(this.getWorkbenchStateString());
+    }
+    updateWorkspaceFolderCountContextKey() {
+        this.workspaceFolderCountContext.set(this.contextService.getWorkspace().folders.length);
+    }
+    updateSplitEditorsVerticallyContext() {
+        const direction = preferredSideBySideGroupDirection(this.configurationService);
+        this.splitEditorsVerticallyContext.set(direction === 1 );
+    }
+    getWorkbenchStateString() {
+        switch (this.contextService.getWorkbenchState()) {
+            case 1 : return 'empty';
+            case 2 : return 'folder';
+            case 3 : return 'workspace';
+        }
+    }
+    updateSideBarContextKeys() {
+        this.sideBarVisibleContext.set(this.layoutService.isVisible("workbench.parts.sidebar" ));
+    }
+    updateWorkspaceContextKeys() {
+        this.virtualWorkspaceContext.set(getVirtualWorkspaceScheme(this.contextService.getWorkspace()) || '');
+        this.temporaryWorkspaceContext.set(isTemporaryWorkspace(this.contextService.getWorkspace()));
+    }
+};
+WorkbenchContextKeysHandler = ( __decorate([
+    ( __param(0, IContextKeyService)),
+    ( __param(1, IWorkspaceContextService)),
+    ( __param(2, IConfigurationService)),
+    ( __param(3, IWorkbenchEnvironmentService)),
+    ( __param(4, IProductService)),
+    ( __param(5, IEditorService)),
+    ( __param(6, IEditorResolverService)),
+    ( __param(7, IEditorGroupsService)),
+    ( __param(8, IWorkbenchLayoutService)),
+    ( __param(9, IPaneCompositePartService)),
+    ( __param(10, IWorkingCopyService)),
+    ( __param(11, IFileService))
+], WorkbenchContextKeysHandler));
+
+export { WorkbenchContextKeysHandler };

package/vscode/src/vs/workbench/contrib/keybindings/browser/keybindings.contribution.js

@@ -0,0 +1,29 @@
+import * as nls from 'monaco-editor/esm/vs/nls.js';
+import { registerAction2, Action2 } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
+import { IKeybindingService } from 'monaco-editor/esm/vs/platform/keybinding/common/keybinding.js';
+import { Categories } from 'monaco-editor/esm/vs/platform/action/common/actionCommonCategories.js';
+import { ICommandService } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
+import { showWindowLogActionId } from 'vscode/vscode/vs/workbench/services/log/common/logConstants';
+
+class ToggleKeybindingsLogAction extends Action2 {
+    constructor() {
+        super({
+            id: 'workbench.action.toggleKeybindingsLog',
+            title: { value: ( nls.localizeWithPath(
+                'vs/workbench/contrib/keybindings/browser/keybindings.contribution',
+                'toggleKeybindingsLog',
+                "Toggle Keyboard Shortcuts Troubleshooting"
+            )), original: 'Toggle Keyboard Shortcuts Troubleshooting' },
+            category: Categories.Developer,
+            f1: true
+        });
+    }
+    run(accessor) {
+        const logging = accessor.get(IKeybindingService).toggleLogging();
+        if (logging) {
+            const commandService = accessor.get(ICommandService);
+            commandService.executeCommand(showWindowLogActionId);
+        }
+    }
+}
+registerAction2(ToggleKeybindingsLogAction);