@codingame/monaco-vscode-api 1.79.0-next.0 → 1.79.1

package/dist/vscode/vs/workbench/contrib/files/browser/views/openEditorsView.js

@@ -0,0 +1,608 @@
+import { __decorate, __param } from '../../../../../../../node_modules/tslib/tslib.es6.js';
+import './media/openeditors.css.js';
+import * as nls from 'monaco-editor/esm/vs/nls.js';
+import { RunOnceScheduler } from 'monaco-editor/esm/vs/base/common/async.js';
+import { ActionRunner } from 'monaco-editor/esm/vs/base/common/actions.js';
+import * as dom from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { IContextMenuService } from 'monaco-editor/esm/vs/platform/contextview/browser/contextView.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { IEditorGroupsService } from '../../../../services/editor/common/editorGroupsService.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { IKeybindingService } from 'monaco-editor/esm/vs/platform/keybinding/common/keybinding.js';
+import { EditorResourceAccessor, SideBySideEditor } from '../../../../common/editor.js';
+import { SaveAllInGroupAction, CloseGroupAction } from '../fileActions.js';
+import { OpenEditor, OpenEditorsFocusedContext, ExplorerFocusedContext } from '../../common/files.js';
+import { CloseEditorAction, UnpinEditorAction } from '../../../../browser/parts/editor/editorActions.js';
+import { IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { IThemeService } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
+import { asCssVariable, badgeBackground, badgeForeground, contrastBorder } from 'monaco-editor/esm/vs/platform/theme/common/colorRegistry.js';
+import { WorkbenchList } from 'monaco-editor/esm/vs/platform/list/browser/listService.js';
+import { ResourceLabels } from '../../../../browser/labels.js';
+import { ActionBar } from 'monaco-editor/esm/vs/base/browser/ui/actionbar/actionbar.js';
+import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
+import { dispose } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { MenuRegistry, MenuId } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
+import { OpenEditorsGroupContext, OpenEditorsDirtyEditorContext, OpenEditorsReadonlyEditorContext } from '../fileConstants.js';
+import { ResourceContextKey } from '../../../../common/contextkeys.js';
+import { containsDragType, CodeDataTransfers } from 'monaco-editor/esm/vs/platform/dnd/browser/dnd.js';
+import { ResourcesDropHandler, fillEditorsDragData } from '../../../../browser/dnd.js';
+import { ViewPane } from '../../../../browser/parts/views/viewPane.js';
+import { DataTransfers } from 'monaco-editor/esm/vs/base/browser/dnd.js';
+import { memoize } from 'monaco-editor/esm/vs/base/common/decorators.js';
+import { NativeDragAndDropData, ElementsDragAndDropData } from 'monaco-editor/esm/vs/base/browser/ui/list/listView.js';
+import { withUndefinedAsNull } from 'monaco-editor/esm/vs/base/common/types.js';
+import { IWorkingCopyService } from '../../../../services/workingCopy/common/workingCopyService.js';
+import { IFilesConfigurationService } from '../../../../services/filesConfiguration/common/filesConfigurationService.js';
+import { IViewDescriptorService } from '../../../../common/views.js';
+import { IOpenerService } from 'monaco-editor/esm/vs/platform/opener/common/opener.js';
+import { compareFileNamesDefault } from 'monaco-editor/esm/vs/base/common/comparers.js';
+import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
+import { extUriIgnorePathCase } from 'monaco-editor/esm/vs/base/common/resources.js';
+const $ = dom.$;
+let OpenEditorsView = class OpenEditorsView extends ViewPane {
+    constructor(options, instantiationService, viewDescriptorService, contextMenuService, editorGroupService, configurationService, keybindingService, contextKeyService, themeService, telemetryService, workingCopyService, filesConfigurationService, openerService) {
+        super(options, keybindingService, contextMenuService, configurationService, contextKeyService, viewDescriptorService, instantiationService, openerService, themeService, telemetryService);
+        this.editorGroupService = editorGroupService;
+        this.workingCopyService = workingCopyService;
+        this.filesConfigurationService = filesConfigurationService;
+        this.needsRefresh = false;
+        this.elements = [];
+        this.structuralRefreshDelay = 0;
+        this.sortOrder = configurationService.getValue('explorer.openEditors.sortOrder');
+        this.registerUpdateEvents();
+        this._register(this.configurationService.onDidChangeConfiguration(e => this.onConfigurationChange(e)));
+        this._register(this.workingCopyService.onDidChangeDirty(workingCopy => this.updateDirtyIndicator(workingCopy)));
+    }
+    registerUpdateEvents() {
+        const updateWholeList = () => {
+            if (!this.isBodyVisible() || !this.list) {
+                this.needsRefresh = true;
+                return;
+            }
+            this.listRefreshScheduler?.schedule(this.structuralRefreshDelay);
+        };
+        const groupDisposables = ( new Map());
+        const addGroupListener = (group) => {
+            const groupModelChangeListener = group.onDidModelChange(e => {
+                if (this.listRefreshScheduler?.isScheduled()) {
+                    return;
+                }
+                if (!this.isBodyVisible() || !this.list) {
+                    this.needsRefresh = true;
+                    return;
+                }
+                const index = this.getIndex(group, e.editor);
+                switch (e.kind) {
+                    case 6 :
+                    case 0 :
+                        this.focusActiveEditor();
+                        break;
+                    case 1 :
+                        if (index >= 0) {
+                            this.list.splice(index, 1, [group]);
+                        }
+                        break;
+                    case 11 :
+                    case 10 :
+                    case 8 :
+                    case 9 :
+                    case 7 :
+                        this.list.splice(index, 1, [( new OpenEditor(e.editor, group))]);
+                        this.focusActiveEditor();
+                        break;
+                    case 3 :
+                    case 5 :
+                    case 4 :
+                        updateWholeList();
+                        break;
+                }
+            });
+            groupDisposables.set(group.id, groupModelChangeListener);
+            this._register(groupDisposables.get(group.id));
+        };
+        this.editorGroupService.groups.forEach(g => addGroupListener(g));
+        this._register(this.editorGroupService.onDidAddGroup(group => {
+            addGroupListener(group);
+            updateWholeList();
+        }));
+        this._register(this.editorGroupService.onDidMoveGroup(() => updateWholeList()));
+        this._register(this.editorGroupService.onDidRemoveGroup(group => {
+            dispose(groupDisposables.get(group.id));
+            updateWholeList();
+        }));
+    }
+    renderHeaderTitle(container) {
+        super.renderHeaderTitle(container, this.title);
+        const count = dom.append(container, $('.count'));
+        this.dirtyCountElement = dom.append(count, $('.dirty-count.monaco-count-badge.long'));
+        this.dirtyCountElement.style.backgroundColor = asCssVariable(badgeBackground);
+        this.dirtyCountElement.style.color = asCssVariable(badgeForeground);
+        this.dirtyCountElement.style.border = `1px solid ${asCssVariable(contrastBorder)}`;
+        this.updateDirtyIndicator();
+    }
+    renderBody(container) {
+        super.renderBody(container);
+        container.classList.add('open-editors');
+        container.classList.add('show-file-icons');
+        const delegate = ( new OpenEditorsDelegate());
+        if (this.list) {
+            this.list.dispose();
+        }
+        if (this.listLabels) {
+            this.listLabels.clear();
+        }
+        this.listLabels = this.instantiationService.createInstance(ResourceLabels, { onDidChangeVisibility: this.onDidChangeBodyVisibility });
+        this.list = this.instantiationService.createInstance(WorkbenchList, 'OpenEditors', container, delegate, [
+            ( new EditorGroupRenderer(this.keybindingService, this.instantiationService)),
+            ( new OpenEditorRenderer(
+                this.listLabels,
+                this.instantiationService,
+                this.keybindingService,
+                this.configurationService
+            ))
+        ], {
+            identityProvider: { getId: (element) => element instanceof OpenEditor ? element.getId() : ( element.id.toString()) },
+            dnd: ( new OpenEditorsDragAndDrop(this.instantiationService, this.editorGroupService)),
+            overrideStyles: {
+                listBackground: this.getBackgroundColor()
+            },
+            accessibilityProvider: ( new OpenEditorsAccessibilityProvider())
+        });
+        this._register(this.list);
+        this._register(this.listLabels);
+        let labelChangeListeners = [];
+        this.listRefreshScheduler = this._register(( new RunOnceScheduler(() => {
+            if (!this.list) {
+                return;
+            }
+            labelChangeListeners = dispose(labelChangeListeners);
+            const previousLength = this.list.length;
+            const elements = this.getElements();
+            this.list.splice(0, this.list.length, elements);
+            this.focusActiveEditor();
+            if (previousLength !== this.list.length) {
+                this.updateSize();
+            }
+            this.needsRefresh = false;
+            if (this.sortOrder === 'alphabetical' || this.sortOrder === 'fullPath') {
+                elements.forEach(e => {
+                    if (e instanceof OpenEditor) {
+                        labelChangeListeners.push(e.editor.onDidChangeLabel(() => this.listRefreshScheduler?.schedule()));
+                    }
+                });
+            }
+        }, this.structuralRefreshDelay)));
+        this.updateSize();
+        OpenEditorsFocusedContext.bindTo(this.list.contextKeyService);
+        ExplorerFocusedContext.bindTo(this.list.contextKeyService);
+        this.resourceContext = this.instantiationService.createInstance(ResourceContextKey);
+        this._register(this.resourceContext);
+        this.groupFocusedContext = OpenEditorsGroupContext.bindTo(this.contextKeyService);
+        this.dirtyEditorFocusedContext = OpenEditorsDirtyEditorContext.bindTo(this.contextKeyService);
+        this.readonlyEditorFocusedContext = OpenEditorsReadonlyEditorContext.bindTo(this.contextKeyService);
+        this._register(this.list.onContextMenu(e => this.onListContextMenu(e)));
+        this.list.onDidChangeFocus(e => {
+            this.resourceContext.reset();
+            this.groupFocusedContext.reset();
+            this.dirtyEditorFocusedContext.reset();
+            this.readonlyEditorFocusedContext.reset();
+            const element = e.elements.length ? e.elements[0] : undefined;
+            if (element instanceof OpenEditor) {
+                const resource = element.getResource();
+                this.dirtyEditorFocusedContext.set(element.editor.isDirty() && !element.editor.isSaving());
+                this.readonlyEditorFocusedContext.set(element.editor.hasCapability(2 ));
+                this.resourceContext.set(withUndefinedAsNull(resource));
+            }
+            else if (!!element) {
+                this.groupFocusedContext.set(true);
+            }
+        });
+        this._register(this.list.onMouseMiddleClick(e => {
+            if (e && e.element instanceof OpenEditor) {
+                e.element.group.closeEditor(e.element.editor, { preserveFocus: true });
+            }
+        }));
+        this._register(this.list.onDidOpen(e => {
+            if (!e.element) {
+                return;
+            }
+            else if (e.element instanceof OpenEditor) {
+                if (e.browserEvent instanceof MouseEvent && e.browserEvent.button === 1) {
+                    return;
+                }
+                this.openEditor(e.element, { preserveFocus: e.editorOptions.preserveFocus, pinned: e.editorOptions.pinned, sideBySide: e.sideBySide });
+            }
+            else {
+                this.editorGroupService.activateGroup(e.element);
+            }
+        }));
+        this.listRefreshScheduler.schedule(0);
+        this._register(this.onDidChangeBodyVisibility(visible => {
+            if (visible && this.needsRefresh) {
+                this.listRefreshScheduler?.schedule(0);
+            }
+        }));
+        const containerModel = this.viewDescriptorService.getViewContainerModel(this.viewDescriptorService.getViewContainerByViewId(this.id));
+        this._register(containerModel.onDidChangeAllViewDescriptors(() => {
+            this.updateSize();
+        }));
+    }
+    focus() {
+        super.focus();
+        this.list.domFocus();
+    }
+    getList() {
+        return this.list;
+    }
+    layoutBody(height, width) {
+        super.layoutBody(height, width);
+        this.list?.layout(height, width);
+    }
+    get showGroups() {
+        return this.editorGroupService.groups.length > 1;
+    }
+    getElements() {
+        this.elements = [];
+        this.editorGroupService.getGroups(2 ).forEach(g => {
+            if (this.showGroups) {
+                this.elements.push(g);
+            }
+            let editors = ( g.editors.map(ei => ( new OpenEditor(ei, g))));
+            if (this.sortOrder === 'alphabetical') {
+                editors = editors.sort((first, second) => compareFileNamesDefault(first.editor.getName(), second.editor.getName()));
+            }
+            else if (this.sortOrder === 'fullPath') {
+                editors = editors.sort((first, second) => {
+                    const firstResource = first.editor.resource;
+                    const secondResource = second.editor.resource;
+                    if (firstResource === undefined && secondResource === undefined) {
+                        return compareFileNamesDefault(first.editor.getName(), second.editor.getName());
+                    }
+                    else if (firstResource === undefined) {
+                        return -1;
+                    }
+                    else if (secondResource === undefined) {
+                        return 1;
+                    }
+                    else {
+                        const firstScheme = firstResource.scheme;
+                        const secondScheme = secondResource.scheme;
+                        if (firstScheme !== Schemas.file && secondScheme !== Schemas.file) {
+                            return extUriIgnorePathCase.compare(firstResource, secondResource);
+                        }
+                        else if (firstScheme !== Schemas.file) {
+                            return -1;
+                        }
+                        else if (secondScheme !== Schemas.file) {
+                            return 1;
+                        }
+                        else {
+                            return extUriIgnorePathCase.compare(firstResource, secondResource);
+                        }
+                    }
+                });
+            }
+            this.elements.push(...editors);
+        });
+        return this.elements;
+    }
+    getIndex(group, editor) {
+        if (!editor) {
+            return this.elements.findIndex(e => !(e instanceof OpenEditor) && e.id === group.id);
+        }
+        return this.elements.findIndex(e => e instanceof OpenEditor && e.editor === editor && e.group.id === group.id);
+    }
+    openEditor(element, options) {
+        if (element) {
+            this.telemetryService.publicLog2('workbenchActionExecuted', { id: 'workbench.files.openFile', from: 'openEditors' });
+            const preserveActivateGroup = options.sideBySide && options.preserveFocus;
+            if (!preserveActivateGroup) {
+                this.editorGroupService.activateGroup(element.group);
+            }
+            const targetGroup = options.sideBySide ? this.editorGroupService.sideGroup : this.editorGroupService.activeGroup;
+            targetGroup.openEditor(element.editor, options);
+        }
+    }
+    onListContextMenu(e) {
+        if (!e.element) {
+            return;
+        }
+        const element = e.element;
+        this.contextMenuService.showContextMenu({
+            menuId: MenuId.OpenEditorsContext,
+            menuActionOptions: { shouldForwardArgs: true, arg: element instanceof OpenEditor ? EditorResourceAccessor.getOriginalUri(element.editor) : {} },
+            contextKeyService: this.list.contextKeyService,
+            getAnchor: () => e.anchor,
+            getActionsContext: () => element instanceof OpenEditor ? { groupId: element.groupId, editorIndex: element.group.getIndexOfEditor(element.editor) } : { groupId: element.id }
+        });
+    }
+    focusActiveEditor() {
+        if (this.list.length && this.editorGroupService.activeGroup) {
+            const index = this.getIndex(this.editorGroupService.activeGroup, this.editorGroupService.activeGroup.activeEditor);
+            if (index >= 0) {
+                try {
+                    this.list.setFocus([index]);
+                    this.list.setSelection([index]);
+                    this.list.reveal(index);
+                }
+                catch (e) {
+                }
+                return;
+            }
+        }
+        this.list.setFocus([]);
+        this.list.setSelection([]);
+    }
+    onConfigurationChange(event) {
+        if (event.affectsConfiguration('explorer.openEditors')) {
+            this.updateSize();
+        }
+        if (event.affectsConfiguration('explorer.decorations') || event.affectsConfiguration('explorer.openEditors.sortOrder')) {
+            this.sortOrder = this.configurationService.getValue('explorer.openEditors.sortOrder');
+            this.listRefreshScheduler?.schedule();
+        }
+    }
+    updateSize() {
+        this.minimumBodySize = this.orientation === 0  ? this.getMinExpandedBodySize() : 170;
+        this.maximumBodySize = this.orientation === 0  ? this.getMaxExpandedBodySize() : Number.POSITIVE_INFINITY;
+    }
+    updateDirtyIndicator(workingCopy) {
+        if (workingCopy) {
+            const gotDirty = workingCopy.isDirty();
+            if (gotDirty && !((workingCopy.capabilities & 2) ) && this.filesConfigurationService.getAutoSaveMode() === 1 ) {
+                return;
+            }
+        }
+        const dirty = this.workingCopyService.dirtyCount;
+        if (dirty === 0) {
+            this.dirtyCountElement.classList.add('hidden');
+        }
+        else {
+            this.dirtyCountElement.textContent = ( nls.localize('dirtyCounter', "{0} unsaved", dirty));
+            this.dirtyCountElement.classList.remove('hidden');
+        }
+    }
+    get elementCount() {
+        return ( this.editorGroupService.groups.map(g => g.count))
+            .reduce((first, second) => first + second, this.showGroups ? this.editorGroupService.groups.length : 0);
+    }
+    getMaxExpandedBodySize() {
+        let minVisibleOpenEditors = this.configurationService.getValue('explorer.openEditors.minVisible');
+        if (typeof minVisibleOpenEditors !== 'number') {
+            minVisibleOpenEditors = OpenEditorsView.DEFAULT_MIN_VISIBLE_OPEN_EDITORS;
+        }
+        const containerModel = this.viewDescriptorService.getViewContainerModel(this.viewDescriptorService.getViewContainerByViewId(this.id));
+        if (containerModel.visibleViewDescriptors.length <= 1) {
+            return Number.POSITIVE_INFINITY;
+        }
+        return (Math.max(this.elementCount, minVisibleOpenEditors)) * OpenEditorsDelegate.ITEM_HEIGHT;
+    }
+    getMinExpandedBodySize() {
+        let visibleOpenEditors = this.configurationService.getValue('explorer.openEditors.visible');
+        if (typeof visibleOpenEditors !== 'number') {
+            visibleOpenEditors = OpenEditorsView.DEFAULT_VISIBLE_OPEN_EDITORS;
+        }
+        return this.computeMinExpandedBodySize(visibleOpenEditors);
+    }
+    computeMinExpandedBodySize(visibleOpenEditors = OpenEditorsView.DEFAULT_VISIBLE_OPEN_EDITORS) {
+        const itemsToShow = Math.min(Math.max(visibleOpenEditors, 1), this.elementCount);
+        return itemsToShow * OpenEditorsDelegate.ITEM_HEIGHT;
+    }
+    setStructuralRefreshDelay(delay) {
+        this.structuralRefreshDelay = delay;
+    }
+    getOptimalWidth() {
+        const parentNode = this.list.getHTMLElement();
+        const childNodes = [].slice.call(parentNode.querySelectorAll('.open-editor > a'));
+        return dom.getLargestChildWidth(parentNode, childNodes);
+    }
+};
+OpenEditorsView.DEFAULT_VISIBLE_OPEN_EDITORS = 9;
+OpenEditorsView.DEFAULT_MIN_VISIBLE_OPEN_EDITORS = 0;
+OpenEditorsView.ID = 'workbench.explorer.openEditorsView';
+OpenEditorsView.NAME = ( nls.localize({ key: 'openEditors', comment: ['Open is an adjective'] }, "Open Editors"));
+OpenEditorsView = ( __decorate([
+    ( __param(1, IInstantiationService)),
+    ( __param(2, IViewDescriptorService)),
+    ( __param(3, IContextMenuService)),
+    ( __param(4, IEditorGroupsService)),
+    ( __param(5, IConfigurationService)),
+    ( __param(6, IKeybindingService)),
+    ( __param(7, IContextKeyService)),
+    ( __param(8, IThemeService)),
+    ( __param(9, ITelemetryService)),
+    ( __param(10, IWorkingCopyService)),
+    ( __param(11, IFilesConfigurationService)),
+    ( __param(12, IOpenerService))
+], OpenEditorsView));
+class OpenEditorActionRunner extends ActionRunner {
+    async run(action) {
+        if (!this.editor) {
+            return;
+        }
+        return super.run(action, { groupId: this.editor.groupId, editorIndex: this.editor.group.getIndexOfEditor(this.editor.editor) });
+    }
+}
+class OpenEditorsDelegate {
+    getHeight(_element) {
+        return OpenEditorsDelegate.ITEM_HEIGHT;
+    }
+    getTemplateId(element) {
+        if (element instanceof OpenEditor) {
+            return OpenEditorRenderer.ID;
+        }
+        return EditorGroupRenderer.ID;
+    }
+}
+OpenEditorsDelegate.ITEM_HEIGHT = 22;
+class EditorGroupRenderer {
+    constructor(keybindingService, instantiationService) {
+        this.keybindingService = keybindingService;
+        this.instantiationService = instantiationService;
+    }
+    get templateId() {
+        return EditorGroupRenderer.ID;
+    }
+    renderTemplate(container) {
+        const editorGroupTemplate = Object.create(null);
+        editorGroupTemplate.root = dom.append(container, $('.editor-group'));
+        editorGroupTemplate.name = dom.append(editorGroupTemplate.root, $('span.name'));
+        editorGroupTemplate.actionBar = ( new ActionBar(container));
+        const saveAllInGroupAction = this.instantiationService.createInstance(SaveAllInGroupAction, SaveAllInGroupAction.ID, SaveAllInGroupAction.LABEL);
+        const saveAllInGroupKey = this.keybindingService.lookupKeybinding(saveAllInGroupAction.id);
+        editorGroupTemplate.actionBar.push(saveAllInGroupAction, { icon: true, label: false, keybinding: saveAllInGroupKey ? saveAllInGroupKey.getLabel() : undefined });
+        const closeGroupAction = this.instantiationService.createInstance(CloseGroupAction, CloseGroupAction.ID, CloseGroupAction.LABEL);
+        const closeGroupActionKey = this.keybindingService.lookupKeybinding(closeGroupAction.id);
+        editorGroupTemplate.actionBar.push(closeGroupAction, { icon: true, label: false, keybinding: closeGroupActionKey ? closeGroupActionKey.getLabel() : undefined });
+        return editorGroupTemplate;
+    }
+    renderElement(editorGroup, _index, templateData) {
+        templateData.editorGroup = editorGroup;
+        templateData.name.textContent = editorGroup.label;
+        templateData.actionBar.context = { groupId: editorGroup.id };
+    }
+    disposeTemplate(templateData) {
+        templateData.actionBar.dispose();
+    }
+}
+EditorGroupRenderer.ID = 'editorgroup';
+class OpenEditorRenderer {
+    constructor(labels, instantiationService, keybindingService, configurationService) {
+        this.labels = labels;
+        this.instantiationService = instantiationService;
+        this.keybindingService = keybindingService;
+        this.configurationService = configurationService;
+        this.closeEditorAction = this.instantiationService.createInstance(CloseEditorAction, CloseEditorAction.ID, CloseEditorAction.LABEL);
+        this.unpinEditorAction = this.instantiationService.createInstance(UnpinEditorAction, UnpinEditorAction.ID, UnpinEditorAction.LABEL);
+    }
+    get templateId() {
+        return OpenEditorRenderer.ID;
+    }
+    renderTemplate(container) {
+        const editorTemplate = Object.create(null);
+        editorTemplate.container = container;
+        editorTemplate.actionRunner = ( new OpenEditorActionRunner());
+        editorTemplate.actionBar = ( new ActionBar(container, { actionRunner: editorTemplate.actionRunner }));
+        editorTemplate.root = this.labels.create(container);
+        return editorTemplate;
+    }
+    renderElement(openedEditor, _index, templateData) {
+        const editor = openedEditor.editor;
+        templateData.actionRunner.editor = openedEditor;
+        templateData.container.classList.toggle('dirty', editor.isDirty() && !editor.isSaving());
+        templateData.container.classList.toggle('sticky', openedEditor.isSticky());
+        templateData.root.setResource({
+            resource: EditorResourceAccessor.getOriginalUri(editor, { supportSideBySide: SideBySideEditor.BOTH }),
+            name: editor.getName(),
+            description: editor.getDescription(1 )
+        }, {
+            italic: openedEditor.isPreview(),
+            extraClasses: ['open-editor'].concat(openedEditor.editor.getLabelExtraClasses()),
+            fileDecorations: this.configurationService.getValue().explorer.decorations,
+            title: editor.getTitle(2 )
+        });
+        const editorAction = openedEditor.isSticky() ? this.unpinEditorAction : this.closeEditorAction;
+        if (!templateData.actionBar.hasAction(editorAction)) {
+            if (!templateData.actionBar.isEmpty()) {
+                templateData.actionBar.clear();
+            }
+            templateData.actionBar.push(editorAction, { icon: true, label: false, keybinding: this.keybindingService.lookupKeybinding(editorAction.id)?.getLabel() });
+        }
+    }
+    disposeTemplate(templateData) {
+        templateData.actionBar.dispose();
+        templateData.root.dispose();
+        templateData.actionRunner.dispose();
+    }
+}
+OpenEditorRenderer.ID = 'openeditor';
+class OpenEditorsDragAndDrop {
+    constructor(instantiationService, editorGroupService) {
+        this.instantiationService = instantiationService;
+        this.editorGroupService = editorGroupService;
+    }
+    get dropHandler() {
+        return this.instantiationService.createInstance(ResourcesDropHandler, { allowWorkspaceOpen: false });
+    }
+    getDragURI(element) {
+        if (element instanceof OpenEditor) {
+            const resource = element.getResource();
+            if (resource) {
+                return ( resource.toString());
+            }
+        }
+        return null;
+    }
+    getDragLabel(elements) {
+        if (elements.length > 1) {
+            return String(elements.length);
+        }
+        const element = elements[0];
+        return element instanceof OpenEditor ? element.editor.getName() : element.label;
+    }
+    onDragStart(data, originalEvent) {
+        const items = data.elements;
+        const editors = [];
+        if (items) {
+            for (const item of items) {
+                if (item instanceof OpenEditor) {
+                    editors.push(item);
+                }
+            }
+        }
+        if (editors.length) {
+            this.instantiationService.invokeFunction(fillEditorsDragData, editors, originalEvent);
+        }
+    }
+    onDragOver(data, _targetElement, _targetIndex, originalEvent) {
+        if (data instanceof NativeDragAndDropData) {
+            return containsDragType(originalEvent, DataTransfers.FILES, CodeDataTransfers.FILES);
+        }
+        return true;
+    }
+    drop(data, targetElement, _targetIndex, originalEvent) {
+        const group = targetElement instanceof OpenEditor ? targetElement.group : targetElement || this.editorGroupService.groups[this.editorGroupService.count - 1];
+        const index = targetElement instanceof OpenEditor ? targetElement.group.getIndexOfEditor(targetElement.editor) : 0;
+        if (data instanceof ElementsDragAndDropData) {
+            const elementsData = data.elements;
+            elementsData.forEach((oe, offset) => {
+                oe.group.moveEditor(oe.editor, group, { index: index + offset, preserveFocus: true });
+            });
+            this.editorGroupService.activateGroup(group);
+        }
+        else {
+            this.dropHandler.handleDrop(originalEvent, () => group, () => group.focus(), index);
+        }
+    }
+}
+OpenEditorsDragAndDrop.__decorator = ( __decorate([
+    memoize
+], OpenEditorsDragAndDrop.prototype, "dropHandler", null));
+class OpenEditorsAccessibilityProvider {
+    getWidgetAriaLabel() {
+        return ( nls.localize('openEditors', "Open Editors"));
+    }
+    getAriaLabel(element) {
+        if (element instanceof OpenEditor) {
+            return `${element.editor.getName()}, ${element.editor.getDescription()}`;
+        }
+        return element.ariaLabel;
+    }
+}
+const toggleEditorGroupLayoutId = 'workbench.action.toggleEditorGroupLayout';
+MenuRegistry.appendMenuItem(MenuId.MenubarLayoutMenu, {
+    group: '4_flip',
+    command: {
+        id: toggleEditorGroupLayoutId,
+        title: {
+            original: 'Flip Layout',
+            value: ( nls.localize('miToggleEditorLayoutWithoutMnemonic', "Flip Layout")),
+            mnemonicTitle: ( nls.localize(
+                { key: 'miToggleEditorLayout', comment: ['&& denotes a mnemonic'] },
+                "Flip &&Layout"
+            ))
+        }
+    },
+    order: 1
+});
+export { OpenEditorsView };

package/dist/vscode/vs/workbench/contrib/files/common/files.js

@@ -68,6 +68,7 @@ const OpenEditorsVisibleContext = ( new RawContextKey(
     false,
     { type: 'boolean', description: ( localize('openEditorsVisible', "True when the OPEN EDITORS view is visible.")) }
 ));
+const OpenEditorsFocusedContext = ( new RawContextKey('openEditorsFocus', true, { type: 'boolean', description: ( localize('openEditorsFocus', "True when the focus is inside the OPEN EDITORS view.")) }));
 const ExplorerFocusedContext = ( new RawContextKey(
     'explorerViewletFocus',
     true,
@@ -220,4 +221,4 @@ class OpenEditor {
     }
 }
 OpenEditor.COUNTER = 0;
-export { BINARY_FILE_EDITOR_ID, BINARY_TEXT_FILE_MODE, ExplorerCompressedFirstFocusContext, ExplorerCompressedFocusContext, ExplorerCompressedLastFocusContext, ExplorerFocusCondition, ExplorerFocusedContext, ExplorerFolderContext, ExplorerResourceAvailableEditorIdsContext, ExplorerResourceCut, ExplorerResourceMoveableToTrash, ExplorerResourceNotReadonlyContext, ExplorerResourceReadonlyContext, ExplorerRootContext, ExplorerViewletVisibleContext, FILE_EDITOR_INPUT_ID, FilesExplorerFocusCondition, FilesExplorerFocusedContext, FoldersViewVisibleContext, OpenEditor, OpenEditorsVisibleContext, TEXT_FILE_EDITOR_ID, TextFileContentProvider, VIEWLET_ID, VIEW_ID, ViewHasSomeCollapsibleRootItemContext };
+export { BINARY_FILE_EDITOR_ID, BINARY_TEXT_FILE_MODE, ExplorerCompressedFirstFocusContext, ExplorerCompressedFocusContext, ExplorerCompressedLastFocusContext, ExplorerFocusCondition, ExplorerFocusedContext, ExplorerFolderContext, ExplorerResourceAvailableEditorIdsContext, ExplorerResourceCut, ExplorerResourceMoveableToTrash, ExplorerResourceNotReadonlyContext, ExplorerResourceReadonlyContext, ExplorerRootContext, ExplorerViewletVisibleContext, FILE_EDITOR_INPUT_ID, FilesExplorerFocusCondition, FilesExplorerFocusedContext, FoldersViewVisibleContext, OpenEditor, OpenEditorsFocusedContext, OpenEditorsVisibleContext, TEXT_FILE_EDITOR_ID, TextFileContentProvider, VIEWLET_ID, VIEW_ID, ViewHasSomeCollapsibleRootItemContext };

package/dist/vscode/vs/workbench/contrib/interactiveSession/browser/interactiveSessionInputPart.js

@@ -5,7 +5,7 @@ import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
 import { HistoryNavigator } from 'monaco-editor/esm/vs/base/common/history.js';
 import { Disposable, DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
 import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
-import "../../../../../../assets/interactiveSession.css";
+import './media/interactiveSession.css.js';
 import { CodeEditorWidget } from 'monaco-editor/esm/vs/editor/browser/widget/codeEditorWidget.js';
 import { IModelService } from 'monaco-editor/esm/vs/editor/common/services/model.js';
 import { localize } from 'monaco-editor/esm/vs/nls.js';

package/dist/vscode/vs/workbench/contrib/interactiveSession/browser/interactiveSessionWidget.js

@@ -3,7 +3,7 @@ import * as dom from 'monaco-editor/esm/vs/base/browser/dom.js';
 import { CancellationToken } from 'monaco-editor/esm/vs/base/common/cancellation.js';
 import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
 import { Disposable, DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import "../../../../../../assets/interactiveSession.css";
+import './media/interactiveSession.css.js';
 import { localize } from 'monaco-editor/esm/vs/nls.js';
 import { MenuId } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
 import { IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';

package/dist/vscode/vs/workbench/contrib/interactiveSession/browser/media/interactiveSession.css.js

@@ -0,0 +1,4 @@
+import n from '../../../../../../../node_modules/rollup-plugin-styles/dist/runtime/inject-css.js';
+var css = ".editor-instance .interactive-session{margin:auto;max-width:600px}.interactive-list .monaco-list-row .monaco-tl-twistie{display:none!important}.interactive-item-container{cursor:default;display:flex;flex-direction:column;gap:6px;padding:16px 20px 0;user-select:text;-webkit-user-select:text}.interactive-item-container .header{align-items:center;display:flex;justify-content:space-between}.interactive-item-container .header .user{align-items:center;display:flex;gap:6px}.interactive-item-container .header .username{font-size:12px;font-weight:600;margin:0}.interactive-item-container .header .avatar{align-items:center;background:var(--vscode-badge-background);border-radius:50%;display:flex;height:24px;justify-content:center;pointer-events:none;user-select:none;width:24px}.interactive-item-container .header .avatar .icon{border-radius:50%;height:24px;width:24px}.interactive-item-container .header .avatar .codicon{color:var(--vscode-badge-foreground)!important}.interactive-item-container .header .monaco-toolbar{display:none}.interactive-item-container.interactive-response:hover .header .monaco-toolbar{display:initial}.interactive-item-container .header .monaco-toolbar .action-label{border:1px solid transparent;padding:2px}.interactive-item-container .header .monaco-toolbar .checked .action-label,.interactive-item-container .header .monaco-toolbar .checked .action-label:hover{background-color:var(--vscode-inputOption-activeBackground);border-color:var(--vscode-inputOption-activeBorder);color:var(--vscode-inputOption-activeForeground)!important}.interactive-item-container .value{width:100%}.interactive-item-container .value table{margin-bottom:16px;text-align:left;width:100%}.interactive-item-container .value table,.interactive-item-container .value table td,.interactive-item-container .value table th{border:1px solid var(--vscode-interactive-requestBorder);border-collapse:collapse;padding:4px 6px}.interactive-item-container .value a{color:var(--vscode-textLink-foreground)}.interactive-item-container .value a:active,.interactive-item-container .value a:hover{color:var(--vscode-textLink-activeForeground)}.interactive-list{overflow:hidden}.interactive-request{background-color:var(--vscode-interactive-requestBackground);border-bottom:1px solid var(--vscode-interactive-requestBorder);border-top:1px solid var(--vscode-interactive-requestBorder)}.interactive-item-container .value{word-wrap:break-word;min-height:36px;white-space:normal}.interactive-item-container .value>:last-child:not(.rendered-markdown){margin-bottom:16px}.interactive-item-container .value>.interactive-response-error-details:not(:last-child){margin-bottom:8px}.interactive-item-container .value h1{font-size:20px;font-weight:600;margin:16px 0}.interactive-item-container .value h2{font-size:16px;font-weight:600;margin:16px 0}.interactive-item-container .value h3{font-size:14px;font-weight:600;margin:16px 0}.interactive-item-container .value p{line-height:1.6em;margin:0 0 16px}.interactive-item-container .monaco-tokenized-source,.interactive-item-container code{color:var(--vscode-textPreformat-foreground);font-family:var(--monaco-monospace-font)}.interactive-session .interactive-input-and-toolbar{background-color:var(--vscode-input-background);border:1px solid var(--vscode-input-border,transparent);border-radius:4px;box-sizing:border-box;cursor:text;display:flex;margin:0 12px;padding-left:8px;position:relative}.interactive-session .interactive-input-and-toolbar.focused{border-color:var(--vscode-focusBorder)}.interactive-session .interactive-input-and-toolbar .monaco-editor,.interactive-session .interactive-input-and-toolbar .monaco-editor .monaco-editor-background{background-color:var(--vscode-input-background)!important}.interactive-session .interactive-input-and-toolbar .monaco-editor .cursors-layer{padding-left:4px}.interactive-session .interactive-input-part .interactive-execute-toolbar{bottom:6px;height:22px;position:absolute;right:3px}.interactive-session .interactive-input-part .interactive-execute-toolbar .codicon-debug-stop{color:var(--vscode-icon-foreground)!important}.interactive-item-container .interactive-result-editor-wrapper{position:relative}.interactive-item-container .interactive-result-editor-wrapper .monaco-toolbar{background-color:var(--vscode-interactive-result-editor-background-color,var(--vscode-editor-background));border:1px solid var(--vscode-interactive-requestBorder);display:none;height:26px;position:absolute;right:10px;top:-13px;z-index:100}.interactive-item-container .interactive-result-editor-wrapper .monaco-toolbar .action-item{height:24px;margin:1px 2px;width:24px}.interactive-item-container .interactive-result-editor-wrapper .monaco-toolbar .action-item .codicon{margin:1px}.interactive-item-container .interactive-result-editor-wrapper:hover .monaco-toolbar{display:initial}.interactive-item-container .interactive-result-editor-wrapper .interactive-result-editor{border:1px solid var(--vscode-input-border,transparent)}.interactive-response .monaco-editor .margin,.interactive-response .monaco-editor .monaco-editor-background{background-color:var(--vscode-interactive-result-editor-background-color)}.interactive-item-container .interactive-result-editor-wrapper{margin:16px 0}.interactive-response .interactive-response-error-details{align-items:start;display:flex;gap:6px}.interactive-response .interactive-response-error-details .codicon{margin-top:1px}.interactive-response .interactive-response-error-details .codicon-error{color:var(--vscode-errorForeground)!important}.interactive-response .interactive-response-error-details .codicon-info{color:var(--vscode-notificationsInfoIcon-foreground)!important}.interactive-item-container .value .interactive-slash-command{color:var(--vscode-textLink-foreground)}.interactive-session .interactive-input-part{border-top:1px solid var(--vscode-interactive-requestBorder);display:flex;flex-direction:column;padding:12px 0}.interactive-session-followups{align-items:start;display:flex;flex-direction:column;gap:5px}.interactive-session-followups .monaco-button{text-align:left;width:auto}.interactive-session-followups .monaco-button .codicon{margin-left:0;margin-top:1px}.interactive-item-container .interactive-response-followups .monaco-button{padding:4px 8px}.interactive-session .interactive-input-part .interactive-input-followups{margin:0 20px}.interactive-session .interactive-input-part .interactive-input-followups .interactive-session-followups{margin-bottom:8px}.interactive-session .interactive-input-part .interactive-input-followups .interactive-session-followups .monaco-button{color:var(--vscode-textLink-foreground);display:block}.interactive-session .interactive-input-part .interactive-input-followups .interactive-session-followups code{font-family:var(--monaco-monospace-font)}.interactive-session .interactive-input-part .interactive-input-followups .interactive-session-followups .monaco-button .codicon-sparkle{float:left}.interactive-session-followups .monaco-button.interactive-followup-reply{border:none;font-size:11px;font-weight:600;padding:0}.interactive-welcome .value .interactive-session-followups{margin-bottom:10px}.interactive-item-container .monaco-toolbar .codicon{color:var(--vscode-icon-foreground)!important}.interactive-item-container.filtered-response .value .rendered-markdown{-webkit-mask-image:linear-gradient(rgba(0,0,0,.85),rgba(0,0,0,.05));mask-image:linear-gradient(rgba(0,0,0,.85),rgba(0,0,0,.05))}";
+n(css,{});
+export { css, css as default };