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

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

@@ -0,0 +1,308 @@
+
+import { registerCss } from '@codingame/monaco-vscode-api/css';
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import * as chatGroupDropTarget from './media/chatGroupDropTarget.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 } from '@codingame/monaco-vscode-api/vscode/vs/base/common/types';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+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 { getSessionChatDragData } from '@codingame/monaco-vscode-api/vscode/vs/sessions/browser/dnd';
+
+var ChatGroupDropOverlay_1;
+registerCss(chatGroupDropTarget, 0);
+const EDGE_THRESHOLD = 0.25;
+let ChatGroupDropOverlay = class ChatGroupDropOverlay extends Themable {
+    static {
+        ChatGroupDropOverlay_1 = this;
+    }
+    static {
+        this.OVERLAY_ID = "monaco-workbench-chat-group-drop-overlay";
+    }
+    get disposed() {
+        return this._disposed;
+    }
+    constructor(targetGroupId, _targetElement, _onDrop, _isChatDrag, themeService) {
+        super(themeService);
+        this.targetGroupId = targetGroupId;
+        this._targetElement = _targetElement;
+        this._onDrop = _onDrop;
+        this._isChatDrag = _isChatDrag;
+        this._disposed = false;
+        this._cleanupOverlayScheduler = this._register(( new RunOnceScheduler(() => this.dispose(), 300)));
+        this._create();
+    }
+    _create() {
+        const container = this._container = $("div", {
+            id: ChatGroupDropOverlay_1.OVERLAY_ID
+        });
+        this._targetElement.appendChild(container);
+        this._targetElement.classList.add("chat-group-dragged-over");
+        this._register(toDisposable(() => {
+            container.remove();
+            this._targetElement.classList.remove("chat-group-dragged-over");
+        }));
+        this._overlay = $(".chat-group-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._isChatDrag(e)) {
+                    this._hideOverlay();
+                    return;
+                }
+                this._positionOverlay(e.offsetX, e.offsetY);
+                if (this._cleanupOverlayScheduler.isScheduled()) {
+                    this._cleanupOverlayScheduler.cancel();
+                }
+            },
+            onDragLeave: () => this.dispose(),
+            onDragEnd: () => this.dispose(),
+            onDrop: e => {
+                EventHelper.stop(e, true);
+                const zone = this._currentZone;
+                const data = getSessionChatDragData(e);
+                this.dispose();
+                if (zone) {
+                    this._onDrop(this.targetGroupId, zone, data);
+                }
+            }
+        }));
+        this._register(addDisposableListener(container, EventType.MOUSE_OVER, () => {
+            if (!this._cleanupOverlayScheduler.isScheduled()) {
+                this._cleanupOverlayScheduler.schedule();
+            }
+        }));
+    }
+    _positionOverlay(mousePosX, mousePosY) {
+        const width = this._targetElement.clientWidth;
+        const height = this._targetElement.clientHeight;
+        const zone = this._computeZone(mousePosX, mousePosY, width, height);
+        switch (zone) {
+        case "left":
+            this._doPositionOverlay({
+                left: "0",
+                top: "0",
+                width: "50%",
+                height: "100%"
+            });
+            break;
+        case "right":
+            this._doPositionOverlay({
+                left: "50%",
+                top: "0",
+                width: "50%",
+                height: "100%"
+            });
+            break;
+        case "top":
+            this._doPositionOverlay({
+                left: "0",
+                top: "0",
+                width: "100%",
+                height: "50%"
+            });
+            break;
+        case "bottom":
+            this._doPositionOverlay({
+                left: "0",
+                top: "50%",
+                width: "100%",
+                height: "50%"
+            });
+            break;
+        case "center":
+            this._doPositionOverlay({
+                left: "0",
+                top: "0",
+                width: "100%",
+                height: "100%"
+            });
+            break;
+        }
+        const overlay = assertReturnsDefined(this._overlay);
+        overlay.style.opacity = "1";
+        this._currentZone = zone;
+    }
+    _computeZone(x, y, width, height) {
+        const edgeX = width * EDGE_THRESHOLD;
+        const edgeY = height * EDGE_THRESHOLD;
+        const distLeft = x;
+        const distRight = width - x;
+        const distTop = y;
+        const distBottom = height - y;
+        const inLeft = distLeft <= edgeX;
+        const inRight = distRight <= edgeX;
+        const inTop = distTop <= edgeY;
+        const inBottom = distBottom <= edgeY;
+        if (!inLeft && !inRight && !inTop && !inBottom) {
+            return "center";
+        }
+        const candidates = [];
+        if (inLeft) {
+            candidates.push({
+                zone: "left",
+                ratio: distLeft / edgeX
+            });
+        }
+        if (inRight) {
+            candidates.push({
+                zone: "right",
+                ratio: distRight / edgeX
+            });
+        }
+        if (inTop) {
+            candidates.push({
+                zone: "top",
+                ratio: distTop / edgeY
+            });
+        }
+        if (inBottom) {
+            candidates.push({
+                zone: "bottom",
+                ratio: distBottom / edgeY
+            });
+        }
+        candidates.sort((a, b) => a.ratio - b.ratio);
+        return candidates[0].zone;
+    }
+    _doPositionOverlay(options) {
+        const container = assertReturnsDefined(this._container);
+        const overlay = assertReturnsDefined(this._overlay);
+        container.style.height = "100%";
+        overlay.style.left = options.left;
+        overlay.style.top = options.top;
+        overlay.style.width = options.width;
+        overlay.style.height = options.height;
+    }
+    _hideOverlay() {
+        const overlay = assertReturnsDefined(this._overlay);
+        this._doPositionOverlay({
+            left: "0",
+            top: "0",
+            width: "100%",
+            height: "100%"
+        });
+        overlay.style.opacity = "0";
+        this._currentZone = undefined;
+    }
+    contains(element) {
+        return element === this._container || element === this._overlay;
+    }
+    dispose() {
+        super.dispose();
+        this._disposed = true;
+    }
+};
+ChatGroupDropOverlay = ChatGroupDropOverlay_1 = ( __decorate([( __param(4, IThemeService))], ChatGroupDropOverlay));
+let ChatGroupDropTarget = class ChatGroupDropTarget extends Themable {
+    constructor(_container, _delegate, themeService, _instantiationService) {
+        super(themeService);
+        this._container = _container;
+        this._delegate = _delegate;
+        this._instantiationService = _instantiationService;
+        this._counter = 0;
+        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._delegate.isChatDrag(event)) {
+            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 targetGroup = this._delegate.findTargetGroup(target);
+        if (!targetGroup) {
+            return;
+        }
+        this._overlay = this._instantiationService.createInstance(
+            ChatGroupDropOverlay,
+            targetGroup.id,
+            targetGroup.element,
+            (groupId, zone, data) => this._delegate.onChatDrop(groupId, zone, data),
+            event => this._delegate.isChatDrag(event)
+        );
+    }
+    _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("chat-groups-dragged-over", isDraggedOver);
+    }
+    dispose() {
+        super.dispose();
+        this._disposeOverlay();
+    }
+    _disposeOverlay() {
+        if (this._overlay) {
+            this._overlay.dispose();
+            this._overlay = undefined;
+        }
+    }
+};
+ChatGroupDropTarget = ( __decorate([( __param(2, IThemeService)), ( __param(3, IInstantiationService))], ChatGroupDropTarget));
+
+export { ChatGroupDropTarget };

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

@@ -0,0 +1,108 @@
+import { ISerializableView, IViewSize } from "@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/grid/grid";
+import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
+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 { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+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 { IContextKeyService } from "@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.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 { IChatViewFactory } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/chatView/browser/chatViewFactory.service";
+import { IChatViewOptions, ISelectWorkspaceOptions, WorkspaceSelectionResult } from "@codingame/monaco-vscode-api/vscode/vs/sessions/browser/parts/chatView";
+/**
+ * The data + callbacks a {@link ChatGroupView} needs from its owning
+ * {@link ChatGroupsView}. Each group renders a subset of the session's chats.
+ */
+export interface IChatGroupContext {
+    /** The session whose chats are partitioned across groups. */
+    readonly session: IActiveSession;
+    /** Options forwarded to the new-chat views the group creates. */
+    readonly options: IChatViewOptions;
+    /** The chats assigned to this group, in tab order. */
+    readonly chats: IObservable<readonly IChat[]>;
+    /** The resource (as a string) of the chat shown by this group. */
+    readonly activeChatResource: IObservable<string>;
+    /** The session's main chat resource (as a string); its tab is not closeable. */
+    readonly mainChatResource: IObservable<string>;
+    /** Whether the group's tab strip should be shown. */
+    readonly tabsVisible: IObservable<boolean>;
+    /** Whether this group's tab row replaces the session header and shows its actions. */
+    readonly showSessionActions: IObservable<boolean>;
+    /** Activate (show + focus) the given chat within this group. */
+    openChat(resource: URI): void;
+    /** A chat tab drag has started for the given chat. */
+    onTabDragStart(resource: URI): void;
+    /** A chat tab drag has ended. */
+    onTabDragEnd(): void;
+}
+/**
+ * A single leaf in the {@link ChatGroupsView} grid. Hosts a
+ * {@link ChatCompositeBar} (this group's chats) on top of a kind-switched
+ * {@link AbstractChatView} that renders the group's active chat.
+ */
+export declare class ChatGroupView extends Disposable implements ISerializableView {
+    private readonly _chatViewFactory;
+    private readonly _instantiationService;
+    private readonly _commandService;
+    static readonly TYPE = "sessions.chatGroupView";
+    readonly element: HTMLElement;
+    readonly minimumWidth = 200;
+    readonly maximumWidth: number;
+    readonly minimumHeight = 200;
+    readonly maximumHeight: number;
+    private readonly _onDidChange;
+    readonly onDidChange: Event<IViewSize | undefined>;
+    /** Fires when keyboard focus enters this group (any of its descendants). */
+    private readonly _onDidFocus;
+    readonly onDidFocus: Event<void>;
+    private readonly _compositeBar;
+    private readonly _barContainer;
+    private readonly _readOnlyBanner;
+    private readonly _contentContainer;
+    private readonly _remoteHostUnavailableEmptyState;
+    private readonly _currentView;
+    private readonly _contextDisposables;
+    private readonly _scopedInstantiationService;
+    private readonly _focusedChatIsRenameTargetKey;
+    private readonly _connection;
+    /** The configured wording for the archive/unarchive action (Archive vs Delete). */
+    private readonly _archiveActionWording;
+    private _lastLayout;
+    /** Whether this group is the active (focused) group within the session. */
+    private _groupActive;
+    /** Whether this group's session is the active session in the sessions part. */
+    private _sessionActive;
+    /** Whether this group's session is currently visible in the sessions part. */
+    private _sessionVisible;
+    /** Whether this is the first group in the chat grid's logical order. */
+    private _primary;
+    /** Index of this group within the persisted layout, written into {@link toJSON}. */
+    private _serializationIndex;
+    constructor(_chatViewFactory: IChatViewFactory, _instantiationService: IInstantiationService, _commandService: ICommandService, configurationService: IConfigurationService, contextKeyService: IContextKeyService);
+    setGroupPosition(index: number, count: number): void;
+    /** Sets (or clears) the group this view renders. */
+    setContext(context: IChatGroupContext | undefined): void;
+    private _setReadOnlyBanner;
+    private _setRemoteHostUnavailableEmptyState;
+    /** Whether this group is the active (focused) group within the session. */
+    setGroupActive(active: boolean): void;
+    get groupActive(): boolean;
+    /** Whether this group's session is the active session in the sessions part. */
+    setSessionActive(active: boolean): void;
+    /** Whether this group's session is currently visible in the sessions part. */
+    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;
+    layout(width: number, height: number, top: number, left: number): void;
+    private _layoutChildren;
+    /** Sets the index this group serializes as, so the grid deserializer can map nodes back to groups. */
+    setSerializationIndex(index: number): void;
+    toJSON(): object;
+    focus(): void;
+}