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

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

@@ -0,0 +1,178 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { mainWindow } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/window';
+import { DisposableMap, MutableDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+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 { Parts } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/layout/browser/layoutService';
+import { IHostService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/host/browser/host.service';
+import { DockedEditorInput } from '@codingame/monaco-vscode-api/vscode/vs/sessions/common/dockedEditorInput';
+import { DockedAuxiliaryBarController } from '../dockedAuxiliaryBarController.js';
+import { Menus } from '@codingame/monaco-vscode-api/vscode/vs/sessions/browser/menus';
+import { IAgentWorkbenchLayoutService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/browser/workbench.service';
+import { MainEditorPart } from './editorPart.js';
+import { SinglePaneAuxiliaryBarPart } from './singlePaneAuxiliaryBarPart.js';
+
+let SinglePaneMainEditorPart = class SinglePaneMainEditorPart extends MainEditorPart {
+    getGroupViewOptions() {
+        return {
+            menuIds: {
+                headerPrimary: Menus.SessionsEditorHeaderPrimary,
+                headerLayout: Menus.SessionsEditorHeaderLayout,
+                editorActions: Menus.SessionsEditorTitle,
+                tabsBarContext: Menus.SessionsEditorTabsBarContext,
+                tabsBarAddTab: Menus.SessionsEditorTabsBarAddTab
+            },
+            showHeader: true,
+            useModernUITabs: true,
+            reserveHeaderSpace: editor => editor instanceof DockedEditorInput && this.agentWorkbenchLayoutService.isVisible(Parts.EDITOR_PART, mainWindow)
+        };
+    }
+    get preferredWidth() {
+        return this.agentWorkbenchLayoutService.getPreferredEditorPartWidth();
+    }
+    get minimumWidth() {
+        if (!this.agentWorkbenchLayoutService.isVisible(Parts.EDITOR_PART, mainWindow)) {
+            return DockedAuxiliaryBarController.NO_EDITOR_MIN_WIDTH;
+        }
+        return super.minimumWidth;
+    }
+    get snap() {
+        return !this.agentWorkbenchLayoutService.isVisible(Parts.EDITOR_PART, mainWindow);
+    }
+    constructor(
+        editorPartsView,
+        _instantiationService,
+        themeService,
+        configurationService,
+        storageService,
+        agentWorkbenchLayoutService,
+        hostService,
+        contextKeyService
+    ) {
+        super(
+            editorPartsView,
+            _instantiationService,
+            themeService,
+            configurationService,
+            storageService,
+            agentWorkbenchLayoutService,
+            hostService,
+            contextKeyService
+        );
+        this._instantiationService = _instantiationService;
+        this.agentWorkbenchLayoutService = agentWorkbenchLayoutService;
+        this._groupRelayoutListeners = this._register(( new DisposableMap()));
+        this._tabsOverride = this._register(( new MutableDisposable()));
+        this._register(configurationService.onDidChangeConfiguration(event => {
+            if (event.affectsConfiguration("workbench.editor.showTabs")) {
+                this._updateTabsOverride();
+            }
+        }));
+        this._register(agentWorkbenchLayoutService.onDidChangePartVisibility(event => {
+            if (event.partId === Parts.EDITOR_PART || event.partId === Parts.AUXILIARYBAR_PART) {
+                this._updateTabsOverride();
+            }
+        }));
+    }
+    _updateTabsOverride() {
+        const nextShowTabs = this._getShowTabsOverride(
+            this.configurationService.getValue("workbench.editor.showTabs"),
+            this.agentWorkbenchLayoutService.isVisible(Parts.EDITOR_PART, mainWindow),
+            this.agentWorkbenchLayoutService.isVisible(Parts.AUXILIARYBAR_PART, mainWindow)
+        );
+        if (nextShowTabs === this._enforcedShowTabs) {
+            return;
+        }
+        this._enforcedShowTabs = nextShowTabs;
+        this._tabsOverride.value = nextShowTabs ? this.enforcePartOptions({
+            showTabs: nextShowTabs
+        }) : undefined;
+    }
+    _getShowTabsOverride(configuredShowTabs, editorVisible, auxiliaryBarVisible) {
+        if (auxiliaryBarVisible && !editorVisible) {
+            return "multiple";
+        }
+        return configuredShowTabs === "none" ? "single" : undefined;
+    }
+    get auxiliaryBar() {
+        if (!this._auxiliaryBar) {
+            this._auxiliaryBar = this._register(this._instantiationService.createInstance(SinglePaneAuxiliaryBarPart));
+        }
+        return this._auxiliaryBar;
+    }
+    createContentArea(parent, options) {
+        this._updateTabsOverride();
+        const container = super.createContentArea(parent, options);
+        this._registerGroupRelayoutListeners();
+        const layoutService = this.agentWorkbenchLayoutService;
+        this._dockedAuxBar = this._register(( new DockedAuxiliaryBarController(this.element, this.auxiliaryBar, {
+            getWidth: () => layoutService.getDockedAuxiliaryBarWidth(),
+            setWidth: width => layoutService.setDockedAuxiliaryBarWidth(width),
+            isEditorAreaVisible: () => layoutService.isVisible(Parts.EDITOR_PART, mainWindow) || layoutService.isVisible(Parts.AUXILIARYBAR_PART),
+            isEditorVisible: () => layoutService.isVisible(Parts.EDITOR_PART, mainWindow),
+            isAuxiliaryBarVisible: () => layoutService.isVisible(Parts.AUXILIARYBAR_PART),
+            hideAuxiliaryBar: () => layoutService.setAuxiliaryBarHiddenForResize(true),
+            setEditorContentRightInset: px => this.setContentRightInset(px),
+            getTabsHeight: () => this.activeGroup.titleHeight.offset
+        })));
+        return container;
+    }
+    addGroup(location, _direction, _groupToCopy) {
+        return this.assertGroupView(location);
+    }
+    applyLayout(layout) {
+        if (countEditorGroups(layout.groups) > 1) {
+            return;
+        }
+        super.applyLayout(layout);
+    }
+    createEditorDropTarget(container, delegate) {
+        return super.createEditorDropTarget(container, {
+            ...delegate,
+            supportsSplitting: false
+        });
+    }
+    async applyState(state, options) {
+        await super.applyState(state, options);
+        this._ensureSingleEditorGroup();
+    }
+    _ensureSingleEditorGroup() {
+        if (this.count > 1) {
+            this.mergeAllGroups(this.activeGroup);
+        }
+    }
+    _registerGroupRelayoutListeners() {
+        for (const group of this.groups) {
+            this._registerGroupRelayoutListener(group);
+        }
+        this._register(this.onDidAddGroup(group => this._registerGroupRelayoutListener(group)));
+        this._register(
+            this.onDidRemoveGroup(group => this._groupRelayoutListeners.deleteAndDispose(group))
+        );
+    }
+    _registerGroupRelayoutListener(group) {
+        this._groupRelayoutListeners.set(group, group.onDidRelayout(() => this._dockedAuxBar?.layout()));
+    }
+    layout(width, height, top, left) {
+        super.layout(width, height, top, left);
+        this.agentWorkbenchLayoutService.handleDockedEditorPartLayout(width);
+        this._dockedAuxBar?.layout();
+    }
+    layoutDockedAuxiliaryBar() {
+        this._dockedAuxBar?.layout();
+    }
+};
+SinglePaneMainEditorPart = ( __decorate([( __param(1, IInstantiationService)), ( __param(2, IThemeService)), ( __param(3, IConfigurationService)), ( __param(4, IStorageService)), ( __param(5, IAgentWorkbenchLayoutService)), ( __param(6, IHostService)), ( __param(7, IContextKeyService))], SinglePaneMainEditorPart));
+function countEditorGroups(groups) {
+    let count = 0;
+    for (const group of groups) {
+        count += group.groups ? countEditorGroups(group.groups) : 1;
+    }
+    return count;
+}
+
+export { SinglePaneMainEditorPart };

package/vscode/src/vs/sessions/browser/sessionWorkspace.d.ts

@@ -0,0 +1,12 @@
+import { IReader } from "@codingame/monaco-vscode-api/vscode/vs/base/common/observable";
+import { ThemeIcon } from "@codingame/monaco-vscode-api/vscode/vs/base/common/themables";
+import { ISession } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/session";
+export interface ISessionWorkspaceDisplayInfo {
+    readonly label: string;
+    readonly icon: ThemeIcon;
+    readonly workingDirectoryPath: string | undefined;
+    readonly branch: string | undefined;
+    readonly worktreePending: boolean;
+}
+/** Returns the workspace presentation shared by the command center and Files pill. */
+export declare function getSessionWorkspaceDisplayInfo(session: ISession | undefined, reader: IReader): ISessionWorkspaceDisplayInfo | undefined;

package/vscode/src/vs/sessions/browser/sessionWorkspace.js

@@ -0,0 +1,19 @@
+
+import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import { getSessionWorkspaceKind, SessionWorkspaceKind } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/session';
+
+function getSessionWorkspaceDisplayInfo(session, reader) {
+    const workspace = session?.workspace.read(reader);
+    if (!workspace?.label) {
+        return undefined;
+    }
+    const worktreePending = session?.worktreePending?.read(reader) ?? false;
+    const kind = getSessionWorkspaceKind(workspace, worktreePending);
+    const icon = workspace.typeIcon ?? (kind === SessionWorkspaceKind.Virtual ? Codicon.cloudCompact : kind === SessionWorkspaceKind.Folder ? Codicon.folderCompact : Codicon.worktreeCompact);
+    const folder = workspace.folders[0];
+    const branch = worktreePending ? undefined : folder?.gitRepository?.branchName?.trim() || undefined;
+    const workingDirectoryPath = worktreePending ? undefined : folder?.workingDirectory.fsPath;
+    return { label: workspace.label, icon, workingDirectoryPath, branch, worktreePending };
+}
+
+export { getSessionWorkspaceDisplayInfo };

package/vscode/src/vs/sessions/browser/sessionsSetUpService.d.ts

@@ -0,0 +1,24 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
+import { IUserDataProfileStorageService } from "@codingame/monaco-vscode-api/vscode/vs/platform/userDataProfile/common/userDataProfileStorageService.service";
+import { IUserDataProfilesService } from "@codingame/monaco-vscode-api/vscode/vs/platform/userDataProfile/common/userDataProfile.service";
+import { IChatEntitlementService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/chat/common/chatEntitlementService.service";
+import { ISessionsSetUpService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/browser/sessionsSetUpService.service";
+export declare class SessionsSetUpService extends Disposable implements ISessionsSetUpService {
+    private readonly instantiationService;
+    private readonly userDataProfileStorageService;
+    private readonly userDataProfilesService;
+    private readonly chatEntitlementService;
+    private readonly logService;
+    readonly _serviceBrand: undefined;
+    private readonly _initPromise;
+    private readonly _welcomeDoneDeferred;
+    private _initialSignInDialogShown;
+    get initialSignInDialogShown(): boolean;
+    constructor(instantiationService: IInstantiationService, userDataProfileStorageService: IUserDataProfileStorageService, userDataProfilesService: IUserDataProfilesService, chatEntitlementService: IChatEntitlementService, logService: ILogService);
+    private whenSetupDone;
+    private markDone;
+    whenWelcomeDone(): Promise<void>;
+    private initialize;
+}