@codingame/monaco-vscode-workbench-service-override 37.2.0 → 37.3.0

package/vscode/src/vs/sessions/browser/parts/chatGroupsView.js

@@ -0,0 +1,771 @@
+
+import { registerCss } from '@codingame/monaco-vscode-api/css';
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import * as chatGroupsView from './media/chatGroupsView.css';
+import { $, isAncestorOfActiveElement, size } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { Color } from '@codingame/monaco-vscode-api/vscode/vs/base/common/color';
+import { onUnexpectedError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
+import { MutableDisposable, DisposableMap, DisposableStore, toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { SerializableGrid, Sizing, Direction } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/grid/grid';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { StorageScope, StorageTarget } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage';
+import { IStorageService } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colorUtils';
+import { contrastBorder } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/baseColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/chartsColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/editorColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/inputColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/listColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/menuColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/minimapColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/miscColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/quickpickColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/searchColors';
+import { Themable } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/themeService';
+import { IThemeService } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/themeService.service';
+import { agentsPanelBorder } from '@codingame/monaco-vscode-api/vscode/vs/sessions/common/theme';
+import { ISessionsService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsService.service';
+import { ChatGroupView } from './chatGroupView.js';
+import { ChatGroupDropTarget } from './chatGroupDropTarget.js';
+import { isSessionChatDrag } from '@codingame/monaco-vscode-api/vscode/vs/sessions/browser/dnd';
+import { observableValue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableValue';
+import { derived } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/derived';
+import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
+import { transaction } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/transaction';
+
+var ChatGroupsView_1;
+registerCss(chatGroupsView, 0);
+let ChatGroupsView = class ChatGroupsView extends Themable {
+    static {
+        ChatGroupsView_1 = this;
+    }
+    static {
+        this.STORAGE_KEY = "sessions.chatGroupsLayout";
+    }
+    get groupCount() {
+        return this._groupCount;
+    }
+    constructor(themeService, _instantiationService, _sessionsService, _storageService) {
+        super(themeService);
+        this._instantiationService = _instantiationService;
+        this._sessionsService = _sessionsService;
+        this._storageService = _storageService;
+        this.element = $(".chat-groups-view");
+        this._sessionDisposables = this._register(( new MutableDisposable()));
+        this._groupDisposables = this._register(( new DisposableMap()));
+        this._groups = [];
+        this._groupCount = observableValue(this, 1);
+        this._nextGroupId = 0;
+        this._sessionActive = true;
+        this._sessionVisible = true;
+        this._singleGroupTabsReplaceHeader = observableValue(this, false);
+        this._restorePending = false;
+        this._gridDidLayout = false;
+    }
+    setSingleGroupTabsReplaceHeader(enabled) {
+        this._singleGroupTabsReplaceHeader.set(enabled, undefined);
+    }
+    setSession(session, options) {
+        this._options = options;
+        if (this._session === session) {
+            return;
+        }
+        this._persistLayout();
+        this._session = session;
+        const store = ( new DisposableStore());
+        this._sessionDisposables.value = store;
+        this._groupDisposables.clearAndDisposeAll();
+        this._currentSessionStore = store;
+        this._grid = undefined;
+        this._gridDidLayout = false;
+        this._groups = [];
+        this._activeGroup = undefined;
+        this._restoreAssignment = undefined;
+        this._restoreOrder = undefined;
+        this._restorePending = false;
+        this._lastSessionActiveChatId = undefined;
+        this._setGroupCount(1);
+        if (!session) {
+            this.element.replaceChildren();
+            return;
+        }
+        this._mainChatResource = derived(reader => ( session.mainChat.read(reader).resource.toString()));
+        const grid = session.isCreated.get() ? this._tryRestoreLayout(session, store) ?? this._createSingleGroupGrid(session, store) : this._createSingleGroupGrid(session, store);
+        this._grid = grid;
+        store.add(grid);
+        this.element.replaceChildren(grid.element);
+        store.add(toDisposable(() => grid.element.remove()));
+        const dropDelegate = {
+            isChatDrag: event => isSessionChatDrag(event, session.sessionId),
+            findTargetGroup: child => this._findTargetGroup(child),
+            onChatDrop: (groupId, zone, data) => {
+                this._onChatDrop(groupId, zone, data).catch(onUnexpectedError);
+            }
+        };
+        store.add(
+            this._instantiationService.createInstance(ChatGroupDropTarget, this.element, dropDelegate)
+        );
+        store.add(autorun(reader => this._reconcile(reader)));
+        this._applyLayout();
+    }
+    _createSingleGroupGrid(session, store) {
+        const firstGroup = this._createGroupEntry(session);
+        this._groups = [firstGroup];
+        this._activeGroup = firstGroup;
+        firstGroup.view.setGroupActive(true);
+        this._setGroupCount(1);
+        return ( new SerializableGrid(firstGroup.view, {
+            styles: {
+                separatorBorder: this._separatorBorder
+            }
+        }));
+    }
+    _tryRestoreLayout(session, store) {
+        const saved = this._loadStored(session.sessionId);
+        if (!saved || saved.groups.length <= 1) {
+            return undefined;
+        }
+        const indexToEntry = ( new Map());
+        const deserializer = {
+            fromJSON: json => {
+                const index = typeof json?.index === "number" ? json.index : indexToEntry.size;
+                const entry = this._createGroupEntry(session);
+                indexToEntry.set(index, entry);
+                return entry.view;
+            }
+        };
+        let grid;
+        try {
+            grid = SerializableGrid.deserialize(saved.grid, deserializer, {
+                styles: {
+                    separatorBorder: this._separatorBorder
+                }
+            });
+        } catch (e) {
+            onUnexpectedError(e);
+            return undefined;
+        }
+        const groups = [];
+        for (let i = 0; i < saved.groups.length; i++) {
+            const entry = indexToEntry.get(i);
+            if (entry) {
+                groups.push(entry);
+            }
+        }
+        if (groups.length <= 1) {
+            grid.dispose();
+            return undefined;
+        }
+        const assignment = ( new Map());
+        const order = ( new Map());
+        let ordinal = 0;
+        saved.groups.forEach((g, i) => {
+            const entry = indexToEntry.get(i);
+            if (!entry) {
+                return;
+            }
+            for (const id of g.resourceIds) {
+                assignment.set(id, entry.id);
+                order.set(id, ordinal++);
+            }
+            if (g.activeResourceId) {
+                entry.activeResourceId.set(g.activeResourceId, undefined);
+            }
+        });
+        this._groups = groups;
+        this._restoreAssignment = assignment;
+        this._restoreOrder = order;
+        this._restorePending = true;
+        this._activeGroup = indexToEntry.get(saved.activeGroupIndex) ?? groups[0];
+        for (const group of this._groups) {
+            group.view.setGroupActive(group === this._activeGroup);
+        }
+        this._setGroupCount(this._groups.length);
+        return grid;
+    }
+    _createGroupEntry(session) {
+        const id = this._nextGroupId++;
+        const store = ( new DisposableStore());
+        this._groupDisposables.set(id, store);
+        const resourceIds = observableValue(`chatGroup.${id}.resourceIds`, []);
+        const activeResourceId = observableValue(`chatGroup.${id}.activeResourceId`, "");
+        const chats = derived(reader => {
+            const all = session.visibleChatTabs.read(reader);
+            const ids = resourceIds.read(reader);
+            const result = [];
+            for (const idStr of ids) {
+                const chat = all.find(c => ( c.resource.toString()) === idStr);
+                if (chat) {
+                    result.push(chat);
+                }
+            }
+            return result;
+        });
+        const tabsVisible = derived(reader => {
+            if (!session.isCreated.read(reader)) {
+                return false;
+            }
+            if (this._groupCount.read(reader) > 1) {
+                return true;
+            }
+            return session.shouldShowChatTabs.read(reader);
+        });
+        const showSessionActions = derived(
+            reader => this._singleGroupTabsReplaceHeader.read(reader) && this._groupCount.read(reader) === 1 && tabsVisible.read(reader)
+        );
+        const view = store.add(this._instantiationService.createInstance(ChatGroupView));
+        const entry = {
+            id,
+            view,
+            resourceIds,
+            activeResourceId,
+            chats,
+            tabsVisible
+        };
+        store.add(view.onDidFocus(() => this._onGroupFocused(entry)));
+        const context = {
+            session,
+            options: this._options,
+            chats,
+            activeChatResource: activeResourceId,
+            mainChatResource: this._mainChatResource,
+            tabsVisible,
+            showSessionActions,
+            openChat: resource => this._openChat(entry, resource),
+            onTabDragStart: () => {},
+            onTabDragEnd: () => {}
+        };
+        view.setContext(context);
+        view.setSessionActive(this._sessionActive);
+        view.setSessionVisible(this._sessionVisible);
+        return entry;
+    }
+    _reconcile(reader) {
+        const session = this._session;
+        if (!session) {
+            return;
+        }
+        const chats = session.visibleChatTabs.read(reader);
+        const activeChat = session.activeChat.read(reader);
+        const orderedIds = chats.map(c => ( c.resource.toString()));
+        const validIds = ( new Set(orderedIds));
+        const activeId = activeChat?.resource.toString();
+        const hasUnassignedVisibleChats = ( orderedIds.some(id => !( this._groups.some(group => group.resourceIds.get().includes(id)))));
+        if (!this._restorePending && !hasUnassignedVisibleChats) {
+            this._removeGroupsWithoutVisibleChats(validIds);
+        }
+        transaction(tx => {
+            for (const group of this._groups) {
+                const ids = group.resourceIds.get();
+                const pruned = ids.filter(id => ( validIds.has(id)));
+                if (pruned.length !== ids.length) {
+                    group.resourceIds.set(pruned, tx);
+                }
+            }
+            const assigned = ( new Set());
+            for (const group of this._groups) {
+                for (const id of group.resourceIds.get()) {
+                    assigned.add(id);
+                }
+            }
+            for (const id of orderedIds) {
+                if (( assigned.has(id))) {
+                    continue;
+                }
+                const savedGroupId = this._restoreAssignment?.get(id);
+                let target = savedGroupId !== undefined ? this._groups.find(g => g.id === savedGroupId) : undefined;
+                const chat = chats.find(chat => ( chat.resource.toString()) === id);
+                const parentResource = id === activeId ? chat?.origin?.parentChat : undefined;
+                const parentGroup = parentResource ? this._groups.find(group => group.resourceIds.get().includes(( parentResource.toString()))) : undefined;
+                target ??= parentGroup ? this._findAdjacentGroup(parentGroup) : undefined;
+                target ??= this._activeGroup;
+                if (target) {
+                    target.resourceIds.set([...target.resourceIds.get(), id], tx);
+                }
+            }
+            if (this._restorePending && this._restoreOrder) {
+                const restoreOrder = this._restoreOrder;
+                for (const group of this._groups) {
+                    const ids = group.resourceIds.get();
+                    const sorted = [...ids].sort(
+                        (a, b) => (restoreOrder.get(a) ?? Number.MAX_SAFE_INTEGER) - (restoreOrder.get(b) ?? Number.MAX_SAFE_INTEGER)
+                    );
+                    if (( sorted.some((id, i) => id !== ids[i]))) {
+                        group.resourceIds.set(sorted, tx);
+                    }
+                }
+            }
+            if (activeId && activeId !== this._lastSessionActiveChatId) {
+                const owner = this._groups.find(g => g.resourceIds.get().includes(activeId));
+                if (owner) {
+                    owner.activeResourceId.set(activeId, tx);
+                    this._setActiveGroup(owner);
+                }
+            }
+            this._lastSessionActiveChatId = activeId;
+            for (const group of this._groups) {
+                const ids = group.resourceIds.get();
+                if (ids.length && !ids.includes(group.activeResourceId.get())) {
+                    group.activeResourceId.set(ids[0], tx);
+                }
+            }
+        });
+        if (this._restorePending) {
+            const allSavedPresent = this._restoreAssignment ? [...( this._restoreAssignment.keys())].every(id => ( validIds.has(id))) : true;
+            const catalogSettled = !session.loading.read(reader);
+            if (allSavedPresent || catalogSettled) {
+                this._restorePending = false;
+                this._restoreAssignment = undefined;
+                this._restoreOrder = undefined;
+            }
+        }
+        if (!this._restorePending) {
+            this._removeEmptyGroups();
+            this._persistLayout();
+        }
+    }
+    _findTargetGroup(child) {
+        for (const group of this._groups) {
+            if (group.view.element.contains(child)) {
+                return {
+                    id: group.id,
+                    element: group.view.element
+                };
+            }
+        }
+        return undefined;
+    }
+    async _onChatDrop(targetGroupId, zone, data) {
+        if (!data || !this._session) {
+            return;
+        }
+        if (data.sessionId !== this._session.sessionId) {
+            return;
+        }
+        const id = data.resource;
+        const resource = ( URI.parse(id));
+        let target = this._groups.find(g => g.id === targetGroupId);
+        let source = this._groups.find(g => g.resourceIds.get().includes(id));
+        if (!source) {
+            const session = this._session;
+            if (!( session.chats.get().some(chat => ( chat.resource.toString()) === id))) {
+                return;
+            }
+            await this._sessionsService.openChat(session, resource);
+            if (this._session !== session) {
+                return;
+            }
+            target = this._groups.find(g => g.id === targetGroupId);
+            source = this._groups.find(g => g.resourceIds.get().includes(id));
+        }
+        if (!target || !source) {
+            return;
+        }
+        if (zone === "center") {
+            if (source === target) {
+                return;
+            }
+            this._moveChatToGroup(resource, source, target);
+        } else {
+            if (source === target && source.resourceIds.get().length <= 1) {
+                return;
+            }
+            await this._splitChatIntoNewGroup(resource, source, target, zone);
+        }
+    }
+    _moveChatToGroup(resource, source, target) {
+        const id = ( resource.toString());
+        transaction(tx => {
+            this._detachChatFromGroup(source, id, tx);
+            if (!target.resourceIds.get().includes(id)) {
+                target.resourceIds.set([...target.resourceIds.get(), id], tx);
+            }
+            target.activeResourceId.set(id, tx);
+        });
+        this._setActiveGroup(target);
+        this._sessionsService.openChat(this._session, resource).catch(onUnexpectedError);
+        this._removeEmptyGroups();
+        this._persistLayout();
+    }
+    async _splitChatIntoNewGroup(resource, source, reference, zone) {
+        if (!this._grid || !this._currentSessionStore || !this._session) {
+            return;
+        }
+        const id = ( resource.toString());
+        const newGroup = this._createGroupEntry(this._session);
+        this._grid.addView(
+            newGroup.view,
+            Sizing.Distribute,
+            reference.view,
+            this._zoneToDirection(zone)
+        );
+        this._insertGroup(newGroup, reference, zone);
+        this._setGroupCount(this._groups.length);
+        transaction(tx => {
+            this._detachChatFromGroup(source, id, tx);
+            newGroup.resourceIds.set([id], tx);
+            newGroup.activeResourceId.set(id, tx);
+        });
+        this._setActiveGroup(newGroup);
+        await this._sessionsService.openChat(this._session, resource);
+        this._removeEmptyGroups();
+        this._applyLayout();
+        this._persistLayout();
+    }
+    _detachChatFromGroup(group, id, tx) {
+        const remaining = group.resourceIds.get().filter(x => x !== id);
+        group.resourceIds.set(remaining, tx);
+        if (group.activeResourceId.get() === id && remaining.length) {
+            group.activeResourceId.set(remaining[0], tx);
+        }
+    }
+    async openChatInNewGroup(resource) {
+        if (!this._session || !this._grid || !this._currentSessionStore) {
+            return;
+        }
+        const id = ( resource.toString());
+        const existing = this._groups.find(g => g.resourceIds.get().includes(id));
+        if (existing) {
+            if (existing.resourceIds.get().length > 1) {
+                await this._splitChatIntoNewGroup(resource, existing, existing, "right");
+                return;
+            }
+            existing.activeResourceId.set(id, undefined);
+            this._setActiveGroup(existing);
+            await this._sessionsService.openChat(this._session, resource);
+            return;
+        }
+        const reference = this._activeGroup ?? this._groups[0];
+        if (!reference) {
+            return;
+        }
+        const session = this._session;
+        await this._sessionsService.openChat(session, resource);
+        if (this._session !== session || !( session.visibleChatTabs.get().some(chat => ( chat.resource.toString()) === id))) {
+            return;
+        }
+        const newGroup = this._createGroupEntry(session);
+        this._grid.addView(newGroup.view, Sizing.Distribute, reference.view, Direction.Right);
+        this._insertGroup(newGroup, reference, "right");
+        this._setGroupCount(this._groups.length);
+        transaction(tx => {
+            const assignedGroup = this._groups.find(group => group !== newGroup && group.resourceIds.get().includes(id));
+            if (assignedGroup) {
+                this._detachChatFromGroup(assignedGroup, id, tx);
+            }
+            newGroup.resourceIds.set([id], tx);
+            newGroup.activeResourceId.set(id, tx);
+        });
+        this._setActiveGroup(newGroup);
+        this._removeEmptyGroups();
+        this._applyLayout();
+        this._persistLayout();
+    }
+    _findAdjacentGroup(reference) {
+        if (this._grid && this._gridDidLayout) {
+            for (const direction of [Direction.Right, Direction.Left, Direction.Down, Direction.Up]) {
+                const neighbor = this._grid.getNeighborViews(reference.view, direction)[0];
+                const group = neighbor && this._groups.find(candidate => candidate.view === neighbor);
+                if (group) {
+                    return group;
+                }
+            }
+        }
+        const referenceIndex = this._groups.indexOf(reference);
+        return this._groups[referenceIndex + 1] ?? this._groups[referenceIndex - 1];
+    }
+    _insertGroup(group, reference, zone) {
+        const referenceIndex = this._groups.indexOf(reference);
+        const insertBefore = zone === "left" || zone === "top";
+        this._groups.splice(referenceIndex + (insertBefore ? 0 : 1), 0, group);
+    }
+    splitChatToSide(resource) {
+        if (!this._session || !this._grid || !this._currentSessionStore) {
+            return;
+        }
+        const id = ( resource.toString());
+        const source = this._groups.find(g => g.resourceIds.get().includes(id));
+        if (source) {
+            if (source.resourceIds.get().length <= 1) {
+                this._setActiveGroup(source);
+                return;
+            }
+            this._splitChatIntoNewGroup(resource, source, source, "right").catch(onUnexpectedError);
+            return;
+        }
+        if (( this._groups.some(g => ( g.resourceIds.get().some(x => x !== id))))) {
+            this.openChatInNewGroup(resource).catch(onUnexpectedError);
+        }
+    }
+    _removeEmptyGroups() {
+        this._removeGroups(group => group.resourceIds.get().length === 0);
+    }
+    _removeGroupsWithoutVisibleChats(visibleChatIds) {
+        this._removeGroups(group => group.resourceIds.get().every(id => !( visibleChatIds.has(id))));
+    }
+    _removeGroups(shouldRemove) {
+        if (!this._grid || this._groups.length <= 1) {
+            return;
+        }
+        const groups = this._groups.filter(shouldRemove);
+        for (const group of groups) {
+            if (this._groups.length <= 1) {
+                break;
+            }
+            const hadFocus = group.view.element.contains(group.view.element.ownerDocument.activeElement);
+            this._grid.removeView(group.view, Sizing.Distribute);
+            this._groups = this._groups.filter(g => g !== group);
+            if (this._activeGroup === group) {
+                this._activeGroup = this._groups[0];
+                this._activeGroup?.view.setGroupActive(true);
+            }
+            this._groupDisposables.deleteAndDispose(group.id);
+            if (hadFocus) {
+                this._activeGroup?.view.focus();
+            }
+        }
+        this._setGroupCount(this._groups.length);
+    }
+    _setActiveGroup(entry) {
+        if (this._activeGroup === entry) {
+            return;
+        }
+        this._activeGroup = entry;
+        for (const group of this._groups) {
+            group.view.setGroupActive(group === entry);
+        }
+        this._persistLayout();
+    }
+    getFocusedChat() {
+        const group = this._getFocusedGroup();
+        if (!group) {
+            return undefined;
+        }
+        const activeResource = group.activeResourceId.get();
+        return group.chats.get().find(chat => ( chat.resource.toString()) === activeResource);
+    }
+    _getFocusedGroup() {
+        return this._groups.find(group => isAncestorOfActiveElement(group.view.element));
+    }
+    _onGroupFocused(entry) {
+        this._setActiveGroup(entry);
+        const session = this._session;
+        const activeResourceId = entry.activeResourceId.get();
+        if (session && activeResourceId && ( session.activeChat.get().resource.toString()) !== activeResourceId) {
+            this._sessionsService.openChat(session, ( URI.parse(activeResourceId))).catch(onUnexpectedError);
+        }
+        if (!this._grid || this._groups.length < 2 || !this._isGroupCollapsed(entry.view)) {
+            return;
+        }
+        const gridSize = this._grid.getViewSize();
+        this._grid.resizeView(entry.view, {
+            width: gridSize.width,
+            height: gridSize.height
+        });
+        this._persistLayout();
+    }
+    _isGroupCollapsed(view) {
+        if (!this._grid) {
+            return false;
+        }
+        const COLLAPSE_THRESHOLD = 8;
+        const size = this._grid.getViewSize(view);
+        const gridSize = this._grid.getViewSize();
+        const collapsedHorizontally = size.width <= view.minimumWidth + COLLAPSE_THRESHOLD && gridSize.width > view.minimumWidth + COLLAPSE_THRESHOLD;
+        const collapsedVertically = size.height <= view.minimumHeight + COLLAPSE_THRESHOLD && gridSize.height > view.minimumHeight + COLLAPSE_THRESHOLD;
+        return collapsedHorizontally || collapsedVertically;
+    }
+    _setGroupCount(count) {
+        this._groupCount.set(count, undefined);
+        this.element.classList.toggle("single-group", count <= 1);
+        this._groups.forEach((group, index) => group.view.setGroupPosition(index, count));
+    }
+    _openChat(entry, resource) {
+        entry.activeResourceId.set(( resource.toString()), undefined);
+        this._setActiveGroup(entry);
+        if (this._session) {
+            this._sessionsService.openChat(this._session, resource).catch(onUnexpectedError);
+        }
+    }
+    focusAdjacentGroup(direction) {
+        const activeIndex = this._activeGroup ? this._groups.indexOf(this._activeGroup) : -1;
+        if (activeIndex < 0 || this._groups.length < 2) {
+            return;
+        }
+        const offset = direction === "next" ? 1 : -1;
+        const target = this._groups[(activeIndex + offset + this._groups.length) % this._groups.length];
+        this._onGroupFocused(target);
+        target.view.focus();
+    }
+    splitActiveChat(direction) {
+        const source = this._activeGroup;
+        const resource = source?.activeResourceId.get();
+        if (source && resource && source.resourceIds.get().length > 1) {
+            this._splitChatIntoNewGroup(( URI.parse(resource)), source, source, direction).catch(onUnexpectedError);
+        }
+    }
+    moveActiveChatToAdjacentGroup(direction) {
+        const source = this._activeGroup;
+        const sourceIndex = source ? this._groups.indexOf(source) : -1;
+        const resource = source?.activeResourceId.get();
+        if (!source || sourceIndex < 0 || !resource || this._groups.length < 2) {
+            return;
+        }
+        const offset = direction === "next" ? 1 : -1;
+        const target = this._groups[(sourceIndex + offset + this._groups.length) % this._groups.length];
+        this._moveChatToGroup(( URI.parse(resource)), source, target);
+        target.view.focus();
+    }
+    _zoneToDirection(zone) {
+        switch (zone) {
+        case "left":
+            return Direction.Left;
+        case "right":
+            return Direction.Right;
+        case "top":
+            return Direction.Up;
+        case "bottom":
+            return Direction.Down;
+        default:
+            return Direction.Right;
+        }
+    }
+    setSessionActive(active) {
+        if (this._sessionActive === active) {
+            return;
+        }
+        this._sessionActive = active;
+        for (const group of this._groups) {
+            group.view.setSessionActive(active);
+        }
+    }
+    setSessionVisible(visible) {
+        if (this._sessionVisible === visible) {
+            return;
+        }
+        this._sessionVisible = visible;
+        for (const group of this._groups) {
+            group.view.setSessionVisible(visible);
+        }
+    }
+    submitInput() {
+        return this._activeGroup?.view.submitInput() ?? Promise.resolve(false);
+    }
+    selectWorkspace(folderUri, options) {
+        return this._activeGroup?.view.selectWorkspace(folderUri, options) ?? "notReady";
+    }
+    selectNoWorkspace() {
+        this._activeGroup?.view.selectNoWorkspace();
+    }
+    prefillInput(text) {
+        this._activeGroup?.view.prefillInput(text);
+    }
+    sendQuery(text) {
+        this._activeGroup?.view.sendQuery(text);
+    }
+    attach(uris) {
+        this._activeGroup?.view.attach(uris);
+    }
+    focus() {
+        this._activeGroup?.view.focus();
+    }
+    layout(width, height, top, left) {
+        this._lastLayout = {
+            width,
+            height,
+            top,
+            left
+        };
+        this._applyLayout();
+    }
+    _applyLayout() {
+        if (!this._lastLayout) {
+            return;
+        }
+        const {
+            width,
+            height,
+            top,
+            left
+        } = this._lastLayout;
+        size(this.element, width, height);
+        if (this._grid) {
+            this._grid.layout(width, height, top, left);
+            this._gridDidLayout = true;
+        }
+    }
+    get _separatorBorder() {
+        return this.theme.getColor(agentsPanelBorder) || this.theme.getColor(contrastBorder) || Color.transparent;
+    }
+    updateStyles() {
+        super.updateStyles();
+        this._grid?.style({
+            separatorBorder: this._separatorBorder
+        });
+    }
+    _persistLayout() {
+        if (!this._session || !this._grid || this._restorePending) {
+            return;
+        }
+        const sessionId = this._session.sessionId;
+        if (!this._session.isCreated.get()) {
+            this._saveStored(sessionId, undefined);
+            return;
+        }
+        if (this._groups.length <= 1) {
+            this._saveStored(sessionId, undefined);
+            return;
+        }
+        this._groups.forEach((group, i) => group.view.setSerializationIndex(i));
+        const layout = {
+            version: 1,
+            grid: this._grid.serialize(),
+            groups: this._groups.map(group => ({
+                resourceIds: group.resourceIds.get(),
+                activeResourceId: group.activeResourceId.get()
+            })),
+            activeGroupIndex: Math.max(0, this._groups.indexOf(this._activeGroup))
+        };
+        this._saveStored(sessionId, layout);
+    }
+    _readStoredLayouts() {
+        const raw = this._storageService.get(ChatGroupsView_1.STORAGE_KEY, StorageScope.WORKSPACE);
+        if (!raw) {
+            return {};
+        }
+        try {
+            return JSON.parse(raw);
+        } catch {
+            return {};
+        }
+    }
+    _loadStored(sessionId) {
+        const entry = this._readStoredLayouts()[sessionId];
+        return entry?.version === 1 ? entry : undefined;
+    }
+    _saveStored(sessionId, layout) {
+        const layouts = this._readStoredLayouts();
+        if (layout) {
+            layouts[sessionId] = layout;
+        } else if (layouts[sessionId] === undefined) {
+            return;
+        } else {
+            delete layouts[sessionId];
+        }
+        this._storageService.store(
+            ChatGroupsView_1.STORAGE_KEY,
+            JSON.stringify(layouts),
+            StorageScope.WORKSPACE,
+            StorageTarget.MACHINE
+        );
+    }
+    dispose() {
+        this._persistLayout();
+        super.dispose();
+    }
+};
+ChatGroupsView = ChatGroupsView_1 = ( __decorate([( __param(0, IThemeService)), ( __param(1, IInstantiationService)), ( __param(2, ISessionsService)), ( __param(3, IStorageService))], ChatGroupsView));
+
+export { ChatGroupsView };