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

package/vscode/src/vs/workbench/browser/actions/windowActions.js

@@ -1,7 +1,9 @@
 import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
 import '../../../../../../override/vs/platform/dialogs/common/dialogs.js';
-import { MenuId, Action2 } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
-import { IsDevelopmentContext } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkeys.js';
+import { MenuId, Action2, registerAction2, MenuRegistry } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
+import { KeyChord } from 'monaco-editor/esm/vs/base/common/keyCodes.js';
+import { IsAuxiliaryWindowFocusedContext, IsFullscreenContext } from '../../common/contextkeys.js';
+import { IsDevelopmentContext, IsWebContext, IsIOSContext, IsMacNativeContext } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkeys.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 { IQuickInputService } from 'monaco-editor/esm/vs/platform/quickinput/common/quickInput.js';
@@ -14,7 +16,7 @@ import { IWorkspacesService, isRecentFolder, isRecentWorkspace } from '../../../
 import { getIconClasses } from 'monaco-editor/esm/vs/editor/common/services/getIconClasses.js';
 import { FileKind } from 'monaco-editor/esm/vs/platform/files/common/files.js';
 import { splitRecentLabel } from 'monaco-editor/esm/vs/base/common/labels.js';
-import { isMacintosh } from 'monaco-editor/esm/vs/base/common/platform.js';
+import { isMacintosh, isWeb, isWindows } from 'monaco-editor/esm/vs/base/common/platform.js';
 import { ContextKeyExpr } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
 import { getQuickNavigateHandler, inQuickPickContext } from '../quickaccess.js';
 import { IHostService } from '../../services/host/browser/host.js';
@@ -24,6 +26,8 @@ import { ThemeIcon } from 'monaco-editor/esm/vs/base/common/themables.js';
 import { CommandsRegistry } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
 import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
 import { isFolderBackupInfo, isWorkspaceBackupInfo } from '../../../platform/backup/common/backup.js';
+import { getActiveWindow, getActiveElement } from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { mainWindow } from 'monaco-editor/esm/vs/base/browser/window.js';
 import { IDialogService } from '../../../platform/dialogs/common/dialogs.js';
 const inRecentFilesPickerContextKey = 'inRecentFilesPicker';
 class BaseOpenRecentAction extends Action2 {
@@ -269,6 +273,63 @@ class OpenRecentAction extends BaseOpenRecentAction {
         return false;
     }
 }
+class QuickPickRecentAction extends BaseOpenRecentAction {
+    constructor() {
+        super({
+            id: 'workbench.action.quickOpenRecent',
+            title: { value: ( localizeWithPath(
+                'vs/workbench/browser/actions/windowActions',
+                'quickOpenRecent',
+                "Quick Open Recent..."
+            )), original: 'Quick Open Recent...' },
+            category: Categories.File,
+            f1: false
+        });
+    }
+    isQuickNavigate() {
+        return true;
+    }
+}
+class ToggleFullScreenAction extends Action2 {
+    constructor() {
+        super({
+            id: 'workbench.action.toggleFullScreen',
+            title: {
+                value: ( localizeWithPath(
+                    'vs/workbench/browser/actions/windowActions',
+                    'toggleFullScreen',
+                    "Toggle Full Screen"
+                )),
+                mnemonicTitle: ( localizeWithPath(
+                    'vs/workbench/browser/actions/windowActions',
+                    { key: 'miToggleFullScreen', comment: ['&& denotes a mnemonic'] },
+                    "&&Full Screen"
+                )),
+                original: 'Toggle Full Screen'
+            },
+            category: Categories.View,
+            f1: true,
+            keybinding: {
+                weight: 200 ,
+                primary: 69 ,
+                mac: {
+                    primary: 2048  | 256  | 36
+                }
+            },
+            precondition: ( IsIOSContext.toNegated()),
+            toggled: IsFullscreenContext,
+            menu: [{
+                    id: MenuId.MenubarAppearanceMenu,
+                    group: '1_toggle_view',
+                    order: 1
+                }]
+        });
+    }
+    run(accessor) {
+        const hostService = accessor.get(IHostService);
+        return hostService.toggleFullScreen(getActiveWindow());
+    }
+}
 class ReloadWindowAction extends Action2 {
     static { this.ID = 'workbench.action.reloadWindow'; }
     constructor() {
@@ -280,6 +341,7 @@ class ReloadWindowAction extends Action2 {
                 "Reload Window"
             )), original: 'Reload Window' },
             category: Categories.Developer,
+            precondition: ( IsAuxiliaryWindowFocusedContext.toNegated()),
             f1: true,
             keybinding: {
                 weight: 200  + 50,
@@ -288,11 +350,97 @@ class ReloadWindowAction extends Action2 {
             }
         });
     }
+    async run(accessor) {
+        const hostService = accessor.get(IHostService);
+        if (getActiveWindow() === mainWindow) {
+            return hostService.reload();
+        }
+    }
+}
+class ShowAboutDialogAction extends Action2 {
+    constructor() {
+        super({
+            id: 'workbench.action.showAboutDialog',
+            title: {
+                value: ( localizeWithPath('vs/workbench/browser/actions/windowActions', 'about', "About")),
+                mnemonicTitle: ( localizeWithPath(
+                    'vs/workbench/browser/actions/windowActions',
+                    { key: 'miAbout', comment: ['&& denotes a mnemonic'] },
+                    "&&About"
+                )),
+                original: 'About'
+            },
+            category: Categories.Help,
+            f1: true,
+            menu: {
+                id: MenuId.MenubarHelpMenu,
+                group: 'z_about',
+                order: 1,
+                when: ( IsMacNativeContext.toNegated())
+            }
+        });
+    }
+    run(accessor) {
+        const dialogService = accessor.get(IDialogService);
+        return dialogService.about();
+    }
+}
+class NewWindowAction extends Action2 {
+    constructor() {
+        super({
+            id: 'workbench.action.newWindow',
+            title: {
+                value: ( localizeWithPath('vs/workbench/browser/actions/windowActions', 'newWindow', "New Window")),
+                mnemonicTitle: ( localizeWithPath(
+                    'vs/workbench/browser/actions/windowActions',
+                    { key: 'miNewWindow', comment: ['&& denotes a mnemonic'] },
+                    "New &&Window"
+                )),
+                original: 'New Window'
+            },
+            f1: true,
+            keybinding: {
+                weight: 200 ,
+                primary: isWeb ? ((isWindows ? KeyChord(2048  | 41 , 1024  | 44 ) : 2048  | 512  | 1024  | 44) ) : 2048  | 1024  | 44 ,
+                secondary: isWeb ? [2048  | 1024  | 44 ] : undefined
+            },
+            menu: {
+                id: MenuId.MenubarFileMenu,
+                group: '1_new',
+                order: 3
+            }
+        });
+    }
     run(accessor) {
         const hostService = accessor.get(IHostService);
-        return hostService.reload();
+        return hostService.openWindow({ remoteAuthority: null });
     }
 }
+class BlurAction extends Action2 {
+    constructor() {
+        super({
+            id: 'workbench.action.blur',
+            title: { value: ( localizeWithPath(
+                'vs/workbench/browser/actions/windowActions',
+                'blur',
+                "Remove keyboard focus from focused element"
+            )), original: 'Remove keyboard focus from focused element' }
+        });
+    }
+    run() {
+        const activeElement = getActiveElement();
+        if (activeElement instanceof HTMLElement) {
+            activeElement.blur();
+        }
+    }
+}
+registerAction2(NewWindowAction);
+registerAction2(ToggleFullScreenAction);
+registerAction2(QuickPickRecentAction);
+registerAction2(OpenRecentAction);
+registerAction2(ReloadWindowAction);
+registerAction2(ShowAboutDialogAction);
+registerAction2(BlurAction);
 const recentFilesPickerContext = ( ContextKeyExpr.and(inQuickPickContext, ( ContextKeyExpr.has(inRecentFilesPickerContextKey))));
 const quickPickNavigateNextInRecentFilesPickerId = 'workbench.action.quickOpenNavigateNextInRecentFilesPicker';
 KeybindingsRegistry.registerCommandAndKeybindingRule({
@@ -317,4 +465,28 @@ CommandsRegistry.registerCommand('workbench.action.toggleConfirmBeforeClose', ac
     const setting = configurationService.inspect('window.confirmBeforeClose').userValue;
     return configurationService.updateValue('window.confirmBeforeClose', setting === 'never' ? 'keyboardOnly' : 'never');
 });
+MenuRegistry.appendMenuItem(MenuId.MenubarFileMenu, {
+    group: 'z_ConfirmClose',
+    command: {
+        id: 'workbench.action.toggleConfirmBeforeClose',
+        title: ( localizeWithPath(
+            'vs/workbench/browser/actions/windowActions',
+            'miConfirmClose',
+            "Confirm Before Close"
+        )),
+        toggled: ( ContextKeyExpr.notEquals('config.window.confirmBeforeClose', 'never'))
+    },
+    order: 1,
+    when: IsWebContext
+});
+MenuRegistry.appendMenuItem(MenuId.MenubarFileMenu, {
+    title: ( localizeWithPath(
+        'vs/workbench/browser/actions/windowActions',
+        { key: 'miOpenRecent', comment: ['&& denotes a mnemonic'] },
+        "Open &&Recent"
+    )),
+    submenu: MenuId.MenubarRecentMenu,
+    group: '2_open',
+    order: 4
+});
 export { OpenRecentAction, ReloadWindowAction, inRecentFilesPickerContextKey };

package/vscode/src/vs/workbench/browser/actions/workspaceActions.js

@@ -5,7 +5,7 @@ import { IEditorService } from '../../services/editor/common/editorService.js';
 import { ICommandService } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
 import { SET_ROOT_FOLDER_COMMAND_ID, ADD_ROOT_FOLDER_LABEL, ADD_ROOT_FOLDER_COMMAND_ID, PICK_WORKSPACE_FOLDER_COMMAND_ID } from './workspaceCommands.js';
 import '../../../../../../override/vs/platform/dialogs/common/dialogs.js';
-import { Action2 } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
+import { Action2, registerAction2, MenuRegistry, MenuId } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
 import { OpenFolderWorkspaceSupportContext, WorkbenchStateContext, EnterMultiRootWorkspaceSupportContext, EmptyWorkspaceSupportContext, WorkspaceFolderCountContext } from '../../common/contextkeys.js';
 import { IHostService } from '../../services/host/browser/host.js';
 import { KeyChord } from 'monaco-editor/esm/vs/base/common/keyCodes.js';
@@ -32,8 +32,8 @@ class OpenFileAction extends Action2 {
             )), original: 'Open File...' },
             category: Categories.File,
             f1: true,
-            precondition: ( IsMacNativeContext.toNegated()),
             keybinding: {
+                when: ( IsMacNativeContext.toNegated()),
                 weight: 200 ,
                 primary: 2048  | 45
             }
@@ -292,4 +292,145 @@ class DuplicateWorkspaceInNewWindowAction extends Action2 {
         return hostService.openWindow([{ workspaceUri: newWorkspace.configPath }], { forceNewWindow: true, remoteAuthority });
     }
 }
+registerAction2(AddRootFolderAction);
+registerAction2(RemoveRootFolderAction);
+registerAction2(OpenFileAction);
+registerAction2(OpenFolderAction);
+registerAction2(OpenFolderViaWorkspaceAction);
+registerAction2(OpenFileFolderAction);
+registerAction2(OpenWorkspaceAction);
+registerAction2(OpenWorkspaceConfigFileAction);
+registerAction2(CloseWorkspaceAction);
+registerAction2(SaveWorkspaceAsAction);
+registerAction2(DuplicateWorkspaceInNewWindowAction);
+MenuRegistry.appendMenuItem(MenuId.MenubarFileMenu, {
+    group: '2_open',
+    command: {
+        id: OpenFileAction.ID,
+        title: ( localizeWithPath(
+            'vs/workbench/browser/actions/workspaceActions',
+            { key: 'miOpenFile', comment: ['&& denotes a mnemonic'] },
+            "&&Open File..."
+        ))
+    },
+    order: 1,
+    when: ( IsMacNativeContext.toNegated())
+});
+MenuRegistry.appendMenuItem(MenuId.MenubarFileMenu, {
+    group: '2_open',
+    command: {
+        id: OpenFolderAction.ID,
+        title: ( localizeWithPath(
+            'vs/workbench/browser/actions/workspaceActions',
+            { key: 'miOpenFolder', comment: ['&& denotes a mnemonic'] },
+            "Open &&Folder..."
+        ))
+    },
+    order: 2,
+    when: OpenFolderWorkspaceSupportContext
+});
+MenuRegistry.appendMenuItem(MenuId.MenubarFileMenu, {
+    group: '2_open',
+    command: {
+        id: OpenFolderViaWorkspaceAction.ID,
+        title: ( localizeWithPath(
+            'vs/workbench/browser/actions/workspaceActions',
+            { key: 'miOpenFolder', comment: ['&& denotes a mnemonic'] },
+            "Open &&Folder..."
+        ))
+    },
+    order: 2,
+    when: ( ContextKeyExpr.and(( OpenFolderWorkspaceSupportContext.toNegated()), ( WorkbenchStateContext.isEqualTo('workspace'))))
+});
+MenuRegistry.appendMenuItem(MenuId.MenubarFileMenu, {
+    group: '2_open',
+    command: {
+        id: OpenFileFolderAction.ID,
+        title: ( localizeWithPath(
+            'vs/workbench/browser/actions/workspaceActions',
+            { key: 'miOpen', comment: ['&& denotes a mnemonic'] },
+            "&&Open..."
+        ))
+    },
+    order: 1,
+    when: ( ContextKeyExpr.and(IsMacNativeContext, OpenFolderWorkspaceSupportContext))
+});
+MenuRegistry.appendMenuItem(MenuId.MenubarFileMenu, {
+    group: '2_open',
+    command: {
+        id: OpenWorkspaceAction.ID,
+        title: ( localizeWithPath(
+            'vs/workbench/browser/actions/workspaceActions',
+            { key: 'miOpenWorkspace', comment: ['&& denotes a mnemonic'] },
+            "Open Wor&&kspace from File..."
+        ))
+    },
+    order: 3,
+    when: EnterMultiRootWorkspaceSupportContext
+});
+MenuRegistry.appendMenuItem(MenuId.MenubarFileMenu, {
+    group: '3_workspace',
+    command: {
+        id: ADD_ROOT_FOLDER_COMMAND_ID,
+        title: ( localizeWithPath(
+            'vs/workbench/browser/actions/workspaceActions',
+            { key: 'miAddFolderToWorkspace', comment: ['&& denotes a mnemonic'] },
+            "A&&dd Folder to Workspace..."
+        ))
+    },
+    when: ( ContextKeyExpr.or(EnterMultiRootWorkspaceSupportContext, ( WorkbenchStateContext.isEqualTo('workspace')))),
+    order: 1
+});
+MenuRegistry.appendMenuItem(MenuId.MenubarFileMenu, {
+    group: '3_workspace',
+    command: {
+        id: SaveWorkspaceAsAction.ID,
+        title: ( localizeWithPath(
+            'vs/workbench/browser/actions/workspaceActions',
+            'miSaveWorkspaceAs',
+            "Save Workspace As..."
+        ))
+    },
+    order: 2,
+    when: EnterMultiRootWorkspaceSupportContext
+});
+MenuRegistry.appendMenuItem(MenuId.MenubarFileMenu, {
+    group: '3_workspace',
+    command: {
+        id: DuplicateWorkspaceInNewWindowAction.ID,
+        title: ( localizeWithPath(
+            'vs/workbench/browser/actions/workspaceActions',
+            'duplicateWorkspace',
+            "Duplicate Workspace"
+        ))
+    },
+    order: 3,
+    when: EnterMultiRootWorkspaceSupportContext
+});
+MenuRegistry.appendMenuItem(MenuId.MenubarFileMenu, {
+    group: '6_close',
+    command: {
+        id: CloseWorkspaceAction.ID,
+        title: ( localizeWithPath(
+            'vs/workbench/browser/actions/workspaceActions',
+            { key: 'miCloseFolder', comment: ['&& denotes a mnemonic'] },
+            "Close &&Folder"
+        ))
+    },
+    order: 3,
+    when: ( ContextKeyExpr.and(( WorkbenchStateContext.isEqualTo('folder')), EmptyWorkspaceSupportContext))
+});
+MenuRegistry.appendMenuItem(MenuId.MenubarFileMenu, {
+    group: '6_close',
+    command: {
+        id: CloseWorkspaceAction.ID,
+        title: ( localizeWithPath(
+            'vs/workbench/browser/actions/workspaceActions',
+            { key: 'miCloseWorkspace', comment: ['&& denotes a mnemonic'] },
+            "Close &&Workspace"
+        ))
+    },
+    order: 3,
+    when: ( ContextKeyExpr.and(( WorkbenchStateContext.isEqualTo('workspace')), EmptyWorkspaceSupportContext))
+});
 export { AddRootFolderAction, OpenFileAction, OpenFileFolderAction, OpenFolderAction, OpenFolderViaWorkspaceAction, RemoveRootFolderAction };

package/vscode/src/vs/workbench/browser/actions/workspaceCommands.js

@@ -1,5 +1,22 @@
 import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+import { IWorkspaceContextService, hasWorkspaceFileExtension } from 'monaco-editor/esm/vs/platform/workspace/common/workspace.js';
+import { IWorkspaceEditingService } from '../../services/workspaces/common/workspaceEditing.js';
+import { dirname } from 'monaco-editor/esm/vs/base/common/resources.js';
+import { CancellationToken } from 'monaco-editor/esm/vs/base/common/cancellation.js';
+import { mnemonicButtonLabel } from 'monaco-editor/esm/vs/base/common/labels.js';
+import { CommandsRegistry, ICommandService } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
+import { FileKind } from 'monaco-editor/esm/vs/platform/files/common/files.js';
+import { ILabelService } from 'monaco-editor/esm/vs/platform/label/common/label.js';
+import { IQuickInputService } from 'monaco-editor/esm/vs/platform/quickinput/common/quickInput.js';
+import { getIconClasses } from 'monaco-editor/esm/vs/editor/common/services/getIconClasses.js';
+import { IModelService } from 'monaco-editor/esm/vs/editor/common/services/model.js';
+import { ILanguageService } from 'monaco-editor/esm/vs/editor/common/languages/language.js';
 import '../../../../../../override/vs/platform/dialogs/common/dialogs.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
+import { IWorkspacesService } from '../../../platform/workspaces/common/workspaces.js';
+import { IPathService } from '../../services/path/common/pathService.js';
+import { IFileDialogService } from '../../../platform/dialogs/common/dialogs.js';
 const ADD_ROOT_FOLDER_COMMAND_ID = 'addRootFolder';
 const ADD_ROOT_FOLDER_LABEL = { value: ( localizeWithPath(
     'vs/workbench/browser/actions/workspaceCommands',
@@ -8,4 +25,224 @@ const ADD_ROOT_FOLDER_LABEL = { value: ( localizeWithPath(
 )), original: 'Add Folder to Workspace...' };
 const SET_ROOT_FOLDER_COMMAND_ID = 'setRootFolder';
 const PICK_WORKSPACE_FOLDER_COMMAND_ID = '_workbench.pickWorkspaceFolder';
+CommandsRegistry.registerCommand({
+    id: 'workbench.action.files.openFileFolderInNewWindow',
+    handler: (accessor) => accessor.get(IFileDialogService).pickFileFolderAndOpen({ forceNewWindow: true })
+});
+CommandsRegistry.registerCommand({
+    id: '_files.pickFolderAndOpen',
+    handler: (accessor, options) => accessor.get(IFileDialogService).pickFolderAndOpen(options)
+});
+CommandsRegistry.registerCommand({
+    id: 'workbench.action.files.openFolderInNewWindow',
+    handler: (accessor) => accessor.get(IFileDialogService).pickFolderAndOpen({ forceNewWindow: true })
+});
+CommandsRegistry.registerCommand({
+    id: 'workbench.action.files.openFileInNewWindow',
+    handler: (accessor) => accessor.get(IFileDialogService).pickFileAndOpen({ forceNewWindow: true })
+});
+CommandsRegistry.registerCommand({
+    id: 'workbench.action.openWorkspaceInNewWindow',
+    handler: (accessor) => accessor.get(IFileDialogService).pickWorkspaceAndOpen({ forceNewWindow: true })
+});
+CommandsRegistry.registerCommand({
+    id: ADD_ROOT_FOLDER_COMMAND_ID,
+    handler: async (accessor) => {
+        const workspaceEditingService = accessor.get(IWorkspaceEditingService);
+        const folders = await selectWorkspaceFolders(accessor);
+        if (!folders || !folders.length) {
+            return;
+        }
+        await workspaceEditingService.addFolders(( folders.map(folder => ({ uri: folder }))));
+    }
+});
+CommandsRegistry.registerCommand({
+    id: SET_ROOT_FOLDER_COMMAND_ID,
+    handler: async (accessor) => {
+        const workspaceEditingService = accessor.get(IWorkspaceEditingService);
+        const contextService = accessor.get(IWorkspaceContextService);
+        const folders = await selectWorkspaceFolders(accessor);
+        if (!folders || !folders.length) {
+            return;
+        }
+        await workspaceEditingService.updateFolders(0, contextService.getWorkspace().folders.length, ( folders.map(folder => ({ uri: folder }))));
+    }
+});
+async function selectWorkspaceFolders(accessor) {
+    const dialogsService = accessor.get(IFileDialogService);
+    const pathService = accessor.get(IPathService);
+    const folders = await dialogsService.showOpenDialog({
+        openLabel: mnemonicButtonLabel(( localizeWithPath(
+            'vs/workbench/browser/actions/workspaceCommands',
+            { key: 'add', comment: ['&& denotes a mnemonic'] },
+            "&&Add"
+        ))),
+        title: ( localizeWithPath(
+            'vs/workbench/browser/actions/workspaceCommands',
+            'addFolderToWorkspaceTitle',
+            "Add Folder to Workspace"
+        )),
+        canSelectFolders: true,
+        canSelectMany: true,
+        defaultUri: await dialogsService.defaultFolderPath(),
+        availableFileSystems: [pathService.defaultUriScheme]
+    });
+    return folders;
+}
+CommandsRegistry.registerCommand(PICK_WORKSPACE_FOLDER_COMMAND_ID, async function (accessor, args) {
+    const quickInputService = accessor.get(IQuickInputService);
+    const labelService = accessor.get(ILabelService);
+    const contextService = accessor.get(IWorkspaceContextService);
+    const modelService = accessor.get(IModelService);
+    const languageService = accessor.get(ILanguageService);
+    const folders = contextService.getWorkspace().folders;
+    if (!folders.length) {
+        return;
+    }
+    const folderPicks = ( folders.map(folder => {
+        const label = folder.name;
+        const description = labelService.getUriLabel(dirname(folder.uri), { relative: true });
+        return {
+            label,
+            description: description !== label ? description : undefined,
+            folder,
+            iconClasses: getIconClasses(modelService, languageService, folder.uri, FileKind.ROOT_FOLDER)
+        };
+    }));
+    const options = (args ? args[0] : undefined) || Object.create(null);
+    if (!options.activeItem) {
+        options.activeItem = folderPicks[0];
+    }
+    if (!options.placeHolder) {
+        options.placeHolder = ( localizeWithPath(
+            'vs/workbench/browser/actions/workspaceCommands',
+            'workspaceFolderPickerPlaceholder',
+            "Select workspace folder"
+        ));
+    }
+    if (typeof options.matchOnDescription !== 'boolean') {
+        options.matchOnDescription = true;
+    }
+    const token = (args ? args[1] : undefined) || CancellationToken.None;
+    const pick = await quickInputService.pick(folderPicks, options, token);
+    if (pick) {
+        return folders[folderPicks.indexOf(pick)];
+    }
+    return;
+});
+CommandsRegistry.registerCommand({
+    id: 'vscode.openFolder',
+    handler: (accessor, uriComponents, arg) => {
+        const commandService = accessor.get(ICommandService);
+        if (typeof arg === 'boolean') {
+            arg = { forceNewWindow: arg };
+        }
+        if (!uriComponents) {
+            const options = {
+                forceNewWindow: arg?.forceNewWindow
+            };
+            if (arg?.forceLocalWindow) {
+                options.remoteAuthority = null;
+                options.availableFileSystems = ['file'];
+            }
+            return commandService.executeCommand('_files.pickFolderAndOpen', options);
+        }
+        const uri = ( URI.from(uriComponents, true));
+        const options = {
+            forceNewWindow: arg?.forceNewWindow,
+            forceReuseWindow: arg?.forceReuseWindow,
+            noRecentEntry: arg?.noRecentEntry,
+            remoteAuthority: arg?.forceLocalWindow ? null : undefined,
+            forceProfile: arg?.forceProfile,
+            forceTempProfile: arg?.forceTempProfile,
+        };
+        const uriToOpen = (hasWorkspaceFileExtension(uri) || uri.scheme === Schemas.untitled) ? { workspaceUri: uri } : { folderUri: uri };
+        return commandService.executeCommand('_files.windowOpen', [uriToOpen], options);
+    },
+    metadata: {
+        description: 'Open a folder or workspace in the current window or new window depending on the newWindow argument. Note that opening in the same window will shutdown the current extension host process and start a new one on the given folder/workspace unless the newWindow parameter is set to true.',
+        args: [
+            {
+                name: 'uri', description: '(optional) Uri of the folder or workspace file to open. If not provided, a native dialog will ask the user for the folder',
+                constraint: (value) => value === undefined || value === null || value instanceof URI
+            },
+            {
+                name: 'options',
+                description: '(optional) Options. Object with the following properties: ' +
+                    '`forceNewWindow`: Whether to open the folder/workspace in a new window or the same. Defaults to opening in the same window. ' +
+                    '`forceReuseWindow`: Whether to force opening the folder/workspace in the same window.  Defaults to false. ' +
+                    '`noRecentEntry`: Whether the opened URI will appear in the \'Open Recent\' list. Defaults to false. ' +
+                    'Note, for backward compatibility, options can also be of type boolean, representing the `forceNewWindow` setting.',
+                constraint: (value) => value === undefined || typeof value === 'object' || typeof value === 'boolean'
+            }
+        ]
+    }
+});
+CommandsRegistry.registerCommand({
+    id: 'vscode.newWindow',
+    handler: (accessor, options) => {
+        const commandService = accessor.get(ICommandService);
+        const commandOptions = {
+            forceReuseWindow: options && options.reuseWindow,
+            remoteAuthority: options && options.remoteAuthority
+        };
+        return commandService.executeCommand('_files.newWindow', commandOptions);
+    },
+    metadata: {
+        description: 'Opens an new window depending on the newWindow argument.',
+        args: [
+            {
+                name: 'options',
+                description: '(optional) Options. Object with the following properties: ' +
+                    '`reuseWindow`: Whether to open a new window or the same. Defaults to opening in a new window. ',
+                constraint: (value) => value === undefined || typeof value === 'object'
+            }
+        ]
+    }
+});
+CommandsRegistry.registerCommand('_workbench.removeFromRecentlyOpened', function (accessor, uri) {
+    const workspacesService = accessor.get(IWorkspacesService);
+    return workspacesService.removeRecentlyOpened([uri]);
+});
+CommandsRegistry.registerCommand({
+    id: 'vscode.removeFromRecentlyOpened',
+    handler: (accessor, path) => {
+        const workspacesService = accessor.get(IWorkspacesService);
+        if (typeof path === 'string') {
+            path = path.match(/^[^:/?#]+:\/\//) ? ( URI.parse(path)) : URI.file(path);
+        }
+        else {
+            path = URI.revive(path);
+        }
+        return workspacesService.removeRecentlyOpened([path]);
+    },
+    metadata: {
+        description: 'Removes an entry with the given path from the recently opened list.',
+        args: [
+            { name: 'path', description: 'URI or URI string to remove from recently opened.', constraint: (value) => typeof value === 'string' || value instanceof URI }
+        ]
+    }
+});
+CommandsRegistry.registerCommand('_workbench.addToRecentlyOpened', async function (accessor, recentEntry) {
+    const workspacesService = accessor.get(IWorkspacesService);
+    const uri = recentEntry.uri;
+    const label = recentEntry.label;
+    const remoteAuthority = recentEntry.remoteAuthority;
+    let recent = undefined;
+    if (recentEntry.type === 'workspace') {
+        const workspace = await workspacesService.getWorkspaceIdentifier(uri);
+        recent = { workspace, label, remoteAuthority };
+    }
+    else if (recentEntry.type === 'folder') {
+        recent = { folderUri: uri, label, remoteAuthority };
+    }
+    else {
+        recent = { fileUri: uri, label, remoteAuthority };
+    }
+    return workspacesService.addRecentlyOpened([recent]);
+});
+CommandsRegistry.registerCommand('_workbench.getRecentlyOpened', async function (accessor) {
+    const workspacesService = accessor.get(IWorkspacesService);
+    return workspacesService.getRecentlyOpened();
+});
 export { ADD_ROOT_FOLDER_COMMAND_ID, ADD_ROOT_FOLDER_LABEL, PICK_WORKSPACE_FOLDER_COMMAND_ID, SET_ROOT_FOLDER_COMMAND_ID };

package/vscode/src/vs/workbench/browser/composite.d.ts

@@ -81,10 +81,6 @@ declare abstract class Composite extends Component implements IComposite {
      * draggable corner areas with inner sashes.
      */
     abstract setBoundarySashes(sashes: IBoundarySashes): void;
-    /**
-     * Update the styles of the contents of this composite.
-     */
-    updateStyles(): void;
     /**
      *
      * @returns the action runner for this composite

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

@@ -1,7 +1,7 @@
 import { ActionRunner } from 'monaco-editor/esm/vs/base/common/actions.js';
 import { Component } from '../common/component.js';
 import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
-import { trackFocus } from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { trackFocus, focusWindow } from 'monaco-editor/esm/vs/base/browser/dom.js';
 import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
 import { assertIsDefined } from 'monaco-editor/esm/vs/base/common/types.js';
 class Composite extends Component {
@@ -62,9 +62,10 @@ class Composite extends Component {
         }
     }
     focus() {
-    }
-    updateStyles() {
-        super.updateStyles();
+        const container = this.getContainer();
+        if (container) {
+            focusWindow(container);
+        }
     }
     getMenuIds() {
         return [];