@codingame/monaco-vscode-debug-service-override 1.82.4 → 1.82.5-next.1

package/vscode/src/vs/workbench/contrib/debug/browser/debugToolBar.js

@@ -0,0 +1,314 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import * as browser from 'monaco-editor/esm/vs/base/browser/browser.js';
+import * as dom from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { StandardMouseEvent } from 'monaco-editor/esm/vs/base/browser/mouseEvent.js';
+import { ActionBar } from 'monaco-editor/esm/vs/base/browser/ui/actionbar/actionbar.js';
+import { Action } from 'monaco-editor/esm/vs/base/common/actions.js';
+import * as arrays from 'monaco-editor/esm/vs/base/common/arrays.js';
+import { RunOnceScheduler } from 'monaco-editor/esm/vs/base/common/async.js';
+import * as errors from 'monaco-editor/esm/vs/base/common/errors.js';
+import { dispose, DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import './media/debugToolBar.css.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { DropdownWithPrimaryActionViewItem } from 'vscode/vscode/vs/platform/actions/browser/dropdownWithPrimaryActionViewItem';
+import { createActionViewItem, createAndFillInActionBarActions } from 'monaco-editor/esm/vs/platform/actions/browser/menuEntryActionViewItem.js';
+import { MenuRegistry, MenuId, IMenuService } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { ContextKeyExpr, IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { IContextMenuService } from 'monaco-editor/esm/vs/platform/contextview/browser/contextView.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { INotificationService } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
+import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
+import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
+import { widgetShadow, widgetBorder } from 'monaco-editor/esm/vs/platform/theme/common/colorRegistry.js';
+import { Themable, IThemeService } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
+import { ThemeIcon } from 'monaco-editor/esm/vs/base/common/themables.js';
+import { FocusSessionActionViewItem } from './debugActionViewItems.js';
+import { debugToolBarBackground, debugToolBarBorder } from 'vscode/vscode/vs/workbench/contrib/debug/browser/debugColors';
+import { CONTINUE_LABEL, CONTINUE_ID, PAUSE_LABEL, PAUSE_ID, DISCONNECT_ID, DISCONNECT_LABEL, STOP_LABEL, STOP_ID, STEP_OVER_LABEL, STEP_OVER_ID, STEP_INTO_LABEL, STEP_INTO_ID, STEP_OUT_LABEL, STEP_OUT_ID, STEP_BACK_ID, REVERSE_CONTINUE_ID, DISCONNECT_AND_SUSPEND_ID, DISCONNECT_AND_SUSPEND_LABEL, FOCUS_SESSION_ID, RESTART_LABEL, RESTART_SESSION_ID, FOCUS_SESSION_LABEL } from './debugCommands.js';
+import { debugContinue, debugPause, debugDisconnect, debugStop, debugStepOver, debugStepInto, debugStepOut, debugStepBack, debugReverseContinue, debugGripper, debugRestart } from 'vscode/vscode/vs/workbench/contrib/debug/browser/debugIcons';
+import { VIEWLET_ID, CONTEXT_DEBUG_STATE, CONTEXT_FOCUSED_SESSION_IS_ATTACH, CONTEXT_TERMINATE_DEBUGGEE_SUPPORTED, CONTEXT_STEP_BACK_SUPPORTED, CONTEXT_SUSPEND_DEBUGGEE_SUPPORTED, CONTEXT_MULTI_SESSION_DEBUG, IDebugService } from 'vscode/vscode/vs/workbench/contrib/debug/common/debug';
+import { IWorkbenchLayoutService } from 'vscode/vscode/vs/workbench/services/layout/browser/layoutService';
+
+const DEBUG_TOOLBAR_POSITION_KEY = 'debug.actionswidgetposition';
+const DEBUG_TOOLBAR_Y_KEY = 'debug.actionswidgety';
+let DebugToolBar = class DebugToolBar extends Themable {
+    constructor(notificationService, telemetryService, debugService, layoutService, storageService, configurationService, themeService, instantiationService, menuService, contextKeyService) {
+        super(themeService);
+        this.notificationService = notificationService;
+        this.telemetryService = telemetryService;
+        this.debugService = debugService;
+        this.layoutService = layoutService;
+        this.storageService = storageService;
+        this.configurationService = configurationService;
+        this.instantiationService = instantiationService;
+        this.yCoordinate = 0;
+        this.isVisible = false;
+        this.isBuilt = false;
+        this.stopActionViewItemDisposables = this._register(( new DisposableStore()));
+        this.$el = dom.$('div.debug-toolbar');
+        this.$el.style.top = `${layoutService.offset.top}px`;
+        this.dragArea = dom.append(this.$el, dom.$('div.drag-area' + ThemeIcon.asCSSSelector(debugGripper)));
+        const actionBarContainer = dom.append(this.$el, dom.$('div.action-bar-container'));
+        this.debugToolBarMenu = menuService.createMenu(MenuId.DebugToolBar, contextKeyService);
+        this._register(this.debugToolBarMenu);
+        this.activeActions = [];
+        this.actionBar = this._register(( new ActionBar(actionBarContainer, {
+            orientation: 0 ,
+            actionViewItemProvider: (action) => {
+                if (action.id === FOCUS_SESSION_ID) {
+                    return this.instantiationService.createInstance(FocusSessionActionViewItem, action, undefined);
+                }
+                else if (action.id === STOP_ID || action.id === DISCONNECT_ID) {
+                    this.stopActionViewItemDisposables.clear();
+                    const item = this.instantiationService.invokeFunction(accessor => createDisconnectMenuItemAction(action, this.stopActionViewItemDisposables, accessor));
+                    if (item) {
+                        return item;
+                    }
+                }
+                return createActionViewItem(this.instantiationService, action);
+            }
+        })));
+        this.updateScheduler = this._register(( new RunOnceScheduler(() => {
+            const state = this.debugService.state;
+            const toolBarLocation = this.configurationService.getValue('debug').toolBarLocation;
+            if (state === 0  ||
+                toolBarLocation === 'docked' ||
+                toolBarLocation === 'hidden' ||
+                this.debugService.getModel().getSessions().every(s => s.suppressDebugToolbar) ||
+                (state === 1  && this.debugService.initializingOptions?.suppressDebugToolbar)) {
+                return this.hide();
+            }
+            const actions = [];
+            createAndFillInActionBarActions(this.debugToolBarMenu, { shouldForwardArgs: true }, actions);
+            if (!arrays.equals(actions, this.activeActions, (first, second) => first.id === second.id && first.enabled === second.enabled)) {
+                this.actionBar.clear();
+                this.actionBar.push(actions, { icon: true, label: false });
+                this.activeActions = actions;
+            }
+            this.show();
+        }, 20)));
+        this.updateStyles();
+        this.registerListeners();
+        this.hide();
+    }
+    registerListeners() {
+        this._register(this.debugService.onDidChangeState(() => this.updateScheduler.schedule()));
+        this._register(this.configurationService.onDidChangeConfiguration(e => {
+            if (e.affectsConfiguration('debug.toolBarLocation')) {
+                this.updateScheduler.schedule();
+            }
+        }));
+        this._register(this.debugToolBarMenu.onDidChange(() => this.updateScheduler.schedule()));
+        this._register(this.actionBar.actionRunner.onDidRun((e) => {
+            if (e.error && !errors.isCancellationError(e.error)) {
+                this.notificationService.error(e.error);
+            }
+            this.telemetryService.publicLog2('workbenchActionExecuted', { id: e.action.id, from: 'debugActionsWidget' });
+        }));
+        this._register(dom.addDisposableListener(window, dom.EventType.RESIZE, () => this.setCoordinates()));
+        this._register(dom.addDisposableGenericMouseUpListener(this.dragArea, (event) => {
+            const mouseClickEvent = ( new StandardMouseEvent(event));
+            if (mouseClickEvent.detail === 2) {
+                const widgetWidth = this.$el.clientWidth;
+                this.setCoordinates(0.5 * window.innerWidth - 0.5 * widgetWidth, 0);
+                this.storePosition();
+            }
+        }));
+        this._register(dom.addDisposableGenericMouseDownListener(this.dragArea, (event) => {
+            this.dragArea.classList.add('dragged');
+            const mouseMoveListener = dom.addDisposableGenericMouseMoveListener(window, (e) => {
+                const mouseMoveEvent = ( new StandardMouseEvent(e));
+                mouseMoveEvent.preventDefault();
+                this.setCoordinates(mouseMoveEvent.posx - 14, mouseMoveEvent.posy - (this.layoutService.offset.top));
+            });
+            const mouseUpListener = dom.addDisposableGenericMouseUpListener(window, (e) => {
+                this.storePosition();
+                this.dragArea.classList.remove('dragged');
+                mouseMoveListener.dispose();
+                mouseUpListener.dispose();
+            });
+        }));
+        this._register(this.layoutService.onDidChangePartVisibility(() => this.setYCoordinate()));
+        this._register(browser.PixelRatio.onDidChange(() => this.setYCoordinate()));
+    }
+    storePosition() {
+        const left = dom.getComputedStyle(this.$el).left;
+        if (left) {
+            const position = parseFloat(left) / window.innerWidth;
+            this.storageService.store(DEBUG_TOOLBAR_POSITION_KEY, position, 0 , 1 );
+        }
+    }
+    updateStyles() {
+        super.updateStyles();
+        if (this.$el) {
+            this.$el.style.backgroundColor = this.getColor(debugToolBarBackground) || '';
+            const widgetShadowColor = this.getColor(widgetShadow);
+            this.$el.style.boxShadow = widgetShadowColor ? `0 0 8px 2px ${widgetShadowColor}` : '';
+            const contrastBorderColor = this.getColor(widgetBorder);
+            const borderColor = this.getColor(debugToolBarBorder);
+            if (contrastBorderColor) {
+                this.$el.style.border = `1px solid ${contrastBorderColor}`;
+            }
+            else {
+                this.$el.style.border = borderColor ? `solid ${borderColor}` : 'none';
+                this.$el.style.border = '1px 0';
+            }
+        }
+    }
+    setYCoordinate(y = this.yCoordinate) {
+        const titlebarOffset = this.layoutService.offset.top;
+        this.$el.style.top = `${titlebarOffset + y}px`;
+        this.yCoordinate = y;
+    }
+    setCoordinates(x, y) {
+        if (!this.isVisible) {
+            return;
+        }
+        const widgetWidth = this.$el.clientWidth;
+        if (x === undefined) {
+            const positionPercentage = this.storageService.get(DEBUG_TOOLBAR_POSITION_KEY, 0 );
+            x = positionPercentage !== undefined ? parseFloat(positionPercentage) * window.innerWidth : (0.5 * window.innerWidth - 0.5 * widgetWidth);
+        }
+        x = Math.max(0, Math.min(x, window.innerWidth - widgetWidth));
+        this.$el.style.left = `${x}px`;
+        if (y === undefined) {
+            y = this.storageService.getNumber(DEBUG_TOOLBAR_Y_KEY, 0 , 0);
+        }
+        const titleAreaHeight = 35;
+        if ((y < titleAreaHeight / 2) || (y > titleAreaHeight + titleAreaHeight / 2)) {
+            const moveToTop = y < titleAreaHeight;
+            this.setYCoordinate(moveToTop ? 0 : titleAreaHeight);
+            this.storageService.store(DEBUG_TOOLBAR_Y_KEY, moveToTop ? 0 : 2 * titleAreaHeight, 0 , 1 );
+        }
+    }
+    show() {
+        if (this.isVisible) {
+            this.setCoordinates();
+            return;
+        }
+        if (!this.isBuilt) {
+            this.isBuilt = true;
+            this.layoutService.container.appendChild(this.$el);
+        }
+        this.isVisible = true;
+        dom.show(this.$el);
+        this.setCoordinates();
+    }
+    hide() {
+        this.isVisible = false;
+        dom.hide(this.$el);
+    }
+    dispose() {
+        super.dispose();
+        this.$el?.remove();
+    }
+};
+DebugToolBar = ( __decorate([
+    ( __param(0, INotificationService)),
+    ( __param(1, ITelemetryService)),
+    ( __param(2, IDebugService)),
+    ( __param(3, IWorkbenchLayoutService)),
+    ( __param(4, IStorageService)),
+    ( __param(5, IConfigurationService)),
+    ( __param(6, IThemeService)),
+    ( __param(7, IInstantiationService)),
+    ( __param(8, IMenuService)),
+    ( __param(9, IContextKeyService))
+], DebugToolBar));
+function createDisconnectMenuItemAction(action, disposables, accessor) {
+    const menuService = accessor.get(IMenuService);
+    const contextKeyService = accessor.get(IContextKeyService);
+    const instantiationService = accessor.get(IInstantiationService);
+    const contextMenuService = accessor.get(IContextMenuService);
+    const menu = menuService.createMenu(MenuId.DebugToolBarStop, contextKeyService);
+    const secondary = [];
+    createAndFillInActionBarActions(menu, { shouldForwardArgs: true }, secondary);
+    if (!secondary.length) {
+        return undefined;
+    }
+    const dropdownAction = disposables.add(( new Action('notebook.moreRunActions', ( localize('notebook.moreRunActionsLabel', "More...")), 'codicon-chevron-down', true)));
+    const item = instantiationService.createInstance(DropdownWithPrimaryActionViewItem, action, dropdownAction, secondary, 'debug-stop-actions', contextMenuService, {});
+    return item;
+}
+const debugViewTitleItems = [];
+const registerDebugToolBarItem = (id, title, order, icon, when, precondition, alt) => {
+    MenuRegistry.appendMenuItem(MenuId.DebugToolBar, {
+        group: 'navigation',
+        when,
+        order,
+        command: {
+            id,
+            title,
+            icon,
+            precondition
+        },
+        alt
+    });
+    debugViewTitleItems.push(MenuRegistry.appendMenuItem(MenuId.ViewContainerTitle, {
+        group: 'navigation',
+        when: ( ContextKeyExpr.and(when, ( ContextKeyExpr.equals('viewContainer', VIEWLET_ID)), ( CONTEXT_DEBUG_STATE.notEqualsTo('inactive')), ( ContextKeyExpr.equals('config.debug.toolBarLocation', 'docked')))),
+        order,
+        command: {
+            id,
+            title,
+            icon,
+            precondition
+        }
+    }));
+};
+MenuRegistry.onDidChangeMenu(e => {
+    if (( e.has(MenuId.DebugToolBar))) {
+        dispose(debugViewTitleItems);
+        const items = MenuRegistry.getMenuItems(MenuId.DebugToolBar);
+        for (const i of items) {
+            debugViewTitleItems.push(MenuRegistry.appendMenuItem(MenuId.ViewContainerTitle, {
+                ...i,
+                when: ( ContextKeyExpr.and(i.when, ( ContextKeyExpr.equals('viewContainer', VIEWLET_ID)), ( CONTEXT_DEBUG_STATE.notEqualsTo('inactive')), ( ContextKeyExpr.equals('config.debug.toolBarLocation', 'docked'))))
+            }));
+        }
+    }
+});
+registerDebugToolBarItem(CONTINUE_ID, CONTINUE_LABEL, 10, debugContinue, ( CONTEXT_DEBUG_STATE.isEqualTo('stopped')));
+registerDebugToolBarItem(PAUSE_ID, PAUSE_LABEL, 10, debugPause, ( CONTEXT_DEBUG_STATE.notEqualsTo('stopped')), ( CONTEXT_DEBUG_STATE.isEqualTo('running')));
+registerDebugToolBarItem(STOP_ID, STOP_LABEL, 70, debugStop, ( CONTEXT_FOCUSED_SESSION_IS_ATTACH.toNegated()), undefined, { id: DISCONNECT_ID, title: DISCONNECT_LABEL, icon: debugDisconnect, precondition: ( ContextKeyExpr.and(( CONTEXT_FOCUSED_SESSION_IS_ATTACH.toNegated()), CONTEXT_TERMINATE_DEBUGGEE_SUPPORTED)), });
+registerDebugToolBarItem(DISCONNECT_ID, DISCONNECT_LABEL, 70, debugDisconnect, CONTEXT_FOCUSED_SESSION_IS_ATTACH, undefined, { id: STOP_ID, title: STOP_LABEL, icon: debugStop, precondition: ( ContextKeyExpr.and(CONTEXT_FOCUSED_SESSION_IS_ATTACH, CONTEXT_TERMINATE_DEBUGGEE_SUPPORTED)), });
+registerDebugToolBarItem(STEP_OVER_ID, STEP_OVER_LABEL, 20, debugStepOver, undefined, ( CONTEXT_DEBUG_STATE.isEqualTo('stopped')));
+registerDebugToolBarItem(STEP_INTO_ID, STEP_INTO_LABEL, 30, debugStepInto, undefined, ( CONTEXT_DEBUG_STATE.isEqualTo('stopped')));
+registerDebugToolBarItem(STEP_OUT_ID, STEP_OUT_LABEL, 40, debugStepOut, undefined, ( CONTEXT_DEBUG_STATE.isEqualTo('stopped')));
+registerDebugToolBarItem(RESTART_SESSION_ID, RESTART_LABEL, 60, debugRestart);
+registerDebugToolBarItem(STEP_BACK_ID, ( localize('stepBackDebug', "Step Back")), 50, debugStepBack, CONTEXT_STEP_BACK_SUPPORTED, ( CONTEXT_DEBUG_STATE.isEqualTo('stopped')));
+registerDebugToolBarItem(REVERSE_CONTINUE_ID, ( localize('reverseContinue', "Reverse")), 55, debugReverseContinue, CONTEXT_STEP_BACK_SUPPORTED, ( CONTEXT_DEBUG_STATE.isEqualTo('stopped')));
+registerDebugToolBarItem(FOCUS_SESSION_ID, FOCUS_SESSION_LABEL, 100, undefined, CONTEXT_MULTI_SESSION_DEBUG);
+MenuRegistry.appendMenuItem(MenuId.DebugToolBarStop, {
+    group: 'navigation',
+    when: ( ContextKeyExpr.and(( CONTEXT_FOCUSED_SESSION_IS_ATTACH.toNegated()), CONTEXT_TERMINATE_DEBUGGEE_SUPPORTED)),
+    order: 0,
+    command: {
+        id: DISCONNECT_ID,
+        title: DISCONNECT_LABEL,
+        icon: debugDisconnect
+    }
+});
+MenuRegistry.appendMenuItem(MenuId.DebugToolBarStop, {
+    group: 'navigation',
+    when: ( ContextKeyExpr.and(CONTEXT_FOCUSED_SESSION_IS_ATTACH, CONTEXT_TERMINATE_DEBUGGEE_SUPPORTED)),
+    order: 0,
+    command: {
+        id: STOP_ID,
+        title: STOP_LABEL,
+        icon: debugStop
+    }
+});
+MenuRegistry.appendMenuItem(MenuId.DebugToolBarStop, {
+    group: 'navigation',
+    when: ( ContextKeyExpr.or(( ContextKeyExpr.and(( CONTEXT_FOCUSED_SESSION_IS_ATTACH.toNegated()), CONTEXT_SUSPEND_DEBUGGEE_SUPPORTED, CONTEXT_TERMINATE_DEBUGGEE_SUPPORTED)), ( ContextKeyExpr.and(CONTEXT_FOCUSED_SESSION_IS_ATTACH, CONTEXT_SUSPEND_DEBUGGEE_SUPPORTED)))),
+    order: 0,
+    command: {
+        id: DISCONNECT_AND_SUSPEND_ID,
+        title: DISCONNECT_AND_SUSPEND_LABEL,
+        icon: debugDisconnect
+    }
+});
+
+export { DebugToolBar, createDisconnectMenuItemAction };

package/vscode/src/vs/workbench/contrib/debug/browser/debugViewlet.js

@@ -0,0 +1,168 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { DisposableStore, dispose } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import './media/debugViewlet.css.js';
+import * as nls from 'monaco-editor/esm/vs/nls.js';
+import { createActionViewItem } from 'monaco-editor/esm/vs/platform/actions/browser/menuEntryActionViewItem.js';
+import { registerAction2, Action2 } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { ContextKeyExpr, IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { IContextMenuService, IContextViewService } from 'monaco-editor/esm/vs/platform/contextview/browser/contextView.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { IProgressService } from 'monaco-editor/esm/vs/platform/progress/common/progress.js';
+import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
+import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
+import { IThemeService } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
+import { IWorkspaceContextService } from 'monaco-editor/esm/vs/platform/workspace/common/workspace.js';
+import { ViewsSubMenu, ViewPaneContainer } from 'vscode/vscode/vs/workbench/browser/parts/views/viewPaneContainer';
+import { IViewsService, IViewDescriptorService } from 'vscode/vscode/vs/workbench/common/views';
+import { StartDebugActionViewItem, FocusSessionActionViewItem } from './debugActionViewItems.js';
+import { DEBUG_START_COMMAND_ID, FOCUS_SESSION_ID, STOP_ID, DISCONNECT_ID } from './debugCommands.js';
+import { createDisconnectMenuItemAction } from './debugToolBar.js';
+import { WelcomeView } from './welcomeView.js';
+import { REPL_VIEW_ID, VIEWLET_ID, CONTEXT_DEBUG_UX_KEY, BREAKPOINTS_VIEW_ID, IDebugService } from 'vscode/vscode/vs/workbench/contrib/debug/common/debug';
+import { IExtensionService } from 'vscode/vscode/vs/workbench/services/extensions/common/extensions';
+import { IWorkbenchLayoutService } from 'vscode/vscode/vs/workbench/services/layout/browser/layoutService';
+
+let DebugViewPaneContainer = class DebugViewPaneContainer extends ViewPaneContainer {
+    constructor(layoutService, telemetryService, progressService, debugService, instantiationService, contextService, storageService, themeService, contextMenuService, extensionService, configurationService, contextViewService, contextKeyService, viewDescriptorService) {
+        super(VIEWLET_ID, { mergeViewWithContainerWhenSingleView: true }, instantiationService, configurationService, layoutService, contextMenuService, telemetryService, extensionService, themeService, storageService, contextService, viewDescriptorService);
+        this.progressService = progressService;
+        this.debugService = debugService;
+        this.contextViewService = contextViewService;
+        this.contextKeyService = contextKeyService;
+        this.paneListeners = ( new Map());
+        this.stopActionViewItemDisposables = this._register(( new DisposableStore()));
+        this._register(this.debugService.onDidChangeState(state => this.onDebugServiceStateChange(state)));
+        this._register(this.contextKeyService.onDidChangeContext(e => {
+            if (e.affectsSome(( new Set([CONTEXT_DEBUG_UX_KEY])))) {
+                this.updateTitleArea();
+            }
+        }));
+        this._register(this.contextService.onDidChangeWorkbenchState(() => this.updateTitleArea()));
+        this._register(this.configurationService.onDidChangeConfiguration(e => {
+            if (e.affectsConfiguration('debug.toolBarLocation')) {
+                this.updateTitleArea();
+            }
+        }));
+    }
+    create(parent) {
+        super.create(parent);
+        parent.classList.add('debug-viewlet');
+    }
+    focus() {
+        super.focus();
+        if (this.startDebugActionViewItem) {
+            this.startDebugActionViewItem.focus();
+        }
+        else {
+            this.focusView(WelcomeView.ID);
+        }
+    }
+    getActionViewItem(action) {
+        if (action.id === DEBUG_START_COMMAND_ID) {
+            this.startDebugActionViewItem = this.instantiationService.createInstance(StartDebugActionViewItem, null, action);
+            return this.startDebugActionViewItem;
+        }
+        if (action.id === FOCUS_SESSION_ID) {
+            return ( new FocusSessionActionViewItem(
+                action,
+                undefined,
+                this.debugService,
+                this.contextViewService,
+                this.configurationService
+            ));
+        }
+        if (action.id === STOP_ID || action.id === DISCONNECT_ID) {
+            this.stopActionViewItemDisposables.clear();
+            const item = this.instantiationService.invokeFunction(accessor => createDisconnectMenuItemAction(action, this.stopActionViewItemDisposables, accessor));
+            if (item) {
+                return item;
+            }
+        }
+        return createActionViewItem(this.instantiationService, action);
+    }
+    focusView(id) {
+        const view = this.getView(id);
+        if (view) {
+            view.focus();
+        }
+    }
+    onDebugServiceStateChange(state) {
+        if (this.progressResolve) {
+            this.progressResolve();
+            this.progressResolve = undefined;
+        }
+        if (state === 1 ) {
+            this.progressService.withProgress({ location: VIEWLET_ID, }, _progress => {
+                return ( new Promise(resolve => this.progressResolve = resolve));
+            });
+        }
+    }
+    addPanes(panes) {
+        super.addPanes(panes);
+        for (const { pane: pane } of panes) {
+            if (pane.id === BREAKPOINTS_VIEW_ID) {
+                this.breakpointView = pane;
+                this.updateBreakpointsMaxSize();
+            }
+            else {
+                this.paneListeners.set(pane.id, pane.onDidChange(() => this.updateBreakpointsMaxSize()));
+            }
+        }
+    }
+    removePanes(panes) {
+        super.removePanes(panes);
+        for (const pane of panes) {
+            dispose(this.paneListeners.get(pane.id));
+            this.paneListeners.delete(pane.id);
+        }
+    }
+    updateBreakpointsMaxSize() {
+        if (this.breakpointView) {
+            const allOtherCollapsed = this.panes.every(view => !view.isExpanded() || view === this.breakpointView);
+            this.breakpointView.maximumBodySize = allOtherCollapsed ? Number.POSITIVE_INFINITY : this.breakpointView.minimumBodySize;
+        }
+    }
+};
+DebugViewPaneContainer = ( __decorate([
+    ( __param(0, IWorkbenchLayoutService)),
+    ( __param(1, ITelemetryService)),
+    ( __param(2, IProgressService)),
+    ( __param(3, IDebugService)),
+    ( __param(4, IInstantiationService)),
+    ( __param(5, IWorkspaceContextService)),
+    ( __param(6, IStorageService)),
+    ( __param(7, IThemeService)),
+    ( __param(8, IContextMenuService)),
+    ( __param(9, IExtensionService)),
+    ( __param(10, IConfigurationService)),
+    ( __param(11, IContextViewService)),
+    ( __param(12, IContextKeyService)),
+    ( __param(13, IViewDescriptorService))
+], DebugViewPaneContainer));
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: 'debug.toggleReplIgnoreFocus',
+            title: ( nls.localize('debugPanel', "Debug Console")),
+            toggled: ( ContextKeyExpr.has(`view.${REPL_VIEW_ID}.visible`)),
+            menu: [{
+                    id: ViewsSubMenu,
+                    group: '3_toggleRepl',
+                    order: 30,
+                    when: ( ContextKeyExpr.and(( ContextKeyExpr.equals('viewContainer', VIEWLET_ID))))
+                }]
+        });
+    }
+    async run(accessor) {
+        const viewsService = accessor.get(IViewsService);
+        if (viewsService.isViewVisible(REPL_VIEW_ID)) {
+            viewsService.closeView(REPL_VIEW_ID);
+        }
+        else {
+            await viewsService.openView(REPL_VIEW_ID);
+        }
+    }
+});
+
+export { DebugViewPaneContainer };