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

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

@@ -0,0 +1,300 @@
+
+import { registerCss } from '@codingame/monaco-vscode-api/css';
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import * as sessionView from './media/sessionView.css';
+import { $, 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 { 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 { IThemeService } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/themeService.service';
+import { ChatGroupsView } from './chatGroupsView.js';
+import { SessionHeader, SessionViewFloatingToolbar } from './sessionHeader.js';
+import { SessionContext } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionContext';
+import { ISessionContext } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionContext.service';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { SessionIsMaximizedContext } from '@codingame/monaco-vscode-api/vscode/vs/sessions/common/contextkeys';
+import { AGENTS_CENTERED_CONTENT_MAX_WIDTH } from '@codingame/monaco-vscode-api/vscode/vs/sessions/common/layoutConstants';
+import { setActiveSessionContextKeys } from '../../services/sessions/common/sessionContextKeys.js';
+import { ISessionChangesStatsCache } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/sessionChangesStatsCache.service';
+import { applySessionViewThemeColors } from './sessionBarStyles.js';
+import { IChatViewFactory } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/chatView/browser/chatViewFactory.service';
+import { observableValue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableValue';
+import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
+
+var SessionView_1;
+registerCss(sessionView, 0);
+let SessionView = class SessionView extends Disposable {
+    static {
+        SessionView_1 = this;
+    }
+    static {
+        this.TYPE = "sessions.sessionView";
+    }
+    static {
+        this.CENTERED_CONTENT_MAX_WIDTH = AGENTS_CENTERED_CONTENT_MAX_WIDTH;
+    }
+    constructor(
+        _chatViewFactory,
+        instantiationService,
+        contextKeyService,
+        themeService,
+        _changesStatsCache
+    ) {
+        super();
+        this._chatViewFactory = _chatViewFactory;
+        this.themeService = themeService;
+        this._changesStatsCache = _changesStatsCache;
+        this.element = $(".session-view.modern-ui-editor-tab-group");
+        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._standaloneView = this._register(( new MutableDisposable()));
+        this._openSessionDisposables = this._register(( new DisposableStore()));
+        this._hasOpenedSession = false;
+        this._isGridLayout = false;
+        this._isActive = true;
+        this._isPartVisible = true;
+        this._isLeafVisible = true;
+        this._sessionObs = observableValue(this, undefined);
+        const scopedContextKeyService = this._scopedContextKeyService = this._register(contextKeyService.createScoped(this.element));
+        this._sessionIsMaximizedKey = SessionIsMaximizedContext.bindTo(scopedContextKeyService);
+        this._scopedInstantiationService = this._register(instantiationService.createChild(( new ServiceCollection(
+            [IContextKeyService, scopedContextKeyService],
+            [ISessionContext, ( new SessionContext(this._sessionObs))]
+        ))));
+        this.element.style.setProperty(
+            "--session-view-centered-content-max-width",
+            `${SessionView_1.CENTERED_CONTENT_MAX_WIDTH}px`
+        );
+        this._centeredContentContainer = $(".session-view-centered-content");
+        this.element.appendChild(this._centeredContentContainer);
+        this._header = this._register(this._scopedInstantiationService.createInstance(SessionHeader));
+        this._centeredContentContainer.appendChild(this._header.element);
+        this._contentContainer = $(".session-view-content");
+        this.element.appendChild(this._contentContainer);
+        this._groupsView = this._register(this._scopedInstantiationService.createInstance(ChatGroupsView));
+        this._contentContainer.appendChild(this._groupsView.element);
+        this._floatingToolbar = this._register(
+            this._scopedInstantiationService.createInstance(SessionViewFloatingToolbar)
+        );
+        this.element.appendChild(this._floatingToolbar.element);
+        this._applyActiveSessionStyles();
+        this._register(
+            this.themeService.onDidColorThemeChange(() => this._applyActiveSessionStyles())
+        );
+        this._register(this._header.onDidChangeVisibility(() => this._layoutChildren()));
+        this._register(this._header.onDidChangeHeight(() => this._layoutChildren()));
+        this._register(autorun(reader => {
+            const isGridLayout = this._groupsView.groupCount.read(reader) > 1;
+            if (this._isGridLayout === isGridLayout) {
+                return;
+            }
+            this._isGridLayout = isGridLayout;
+            this.element.classList.toggle("grid-layout", isGridLayout);
+            this._layoutChildren();
+        }));
+        this._register(autorun(reader => {
+            const session = this._sessionObs.read(reader);
+            const tabsReplaceHeader = this._groupsView.groupCount.read(reader) === 1 && (session?.isCreated.read(reader) ?? false) && (session?.shouldShowChatTabs.read(reader) ?? false);
+            this._header.setVisible(!tabsReplaceHeader);
+            this._groupsView.setSingleGroupTabsReplaceHeader(tabsReplaceHeader);
+            this.element.classList.toggle("tabs-replace-header", tabsReplaceHeader);
+        }));
+    }
+    openSession(session, options) {
+        if (this._hasOpenedSession && this._currentSession === session) {
+            return;
+        }
+        this._hasOpenedSession = true;
+        this._currentSession = session;
+        this._sessionObs.set(session, undefined);
+        this._openSessionDisposables.clear();
+        this._openSessionDisposables.add(this._handleContextKeys(session));
+        this._header.setSession(session);
+        if (session && !session.isCreated.get()) {
+            this._groupsView.setSession(undefined, options);
+            let view = this._standaloneView.value;
+            if (!view || view.kind !== "newSession") {
+                view = this._chatViewFactory.createNewChatView(false, options, this._scopedInstantiationService);
+                this._standaloneView.value = view;
+            }
+            if (view.element.parentElement !== this._contentContainer) {
+                this._contentContainer.replaceChildren(view.element);
+            }
+            view.setActive(this._isActive);
+            view.setVisible(this._isVisible);
+            this._openSessionDisposables.add(autorun(reader => {
+                if (session.isCreated.read(reader) && this._currentSession === session) {
+                    this._showSessionGroups(session, options);
+                }
+            }));
+        } else if (session) {
+            this._showSessionGroups(session, options);
+        } else {
+            this._groupsView.setSession(undefined, options);
+            const view = this._chatViewFactory.createNewChatView(false, options, this._scopedInstantiationService);
+            this._standaloneView.value = view;
+            this._contentContainer.replaceChildren(view.element);
+            view.setActive(this._isActive);
+            view.setVisible(this._isVisible);
+        }
+        this._floatingToolbar.setSession(session);
+        this._layoutChildren();
+    }
+    _showSessionGroups(session, options) {
+        this._standaloneView.clear();
+        this._contentContainer.replaceChildren(this._groupsView.element);
+        this._groupsView.setSession(session, options);
+        this._layoutChildren();
+    }
+    _handleContextKeys(session) {
+        return autorun(reader => {
+            setActiveSessionContextKeys(session, this._scopedContextKeyService, reader, this._changesStatsCache);
+        });
+    }
+    layout(width, height, top, left) {
+        size(this.element, width, height);
+        this._lastLayout = {
+            width,
+            height,
+            top,
+            left
+        };
+        this._layoutChildren();
+    }
+    _layoutChildren() {
+        if (!this._lastLayout) {
+            return;
+        }
+        const {
+            width,
+            height,
+            top,
+            left
+        } = this._lastLayout;
+        if (!this._isVisible || width === 0 || height === 0) {
+            return;
+        }
+        this._centeredContentContainer.style.width = `${width}px`;
+        const barHeight = this._header.visible ? this._header.height : 0;
+        size(this._centeredContentContainer, width, barHeight);
+        const contentHeight = height - barHeight;
+        const contentTop = top + barHeight;
+        const standaloneView = this._standaloneView.value;
+        if (standaloneView) {
+            standaloneView.layout(width, contentHeight, contentTop, left);
+        } else {
+            this._groupsView.layout(width, contentHeight, contentTop, left);
+        }
+    }
+    toJSON() {
+        return {
+            type: SessionView_1.TYPE
+        };
+    }
+    focus() {
+        const standaloneView = this._standaloneView.value;
+        standaloneView ? standaloneView.focus() : this._groupsView.focus();
+    }
+    startTitleEditing() {
+        return this._isVisible && this._header.startTitleEditing();
+    }
+    getFocusedChat() {
+        return this._groupsView.getFocusedChat();
+    }
+    getSession() {
+        return this._currentSession;
+    }
+    selectWorkspace(folderUri, options) {
+        const standaloneView = this._standaloneView.value;
+        return standaloneView ? standaloneView.selectWorkspace(folderUri, options) : this._groupsView.selectWorkspace(folderUri, options);
+    }
+    selectNoWorkspace() {
+        const standaloneView = this._standaloneView.value;
+        standaloneView ? standaloneView.selectNoWorkspace() : this._groupsView.selectNoWorkspace();
+    }
+    openChatToSide(resource) {
+        return this._groupsView.openChatInNewGroup(resource);
+    }
+    splitChatToSide(resource) {
+        this._groupsView.splitChatToSide(resource);
+    }
+    focusAdjacentChatGroup(direction) {
+        this._groupsView.focusAdjacentGroup(direction);
+    }
+    splitActiveChat(direction) {
+        this._groupsView.splitActiveChat(direction);
+    }
+    moveActiveChatToAdjacentGroup(direction) {
+        this._groupsView.moveActiveChatToAdjacentGroup(direction);
+    }
+    prefillInput(text) {
+        const standaloneView = this._standaloneView.value;
+        standaloneView ? standaloneView.prefillInput(text) : this._groupsView.prefillInput(text);
+    }
+    sendQuery(text) {
+        const standaloneView = this._standaloneView.value;
+        standaloneView ? standaloneView.sendQuery(text) : this._groupsView.sendQuery(text);
+    }
+    submitInput() {
+        return this._standaloneView.value?.submitInput() ?? this._groupsView.submitInput();
+    }
+    attach(uris) {
+        const standaloneView = this._standaloneView.value;
+        standaloneView ? standaloneView.attach(uris) : this._groupsView.attach(uris);
+    }
+    setMaximized(maximized) {
+        this._sessionIsMaximizedKey.set(maximized);
+    }
+    setActive(active) {
+        if (this._isActive === active) {
+            return;
+        }
+        this._isActive = active;
+        this._applyActiveSessionStyles();
+        this._groupsView.setSessionActive(active);
+        this._standaloneView.value?.setActive(active);
+    }
+    setVisible(visible) {
+        if (this._isLeafVisible === visible) {
+            return;
+        }
+        const wasVisible = this._isVisible;
+        this._isLeafVisible = visible;
+        this._updateVisibility(wasVisible);
+    }
+    setPartVisible(visible) {
+        if (this._isPartVisible === visible) {
+            return;
+        }
+        const wasVisible = this._isVisible;
+        this._isPartVisible = visible;
+        this._updateVisibility(wasVisible);
+    }
+    get _isVisible() {
+        return this._isPartVisible && this._isLeafVisible;
+    }
+    _updateVisibility(wasVisible) {
+        const visible = this._isVisible;
+        if (visible === wasVisible) {
+            return;
+        }
+        this._groupsView.setSessionVisible(visible);
+        this._standaloneView.value?.setVisible(visible);
+        if (visible) {
+            this._layoutChildren();
+        }
+    }
+    _applyActiveSessionStyles() {
+        this.element.classList.toggle("modern-ui-editor-tab-group-active", this._isActive);
+        applySessionViewThemeColors(this.element, this.themeService.getColorTheme(), this._isActive);
+    }
+};
+SessionView = SessionView_1 = ( __decorate([( __param(0, IChatViewFactory)), ( __param(1, IInstantiationService)), ( __param(2, IContextKeyService)), ( __param(3, IThemeService)), ( __param(4, ISessionChangesStatsCache))], SessionView));
+
+export { SessionView };

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

@@ -0,0 +1,124 @@
+import { IContextKeyService } from "@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service";
+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 { IThemeService } from "@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/themeService.service";
+import { LayoutPriority } from "@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/splitview/splitview";
+import { SerializableGrid } from "@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/grid/grid";
+import { Part } from "@codingame/monaco-vscode-api/vscode/vs/workbench/browser/part";
+import { IActiveSession } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/sessionsManagement";
+import { SessionView } from "./sessionView.js";
+import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
+import { IProgressIndicator } from "@codingame/monaco-vscode-api/vscode/vs/platform/progress/common/progress";
+import { IAgentWorkbenchLayoutService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/browser/workbench.service";
+import { ISessionsChatBackgroundService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/chatBackground/browser/chatBackgroundService.service";
+export declare class SessionsPart extends Part {
+    private readonly agentWorkbenchLayoutService;
+    private readonly instantiationService;
+    private readonly chatBackgroundService;
+    readonly minimumWidth: number;
+    readonly maximumWidth: number;
+    readonly minimumHeight: number;
+    readonly maximumHeight: number;
+    get snap(): boolean;
+    /** Border width on the card (1px each side) */
+    static readonly BORDER_WIDTH = 1;
+    /** Internal grid that hosts the part's session views. */
+    protected _gridWidget: SerializableGrid<SessionView> | undefined;
+    /** Lazily-created progress bar shown at the top of the content area. */
+    private _progressBar;
+    private _progressIndicator;
+    /**
+     * Session views mounted in the grid, in display order (left-to-right). Slots
+     * are reused across reconciliations: only the slot count changes with the
+     * number of visible sessions; each slot is rebound to its session by position
+     * via {@link SessionView.openSession}. There is always at least one slot — a
+     * new-session placeholder (`boundSessionId === undefined`) when no sessions
+     * are visible.
+     */
+    private readonly _slots;
+    private readonly _onDidFocusSession;
+    /** Fired when a session view in the grid receives keyboard focus. */
+    readonly onDidFocusSession: Event<string>;
+    protected _lastLayout: {
+        readonly width: number;
+        readonly height: number;
+        readonly top: number;
+        readonly left: number;
+    } | undefined;
+    private readonly _multipleSessionsVisibleKey;
+    private readonly _sessionsFocusKey;
+    /**
+     * Whether the part itself is visible in the workbench grid. Starts `true`
+     * because the workbench grid only calls {@link setVisible} on change.
+     */
+    private _isPartVisible;
+    /** Whether the workbench permits the mounted session views to render. */
+    private _contentVisible;
+    private get _sessionViewsVisible();
+    get preferredHeight(): number | undefined;
+    readonly priority = LayoutPriority.High;
+    constructor(themeService: IThemeService, storageService: IStorageService, agentWorkbenchLayoutService: IAgentWorkbenchLayoutService, contextKeyService: IContextKeyService, instantiationService: IInstantiationService, chatBackgroundService: ISessionsChatBackgroundService);
+    create(parent: HTMLElement): void;
+    protected createContentArea(parent: HTMLElement): HTMLElement;
+    private _findTargetView;
+    /**
+     * Reconcile the grid with the desired set of visible sessions. Reuses the
+     * existing {@link SessionView} slots, growing or shrinking the pool only when
+     * the number of visible sessions changes, and rebinds each slot to its
+     * session by position via {@link SessionView.openSession}.
+     */
+    updateVisibleSessions(visible: readonly (IActiveSession | undefined)[], active: IActiveSession | undefined): void;
+    private _updateContextKeys;
+    /**
+     * Pushes the grid's current maximized state into each {@link SessionView} so
+     * its scoped `sessionIsMaximized` context key (used by toolbar actions) is
+     * accurate. Called whenever the grid emits a maximize change.
+     */
+    private _updateMaximizedState;
+    /**
+     * Toggles the maximized state of the session view hosting the given session.
+     * If the view is already maximized, exits maximized state. Otherwise maximizes
+     * it (no-op if fewer than two non-placeholder views are present).
+     *
+     * Returns the view's maximized state after the toggle, or `undefined` when
+     * the call was a no-op.
+     */
+    toggleMaximizeSession(sessionId: string | undefined): boolean | undefined;
+    /**
+     * Returns the {@link SessionView} currently hosting the given session id, or
+     * the placeholder (new-session) view when `sessionId` is `undefined`. Returns
+     * `undefined` if no matching slot exists in the grid.
+     */
+    getSessionView(sessionId: string | undefined): SessionView | undefined;
+    getFocusedSessionView(): SessionView | undefined;
+    /**
+     * Moves keyboard focus into the session view hosting the given session id (or
+     * the placeholder view when `sessionId` is `undefined`), first revealing it in
+     * the grid when it is only partially visible. No-op if no matching slot exists.
+     */
+    focusSession(sessionId: string | undefined): void;
+    /**
+     * Ensures the given view is fully visible within the grid. The grid clips its
+     * leaves (`overflow: hidden`) and lays them out side by side; when there are
+     * more sessions than fit, the grid's split view overflows horizontally and
+     * becomes scrollable, leaving views near the edges partially hidden. When the
+     * target view is not fully visible, scroll it into view.
+     */
+    private _revealView;
+    /**
+     * Returns the progress indicator for the part. Drives the progress bar shown
+     * at the top of the content area. Indicator state is scoped to the part's
+     * visibility, mirroring how view panes manage their own progress indicators.
+     */
+    getProgressIndicator(): IProgressIndicator;
+    private _createSlot;
+    private _restoreSessionOnActivation;
+    private get _gridSeparatorBorder();
+    updateStyles(): void;
+    setContentVisible(visible: boolean): void;
+    private _updateSessionViewsVisibility;
+    setVisible(visible: boolean): void;
+    layout(width: number, height: number, top: number, left: number): void;
+    dispose(): void;
+    toJSON(): object;
+}