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

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

@@ -0,0 +1,324 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { $, trackFocus, size } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { Disposable, MutableDisposable, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { ICommandService } from '@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands.service';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { ServiceCollection } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/serviceCollection';
+import { IContextKeyService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service';
+import { getChatSessionArchiveActionWording, getChatSessionArchiveActionPresentation } from '@codingame/monaco-vscode-api/vscode/vs/platform/chat/common/sessionArchiveActions';
+import { ChatInteractivity, SessionStatus } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/session';
+import { UNARCHIVE_SESSION_COMMAND_ID } from '@codingame/monaco-vscode-api/vscode/vs/sessions/common/sessionCommands';
+import { SessionFocusedChatIsRenameTargetContext } from '@codingame/monaco-vscode-api/vscode/vs/sessions/common/contextkeys';
+import { IChatViewFactory } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/chatView/browser/chatViewFactory.service';
+import { ChatCompositeBar } from './chatCompositeBar.js';
+import { RemoteHostUnavailableEmptyState } from './remoteHostUnavailableEmptyState.js';
+import { SessionRemoteConnection } from './sessionRemoteConnection.js';
+import { SessionReadOnlyBanner } from './sessionReadOnlyBanner.js';
+import { observableFromEvent } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableFromEvent';
+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 { observableValue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableValue';
+
+var ChatGroupView_1;
+let ChatGroupView = class ChatGroupView extends Disposable {
+    static {
+        ChatGroupView_1 = this;
+    }
+    static {
+        this.TYPE = "sessions.chatGroupView";
+    }
+    constructor(
+        _chatViewFactory,
+        _instantiationService,
+        _commandService,
+        configurationService,
+        contextKeyService
+    ) {
+        super();
+        this._chatViewFactory = _chatViewFactory;
+        this._instantiationService = _instantiationService;
+        this._commandService = _commandService;
+        this.element = $(".chat-group-view");
+        this.minimumWidth = 200;
+        this.maximumWidth = Number.POSITIVE_INFINITY;
+        this.minimumHeight = 200;
+        this.maximumHeight = Number.POSITIVE_INFINITY;
+        this._onDidChange = this._register(( new Emitter()));
+        this.onDidChange = this._onDidChange.event;
+        this._onDidFocus = this._register(( new Emitter()));
+        this.onDidFocus = this._onDidFocus.event;
+        this._currentView = this._register(( new MutableDisposable()));
+        this._contextDisposables = this._register(( new DisposableStore()));
+        this._groupActive = false;
+        this._sessionActive = true;
+        this._sessionVisible = true;
+        this._primary = false;
+        this._serializationIndex = 0;
+        const scopedContextKeyService = this._register(contextKeyService.createScoped(this.element));
+        this._scopedInstantiationService = this._register(this._instantiationService.createChild(( new ServiceCollection([IContextKeyService, scopedContextKeyService]))));
+        this._focusedChatIsRenameTargetKey = SessionFocusedChatIsRenameTargetContext.bindTo(scopedContextKeyService);
+        this._connection = this._register(this._instantiationService.createInstance(SessionRemoteConnection));
+        this._archiveActionWording = observableFromEvent(
+            this,
+            configurationService.onDidChangeConfiguration,
+            () => getChatSessionArchiveActionWording(configurationService)
+        );
+        this._barContainer = $(".chat-group-view-bar");
+        this.element.appendChild(this._barContainer);
+        this._compositeBar = this._register(
+            this._scopedInstantiationService.createInstance(ChatCompositeBar, undefined)
+        );
+        this._barContainer.appendChild(this._compositeBar.element);
+        this._readOnlyBanner = this._register(( new SessionReadOnlyBanner()));
+        this._barContainer.appendChild(this._readOnlyBanner.domNode);
+        this._contentContainer = $(".chat-group-view-content");
+        this.element.appendChild(this._contentContainer);
+        this._remoteHostUnavailableEmptyState = this._register(( new RemoteHostUnavailableEmptyState()));
+        this._contentContainer.appendChild(this._remoteHostUnavailableEmptyState.domNode);
+        this._register(this._compositeBar.onDidChangeVisibility(() => this._layoutChildren()));
+        this._register(this._compositeBar.onDidChangeHeight(() => this._layoutChildren()));
+        const focusTracker = this._register(trackFocus(this.element));
+        this._register(focusTracker.onDidFocus(() => this._onDidFocus.fire()));
+    }
+    setGroupPosition(index, count) {
+        this._primary = index === 0;
+        this._currentView.value?.setPrimary(this._primary);
+        if (count <= 1) {
+            this.element.removeAttribute("role");
+            this.element.removeAttribute("aria-label");
+            this._compositeBar.setAriaLabel(( localize(2959, "Chats")));
+            return;
+        }
+        this.element.setAttribute("role", "region");
+        this.element.setAttribute("aria-label", ( localize(2960, "Chat Group {0} of {1}", index + 1, count)));
+        this._compositeBar.setAriaLabel(( localize(2961, "Chats, Group {0} of {1}", index + 1, count)));
+    }
+    setContext(context) {
+        this._contextDisposables.clear();
+        this._connection.setSession(context?.session);
+        if (!context) {
+            this._focusedChatIsRenameTargetKey.reset();
+            this._compositeBar.setGroup(undefined);
+            this._currentView.clear();
+            this._setRemoteHostUnavailableEmptyState(undefined);
+            this._contentContainer.replaceChildren(this._remoteHostUnavailableEmptyState.domNode);
+            return;
+        }
+        const delegate = {
+            session: context.session,
+            chats: context.chats,
+            activeChatResource: context.activeChatResource,
+            mainChatResource: context.mainChatResource,
+            visible: context.tabsVisible,
+            showSessionActions: context.showSessionActions,
+            openChat: resource => context.openChat(resource),
+            onTabDragStart: resource => context.onTabDragStart(resource),
+            onTabDragEnd: () => context.onTabDragEnd()
+        };
+        this._compositeBar.setGroup(delegate);
+        const activeChat = derived(reader => {
+            const activeResource = context.activeChatResource.read(reader);
+            return context.chats.read(reader).find(c => ( c.resource.toString()) === activeResource);
+        });
+        this._contextDisposables.add(autorun(reader => {
+            const activeResource = context.activeChatResource.read(reader);
+            const mainResource = context.mainChatResource.read(reader);
+            this._focusedChatIsRenameTargetKey.set(activeResource !== mainResource);
+        }));
+        const currentView = observableValue(this._contextDisposables, this._currentView.value);
+        const readOnlyContent = derived(reader => {
+            const chat = activeChat.read(reader);
+            if (!chat || chat.interactivity.read(reader) === ChatInteractivity.Full) {
+                return undefined;
+            }
+            const archived = context.session.isArchived.read(reader);
+            if (archived) {
+                const action = getChatSessionArchiveActionPresentation(this._archiveActionWording.read(reader)).unarchive;
+                return {
+                    archived: true,
+                    content: {
+                        message: ( localize(2962, "Archived sessions are read-only.")),
+                        action: {
+                            label: action.title.value,
+                            run: () => this._commandService.executeCommand(UNARCHIVE_SESSION_COMMAND_ID, context.session)
+                        }
+                    }
+                };
+            }
+            return {
+                archived: false,
+                content: {
+                    message: ( localize(2963, "This chat is read-only"))
+                }
+            };
+        });
+        const surface = derived(reader => {
+            const readOnly = readOnlyContent.read(reader);
+            if (readOnly?.archived) {
+                return {
+                    banner: readOnly.content,
+                    recovery: undefined
+                };
+            }
+            const view = currentView.read(reader);
+            const transcriptSettled = view === undefined || !view.isLoadingTranscript.read(reader);
+            const recovery = !transcriptSettled || view?.hasVisibleTranscriptContent.read(reader) ? undefined : this._connection.recoveryContent.read(reader);
+            if (recovery) {
+                return {
+                    banner: undefined,
+                    recovery
+                };
+            }
+            const connectionBanner = this._connection.bannerContent.read(reader);
+            if (connectionBanner) {
+                return {
+                    banner: connectionBanner,
+                    recovery: undefined
+                };
+            }
+            return {
+                banner: readOnly?.content,
+                recovery: undefined
+            };
+        });
+        this._contextDisposables.add(autorun(reader => {
+            const session = context.session;
+            const chat = activeChat.read(reader);
+            let desiredKind;
+            if (session.isCreated.read(reader) === false) {
+                desiredKind = session.isNewSessionRequestInProgress?.read(reader) === true ? "chat" : "newSession";
+            } else if (!chat || (chat.status.read(reader) === SessionStatus.Untitled && chat.interactivity.read(reader) === ChatInteractivity.Full)) {
+                desiredKind = "newChatInSession";
+            } else {
+                desiredKind = "chat";
+            }
+            let view = this._currentView.value;
+            if (!view || view.kind !== desiredKind) {
+                view = desiredKind === "chat" ? this._chatViewFactory.createChatView(this._scopedInstantiationService) : this._chatViewFactory.createNewChatView(
+                    desiredKind === "newChatInSession",
+                    context.options,
+                    this._scopedInstantiationService
+                );
+                this._contentContainer.replaceChildren(view.element, this._remoteHostUnavailableEmptyState.domNode);
+                this._currentView.value = view;
+                currentView.set(view, undefined);
+                view.setPrimary(this._primary);
+                view.setActive(this._sessionActive);
+                view.setVisible(this._sessionVisible);
+                this._layoutChildren();
+            }
+            if (chat) {
+                view.setChat(chat, session.sessionId, session);
+            }
+            const surfaceContent = surface.read(reader);
+            this._setRemoteHostUnavailableEmptyState(surfaceContent.recovery);
+            this._setReadOnlyBanner(surfaceContent.banner);
+        }));
+    }
+    _setReadOnlyBanner(content) {
+        if (content) {
+            this._readOnlyBanner.setContent(content);
+        }
+        if (this._readOnlyBanner.visible !== !!content) {
+            this._readOnlyBanner.setVisible(!!content);
+            this._layoutChildren();
+        }
+    }
+    _setRemoteHostUnavailableEmptyState(content) {
+        this._remoteHostUnavailableEmptyState.setContent(content);
+        this._contentContainer.classList.toggle("remote-host-unavailable", !!content);
+    }
+    setGroupActive(active) {
+        this._groupActive = active;
+        this.element.classList.toggle("active-group", active);
+    }
+    get groupActive() {
+        return this._groupActive;
+    }
+    setSessionActive(active) {
+        if (this._sessionActive === active) {
+            return;
+        }
+        this._sessionActive = active;
+        this._currentView.value?.setActive(active);
+    }
+    setSessionVisible(visible) {
+        if (this._sessionVisible === visible) {
+            return;
+        }
+        this._sessionVisible = visible;
+        this._currentView.value?.setVisible(visible);
+        if (visible) {
+            this._layoutChildren();
+        }
+    }
+    submitInput() {
+        return this._currentView.value?.submitInput() ?? Promise.resolve(false);
+    }
+    selectWorkspace(folderUri, options) {
+        return this._currentView.value?.selectWorkspace(folderUri, options) ?? "notReady";
+    }
+    selectNoWorkspace() {
+        this._currentView.value?.selectNoWorkspace();
+    }
+    prefillInput(text) {
+        this._currentView.value?.prefillInput(text);
+    }
+    sendQuery(text) {
+        this._currentView.value?.sendQuery(text);
+    }
+    attach(uris) {
+        this._currentView.value?.attach(uris);
+    }
+    layout(width, height, top, left) {
+        size(this.element, width, height);
+        this._lastLayout = {
+            width,
+            height,
+            top,
+            left
+        };
+        this._layoutChildren();
+    }
+    _layoutChildren() {
+        if (!this._lastLayout || !this._sessionVisible) {
+            return;
+        }
+        const {
+            width,
+            height,
+            top,
+            left
+        } = this._lastLayout;
+        const tabsHeight = this._compositeBar.visible ? this._compositeBar.height : 0;
+        const bannerHeight = this._readOnlyBanner.visible ? this._readOnlyBanner.domNode.offsetHeight : 0;
+        const barHeight = tabsHeight + bannerHeight;
+        size(this._barContainer, width, barHeight);
+        size(this._contentContainer, width, height - barHeight);
+        this._currentView.value?.layout(width, height - barHeight, top + barHeight, left);
+    }
+    setSerializationIndex(index) {
+        this._serializationIndex = index;
+    }
+    toJSON() {
+        return {
+            type: ChatGroupView_1.TYPE,
+            index: this._serializationIndex
+        };
+    }
+    focus() {
+        if (this._remoteHostUnavailableEmptyState.visible) {
+            this._remoteHostUnavailableEmptyState.focus();
+            return;
+        }
+        this._currentView.value?.focus();
+    }
+};
+ChatGroupView = ChatGroupView_1 = ( __decorate([( __param(0, IChatViewFactory)), ( __param(1, IInstantiationService)), ( __param(2, ICommandService)), ( __param(3, IConfigurationService)), ( __param(4, IContextKeyService))], ChatGroupView));
+
+export { ChatGroupView };

package/vscode/src/vs/sessions/browser/parts/chatGroupsView.d.ts

@@ -0,0 +1,136 @@
+import { IObservable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/observable";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { IStorageService } from "@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service";
+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 { IChat } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/session";
+import { IActiveSession } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/sessionsManagement";
+import { ISessionsService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsService.service";
+import { IChatViewOptions, ISelectWorkspaceOptions, WorkspaceSelectionResult } from "@codingame/monaco-vscode-api/vscode/vs/sessions/browser/parts/chatView";
+/**
+ * Hosts the grid of chat groups within a single {@link IActiveSession}. Chats
+ * default to a single group (tab strip). Dragging a chat tab to a group's edge
+ * splits it into a new group; dropping it onto another group's center moves it
+ * there — mirroring VS Code editor groups.
+ *
+ * The session is the single source of truth for which chats exist; the grid is
+ * a UI-only partition over those chats. The partition (groups, their assigned
+ * chats, and the grid structure/sizes) is persisted per session to workspace
+ * storage and restored on reload via {@link _tryRestoreLayout}.
+ */
+export declare class ChatGroupsView extends Themable {
+    private readonly _instantiationService;
+    private readonly _sessionsService;
+    private readonly _storageService;
+    private static readonly STORAGE_KEY;
+    readonly element: HTMLElement;
+    private readonly _sessionDisposables;
+    private readonly _groupDisposables;
+    private _currentSessionStore;
+    private _grid;
+    private _groups;
+    private _activeGroup;
+    private readonly _groupCount;
+    /** Number of chat groups currently in the grid. `> 1` means a grid layout. */
+    get groupCount(): IObservable<number>;
+    private _nextGroupId;
+    private _session;
+    private _options;
+    private _mainChatResource;
+    private _sessionActive;
+    private _sessionVisible;
+    private readonly _singleGroupTabsReplaceHeader;
+    /** While restoring a persisted layout: routes (late-loading) chats back to their saved groups. */
+    private _restoreAssignment;
+    /** Saved tab order (resource string -> ordinal) used to restore tab order across groups. */
+    private _restoreOrder;
+    /** Whether a persisted layout is still being restored (saved chats may not have loaded yet). */
+    private _restorePending;
+    private _lastSessionActiveChatId;
+    private _lastLayout;
+    private _gridDidLayout;
+    constructor(themeService: IThemeService, _instantiationService: IInstantiationService, _sessionsService: ISessionsService, _storageService: IStorageService);
+    setSingleGroupTabsReplaceHeader(enabled: boolean): void;
+    /** Sets (or clears) the session whose chats this view partitions into groups. */
+    setSession(session: IActiveSession | undefined, options: IChatViewOptions): void;
+    private _createSingleGroupGrid;
+    /**
+     * Rebuilds a persisted grid layout for the session, if one is stored. Returns
+     * `undefined` to fall back to a single group. Saved chats may not have loaded
+     * yet (the catalog arrives asynchronously); {@link _reconcile} routes them back
+     * to their groups via {@link _restoreAssignment} once they appear.
+     */
+    private _tryRestoreLayout;
+    private _createGroupEntry;
+    private _reconcile;
+    private _findTargetGroup;
+    private _onChatDrop;
+    private _moveChatToGroup;
+    private _splitChatIntoNewGroup;
+    /**
+     * Removes a chat from a group. If it was the group's active chat, activates a
+     * remaining one so the source group keeps showing a chat it still owns.
+     */
+    private _detachChatFromGroup;
+    /**
+     * Opens a chat in a group beside its current group ("open to the side"). A
+     * chat already sharing a group is moved into a new group to its right. A chat
+     * already alone in its own group is focused without creating a duplicate.
+     */
+    openChatInNewGroup(resource: URI): Promise<void>;
+    private _findAdjacentGroup;
+    private _insertGroup;
+    /**
+     * Places a freshly created chat (e.g. a side chat) beside the current one.
+     * Unlike {@link openChatInNewGroup} — which focuses the chat in place when it
+     * is already visible — this moves the chat out of a shared group into its own
+     * group to the right so it sits next to the chat it was created from. Called
+     * only at creation time; if the chat is already alone in its group (nothing to
+     * sit beside) it is left where it is.
+     */
+    splitChatToSide(resource: URI): void;
+    private _removeEmptyGroups;
+    private _removeGroupsWithoutVisibleChats;
+    private _removeGroups;
+    private _setActiveGroup;
+    getFocusedChat(): IChat | undefined;
+    private _getFocusedGroup;
+    /**
+     * Handles focus entering a group: promotes it to the active group and, when
+     * that group is currently collapsed to its minimum size in a split, expands it
+     * so the other groups collapse to their minimum. Focusing an already-expanded
+     * group (or a balanced/manual layout) leaves the sizes untouched.
+     */
+    private _onGroupFocused;
+    /**
+     * Whether the group is squeezed to (near) its minimum along an axis where the
+     * grid has room to be larger — i.e. the user has collapsed it in a split.
+     */
+    private _isGroupCollapsed;
+    private _setGroupCount;
+    private _openChat;
+    focusAdjacentGroup(direction: "previous" | "next"): void;
+    splitActiveChat(direction: "right" | "bottom"): void;
+    moveActiveChatToAdjacentGroup(direction: "previous" | "next"): void;
+    private _zoneToDirection;
+    setSessionActive(active: boolean): void;
+    setSessionVisible(visible: boolean): void;
+    submitInput(): Promise<boolean>;
+    selectWorkspace(folderUri: URI, options?: ISelectWorkspaceOptions): WorkspaceSelectionResult;
+    selectNoWorkspace(): void;
+    prefillInput(text: string): void;
+    sendQuery(text: string): void;
+    attach(uris: URI[]): void;
+    focus(): void;
+    layout(width: number, height: number, top: number, left: number): void;
+    private _applyLayout;
+    private get _separatorBorder();
+    updateStyles(): void;
+    /** Persists the current grid layout for the active session (or clears it when a single group). */
+    private _persistLayout;
+    private _readStoredLayouts;
+    private _loadStored;
+    private _saveStored;
+    dispose(): void;
+}