@codingame/monaco-vscode-api 1.82.2 → 1.82.4-next.0

package/vscode/src/vs/platform/workspaces/common/workspaces.d.ts

@@ -1,8 +1,50 @@
+import { ServiceIdentifier } from '../../instantiation/common/instantiation.js';
+import { Event } from '../../../base/common/event.js';
 import { URI } from '../../../base/common/uri.js';
+import { IWorkspaceBackupInfo, IFolderBackupInfo } from '../../backup/common/backup.js';
+import { IWorkspaceIdentifier } from '../../workspace/common/workspace.js';
 
+declare const IWorkspacesService: ServiceIdentifier<IWorkspacesService>;
+interface IWorkspacesService {
+    readonly _serviceBrand: undefined;
+    enterWorkspace(workspaceUri: URI): Promise<IEnterWorkspaceResult | undefined>;
+    createUntitledWorkspace(folders?: IWorkspaceFolderCreationData[], remoteAuthority?: string): Promise<IWorkspaceIdentifier>;
+    deleteUntitledWorkspace(workspace: IWorkspaceIdentifier): Promise<void>;
+    getWorkspaceIdentifier(workspaceUri: URI): Promise<IWorkspaceIdentifier>;
+    readonly onDidChangeRecentlyOpened: Event<void>;
+    addRecentlyOpened(recents: IRecent[]): Promise<void>;
+    removeRecentlyOpened(workspaces: URI[]): Promise<void>;
+    clearRecentlyOpened(): Promise<void>;
+    getRecentlyOpened(): Promise<IRecentlyOpened>;
+    getDirtyWorkspaces(): Promise<Array<IWorkspaceBackupInfo | IFolderBackupInfo>>;
+}
+interface IRecentlyOpened {
+    workspaces: Array<IRecentWorkspace | IRecentFolder>;
+    files: IRecentFile[];
+}
+type IRecent = IRecentWorkspace | IRecentFolder | IRecentFile;
+interface IRecentWorkspace {
+    readonly workspace: IWorkspaceIdentifier;
+    label?: string;
+    readonly remoteAuthority?: string;
+}
+interface IRecentFolder {
+    readonly folderUri: URI;
+    label?: string;
+    readonly remoteAuthority?: string;
+}
+interface IRecentFile {
+    readonly fileUri: URI;
+    label?: string;
+    readonly remoteAuthority?: string;
+}
 interface IWorkspaceFolderCreationData {
     readonly uri: URI;
     readonly name?: string;
 }
+interface IEnterWorkspaceResult {
+    readonly workspace: IWorkspaceIdentifier;
+    readonly backupPath?: string;
+}
 
-export type { IWorkspaceFolderCreationData };
+export { type IEnterWorkspaceResult, type IRecent, type IRecentFile, type IRecentFolder, type IRecentWorkspace, type IRecentlyOpened, type IWorkspaceFolderCreationData, IWorkspacesService };

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

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

package/vscode/src/vs/workbench/browser/parts/banner/bannerPart.d.ts

@@ -0,0 +1,45 @@
+import { Event } from '../../../../base/common/event.js';
+import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
+import { IStorageService } from '../../../../platform/storage/common/storage.js';
+import { IThemeService } from '../../../../platform/theme/common/themeService.js';
+import { Part } from '../../part.js';
+import { IWorkbenchLayoutService } from '../../../services/layout/browser/layoutService.js';
+import { IBannerService, IBannerItem } from '../../../services/banner/browser/bannerService.js';
+import { IContextKeyService } from '../../../../platform/contextkey/common/contextkey.js';
+
+declare class BannerPart extends Part implements IBannerService {
+    private readonly contextKeyService;
+    private readonly instantiationService;
+    readonly _serviceBrand: undefined;
+    readonly height: number;
+    readonly minimumWidth: number;
+    readonly maximumWidth: number;
+    get minimumHeight(): number;
+    get maximumHeight(): number;
+    private _onDidChangeSize;
+    get onDidChange(): Event<{
+        width: number;
+        height: number;
+    } | undefined>;
+    private item;
+    private readonly markdownRenderer;
+    private visible;
+    private actionBar;
+    private messageActionsContainer;
+    private focusedActionIndex;
+    constructor(themeService: IThemeService, layoutService: IWorkbenchLayoutService, storageService: IStorageService, contextKeyService: IContextKeyService, instantiationService: IInstantiationService);
+    protected createContentArea(parent: HTMLElement): HTMLElement;
+    private close;
+    private focusActionLink;
+    private getAriaLabel;
+    private getBannerMessage;
+    private setVisibility;
+    focus(): void;
+    focusNextAction(): void;
+    focusPreviousAction(): void;
+    hide(id: string): void;
+    show(item: IBannerItem): void;
+    toJSON(): object;
+}
+
+export { BannerPart };

package/vscode/src/vs/workbench/browser/parts/banner/bannerPart.js

@@ -0,0 +1,228 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import './media/bannerpart.css.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { addDisposableListener, EventType, clearNode, $, append, asCSSUrl } from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { ActionBar } from 'monaco-editor/esm/vs/base/browser/ui/actionbar/actionbar.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
+import { IThemeService } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
+import { ThemeIcon } from 'monaco-editor/esm/vs/base/common/themables.js';
+import { Part } from '../../part.js';
+import { IWorkbenchLayoutService } from '../../../services/layout/browser/layoutService.js';
+import { Action } from 'monaco-editor/esm/vs/base/common/actions.js';
+import { Link } from 'monaco-editor/esm/vs/platform/opener/browser/link.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { IBannerService } from '../../../services/banner/browser/bannerService.js';
+import { MarkdownRenderer } from 'monaco-editor/esm/vs/editor/contrib/markdownRenderer/browser/markdownRenderer.js';
+import { Action2, registerAction2 } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
+import { Categories } from 'monaco-editor/esm/vs/platform/action/common/actionCommonCategories.js';
+import { KeybindingsRegistry } from 'monaco-editor/esm/vs/platform/keybinding/common/keybindingsRegistry.js';
+import { IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { widgetClose } from 'monaco-editor/esm/vs/platform/theme/common/iconRegistry.js';
+import { BannerFocused } from '../../../common/contextkeys.js';
+let BannerPart = class BannerPart extends Part {
+    get minimumHeight() {
+        return this.visible ? this.height : 0;
+    }
+    get maximumHeight() {
+        return this.visible ? this.height : 0;
+    }
+    get onDidChange() { return this._onDidChangeSize.event; }
+    constructor(themeService, layoutService, storageService, contextKeyService, instantiationService) {
+        super("workbench.parts.banner" , { hasTitle: false }, themeService, storageService, layoutService);
+        this.contextKeyService = contextKeyService;
+        this.instantiationService = instantiationService;
+        this.height = 26;
+        this.minimumWidth = 0;
+        this.maximumWidth = Number.POSITIVE_INFINITY;
+        this._onDidChangeSize = this._register(( new Emitter()));
+        this.visible = false;
+        this.focusedActionIndex = -1;
+        this.markdownRenderer = this.instantiationService.createInstance(MarkdownRenderer, {});
+    }
+    createContentArea(parent) {
+        this.element = parent;
+        this.element.tabIndex = 0;
+        this._register(addDisposableListener(this.element, EventType.FOCUS, () => {
+            if (this.focusedActionIndex !== -1) {
+                this.focusActionLink();
+            }
+        }));
+        const scopedContextKeyService = this.contextKeyService.createScoped(this.element);
+        BannerFocused.bindTo(scopedContextKeyService).set(true);
+        return this.element;
+    }
+    close(item) {
+        this.setVisibility(false);
+        clearNode(this.element);
+        if (typeof item.onClose === 'function') {
+            item.onClose();
+        }
+        this.item = undefined;
+    }
+    focusActionLink() {
+        const length = this.item?.actions?.length ?? 0;
+        if (this.focusedActionIndex < length) {
+            const actionLink = this.messageActionsContainer?.children[this.focusedActionIndex];
+            if (actionLink instanceof HTMLElement) {
+                this.actionBar?.setFocusable(false);
+                actionLink.focus();
+            }
+        }
+        else {
+            this.actionBar?.focus(0);
+        }
+    }
+    getAriaLabel(item) {
+        if (item.ariaLabel) {
+            return item.ariaLabel;
+        }
+        if (typeof item.message === 'string') {
+            return item.message;
+        }
+        return undefined;
+    }
+    getBannerMessage(message) {
+        if (typeof message === 'string') {
+            const element = $('span');
+            element.innerText = message;
+            return element;
+        }
+        return this.markdownRenderer.render(message).element;
+    }
+    setVisibility(visible) {
+        if (visible !== this.visible) {
+            this.visible = visible;
+            this.focusedActionIndex = -1;
+            this.layoutService.setPartHidden(!visible, "workbench.parts.banner" );
+            this._onDidChangeSize.fire(undefined);
+        }
+    }
+    focus() {
+        this.focusedActionIndex = -1;
+        this.element.focus();
+    }
+    focusNextAction() {
+        const length = this.item?.actions?.length ?? 0;
+        this.focusedActionIndex = this.focusedActionIndex < length ? this.focusedActionIndex + 1 : 0;
+        this.focusActionLink();
+    }
+    focusPreviousAction() {
+        const length = this.item?.actions?.length ?? 0;
+        this.focusedActionIndex = this.focusedActionIndex > 0 ? this.focusedActionIndex - 1 : length;
+        this.focusActionLink();
+    }
+    hide(id) {
+        if (this.item?.id !== id) {
+            return;
+        }
+        this.setVisibility(false);
+    }
+    show(item) {
+        if (item.id === this.item?.id) {
+            this.setVisibility(true);
+            return;
+        }
+        clearNode(this.element);
+        const ariaLabel = this.getAriaLabel(item);
+        if (ariaLabel) {
+            this.element.setAttribute('aria-label', ariaLabel);
+        }
+        const iconContainer = append(this.element, $('div.icon-container'));
+        iconContainer.setAttribute('aria-hidden', 'true');
+        if (ThemeIcon.isThemeIcon(item.icon)) {
+            iconContainer.appendChild($(`div${ThemeIcon.asCSSSelector(item.icon)}`));
+        }
+        else {
+            iconContainer.classList.add('custom-icon');
+            if (URI.isUri(item.icon)) {
+                iconContainer.style.backgroundImage = asCSSUrl(item.icon);
+            }
+        }
+        const messageContainer = append(this.element, $('div.message-container'));
+        messageContainer.setAttribute('aria-hidden', 'true');
+        messageContainer.appendChild(this.getBannerMessage(item.message));
+        this.messageActionsContainer = append(this.element, $('div.message-actions-container'));
+        if (item.actions) {
+            for (const action of item.actions) {
+                this._register(this.instantiationService.createInstance(Link, this.messageActionsContainer, { ...action, tabIndex: -1 }, {}));
+            }
+        }
+        const actionBarContainer = append(this.element, $('div.action-container'));
+        this.actionBar = this._register(( new ActionBar(actionBarContainer)));
+        const closeAction = this._register(( new Action(
+            'banner.close',
+            'Close Banner',
+            ThemeIcon.asClassName(widgetClose),
+            true,
+            () => this.close(item)
+        )));
+        this.actionBar.push(closeAction, { icon: true, label: false });
+        this.actionBar.setFocusable(false);
+        this.setVisibility(true);
+        this.item = item;
+    }
+    toJSON() {
+        return {
+            type: "workbench.parts.banner"
+        };
+    }
+};
+BannerPart = ( __decorate([
+    ( __param(0, IThemeService)),
+    ( __param(1, IWorkbenchLayoutService)),
+    ( __param(2, IStorageService)),
+    ( __param(3, IContextKeyService)),
+    ( __param(4, IInstantiationService))
+], BannerPart));
+KeybindingsRegistry.registerCommandAndKeybindingRule({
+    id: 'workbench.banner.focusBanner',
+    weight: 200 ,
+    primary: 9 ,
+    when: BannerFocused,
+    handler: (accessor) => {
+        const bannerService = accessor.get(IBannerService);
+        bannerService.focus();
+    }
+});
+KeybindingsRegistry.registerCommandAndKeybindingRule({
+    id: 'workbench.banner.focusNextAction',
+    weight: 200 ,
+    primary: 17 ,
+    secondary: [18 ],
+    when: BannerFocused,
+    handler: (accessor) => {
+        const bannerService = accessor.get(IBannerService);
+        bannerService.focusNextAction();
+    }
+});
+KeybindingsRegistry.registerCommandAndKeybindingRule({
+    id: 'workbench.banner.focusPreviousAction',
+    weight: 200 ,
+    primary: 15 ,
+    secondary: [16 ],
+    when: BannerFocused,
+    handler: (accessor) => {
+        const bannerService = accessor.get(IBannerService);
+        bannerService.focusPreviousAction();
+    }
+});
+class FocusBannerAction extends Action2 {
+    static { this.ID = 'workbench.action.focusBanner'; }
+    static { this.LABEL = ( localize('focusBanner', "Focus Banner")); }
+    constructor() {
+        super({
+            id: FocusBannerAction.ID,
+            title: { value: FocusBannerAction.LABEL, original: 'Focus Banner' },
+            category: Categories.View,
+            f1: true
+        });
+    }
+    async run(accessor) {
+        const layoutService = accessor.get(IWorkbenchLayoutService);
+        layoutService.focusPart("workbench.parts.banner" );
+    }
+}
+registerAction2(FocusBannerAction);
+export { BannerPart };

package/vscode/src/vs/workbench/browser/parts/banner/media/bannerpart.css.js

@@ -0,0 +1,4 @@
+import n from '../../../../../../../../external/rollup-plugin-styles/dist/runtime/inject-css.js';
+var css = ".monaco-workbench .part.banner{background-color:var(--vscode-banner-background);box-sizing:border-box;color:var(--vscode-banner-foreground);cursor:default;display:flex;font-size:12px;height:100%;overflow:visible;width:100%}.monaco-workbench .part.banner .icon-container{align-items:center;display:flex;flex-shrink:0;padding:0 6px 0 10px}.monaco-workbench .part.banner .icon-container .codicon{color:var(--vscode-banner-iconForeground)}.monaco-workbench .part.banner .icon-container.custom-icon{background-image:url(\"data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCAxMDI0IDEwMjQiPjxwYXRoIGQ9Ik0xMDI0IDEwMjRIMFYwaDEwMjR2MTAyNHoiIHN0eWxlPSJmaWxsOiNmNmY2ZjY7ZmlsbC1vcGFjaXR5OjAiIGZpbGw9Im5vbmUiLz48cGF0aCBkPSJNMTAyNCA4NS4zMzN2ODUzLjMzM0gwVjg1LjMzM2gxMDI0eiIgc3R5bGU9ImZpbGw6I2ZmZiIvPjxwYXRoIGQ9Ik0wIDg1LjMzM2gyOTguNjY3djg1My4zMzNIMFY4NS4zMzN6bTEwMjQgMHY4NTMuMzMzSDM4NFY4NS4zMzNoNjQwem0tNTU0LjY2NyAxNjBoMzQxLjMzM3YtNjRINDY5LjMzM3Y2NHptMzQxLjMzNCA1MzMuMzM0SDQ2OS4zMzN2NjRoMzQxLjMzM2wuMDAxLTY0em0xMjgtMTQ5LjMzNEg1OTcuMzMzdjY0aDM0MS4zMzNsLjAwMS02NHptMC0xNDkuMzMzSDU5Ny4zMzN2NjRoMzQxLjMzM2wuMDAxLTY0em0wLTE0OS4zMzNINTk3LjMzM3Y2NGgzNDEuMzMzbC4wMDEtNjR6IiBzdHlsZT0iZmlsbDojMTY3YWJmIi8+PC9zdmc+\");background-position:50%;background-repeat:no-repeat;background-size:16px;margin:0 6px 0 10px;padding:0;width:16px}.monaco-workbench .part.banner .message-container{line-height:26px;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.monaco-workbench .part.banner .message-container a{color:var(--vscode-banner-foreground)}.monaco-workbench .part.banner .message-container p{margin-block-end:0;margin-block-start:0}.monaco-workbench .part.banner .message-actions-container{flex-grow:1;flex-shrink:0;line-height:26px}.monaco-workbench .part.banner .message-actions-container a{color:var(--vscode-banner-foreground);cursor:pointer;margin-left:12px;padding:3px;text-decoration:underline}.monaco-workbench .part.banner .message-container a{cursor:pointer;text-decoration:underline}.monaco-workbench .part.banner .action-container{padding:0 10px 0 6px}.monaco-workbench .part.banner .action-container .codicon{color:var(--vscode-banner-foreground)}";
+n(css,{});
+export { css, css as default };

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

@@ -257,6 +257,27 @@ registerAction2(class extends SwitchPanelViewAction {
         return super.run(accessor, 1);
     }
 });
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: 'workbench.action.closePanel',
+            title: { value: ( localize('closePanel', "Close Panel")), original: 'Close Panel' },
+            category: Categories.View,
+            icon: closeIcon,
+            menu: [{
+                    id: MenuId.CommandPalette,
+                    when: PanelVisibleContext,
+                }, {
+                    id: MenuId.PanelTitle,
+                    group: 'navigation',
+                    order: 2
+                }]
+        });
+    }
+    run(accessor) {
+        accessor.get(IWorkbenchLayoutService).setPartHidden(true, "workbench.parts.panel" );
+    }
+});
 registerAction2(class extends Action2 {
     constructor() {
         super({