@codingame/monaco-vscode-extensions-service-override 1.83.7 → 1.83.9

package/vscode/src/vs/workbench/api/browser/mainThreadEditorTabs.js

@@ -0,0 +1,475 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { MainContext, ExtHostContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
+import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
+import { EditorResourceAccessor, SideBySideEditor } from 'vscode/vscode/vs/workbench/common/editor';
+import { DiffEditorInput } from 'vscode/vscode/vs/workbench/common/editor/diffEditorInput';
+import { editorGroupToColumn, columnToEditorGroup } from 'vscode/vscode/vs/workbench/services/editor/common/editorGroupColumn';
+import { IEditorGroupsService, preferredSideBySideGroupDirection } from 'vscode/vscode/vs/workbench/services/editor/common/editorGroupsService';
+import { IEditorService, SIDE_GROUP } from 'vscode/vscode/vs/workbench/services/editor/common/editorService';
+import { AbstractTextResourceEditorInput } from 'vscode/vscode/vs/workbench/common/editor/textResourceEditorInput';
+import { NotebookEditorInput } from '../../../../../../override/vs/workbench/contrib/notebook/common/notebookEditorInput.js';
+import { CustomEditorInput } from 'vscode/vscode/vs/workbench/contrib/customEditor/browser/customEditorInput';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { WebviewInput } from 'vscode/vscode/vs/workbench/contrib/webviewPanel/browser/webviewEditorInput';
+import { TerminalEditorInput } from 'vscode/vscode/vs/workbench/contrib/terminal/browser/terminalEditorInput';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { SideBySideEditorInput } from 'vscode/vscode/vs/workbench/common/editor/sideBySideEditorInput';
+import { isEqual } from 'monaco-editor/esm/vs/base/common/resources.js';
+import { isGroupEditorMoveEvent } from 'vscode/vscode/vs/workbench/common/editor/editorGroupModel';
+import { InteractiveEditorInput } from '../../contrib/interactive/browser/interactiveEditorInput.js';
+import { MergeEditorInput } from '../../contrib/mergeEditor/browser/mergeEditorInput.js';
+import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+
+let MainThreadEditorTabs = class MainThreadEditorTabs {
+    constructor(extHostContext, _editorGroupsService, _configurationService, _logService, editorService) {
+        this._editorGroupsService = _editorGroupsService;
+        this._configurationService = _configurationService;
+        this._logService = _logService;
+        this._dispoables = ( new DisposableStore());
+        this._tabGroupModel = [];
+        this._groupLookup = ( new Map());
+        this._tabInfoLookup = ( new Map());
+        this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostEditorTabs));
+        this._dispoables.add(editorService.onDidEditorsChange((event) => {
+            try {
+                this._updateTabsModel(event);
+            }
+            catch {
+                this._logService.error('Failed to update model, rebuilding');
+                this._createTabsModel();
+            }
+        }));
+        this._dispoables.add(this._editorGroupsService.onDidAddGroup(() => this._createTabsModel()));
+        this._dispoables.add(this._editorGroupsService.onDidRemoveGroup(() => this._createTabsModel()));
+        this._editorGroupsService.whenReady.then(() => this._createTabsModel());
+    }
+    dispose() {
+        this._groupLookup.clear();
+        this._tabInfoLookup.clear();
+        this._dispoables.dispose();
+    }
+    _buildTabObject(group, editor, editorIndex) {
+        const editorId = editor.editorId;
+        const tab = {
+            id: this._generateTabId(editor, group.id),
+            label: editor.getName(),
+            editorId,
+            input: this._editorInputToDto(editor),
+            isPinned: group.isSticky(editorIndex),
+            isPreview: !group.isPinned(editorIndex),
+            isActive: group.isActive(editor),
+            isDirty: editor.isDirty()
+        };
+        return tab;
+    }
+    _editorInputToDto(editor) {
+        if (editor instanceof MergeEditorInput) {
+            return {
+                kind: 3 ,
+                base: editor.base,
+                input1: editor.input1.uri,
+                input2: editor.input2.uri,
+                result: editor.resource
+            };
+        }
+        if (editor instanceof AbstractTextResourceEditorInput) {
+            return {
+                kind: 1 ,
+                uri: editor.resource
+            };
+        }
+        if (editor instanceof SideBySideEditorInput && !(editor instanceof DiffEditorInput)) {
+            const primaryResource = editor.primary.resource;
+            const secondaryResource = editor.secondary.resource;
+            if (editor.primary instanceof AbstractTextResourceEditorInput
+                && editor.secondary instanceof AbstractTextResourceEditorInput
+                && isEqual(primaryResource, secondaryResource)
+                && primaryResource
+                && secondaryResource) {
+                return {
+                    kind: 1 ,
+                    uri: primaryResource
+                };
+            }
+            return { kind: 0  };
+        }
+        if (editor instanceof NotebookEditorInput) {
+            return {
+                kind: 4 ,
+                notebookType: editor.viewType,
+                uri: editor.resource
+            };
+        }
+        if (editor instanceof CustomEditorInput) {
+            return {
+                kind: 6 ,
+                viewType: editor.viewType,
+                uri: editor.resource,
+            };
+        }
+        if (editor instanceof WebviewInput) {
+            return {
+                kind: 7 ,
+                viewType: editor.viewType
+            };
+        }
+        if (editor instanceof TerminalEditorInput) {
+            return {
+                kind: 8
+            };
+        }
+        if (editor instanceof DiffEditorInput) {
+            if (editor.modified instanceof AbstractTextResourceEditorInput && editor.original instanceof AbstractTextResourceEditorInput) {
+                return {
+                    kind: 2 ,
+                    modified: editor.modified.resource,
+                    original: editor.original.resource
+                };
+            }
+            if (editor.modified instanceof NotebookEditorInput && editor.original instanceof NotebookEditorInput) {
+                return {
+                    kind: 5 ,
+                    notebookType: editor.original.viewType,
+                    modified: editor.modified.resource,
+                    original: editor.original.resource
+                };
+            }
+        }
+        if (editor instanceof InteractiveEditorInput) {
+            return {
+                kind: 9 ,
+                uri: editor.resource,
+                inputBoxUri: editor.inputResource
+            };
+        }
+        return { kind: 0  };
+    }
+    _generateTabId(editor, groupId) {
+        let resourceString;
+        const resource = EditorResourceAccessor.getCanonicalUri(editor, { supportSideBySide: SideBySideEditor.BOTH });
+        if (resource instanceof URI) {
+            resourceString = ( resource.toString());
+        }
+        else {
+            resourceString = `${resource?.primary?.toString()}-${resource?.secondary?.toString()}`;
+        }
+        return `${groupId}~${editor.editorId}-${editor.typeId}-${resourceString} `;
+    }
+    _onDidGroupActivate() {
+        const activeGroupId = this._editorGroupsService.activeGroup.id;
+        const activeGroup = this._groupLookup.get(activeGroupId);
+        if (activeGroup) {
+            activeGroup.isActive = true;
+            this._proxy.$acceptTabGroupUpdate(activeGroup);
+        }
+    }
+    _onDidTabLabelChange(groupId, editorInput, editorIndex) {
+        const tabId = this._generateTabId(editorInput, groupId);
+        const tabInfo = this._tabInfoLookup.get(tabId);
+        if (tabInfo) {
+            tabInfo.tab.label = editorInput.getName();
+            this._proxy.$acceptTabOperation({
+                groupId,
+                index: editorIndex,
+                tabDto: tabInfo.tab,
+                kind: 2
+            });
+        }
+        else {
+            this._logService.error('Invalid model for label change, rebuilding');
+            this._createTabsModel();
+        }
+    }
+    _onDidTabOpen(groupId, editorInput, editorIndex) {
+        const group = this._editorGroupsService.getGroup(groupId);
+        const groupInModel = this._groupLookup.get(groupId) !== undefined;
+        if (!group || !groupInModel) {
+            this._createTabsModel();
+            return;
+        }
+        const tabs = this._groupLookup.get(groupId)?.tabs;
+        if (!tabs) {
+            return;
+        }
+        const tabObject = this._buildTabObject(group, editorInput, editorIndex);
+        tabs.splice(editorIndex, 0, tabObject);
+        this._tabInfoLookup.set(this._generateTabId(editorInput, groupId), { group, editorInput, tab: tabObject });
+        this._proxy.$acceptTabOperation({
+            groupId,
+            index: editorIndex,
+            tabDto: tabObject,
+            kind: 0
+        });
+    }
+    _onDidTabClose(groupId, editorIndex) {
+        const group = this._editorGroupsService.getGroup(groupId);
+        const tabs = this._groupLookup.get(groupId)?.tabs;
+        if (!group || !tabs) {
+            this._createTabsModel();
+            return;
+        }
+        const removedTab = tabs.splice(editorIndex, 1);
+        if (removedTab.length === 0) {
+            return;
+        }
+        this._tabInfoLookup.delete(removedTab[0]?.id ?? '');
+        this._proxy.$acceptTabOperation({
+            groupId,
+            index: editorIndex,
+            tabDto: removedTab[0],
+            kind: 1
+        });
+    }
+    _onDidTabActiveChange(groupId, editorIndex) {
+        const tabs = this._groupLookup.get(groupId)?.tabs;
+        if (!tabs) {
+            return;
+        }
+        const activeTab = tabs[editorIndex];
+        activeTab.isActive = true;
+        this._proxy.$acceptTabOperation({
+            groupId,
+            index: editorIndex,
+            tabDto: activeTab,
+            kind: 2
+        });
+    }
+    _onDidTabDirty(groupId, editorIndex, editor) {
+        const tabId = this._generateTabId(editor, groupId);
+        const tabInfo = this._tabInfoLookup.get(tabId);
+        if (!tabInfo) {
+            this._logService.error('Invalid model for dirty change, rebuilding');
+            this._createTabsModel();
+            return;
+        }
+        tabInfo.tab.isDirty = editor.isDirty();
+        this._proxy.$acceptTabOperation({
+            groupId,
+            index: editorIndex,
+            tabDto: tabInfo.tab,
+            kind: 2
+        });
+    }
+    _onDidTabPinChange(groupId, editorIndex, editor) {
+        const tabId = this._generateTabId(editor, groupId);
+        const tabInfo = this._tabInfoLookup.get(tabId);
+        const group = tabInfo?.group;
+        const tab = tabInfo?.tab;
+        if (!group || !tab) {
+            this._logService.error('Invalid model for sticky change, rebuilding');
+            this._createTabsModel();
+            return;
+        }
+        tab.isPinned = group.isSticky(editorIndex);
+        this._proxy.$acceptTabOperation({
+            groupId,
+            index: editorIndex,
+            tabDto: tab,
+            kind: 2
+        });
+    }
+    _onDidTabPreviewChange(groupId, editorIndex, editor) {
+        const tabId = this._generateTabId(editor, groupId);
+        const tabInfo = this._tabInfoLookup.get(tabId);
+        const group = tabInfo?.group;
+        const tab = tabInfo?.tab;
+        if (!group || !tab) {
+            this._logService.error('Invalid model for sticky change, rebuilding');
+            this._createTabsModel();
+            return;
+        }
+        tab.isPreview = !group.isPinned(editorIndex);
+        this._proxy.$acceptTabOperation({
+            kind: 2 ,
+            groupId,
+            tabDto: tab,
+            index: editorIndex
+        });
+    }
+    _onDidTabMove(groupId, editorIndex, oldEditorIndex, editor) {
+        const tabs = this._groupLookup.get(groupId)?.tabs;
+        if (!tabs) {
+            this._logService.error('Invalid model for move change, rebuilding');
+            this._createTabsModel();
+            return;
+        }
+        const removedTab = tabs.splice(oldEditorIndex, 1);
+        if (removedTab.length === 0) {
+            return;
+        }
+        tabs.splice(editorIndex, 0, removedTab[0]);
+        this._proxy.$acceptTabOperation({
+            kind: 3 ,
+            groupId,
+            tabDto: removedTab[0],
+            index: editorIndex,
+            oldIndex: oldEditorIndex
+        });
+    }
+    _createTabsModel() {
+        this._tabGroupModel = [];
+        this._groupLookup.clear();
+        this._tabInfoLookup.clear();
+        let tabs = [];
+        for (const group of this._editorGroupsService.groups) {
+            const currentTabGroupModel = {
+                groupId: group.id,
+                isActive: group.id === this._editorGroupsService.activeGroup.id,
+                viewColumn: editorGroupToColumn(this._editorGroupsService, group),
+                tabs: []
+            };
+            group.editors.forEach((editor, editorIndex) => {
+                const tab = this._buildTabObject(group, editor, editorIndex);
+                tabs.push(tab);
+                this._tabInfoLookup.set(this._generateTabId(editor, group.id), {
+                    group,
+                    tab,
+                    editorInput: editor
+                });
+            });
+            currentTabGroupModel.tabs = tabs;
+            this._tabGroupModel.push(currentTabGroupModel);
+            this._groupLookup.set(group.id, currentTabGroupModel);
+            tabs = [];
+        }
+        this._proxy.$acceptEditorTabModel(this._tabGroupModel);
+    }
+    _updateTabsModel(changeEvent) {
+        const event = changeEvent.event;
+        const groupId = changeEvent.groupId;
+        switch (event.kind) {
+            case 0 :
+                if (groupId === this._editorGroupsService.activeGroup.id) {
+                    this._onDidGroupActivate();
+                    break;
+                }
+                else {
+                    return;
+                }
+            case 7 :
+                if (event.editor !== undefined && event.editorIndex !== undefined) {
+                    this._onDidTabLabelChange(groupId, event.editor, event.editorIndex);
+                    break;
+                }
+            case 3 :
+                if (event.editor !== undefined && event.editorIndex !== undefined) {
+                    this._onDidTabOpen(groupId, event.editor, event.editorIndex);
+                    break;
+                }
+            case 4 :
+                if (event.editorIndex !== undefined) {
+                    this._onDidTabClose(groupId, event.editorIndex);
+                    break;
+                }
+            case 6 :
+                if (event.editorIndex !== undefined) {
+                    this._onDidTabActiveChange(groupId, event.editorIndex);
+                    break;
+                }
+            case 11 :
+                if (event.editorIndex !== undefined && event.editor !== undefined) {
+                    this._onDidTabDirty(groupId, event.editorIndex, event.editor);
+                    break;
+                }
+            case 10 :
+                if (event.editorIndex !== undefined && event.editor !== undefined) {
+                    this._onDidTabPinChange(groupId, event.editorIndex, event.editor);
+                    break;
+                }
+            case 9 :
+                if (event.editorIndex !== undefined && event.editor !== undefined) {
+                    this._onDidTabPreviewChange(groupId, event.editorIndex, event.editor);
+                    break;
+                }
+            case 5 :
+                if (isGroupEditorMoveEvent(event) && event.editor && event.editorIndex !== undefined && event.oldEditorIndex !== undefined) {
+                    this._onDidTabMove(groupId, event.editorIndex, event.oldEditorIndex, event.editor);
+                    break;
+                }
+            default:
+                this._createTabsModel();
+        }
+    }
+    $moveTab(tabId, index, viewColumn, preserveFocus) {
+        const groupId = columnToEditorGroup(this._editorGroupsService, this._configurationService, viewColumn);
+        const tabInfo = this._tabInfoLookup.get(tabId);
+        const tab = tabInfo?.tab;
+        if (!tab) {
+            throw new Error(`Attempted to close tab with id ${tabId} which does not exist`);
+        }
+        let targetGroup;
+        const sourceGroup = this._editorGroupsService.getGroup(tabInfo.group.id);
+        if (!sourceGroup) {
+            return;
+        }
+        if (this._groupLookup.get(groupId) === undefined) {
+            let direction = 3 ;
+            if (viewColumn === SIDE_GROUP) {
+                direction = preferredSideBySideGroupDirection(this._configurationService);
+            }
+            targetGroup = this._editorGroupsService.addGroup(this._editorGroupsService.groups[this._editorGroupsService.groups.length - 1], direction);
+        }
+        else {
+            targetGroup = this._editorGroupsService.getGroup(groupId);
+        }
+        if (!targetGroup) {
+            return;
+        }
+        if (index < 0 || index > targetGroup.editors.length) {
+            index = targetGroup.editors.length;
+        }
+        const editorInput = tabInfo?.editorInput;
+        if (!editorInput) {
+            return;
+        }
+        sourceGroup.moveEditor(editorInput, targetGroup, { index, preserveFocus });
+        return;
+    }
+    async $closeTab(tabIds, preserveFocus) {
+        const groups = ( new Map());
+        for (const tabId of tabIds) {
+            const tabInfo = this._tabInfoLookup.get(tabId);
+            const tab = tabInfo?.tab;
+            const group = tabInfo?.group;
+            const editorTab = tabInfo?.editorInput;
+            if (!group || !tab || !tabInfo || !editorTab) {
+                continue;
+            }
+            const groupEditors = groups.get(group);
+            if (!groupEditors) {
+                groups.set(group, [editorTab]);
+            }
+            else {
+                groupEditors.push(editorTab);
+            }
+        }
+        const results = [];
+        for (const [group, editors] of groups) {
+            results.push(await group.closeEditors(editors, { preserveFocus }));
+        }
+        return results.every(result => result);
+    }
+    async $closeGroup(groupIds, preserveFocus) {
+        const groupCloseResults = [];
+        for (const groupId of groupIds) {
+            const group = this._editorGroupsService.getGroup(groupId);
+            if (group) {
+                groupCloseResults.push(await group.closeAllEditors());
+                if (group.count === 0 && this._editorGroupsService.getGroup(group.id)) {
+                    this._editorGroupsService.removeGroup(group);
+                }
+            }
+        }
+        return groupCloseResults.every(result => result);
+    }
+};
+MainThreadEditorTabs = __decorate([
+    extHostNamedCustomer(MainContext.MainThreadEditorTabs),
+    ( __param(1, IEditorGroupsService)),
+    ( __param(2, IConfigurationService)),
+    ( __param(3, ILogService)),
+    ( __param(4, IEditorService))
+], MainThreadEditorTabs);
+
+export { MainThreadEditorTabs };