@codingame/monaco-vscode-ac93482b-2178-52df-a200-ba0d1a4963fb-common 20.0.0

package/vscode/src/vs/workbench/contrib/files/browser/fileCommands.d.ts

@@ -0,0 +1,4 @@
+import { IWindowOpenable, IOpenWindowOptions, IOpenEmptyWindowOptions } from "@codingame/monaco-vscode-api/vscode/vs/platform/window/common/window";
+import { ServicesAccessor } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+export declare const openWindowCommand: (accessor: ServicesAccessor, toOpen: IWindowOpenable[], options?: IOpenWindowOptions) => void;
+export declare const newWindowCommand: (accessor: ServicesAccessor, options?: IOpenEmptyWindowOptions) => void;

package/vscode/src/vs/workbench/contrib/files/browser/fileCommands.js

@@ -0,0 +1,474 @@
+
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { EditorResourceAccessor, SideBySideEditor } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/editor';
+import { isWorkspaceToOpen } from '@codingame/monaco-vscode-api/vscode/vs/platform/window/common/window';
+import { IHostService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/host/browser/host.service';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { UNTITLED_WORKSPACE_NAME } from '@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace';
+import { IWorkspaceContextService } from '@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service';
+import { ExplorerFocusCondition, FilesExplorerFocusCondition, ExplorerFolderContext, TextFileContentProvider, VIEW_ID, VIEWLET_ID, ExplorerCompressedFocusContext, ExplorerCompressedFirstFocusContext, ExplorerCompressedLastFocusContext } from '@codingame/monaco-vscode-f24e325c-2ce0-5bba-8236-bfc4f53180ab-common/vscode/vs/workbench/contrib/files/common/files';
+import { IClipboardService } from '@codingame/monaco-vscode-api/vscode/vs/platform/clipboard/common/clipboardService.service';
+import { CommandsRegistry } from '@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands';
+import { ICommandService } from '@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands.service';
+import { ContextKeyExpr } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey';
+import { IContextKeyService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service';
+import { IFileService } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service';
+import { KeybindingsRegistry, KeybindingWeight } from '@codingame/monaco-vscode-api/vscode/vs/platform/keybinding/common/keybindingsRegistry';
+import { KeyMod, KeyCode, KeyChord } from '@codingame/monaco-vscode-api/vscode/vs/base/common/keyCodes';
+import { isWindows, isWeb } from '@codingame/monaco-vscode-api/vscode/vs/base/common/platform';
+import { ITextModelService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/resolverService.service';
+import { getMultiSelectedResources, getResourceForCommand } from '@codingame/monaco-vscode-72a1b7d3-3f58-5545-9b7e-f579bd003081-common/vscode/vs/workbench/contrib/files/browser/files';
+import { IExplorerService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/files/browser/files.service';
+import { IWorkspaceEditingService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/workspaces/common/workspaceEditing.service';
+import { Schemas } from '@codingame/monaco-vscode-api/vscode/vs/base/common/network';
+import { EditorContextKeys } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/editorContextKeys';
+import { SIDE_GROUP } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService';
+import { IEditorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service';
+import { IEditorGroupsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorGroupsService.service';
+import { ILabelService } from '@codingame/monaco-vscode-api/vscode/vs/platform/label/common/label.service';
+import { joinPath, basename } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { dispose } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { IEnvironmentService } from '@codingame/monaco-vscode-api/vscode/vs/platform/environment/common/environment.service';
+import { IUriIdentityService } from '@codingame/monaco-vscode-api/vscode/vs/platform/uriIdentity/common/uriIdentity.service';
+import { EditorOpenSource, EditorResolution } from '@codingame/monaco-vscode-api/vscode/vs/platform/editor/common/editor';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { IPaneCompositePartService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/panecomposite/browser/panecomposite.service';
+import { ViewContainerLocation } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/views';
+import { IViewsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/views/common/viewsService.service';
+import { OPEN_TO_SIDE_COMMAND_ID, COMPARE_WITH_SAVED_COMMAND_ID, ResourceSelectedForCompareContext, SELECT_FOR_COMPARE_COMMAND_ID, COMPARE_SELECTED_COMMAND_ID, COMPARE_RESOURCE_COMMAND_ID, COPY_PATH_COMMAND_ID, COPY_RELATIVE_PATH_COMMAND_ID, REVEAL_IN_EXPLORER_COMMAND_ID, OPEN_WITH_EXPLORER_COMMAND_ID, REMOVE_ROOT_FOLDER_COMMAND_ID, PREVIOUS_COMPRESSED_FOLDER, NEXT_COMPRESSED_FOLDER, FIRST_COMPRESSED_FOLDER, LAST_COMPRESSED_FOLDER, NEW_UNTITLED_FILE_LABEL, NEW_UNTITLED_FILE_COMMAND_ID, NEW_FILE_COMMAND_ID } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/files/browser/fileConstants';
+import { IFileDialogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/dialogs/common/dialogs.service';
+import { RemoveRootFolderAction } from '@codingame/monaco-vscode-f24e325c-2ce0-5bba-8236-bfc4f53180ab-common/vscode/vs/workbench/browser/actions/workspaceActions';
+import { OpenEditorsView } from '@codingame/monaco-vscode-bd0792ac-6043-5ec3-a41a-54ccb922a1f4-common/vscode/vs/workbench/contrib/files/browser/views/openEditorsView';
+import { IListService } from '@codingame/monaco-vscode-api/vscode/vs/platform/list/browser/listService.service';
+import '@codingame/monaco-vscode-72a1b7d3-3f58-5545-9b7e-f579bd003081-common/vscode/vs/workbench/contrib/files/browser/fileCommands._save';
+
+const openWindowCommand = (accessor, toOpen, options) => {
+    if (Array.isArray(toOpen)) {
+        const hostService = accessor.get(IHostService);
+        const environmentService = accessor.get(IEnvironmentService);
+        toOpen = ( toOpen.map(openable => {
+            if (isWorkspaceToOpen(openable) && openable.workspaceUri.scheme === Schemas.untitled) {
+                return {
+                    workspaceUri: joinPath(environmentService.untitledWorkspacesHome, openable.workspaceUri.path, UNTITLED_WORKSPACE_NAME)
+                };
+            }
+            return openable;
+        }));
+        hostService.openWindow(toOpen, options);
+    }
+};
+const newWindowCommand = (accessor, options) => {
+    const hostService = accessor.get(IHostService);
+    hostService.openWindow(options);
+};
+KeybindingsRegistry.registerCommandAndKeybindingRule({
+    weight: KeybindingWeight.WorkbenchContrib,
+    when: ExplorerFocusCondition,
+    primary: KeyMod.CtrlCmd | KeyCode.Enter,
+    mac: {
+        primary: KeyMod.WinCtrl | KeyCode.Enter
+    },
+    id: OPEN_TO_SIDE_COMMAND_ID, handler: async (accessor, resource) => {
+        const editorService = accessor.get(IEditorService);
+        const fileService = accessor.get(IFileService);
+        const explorerService = accessor.get(IExplorerService);
+        const resources = getMultiSelectedResources(resource, accessor.get(IListService), editorService, accessor.get(IEditorGroupsService), explorerService);
+        if (resources.length) {
+            const untitledResources = resources.filter(resource => resource.scheme === Schemas.untitled);
+            const fileResources = resources.filter(resource => resource.scheme !== Schemas.untitled);
+            const items = await Promise.all(( fileResources.map(async (resource) => {
+                const item = explorerService.findClosest(resource);
+                if (item) {
+                    return item;
+                }
+                return await fileService.stat(resource);
+            })));
+            const files = items.filter(i => !i.isDirectory);
+            const editors = ( files.map(f => ({
+                resource: f.resource,
+                options: { pinned: true }
+            }))).concat(...( untitledResources.map(
+                untitledResource => ({ resource: untitledResource, options: { pinned: true } })
+            )));
+            await editorService.openEditors(editors, SIDE_GROUP);
+        }
+    }
+});
+KeybindingsRegistry.registerCommandAndKeybindingRule({
+    weight: KeybindingWeight.WorkbenchContrib + 10,
+    when: ( ContextKeyExpr.and(FilesExplorerFocusCondition, ( ExplorerFolderContext.toNegated()))),
+    primary: KeyCode.Enter,
+    mac: {
+        primary: KeyMod.CtrlCmd | KeyCode.DownArrow
+    },
+    id: 'explorer.openAndPassFocus', handler: async (accessor, _resource) => {
+        const editorService = accessor.get(IEditorService);
+        const explorerService = accessor.get(IExplorerService);
+        const resources = explorerService.getContext(true);
+        if (resources.length) {
+            await editorService.openEditors(( resources.map(
+                r => ({ resource: r.resource, options: { preserveFocus: false, pinned: true } })
+            )));
+        }
+    }
+});
+const COMPARE_WITH_SAVED_SCHEMA = 'showModifications';
+let providerDisposables = [];
+KeybindingsRegistry.registerCommandAndKeybindingRule({
+    id: COMPARE_WITH_SAVED_COMMAND_ID,
+    when: undefined,
+    weight: KeybindingWeight.WorkbenchContrib,
+    primary: KeyChord(KeyMod.CtrlCmd | KeyCode.KeyK, KeyCode.KeyD),
+    handler: async (accessor, resource) => {
+        const instantiationService = accessor.get(IInstantiationService);
+        const textModelService = accessor.get(ITextModelService);
+        const editorService = accessor.get(IEditorService);
+        const fileService = accessor.get(IFileService);
+        const listService = accessor.get(IListService);
+        let registerEditorListener = false;
+        if (providerDisposables.length === 0) {
+            registerEditorListener = true;
+            const provider = instantiationService.createInstance(TextFileContentProvider);
+            providerDisposables.push(provider);
+            providerDisposables.push(textModelService.registerTextModelContentProvider(COMPARE_WITH_SAVED_SCHEMA, provider));
+        }
+        const uri = getResourceForCommand(resource, editorService, listService);
+        if (uri && fileService.hasProvider(uri)) {
+            const name = basename(uri);
+            const editorLabel = ( localize(7412, "{0} (in file) ↔ {1}", name, name));
+            try {
+                await TextFileContentProvider.open(uri, COMPARE_WITH_SAVED_SCHEMA, editorLabel, editorService, { pinned: true });
+                if (registerEditorListener) {
+                    providerDisposables.push(editorService.onDidVisibleEditorsChange(() => {
+                        if (!( editorService.editors.some(
+                            editor => !!EditorResourceAccessor.getCanonicalUri(editor, { supportSideBySide: SideBySideEditor.SECONDARY, filterByScheme: COMPARE_WITH_SAVED_SCHEMA })
+                        ))) {
+                            providerDisposables = dispose(providerDisposables);
+                        }
+                    }));
+                }
+            }
+            catch {
+                providerDisposables = dispose(providerDisposables);
+            }
+        }
+    }
+});
+let globalResourceToCompare;
+let resourceSelectedForCompareContext;
+CommandsRegistry.registerCommand({
+    id: SELECT_FOR_COMPARE_COMMAND_ID,
+    handler: (accessor, resource) => {
+        globalResourceToCompare = getResourceForCommand(resource, accessor.get(IEditorService), accessor.get(IListService));
+        if (!resourceSelectedForCompareContext) {
+            resourceSelectedForCompareContext = ResourceSelectedForCompareContext.bindTo(accessor.get(IContextKeyService));
+        }
+        resourceSelectedForCompareContext.set(true);
+    }
+});
+CommandsRegistry.registerCommand({
+    id: COMPARE_SELECTED_COMMAND_ID,
+    handler: async (accessor, resource) => {
+        const editorService = accessor.get(IEditorService);
+        const resources = getMultiSelectedResources(resource, accessor.get(IListService), editorService, accessor.get(IEditorGroupsService), accessor.get(IExplorerService));
+        if (resources.length === 2) {
+            return editorService.openEditor({
+                original: { resource: resources[0] },
+                modified: { resource: resources[1] },
+                options: { pinned: true }
+            });
+        }
+        return true;
+    }
+});
+CommandsRegistry.registerCommand({
+    id: COMPARE_RESOURCE_COMMAND_ID,
+    handler: (accessor, resource) => {
+        const editorService = accessor.get(IEditorService);
+        const rightResource = getResourceForCommand(resource, editorService, accessor.get(IListService));
+        if (globalResourceToCompare && rightResource) {
+            editorService.openEditor({
+                original: { resource: globalResourceToCompare },
+                modified: { resource: rightResource },
+                options: { pinned: true }
+            });
+        }
+    }
+});
+async function resourcesToClipboard(resources, relative, clipboardService, labelService, configurationService) {
+    if (resources.length) {
+        const lineDelimiter = isWindows ? '\r\n' : '\n';
+        let separator = undefined;
+        const copyRelativeOrFullPathSeparatorSection = relative ? 'explorer.copyRelativePathSeparator' : 'explorer.copyPathSeparator';
+        const copyRelativeOrFullPathSeparator = configurationService.getValue(copyRelativeOrFullPathSeparatorSection);
+        if (copyRelativeOrFullPathSeparator === '/' || copyRelativeOrFullPathSeparator === '\\') {
+            separator = copyRelativeOrFullPathSeparator;
+        }
+        const text = ( resources.map(
+            resource => labelService.getUriLabel(resource, { relative, noPrefix: true, separator })
+        )).join(lineDelimiter);
+        await clipboardService.writeText(text);
+    }
+}
+const copyPathCommandHandler = async (accessor, resource) => {
+    const resources = getMultiSelectedResources(resource, accessor.get(IListService), accessor.get(IEditorService), accessor.get(IEditorGroupsService), accessor.get(IExplorerService));
+    await resourcesToClipboard(resources, false, accessor.get(IClipboardService), accessor.get(ILabelService), accessor.get(IConfigurationService));
+};
+KeybindingsRegistry.registerCommandAndKeybindingRule({
+    weight: KeybindingWeight.WorkbenchContrib,
+    when: ( EditorContextKeys.focus.toNegated()),
+    primary: KeyMod.CtrlCmd | KeyMod.Alt | KeyCode.KeyC,
+    win: {
+        primary: KeyMod.Shift | KeyMod.Alt | KeyCode.KeyC
+    },
+    id: COPY_PATH_COMMAND_ID,
+    handler: copyPathCommandHandler
+});
+KeybindingsRegistry.registerCommandAndKeybindingRule({
+    weight: KeybindingWeight.WorkbenchContrib,
+    when: EditorContextKeys.focus,
+    primary: KeyChord(KeyMod.CtrlCmd | KeyCode.KeyK, KeyMod.CtrlCmd | KeyMod.Alt | KeyCode.KeyC),
+    win: {
+        primary: KeyMod.Shift | KeyMod.Alt | KeyCode.KeyC
+    },
+    id: COPY_PATH_COMMAND_ID,
+    handler: copyPathCommandHandler
+});
+const copyRelativePathCommandHandler = async (accessor, resource) => {
+    const resources = getMultiSelectedResources(resource, accessor.get(IListService), accessor.get(IEditorService), accessor.get(IEditorGroupsService), accessor.get(IExplorerService));
+    await resourcesToClipboard(resources, true, accessor.get(IClipboardService), accessor.get(ILabelService), accessor.get(IConfigurationService));
+};
+KeybindingsRegistry.registerCommandAndKeybindingRule({
+    weight: KeybindingWeight.WorkbenchContrib,
+    when: ( EditorContextKeys.focus.toNegated()),
+    primary: KeyMod.CtrlCmd | KeyMod.Shift | KeyMod.Alt | KeyCode.KeyC,
+    win: {
+        primary: KeyChord(KeyMod.CtrlCmd | KeyCode.KeyK, KeyMod.CtrlCmd | KeyMod.Shift | KeyCode.KeyC)
+    },
+    id: COPY_RELATIVE_PATH_COMMAND_ID,
+    handler: copyRelativePathCommandHandler
+});
+KeybindingsRegistry.registerCommandAndKeybindingRule({
+    weight: KeybindingWeight.WorkbenchContrib,
+    when: EditorContextKeys.focus,
+    primary: KeyChord(KeyMod.CtrlCmd | KeyCode.KeyK, KeyMod.CtrlCmd | KeyMod.Shift | KeyMod.Alt | KeyCode.KeyC),
+    win: {
+        primary: KeyChord(KeyMod.CtrlCmd | KeyCode.KeyK, KeyMod.CtrlCmd | KeyMod.Shift | KeyCode.KeyC)
+    },
+    id: COPY_RELATIVE_PATH_COMMAND_ID,
+    handler: copyRelativePathCommandHandler
+});
+KeybindingsRegistry.registerCommandAndKeybindingRule({
+    weight: KeybindingWeight.WorkbenchContrib,
+    when: undefined,
+    primary: KeyChord(KeyMod.CtrlCmd | KeyCode.KeyK, KeyCode.KeyP),
+    id: 'workbench.action.files.copyPathOfActiveFile',
+    handler: async (accessor) => {
+        const editorService = accessor.get(IEditorService);
+        const activeInput = editorService.activeEditor;
+        const resource = EditorResourceAccessor.getOriginalUri(activeInput, { supportSideBySide: SideBySideEditor.PRIMARY });
+        const resources = resource ? [resource] : [];
+        await resourcesToClipboard(resources, false, accessor.get(IClipboardService), accessor.get(ILabelService), accessor.get(IConfigurationService));
+    }
+});
+CommandsRegistry.registerCommand({
+    id: REVEAL_IN_EXPLORER_COMMAND_ID,
+    handler: async (accessor, resource) => {
+        const viewService = accessor.get(IViewsService);
+        const contextService = accessor.get(IWorkspaceContextService);
+        const explorerService = accessor.get(IExplorerService);
+        const editorService = accessor.get(IEditorService);
+        const listService = accessor.get(IListService);
+        const uri = getResourceForCommand(resource, editorService, listService);
+        if (uri && contextService.isInsideWorkspace(uri)) {
+            const explorerView = await viewService.openView(VIEW_ID, false);
+            if (explorerView) {
+                const oldAutoReveal = explorerView.autoReveal;
+                explorerView.autoReveal = false;
+                explorerView.setExpanded(true);
+                await explorerService.select(uri, 'force');
+                explorerView.focus();
+                explorerView.autoReveal = oldAutoReveal;
+            }
+        }
+        else {
+            const openEditorsView = viewService.getViewWithId(OpenEditorsView.ID);
+            if (openEditorsView) {
+                openEditorsView.setExpanded(true);
+                openEditorsView.focus();
+            }
+        }
+    }
+});
+CommandsRegistry.registerCommand({
+    id: OPEN_WITH_EXPLORER_COMMAND_ID,
+    handler: async (accessor, resource) => {
+        const editorService = accessor.get(IEditorService);
+        const listService = accessor.get(IListService);
+        const uri = getResourceForCommand(resource, editorService, listService);
+        if (uri) {
+            return editorService.openEditor({ resource: uri, options: { override: EditorResolution.PICK, source: EditorOpenSource.USER } });
+        }
+        return undefined;
+    }
+});
+CommandsRegistry.registerCommand({
+    id: REMOVE_ROOT_FOLDER_COMMAND_ID,
+    handler: (accessor, resource) => {
+        const contextService = accessor.get(IWorkspaceContextService);
+        const uriIdentityService = accessor.get(IUriIdentityService);
+        const workspace = contextService.getWorkspace();
+        const resources = getMultiSelectedResources(resource, accessor.get(IListService), accessor.get(IEditorService), accessor.get(IEditorGroupsService), accessor.get(IExplorerService)).filter(resource => ( workspace.folders.some(folder => uriIdentityService.extUri.isEqual(folder.uri, resource)))
+        );
+        if (resources.length === 0) {
+            const commandService = accessor.get(ICommandService);
+            return commandService.executeCommand(RemoveRootFolderAction.ID);
+        }
+        const workspaceEditingService = accessor.get(IWorkspaceEditingService);
+        return workspaceEditingService.removeFolders(resources);
+    }
+});
+KeybindingsRegistry.registerCommandAndKeybindingRule({
+    weight: KeybindingWeight.WorkbenchContrib + 10,
+    when: ( ContextKeyExpr.and(
+        FilesExplorerFocusCondition,
+        ExplorerCompressedFocusContext,
+        ( ExplorerCompressedFirstFocusContext.negate())
+    )),
+    primary: KeyCode.LeftArrow,
+    id: PREVIOUS_COMPRESSED_FOLDER,
+    handler: accessor => {
+        const paneCompositeService = accessor.get(IPaneCompositePartService);
+        const viewlet = paneCompositeService.getActivePaneComposite(ViewContainerLocation.Sidebar);
+        if (viewlet?.getId() !== VIEWLET_ID) {
+            return;
+        }
+        const explorer = viewlet.getViewPaneContainer();
+        const view = explorer.getExplorerView();
+        view.previousCompressedStat();
+    }
+});
+KeybindingsRegistry.registerCommandAndKeybindingRule({
+    weight: KeybindingWeight.WorkbenchContrib + 10,
+    when: ( ContextKeyExpr.and(
+        FilesExplorerFocusCondition,
+        ExplorerCompressedFocusContext,
+        ( ExplorerCompressedLastFocusContext.negate())
+    )),
+    primary: KeyCode.RightArrow,
+    id: NEXT_COMPRESSED_FOLDER,
+    handler: accessor => {
+        const paneCompositeService = accessor.get(IPaneCompositePartService);
+        const viewlet = paneCompositeService.getActivePaneComposite(ViewContainerLocation.Sidebar);
+        if (viewlet?.getId() !== VIEWLET_ID) {
+            return;
+        }
+        const explorer = viewlet.getViewPaneContainer();
+        const view = explorer.getExplorerView();
+        view.nextCompressedStat();
+    }
+});
+KeybindingsRegistry.registerCommandAndKeybindingRule({
+    weight: KeybindingWeight.WorkbenchContrib + 10,
+    when: ( ContextKeyExpr.and(
+        FilesExplorerFocusCondition,
+        ExplorerCompressedFocusContext,
+        ( ExplorerCompressedFirstFocusContext.negate())
+    )),
+    primary: KeyCode.Home,
+    id: FIRST_COMPRESSED_FOLDER,
+    handler: accessor => {
+        const paneCompositeService = accessor.get(IPaneCompositePartService);
+        const viewlet = paneCompositeService.getActivePaneComposite(ViewContainerLocation.Sidebar);
+        if (viewlet?.getId() !== VIEWLET_ID) {
+            return;
+        }
+        const explorer = viewlet.getViewPaneContainer();
+        const view = explorer.getExplorerView();
+        view.firstCompressedStat();
+    }
+});
+KeybindingsRegistry.registerCommandAndKeybindingRule({
+    weight: KeybindingWeight.WorkbenchContrib + 10,
+    when: ( ContextKeyExpr.and(
+        FilesExplorerFocusCondition,
+        ExplorerCompressedFocusContext,
+        ( ExplorerCompressedLastFocusContext.negate())
+    )),
+    primary: KeyCode.End,
+    id: LAST_COMPRESSED_FOLDER,
+    handler: accessor => {
+        const paneCompositeService = accessor.get(IPaneCompositePartService);
+        const viewlet = paneCompositeService.getActivePaneComposite(ViewContainerLocation.Sidebar);
+        if (viewlet?.getId() !== VIEWLET_ID) {
+            return;
+        }
+        const explorer = viewlet.getViewPaneContainer();
+        const view = explorer.getExplorerView();
+        view.lastCompressedStat();
+    }
+});
+KeybindingsRegistry.registerCommandAndKeybindingRule({
+    weight: KeybindingWeight.WorkbenchContrib,
+    when: null,
+    primary: isWeb ? (isWindows ? KeyChord(KeyMod.CtrlCmd | KeyCode.KeyK, KeyCode.KeyN) : KeyMod.CtrlCmd | KeyMod.Alt | KeyCode.KeyN) : KeyMod.CtrlCmd | KeyCode.KeyN,
+    secondary: isWeb ? [KeyMod.CtrlCmd | KeyCode.KeyN] : undefined,
+    id: NEW_UNTITLED_FILE_COMMAND_ID,
+    metadata: {
+        description: NEW_UNTITLED_FILE_LABEL,
+        args: [
+            {
+                isOptional: true,
+                name: 'New Untitled Text File arguments',
+                description: 'The editor view type or language ID if known',
+                schema: {
+                    'type': 'object',
+                    'properties': {
+                        'viewType': {
+                            'type': 'string'
+                        },
+                        'languageId': {
+                            'type': 'string'
+                        }
+                    }
+                }
+            }
+        ]
+    },
+    handler: async (accessor, args) => {
+        const editorService = accessor.get(IEditorService);
+        await editorService.openEditor({
+            resource: undefined,
+            options: {
+                override: args?.viewType,
+                pinned: true
+            },
+            languageId: args?.languageId,
+        });
+    }
+});
+CommandsRegistry.registerCommand({
+    id: NEW_FILE_COMMAND_ID,
+    handler: async (accessor, args) => {
+        const editorService = accessor.get(IEditorService);
+        const dialogService = accessor.get(IFileDialogService);
+        const fileService = accessor.get(IFileService);
+        const createFileLocalized = ( localize(7413, "Create File"));
+        const defaultFileUri = joinPath(await dialogService.defaultFilePath(), args?.fileName ?? 'Untitled.txt');
+        const saveUri = await dialogService.showSaveDialog({ saveLabel: createFileLocalized, title: createFileLocalized, defaultUri: defaultFileUri });
+        if (!saveUri) {
+            return;
+        }
+        await fileService.createFile(saveUri, undefined, { overwrite: true });
+        await editorService.openEditor({
+            resource: saveUri,
+            options: {
+                override: args?.viewType,
+                pinned: true
+            },
+            languageId: args?.languageId,
+        });
+    }
+});
+
+export { newWindowCommand, openWindowCommand };

package/vscode/src/vs/workbench/contrib/files/browser/files.contribution._fileEditorFactory.d.ts

@@ -0,0 +1 @@
+export {};

package/vscode/src/vs/workbench/contrib/files/browser/files.contribution._fileEditorFactory.js

@@ -0,0 +1,15 @@
+
+import { Registry } from '@codingame/monaco-vscode-api/vscode/vs/platform/registry/common/platform';
+import { EditorExtensions } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/editor';
+import { FILE_EDITOR_INPUT_ID } from '@codingame/monaco-vscode-f24e325c-2ce0-5bba-8236-bfc4f53180ab-common/vscode/vs/workbench/contrib/files/common/files';
+import { FileEditorInput } from '@codingame/monaco-vscode-72a1b7d3-3f58-5545-9b7e-f579bd003081-common/vscode/vs/workbench/contrib/files/browser/editors/fileEditorInput';
+
+( Registry.as(EditorExtensions.EditorFactory)).registerFileEditorFactory({
+    typeId: FILE_EDITOR_INPUT_ID,
+    createFileEditor: (resource, preferredResource, preferredName, preferredDescription, preferredEncoding, preferredLanguageId, preferredContents, instantiationService) => {
+        return instantiationService.createInstance(FileEditorInput, resource, preferredResource, preferredName, preferredDescription, preferredEncoding, preferredLanguageId, preferredContents);
+    },
+    isFileEditor: (obj) => {
+        return obj instanceof FileEditorInput;
+    }
+});

package/vscode/src/vs/workbench/contrib/webview/browser/webview.contribution.d.ts

@@ -0,0 +1 @@
+export declare const PreventDefaultContextMenuItemsContextKeyName = "preventDefaultContextMenuItems";

package/vscode/src/vs/workbench/contrib/webview/browser/webview.contribution.js

@@ -0,0 +1,72 @@
+
+import { getActiveElement } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { UndoCommand, RedoCommand, SelectAllCommand } from '@codingame/monaco-vscode-api/vscode/vs/editor/browser/editorExtensions';
+import { CopyAction, PasteAction, CutAction } from '@codingame/monaco-vscode-api/vscode/vs/editor/contrib/clipboard/browser/clipboard';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { MenuRegistry, MenuId } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions';
+import { ContextKeyExpr } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey';
+import { IWebviewService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/webview/browser/webview.service';
+import { WebviewInput } from '@codingame/monaco-vscode-670aae94-7f88-54d7-90ea-6fcbef423557-common/vscode/vs/workbench/contrib/webviewPanel/browser/webviewEditorInput';
+import { IEditorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service';
+
+const PRIORITY = 100;
+function overrideCommandForWebview(command, f) {
+    command?.addImplementation(PRIORITY, 'webview', accessor => {
+        const webviewService = accessor.get(IWebviewService);
+        const webview = webviewService.activeWebview;
+        if (webview?.isFocused) {
+            f(webview);
+            return true;
+        }
+        if (getActiveElement()?.classList.contains('action-menu-item')) {
+            const editorService = accessor.get(IEditorService);
+            if (editorService.activeEditor instanceof WebviewInput) {
+                f(editorService.activeEditor.webview);
+                return true;
+            }
+        }
+        return false;
+    });
+}
+overrideCommandForWebview(UndoCommand, webview => webview.undo());
+overrideCommandForWebview(RedoCommand, webview => webview.redo());
+overrideCommandForWebview(SelectAllCommand, webview => webview.selectAll());
+overrideCommandForWebview(CopyAction, webview => webview.copy());
+overrideCommandForWebview(PasteAction, webview => webview.paste());
+overrideCommandForWebview(CutAction, webview => webview.cut());
+const PreventDefaultContextMenuItemsContextKeyName = 'preventDefaultContextMenuItems';
+if (CutAction) {
+    MenuRegistry.appendMenuItem(MenuId.WebviewContext, {
+        command: {
+            id: CutAction.id,
+            title: ( localize(12276, "Cut")),
+        },
+        group: '5_cutcopypaste',
+        order: 1,
+        when: ContextKeyExpr.not(PreventDefaultContextMenuItemsContextKeyName),
+    });
+}
+if (CopyAction) {
+    MenuRegistry.appendMenuItem(MenuId.WebviewContext, {
+        command: {
+            id: CopyAction.id,
+            title: ( localize(12277, "Copy")),
+        },
+        group: '5_cutcopypaste',
+        order: 2,
+        when: ContextKeyExpr.not(PreventDefaultContextMenuItemsContextKeyName),
+    });
+}
+if (PasteAction) {
+    MenuRegistry.appendMenuItem(MenuId.WebviewContext, {
+        command: {
+            id: PasteAction.id,
+            title: ( localize(12278, "Paste")),
+        },
+        group: '5_cutcopypaste',
+        order: 3,
+        when: ContextKeyExpr.not(PreventDefaultContextMenuItemsContextKeyName),
+    });
+}
+
+export { PreventDefaultContextMenuItemsContextKeyName };

package/vscode/src/vs/workbench/services/textfile/common/textEditorService.d.ts

@@ -0,0 +1,32 @@
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { IFileEditorInput, IUntypedEditorInput, IUntypedFileEditorInput } from "@codingame/monaco-vscode-api/vscode/vs/workbench/common/editor";
+import { EditorInput } from "@codingame/monaco-vscode-api/vscode/vs/workbench/common/editor/editorInput";
+import { IUntitledTextEditorService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/untitled/common/untitledTextEditorService.service";
+import { IUriIdentityService } from "@codingame/monaco-vscode-api/vscode/vs/platform/uriIdentity/common/uriIdentity.service";
+import { IFileService } from "@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service";
+import { IEditorResolverService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorResolverService.service";
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { ITextEditorService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/textfile/common/textEditorService.service";
+export declare class TextEditorService extends Disposable implements ITextEditorService {
+    private readonly untitledTextEditorService;
+    private readonly instantiationService;
+    private readonly uriIdentityService;
+    private readonly fileService;
+    private readonly editorResolverService;
+    readonly _serviceBrand: undefined;
+    private readonly editorInputCache;
+    private readonly fileEditorFactory;
+    constructor(untitledTextEditorService: IUntitledTextEditorService, instantiationService: IInstantiationService, uriIdentityService: IUriIdentityService, fileService: IFileService, editorResolverService: IEditorResolverService);
+    private registerDefaultEditor;
+    resolveTextEditor(input: IUntypedEditorInput): Promise<EditorInput>;
+    resolveTextEditor(input: IUntypedFileEditorInput): Promise<IFileEditorInput>;
+    createTextEditor(input: IUntypedEditorInput): EditorInput;
+    createTextEditor(input: IUntypedFileEditorInput): IFileEditorInput;
+    private createOrGetCached;
+    private static readonly LEAK_TRACKING_THRESHOLD;
+    private static readonly LEAK_REPORTING_THRESHOLD;
+    private static LEAK_REPORTED;
+    private readonly mapLeakToCounter;
+    private trackLeaks;
+    private untrackLeaks;
+}