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

package/vscode/src/vs/workbench/contrib/quickaccess/browser/viewQuickAccess.js

@@ -0,0 +1,265 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+import { IQuickInputService, ItemActivation } from 'monaco-editor/esm/vs/platform/quickinput/common/quickInput.js';
+import { PickerQuickAccessProvider } from 'vscode/vscode/vs/platform/quickinput/browser/pickerQuickAccess';
+import { IViewDescriptorService, IViewsService } from 'vscode/vscode/vs/workbench/common/views';
+import { IOutputService } from 'vscode/vscode/vs/workbench/services/output/common/output';
+import { ITerminalService, ITerminalGroupService } from 'vscode/vscode/vs/workbench/contrib/terminal/browser/terminal';
+import { IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { matchesFuzzy } from 'monaco-editor/esm/vs/base/common/filters.js';
+import { fuzzyContains } from 'monaco-editor/esm/vs/base/common/strings.js';
+import { IKeybindingService } from 'monaco-editor/esm/vs/platform/keybinding/common/keybinding.js';
+import { Action2 } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
+import { Categories } from 'monaco-editor/esm/vs/platform/action/common/actionCommonCategories.js';
+import { IPaneCompositePartService } from 'vscode/vscode/vs/workbench/services/panecomposite/browser/panecomposite';
+import { REPL_VIEW_ID, IDebugService } from 'vscode/vscode/vs/workbench/contrib/debug/common/debug';
+
+var ViewQuickAccessProvider_1;
+let ViewQuickAccessProvider = class ViewQuickAccessProvider extends PickerQuickAccessProvider {
+    static { ViewQuickAccessProvider_1 = this; }
+    static { this.PREFIX = 'view '; }
+    constructor(viewDescriptorService, viewsService, outputService, terminalService, terminalGroupService, debugService, paneCompositeService, contextKeyService) {
+        super(ViewQuickAccessProvider_1.PREFIX, {
+            noResultsPick: {
+                label: ( localizeWithPath(
+                    'vs/workbench/contrib/quickaccess/browser/viewQuickAccess',
+                    'noViewResults',
+                    "No matching views"
+                )),
+                containerLabel: ''
+            }
+        });
+        this.viewDescriptorService = viewDescriptorService;
+        this.viewsService = viewsService;
+        this.outputService = outputService;
+        this.terminalService = terminalService;
+        this.terminalGroupService = terminalGroupService;
+        this.debugService = debugService;
+        this.paneCompositeService = paneCompositeService;
+        this.contextKeyService = contextKeyService;
+    }
+    _getPicks(filter) {
+        const filteredViewEntries = this.doGetViewPickItems().filter(entry => {
+            if (!filter) {
+                return true;
+            }
+            entry.highlights = { label: matchesFuzzy(filter, entry.label, true) ?? undefined };
+            return entry.highlights.label || fuzzyContains(entry.containerLabel, filter);
+        });
+        const mapEntryToContainer = ( new Map());
+        for (const entry of filteredViewEntries) {
+            if (!( mapEntryToContainer.has(entry.label))) {
+                mapEntryToContainer.set(entry.label, entry.containerLabel);
+            }
+        }
+        const filteredViewEntriesWithSeparators = [];
+        let lastContainer = undefined;
+        for (const entry of filteredViewEntries) {
+            if (lastContainer !== entry.containerLabel) {
+                lastContainer = entry.containerLabel;
+                let separatorLabel;
+                if (( mapEntryToContainer.has(lastContainer))) {
+                    separatorLabel = `${mapEntryToContainer.get(lastContainer)} / ${lastContainer}`;
+                }
+                else {
+                    separatorLabel = lastContainer;
+                }
+                filteredViewEntriesWithSeparators.push({ type: 'separator', label: separatorLabel });
+            }
+            filteredViewEntriesWithSeparators.push(entry);
+        }
+        return filteredViewEntriesWithSeparators;
+    }
+    doGetViewPickItems() {
+        const viewEntries = [];
+        const getViewEntriesForPaneComposite = (paneComposite, viewContainer) => {
+            const viewContainerModel = this.viewDescriptorService.getViewContainerModel(viewContainer);
+            const result = [];
+            for (const view of viewContainerModel.allViewDescriptors) {
+                if (this.contextKeyService.contextMatchesRules(view.when)) {
+                    result.push({
+                        label: view.name,
+                        containerLabel: viewContainerModel.title,
+                        accept: () => this.viewsService.openView(view.id, true)
+                    });
+                }
+            }
+            return result;
+        };
+        const addPaneComposites = (location, containerLabel) => {
+            const paneComposites = this.paneCompositeService.getPaneComposites(location);
+            const visiblePaneCompositeIds = this.paneCompositeService.getVisiblePaneCompositeIds(location);
+            paneComposites.sort((a, b) => {
+                let aIndex = visiblePaneCompositeIds.findIndex(id => a.id === id);
+                let bIndex = visiblePaneCompositeIds.findIndex(id => b.id === id);
+                if (aIndex < 0) {
+                    aIndex = paneComposites.indexOf(a) + visiblePaneCompositeIds.length;
+                }
+                if (bIndex < 0) {
+                    bIndex = paneComposites.indexOf(b) + visiblePaneCompositeIds.length;
+                }
+                return aIndex - bIndex;
+            });
+            for (const paneComposite of paneComposites) {
+                if (this.includeViewContainer(paneComposite)) {
+                    const viewContainer = this.viewDescriptorService.getViewContainerById(paneComposite.id);
+                    if (viewContainer) {
+                        viewEntries.push({
+                            label: this.viewDescriptorService.getViewContainerModel(viewContainer).title,
+                            containerLabel,
+                            accept: () => this.paneCompositeService.openPaneComposite(paneComposite.id, location, true)
+                        });
+                    }
+                }
+            }
+        };
+        addPaneComposites(0 , ( localizeWithPath(
+            'vs/workbench/contrib/quickaccess/browser/viewQuickAccess',
+            'views',
+            "Side Bar"
+        )));
+        addPaneComposites(1 , ( localizeWithPath(
+            'vs/workbench/contrib/quickaccess/browser/viewQuickAccess',
+            'panels',
+            "Panel"
+        )));
+        addPaneComposites(2 , ( localizeWithPath(
+            'vs/workbench/contrib/quickaccess/browser/viewQuickAccess',
+            'secondary side bar',
+            "Secondary Side Bar"
+        )));
+        const addPaneCompositeViews = (location) => {
+            const paneComposites = this.paneCompositeService.getPaneComposites(location);
+            for (const paneComposite of paneComposites) {
+                const viewContainer = this.viewDescriptorService.getViewContainerById(paneComposite.id);
+                if (viewContainer) {
+                    viewEntries.push(...getViewEntriesForPaneComposite(paneComposite, viewContainer));
+                }
+            }
+        };
+        addPaneCompositeViews(0 );
+        addPaneCompositeViews(1 );
+        addPaneCompositeViews(2 );
+        this.terminalGroupService.groups.forEach((group, groupIndex) => {
+            group.terminalInstances.forEach((terminal, terminalIndex) => {
+                const label = ( localizeWithPath(
+                    'vs/workbench/contrib/quickaccess/browser/viewQuickAccess',
+                    'terminalTitle',
+                    "{0}: {1}",
+                    `${groupIndex + 1}.${terminalIndex + 1}`,
+                    terminal.title
+                ));
+                viewEntries.push({
+                    label,
+                    containerLabel: ( localizeWithPath(
+                        'vs/workbench/contrib/quickaccess/browser/viewQuickAccess',
+                        'terminals',
+                        "Terminal"
+                    )),
+                    accept: async () => {
+                        await this.terminalGroupService.showPanel(true);
+                        this.terminalService.setActiveInstance(terminal);
+                    }
+                });
+            });
+        });
+        this.debugService.getModel().getSessions(true).filter(s => s.hasSeparateRepl()).forEach((session, _) => {
+            const label = session.name;
+            viewEntries.push({
+                label,
+                containerLabel: ( localizeWithPath(
+                    'vs/workbench/contrib/quickaccess/browser/viewQuickAccess',
+                    'debugConsoles',
+                    "Debug Console"
+                )),
+                accept: async () => {
+                    await this.debugService.focusStackFrame(undefined, undefined, session, { explicit: true });
+                    if (!this.viewsService.isViewVisible(REPL_VIEW_ID)) {
+                        await this.viewsService.openView(REPL_VIEW_ID, true);
+                    }
+                }
+            });
+        });
+        const channels = this.outputService.getChannelDescriptors();
+        for (const channel of channels) {
+            viewEntries.push({
+                label: channel.label,
+                containerLabel: ( localizeWithPath(
+                    'vs/workbench/contrib/quickaccess/browser/viewQuickAccess',
+                    'channels',
+                    "Output"
+                )),
+                accept: () => this.outputService.showChannel(channel.id)
+            });
+        }
+        return viewEntries;
+    }
+    includeViewContainer(container) {
+        const viewContainer = this.viewDescriptorService.getViewContainerById(container.id);
+        if (viewContainer?.hideIfEmpty) {
+            return this.viewDescriptorService.getViewContainerModel(viewContainer).activeViewDescriptors.length > 0;
+        }
+        return true;
+    }
+};
+ViewQuickAccessProvider = ViewQuickAccessProvider_1 = ( __decorate([
+    ( __param(0, IViewDescriptorService)),
+    ( __param(1, IViewsService)),
+    ( __param(2, IOutputService)),
+    ( __param(3, ITerminalService)),
+    ( __param(4, ITerminalGroupService)),
+    ( __param(5, IDebugService)),
+    ( __param(6, IPaneCompositePartService)),
+    ( __param(7, IContextKeyService))
+], ViewQuickAccessProvider));
+class OpenViewPickerAction extends Action2 {
+    static { this.ID = 'workbench.action.openView'; }
+    constructor() {
+        super({
+            id: OpenViewPickerAction.ID,
+            title: { value: ( localizeWithPath(
+                'vs/workbench/contrib/quickaccess/browser/viewQuickAccess',
+                'openView',
+                "Open View"
+            )), original: 'Open View' },
+            category: Categories.View,
+            f1: true
+        });
+    }
+    async run(accessor) {
+        accessor.get(IQuickInputService).quickAccess.show(ViewQuickAccessProvider.PREFIX);
+    }
+}
+class QuickAccessViewPickerAction extends Action2 {
+    static { this.ID = 'workbench.action.quickOpenView'; }
+    static { this.KEYBINDING = {
+        primary: 2048  | 47 ,
+        mac: { primary: 256  | 47  },
+        linux: { primary: 0 }
+    }; }
+    constructor() {
+        super({
+            id: QuickAccessViewPickerAction.ID,
+            title: { value: ( localizeWithPath(
+                'vs/workbench/contrib/quickaccess/browser/viewQuickAccess',
+                'quickOpenView',
+                "Quick Open View"
+            )), original: 'Quick Open View' },
+            category: Categories.View,
+            f1: false,
+            keybinding: {
+                weight: 200 ,
+                when: undefined,
+                ...QuickAccessViewPickerAction.KEYBINDING
+            }
+        });
+    }
+    async run(accessor) {
+        const keybindingService = accessor.get(IKeybindingService);
+        const quickInputService = accessor.get(IQuickInputService);
+        const keys = keybindingService.lookupKeybindings(QuickAccessViewPickerAction.ID);
+        quickInputService.quickAccess.show(ViewQuickAccessProvider.PREFIX, { quickNavigateConfiguration: { keybindings: keys }, itemActivation: ItemActivation.FIRST });
+    }
+}
+
+export { OpenViewPickerAction, QuickAccessViewPickerAction, ViewQuickAccessProvider };

package/vscode/src/vs/workbench/services/quickinput/browser/quickInputService.js

@@ -0,0 +1,69 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { ILayoutService } from 'monaco-editor/esm/vs/platform/layout/browser/layoutService.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { IThemeService } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { IKeybindingService } from 'monaco-editor/esm/vs/platform/keybinding/common/keybinding.js';
+import { QuickInputService as QuickInputService$1 } from 'monaco-editor/esm/vs/platform/quickinput/browser/quickInputService.js';
+import { InQuickPickContextKey } from 'vscode/vscode/vs/workbench/browser/quickaccess';
+import { IHoverService } from 'vscode/vscode/vs/workbench/services/hover/browser/hover';
+
+let QuickInputService = class QuickInputService extends QuickInputService$1 {
+    constructor(configurationService, instantiationService, keybindingService, contextKeyService, themeService, layoutService, hoverService) {
+        super(instantiationService, contextKeyService, themeService, layoutService);
+        this.configurationService = configurationService;
+        this.keybindingService = keybindingService;
+        this.hoverService = hoverService;
+        this.hoverDelegate = ( new QuickInputHoverDelegate(this.configurationService, this.hoverService));
+        this.inQuickInputContext = InQuickPickContextKey.bindTo(this.contextKeyService);
+        this.registerListeners();
+    }
+    registerListeners() {
+        this._register(this.onShow(() => this.inQuickInputContext.set(true)));
+        this._register(this.onHide(() => this.inQuickInputContext.set(false)));
+    }
+    createController() {
+        return super.createController(this.layoutService, {
+            ignoreFocusOut: () => !this.configurationService.getValue('workbench.quickOpen.closeOnFocusLost'),
+            backKeybindingLabel: () => this.keybindingService.lookupKeybinding('workbench.action.quickInputBack')?.getLabel() || undefined,
+            hoverDelegate: this.hoverDelegate
+        });
+    }
+};
+QuickInputService = ( __decorate([
+    ( __param(0, IConfigurationService)),
+    ( __param(1, IInstantiationService)),
+    ( __param(2, IKeybindingService)),
+    ( __param(3, IContextKeyService)),
+    ( __param(4, IThemeService)),
+    ( __param(5, ILayoutService)),
+    ( __param(6, IHoverService))
+], QuickInputService));
+class QuickInputHoverDelegate {
+    get delay() {
+        if (Date.now() - this.lastHoverHideTime < 200) {
+            return 0;
+        }
+        return this.configurationService.getValue('workbench.hover.delay');
+    }
+    constructor(configurationService, hoverService) {
+        this.configurationService = configurationService;
+        this.hoverService = hoverService;
+        this.lastHoverHideTime = 0;
+        this.placement = 'element';
+    }
+    showHover(options, focus) {
+        return this.hoverService.showHover({
+            ...options,
+            showHoverHint: true,
+            hideOnKeyDown: false,
+            skipFadeInAnimation: true,
+        }, focus);
+    }
+    onDidHideHover() {
+        this.lastHoverHideTime = Date.now();
+    }
+}
+
+export { QuickInputService };