@codingame/monaco-vscode-api 1.82.1 → 1.82.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-api",
-  "version": "1.82.1",
+  "version": "1.82.3",
   "description": "VSCode public API plugged on the monaco editor",
   "keywords": [],
   "author": {

package/service-override/quickaccess.js

@@ -38,7 +38,7 @@ let DelegateQuickInputService = class DelegateQuickInputService {
     }
     get activeService() {
         const activeCodeEditor = StandaloneServices.get(ICodeEditorService).getFocusedCodeEditor();
-        if (shouldUseGlobalPicker(activeCodeEditor, activeCodeEditor instanceof StandaloneCodeEditor)) {
+        if (activeCodeEditor == null || shouldUseGlobalPicker(activeCodeEditor, activeCodeEditor instanceof StandaloneCodeEditor)) {
             return this.workbenchQuickInputService;
         }
         this.standaloneQuickInputService ?? (this.standaloneQuickInputService = this.instantiationService.createInstance(StandaloneQuickInputService));

package/service-override/tools/editor.d.ts

@@ -14,8 +14,8 @@ import { PreferredGroup } from '../../vscode/src/vs/workbench/services/editor/co
 import { IEditorResolverService } from '../../vscode/src/vs/workbench/services/editor/common/editorResolverService.js';
 import { ITextEditorService } from '../../vscode/src/vs/workbench/services/textfile/common/textEditorService.js';
 import { IHostService } from '../../vscode/src/vs/workbench/services/host/browser/host.js';
-import { EditorService } from '../../vscode/src/vs/workbench/services/editor/browser/editorService.js';
 import { IWorkspaceTrustRequestService } from '../../vscode/src/vs/platform/workspace/common/workspaceTrust.js';
+import { EditorService } from '../../vscode/src/vs/workbench/services/editor/browser/editorService.js';
 
 type OpenEditor = (modelRef: IReference<IResolvedTextEditorModel>, options: IEditorOptions | undefined, sideBySide?: boolean) => Promise<ICodeEditor | undefined>;
 declare class MonacoEditorService extends EditorService {

package/service-override/views.js

@@ -84,6 +84,10 @@ import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/st
 import { IThemeService } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
 export { ConfirmResult } from '../override/vs/platform/dialogs/common/dialogs.js';
 import { ILayoutService } from 'monaco-editor/esm/vs/platform/layout/browser/layoutService.js';
+import { BannerPart } from '../vscode/src/vs/workbench/browser/parts/banner/bannerPart.js';
+import { IBannerService } from '../vscode/src/vs/workbench/services/banner/browser/bannerService.js';
+import { ITitleService } from '../vscode/src/vs/workbench/services/title/common/titleService.js';
+import { TitlebarPart } from '../vscode/src/vs/workbench/browser/parts/titlebar/titlebarPart.js';
 import { MonacoEditorService, MonacoDelegateEditorGroupsService } from './tools/editor.js';
 import getServiceOverride$2 from './bulkEdit.js';
 import getServiceOverride$1 from './layout.js';
@@ -439,12 +443,16 @@ registerServiceInitializePostParticipant(async (accessor) => {
     const paneCompositePartService = accessor.get(IPaneCompositePartService);
     const viewDescriptorService = accessor.get(IViewDescriptorService);
     accessor.get(IStatusbarService);
+    accessor.get(IBannerService);
+    accessor.get(ITitleService);
     paneCompositePartService.getPaneComposites(1 );
     const layoutService = accessor.get(ILayoutService);
     const invisibleContainer = document.createElement('div');
     invisibleContainer.style.display = 'none';
     document.body.append(invisibleContainer);
     for (const { id, role, classes, options } of [
+        { id: "workbench.parts.titlebar" , role: 'none', classes: ['titlebar'] },
+        { id: "workbench.parts.banner" , role: 'banner', classes: ['banner'] },
         { id: "workbench.parts.activitybar" , role: 'none', classes: ['activitybar', 'left'] },
         { id: "workbench.parts.sidebar" , role: 'none', classes: ['sidebar', 'left'] },
         { id: "workbench.parts.editor" , role: 'main', classes: ['editor'], options: { restorePreviousState: false } },
@@ -485,6 +493,8 @@ function getServiceOverride(openEditorFallback, _webviewIframeAlternateDomains)
         [( ICodeEditorService.toString())]: new SyncDescriptor(CodeEditorService, [], true),
         [( ITextEditorService.toString())]: new SyncDescriptor(TextEditorService, [], false),
         [( IEditorGroupsService.toString())]: new SyncDescriptor(MonacoEditorPart, [], false),
+        [( ITitleService.toString())]: new SyncDescriptor(TitlebarPart, [], false),
+        [( IBannerService.toString())]: new SyncDescriptor(BannerPart, [], false),
         [( IStatusbarService.toString())]: new SyncDescriptor(StatusbarPart, [], false),
         [( IEditorDropService.toString())]: new SyncDescriptor(EditorDropService, [], true),
         [( IEditorService.toString())]: new SyncDescriptor(MonacoEditorService, [openEditorFallback, isEditorPartVisible], false),

package/service-override/workspaceTrust.d.ts

@@ -0,0 +1,5 @@
+import { IEditorOverrideServices } from '../vscode/src/vs/editor/standalone/browser/standaloneServices.js';
+
+declare function getServiceOverride(): IEditorOverrideServices;
+
+export { getServiceOverride as default };

package/service-override/workspaceTrust.js

@@ -0,0 +1,13 @@
+import '../missing-services.js';
+import { SyncDescriptor } from 'monaco-editor/esm/vs/platform/instantiation/common/descriptors.js';
+import { IWorkspaceTrustEnablementService, IWorkspaceTrustManagementService, IWorkspaceTrustRequestService } from 'monaco-editor/esm/vs/platform/workspace/common/workspaceTrust.js';
+import { WorkspaceTrustEnablementService, WorkspaceTrustManagementService, WorkspaceTrustRequestService } from '../vscode/src/vs/workbench/services/workspaces/common/workspaceTrust.js';
+import '../vscode/src/vs/workbench/contrib/workspace/browser/workspace.contribution.js';
+function getServiceOverride() {
+    return {
+        [( IWorkspaceTrustEnablementService.toString())]: new SyncDescriptor(WorkspaceTrustEnablementService),
+        [( IWorkspaceTrustManagementService.toString())]: new SyncDescriptor(WorkspaceTrustManagementService),
+        [( IWorkspaceTrustRequestService.toString())]: new SyncDescriptor(WorkspaceTrustRequestService)
+    };
+}
+export { getServiceOverride as default };

package/services.d.ts

@@ -66,6 +66,9 @@ export { IActivityService, IBadge } from './vscode/src/vs/workbench/services/act
 export { IHoverService } from './vscode/src/vs/workbench/services/hover/browser/hover.js';
 export { IExplorerService } from './vscode/src/vs/workbench/contrib/files/browser/files.js';
 export { IStatusbarService } from './vscode/src/vs/workbench/services/statusbar/browser/statusbar.js';
+export { ITitleService } from './vscode/src/vs/workbench/services/title/common/titleService.js';
+export { IBannerService } from './vscode/src/vs/workbench/services/banner/browser/bannerService.js';
+export { IWorkspaceTrustEnablementService, IWorkspaceTrustManagementService, IWorkspaceTrustRequestService, IWorkspaceTrustUriInfo } from './vscode/src/vs/platform/workspace/common/workspaceTrust.js';
 
 declare function initialize(overrides: IEditorOverrideServices): Promise<void>;
 declare function getService<T>(identifier: ServiceIdentifier<T>): Promise<T>;

package/services.js

@@ -67,6 +67,9 @@ export { IActivityService } from './vscode/src/vs/workbench/services/activity/co
 export { IHoverService } from './vscode/src/vs/workbench/services/hover/browser/hover.js';
 export { IExplorerService } from './vscode/src/vs/workbench/contrib/files/browser/files.js';
 export { IStatusbarService } from './vscode/src/vs/workbench/services/statusbar/browser/statusbar.js';
+export { ITitleService } from './vscode/src/vs/workbench/services/title/common/titleService.js';
+export { IBannerService } from './vscode/src/vs/workbench/services/banner/browser/bannerService.js';
+export { IWorkspaceTrustEnablementService, IWorkspaceTrustManagementService, IWorkspaceTrustRequestService } from 'monaco-editor/esm/vs/platform/workspace/common/workspaceTrust.js';
 export { IDialogService, IFileDialogService } from './vscode/src/vs/platform/dialogs/common/dialogs.js';
 async function initialize(overrides) {
     const instantiationService = StandaloneServices.initialize({

package/vscode/src/vs/base/common/htmlContent.d.ts

@@ -1,4 +1,4 @@
-import { UriComponents } from './uri.js';
+import { UriComponents, URI } from './uri.js';
 
 interface MarkdownStringTrustedOptions {
     readonly enabledCommands: readonly string[];
@@ -13,5 +13,26 @@ interface IMarkdownString {
         [href: string]: UriComponents;
     };
 }
+declare const enum MarkdownStringTextNewlineStyle {
+    Paragraph = 0,
+    Break = 1
+}
+declare class MarkdownString implements IMarkdownString {
+    value: string;
+    isTrusted?: boolean | MarkdownStringTrustedOptions;
+    supportThemeIcons?: boolean;
+    supportHtml?: boolean;
+    baseUri?: URI;
+    constructor(value?: string, isTrustedOrOptions?: boolean | {
+        isTrusted?: boolean | MarkdownStringTrustedOptions;
+        supportThemeIcons?: boolean;
+        supportHtml?: boolean;
+    });
+    appendText(value: string, newlineStyle?: MarkdownStringTextNewlineStyle): MarkdownString;
+    appendMarkdown(value: string): MarkdownString;
+    appendCodeblock(langId: string, code: string): MarkdownString;
+    appendLink(target: URI | string, label: string, title?: string): MarkdownString;
+    private _escape;
+}
 
-export type { IMarkdownString, MarkdownStringTrustedOptions };
+export { type IMarkdownString, MarkdownString, MarkdownStringTextNewlineStyle, type MarkdownStringTrustedOptions };

package/vscode/src/vs/platform/extensionManagement/common/extensionManagementUtil.js

@@ -18,4 +18,19 @@ function adoptToGalleryExtensionId(id) {
 function getGalleryExtensionId(publisher, name) {
     return adoptToGalleryExtensionId(getExtensionId(publisher ?? UNDEFINED_PUBLISHER, name));
 }
-export { adoptToGalleryExtensionId, areSameExtensions, getExtensionId, getGalleryExtensionId };
+function getExtensionDependencies(installedExtensions, extension) {
+    const dependencies = [];
+    const extensions = extension.manifest.extensionDependencies?.slice(0) ?? [];
+    while (extensions.length) {
+        const id = extensions.shift();
+        if (id && dependencies.every(e => !areSameExtensions(e.identifier, { id }))) {
+            const ext = installedExtensions.filter(e => areSameExtensions(e.identifier, { id }));
+            if (ext.length === 1) {
+                dependencies.push(ext[0]);
+                extensions.push(...(ext[0].manifest.extensionDependencies?.slice(0) ?? []));
+            }
+        }
+    }
+    return dependencies;
+}
+export { adoptToGalleryExtensionId, areSameExtensions, getExtensionDependencies, getExtensionId, getGalleryExtensionId };

package/vscode/src/vs/platform/opener/browser/link.d.ts

@@ -0,0 +1,8 @@
+interface ILinkDescriptor {
+    readonly label: string | HTMLElement;
+    readonly href: string;
+    readonly title?: string;
+    readonly tabIndex?: number;
+}
+
+export type { ILinkDescriptor };

package/vscode/src/vs/platform/workspace/common/workspaceTrust.d.ts

@@ -1,5 +1,6 @@
 import { ServiceIdentifier } from '../../instantiation/common/instantiation.js';
 import { Event } from '../../../base/common/event.js';
+import { IDisposable } from '../../../base/common/lifecycle.js';
 import { URI } from '../../../base/common/uri.js';
 
 interface WorkspaceTrustRequestButton {
@@ -10,6 +11,31 @@ interface WorkspaceTrustRequestOptions {
     readonly buttons?: WorkspaceTrustRequestButton[];
     readonly message?: string;
 }
+declare const IWorkspaceTrustEnablementService: ServiceIdentifier<IWorkspaceTrustEnablementService>;
+interface IWorkspaceTrustEnablementService {
+    readonly _serviceBrand: undefined;
+    isWorkspaceTrustEnabled(): boolean;
+}
+declare const IWorkspaceTrustManagementService: ServiceIdentifier<IWorkspaceTrustManagementService>;
+interface IWorkspaceTrustManagementService {
+    readonly _serviceBrand: undefined;
+    onDidChangeTrust: Event<boolean>;
+    onDidChangeTrustedFolders: Event<void>;
+    readonly workspaceResolved: Promise<void>;
+    readonly workspaceTrustInitialized: Promise<void>;
+    acceptsOutOfWorkspaceFiles: boolean;
+    isWorkspaceTrusted(): boolean;
+    isWorkspaceTrustForced(): boolean;
+    canSetParentFolderTrust(): boolean;
+    setParentFolderTrust(trusted: boolean): Promise<void>;
+    canSetWorkspaceTrust(): boolean;
+    setWorkspaceTrust(trusted: boolean): Promise<void>;
+    getUriTrustInfo(uri: URI): Promise<IWorkspaceTrustUriInfo>;
+    setUrisTrust(uri: URI[], trusted: boolean): Promise<void>;
+    getTrustedUris(): URI[];
+    setTrustedUris(uris: URI[]): Promise<void>;
+    addWorkspaceTrustTransitionParticipant(participant: IWorkspaceTrustTransitionParticipant): IDisposable;
+}
 declare const enum WorkspaceTrustUriResponse {
     Open = 1,
     OpenInNewWindow = 2,
@@ -28,5 +54,12 @@ interface IWorkspaceTrustRequestService {
     requestWorkspaceTrust(options?: WorkspaceTrustRequestOptions): Promise<boolean | undefined>;
     requestWorkspaceTrustOnStartup(): void;
 }
+interface IWorkspaceTrustTransitionParticipant {
+    participate(trusted: boolean): Promise<void>;
+}
+interface IWorkspaceTrustUriInfo {
+    uri: URI;
+    trusted: boolean;
+}
 
-export { IWorkspaceTrustRequestService, type WorkspaceTrustRequestButton, type WorkspaceTrustRequestOptions, WorkspaceTrustUriResponse };
+export { IWorkspaceTrustEnablementService, IWorkspaceTrustManagementService, IWorkspaceTrustRequestService, type IWorkspaceTrustTransitionParticipant, type IWorkspaceTrustUriInfo, type WorkspaceTrustRequestButton, type WorkspaceTrustRequestOptions, WorkspaceTrustUriResponse };

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({

package/vscode/src/vs/workbench/browser/parts/titlebar/commandCenterControl.js

@@ -0,0 +1,134 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { reset } from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { BaseActionViewItem } from 'monaco-editor/esm/vs/base/browser/ui/actionbar/actionViewItems.js';
+import { setupCustomHover } from 'monaco-editor/esm/vs/base/browser/ui/iconLabel/iconLabelHover.js';
+import { renderIcon } from 'monaco-editor/esm/vs/base/browser/ui/iconLabel/iconLabels.js';
+import { Codicon } from 'monaco-editor/esm/vs/base/common/codicons.js';
+import { Color } from 'monaco-editor/esm/vs/base/common/color.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { createActionViewItem } from 'monaco-editor/esm/vs/platform/actions/browser/menuEntryActionViewItem.js';
+import { MenuWorkbenchToolBar } from 'monaco-editor/esm/vs/platform/actions/browser/toolbar.js';
+import { MenuId, MenuItemAction } from 'monaco-editor/esm/vs/platform/actions/common/actions.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 { IQuickInputService } from 'monaco-editor/esm/vs/platform/quickinput/common/quickInput.js';
+import * as colorRegistry from 'monaco-editor/esm/vs/platform/theme/common/colorRegistry.js';
+import { TITLE_BAR_ACTIVE_FOREGROUND, MENUBAR_SELECTION_FOREGROUND, TITLE_BAR_INACTIVE_FOREGROUND, MENUBAR_SELECTION_BACKGROUND } from '../../../common/theme.js';
+let CommandCenterControl = class CommandCenterControl {
+    constructor(windowTitle, hoverDelegate, instantiationService, quickInputService, keybindingService) {
+        this._disposables = ( new DisposableStore());
+        this._onDidChangeVisibility = ( new Emitter());
+        this.onDidChangeVisibility = this._onDidChangeVisibility.event;
+        this.element = document.createElement('div');
+        this.element.classList.add('command-center');
+        const titleToolbar = instantiationService.createInstance(MenuWorkbenchToolBar, this.element, MenuId.CommandCenter, {
+            contextMenu: MenuId.TitleBarContext,
+            hiddenItemStrategy: 0 ,
+            toolbarOptions: {
+                primaryGroup: () => true,
+            },
+            telemetrySource: 'commandCenter',
+            actionViewItemProvider: (action) => {
+                if (action instanceof MenuItemAction && action.id === 'workbench.action.quickOpenWithModes') {
+                    class CommandCenterViewItem extends BaseActionViewItem {
+                        constructor(action, options) {
+                            super(undefined, action, options);
+                        }
+                        render(container) {
+                            super.render(container);
+                            container.classList.add('command-center');
+                            const searchIcon = renderIcon(Codicon.search);
+                            searchIcon.classList.add('search-icon');
+                            const label = this._getLabel();
+                            const labelElement = document.createElement('span');
+                            labelElement.classList.add('search-label');
+                            labelElement.innerText = label;
+                            reset(container, searchIcon, labelElement);
+                            const hover = this._store.add(setupCustomHover(hoverDelegate, container, this.getTooltip()));
+                            this._store.add(windowTitle.onDidChange(() => {
+                                hover.update(this.getTooltip());
+                                labelElement.innerText = this._getLabel();
+                            }));
+                        }
+                        _getLabel() {
+                            const { prefix, suffix } = windowTitle.getTitleDecorations();
+                            let label = windowTitle.isCustomTitleFormat() ? windowTitle.getWindowTitle() : windowTitle.workspaceName;
+                            if (!label) {
+                                label = ( localize('label.dfl', "Search"));
+                            }
+                            if (prefix) {
+                                label = ( localize('label1', "{0} {1}", prefix, label));
+                            }
+                            if (suffix) {
+                                label = ( localize('label2', "{0} {1}", label, suffix));
+                            }
+                            return label;
+                        }
+                        getTooltip() {
+                            const kb = keybindingService.lookupKeybinding(action.id)?.getLabel();
+                            const title = kb
+                                ? ( localize(
+                                'title',
+                                "Search {0} ({1}) \u2014 {2}",
+                                windowTitle.workspaceName,
+                                kb,
+                                windowTitle.value
+                            ))
+                                : ( localize(
+                                'title2',
+                                "Search {0} \u2014 {1}",
+                                windowTitle.workspaceName,
+                                windowTitle.value
+                            ));
+                            return title;
+                        }
+                    }
+                    return instantiationService.createInstance(CommandCenterViewItem, action, {});
+                }
+                else {
+                    return createActionViewItem(instantiationService, action, { hoverDelegate });
+                }
+            }
+        });
+        this._disposables.add(quickInputService.onShow(this._setVisibility.bind(this, false)));
+        this._disposables.add(quickInputService.onHide(this._setVisibility.bind(this, true)));
+        this._disposables.add(titleToolbar);
+    }
+    _setVisibility(show) {
+        this.element.classList.toggle('hide', !show);
+        this._onDidChangeVisibility.fire();
+    }
+    dispose() {
+        this._disposables.dispose();
+    }
+};
+CommandCenterControl = ( __decorate([
+    ( __param(2, IInstantiationService)),
+    ( __param(3, IQuickInputService)),
+    ( __param(4, IKeybindingService))
+], CommandCenterControl));
+colorRegistry.registerColor('commandCenter.foreground', { dark: TITLE_BAR_ACTIVE_FOREGROUND, hcDark: TITLE_BAR_ACTIVE_FOREGROUND, light: TITLE_BAR_ACTIVE_FOREGROUND, hcLight: TITLE_BAR_ACTIVE_FOREGROUND }, ( localize('commandCenter-foreground', "Foreground color of the command center")), false);
+colorRegistry.registerColor('commandCenter.activeForeground', { dark: MENUBAR_SELECTION_FOREGROUND, hcDark: MENUBAR_SELECTION_FOREGROUND, light: MENUBAR_SELECTION_FOREGROUND, hcLight: MENUBAR_SELECTION_FOREGROUND }, ( localize(
+    'commandCenter-activeForeground',
+    "Active foreground color of the command center"
+)), false);
+colorRegistry.registerColor('commandCenter.inactiveForeground', { dark: TITLE_BAR_INACTIVE_FOREGROUND, hcDark: TITLE_BAR_INACTIVE_FOREGROUND, light: TITLE_BAR_INACTIVE_FOREGROUND, hcLight: TITLE_BAR_INACTIVE_FOREGROUND }, ( localize(
+    'commandCenter-inactiveForeground',
+    "Foreground color of the command center when the window is inactive"
+)), false);
+colorRegistry.registerColor('commandCenter.background', {
+    dark: ( Color.white.transparent(0.05)), hcDark: null, light: ( Color.black.transparent(0.05)), hcLight: null
+}, ( localize('commandCenter-background', "Background color of the command center")), false);
+colorRegistry.registerColor('commandCenter.activeBackground', { dark: ( Color.white.transparent(0.08)), hcDark: MENUBAR_SELECTION_BACKGROUND, light: ( Color.black.transparent(0.08)), hcLight: MENUBAR_SELECTION_BACKGROUND }, ( localize(
+    'commandCenter-activeBackground',
+    "Active background color of the command center"
+)), false);
+colorRegistry.registerColor('commandCenter.border', { dark: ( colorRegistry.transparent(TITLE_BAR_ACTIVE_FOREGROUND, .20)), hcDark: ( colorRegistry.transparent(TITLE_BAR_ACTIVE_FOREGROUND, .60)), light: ( colorRegistry.transparent(TITLE_BAR_ACTIVE_FOREGROUND, .20)), hcLight: ( colorRegistry.transparent(TITLE_BAR_ACTIVE_FOREGROUND, .60)) }, ( localize('commandCenter-border', "Border color of the command center")), false);
+colorRegistry.registerColor('commandCenter.activeBorder', { dark: ( colorRegistry.transparent(TITLE_BAR_ACTIVE_FOREGROUND, .30)), hcDark: TITLE_BAR_ACTIVE_FOREGROUND, light: ( colorRegistry.transparent(TITLE_BAR_ACTIVE_FOREGROUND, .30)), hcLight: TITLE_BAR_ACTIVE_FOREGROUND }, ( localize('commandCenter-activeBorder', "Active border color of the command center")), false);
+colorRegistry.registerColor('commandCenter.inactiveBorder', { dark: ( colorRegistry.transparent(TITLE_BAR_INACTIVE_FOREGROUND, .25)), hcDark: ( colorRegistry.transparent(TITLE_BAR_INACTIVE_FOREGROUND, .25)), light: ( colorRegistry.transparent(TITLE_BAR_INACTIVE_FOREGROUND, .25)), hcLight: ( colorRegistry.transparent(TITLE_BAR_INACTIVE_FOREGROUND, .25)) }, ( localize(
+    'commandCenter-inactiveBorder',
+    "Border color of the command center when the window is inactive"
+)), false);
+export { CommandCenterControl };