@codingame/monaco-vscode-extensions-service-override 3.2.3 → 4.1.0

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

@@ -1,482 +0,0 @@
-import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
-import { DisposableStore } from 'vscode/vscode/vs/base/common/lifecycle';
-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 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookEditorInput';
-import { CustomEditorInput } from 'vscode/vscode/vs/workbench/contrib/customEditor/browser/customEditorInput';
-import { URI } from 'vscode/vscode/vs/base/common/uri';
-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 'vscode/vscode/vs/platform/configuration/common/configuration';
-import { SideBySideEditorInput } from 'vscode/vscode/vs/workbench/common/editor/sideBySideEditorInput';
-import { isEqual } from 'vscode/vscode/vs/base/common/resources';
-import { isGroupEditorMoveEvent } from 'vscode/vscode/vs/workbench/common/editor/editorGroupModel';
-import { InteractiveEditorInput } from 'vscode/vscode/vs/workbench/contrib/interactive/browser/interactiveEditorInput';
-import { MergeEditorInput } from 'vscode/vscode/vs/workbench/contrib/mergeEditor/browser/mergeEditorInput';
-import { ILogService } from 'vscode/vscode/vs/platform/log/common/log';
-import { ChatEditorInput } from 'vscode/vscode/vs/workbench/contrib/chat/browser/chatEditorInput';
-
-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
-            };
-        }
-        if (editor instanceof ChatEditorInput) {
-            return {
-                kind: 10 ,
-                providerId: editor.providerId ?? 'unknown',
-            };
-        }
-        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 8 :
-                if (event.editor !== undefined && event.editorIndex !== undefined) {
-                    this._onDidTabLabelChange(groupId, event.editor, event.editorIndex);
-                    break;
-                }
-            case 4 :
-                if (event.editor !== undefined && event.editorIndex !== undefined) {
-                    this._onDidTabOpen(groupId, event.editor, event.editorIndex);
-                    break;
-                }
-            case 5 :
-                if (event.editorIndex !== undefined) {
-                    this._onDidTabClose(groupId, event.editorIndex);
-                    break;
-                }
-            case 7 :
-                if (event.editorIndex !== undefined) {
-                    this._onDidTabActiveChange(groupId, event.editorIndex);
-                    break;
-                }
-            case 12 :
-                if (event.editorIndex !== undefined && event.editor !== undefined) {
-                    this._onDidTabDirty(groupId, event.editorIndex, event.editor);
-                    break;
-                }
-            case 11 :
-                if (event.editorIndex !== undefined && event.editor !== undefined) {
-                    this._onDidTabPinChange(groupId, event.editorIndex, event.editor);
-                    break;
-                }
-            case 10 :
-                if (event.editorIndex !== undefined && event.editor !== undefined) {
-                    this._onDidTabPreviewChange(groupId, event.editorIndex, event.editor);
-                    break;
-                }
-            case 6 :
-                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 };