@codingame/monaco-vscode-api 1.78.5 → 1.78.6-next.0

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

@@ -0,0 +1,271 @@
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { IDialogService } from 'monaco-editor/esm/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 { 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';
+import { IWorkspaceContextService } from 'monaco-editor/esm/vs/platform/workspace/common/workspace.js';
+import { ILabelService } from 'monaco-editor/esm/vs/platform/label/common/label.js';
+import { IKeybindingService } from 'monaco-editor/esm/vs/platform/keybinding/common/keybinding.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 { IWorkspacesService, isRecentFolder, isRecentWorkspace } from '../../../platform/workspaces/common/workspaces.js';
+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 { splitName } from 'monaco-editor/esm/vs/base/common/labels.js';
+import { isMacintosh } 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';
+import { ResourceMap } from 'monaco-editor/esm/vs/base/common/map.js';
+import { Codicon } from 'monaco-editor/esm/vs/base/common/codicons.js';
+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';
+const inRecentFilesPickerContextKey = 'inRecentFilesPicker';
+class BaseOpenRecentAction extends Action2 {
+    constructor(desc) {
+        super(desc);
+        this.removeFromRecentlyOpened = {
+            iconClass: ThemeIcon.asClassName(Codicon.removeClose),
+            tooltip: ( localize('remove', "Remove from Recently Opened"))
+        };
+        this.dirtyRecentlyOpenedFolder = {
+            iconClass: 'dirty-workspace ' + ThemeIcon.asClassName(Codicon.closeDirty),
+            tooltip: ( localize('dirtyRecentlyOpenedFolder', "Folder With Unsaved Files")),
+            alwaysVisible: true
+        };
+        this.dirtyRecentlyOpenedWorkspace = {
+            ...this.dirtyRecentlyOpenedFolder,
+            tooltip: ( localize('dirtyRecentlyOpenedWorkspace', "Workspace With Unsaved Files")),
+        };
+    }
+    async run(accessor) {
+        const workspacesService = accessor.get(IWorkspacesService);
+        const quickInputService = accessor.get(IQuickInputService);
+        const contextService = accessor.get(IWorkspaceContextService);
+        const labelService = accessor.get(ILabelService);
+        const keybindingService = accessor.get(IKeybindingService);
+        const modelService = accessor.get(IModelService);
+        const languageService = accessor.get(ILanguageService);
+        const hostService = accessor.get(IHostService);
+        const dialogService = accessor.get(IDialogService);
+        const recentlyOpened = await workspacesService.getRecentlyOpened();
+        const dirtyWorkspacesAndFolders = await workspacesService.getDirtyWorkspaces();
+        let hasWorkspaces = false;
+        const dirtyFolders = ( new ResourceMap());
+        const dirtyWorkspaces = ( new ResourceMap());
+        for (const dirtyWorkspace of dirtyWorkspacesAndFolders) {
+            if (isFolderBackupInfo(dirtyWorkspace)) {
+                dirtyFolders.set(dirtyWorkspace.folderUri, true);
+            }
+            else {
+                dirtyWorkspaces.set(dirtyWorkspace.workspace.configPath, dirtyWorkspace.workspace);
+                hasWorkspaces = true;
+            }
+        }
+        const recentFolders = ( new ResourceMap());
+        const recentWorkspaces = ( new ResourceMap());
+        for (const recent of recentlyOpened.workspaces) {
+            if (isRecentFolder(recent)) {
+                recentFolders.set(recent.folderUri, true);
+            }
+            else {
+                recentWorkspaces.set(recent.workspace.configPath, recent.workspace);
+                hasWorkspaces = true;
+            }
+        }
+        const workspacePicks = [];
+        for (const recent of recentlyOpened.workspaces) {
+            const isDirty = isRecentFolder(recent) ? ( dirtyFolders.has(recent.folderUri)) : ( dirtyWorkspaces.has(recent.workspace.configPath));
+            workspacePicks.push(this.toQuickPick(modelService, languageService, labelService, recent, isDirty));
+        }
+        for (const dirtyWorkspaceOrFolder of dirtyWorkspacesAndFolders) {
+            if (isFolderBackupInfo(dirtyWorkspaceOrFolder) && !( recentFolders.has(dirtyWorkspaceOrFolder.folderUri))) {
+                workspacePicks.push(this.toQuickPick(modelService, languageService, labelService, dirtyWorkspaceOrFolder, true));
+            }
+            else if (isWorkspaceBackupInfo(dirtyWorkspaceOrFolder) && !( recentWorkspaces.has(dirtyWorkspaceOrFolder.workspace.configPath))) {
+                workspacePicks.push(this.toQuickPick(modelService, languageService, labelService, dirtyWorkspaceOrFolder, true));
+            }
+        }
+        const filePicks = ( recentlyOpened.files.map(
+            p => this.toQuickPick(modelService, languageService, labelService, p, false)
+        ));
+        const firstEntry = recentlyOpened.workspaces[0];
+        const autoFocusSecondEntry = firstEntry && contextService.isCurrentWorkspace(isRecentWorkspace(firstEntry) ? firstEntry.workspace : firstEntry.folderUri);
+        let keyMods;
+        const workspaceSeparator = { type: 'separator', label: hasWorkspaces ? ( localize('workspacesAndFolders', "folders & workspaces")) : ( localize('folders', "folders")) };
+        const fileSeparator = { type: 'separator', label: ( localize('files', "files")) };
+        const picks = [workspaceSeparator, ...workspacePicks, fileSeparator, ...filePicks];
+        const pick = await quickInputService.pick(picks, {
+            contextKey: inRecentFilesPickerContextKey,
+            activeItem: [...workspacePicks, ...filePicks][autoFocusSecondEntry ? 1 : 0],
+            placeHolder: isMacintosh ? ( localize(
+                'openRecentPlaceholderMac',
+                "Select to open (hold Cmd-key to force new window or Option-key for same window)"
+            )) : ( localize(
+                'openRecentPlaceholder',
+                "Select to open (hold Ctrl-key to force new window or Alt-key for same window)"
+            )),
+            matchOnDescription: true,
+            onKeyMods: mods => keyMods = mods,
+            quickNavigate: this.isQuickNavigate() ? { keybindings: keybindingService.lookupKeybindings(this.desc.id) } : undefined,
+            hideInput: this.isQuickNavigate(),
+            onDidTriggerItemButton: async (context) => {
+                if (context.button === this.removeFromRecentlyOpened) {
+                    await workspacesService.removeRecentlyOpened([context.item.resource]);
+                    context.removeItem();
+                }
+                else if (context.button === this.dirtyRecentlyOpenedFolder || context.button === this.dirtyRecentlyOpenedWorkspace) {
+                    const isDirtyWorkspace = context.button === this.dirtyRecentlyOpenedWorkspace;
+                    const { confirmed } = await dialogService.confirm({
+                        title: isDirtyWorkspace ? ( localize('dirtyWorkspace', "Workspace with Unsaved Files")) : ( localize('dirtyFolder', "Folder with Unsaved Files")),
+                        message: isDirtyWorkspace ? ( localize(
+                            'dirtyWorkspaceConfirm',
+                            "Do you want to open the workspace to review the unsaved files?"
+                        )) : ( localize(
+                            'dirtyFolderConfirm',
+                            "Do you want to open the folder to review the unsaved files?"
+                        )),
+                        detail: isDirtyWorkspace ? ( localize(
+                            'dirtyWorkspaceConfirmDetail',
+                            "Workspaces with unsaved files cannot be removed until all unsaved files have been saved or reverted."
+                        )) : ( localize(
+                            'dirtyFolderConfirmDetail',
+                            "Folders with unsaved files cannot be removed until all unsaved files have been saved or reverted."
+                        ))
+                    });
+                    if (confirmed) {
+                        hostService.openWindow([context.item.openable], {
+                            remoteAuthority: context.item.remoteAuthority || null
+                        });
+                        quickInputService.cancel();
+                    }
+                }
+            }
+        });
+        if (pick) {
+            return hostService.openWindow([pick.openable], {
+                forceNewWindow: keyMods?.ctrlCmd,
+                forceReuseWindow: keyMods?.alt,
+                remoteAuthority: pick.remoteAuthority || null
+            });
+        }
+    }
+    toQuickPick(modelService, languageService, labelService, recent, isDirty) {
+        let openable;
+        let iconClasses;
+        let fullLabel;
+        let resource;
+        let isWorkspace = false;
+        if (isRecentFolder(recent)) {
+            resource = recent.folderUri;
+            iconClasses = getIconClasses(modelService, languageService, resource, FileKind.FOLDER);
+            openable = { folderUri: resource };
+            fullLabel = recent.label || labelService.getWorkspaceLabel(resource, { verbose: 2  });
+        }
+        else if (isRecentWorkspace(recent)) {
+            resource = recent.workspace.configPath;
+            iconClasses = getIconClasses(modelService, languageService, resource, FileKind.ROOT_FOLDER);
+            openable = { workspaceUri: resource };
+            fullLabel = recent.label || labelService.getWorkspaceLabel(recent.workspace, { verbose: 2  });
+            isWorkspace = true;
+        }
+        else {
+            resource = recent.fileUri;
+            iconClasses = getIconClasses(modelService, languageService, resource, FileKind.FILE);
+            openable = { fileUri: resource };
+            fullLabel = recent.label || labelService.getUriLabel(resource);
+        }
+        const { name, parentPath } = splitName(fullLabel);
+        return {
+            iconClasses,
+            label: name,
+            ariaLabel: isDirty ? isWorkspace ? ( localize(
+                'recentDirtyWorkspaceAriaLabel',
+                "{0}, workspace with unsaved changes",
+                name
+            )) : ( localize('recentDirtyFolderAriaLabel', "{0}, folder with unsaved changes", name)) : name,
+            description: parentPath,
+            buttons: isDirty ? [isWorkspace ? this.dirtyRecentlyOpenedWorkspace : this.dirtyRecentlyOpenedFolder] : [this.removeFromRecentlyOpened],
+            openable,
+            resource,
+            remoteAuthority: recent.remoteAuthority
+        };
+    }
+}
+class OpenRecentAction extends BaseOpenRecentAction {
+    constructor() {
+        super({
+            id: OpenRecentAction.ID,
+            title: {
+                value: ( localize('openRecent', "Open Recent...")),
+                mnemonicTitle: ( localize({ key: 'miMore', comment: ['&& denotes a mnemonic'] }, "&&More...")),
+                original: 'Open Recent...'
+            },
+            category: Categories.File,
+            f1: true,
+            keybinding: {
+                weight: 200 ,
+                primary: 2048  | 48 ,
+                mac: { primary: 256  | 48  }
+            },
+            menu: {
+                id: MenuId.MenubarRecentMenu,
+                group: 'y_more',
+                order: 1
+            }
+        });
+    }
+    isQuickNavigate() {
+        return false;
+    }
+}
+OpenRecentAction.ID = 'workbench.action.openRecent';
+class ReloadWindowAction extends Action2 {
+    constructor() {
+        super({
+            id: ReloadWindowAction.ID,
+            title: { value: ( localize('reloadWindow', "Reload Window")), original: 'Reload Window' },
+            category: Categories.Developer,
+            f1: true,
+            keybinding: {
+                weight: 200  + 50,
+                when: IsDevelopmentContext,
+                primary: 2048  | 48
+            }
+        });
+    }
+    run(accessor) {
+        const hostService = accessor.get(IHostService);
+        return hostService.reload();
+    }
+}
+ReloadWindowAction.ID = 'workbench.action.reloadWindow';
+const recentFilesPickerContext = ( ContextKeyExpr.and(inQuickPickContext, ( ContextKeyExpr.has(inRecentFilesPickerContextKey))));
+const quickPickNavigateNextInRecentFilesPickerId = 'workbench.action.quickOpenNavigateNextInRecentFilesPicker';
+KeybindingsRegistry.registerCommandAndKeybindingRule({
+    id: quickPickNavigateNextInRecentFilesPickerId,
+    weight: 200  + 50,
+    handler: getQuickNavigateHandler(quickPickNavigateNextInRecentFilesPickerId, true),
+    when: recentFilesPickerContext,
+    primary: 2048  | 48 ,
+    mac: { primary: 256  | 48  }
+});
+const quickPickNavigatePreviousInRecentFilesPicker = 'workbench.action.quickOpenNavigatePreviousInRecentFilesPicker';
+KeybindingsRegistry.registerCommandAndKeybindingRule({
+    id: quickPickNavigatePreviousInRecentFilesPicker,
+    weight: 200  + 50,
+    handler: getQuickNavigateHandler(quickPickNavigatePreviousInRecentFilesPicker, false),
+    when: recentFilesPickerContext,
+    primary: 2048  | 1024  | 48 ,
+    mac: { primary: 256  | 1024  | 48  }
+});
+CommandsRegistry.registerCommand('workbench.action.toggleConfirmBeforeClose', accessor => {
+    const configurationService = accessor.get(IConfigurationService);
+    const setting = configurationService.inspect('window.confirmBeforeClose').userValue;
+    return configurationService.updateValue('window.confirmBeforeClose', setting === 'never' ? 'keyboardOnly' : 'never');
+});
+export { OpenRecentAction, ReloadWindowAction, inRecentFilesPickerContextKey };

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

@@ -0,0 +1,250 @@
+import { localize } 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 { 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 { IFileDialogService } from 'monaco-editor/esm/vs/platform/dialogs/common/dialogs.js';
+import { Action2 } 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';
+import { ContextKeyExpr } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { IWorkbenchEnvironmentService } from '../../services/environment/common/environmentService.js';
+import { IWorkspacesService } from '../../../platform/workspaces/common/workspaces.js';
+import { IsMacNativeContext } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkeys.js';
+import { Categories } from 'monaco-editor/esm/vs/platform/action/common/actionCommonCategories.js';
+const workspacesCategory = { value: ( localize('workspaces', "Workspaces")), original: 'Workspaces' };
+class OpenFileAction extends Action2 {
+    constructor() {
+        super({
+            id: OpenFileAction.ID,
+            title: { value: ( localize('openFile', "Open File...")), original: 'Open File...' },
+            category: Categories.File,
+            f1: true,
+            precondition: ( IsMacNativeContext.toNegated()),
+            keybinding: {
+                weight: 200 ,
+                primary: 2048  | 45
+            }
+        });
+    }
+    async run(accessor, data) {
+        const fileDialogService = accessor.get(IFileDialogService);
+        return fileDialogService.pickFileAndOpen({ forceNewWindow: false, telemetryExtraData: data });
+    }
+}
+OpenFileAction.ID = 'workbench.action.files.openFile';
+class OpenFolderAction extends Action2 {
+    constructor() {
+        super({
+            id: OpenFolderAction.ID,
+            title: { value: ( localize('openFolder', "Open Folder...")), original: 'Open Folder...' },
+            category: Categories.File,
+            f1: true,
+            precondition: OpenFolderWorkspaceSupportContext,
+            keybinding: {
+                weight: 200 ,
+                primary: undefined,
+                linux: {
+                    primary: KeyChord(2048  | 41 , 2048  | 45 )
+                },
+                win: {
+                    primary: KeyChord(2048  | 41 , 2048  | 45 )
+                }
+            }
+        });
+    }
+    async run(accessor, data) {
+        const fileDialogService = accessor.get(IFileDialogService);
+        return fileDialogService.pickFolderAndOpen({ forceNewWindow: false, telemetryExtraData: data });
+    }
+}
+OpenFolderAction.ID = 'workbench.action.files.openFolder';
+class OpenFolderViaWorkspaceAction extends Action2 {
+    constructor() {
+        super({
+            id: OpenFolderViaWorkspaceAction.ID,
+            title: { value: ( localize('openFolder', "Open Folder...")), original: 'Open Folder...' },
+            category: Categories.File,
+            f1: true,
+            precondition: ( ContextKeyExpr.and(( OpenFolderWorkspaceSupportContext.toNegated()), ( WorkbenchStateContext.isEqualTo('workspace')))),
+            keybinding: {
+                weight: 200 ,
+                primary: 2048  | 45
+            }
+        });
+    }
+    run(accessor) {
+        const commandService = accessor.get(ICommandService);
+        return commandService.executeCommand(SET_ROOT_FOLDER_COMMAND_ID);
+    }
+}
+OpenFolderViaWorkspaceAction.ID = 'workbench.action.files.openFolderViaWorkspace';
+class OpenFileFolderAction extends Action2 {
+    constructor() {
+        super({
+            id: OpenFileFolderAction.ID,
+            title: OpenFileFolderAction.LABEL,
+            category: Categories.File,
+            f1: true,
+            precondition: ( ContextKeyExpr.and(IsMacNativeContext, OpenFolderWorkspaceSupportContext)),
+            keybinding: {
+                weight: 200 ,
+                primary: 2048  | 45
+            }
+        });
+    }
+    async run(accessor, data) {
+        const fileDialogService = accessor.get(IFileDialogService);
+        return fileDialogService.pickFileFolderAndOpen({ forceNewWindow: false, telemetryExtraData: data });
+    }
+}
+OpenFileFolderAction.ID = 'workbench.action.files.openFileFolder';
+OpenFileFolderAction.LABEL = { value: ( localize('openFileFolder', "Open...")), original: 'Open...' };
+class OpenWorkspaceAction extends Action2 {
+    constructor() {
+        super({
+            id: OpenWorkspaceAction.ID,
+            title: { value: ( localize('openWorkspaceAction', "Open Workspace from File...")), original: 'Open Workspace from File...' },
+            category: Categories.File,
+            f1: true,
+            precondition: EnterMultiRootWorkspaceSupportContext
+        });
+    }
+    async run(accessor, data) {
+        const fileDialogService = accessor.get(IFileDialogService);
+        return fileDialogService.pickWorkspaceAndOpen({ telemetryExtraData: data });
+    }
+}
+OpenWorkspaceAction.ID = 'workbench.action.openWorkspace';
+class CloseWorkspaceAction extends Action2 {
+    constructor() {
+        super({
+            id: CloseWorkspaceAction.ID,
+            title: { value: ( localize('closeWorkspace', "Close Workspace")), original: 'Close Workspace' },
+            category: workspacesCategory,
+            f1: true,
+            precondition: ( ContextKeyExpr.and(( WorkbenchStateContext.notEqualsTo('empty')), EmptyWorkspaceSupportContext)),
+            keybinding: {
+                weight: 200 ,
+                primary: KeyChord(2048  | 41 , 36 )
+            }
+        });
+    }
+    async run(accessor) {
+        const hostService = accessor.get(IHostService);
+        const environmentService = accessor.get(IWorkbenchEnvironmentService);
+        return hostService.openWindow({ forceReuseWindow: true, remoteAuthority: environmentService.remoteAuthority });
+    }
+}
+CloseWorkspaceAction.ID = 'workbench.action.closeFolder';
+class OpenWorkspaceConfigFileAction extends Action2 {
+    constructor() {
+        super({
+            id: OpenWorkspaceConfigFileAction.ID,
+            title: { value: ( localize('openWorkspaceConfigFile', "Open Workspace Configuration File")), original: 'Open Workspace Configuration File' },
+            category: workspacesCategory,
+            f1: true,
+            precondition: ( WorkbenchStateContext.isEqualTo('workspace'))
+        });
+    }
+    async run(accessor) {
+        const contextService = accessor.get(IWorkspaceContextService);
+        const editorService = accessor.get(IEditorService);
+        const configuration = contextService.getWorkspace().configuration;
+        if (configuration) {
+            await editorService.openEditor({ resource: configuration, options: { pinned: true } });
+        }
+    }
+}
+OpenWorkspaceConfigFileAction.ID = 'workbench.action.openWorkspaceConfigFile';
+class AddRootFolderAction extends Action2 {
+    constructor() {
+        super({
+            id: AddRootFolderAction.ID,
+            title: ADD_ROOT_FOLDER_LABEL,
+            category: workspacesCategory,
+            f1: true,
+            precondition: ( ContextKeyExpr.or(EnterMultiRootWorkspaceSupportContext, ( WorkbenchStateContext.isEqualTo('workspace'))))
+        });
+    }
+    run(accessor) {
+        const commandService = accessor.get(ICommandService);
+        return commandService.executeCommand(ADD_ROOT_FOLDER_COMMAND_ID);
+    }
+}
+AddRootFolderAction.ID = 'workbench.action.addRootFolder';
+class RemoveRootFolderAction extends Action2 {
+    constructor() {
+        super({
+            id: RemoveRootFolderAction.ID,
+            title: { value: ( localize('globalRemoveFolderFromWorkspace', "Remove Folder from Workspace...")), original: 'Remove Folder from Workspace...' },
+            category: workspacesCategory,
+            f1: true,
+            precondition: ( ContextKeyExpr.and(( WorkspaceFolderCountContext.notEqualsTo('0')), ( ContextKeyExpr.or(EnterMultiRootWorkspaceSupportContext, ( WorkbenchStateContext.isEqualTo('workspace'))))))
+        });
+    }
+    async run(accessor) {
+        const commandService = accessor.get(ICommandService);
+        const workspaceEditingService = accessor.get(IWorkspaceEditingService);
+        const folder = await commandService.executeCommand(PICK_WORKSPACE_FOLDER_COMMAND_ID);
+        if (folder) {
+            await workspaceEditingService.removeFolders([folder.uri]);
+        }
+    }
+}
+RemoveRootFolderAction.ID = 'workbench.action.removeRootFolder';
+class SaveWorkspaceAsAction extends Action2 {
+    constructor() {
+        super({
+            id: SaveWorkspaceAsAction.ID,
+            title: { value: ( localize('saveWorkspaceAsAction', "Save Workspace As...")), original: 'Save Workspace As...' },
+            category: workspacesCategory,
+            f1: true,
+            precondition: EnterMultiRootWorkspaceSupportContext
+        });
+    }
+    async run(accessor) {
+        const workspaceEditingService = accessor.get(IWorkspaceEditingService);
+        const contextService = accessor.get(IWorkspaceContextService);
+        const configPathUri = await workspaceEditingService.pickNewWorkspacePath();
+        if (configPathUri && hasWorkspaceFileExtension(configPathUri)) {
+            switch (contextService.getWorkbenchState()) {
+                case 1 :
+                case 2 : {
+                    const folders = ( contextService.getWorkspace().folders.map(folder => ({ uri: folder.uri })));
+                    return workspaceEditingService.createAndEnterWorkspace(folders, configPathUri);
+                }
+                case 3 :
+                    return workspaceEditingService.saveAndEnterWorkspace(configPathUri);
+            }
+        }
+    }
+}
+SaveWorkspaceAsAction.ID = 'workbench.action.saveWorkspaceAs';
+class DuplicateWorkspaceInNewWindowAction extends Action2 {
+    constructor() {
+        super({
+            id: DuplicateWorkspaceInNewWindowAction.ID,
+            title: { value: ( localize('duplicateWorkspaceInNewWindow', "Duplicate As Workspace in New Window")), original: 'Duplicate As Workspace in New Window' },
+            category: workspacesCategory,
+            f1: true,
+            precondition: EnterMultiRootWorkspaceSupportContext
+        });
+    }
+    async run(accessor) {
+        const workspaceContextService = accessor.get(IWorkspaceContextService);
+        const workspaceEditingService = accessor.get(IWorkspaceEditingService);
+        const hostService = accessor.get(IHostService);
+        const workspacesService = accessor.get(IWorkspacesService);
+        const environmentService = accessor.get(IWorkbenchEnvironmentService);
+        const folders = workspaceContextService.getWorkspace().folders;
+        const remoteAuthority = environmentService.remoteAuthority;
+        const newWorkspace = await workspacesService.createUntitledWorkspace(folders, remoteAuthority);
+        await workspaceEditingService.copyWorkspaceSettings(newWorkspace);
+        return hostService.openWindow([{ workspaceUri: newWorkspace.configPath }], { forceNewWindow: true, remoteAuthority });
+    }
+}
+DuplicateWorkspaceInNewWindowAction.ID = 'workbench.action.duplicateWorkspaceInNewWindow';
+export { AddRootFolderAction, OpenFileAction, OpenFileFolderAction, OpenFolderAction, OpenFolderViaWorkspaceAction, RemoveRootFolderAction };

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

@@ -0,0 +1,6 @@
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+const ADD_ROOT_FOLDER_COMMAND_ID = 'addRootFolder';
+const ADD_ROOT_FOLDER_LABEL = { value: ( localize('addFolderToWorkspace', "Add Folder to Workspace...")), original: 'Add Folder to Workspace...' };
+const SET_ROOT_FOLDER_COMMAND_ID = 'setRootFolder';
+const PICK_WORKSPACE_FOLDER_COMMAND_ID = '_workbench.pickWorkspaceFolder';
+export { ADD_ROOT_FOLDER_COMMAND_ID, ADD_ROOT_FOLDER_LABEL, PICK_WORKSPACE_FOLDER_COMMAND_ID, SET_ROOT_FOLDER_COMMAND_ID };

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

@@ -2,6 +2,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 { 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 {
     get onDidFocus() {
@@ -99,4 +100,51 @@ class Composite extends Component {
         return undefined;
     }
 }
-export { Composite };
+class CompositeDescriptor {
+    constructor(ctor, id, name, cssClass, order, requestedIndex) {
+        this.ctor = ctor;
+        this.id = id;
+        this.name = name;
+        this.cssClass = cssClass;
+        this.order = order;
+        this.requestedIndex = requestedIndex;
+    }
+    instantiate(instantiationService) {
+        return instantiationService.createInstance(this.ctor);
+    }
+}
+class CompositeRegistry extends Disposable {
+    constructor() {
+        super(...arguments);
+        this._onDidRegister = this._register(( new Emitter()));
+        this.onDidRegister = this._onDidRegister.event;
+        this._onDidDeregister = this._register(( new Emitter()));
+        this.onDidDeregister = this._onDidDeregister.event;
+        this.composites = [];
+    }
+    registerComposite(descriptor) {
+        if (this.compositeById(descriptor.id)) {
+            return;
+        }
+        this.composites.push(descriptor);
+        this._onDidRegister.fire(descriptor);
+    }
+    deregisterComposite(id) {
+        const descriptor = this.compositeById(id);
+        if (!descriptor) {
+            return;
+        }
+        this.composites.splice(this.composites.indexOf(descriptor), 1);
+        this._onDidDeregister.fire(descriptor);
+    }
+    getComposite(id) {
+        return this.compositeById(id);
+    }
+    getComposites() {
+        return this.composites.slice(0);
+    }
+    compositeById(id) {
+        return this.composites.find(composite => composite.id === id);
+    }
+}
+export { Composite, CompositeDescriptor, CompositeRegistry };