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

package/vscode/src/vs/sessions/contrib/changes/browser/changesActions.js

@@ -0,0 +1,385 @@
+
+import { registerCss } from '@codingame/monaco-vscode-api/css';
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import * as changesActions from './media/changesActions.css';
+import { reset, $ } 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 { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { isEqual } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { ThemeIcon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/themables';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { localize2 } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { IActionViewItemService } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/browser/actionViewItemService.service';
+import { MenuEntryActionViewItem } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/browser/menuEntryActionViewItem';
+import { Action2, registerAction2, MenuId, MenuItemAction } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions';
+import { ContextKeyExpr } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey';
+import { IContextKeyService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service';
+import { EditorContextKeys } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/editorContextKeys';
+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 { bindContextKey } from '@codingame/monaco-vscode-api/vscode/vs/platform/observable/common/platformObservableUtils';
+import { ActiveEditorContext } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/contextkeys';
+import { registerWorkbenchContribution2, WorkbenchPhase } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions';
+import { IEditorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service';
+import { MultiDiffEditor } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/multiDiffEditor/browser/multiDiffEditor';
+import { DiffEditorWidget } from '@codingame/monaco-vscode-api/vscode/vs/editor/browser/widget/diffEditor/diffEditorWidget';
+import { IAgentWorkbenchLayoutService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/browser/workbench.service';
+import { Menus } from '@codingame/monaco-vscode-api/vscode/vs/sessions/browser/menus';
+import { AGENT_HOST_PULL_REQUEST_OPERATION_IDS, AGENT_HOST_COMMIT_CHANGESET_OPERATION_ID, AGENT_HOST_SYNC_CHANGESET_OPERATION_ID, AGENT_HOST_CHECKOUT_CHANGESET_OPERATION_ID } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostChangesetOperationService';
+import { SessionPrimaryPullRequestOperationContext, SessionHasOpenPullRequestContext } from '@codingame/monaco-vscode-api/vscode/vs/sessions/common/contextkeys';
+import { ISessionsService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsService.service';
+import { SessionChangesetOperationScope, SessionStatus, UNCOMMITTED_CHANGES_CHANGESET_ID, SessionChangesetOperationStatus } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/session';
+import { readSessionChangesStats } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/sessionChangesStatsCache';
+import { ISessionChangesStatsCache } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/sessionChangesStatsCache.service';
+import { IChangesViewService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/changes/common/changesViewService.service';
+import { ChangesMultiDiffSourceResolver, SessionChangesReviewedFilesContext } from './changesMultiDiffSourceResolver.js';
+import '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/changes/browser/sessionChangesService';
+import { SessionChangesEditor } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/changes/browser/sessionChangesEditor';
+import { VIEW_SESSION_CHANGES_COMMAND_ID } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/changes/common/changes';
+import { ISessionChangesService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/changes/common/sessionChangesService.service';
+import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
+import { observableValue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableValue';
+import { transaction } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/transaction';
+
+registerCss(changesActions, 1);
+class ViewAllChangesAction extends Action2 {
+    static {
+        this.ID = VIEW_SESSION_CHANGES_COMMAND_ID;
+    }
+    constructor() {
+        super({
+            id: ViewAllChangesAction.ID,
+            title: ( localize2(3391, "Changes")),
+            icon: Codicon.diffMultiple,
+            f1: false
+        });
+    }
+    async run(accessor, session) {
+        const sessionsService = accessor.get(ISessionsService);
+        const sessionChangesService = accessor.get(ISessionChangesService);
+        const layoutService = accessor.get(IAgentWorkbenchLayoutService);
+        const sessionResource = (session ?? sessionsService.activeSession.get())?.resource;
+        if (!sessionResource) {
+            return;
+        }
+        layoutService.revealEditorPartExplicitly();
+        await sessionChangesService.openChangesEditor(sessionResource, {
+            changesetSelection: {
+                kind: "id",
+                id: undefined
+            }
+        });
+    }
+}
+registerAction2(ViewAllChangesAction);
+class OpenChangedFileAction extends Action2 {
+    static {
+        this.ID = "workbench.agentSessions.changes.openFile";
+    }
+    constructor() {
+        super({
+            id: OpenChangedFileAction.ID,
+            title: ( localize2(3392, "Open File")),
+            icon: Codicon.goToFile,
+            f1: false,
+            menu: {
+                id: MenuId.MultiDiffEditorFileToolbar,
+                when: ( ActiveEditorContext.isEqualTo(SessionChangesEditor.ID)),
+                group: "navigation",
+                order: 22
+            }
+        });
+    }
+    async run(accessor, ...args) {
+        const resource = args[0];
+        if (!(resource instanceof URI)) {
+            return;
+        }
+        await accessor.get(IEditorService).openEditor({
+            resource
+        });
+    }
+}
+registerAction2(OpenChangedFileAction);
+function getChangesDiffEditor(pane, resource) {
+    const codeEditor = pane instanceof SessionChangesEditor || pane instanceof MultiDiffEditor ? pane.tryGetCodeEditor(resource) : undefined;
+    return codeEditor?.diffEditor instanceof DiffEditorWidget ? codeEditor.diffEditor : undefined;
+}
+function getExpandedChangesDiffEditor(pane, resource) {
+    if (pane instanceof SessionChangesEditor) {
+        pane.expand(resource);
+    } else if (pane instanceof MultiDiffEditor) {
+        const viewModel = pane.viewModel;
+        const item = viewModel?.items.read(undefined).find(
+            item => isEqual(item.modifiedUri, resource) || isEqual(item.originalUri, resource)
+        );
+        if (viewModel && item) {
+            viewModel.expand(item);
+        }
+    }
+    return getChangesDiffEditor(pane, resource);
+}
+class ExpandFullFileAction extends Action2 {
+    static {
+        this.ID = "workbench.agentSessions.changes.expandFullFile";
+    }
+    constructor() {
+        super({
+            id: ExpandFullFileAction.ID,
+            title: ( localize2(3393, "Expand Full File")),
+            icon: Codicon.unfold,
+            f1: false,
+            menu: {
+                id: MenuId.MultiDiffEditorFileToolbar,
+                when: ( ContextKeyExpr.and(( ContextKeyExpr.equals("resourceScheme", "changes-multi-diff-source")), ( EditorContextKeys.multiDiffEditorItemAllUnchangedRegionsShown.toNegated()))),
+                group: "navigation",
+                order: 21
+            }
+        });
+    }
+    async run(accessor, ...args) {
+        const resource = args[0];
+        if (!(resource instanceof URI)) {
+            return;
+        }
+        getExpandedChangesDiffEditor(accessor.get(IEditorService).activeEditorPane, resource)?.showAllUnchangedRegions();
+    }
+}
+registerAction2(ExpandFullFileAction);
+class CollapseUnchangedRegionsAction extends Action2 {
+    static {
+        this.ID = "workbench.agentSessions.changes.collapseUnchangedRegions";
+    }
+    constructor() {
+        super({
+            id: CollapseUnchangedRegionsAction.ID,
+            title: ( localize2(3394, "Collapse Unchanged Regions")),
+            icon: Codicon.fold,
+            f1: false,
+            menu: {
+                id: MenuId.MultiDiffEditorFileToolbar,
+                when: ( ContextKeyExpr.and(( ContextKeyExpr.equals("resourceScheme", "changes-multi-diff-source")), EditorContextKeys.multiDiffEditorItemAllUnchangedRegionsShown)),
+                group: "navigation",
+                order: 21
+            }
+        });
+    }
+    async run(accessor, ...args) {
+        const resource = args[0];
+        if (!(resource instanceof URI)) {
+            return;
+        }
+        getExpandedChangesDiffEditor(accessor.get(IEditorService).activeEditorPane, resource)?.collapseAllUnchangedRegions();
+    }
+}
+registerAction2(CollapseUnchangedRegionsAction);
+let SessionChangesStatsCacheContribution = class SessionChangesStatsCacheContribution extends Disposable {
+    static {
+        this.ID = "workbench.contrib.sessions.changesStatsCache";
+    }
+    constructor(sessionsService, changesStatsCache) {
+        super();
+        this._register(autorun(reader => {
+            for (const session of sessionsService.visibleSessions.read(reader)) {
+                if (!session || session.worktreePending?.read(reader)) {
+                    continue;
+                }
+                const stats = readSessionChangesStats(session, reader);
+                if (stats) {
+                    changesStatsCache.set(session.sessionId, stats);
+                }
+            }
+        }));
+    }
+};
+SessionChangesStatsCacheContribution = ( __decorate([( __param(0, ISessionsService)), ( __param(1, ISessionChangesStatsCache))], SessionChangesStatsCacheContribution));
+let ChangesMultiDiffSourceResolverContribution = class ChangesMultiDiffSourceResolverContribution extends Disposable {
+    static {
+        this.ID = "workbench.contrib.sessions.changesMultiDiffSourceResolver";
+    }
+    constructor(instantiationService) {
+        super();
+        this._register(instantiationService.createInstance(ChangesMultiDiffSourceResolver));
+    }
+};
+ChangesMultiDiffSourceResolverContribution = ( __decorate([( __param(0, IInstantiationService))], ChangesMultiDiffSourceResolverContribution));
+let ChangesetOperationsActionControllerContribution = class ChangesetOperationsActionControllerContribution extends Disposable {
+    static {
+        this.ID = "workbench.contrib.sessions.changesetOperationsActionController";
+    }
+    constructor(changesViewService, contextKeyService, logService) {
+        super();
+        const clientReviewedFilesObs = observableValue(this, undefined);
+        const agentHostReviewedFilesObs = observableValue(this, []);
+        this._register(autorun(reader => {
+            const changes = changesViewService.activeSessionChangesObs.read(reader);
+            const reviewedFiles = changes.filter(change => change.reviewed).map(change => change.modifiedUri?.toString() ?? change.originalUri?.toString()).filter(uri => uri !== undefined);
+            transaction(tx => {
+                clientReviewedFilesObs.set(undefined, tx);
+                agentHostReviewedFilesObs.set(reviewedFiles, tx);
+            });
+        }));
+        this._register(
+            bindContextKey(SessionChangesReviewedFilesContext, contextKeyService, reader => {
+                return clientReviewedFilesObs.read(reader) ?? agentHostReviewedFilesObs.read(reader);
+            })
+        );
+        let lastPullRequestOperation;
+        this._register(
+            bindContextKey(SessionPrimaryPullRequestOperationContext, contextKeyService, reader => {
+                const operations = changesViewService.activeSessionChangesetObs.read(reader)?.operations.read(reader) ?? [];
+                const primary = operations.find(op => ( AGENT_HOST_PULL_REQUEST_OPERATION_IDS.has(op.id)))?.id ?? "";
+                if (lastPullRequestOperation !== primary) {
+                    lastPullRequestOperation = primary;
+                    logService.info(
+                        `[ChangesetOperationsActionController] Primary pull request operation: ${primary || "none"}`
+                    );
+                }
+                return primary;
+            })
+        );
+        this._register(
+            bindContextKey(SessionHasOpenPullRequestContext, contextKeyService, reader => {
+                return changesViewService.activeSessionStateObs.read(reader)?.hasOpenPullRequest === true;
+            })
+        );
+        this._register(autorun(reader => {
+            const changeset = changesViewService.activeSessionChangesetObs.read(reader);
+            const resourceOperations = (changeset?.operations.read(reader) ?? []).filter(op => op.scopes.includes(SessionChangesetOperationScope.Resource));
+            if (resourceOperations.length === 0) {
+                return;
+            }
+            for (const operation of resourceOperations) {
+                reader.store.add(registerAction2(class extends Action2 {
+                    constructor() {
+                        super({
+                            id: `workbench.contrib.sessions.changesetOperation.${operation.id}`,
+                            title: operation.label,
+                            icon: operation.icon,
+                            f1: false,
+                            menu: [{
+                                id: MenuId.AgentsChangeInlineToolbar,
+                                group: "navigation",
+                                order: 100
+                            }, {
+                                id: MenuId.MultiDiffEditorFileToolbar,
+                                group: "navigation",
+                                order: 100
+                            }]
+                        });
+                    }
+                    async run(accessor, ...args) {
+                        const resource = args.length === 3 ? args[2] : args[0];
+                        if (!resource || !(resource instanceof URI)) {
+                            return;
+                        }
+                        await changeset?.invokeOperation(operation.id, {
+                            kind: "resource",
+                            resource
+                        });
+                    }
+                }));
+            }
+        }));
+    }
+};
+ChangesetOperationsActionControllerContribution = ( __decorate([( __param(0, IChangesViewService)), ( __param(1, IContextKeyService)), ( __param(2, ILogService))], ChangesetOperationsActionControllerContribution));
+const NEW_SESSION_CHANGESET_OPERATION_ACTION_PREFIX = "workbench.contrib.sessions.newSessionUncommittedChangesetOperation.";
+class CommitActionViewItem extends MenuEntryActionViewItem {
+    render(container) {
+        this.options.icon = false;
+        this.options.label = true;
+        container.classList.add("changes-commit-action");
+        super.render(container);
+    }
+    updateLabel() {
+        if (this.label) {
+            const icon = this._commandAction.item.icon;
+            const iconElement = icon && ThemeIcon.isThemeIcon(icon) ? renderIcon(icon) : undefined;
+            iconElement?.setAttribute("aria-hidden", "true");
+            reset(
+                this.label,
+                ...(iconElement ? [iconElement] : []),
+                $("span.changes-commit-label", undefined, this._commandAction.label)
+            );
+        }
+    }
+}
+let NewSessionUncommittedChangesetOperationsActionContribution = class NewSessionUncommittedChangesetOperationsActionContribution extends Disposable {
+    static {
+        this.ID = "workbench.contrib.sessions.newSessionUncommittedChangesetOperationsAction";
+    }
+    constructor(sessionsService, actionViewItemService) {
+        super();
+        this._register(actionViewItemService.register(
+            Menus.SessionsEditorHeaderLayout,
+            `${NEW_SESSION_CHANGESET_OPERATION_ACTION_PREFIX}${AGENT_HOST_COMMIT_CHANGESET_OPERATION_ID}`,
+            (action, options, instantiationService) => {
+                return action instanceof MenuItemAction ? instantiationService.createInstance(CommitActionViewItem, action, options) : undefined;
+            }
+        ));
+        this._register(autorun(reader => {
+            const activeSession = sessionsService.activeSession.read(reader);
+            if (activeSession?.status.read(reader) !== SessionStatus.Untitled) {
+                return;
+            }
+            const changeset = activeSession.changesets.read(reader)?.find(
+                candidate => candidate.id === UNCOMMITTED_CHANGES_CHANGESET_ID && candidate.isEnabled.read(reader)
+            );
+            const operations = changeset?.operations.read(reader).filter(operation => operation.id !== AGENT_HOST_SYNC_CHANGESET_OPERATION_ID).filter(operation => operation.id !== AGENT_HOST_CHECKOUT_CHANGESET_OPERATION_ID).filter(
+                operation => operation.scopes.includes(SessionChangesetOperationScope.Changeset)
+            ) ?? [];
+            const hasUncommittedChanges = (activeSession.workspace.read(reader)?.folders[0]?.gitRepository?.uncommittedChanges ?? 0) > 0;
+            for (let index = 0; index < operations.length; index++) {
+                const operation = operations[index];
+                const precondition = operation.status === SessionChangesetOperationStatus.Disabled || operation.status === SessionChangesetOperationStatus.Running || (operation.id === AGENT_HOST_COMMIT_CHANGESET_OPERATION_ID && !hasUncommittedChanges) ? ( ContextKeyExpr.false()) : undefined;
+                reader.store.add(registerAction2(class extends Action2 {
+                    constructor() {
+                        super({
+                            id: `${NEW_SESSION_CHANGESET_OPERATION_ACTION_PREFIX}${operation.id}`,
+                            title: operation.label,
+                            tooltip: operation.description,
+                            icon: operation.icon,
+                            precondition,
+                            f1: false,
+                            menu: {
+                                id: Menus.SessionsEditorHeaderLayout,
+                                group: "navigation",
+                                order: index,
+                                when: ( ActiveEditorContext.isEqualTo(SessionChangesEditor.ID))
+                            }
+                        });
+                    }
+                    async run() {
+                        await changeset?.invokeOperation(operation.id);
+                    }
+                }));
+            }
+        }));
+    }
+};
+NewSessionUncommittedChangesetOperationsActionContribution = ( __decorate([( __param(0, ISessionsService)), ( __param(1, IActionViewItemService))], NewSessionUncommittedChangesetOperationsActionContribution));
+registerWorkbenchContribution2(
+    ChangesMultiDiffSourceResolverContribution.ID,
+    ChangesMultiDiffSourceResolverContribution,
+    WorkbenchPhase.BlockRestore
+);
+registerWorkbenchContribution2(
+    ChangesetOperationsActionControllerContribution.ID,
+    ChangesetOperationsActionControllerContribution,
+    WorkbenchPhase.AfterRestored
+);
+registerWorkbenchContribution2(
+    NewSessionUncommittedChangesetOperationsActionContribution.ID,
+    NewSessionUncommittedChangesetOperationsActionContribution,
+    WorkbenchPhase.AfterRestored
+);
+registerWorkbenchContribution2(
+    SessionChangesStatsCacheContribution.ID,
+    SessionChangesStatsCacheContribution,
+    WorkbenchPhase.AfterRestored
+);
+
+export { NewSessionUncommittedChangesetOperationsActionContribution };

package/vscode/src/vs/sessions/contrib/changes/browser/changesMultiDiffSourceResolver.d.ts

@@ -0,0 +1,28 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { IMultiDiffSourceResolver, IResolvedMultiDiffSource } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/multiDiffEditor/browser/multiDiffSourceResolverService";
+import { IMultiDiffSourceResolverService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/multiDiffEditor/browser/multiDiffSourceResolverService.service";
+import { IChangesViewService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/changes/common/changesViewService.service";
+import { ISessionChangesService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/changes/browser/sessionChangesService";
+import { RawContextKey } from "@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey";
+/**
+ * Global context key holding the URIs (as strings) of every file the user has
+ * marked as reviewed in the active session. Combined with
+ * {@link SessionChangesFileResourceContext} via the `in` / `not in` operators,
+ * file toolbar menu items can toggle between "Mark as Reviewed" and
+ * "Unmark as Reviewed".
+ */
+export declare const SessionChangesReviewedFilesContext: RawContextKey<string[]>;
+/**
+ * Per-file context key set on each entry in the changes multi-diff editor.
+ * Holds the URI (as a string) of the file shown in that diff row, so it can be
+ * tested for membership in {@link SessionChangesReviewedFilesContext}.
+ */
+export declare const SessionChangesFileResourceContext: RawContextKey<string>;
+export declare class ChangesMultiDiffSourceResolver extends Disposable implements IMultiDiffSourceResolver {
+    private readonly changesViewService;
+    private readonly _sessionChangesService;
+    constructor(changesViewService: IChangesViewService, multiDiffSourceResolverService: IMultiDiffSourceResolverService, _sessionChangesService: ISessionChangesService);
+    canHandleUri(uri: URI): boolean;
+    resolveDiffSource(uri: URI): Promise<IResolvedMultiDiffSource>;
+}

package/vscode/src/vs/sessions/contrib/changes/browser/changesMultiDiffSourceResolver.js

@@ -0,0 +1,76 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { equals } from '@codingame/monaco-vscode-api/vscode/vs/base/common/arrays';
+import { isEqual } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { comparePaths } from '@codingame/monaco-vscode-api/vscode/vs/base/common/comparers';
+import { isIChatSessionFileChange2 } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService';
+import { MultiDiffEditorItem } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/multiDiffEditor/browser/multiDiffSourceResolverService';
+import { IMultiDiffSourceResolverService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/multiDiffEditor/browser/multiDiffSourceResolverService.service';
+import { IChangesViewService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/changes/common/changesViewService.service';
+import '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/changes/browser/sessionChangesService';
+import { RawContextKey } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey';
+import { derivedObservableWithCache } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/utils/utils';
+import { derivedOpts } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/derived';
+import { ValueWithChangeEventFromObservable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/utils/valueWithChangeEvent';
+import { ISessionChangesService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/changes/common/sessionChangesService.service';
+
+const SessionChangesReviewedFilesContext = new RawContextKey("sessions.changesReviewedFiles", []);
+const SessionChangesFileResourceContext = new RawContextKey("sessions.changesFileResource", undefined);
+function compareChanges(a, b) {
+    const aPath = isIChatSessionFileChange2(a) ? a.uri.fsPath : a.modifiedUri.fsPath;
+    const bPath = isIChatSessionFileChange2(b) ? b.uri.fsPath : b.modifiedUri.fsPath;
+    return comparePaths(aPath, bPath);
+}
+function getChangeResource(change) {
+    return isIChatSessionFileChange2(change) ? change.uri : change.modifiedUri;
+}
+let ChangesMultiDiffSourceResolver = class ChangesMultiDiffSourceResolver extends Disposable {
+    constructor(changesViewService, multiDiffSourceResolverService, _sessionChangesService) {
+        super();
+        this.changesViewService = changesViewService;
+        this._sessionChangesService = _sessionChangesService;
+        this._register(multiDiffSourceResolverService.registerResolver(this));
+    }
+    canHandleUri(uri) {
+        return this._sessionChangesService.getSessionResource(uri) !== undefined;
+    }
+    async resolveDiffSource(uri) {
+        const sessionResource = this._sessionChangesService.getSessionResource(uri);
+        const changesObs = derivedObservableWithCache({
+            owner: this
+        }, (reader, lastValue) => {
+            if (this.changesViewService.activeSessionLoadingObs.read(reader)) {
+                return lastValue ?? [];
+            }
+            const activeSessionResource = this.changesViewService.activeSessionResourceObs.read(reader);
+            if (!activeSessionResource || !isEqual(activeSessionResource, sessionResource)) {
+                return lastValue ?? [];
+            }
+            return this.changesViewService.activeSessionChangesObs.read(reader);
+        });
+        const resourcesObs = derivedOpts({
+            owner: this,
+            equalsFn: (a, b) => equals(
+                a,
+                b,
+                (x, y) => isEqual(x.originalUri, y.originalUri) && isEqual(x.modifiedUri, y.modifiedUri)
+            )
+        }, reader => {
+            const changes = changesObs.read(reader);
+            return [...changes].sort(compareChanges).map(change => {
+                const resource = getChangeResource(change);
+                return ( new MultiDiffEditorItem(change.originalUri, change.modifiedUri, resource, undefined, {
+                    [SessionChangesFileResourceContext.key]: ( resource.toString())
+                }));
+            });
+        });
+        return {
+            resources: ( new ValueWithChangeEventFromObservable(resourcesObs))
+        };
+    }
+};
+ChangesMultiDiffSourceResolver = ( __decorate([( __param(0, IChangesViewService)), ( __param(1, IMultiDiffSourceResolverService)), ( __param(2, ISessionChangesService))], ChangesMultiDiffSourceResolver));
+
+export { ChangesMultiDiffSourceResolver, SessionChangesFileResourceContext, SessionChangesReviewedFilesContext };

package/vscode/src/vs/sessions/contrib/changes/browser/changesViewActions.d.ts

@@ -0,0 +1 @@
+export {};