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

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

@@ -0,0 +1,345 @@
+
+import { registerCss } from '@codingame/monaco-vscode-api/css';
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import * as chatCompositeBar from './media/chatCompositeBar.css';
+import { Disposable, MutableDisposable, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { $, addDisposableListener, EventType, DisposableResizeObserver, isMouseEvent, getWindow, addDisposableGenericMouseDownListener, createElement, addStandardDisposableListener } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { StandardMouseEvent } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/mouseEvent';
+import { KeyCode } from '@codingame/monaco-vscode-api/vscode/vs/base/common/keyCodes';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { IThemeService } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/themeService.service';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { ISessionsManagementService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/sessionsManagement.service';
+import { getUntitledSessionTitle } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/session';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { MenuWorkbenchToolBar, HiddenItemStrategy } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/browser/toolbar';
+import { IContextMenuService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextview/browser/contextView.service';
+import { Menus } from '@codingame/monaco-vscode-api/vscode/vs/sessions/browser/menus';
+import { LocalSelectionTransfer } from '@codingame/monaco-vscode-api/vscode/vs/platform/dnd/browser/dnd';
+import { DraggedSessionIdentifier, SessionsDataTransfers } from '@codingame/monaco-vscode-api/vscode/vs/sessions/browser/dnd';
+import { applyDragImage } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/dnd/dnd';
+import { applySessionBarThemeColors } from './sessionBarStyles.js';
+import { IContextKeyService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service';
+import { onUnexpectedError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
+import { SessionStatusIcon } from '@codingame/monaco-vscode-api/vscode/vs/sessions/browser/sessionStatusIcon';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { createSessionActionViewItemProvider } from '@codingame/monaco-vscode-api/vscode/vs/sessions/browser/sessionActionViewItem';
+import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
+
+registerCss(chatCompositeBar, 0);
+let SessionHeader = class SessionHeader extends Disposable {
+    get element() {
+        return this._container;
+    }
+    get visible() {
+        return this._visible;
+    }
+    get height() {
+        return this._visible ? this._container.offsetHeight : 0;
+    }
+    constructor(
+        _themeService,
+        instantiationService,
+        _contextMenuService,
+        _contextKeyService,
+        _sessionsManagementService,
+        configurationService
+    ) {
+        super();
+        this._themeService = _themeService;
+        this._contextMenuService = _contextMenuService;
+        this._contextKeyService = _contextKeyService;
+        this._sessionsManagementService = _sessionsManagementService;
+        this._sessionDisposables = this._register(( new MutableDisposable()));
+        this._editingDisposables = this._register(( new MutableDisposable()));
+        this._sessionIsCreated = false;
+        this._requestedVisible = true;
+        this._onDidChangeVisibility = this._register(( new Emitter()));
+        this.onDidChangeVisibility = this._onDidChangeVisibility.event;
+        this._onDidChangeHeight = this._register(( new Emitter()));
+        this.onDidChangeHeight = this._onDidChangeHeight.event;
+        this._visible = false;
+        this._sessionTransfer = LocalSelectionTransfer.getInstance();
+        this._container = $(".chat-composite-bar.session-header-bar");
+        const header = $(".chat-composite-bar-header");
+        this._container.appendChild(header);
+        this._iconEl = $(".chat-composite-bar-session-icon");
+        header.appendChild(this._iconEl);
+        this._statusIcon = this._register(instantiationService.createInstance(SessionStatusIcon, this._iconEl));
+        const main = $(".chat-composite-bar-header-main");
+        header.appendChild(main);
+        const titleRow = $(".chat-composite-bar-title-row");
+        main.appendChild(titleRow);
+        this._titleEl = $(".chat-composite-bar-session-title");
+        titleRow.appendChild(this._titleEl);
+        this._titleTextEl = $("span.chat-composite-bar-session-title-text");
+        this._titleEl.appendChild(this._titleTextEl);
+        this._register(addDisposableListener(this._titleEl, EventType.CLICK, () => {
+            this.startTitleEditing();
+        }));
+        const titleActions = $(".chat-composite-bar-title-actions");
+        titleRow.appendChild(titleActions);
+        this._titleActionsEl = titleActions;
+        const toolbarContainer = $(".chat-composite-bar-toolbar");
+        titleActions.appendChild(toolbarContainer);
+        this._toolbar = this._register(
+            instantiationService.createInstance(MenuWorkbenchToolBar, toolbarContainer, Menus.SessionBarToolbar, {
+                hiddenItemStrategy: HiddenItemStrategy.Ignore,
+                menuOptions: {
+                    shouldForwardArgs: true
+                },
+                highlightToggledItems: true,
+                actionViewItemProvider: createSessionActionViewItemProvider(instantiationService, configurationService)
+            })
+        );
+        const heightObserver = this._register(( new DisposableResizeObserver("SessionHeader.height", () => {
+            this._onDidChangeHeight.fire();
+        })));
+        this._register(heightObserver.observe(this._container));
+        this._applyVisibility(false);
+        this._updateStyles();
+        this._register(this._themeService.onDidColorThemeChange(() => this._updateStyles()));
+        this._registerDragSource();
+        this._registerContextMenu();
+    }
+    _registerContextMenu() {
+        this._register(addDisposableListener(this._container, EventType.CONTEXT_MENU, e => {
+            const session = this._session;
+            if (!session) {
+                return;
+            }
+            let anchor = this._container;
+            if (isMouseEvent(e)) {
+                anchor = ( new StandardMouseEvent(getWindow(this._container), e));
+            }
+            e.preventDefault();
+            e.stopPropagation();
+            this._contextMenuService.showContextMenu({
+                menuId: Menus.SessionHeaderContext,
+                menuActionOptions: {
+                    shouldForwardArgs: true,
+                    arg: session
+                },
+                getAnchor: () => anchor,
+                contextKeyService: this._contextKeyService
+            });
+        }));
+    }
+    _registerDragSource() {
+        this._container.draggable = true;
+        this._register(addDisposableGenericMouseDownListener(this._container, e => {
+            this._lastPointerDownTarget = e.target ?? undefined;
+        }));
+        this._register(addDisposableListener(this._container, EventType.DRAG_START, e => {
+            const session = this._session;
+            if (!session || !e.dataTransfer) {
+                e.preventDefault();
+                return;
+            }
+            const target = this._lastPointerDownTarget;
+            if (target && this._titleActionsEl.contains(target)) {
+                e.preventDefault();
+                return;
+            }
+            if (this._renameInput) {
+                e.preventDefault();
+                return;
+            }
+            this._sessionTransfer.setData([( new DraggedSessionIdentifier(session.sessionId, session.resource))], DraggedSessionIdentifier.prototype);
+            const payload = JSON.stringify({
+                sessionId: session.sessionId,
+                resource: ( session.resource.toString())
+            });
+            e.dataTransfer.setData(SessionsDataTransfers.SESSION, payload);
+            e.dataTransfer.effectAllowed = "move";
+            applyDragImage(e, this._container, session.title.get());
+        }));
+        this._register(addDisposableListener(this._container, EventType.DRAG_END, () => {
+            this._sessionTransfer.clearData(DraggedSessionIdentifier.prototype);
+        }));
+    }
+    setSession(session) {
+        if (this._session === session) {
+            return;
+        }
+        this._cancelTitleEditing();
+        this._session = session;
+        this._toolbar.context = session;
+        this._statusIcon.reset();
+        const store = ( new DisposableStore());
+        this._sessionDisposables.value = store;
+        if (!session) {
+            this._sessionIsCreated = false;
+            this._updateVisibility();
+            return;
+        }
+        store.add(autorun(reader => {
+            this._updateHeader(session, reader);
+        }));
+        store.add(autorun(reader => {
+            this._sessionIsCreated = session.isCreated.read(reader);
+            this._updateVisibility();
+        }));
+    }
+    setVisible(visible) {
+        if (this._requestedVisible === visible) {
+            return;
+        }
+        this._requestedVisible = visible;
+        this._updateVisibility();
+    }
+    _updateVisibility() {
+        this._applyVisibility(this._sessionIsCreated && this._requestedVisible);
+    }
+    _updateHeader(session, reader) {
+        const status = session.status.read(reader);
+        const isRead = session.isRead.read(reader);
+        const isArchived = session.isArchived.read(reader);
+        this._statusIcon.setStatus(status, isRead, isArchived);
+        const isQuickChat = session.isQuickChat?.read(reader) ?? false;
+        this._titleTextEl.textContent = session.title.read(reader) || getUntitledSessionTitle(isQuickChat);
+        this._titleEl.classList.toggle("editable", this._isTitleEditable());
+        this._onDidChangeHeight.fire();
+    }
+    _applyVisibility(visible) {
+        const wasVisible = this._visible;
+        this._visible = visible;
+        this._container.style.display = this._visible ? "" : "none";
+        if (wasVisible !== this._visible) {
+            this._onDidChangeVisibility.fire(this._visible);
+        }
+    }
+    _updateStyles() {
+        applySessionBarThemeColors(this._container, this._themeService.getColorTheme());
+    }
+    _isTitleEditable() {
+        return !!this._session && (this._session.capabilities.get().supportsRename ?? false);
+    }
+    startTitleEditing() {
+        if (!this._visible || !this._isTitleEditable()) {
+            return false;
+        }
+        if (this._renameInput) {
+            this._renameInput.focus();
+            this._renameInput.select();
+            return true;
+        }
+        this._startTitleEditing();
+        return true;
+    }
+    _startTitleEditing() {
+        const session = this._session;
+        if (!session || this._renameInput) {
+            return;
+        }
+        const initialTitle = session.title.get();
+        const fallbackTitle = getUntitledSessionTitle(session.isQuickChat?.get() ?? false);
+        const input = createElement("input");
+        input.type = "text";
+        input.className = "chat-composite-bar-session-title-input";
+        input.value = initialTitle;
+        input.placeholder = fallbackTitle;
+        input.setAttribute("aria-label", ( localize(3020, "Rename session")));
+        input.spellcheck = false;
+        this._titleTextEl.style.display = "none";
+        this._titleEl.appendChild(input);
+        this._titleEl.classList.add("editing");
+        this._renameInput = input;
+        input.focus();
+        input.select();
+        const store = ( new DisposableStore());
+        this._editingDisposables.value = store;
+        let finished = false;
+        const finish = commit => {
+            if (finished) {
+                return;
+            }
+            finished = true;
+            const newTitle = input.value.trim();
+            this._endTitleEditing();
+            if (commit && newTitle && newTitle !== initialTitle) {
+                this._sessionsManagementService.renameSession(session, newTitle).catch(onUnexpectedError);
+            }
+        };
+        store.add(addStandardDisposableListener(input, EventType.KEY_DOWN, e => {
+            if (e.equals(KeyCode.Enter)) {
+                e.preventDefault();
+                e.stopPropagation();
+                finish(true);
+            } else if (e.equals(KeyCode.Escape)) {
+                e.preventDefault();
+                e.stopPropagation();
+                finish(false);
+            } else {
+                e.stopPropagation();
+            }
+        }));
+        store.add(addDisposableListener(input, EventType.BLUR, () => {
+            finish(false);
+        }));
+        store.add(addDisposableGenericMouseDownListener(input, e => e.stopPropagation()));
+        store.add(addDisposableListener(input, EventType.CLICK, e => e.stopPropagation()));
+    }
+    _cancelTitleEditing() {
+        if (!this._renameInput) {
+            return;
+        }
+        this._endTitleEditing();
+    }
+    _endTitleEditing() {
+        if (this._renameInput) {
+            this._renameInput.remove();
+            this._renameInput = undefined;
+        }
+        this._titleTextEl.style.display = "";
+        this._titleEl.classList.remove("editing");
+        this._editingDisposables.clear();
+    }
+};
+SessionHeader = ( __decorate([( __param(0, IThemeService)), ( __param(1, IInstantiationService)), ( __param(2, IContextMenuService)), ( __param(3, IContextKeyService)), ( __param(4, ISessionsManagementService)), ( __param(5, IConfigurationService))], SessionHeader));
+let SessionViewFloatingToolbar = class SessionViewFloatingToolbar extends Disposable {
+    get element() {
+        return this._container;
+    }
+    constructor(instantiationService, configurationService) {
+        super();
+        this._sessionDisposables = this._register(( new MutableDisposable()));
+        this._container = $(".chat-composite-bar.chat-composite-bar-toolbar-floating");
+        const toolbar = $(".chat-composite-bar-toolbar");
+        this._container.appendChild(toolbar);
+        this._toolbar = this._register(
+            instantiationService.createInstance(MenuWorkbenchToolBar, toolbar, Menus.SessionBarToolbar, {
+                hiddenItemStrategy: HiddenItemStrategy.Ignore,
+                menuOptions: {
+                    shouldForwardArgs: true
+                },
+                highlightToggledItems: true,
+                actionViewItemProvider: createSessionActionViewItemProvider(instantiationService, configurationService)
+            })
+        );
+        this._setVisible(false);
+    }
+    setSession(session) {
+        if (this._session === session) {
+            return;
+        }
+        this._session = session;
+        this._toolbar.context = session;
+        const store = ( new DisposableStore());
+        this._sessionDisposables.value = store;
+        if (!session) {
+            this._setVisible(false);
+            return;
+        }
+        store.add(autorun(reader => {
+            this._setVisible(!session.isCreated.read(reader));
+        }));
+    }
+    _setVisible(visible) {
+        this._container.style.display = visible ? "" : "none";
+    }
+};
+SessionViewFloatingToolbar = ( __decorate([( __param(0, IInstantiationService)), ( __param(1, IConfigurationService))], SessionViewFloatingToolbar));
+
+export { SessionHeader, SessionViewFloatingToolbar };

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

@@ -0,0 +1,43 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { ThemeIcon } from "@codingame/monaco-vscode-api/vscode/vs/base/common/themables";
+/**
+ * Content shown by a {@link SessionReadOnlyBanner}: an optional icon, message,
+ * and optional inline action. The action's callback is supplied by the owner so
+ * the banner stays purely presentational.
+ */
+export interface ISessionReadOnlyBannerContent {
+    readonly icon?: ThemeIcon;
+    readonly message: string;
+    /**
+     * Text announced instead of {@link message}. Set this when the visible text
+     * changes faster than it is worth speaking — a per-second countdown, say —
+     * so the live region announces a stable summary rather than every tick.
+     */
+    readonly ariaLabel?: string;
+    readonly action?: {
+        readonly label: string;
+        readonly run: () => void;
+    };
+}
+/**
+ * A small, self-contained status banner for the current chat. It mirrors the
+ * read-only editor banner: a subtle full-width bar with a leading icon and one
+ * line of text. It can explain both a non-interactive chat and a remote-host
+ * state without adding another bar to the group.
+ *
+ * Purely presentational: visibility is driven by the owning chat view via
+ * {@link setVisible} and its content via {@link setContent}.
+ */
+export declare class SessionReadOnlyBanner extends Disposable {
+    readonly domNode: HTMLElement;
+    private _visible;
+    private readonly _icon;
+    private readonly _text;
+    private readonly _announcement;
+    private readonly _actionContainer;
+    private readonly _actionDisposables;
+    constructor();
+    get visible(): boolean;
+    setVisible(visible: boolean): void;
+    setContent(content: ISessionReadOnlyBannerContent): void;
+}

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

@@ -0,0 +1,69 @@
+
+import { registerCss } from '@codingame/monaco-vscode-api/css';
+import * as sessionReadOnlyBanner from './media/sessionReadOnlyBanner.css';
+import { $, append, clearNode, addDisposableListener, EventType, EventHelper } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { renderIcon } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/iconLabel/iconLabels';
+import { StandardKeyboardEvent } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/keyboardEvent';
+import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import { KeyCode } from '@codingame/monaco-vscode-api/vscode/vs/base/common/keyCodes';
+import { Disposable, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+
+registerCss(sessionReadOnlyBanner, 0);
+class SessionReadOnlyBanner extends Disposable {
+    constructor() {
+        super();
+        this._visible = false;
+        this._actionDisposables = this._register(( new DisposableStore()));
+        this.domNode = $(".session-readonly-banner");
+        this.domNode.setAttribute("role", "status");
+        this._icon = append(this.domNode, $(".session-readonly-banner-icon"));
+        this._icon.setAttribute("aria-hidden", "true");
+        this._text = append(this.domNode, $("span.session-readonly-banner-text"));
+        this._text.setAttribute("aria-hidden", "true");
+        this._announcement = append(this.domNode, $("span.session-readonly-banner-announcement"));
+        this._actionContainer = append(this.domNode, $("span.session-readonly-banner-action"));
+        this.setContent({
+            message: ( localize(3021, "This chat is read-only"))
+        });
+        this.setVisible(false);
+    }
+    get visible() {
+        return this._visible;
+    }
+    setVisible(visible) {
+        this._visible = visible;
+        this.domNode.classList.toggle("hidden", !visible);
+    }
+    setContent(content) {
+        clearNode(this._icon);
+        this._icon.appendChild(renderIcon(content.icon ?? Codicon.lock));
+        this._text.textContent = content.message;
+        const announced = content.ariaLabel ?? content.message;
+        if (this._announcement.textContent !== announced) {
+            this._announcement.textContent = announced;
+        }
+        this._actionDisposables.clear();
+        clearNode(this._actionContainer);
+        if (content.action) {
+            const link = append(this._actionContainer, $("a.session-readonly-banner-action-link"));
+            link.textContent = content.action.label;
+            link.setAttribute("role", "button");
+            link.tabIndex = 0;
+            const run = content.action.run;
+            this._actionDisposables.add(addDisposableListener(link, EventType.CLICK, e => {
+                EventHelper.stop(e, true);
+                run();
+            }));
+            this._actionDisposables.add(addDisposableListener(link, EventType.KEY_DOWN, e => {
+                const event = ( new StandardKeyboardEvent(e));
+                if (event.equals(KeyCode.Enter) || event.equals(KeyCode.Space)) {
+                    EventHelper.stop(e, true);
+                    run();
+                }
+            }));
+        }
+    }
+}
+
+export { SessionReadOnlyBanner };

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

@@ -0,0 +1,79 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IObservable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/observable";
+import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
+import { IActiveSession } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/sessionsManagement";
+import { ISessionsProvidersService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsProvidersService.service";
+import { IRemoteHostUnavailableEmptyStateContent } from "./remoteHostUnavailableEmptyState.js";
+import { ISessionReadOnlyBannerContent } from "./sessionReadOnlyBanner.js";
+/**
+ * Connection presentation and recovery state for the session rendered by a chat group.
+ */
+export declare class SessionRemoteConnection extends Disposable {
+    private readonly _sessionsProvidersService;
+    private readonly _logService;
+    private readonly _session;
+    private readonly _attempt;
+    private readonly _progressListener;
+    private readonly _deadlineSignal;
+    private readonly _reconnectCountdownSignal;
+    /**
+     * The session an automatic start has already been triggered for, cleared
+     * once the host is reachable again so each outage gets its own attempt.
+     * Latched separately from {@link _attempt} because a completed attempt
+     * clears that back to `undefined`; keying the gate on it would let a connect
+     * that resolves without reaching the host retrigger forever.
+     *
+     * Scoped to this view. A split session has one instance per chat group, so
+     * an outage can produce one attempt per group. That stays bounded — each
+     * instance latches independently — and providers collapse the duplicates:
+     * `connect()` joins an in-flight dial rather than starting a second one.
+     */
+    private readonly _autoConnected;
+    /**
+     * The session a connect has already been started for, however it ended. Distinguishes a host
+     * that has never been dialled — where the action reads as "Connect" — from one that was tried
+     * and did not come up, where it reads as "Retry". Latched separately from {@link _attempt},
+     * which clears once an attempt settles and so cannot answer "has this been tried at all".
+     */
+    private readonly _connectAttempted;
+    /**
+     * Whether the host should be started without waiting for a click. Gated on a
+     * stopped host the provider can start, and on not having tried yet — one
+     * automatic try per outage, after which the user gets the button.
+     */
+    private readonly _autoConnectPending;
+    /**
+     * When the current outage began, or `undefined` while the host is reachable.
+     *
+     * Recomputed eagerly so the cache cannot outlive its observers: nothing reads
+     * the reconnecting state while the host is connected, and a derived that
+     * stops being observed keeps its last value without ever recomputing it, so a
+     * later outage would inherit the previous one's start time and skip the delay.
+     *
+     * Keyed by session only to guard future reuse: a ChatGroupView is currently
+     * created per session, so the cache cannot outlive the session it belongs to.
+     */
+    private readonly _reconnectingSince;
+    private readonly _reconnectingBannerVisible;
+    private readonly _reconnectCountdownSeconds;
+    readonly bannerContent: IObservable<ISessionReadOnlyBannerContent | undefined>;
+    readonly recoveryContent: IObservable<IRemoteHostUnavailableEmptyStateContent | undefined>;
+    constructor(_sessionsProvidersService: ISessionsProvidersService, _logService: ILogService);
+    setSession(session: IActiveSession | undefined): void;
+    connect(): void;
+    private _runConnect;
+    private _finishAttempt;
+    private _failAttempt;
+    private _getEffectiveStatus;
+    private _getConnectionLabels;
+    private _getRemoteHostConnectProgress;
+    private _getRemoteHostUnavailableContent;
+    private _getRemoteConnectionBannerContent;
+    /**
+     * The wording for the action that establishes the connection. A host that has never been
+     * dialled from this view is offered a plain "Connect": presenting it as a retry would imply an
+     * attempt the user never made, and for hosts that must be resumed rather than merely reached,
+     * the first dial is a deliberate choice rather than a recovery.
+     */
+    private _connectActionLabel;
+}