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

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

@@ -1,271 +0,0 @@
-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

@@ -1,250 +0,0 @@
-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

@@ -1,6 +0,0 @@
-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 };