@codingame/monaco-vscode-debug-service-override 4.1.0 → 4.1.2

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

@@ -0,0 +1,387 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { $, append, addDisposableGenericMouseUpListener, getWindow, addDisposableGenericMouseDownListener, addDisposableListener, EventType, show, hide } from 'vscode/vscode/vs/base/browser/dom';
+import { StandardMouseEvent } from 'vscode/vscode/vs/base/browser/mouseEvent';
+import { ActionBar } from 'vscode/vscode/vs/base/browser/ui/actionbar/actionbar';
+import { Action } from 'vscode/vscode/vs/base/common/actions';
+import { equals } from 'vscode/vscode/vs/base/common/arrays';
+import { RunOnceScheduler } from 'vscode/vscode/vs/base/common/async';
+import { isCancellationError } from 'vscode/vscode/vs/base/common/errors';
+import { dispose, DisposableStore, MutableDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import './media/debugToolBar.css.js';
+import { localizeWithPath } from 'vscode/vscode/vs/nls';
+import { DropdownWithPrimaryActionViewItem } from 'vscode/vscode/vs/platform/actions/browser/dropdownWithPrimaryActionViewItem';
+import { createActionViewItem, createAndFillInActionBarActions } from 'vscode/vscode/vs/platform/actions/browser/menuEntryActionViewItem';
+import { MenuRegistry, MenuId, IMenuService } from 'vscode/vscode/vs/platform/actions/common/actions';
+import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration';
+import { ContextKeyExpr, IContextKeyService } from 'vscode/vscode/vs/platform/contextkey/common/contextkey';
+import { IContextMenuService } from 'vscode/vscode/vs/platform/contextview/browser/contextView';
+import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
+import { INotificationService } from 'vscode/vscode/vs/platform/notification/common/notification';
+import { IStorageService } from 'vscode/vscode/vs/platform/storage/common/storage';
+import { ITelemetryService } from 'vscode/vscode/vs/platform/telemetry/common/telemetry';
+import 'vscode/vscode/vs/platform/theme/common/colorUtils';
+import 'vscode/vscode/vs/platform/theme/common/colors/baseColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/chartsColors';
+import { widgetShadow, widgetBorder } from 'vscode/vscode/vs/platform/theme/common/colors/editorColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/inputColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/listColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/menuColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/minimapColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/miscColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/quickpickColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/searchColors';
+import { Themable, IThemeService } from 'vscode/vscode/vs/platform/theme/common/themeService';
+import { ThemeIcon } from 'vscode/vscode/vs/base/common/themables';
+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, FOCUS_SESSION_LABEL, FOCUS_SESSION_ID, DISCONNECT_AND_SUSPEND_ID, DISCONNECT_AND_SUSPEND_LABEL, RESTART_LABEL, RESTART_SESSION_ID } 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_IN_DEBUG_MODE, CONTEXT_FOCUSED_SESSION_IS_NO_DEBUG, CONTEXT_FOCUSED_SESSION_IS_ATTACH, CONTEXT_TERMINATE_DEBUGGEE_SUPPORTED, CONTEXT_STEP_BACK_SUPPORTED, CONTEXT_MULTI_SESSION_DEBUG, CONTEXT_SUSPEND_DEBUGGEE_SUPPORTED, IDebugService } from 'vscode/vscode/vs/workbench/contrib/debug/common/debug';
+import { IWorkbenchLayoutService } from 'vscode/vscode/vs/workbench/services/layout/browser/layoutService';
+import { Codicon } from 'vscode/vscode/vs/base/common/codicons';
+import { mainWindow } from 'vscode/vscode/vs/base/browser/window';
+import { clamp } from 'vscode/vscode/vs/base/common/numbers';
+import { PixelRatio } from 'vscode/vscode/vs/base/browser/pixelRatio';
+
+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.auxWindowCoordinates = ( new WeakMap());
+        this.trackPixelRatioListener = this._register(( new MutableDisposable()));
+        this.$el = $('div.debug-toolbar');
+        this.$el.style.top = `${layoutService.mainContainerOffset.top}px`;
+        this.dragArea = append(this.$el, $('div.drag-area' + ThemeIcon.asCSSSelector(debugGripper)));
+        const actionBarContainer = append(this.$el, $('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, options) => {
+                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, { hoverDelegate: options.hoverDelegate }));
+                    if (item) {
+                        return item;
+                    }
+                }
+                return createActionViewItem(this.instantiationService, action, options);
+            }
+        })));
+        this.updateScheduler = this._register(( new RunOnceScheduler(() => {
+            const state = this.debugService.state;
+            const toolBarLocation = this.configurationService.getValue('debug').toolBarLocation;
+            if (state === 0  ||
+                toolBarLocation !== 'floating' ||
+                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 (!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();
+            }
+            if (e.affectsConfiguration("workbench.editor.showTabs" ) || e.affectsConfiguration("window.commandCenter" )) {
+                this._yRange = undefined;
+                this.setYCoordinate();
+            }
+        }));
+        this._register(this.debugToolBarMenu.onDidChange(() => this.updateScheduler.schedule()));
+        this._register(this.actionBar.actionRunner.onDidRun((e) => {
+            if (e.error && !isCancellationError(e.error)) {
+                this.notificationService.warn(e.error);
+            }
+            this.telemetryService.publicLog2('workbenchActionExecuted', { id: e.action.id, from: 'debugActionsWidget' });
+        }));
+        this._register(addDisposableGenericMouseUpListener(this.dragArea, (event) => {
+            const mouseClickEvent = ( new StandardMouseEvent(getWindow(this.dragArea), event));
+            const activeWindow = getWindow(this.layoutService.activeContainer);
+            if (mouseClickEvent.detail === 2) {
+                const widgetWidth = this.$el.clientWidth;
+                this.setCoordinates(0.5 * activeWindow.innerWidth - 0.5 * widgetWidth, this.yDefault);
+                this.storePosition();
+            }
+        }));
+        this._register(addDisposableGenericMouseDownListener(this.dragArea, (event) => {
+            this.dragArea.classList.add('dragged');
+            getWindow(this.layoutService.activeContainer);
+        }));
+        this._register(this.layoutService.onDidChangePartVisibility(() => this.setYCoordinate()));
+        const resizeListener = this._register(( new MutableDisposable()));
+        this._register(this.layoutService.onDidChangeActiveContainer(async () => {
+            this._yRange = undefined;
+            await this.layoutService.whenContainerStylesLoaded(getWindow(this.layoutService.activeContainer));
+            if (this.isBuilt) {
+                this.doShowInActiveContainer();
+                this.setCoordinates();
+            }
+            resizeListener.value = this._register(addDisposableListener(getWindow(this.layoutService.activeContainer), EventType.RESIZE, () => this.setYCoordinate()));
+        }));
+    }
+    storePosition() {
+        const activeWindow = getWindow(this.layoutService.activeContainer);
+        const isMainWindow = this.layoutService.activeContainer === this.layoutService.mainContainer;
+        const left = this.$el.getBoundingClientRect().left / activeWindow.innerWidth;
+        if (isMainWindow) {
+            this.storageService.store(DEBUG_TOOLBAR_POSITION_KEY, left, 0 , 1 );
+            this.storageService.store(DEBUG_TOOLBAR_Y_KEY, this.yCoordinate, 0 , 1 );
+        }
+        else {
+            this.auxWindowCoordinates.set(activeWindow, { x: left, y: this.yCoordinate });
+        }
+    }
+    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';
+            }
+        }
+    }
+    setCoordinates(x, y) {
+        if (!this.isVisible) {
+            return;
+        }
+        const widgetWidth = this.$el.clientWidth;
+        const currentWindow = getWindow(this.layoutService.activeContainer);
+        const isMainWindow = currentWindow === mainWindow;
+        if (x === undefined) {
+            const positionPercentage = isMainWindow
+                ? Number(this.storageService.get(DEBUG_TOOLBAR_POSITION_KEY, 0 ))
+                : this.auxWindowCoordinates.get(currentWindow)?.x;
+            x = positionPercentage !== undefined && !isNaN(positionPercentage)
+                ? positionPercentage * currentWindow.innerWidth
+                : (0.5 * currentWindow.innerWidth - 0.5 * widgetWidth);
+        }
+        x = clamp(x, 0, currentWindow.innerWidth - widgetWidth);
+        this.$el.style.left = `${x}px`;
+        if (y === undefined) {
+            y = isMainWindow
+                ? this.storageService.getNumber(DEBUG_TOOLBAR_Y_KEY, 0 )
+                : this.auxWindowCoordinates.get(currentWindow)?.y;
+        }
+        this.setYCoordinate(y ?? this.yDefault);
+    }
+    setYCoordinate(y = this.yCoordinate) {
+        const [yMin, yMax] = this.yRange;
+        y = Math.max(yMin, Math.min(y, yMax));
+        this.$el.style.top = `${y}px`;
+        this.yCoordinate = y;
+    }
+    get yDefault() {
+        return this.layoutService.mainContainerOffset.top;
+    }
+    get yRange() {
+        if (!this._yRange) {
+            const isTitleBarVisible = this.layoutService.isVisible("workbench.parts.titlebar" , getWindow(this.layoutService.activeContainer));
+            const yMin = isTitleBarVisible ? 0 : this.layoutService.mainContainerOffset.top;
+            let yMax = 0;
+            if (isTitleBarVisible) {
+                if (this.configurationService.getValue("window.commandCenter" ) === true) {
+                    yMax += 35;
+                }
+                else {
+                    yMax += 28;
+                }
+            }
+            if (this.configurationService.getValue("workbench.editor.showTabs" ) !== "none" ) {
+                yMax += 35;
+            }
+            this._yRange = [yMin, yMax];
+        }
+        return this._yRange;
+    }
+    show() {
+        if (this.isVisible) {
+            this.setCoordinates();
+            return;
+        }
+        if (!this.isBuilt) {
+            this.isBuilt = true;
+            this.doShowInActiveContainer();
+        }
+        this.isVisible = true;
+        show(this.$el);
+        this.setCoordinates();
+    }
+    doShowInActiveContainer() {
+        this.layoutService.activeContainer.appendChild(this.$el);
+        this.trackPixelRatioListener.value = PixelRatio.getInstance(getWindow(this.$el)).onDidChange(() => this.setYCoordinate());
+    }
+    hide() {
+        this.isVisible = false;
+        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, options) {
+    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', ( localizeWithPath(
+        'vs/workbench/contrib/debug/browser/debugToolBar',
+        'notebook.moreRunActionsLabel',
+        "More..."
+    )), 'codicon-chevron-down', true)));
+    const item = instantiationService.createInstance(DropdownWithPrimaryActionViewItem, action, dropdownAction, secondary, 'debug-stop-actions', contextMenuService, options);
+    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'))))
+            }));
+        }
+    }
+});
+const CONTEXT_TOOLBAR_COMMAND_CENTER = ( ContextKeyExpr.equals('config.debug.toolBarLocation', 'commandCenter'));
+MenuRegistry.appendMenuItem(MenuId.CommandCenterCenter, {
+    submenu: MenuId.DebugToolBar,
+    title: 'Debug',
+    icon: Codicon.debug,
+    order: 1,
+    when: ( ContextKeyExpr.and(CONTEXT_IN_DEBUG_MODE, CONTEXT_TOOLBAR_COMMAND_CENTER))
+});
+registerDebugToolBarItem(CONTINUE_ID, CONTINUE_LABEL, 10, debugContinue, ( CONTEXT_DEBUG_STATE.isEqualTo('stopped')));
+registerDebugToolBarItem(PAUSE_ID, PAUSE_LABEL, 10, debugPause, ( CONTEXT_DEBUG_STATE.notEqualsTo('stopped')), ( ContextKeyExpr.and(( CONTEXT_DEBUG_STATE.isEqualTo('running')), ( CONTEXT_FOCUSED_SESSION_IS_NO_DEBUG.toNegated()))));
+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, ( localizeWithPath(
+    'vs/workbench/contrib/debug/browser/debugToolBar',
+    'stepBackDebug',
+    "Step Back"
+)), 50, debugStepBack, CONTEXT_STEP_BACK_SUPPORTED, ( CONTEXT_DEBUG_STATE.isEqualTo('stopped')));
+registerDebugToolBarItem(REVERSE_CONTINUE_ID, ( localizeWithPath(
+    'vs/workbench/contrib/debug/browser/debugToolBar',
+    'reverseContinue',
+    "Reverse"
+)), 55, debugReverseContinue, CONTEXT_STEP_BACK_SUPPORTED, ( CONTEXT_DEBUG_STATE.isEqualTo('stopped')));
+registerDebugToolBarItem(FOCUS_SESSION_ID, FOCUS_SESSION_LABEL, 100, Codicon.listTree, ( ContextKeyExpr.and(CONTEXT_MULTI_SESSION_DEBUG, ( CONTEXT_TOOLBAR_COMMAND_CENTER.negate()))));
+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,267 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { DisposableStore, dispose } from 'vscode/vscode/vs/base/common/lifecycle';
+import './media/debugViewlet.css.js';
+import { localizeWithPath } from 'vscode/vscode/vs/nls';
+import { createActionViewItem } from 'vscode/vscode/vs/platform/actions/browser/menuEntryActionViewItem';
+import { MenuRegistry, MenuId, registerAction2, Action2 } from 'vscode/vscode/vs/platform/actions/common/actions';
+import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration';
+import { ContextKeyExpr, IContextKeyService } from 'vscode/vscode/vs/platform/contextkey/common/contextkey';
+import { IContextMenuService, IContextViewService } from 'vscode/vscode/vs/platform/contextview/browser/contextView';
+import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
+import { IProgressService } from 'vscode/vscode/vs/platform/progress/common/progress';
+import { IQuickInputService } from 'vscode/vscode/vs/platform/quickinput/common/quickInput';
+import { IStorageService } from 'vscode/vscode/vs/platform/storage/common/storage';
+import { ITelemetryService } from 'vscode/vscode/vs/platform/telemetry/common/telemetry';
+import { IThemeService } from 'vscode/vscode/vs/platform/theme/common/themeService';
+import { IWorkspaceContextService } from 'vscode/vscode/vs/platform/workspace/common/workspace';
+import { ViewsSubMenu, ViewPaneContainer } from 'vscode/vscode/vs/workbench/browser/parts/views/viewPaneContainer';
+import { WorkbenchStateContext } from 'vscode/vscode/vs/workbench/common/contextkeys';
+import { IViewDescriptorService } from 'vscode/vscode/vs/workbench/common/views';
+import { IViewsService } from 'vscode/vscode/vs/workbench/services/views/common/viewsService';
+import { StartDebugActionViewItem, FocusSessionActionViewItem } from './debugActionViewItems.js';
+import { DEBUG_START_COMMAND_ID, DEBUG_START_LABEL, DEBUG_CONFIGURE_COMMAND_ID, DEBUG_CONFIGURE_LABEL, SELECT_AND_START_ID, FOCUS_SESSION_ID, STOP_ID, DISCONNECT_ID } from './debugCommands.js';
+import { debugConfigure } from 'vscode/vscode/vs/workbench/contrib/debug/browser/debugIcons';
+import { createDisconnectMenuItemAction } from './debugToolBar.js';
+import { WelcomeView } from './welcomeView.js';
+import { VIEWLET_ID, CONTEXT_DEBUG_UX, CONTEXT_DEBUG_STATE, getStateLabel, CONTEXT_DEBUGGERS_AVAILABLE, IDebugService, REPL_VIEW_ID, CONTEXT_DEBUG_UX_KEY, BREAKPOINTS_VIEW_ID } 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, 'inDebugMode'])))) {
+                this.updateTitleArea();
+            }
+        }));
+        this._register(this.contextService.onDidChangeWorkbenchState(() => this.updateTitleArea()));
+        this._register(this.configurationService.onDidChangeConfiguration(e => {
+            if (e.affectsConfiguration('debug.toolBarLocation') || e.affectsConfiguration('debug.hideLauncherWhileDebugging')) {
+                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, options) {
+        if (action.id === DEBUG_START_COMMAND_ID) {
+            this.startDebugActionViewItem = this.instantiationService.createInstance(StartDebugActionViewItem, null, action, options);
+            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, { hoverDelegate: options.hoverDelegate }));
+            if (item) {
+                return item;
+            }
+        }
+        return createActionViewItem(this.instantiationService, action, options);
+    }
+    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));
+MenuRegistry.appendMenuItem(MenuId.ViewContainerTitle, {
+    when: ( ContextKeyExpr.and(( ContextKeyExpr.equals('viewContainer', VIEWLET_ID)), ( CONTEXT_DEBUG_UX.notEqualsTo('simple')), ( WorkbenchStateContext.notEqualsTo('empty')), ( ContextKeyExpr.or(( CONTEXT_DEBUG_STATE.isEqualTo('inactive')), ( ContextKeyExpr.notEquals('config.debug.toolBarLocation', 'docked')))), ( ContextKeyExpr.or(
+        ContextKeyExpr.not('config.debug.hideLauncherWhileDebugging'),
+        ContextKeyExpr.not('inDebugMode')
+    )))),
+    order: 10,
+    group: 'navigation',
+    command: {
+        precondition: ( CONTEXT_DEBUG_STATE.notEqualsTo(getStateLabel(1 ))),
+        id: DEBUG_START_COMMAND_ID,
+        title: DEBUG_START_LABEL
+    }
+});
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: DEBUG_CONFIGURE_COMMAND_ID,
+            title: {
+                value: DEBUG_CONFIGURE_LABEL,
+                original: 'Open \'launch.json\'',
+                mnemonicTitle: ( localizeWithPath(
+                    'vs/workbench/contrib/debug/browser/debugViewlet',
+                    { key: 'miOpenConfigurations', comment: ['&& denotes a mnemonic'] },
+                    "Open &&Configurations"
+                ))
+            },
+            f1: true,
+            icon: debugConfigure,
+            precondition: ( CONTEXT_DEBUG_UX.notEqualsTo('simple')),
+            menu: [{
+                    id: MenuId.ViewContainerTitle,
+                    group: 'navigation',
+                    order: 20,
+                    when: ( ContextKeyExpr.and(( ContextKeyExpr.equals('viewContainer', VIEWLET_ID)), ( CONTEXT_DEBUG_UX.notEqualsTo('simple')), ( WorkbenchStateContext.notEqualsTo('empty')), ( ContextKeyExpr.or(( CONTEXT_DEBUG_STATE.isEqualTo('inactive')), ( ContextKeyExpr.notEquals('config.debug.toolBarLocation', 'docked'))))))
+                }, {
+                    id: MenuId.ViewContainerTitle,
+                    order: 20,
+                    when: ( ContextKeyExpr.and(( ContextKeyExpr.equals('viewContainer', VIEWLET_ID)), ( CONTEXT_DEBUG_STATE.notEqualsTo('inactive')), ( ContextKeyExpr.equals('config.debug.toolBarLocation', 'docked'))))
+                }, {
+                    id: MenuId.MenubarDebugMenu,
+                    group: '2_configuration',
+                    order: 1,
+                    when: CONTEXT_DEBUGGERS_AVAILABLE
+                }]
+        });
+    }
+    async run(accessor) {
+        const debugService = accessor.get(IDebugService);
+        const quickInputService = accessor.get(IQuickInputService);
+        const configurationManager = debugService.getConfigurationManager();
+        let launch;
+        if (configurationManager.selectedConfiguration.name) {
+            launch = configurationManager.selectedConfiguration.launch;
+        }
+        else {
+            const launches = configurationManager.getLaunches().filter(l => !l.hidden);
+            if (launches.length === 1) {
+                launch = launches[0];
+            }
+            else {
+                const picks = ( launches.map(l => ({ label: l.name, launch: l })));
+                const picked = await quickInputService.pick(picks, {
+                    activeItem: picks[0],
+                    placeHolder: ( localizeWithPath(
+                        'vs/workbench/contrib/debug/browser/debugViewlet',
+                        { key: 'selectWorkspaceFolder', comment: ['User picks a workspace folder or a workspace configuration file here. Workspace configuration files can contain settings and thus a launch.json configuration can be written into one.'] },
+                        "Select a workspace folder to create a launch.json file in or add it to the workspace config file"
+                    ))
+                });
+                if (picked) {
+                    launch = picked.launch;
+                }
+            }
+        }
+        if (launch) {
+            await launch.openConfigFile({ preserveFocus: false });
+        }
+    }
+});
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: 'debug.toggleReplIgnoreFocus',
+            title: ( localizeWithPath(
+                'vs/workbench/contrib/debug/browser/debugViewlet',
+                '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);
+        }
+    }
+});
+MenuRegistry.appendMenuItem(MenuId.ViewContainerTitle, {
+    when: ( ContextKeyExpr.and(( ContextKeyExpr.equals('viewContainer', VIEWLET_ID)), ( CONTEXT_DEBUG_STATE.notEqualsTo('inactive')), ( ContextKeyExpr.or(( ContextKeyExpr.equals('config.debug.toolBarLocation', 'docked')), ( ContextKeyExpr.has('config.debug.hideLauncherWhileDebugging')))))),
+    order: 10,
+    command: {
+        id: SELECT_AND_START_ID,
+        title: ( localizeWithPath(
+            'vs/workbench/contrib/debug/browser/debugViewlet',
+            'startAdditionalSession',
+            "Start Additional Session"
+        )),
+    }
+});
+
+export { DebugViewPaneContainer };