@codingame/monaco-vscode-api 1.83.16 → 1.85.0-next.1

package/vscode/src/vs/workbench/browser/parts/editor/sideBySideEditor.js

@@ -256,6 +256,7 @@ let SideBySideEditor = class SideBySideEditor extends AbstractEditorWithViewStat
         this.disposeEditors();
     }
     focus() {
+        super.focus();
         this.getLastFocusedEditorPane()?.focus();
     }
     getLastFocusedEditorPane() {

package/vscode/src/vs/workbench/browser/parts/editor/textCodeEditor.js

@@ -63,6 +63,7 @@ class AbstractTextCodeEditor extends AbstractTextEditor {
         }
     }
     focus() {
+        super.focus();
         this.editorControl?.focus();
     }
     hasFocus() {

package/vscode/src/vs/workbench/browser/parts/editor/textDiffEditor.js

@@ -42,6 +42,7 @@ let TextDiffEditor = class TextDiffEditor extends AbstractTextEditor {
         this.preferencesService = preferencesService;
         this.diffEditorControl = undefined;
         this.inputLifecycleStopWatch = undefined;
+        this._previousViewModel = null;
     }
     getTitle() {
         if (this.input) {
@@ -63,6 +64,10 @@ let TextDiffEditor = class TextDiffEditor extends AbstractTextEditor {
         return this.diffEditorControl?.getModifiedEditor();
     }
     async setInput(input, options, context, token) {
+        if (this._previousViewModel) {
+            this._previousViewModel.dispose();
+            this._previousViewModel = null;
+        }
         this.inputLifecycleStopWatch = undefined;
         await super.setInput(input, options, context, token);
         try {
@@ -77,6 +82,7 @@ let TextDiffEditor = class TextDiffEditor extends AbstractTextEditor {
             const control = assertIsDefined(this.diffEditorControl);
             const resolvedDiffEditorModel = resolvedModel;
             const vm = resolvedDiffEditorModel.textDiffEditorModel ? control.createViewModel(resolvedDiffEditorModel.textDiffEditorModel) : null;
+            this._previousViewModel = vm;
             await vm?.waitForDiff();
             control.setModel(vm);
             let hasPreviousViewState = false;
@@ -94,6 +100,7 @@ let TextDiffEditor = class TextDiffEditor extends AbstractTextEditor {
                 ...this.getReadonlyConfiguration(resolvedDiffEditorModel.modifiedModel?.isReadonly()),
                 originalEditable: !resolvedDiffEditorModel.originalModel?.isReadonly()
             });
+            control.handleInitialized();
             this.inputLifecycleStopWatch = ( new StopWatch(false));
         }
         catch (error) {
@@ -184,9 +191,9 @@ let TextDiffEditor = class TextDiffEditor extends AbstractTextEditor {
         editorConfiguration.accessibilityVerbose = verbose;
         return editorConfiguration;
     }
-    getConfigurationOverrides() {
+    getConfigurationOverrides(configuration) {
         return {
-            ...super.getConfigurationOverrides(),
+            ...super.getConfigurationOverrides(configuration),
             ...this.getReadonlyConfiguration(this.input?.isReadonly()),
             originalEditable: this.input instanceof DiffEditorInput && !this.input.original.isReadonly(),
             lineDecorationsWidth: '2ch'
@@ -211,6 +218,10 @@ let TextDiffEditor = class TextDiffEditor extends AbstractTextEditor {
         return error.textFileOperationResult === 0 ;
     }
     clearInput() {
+        if (this._previousViewModel) {
+            this._previousViewModel.dispose();
+            this._previousViewModel = null;
+        }
         super.clearInput();
         const inputLifecycleElapsed = this.inputLifecycleStopWatch?.elapsed();
         this.inputLifecycleStopWatch = undefined;
@@ -234,6 +245,7 @@ let TextDiffEditor = class TextDiffEditor extends AbstractTextEditor {
         return this.diffEditorControl;
     }
     focus() {
+        super.focus();
         this.diffEditorControl?.focus();
     }
     hasFocus() {

package/vscode/src/vs/workbench/browser/parts/editor/textEditor.js

@@ -46,7 +46,7 @@ let AbstractTextEditor = class AbstractTextEditor extends AbstractEditorWithView
         }
     }
     shouldHandleConfigurationChangeEvent(e, resource) {
-        return e.affectsConfiguration(resource, 'editor');
+        return e.affectsConfiguration(resource, 'editor') || e.affectsConfiguration(resource, 'problems');
     }
     consumePendingConfigurationChangeEvent() {
         if (this.hasPendingConfigurationChange) {
@@ -56,7 +56,7 @@ let AbstractTextEditor = class AbstractTextEditor extends AbstractEditorWithView
     }
     computeConfiguration(configuration) {
         const editorConfiguration = isObject(configuration.editor) ? deepClone(configuration.editor) : Object.create(null);
-        Object.assign(editorConfiguration, this.getConfigurationOverrides());
+        Object.assign(editorConfiguration, this.getConfigurationOverrides(configuration));
         editorConfiguration.ariaLabel = this.computeAriaLabel();
         return editorConfiguration;
     }
@@ -85,13 +85,13 @@ let AbstractTextEditor = class AbstractTextEditor extends AbstractEditorWithView
             readOnlyMessage: typeof isReadonly !== 'boolean' ? isReadonly : undefined
         };
     }
-    getConfigurationOverrides() {
+    getConfigurationOverrides(configuration) {
         return {
             overviewRulerLanes: 3,
             lineNumbersMinChars: 3,
             fixedOverflowWidgets: true,
             ...this.getReadonlyConfiguration(this.input?.isReadonly()),
-            renderValidationDecorations: 'on'
+            renderValidationDecorations: configuration.problems?.visibility !== false ? 'on' : 'off'
         };
     }
     createEditor(parent) {

package/vscode/src/vs/workbench/browser/parts/globalCompositeBar.js

@@ -0,0 +1,277 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { append, $, clearNode, hide, show, addDisposableListener, EventType, EventHelper, getWindow } from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { StandardKeyboardEvent } from 'monaco-editor/esm/vs/base/browser/keyboardEvent.js';
+import { StandardMouseEvent } from 'monaco-editor/esm/vs/base/browser/mouseEvent.js';
+import { EventType as EventType$1 } from 'monaco-editor/esm/vs/base/browser/touch.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 { Codicon } from 'monaco-editor/esm/vs/base/common/codicons.js';
+import { Disposable, DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { ThemeIcon } from 'monaco-editor/esm/vs/base/common/themables.js';
+import { isString } from 'monaco-editor/esm/vs/base/common/types.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+import { createAndFillInActionBarActions } from 'monaco-editor/esm/vs/platform/actions/browser/menuEntryActionViewItem.js';
+import { 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 { 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 { IKeybindingService } from 'monaco-editor/esm/vs/platform/keybinding/common/keybinding.js';
+import { registerIcon } from 'monaco-editor/esm/vs/platform/theme/common/iconRegistry.js';
+import { IThemeService } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
+import { CompositeBarAction, CompoisteBarActionViewItem } from './compositeBarActions.js';
+import { GLOBAL_ACTIVITY_ID } from '../../common/activity.js';
+import { ACTIVITY_BAR_BADGE_BACKGROUND, ACTIVITY_BAR_BADGE_FOREGROUND } from '../../common/theme.js';
+import { NumberBadge, IActivityService } from '../../services/activity/common/activity.js';
+import { IWorkbenchEnvironmentService } from '../../services/environment/common/environmentService.js';
+import { IHoverService } from '../../services/hover/browser/hover.js';
+import { IUserDataProfileService } from '../../services/userDataProfile/common/userDataProfile.js';
+import { DEFAULT_ICON } from '../../services/userDataProfile/common/userDataProfileIcons.js';
+let GlobalCompositeBar = class GlobalCompositeBar extends Disposable {
+    static { this.ACCOUNTS_ICON = registerIcon('accounts-view-bar-icon', Codicon.account, ( localizeWithPath(
+        'vs/workbench/browser/parts/globalCompositeBar',
+        'accountsViewBarIcon',
+        "Accounts icon in the view bar."
+    ))); }
+    constructor(contextMenuActionsProvider, colors, activityHoverOptions, configurationService, instantiationService) {
+        super();
+        this.contextMenuActionsProvider = contextMenuActionsProvider;
+        this.colors = colors;
+        this.activityHoverOptions = activityHoverOptions;
+        this.instantiationService = instantiationService;
+        this.globalActivityAction = this._register(( new Action(GLOBAL_ACTIVITY_ID)));
+        this.element = document.createElement('div');
+        const anchorAlignment = configurationService.getValue('workbench.sideBar.location') === 'left' ? 1  : 0 ;
+        const anchorAxisAlignment = 1 ;
+        this.globalActivityActionBar = this._register(( new ActionBar(this.element, {
+            actionViewItemProvider: action => {
+                if (action.id === GLOBAL_ACTIVITY_ID) {
+                    return this.instantiationService.createInstance(GlobalActivityActionViewItem, this.contextMenuActionsProvider, { colors: this.colors, hoverOptions: this.activityHoverOptions }, anchorAlignment, anchorAxisAlignment);
+                }
+                throw new Error(`No view item for action '${action.id}'`);
+            },
+            orientation: 1 ,
+            ariaLabel: ( localizeWithPath('vs/workbench/browser/parts/globalCompositeBar', 'manage', "Manage")),
+            animated: false,
+            preventLoopNavigation: true
+        })));
+        this.globalActivityActionBar.push(this.globalActivityAction);
+    }
+    create(parent) {
+        parent.appendChild(this.element);
+    }
+    focus() {
+        this.globalActivityActionBar.focus(true);
+    }
+    size() {
+        return this.globalActivityActionBar.viewItems.length;
+    }
+    getContextMenuActions() {
+        return [];
+    }
+};
+GlobalCompositeBar = ( __decorate([
+    ( __param(3, IConfigurationService)),
+    ( __param(4, IInstantiationService))
+], GlobalCompositeBar));
+let AbstractGlobalActivityActionViewItem = class AbstractGlobalActivityActionViewItem extends CompoisteBarActionViewItem {
+    constructor(menuId, action, options, contextMenuActionsProvider, anchorAlignment, anchorAxisAlignment, themeService, hoverService, menuService, contextMenuService, contextKeyService, configurationService, keybindingService, activityService) {
+        super(action, { draggable: false, icon: true, hasPopup: true, ...options }, () => true, themeService, hoverService, configurationService, keybindingService);
+        this.menuId = menuId;
+        this.contextMenuActionsProvider = contextMenuActionsProvider;
+        this.anchorAlignment = anchorAlignment;
+        this.anchorAxisAlignment = anchorAxisAlignment;
+        this.menuService = menuService;
+        this.contextMenuService = contextMenuService;
+        this.contextKeyService = contextKeyService;
+        this.activityService = activityService;
+        this.updateItemActivity();
+        this._register(this.activityService.onDidChangeActivity(viewContainerOrAction => {
+            if (isString(viewContainerOrAction) && viewContainerOrAction === this.compositeBarActionItem.id) {
+                this.updateItemActivity();
+            }
+        }));
+    }
+    updateItemActivity() {
+        const activities = this.activityService.getActivity(this.compositeBarActionItem.id);
+        let activity = activities[0];
+        if (activity) {
+            const { badge, priority } = activity;
+            if (badge instanceof NumberBadge && activities.length > 1) {
+                const cumulativeNumberBadge = this.getCumulativeNumberBadge(activities, priority ?? 0);
+                activity = { badge: cumulativeNumberBadge };
+            }
+        }
+        this.action.activity = activity;
+    }
+    getCumulativeNumberBadge(activityCache, priority) {
+        const numberActivities = activityCache.filter(activity => activity.badge instanceof NumberBadge && (activity.priority ?? 0) === priority);
+        const number = numberActivities.reduce((result, activity) => { return result + activity.badge.number; }, 0);
+        const descriptorFn = () => {
+            return numberActivities.reduce((result, activity, index) => {
+                result = result + activity.badge.getDescription();
+                if (index < numberActivities.length - 1) {
+                    result = `${result}\n`;
+                }
+                return result;
+            }, '');
+        };
+        return ( new NumberBadge(number, descriptorFn));
+    }
+    render(container) {
+        super.render(container);
+        this._register(addDisposableListener(this.container, EventType.MOUSE_DOWN, async (e) => {
+            EventHelper.stop(e, true);
+            const isLeftClick = e?.button !== 2;
+            if (isLeftClick) {
+                this.run();
+            }
+        }));
+        this._register(addDisposableListener(this.container, EventType.CONTEXT_MENU, async (e) => {
+            const disposables = ( new DisposableStore());
+            const actions = await this.resolveContextMenuActions(disposables);
+            const event = ( new StandardMouseEvent(getWindow(this.container), e));
+            this.contextMenuService.showContextMenu({
+                getAnchor: () => event,
+                getActions: () => actions,
+                onHide: () => disposables.dispose()
+            });
+        }));
+        this._register(addDisposableListener(this.container, EventType.KEY_UP, (e) => {
+            const event = ( new StandardKeyboardEvent(e));
+            if (event.equals(3 ) || event.equals(10 )) {
+                EventHelper.stop(e, true);
+                this.run();
+            }
+        }));
+        this._register(addDisposableListener(this.container, EventType$1.Tap, (e) => {
+            EventHelper.stop(e, true);
+            this.run();
+        }));
+    }
+    async resolveContextMenuActions(disposables) {
+        return this.contextMenuActionsProvider();
+    }
+    async run() {
+        const disposables = ( new DisposableStore());
+        const menu = disposables.add(this.menuService.createMenu(this.menuId, this.contextKeyService));
+        const actions = await this.resolveMainMenuActions(menu, disposables);
+        this.contextMenuService.showContextMenu({
+            getAnchor: () => this.label,
+            anchorAlignment: this.anchorAlignment,
+            anchorAxisAlignment: this.anchorAxisAlignment,
+            getActions: () => actions,
+            onHide: () => disposables.dispose(),
+            menuActionOptions: { renderShortTitle: true },
+        });
+    }
+    async resolveMainMenuActions(menu, _disposable) {
+        const actions = [];
+        createAndFillInActionBarActions(menu, { renderShortTitle: true }, { primary: [], secondary: actions });
+        return actions;
+    }
+};
+AbstractGlobalActivityActionViewItem = ( __decorate([
+    ( __param(6, IThemeService)),
+    ( __param(7, IHoverService)),
+    ( __param(8, IMenuService)),
+    ( __param(9, IContextMenuService)),
+    ( __param(10, IContextKeyService)),
+    ( __param(11, IConfigurationService)),
+    ( __param(12, IKeybindingService)),
+    ( __param(13, IActivityService))
+], AbstractGlobalActivityActionViewItem));
+let GlobalActivityActionViewItem = class GlobalActivityActionViewItem extends AbstractGlobalActivityActionViewItem {
+    constructor(contextMenuActionsProvider, options, anchorAlignment, anchorAxisAlignment, userDataProfileService, themeService, hoverService, menuService, contextMenuService, contextKeyService, configurationService, environmentService, keybindingService, instantiationService, activityService) {
+        const action = instantiationService.createInstance(CompositeBarAction, {
+            id: GLOBAL_ACTIVITY_ID,
+            name: ( localizeWithPath('vs/workbench/browser/parts/globalCompositeBar', 'manage', "Manage")),
+            classNames: ThemeIcon.asClassNameArray(userDataProfileService.currentProfile.icon ? ThemeIcon.fromId(userDataProfileService.currentProfile.icon) : DEFAULT_ICON)
+        });
+        super(MenuId.GlobalActivity, action, options, contextMenuActionsProvider, anchorAlignment, anchorAxisAlignment, themeService, hoverService, menuService, contextMenuService, contextKeyService, configurationService, keybindingService, activityService);
+        this.userDataProfileService = userDataProfileService;
+        this._register(action);
+        this._register(this.userDataProfileService.onDidChangeCurrentProfile(e => {
+            action.compositeBarActionItem = {
+                ...action.compositeBarActionItem,
+                classNames: ThemeIcon.asClassNameArray(userDataProfileService.currentProfile.icon ? ThemeIcon.fromId(userDataProfileService.currentProfile.icon) : DEFAULT_ICON)
+            };
+        }));
+    }
+    render(container) {
+        super.render(container);
+        this.profileBadge = append(container, $('.profile-badge'));
+        this.profileBadgeContent = append(this.profileBadge, $('.profile-badge-content'));
+        this.updateProfileBadge();
+    }
+    updateProfileBadge() {
+        if (!this.profileBadge || !this.profileBadgeContent) {
+            return;
+        }
+        clearNode(this.profileBadgeContent);
+        hide(this.profileBadge);
+        if (this.userDataProfileService.currentProfile.isDefault) {
+            return;
+        }
+        if (this.action.activity) {
+            return;
+        }
+        if (!this.userDataProfileService.currentProfile.icon || this.userDataProfileService.currentProfile.icon === DEFAULT_ICON.id) {
+            this.profileBadgeContent.classList.toggle('profile-text-overlay', true);
+            this.profileBadgeContent.classList.toggle('profile-icon-overlay', false);
+            this.profileBadgeContent.textContent = this.userDataProfileService.currentProfile.name.substring(0, 2).toUpperCase();
+        }
+        show(this.profileBadge);
+    }
+    updateActivity() {
+        super.updateActivity();
+        this.updateProfileBadge();
+    }
+    computeTitle() {
+        return this.userDataProfileService.currentProfile.isDefault ? super.computeTitle() : ( localizeWithPath(
+            'vs/workbench/browser/parts/globalCompositeBar',
+            'manage profile',
+            "Manage {0} (Profile)",
+            this.userDataProfileService.currentProfile.name
+        ));
+    }
+};
+GlobalActivityActionViewItem = ( __decorate([
+    ( __param(4, IUserDataProfileService)),
+    ( __param(5, IThemeService)),
+    ( __param(6, IHoverService)),
+    ( __param(7, IMenuService)),
+    ( __param(8, IContextMenuService)),
+    ( __param(9, IContextKeyService)),
+    ( __param(10, IConfigurationService)),
+    ( __param(11, IWorkbenchEnvironmentService)),
+    ( __param(12, IKeybindingService)),
+    ( __param(13, IInstantiationService)),
+    ( __param(14, IActivityService))
+], GlobalActivityActionViewItem));
+let SimpleGlobalActivityActionViewItem = class SimpleGlobalActivityActionViewItem extends GlobalActivityActionViewItem {
+    constructor(hoverOptions, userDataProfileService, themeService, hoverService, menuService, contextMenuService, contextKeyService, configurationService, environmentService, keybindingService, instantiationService, activityService) {
+        super(() => [], {
+            colors: theme => ({
+                badgeBackground: theme.getColor(ACTIVITY_BAR_BADGE_BACKGROUND),
+                badgeForeground: theme.getColor(ACTIVITY_BAR_BADGE_FOREGROUND),
+            }),
+            hoverOptions,
+            compact: true,
+        }, undefined, undefined, userDataProfileService, themeService, hoverService, menuService, contextMenuService, contextKeyService, configurationService, environmentService, keybindingService, instantiationService, activityService);
+    }
+};
+SimpleGlobalActivityActionViewItem = ( __decorate([
+    ( __param(1, IUserDataProfileService)),
+    ( __param(2, IThemeService)),
+    ( __param(3, IHoverService)),
+    ( __param(4, IMenuService)),
+    ( __param(5, IContextMenuService)),
+    ( __param(6, IContextKeyService)),
+    ( __param(7, IConfigurationService)),
+    ( __param(8, IWorkbenchEnvironmentService)),
+    ( __param(9, IKeybindingService)),
+    ( __param(10, IInstantiationService)),
+    ( __param(11, IActivityService))
+], SimpleGlobalActivityActionViewItem));
+export { GlobalActivityActionViewItem, GlobalCompositeBar, SimpleGlobalActivityActionViewItem };

package/vscode/src/vs/workbench/browser/parts/notifications/notificationsCommands.js

@@ -15,6 +15,7 @@ import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiati
 import { ActionRunner } from 'monaco-editor/esm/vs/base/common/actions.js';
 import { hash } from 'monaco-editor/esm/vs/base/common/hash.js';
 import { firstOrDefault } from 'monaco-editor/esm/vs/base/common/arrays.js';
+import { IAccessibleNotificationService } from 'monaco-editor/esm/vs/platform/accessibility/common/accessibility.js';
 const SHOW_NOTIFICATIONS_CENTER = 'notifications.showList';
 const HIDE_NOTIFICATIONS_CENTER = 'notifications.hideList';
 const TOGGLE_NOTIFICATIONS_CENTER = 'notifications.toggleList';
@@ -92,9 +93,11 @@ function registerNotificationCommands(center, toasts, model) {
             primary: 2048  | 1
         },
         handler: (accessor, args) => {
+            const accessibleNotificationService = accessor.get(IAccessibleNotificationService);
             const notification = getNotificationFromContext(accessor.get(IListService), args);
             if (notification && !notification.hasProgress) {
                 notification.close();
+                accessibleNotificationService.notify("clear" );
             }
         }
     });
@@ -111,11 +114,11 @@ function registerNotificationCommands(center, toasts, model) {
     KeybindingsRegistry.registerCommandAndKeybindingRule({
         id: ACCEPT_PRIMARY_ACTION_NOTIFICATION,
         weight: 200 ,
-        when: ( ContextKeyExpr.and(NotificationsToastsVisibleContext)),
+        when: ( ContextKeyExpr.or(NotificationFocusedContext, NotificationsToastsVisibleContext)),
         primary: 2048  | 1024  | 31 ,
         handler: (accessor) => {
             const actionRunner = accessor.get(IInstantiationService).createInstance(NotificationActionRunner);
-            const notification = firstOrDefault(model.notifications);
+            const notification = getNotificationFromContext(accessor.get(IListService)) || firstOrDefault(model.notifications);
             if (!notification) {
                 return;
             }

package/vscode/src/vs/workbench/browser/parts/panel/media/panelpart.css.js

@@ -1,4 +1,4 @@
 import n from '../../../../../../../../external/rollup-plugin-styles/dist/runtime/inject-css.js';
-var css = ".monaco-workbench.nopanel .part.panel{display:none!important;visibility:hidden!important}.monaco-workbench .part.panel.bottom .composite.title{border-top-style:solid;border-top-width:1px}.monaco-workbench.noeditorarea .part.panel.bottom .composite.title{border-top-width:0}.monaco-workbench .part.panel.right{border-left-style:solid;border-left-width:1px}.monaco-workbench.noeditorarea .part.panel.right{border-left-width:0}.monaco-workbench .part.panel.left{border-right-style:solid;border-right-width:1px}.monaco-workbench.noeditorarea .part.panel.left{border-right-width:0}.monaco-workbench .part.panel>.content .monaco-editor,.monaco-workbench .part.panel>.content .monaco-editor .margin,.monaco-workbench .part.panel>.content .monaco-editor .monaco-editor-background{background-color:var(--vscode-panel-background)}.monaco-workbench .part.panel>.title>.panel-switcher-container>.monaco-action-bar .action-item:focus .action-label,.monaco-workbench .part.panel>.title>.panel-switcher-container>.monaco-action-bar .action-item:hover .action-label{color:var(--vscode-panelTitle-activeForeground)!important}.monaco-workbench .part.panel .monaco-inputbox{border-color:var(--vscode-panelInput-border,transparent)!important}.monaco-workbench .part.basepanel>.title>.panel-switcher-container>.monaco-action-bar .action-item:focus .active-item-indicator:before{border-top-color:var(--vscode-focusBorder)!important}.monaco-workbench .part.panel>.title>.panel-switcher-container>.monaco-action-bar .action-item:focus{outline:none}.monaco-workbench .part.basepanel>.title>.panel-switcher-container>.monaco-action-bar .action-item.checked.clicked:focus .active-item-indicator:before,.monaco-workbench .part.basepanel>.title>.panel-switcher-container>.monaco-action-bar .action-item.checked:not(:focus) .active-item-indicator:before{border-top-color:var(--vscode-panelTitle-activeBorder)!important}.monaco-workbench .part.basepanel>.title>.panel-switcher-container>.monaco-action-bar .action-item.checked .action-label,.monaco-workbench .part.basepanel>.title>.panel-switcher-container>.monaco-action-bar .action-item:hover .action-label{outline:var(--vscode-contrastActiveBorder,unset) solid 1px!important}.monaco-workbench .part.basepanel>.title>.panel-switcher-container>.monaco-action-bar .action-item:not(.checked):hover .action-label{outline:var(--vscode-contrastActiveBorder,unset) dashed 1px!important}";
+var css = ".monaco-workbench.nopanel .part.panel{display:none!important;visibility:hidden!important}.monaco-workbench .part.panel.bottom .composite.title{border-top-style:solid;border-top-width:1px}.monaco-workbench.nomaineditorarea .part.panel.bottom .composite.title{border-top-width:0}.monaco-workbench .part.panel.right{border-left-style:solid;border-left-width:1px}.monaco-workbench.nomaineditorarea .part.panel.right{border-left-width:0}.monaco-workbench .part.panel.left{border-right-style:solid;border-right-width:1px}.monaco-workbench.nomaineditorarea .part.panel.left{border-right-width:0}.monaco-workbench .part.panel>.content .monaco-editor,.monaco-workbench .part.panel>.content .monaco-editor .margin,.monaco-workbench .part.panel>.content .monaco-editor .monaco-editor-background{background-color:var(--vscode-panel-background)}.monaco-workbench .part.panel>.content .suggest-input-container .monaco-editor,.monaco-workbench .part.panel>.content .suggest-input-container .monaco-editor .margin,.monaco-workbench .part.panel>.content .suggest-input-container .monaco-editor .monaco-editor-background{background-color:inherit}.monaco-workbench .part.panel>.title>.composite-bar-container>.composite-bar>.monaco-action-bar .action-item:focus .action-label,.monaco-workbench .part.panel>.title>.composite-bar-container>.composite-bar>.monaco-action-bar .action-item:hover .action-label{color:var(--vscode-panelTitle-activeForeground)!important}.monaco-workbench .part.panel .monaco-inputbox{border-color:var(--vscode-panelInput-border,transparent)!important}.monaco-workbench .part.panel>.title>.composite-bar-container>.composite-bar>.monaco-action-bar .action-item:focus{outline:none}.monaco-workbench .part.basepanel.right .global-actions .codicon-panel-maximize:before,.monaco-workbench .part.basepanel.right .global-actions .codicon-panel-restore:before,.monaco-workbench .part.basepanel.right .title-actions .codicon-split-horizontal:before{display:inline-block;transform:rotate(-90deg)}.monaco-workbench .part.basepanel.left .global-actions .codicon-panel-maximize:before,.monaco-workbench .part.basepanel.left .global-actions .codicon-panel-restore:before,.monaco-workbench .part.basepanel.left .title-actions .codicon-split-horizontal:before{display:inline-block;transform:rotate(90deg)}";
 n(css,{});
 export { css, css as default };

package/vscode/src/vs/workbench/browser/parts/panel/panelActions.js

@@ -1,10 +1,8 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
 import './media/panelpart.css.js';
 import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
 import { Action2, MenuId, registerAction2, MenuRegistry } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
 import { Categories } from 'monaco-editor/esm/vs/platform/action/common/actionCommonCategories.js';
 import { IWorkbenchLayoutService, positionToString } from '../../../services/layout/browser/layoutService.js';
-import { ActivityAction, ToggleCompositePinnedAction } from '../compositeBarActions.js';
 import { PanelVisibleContext, PanelAlignmentContext, PanelPositionContext, PanelMaximizedContext, AuxiliaryBarVisibleContext } from '../../../common/contextkeys.js';
 import { ContextKeyExpr } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
 import { Codicon } from 'monaco-editor/esm/vs/base/common/codicons.js';
@@ -272,39 +270,6 @@ AlignPanelActionConfigs.forEach(alignPanelAction => {
         order: 5
     });
 });
-let PanelActivityAction = class PanelActivityAction extends ActivityAction {
-    constructor(activity, viewContainerLocation, paneCompositeService) {
-        super(activity);
-        this.viewContainerLocation = viewContainerLocation;
-        this.paneCompositeService = paneCompositeService;
-    }
-    async run() {
-        await this.paneCompositeService.openPaneComposite(this.activity.id, this.viewContainerLocation, true);
-        this.activate();
-    }
-    setActivity(activity) {
-        this.activity = activity;
-    }
-};
-PanelActivityAction = ( __decorate([
-    ( __param(2, IPaneCompositePartService))
-], PanelActivityAction));
-let PlaceHolderPanelActivityAction = class PlaceHolderPanelActivityAction extends PanelActivityAction {
-    constructor(id, viewContainerLocation, paneCompositeService) {
-        super({ id, name: id }, viewContainerLocation, paneCompositeService);
-    }
-};
-PlaceHolderPanelActivityAction = ( __decorate([
-    ( __param(2, IPaneCompositePartService))
-], PlaceHolderPanelActivityAction));
-class PlaceHolderToggleCompositePinnedAction extends ToggleCompositePinnedAction {
-    constructor(id, compositeBar) {
-        super({ id, name: id, classNames: undefined }, compositeBar);
-    }
-    setActivity(activity) {
-        this.label = activity.name;
-    }
-}
 class SwitchPanelViewAction extends Action2 {
     constructor(id, title) {
         super({
@@ -316,7 +281,7 @@ class SwitchPanelViewAction extends Action2 {
     }
     async run(accessor, offset) {
         const paneCompositeService = accessor.get(IPaneCompositePartService);
-        const pinnedPanels = paneCompositeService.getPinnedPaneCompositeIds(1 );
+        const pinnedPanels = paneCompositeService.getVisiblePaneCompositeIds(1 );
         const activePanel = paneCompositeService.getActivePaneComposite(1 );
         if (!activePanel) {
             return;
@@ -514,7 +479,7 @@ class MoveViewsBetweenPanelsAction extends Action2 {
         const destContainers = viewDescriptorService.getViewContainersByLocation(this.destination);
         if (srcContainers.length) {
             const activeViewContainer = viewsService.getVisibleViewContainer(this.source);
-            srcContainers.forEach(viewContainer => viewDescriptorService.moveViewContainerToLocation(viewContainer, this.destination));
+            srcContainers.forEach(viewContainer => viewDescriptorService.moveViewContainerToLocation(viewContainer, this.destination, undefined, this.desc.id));
             layoutService.setPartHidden(false, this.destination === 1  ? "workbench.parts.panel"  : "workbench.parts.auxiliarybar" );
             if (activeViewContainer && destContainers.length === 0) {
                 viewsService.openViewContainer(activeViewContainer.id, true);
@@ -598,4 +563,4 @@ class MoveSecondarySideBarToPanelAction extends MoveViewsBetweenPanelsAction {
 }
 registerAction2(MoveSidePanelToPanelAction);
 registerAction2(MoveSecondarySideBarToPanelAction);
-export { MovePanelToSecondarySideBarAction, MoveSecondarySideBarToPanelAction, PanelActivityAction, PlaceHolderPanelActivityAction, PlaceHolderToggleCompositePinnedAction, TogglePanelAction };
+export { MovePanelToSecondarySideBarAction, MoveSecondarySideBarToPanelAction, TogglePanelAction };

package/vscode/src/vs/workbench/browser/parts/statusbar/statusbarPart.d.ts

@@ -1,66 +1,68 @@
-import { Event } from '../../../../base/common/event.js';
 import { IDisposable } from '../../../../base/common/lifecycle.js';
-import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
-import { IContextKeyService } from '../../../../platform/contextkey/common/contextkey.js';
-import { IConfigurationService } from '../../../../platform/configuration/common/configuration.js';
-import { IThemeService } from '../../../../platform/theme/common/themeService.js';
-import { IStorageService } from '../../../../platform/storage/common/storage.js';
-import { IContextMenuService } from '../../../../platform/contextview/browser/contextView.js';
-import { IWorkspaceContextService } from '../../../../platform/workspace/common/workspace.js';
-import { IWorkbenchLayoutService } from '../../../services/layout/browser/layoutService.js';
-import { Part } from '../../part.js';
-import { IStatusbarService, IStatusbarEntry, StatusbarAlignment, IStatusbarEntryLocation, IStatusbarEntryPriority, IStatusbarEntryAccessor, IStatusbarStyleOverride } from '../../../services/statusbar/browser/statusbar.js';
-import { IHoverService } from '../../../services/hover/browser/hover.js';
+import { Event } from '../../../../base/common/event.js';
+import { IView } from '../../../../base/browser/ui/grid/grid.js';
+import { IStatusbarEntry, StatusbarAlignment, IStatusbarEntryPriority, IStatusbarEntryAccessor, IStatusbarEntryLocation, IStatusbarStyleOverride } from '../../../services/statusbar/browser/statusbar.js';
 
-declare class StatusbarPart extends Part implements IStatusbarService {
-    private readonly instantiationService;
-    private readonly contextService;
-    private readonly storageService;
-    private contextMenuService;
-    private readonly contextKeyService;
-    private readonly hoverService;
-    private readonly configurationService;
-    readonly _serviceBrand: undefined;
-    readonly minimumWidth: number;
-    readonly maximumWidth: number;
-    readonly minimumHeight: number;
-    readonly maximumHeight: number;
-    private styleElement;
-    private pendingEntries;
-    private readonly viewModel;
+interface IStatusbarEntryContainer extends IDisposable {
+    /**
+     * An event that is triggered when an entry's visibility is changed.
+     */
     readonly onDidChangeEntryVisibility: Event<{
         id: string;
         visible: boolean;
     }>;
-    private leftItemsContainer;
-    private rightItemsContainer;
-    private readonly hoverDelegate;
-    private readonly compactEntriesDisposable;
-    private readonly styleOverrides;
-    constructor(instantiationService: IInstantiationService, themeService: IThemeService, contextService: IWorkspaceContextService, storageService: IStorageService, layoutService: IWorkbenchLayoutService, contextMenuService: IContextMenuService, contextKeyService: IContextKeyService, hoverService: IHoverService, configurationService: IConfigurationService);
-    private registerListeners;
-    addEntry(entry: IStatusbarEntry, id: string, alignment: StatusbarAlignment, priorityOrLocation?: number | IStatusbarEntryLocation | IStatusbarEntryPriority): IStatusbarEntryAccessor;
-    private doAddPendingEntry;
-    private doAddEntry;
-    private doCreateStatusItem;
-    private doAddOrRemoveModelEntry;
+    /**
+     * Adds an entry to the statusbar with the given alignment and priority. Use the returned accessor
+     * to update or remove the statusbar entry.
+     *
+     * @param id identifier of the entry is needed to allow users to hide entries via settings
+     * @param alignment either LEFT or RIGHT side in the status bar
+     * @param priority items get arranged from highest priority to lowest priority from left to right
+     * in their respective alignment slot
+     */
+    addEntry(entry: IStatusbarEntry, id: string, alignment: StatusbarAlignment, priority?: number | IStatusbarEntryPriority): IStatusbarEntryAccessor;
+    addEntry(entry: IStatusbarEntry, id: string, alignment: StatusbarAlignment, priority?: number | IStatusbarEntryPriority | IStatusbarEntryLocation): IStatusbarEntryAccessor;
+    /**
+     * Adds an entry to the statusbar with the given alignment relative to another entry. Use the returned
+     * accessor to update or remove the statusbar entry.
+     *
+     * @param id identifier of the entry is needed to allow users to hide entries via settings
+     * @param alignment either LEFT or RIGHT side in the status bar
+     * @param location a reference to another entry to position relative to
+     */
+    addEntry(entry: IStatusbarEntry, id: string, alignment: StatusbarAlignment, location?: IStatusbarEntryLocation): IStatusbarEntryAccessor;
+    /**
+     * Return if an entry is visible or not.
+     */
     isEntryVisible(id: string): boolean;
+    /**
+     * Allows to update an entry's visibility with the provided ID.
+     */
     updateEntryVisibility(id: string, visible: boolean): void;
+    /**
+     * Focused the status bar. If one of the status bar entries was focused, focuses it directly.
+     */
+    focus(preserveEntryFocus?: boolean): void;
+    /**
+     * Focuses the next status bar entry. If none focused, focuses the first.
+     */
     focusNextEntry(): void;
+    /**
+     * Focuses the previous status bar entry. If none focused, focuses the last.
+     */
     focusPreviousEntry(): void;
+    /**
+     *	Returns true if a status bar entry is focused.
+     */
     isEntryFocused(): boolean;
-    focus(preserveEntryFocus?: boolean): void;
-    protected createContentArea(parent: HTMLElement): HTMLElement;
-    private createInitialStatusbarEntries;
-    private appendStatusbarEntries;
-    private appendStatusbarEntry;
-    private updateCompactEntries;
-    private showContextMenu;
-    private getContextMenuActions;
-    updateStyles(): void;
-    layout(width: number, height: number, top: number, left: number): void;
+    /**
+     * Temporarily override statusbar style.
+     */
     overrideStyle(style: IStatusbarStyleOverride): IDisposable;
-    toJSON(): object;
+}
+interface IAuxiliaryStatusbarPart extends IStatusbarEntryContainer, IView {
+    readonly container: HTMLElement;
+    readonly height: number;
 }
 
-export { StatusbarPart };
+export type { IAuxiliaryStatusbarPart, IStatusbarEntryContainer };