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

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

@@ -0,0 +1,261 @@
+
+import { registerCss } from '@codingame/monaco-vscode-api/css';
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import * as sessionDropTarget from './media/sessionDropTarget.css';
+import { $, DragAndDropObserver, EventHelper, addDisposableListener, EventType, getWindow } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { RunOnceScheduler } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { assertReturnsDefined, assertReturnsAllDefined } from '@codingame/monaco-vscode-api/vscode/vs/base/common/types';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { LocalSelectionTransfer } from '@codingame/monaco-vscode-api/vscode/vs/platform/dnd/browser/dnd';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colorUtils';
+import { activeContrastBorder } 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 { EDITOR_DRAG_AND_DROP_BACKGROUND } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/theme';
+import { DraggedSessionIdentifier } from '@codingame/monaco-vscode-api/vscode/vs/sessions/browser/dnd';
+import { ISessionsManagementService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/sessionsManagement.service';
+import { ISessionsService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsService.service';
+
+var SessionDropOverlay_1;
+registerCss(sessionDropTarget, 0);
+let SessionDropOverlay = class SessionDropOverlay extends Themable {
+    static {
+        SessionDropOverlay_1 = this;
+    }
+    static {
+        this.OVERLAY_ID = "monaco-workbench-session-drop-overlay";
+    }
+    get disposed() {
+        return this._disposed;
+    }
+    constructor(
+        targetSessionId,
+        _targetElement,
+        themeService,
+        _sessionsManagementService,
+        _sessionsService
+    ) {
+        super(themeService);
+        this.targetSessionId = targetSessionId;
+        this._targetElement = _targetElement;
+        this._sessionsManagementService = _sessionsManagementService;
+        this._sessionsService = _sessionsService;
+        this._disposed = false;
+        this._sessionTransfer = LocalSelectionTransfer.getInstance();
+        this._cleanupOverlayScheduler = this._register(( new RunOnceScheduler(() => this.dispose(), 300)));
+        this._create();
+    }
+    _create() {
+        const container = this._container = $("div", {
+            id: SessionDropOverlay_1.OVERLAY_ID
+        });
+        this._targetElement.appendChild(container);
+        this._targetElement.classList.add("dragged-over");
+        this._register(toDisposable(() => {
+            container.remove();
+            this._targetElement.classList.remove("dragged-over");
+        }));
+        this._overlay = $(".session-drop-overlay-indicator");
+        container.appendChild(this._overlay);
+        this._registerListeners(container);
+        this.updateStyles();
+    }
+    updateStyles() {
+        const overlay = assertReturnsDefined(this._overlay);
+        overlay.style.backgroundColor = this.getColor(EDITOR_DRAG_AND_DROP_BACKGROUND) || "";
+        const activeContrastBorderColor = this.getColor(activeContrastBorder);
+        overlay.style.outlineColor = activeContrastBorderColor || "";
+        overlay.style.outlineOffset = activeContrastBorderColor ? "-2px" : "";
+        overlay.style.outlineStyle = activeContrastBorderColor ? "dashed" : "";
+        overlay.style.outlineWidth = activeContrastBorderColor ? "2px" : "";
+    }
+    _registerListeners(container) {
+        this._register(new DragAndDropObserver(container, {
+            onDragOver: e => {
+                if (!this._sessionTransfer.hasData(DraggedSessionIdentifier.prototype)) {
+                    this._hideOverlay();
+                    return;
+                }
+                this._positionOverlay(e.offsetX);
+                if (this._cleanupOverlayScheduler.isScheduled()) {
+                    this._cleanupOverlayScheduler.cancel();
+                }
+            },
+            onDragLeave: () => this.dispose(),
+            onDragEnd: () => this.dispose(),
+            onDrop: e => {
+                EventHelper.stop(e, true);
+                const side = this._currentSide;
+                this.dispose();
+                if (side) {
+                    this._handleDrop(side);
+                }
+            }
+        }));
+        this._register(addDisposableListener(container, EventType.MOUSE_OVER, () => {
+            if (!this._cleanupOverlayScheduler.isScheduled()) {
+                this._cleanupOverlayScheduler.schedule();
+            }
+        }));
+    }
+    _handleDrop(side) {
+        const data = this._sessionTransfer.getData(DraggedSessionIdentifier.prototype);
+        this._sessionTransfer.clearData(DraggedSessionIdentifier.prototype);
+        if (!Array.isArray(data) || data.length === 0) {
+            return;
+        }
+        const sessions = [];
+        for (const dragged of data) {
+            if (dragged.sessionId === this.targetSessionId) {
+                continue;
+            }
+            const session = this._sessionsManagementService.getSession(dragged.resource);
+            if (session) {
+                sessions.push(session);
+            }
+        }
+        if (sessions.length === 0) {
+            return;
+        }
+        const primary = sessions[0];
+        const ordered = side === "right" ? [...sessions].reverse() : sessions;
+        for (const session of ordered) {
+            this._sessionsService.insertAt(session, this.targetSessionId, side, session === primary);
+        }
+    }
+    _positionOverlay(mousePosX) {
+        const width = this._targetElement.clientWidth;
+        const side = mousePosX < width / 2 ? "left" : "right";
+        if (side === "left") {
+            this._doPositionOverlay({
+                left: "0",
+                width: "50%"
+            });
+        } else {
+            this._doPositionOverlay({
+                left: "50%",
+                width: "50%"
+            });
+        }
+        const overlay = assertReturnsDefined(this._overlay);
+        overlay.style.opacity = "1";
+        setTimeout(() => overlay.classList.add("overlay-move-transition"), 0);
+        this._currentSide = side;
+    }
+    _doPositionOverlay(options) {
+        const [container, overlay] = assertReturnsAllDefined(this._container, this._overlay);
+        container.style.height = "100%";
+        overlay.style.top = "0";
+        overlay.style.height = "100%";
+        overlay.style.left = options.left;
+        overlay.style.width = options.width;
+    }
+    _hideOverlay() {
+        const overlay = assertReturnsDefined(this._overlay);
+        this._doPositionOverlay({
+            left: "0",
+            width: "100%"
+        });
+        overlay.style.opacity = "0";
+        overlay.classList.remove("overlay-move-transition");
+        this._currentSide = undefined;
+    }
+    contains(element) {
+        return element === this._container || element === this._overlay;
+    }
+    dispose() {
+        super.dispose();
+        this._disposed = true;
+    }
+};
+SessionDropOverlay = SessionDropOverlay_1 = ( __decorate([( __param(2, IThemeService)), ( __param(3, ISessionsManagementService)), ( __param(4, ISessionsService))], SessionDropOverlay));
+let SessionDropTarget = class SessionDropTarget extends Themable {
+    constructor(_container, _delegate, themeService, _instantiationService) {
+        super(themeService);
+        this._container = _container;
+        this._delegate = _delegate;
+        this._instantiationService = _instantiationService;
+        this._counter = 0;
+        this._sessionTransfer = LocalSelectionTransfer.getInstance();
+        this._registerListeners();
+    }
+    get overlay() {
+        if (this._overlay && !this._overlay.disposed) {
+            return this._overlay;
+        }
+        return undefined;
+    }
+    _registerListeners() {
+        this._register(
+            addDisposableListener(this._container, EventType.DRAG_ENTER, e => this._onDragEnter(e))
+        );
+        this._register(
+            addDisposableListener(this._container, EventType.DRAG_LEAVE, () => this._onDragLeave())
+        );
+        for (const target of [this._container, getWindow(this._container)]) {
+            this._register(addDisposableListener(target, EventType.DRAG_END, () => this._onDragEnd()));
+        }
+    }
+    _onDragEnter(event) {
+        this._counter++;
+        if (!this._sessionTransfer.hasData(DraggedSessionIdentifier.prototype)) {
+            if (event.dataTransfer) {
+                event.dataTransfer.dropEffect = "none";
+            }
+            return;
+        }
+        this._updateContainer(true);
+        const target = event.target;
+        if (!target) {
+            return;
+        }
+        if (this.overlay && !this.overlay.contains(target)) {
+            this._disposeOverlay();
+        }
+        if (this.overlay) {
+            return;
+        }
+        const targetView = this._delegate.findTargetView(target);
+        if (!targetView) {
+            return;
+        }
+        this._overlay = this._instantiationService.createInstance(SessionDropOverlay, targetView.sessionId, targetView.element);
+    }
+    _onDragLeave() {
+        this._counter--;
+        if (this._counter === 0) {
+            this._updateContainer(false);
+        }
+    }
+    _onDragEnd() {
+        this._counter = 0;
+        this._updateContainer(false);
+        this._disposeOverlay();
+    }
+    _updateContainer(isDraggedOver) {
+        this._container.classList.toggle("dragged-over", isDraggedOver);
+    }
+    dispose() {
+        super.dispose();
+        this._disposeOverlay();
+    }
+    _disposeOverlay() {
+        if (this._overlay) {
+            this._overlay.dispose();
+            this._overlay = undefined;
+        }
+    }
+};
+SessionDropTarget = ( __decorate([( __param(2, IThemeService)), ( __param(3, IInstantiationService))], SessionDropTarget));
+
+export { SessionDropTarget };

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

@@ -0,0 +1,97 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
+import { IThemeService } from "@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/themeService.service";
+import { IActiveSession } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/sessionsManagement";
+import { ISessionsManagementService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/sessionsManagement.service";
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { IContextMenuService } from "@codingame/monaco-vscode-api/vscode/vs/platform/contextview/browser/contextView.service";
+import { IContextKeyService } from "@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service";
+import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+/**
+ * The session header shown at the top of a session view. It surfaces the session
+ * identity and session toolbar.
+ *
+ * It is intentionally decoupled from the {@link ChatCompositeBar} (the chat tab
+ * strip) so the two surfaces evolve independently. The hosting view tells the
+ * header which session is relevant via {@link setSession}.
+ */
+export declare class SessionHeader extends Disposable {
+    private readonly _themeService;
+    private readonly _contextMenuService;
+    private readonly _contextKeyService;
+    private readonly _sessionsManagementService;
+    private readonly _container;
+    private readonly _iconEl;
+    private readonly _titleEl;
+    private readonly _titleTextEl;
+    private readonly _toolbar;
+    private readonly _titleActionsEl;
+    private readonly _sessionDisposables;
+    private readonly _editingDisposables;
+    private _renameInput;
+    private _session;
+    private _sessionIsCreated;
+    private _requestedVisible;
+    private _lastPointerDownTarget;
+    private readonly _onDidChangeVisibility;
+    readonly onDidChangeVisibility: Event<boolean>;
+    private readonly _onDidChangeHeight;
+    readonly onDidChangeHeight: Event<void>;
+    private _visible;
+    private readonly _sessionTransfer;
+    private readonly _statusIcon;
+    get element(): HTMLElement;
+    get visible(): boolean;
+    get height(): number;
+    constructor(_themeService: IThemeService, instantiationService: IInstantiationService, _contextMenuService: IContextMenuService, _contextKeyService: IContextKeyService, _sessionsManagementService: ISessionsManagementService, configurationService: IConfigurationService);
+    private _registerContextMenu;
+    private _registerDragSource;
+    /**
+     * Tells the header which session is currently relevant. Pass `undefined` to clear.
+     */
+    setSession(session: IActiveSession | undefined): void;
+    setVisible(visible: boolean): void;
+    private _updateVisibility;
+    private _updateHeader;
+    private _applyVisibility;
+    private _updateStyles;
+    /**
+     * The title is editable when the backing provider declares it supports
+     * renaming the session (`capabilities.supportsRename`). This is the same
+     * signal that gates the `Rename...` context menu action in the sessions list.
+     */
+    private _isTitleEditable;
+    /**
+     * Starts an inline rename of the session title. Returns `false` when the
+     * header cannot host it — the header is hidden (e.g. while the single-group
+     * chat tabs row replaces it) or the session cannot be renamed — so callers
+     * can fall back to another rename affordance.
+     */
+    startTitleEditing(): boolean;
+    /**
+     * Replace the rendered title text with an `<input>` containing the current
+     * title (pre-selected). Enter commits via {@link ISessionsManagementService.renameChat},
+     * Escape or blur cancels.
+     */
+    private _startTitleEditing;
+    private _cancelTitleEditing;
+    private _endTitleEditing;
+}
+/**
+ * A lightweight toolbar that renders only the {@link Menus.SessionBarToolbar} menu
+ * using the same `.chat-composite-bar-toolbar` styling. Unlike the full
+ * {@link SessionHeader}, this toolbar is absolutely positioned at the top-right of
+ * the session view and does not allocate any vertical space.
+ *
+ * It is shown only when the hosted session exists but has not yet been created.
+ */
+export declare class SessionViewFloatingToolbar extends Disposable {
+    private readonly _container;
+    private readonly _toolbar;
+    private _session;
+    private readonly _sessionDisposables;
+    get element(): HTMLElement;
+    constructor(instantiationService: IInstantiationService, configurationService: IConfigurationService);
+    setSession(session: IActiveSession | undefined): void;
+    private _setVisible;
+}