@theia/plugin-ext 1.71.0-next.72 → 1.71.0

package/src/common/plugin-api-rpc.ts

@@ -962,6 +962,17 @@ export namespace ScmCommandArg {
     }
 }
 
+export interface ScmHistoryItemCommandArg {
+    sourceControlHandle: number;
+    id: string;
+    type: 'historyItem' | 'historyItemRef';
+}
+export namespace ScmHistoryItemCommandArg {
+    export function is(arg: unknown): arg is ScmHistoryItemCommandArg {
+        return isObject(arg) && 'sourceControlHandle' in arg && 'id' in arg && 'type' in arg;
+    }
+}
+
 export interface ScmExt {
     createSourceControl(plugin: Plugin, id: string, label: string, rootUri?: theia.Uri): theia.SourceControl;
     getLastInputBox(plugin: Plugin): theia.SourceControlInputBox | undefined;
@@ -970,6 +981,11 @@ export interface ScmExt {
     $validateInput(sourceControlHandle: number, value: string, cursorPosition: number): Promise<[string, number] | undefined>;
     $setSelectedSourceControl(selectedSourceControlHandle: number | undefined): Promise<void>;
     $provideOriginalResource(sourceControlHandle: number, uri: string, token: theia.CancellationToken): Promise<UriComponents | undefined>;
+    $provideHistoryItemRefs(sourceControlHandle: number, historyItemRefs: string[] | undefined, token: theia.CancellationToken): Promise<ScmHistoryItemRefDto[] | undefined>;
+    $provideHistoryItems(sourceControlHandle: number, options: ScmHistoryOptionsDto, token: theia.CancellationToken): Promise<ScmHistoryItemDto[] | undefined>;
+    $provideHistoryItemChanges(sourceControlHandle: number, historyItemId: string, historyItemParentId: string | undefined, token: theia.CancellationToken): Promise<ScmHistoryItemChangeDto[] | undefined>;
+    $resolveHistoryItem(sourceControlHandle: number, historyItemId: string, token: theia.CancellationToken): Promise<ScmHistoryItemDto | undefined>;
+    $resolveHistoryItemRefsCommonAncestor(sourceControlHandle: number, historyItemRefs: string[], token: theia.CancellationToken): Promise<string | undefined>;
 }
 
 export namespace TimelineCommandArg {
@@ -1054,6 +1070,8 @@ export interface ScmMain {
     $setInputBoxEnabled(sourceControlHandle: number, enabled: boolean): void;
 
     $setActionButton(sourceControlHandle: number, actionButton: ScmActionButton | undefined): void;
+    $onDidChangeCurrentHistoryItemRefs(sourceControlHandle: number): void;
+    $onDidChangeHistoryItemRefs(sourceControlHandle: number, event: ScmHistoryItemRefsChangeEventDto): void;
 }
 
 export interface SourceControlProviderFeatures {
@@ -1063,6 +1081,10 @@ export interface SourceControlProviderFeatures {
     acceptInputCommand?: Command;
     statusBarCommands?: Command[];
     contextValue?: string;
+    hasHistoryProvider?: boolean;
+    currentHistoryItemRef?: ScmHistoryItemRefDto;
+    currentHistoryItemRemoteRef?: ScmHistoryItemRefDto;
+    currentHistoryItemBaseRef?: ScmHistoryItemRefDto;
 }
 
 export interface SourceControlGroupFeatures {
@@ -1099,6 +1121,56 @@ export interface ScmRawResourceSplices {
     splices: ScmRawResourceSplice[]
 }
 
+export interface ScmHistoryItemRefDto {
+    id: string;
+    name: string;
+    description?: string;
+    revision?: string;
+    icon?: UriComponents | { light: UriComponents; dark: UriComponents } | ThemeIcon;
+    category?: string;
+}
+
+export interface ScmHistoryItemRefsChangeEventDto {
+    added: ScmHistoryItemRefDto[];
+    removed: ScmHistoryItemRefDto[];
+    modified: ScmHistoryItemRefDto[];
+}
+
+export interface ScmHistoryItemStatisticsDto {
+    files: number;
+    insertions: number;
+    deletions: number;
+}
+
+export interface ScmHistoryItemDto {
+    id: string;
+    parentIds?: string[];
+    subject: string;
+    message?: string | MarkdownString;
+    author?: string;
+    authorEmail?: string;
+    authorIcon?: UriComponents | { light: UriComponents; dark: UriComponents } | ThemeIcon;
+    displayId?: string;
+    timestamp?: number;
+    tooltip?: string | MarkdownString;
+    statistics?: ScmHistoryItemStatisticsDto;
+    references?: ScmHistoryItemRefDto[];
+}
+
+export interface ScmHistoryItemChangeDto {
+    uri: UriComponents;
+    originalUri?: UriComponents;
+    modifiedUri?: UriComponents;
+    renameUri?: UriComponents;
+}
+
+export interface ScmHistoryOptionsDto {
+    skip?: number;
+    limit?: number | { id?: string };
+    historyItemRefs?: string[];
+    filterText?: string;
+}
+
 export interface SourceControlResourceState {
     readonly handle: number
     /**

package/src/main/browser/menus/menus-contribution-handler.ts

@@ -23,6 +23,7 @@ import { TabBarToolbarRegistry } from '@theia/core/lib/browser/shell/tab-bar-too
 import { DeployedPlugin, IconUrl, Menu } from '../../../common';
 import { ScmWidget } from '@theia/scm/lib/browser/scm-widget';
 import { ScmRepositoriesWidget, SCM_SOURCE_CONTROL_TITLE_MENU } from '@theia/scm/lib/browser/scm-repositories-widget';
+import { ScmHistoryGraphWidget, SCM_HISTORY_TITLE_MENU } from '@theia/scm/lib/browser/scm-history-graph-widget';
 import { KeybindingRegistry, QuickCommandService, codicon } from '@theia/core/lib/browser';
 import {
     CodeEditorWidgetUtil, codeToTheiaMappings, ContributionPoint,
@@ -63,6 +64,7 @@ export class MenusContributionPointHandler {
         });
         this.tabBarToolbar.registerMenuDelegate(PLUGIN_SCM_TITLE_MENU, widget => widget instanceof ScmWidget);
         this.tabBarToolbar.registerMenuDelegate(SCM_SOURCE_CONTROL_TITLE_MENU, widget => widget instanceof ScmRepositoriesWidget);
+        this.tabBarToolbar.registerMenuDelegate(SCM_HISTORY_TITLE_MENU, widget => widget instanceof ScmHistoryGraphWidget);
         this.tabBarToolbar.registerMenuDelegate(PLUGIN_VIEW_TITLE_MENU, widget => !CodeEditorWidgetUtil.is(widget));
     }
 

package/src/main/browser/menus/plugin-menu-command-adapter.ts

@@ -25,7 +25,7 @@ import { DirtyDiffWidget } from '@theia/scm/lib/browser/dirty-diff/dirty-diff-wi
 import { Change, LineRange } from '@theia/scm/lib/browser/dirty-diff/diff-computer';
 import { IChange } from '@theia/monaco-editor-core/esm/vs/editor/common/diff/legacyLinesDiffComputer';
 import { TimelineItem } from '@theia/timeline/lib/common/timeline-model';
-import { ScmCommandArg, TimelineCommandArg, TreeViewItemReference } from '../../../common';
+import { ScmCommandArg, ScmHistoryItemCommandArg, TimelineCommandArg, TreeViewItemReference } from '../../../common';
 import { TestItemReference, TestMessageArg } from '../../../common/test-types';
 import { PluginScmProvider, PluginScmResource, PluginScmResourceGroup } from '../scm-main';
 import { TreeViewWidget } from '../view/tree-view-widget';
@@ -70,6 +70,9 @@ export class PluginMenuCommandAdapter {
             ['scm/resourceGroup/context', toScmArgs],
             ['scm/resourceState/context', toScmArgs],
             ['scm/repository', toScmArgs],
+            ['scm/history/title', () => [this.toScmArg(this.scmService.selectedRepository)]],
+            ['scm/historyItem/context', (...args) => this.toScmHistoryArgs(...args)],
+            ['scm/historyItemRef/context', (...args) => this.toScmHistoryArgs(...args)],
             ['scm/title', () => [this.toScmArg(this.scmService.selectedRepository)]],
             ['scm/sourceControl', toScmArgs],
             ['scm/sourceControl/title', () => [this.toScmArg(this.scmService.selectedRepository)]],
@@ -148,6 +151,16 @@ export class PluginMenuCommandAdapter {
         return scmArgs;
     }
 
+    protected toScmHistoryArgs(...args: any[]): any[] {
+        const result: any[] = [];
+        for (const arg of args) {
+            if (ScmHistoryItemCommandArg.is(arg) || ScmCommandArg.is(arg)) {
+                result.push(arg);
+            }
+        }
+        return result;
+    }
+
     protected toScmArg(arg: any): ScmCommandArg | undefined {
         if (arg instanceof ScmRepository && arg.provider instanceof PluginScmProvider) {
             return {

package/src/main/browser/menus/vscode-theia-menu-mappings.ts

@@ -29,6 +29,9 @@ import { PLUGIN_SCM_CHANGE_TITLE_MENU } from '@theia/scm/lib/browser/dirty-diff/
 import {
     SCM_REPOSITORY_MENU, SCM_SOURCE_CONTROL_MENU, SCM_SOURCE_CONTROL_TITLE_MENU, SCM_TITLE_MENU
 } from '@theia/scm/lib/browser/scm-repositories-widget';
+import {
+    SCM_HISTORY_TITLE_MENU, SCM_HISTORY_ITEM_CONTEXT_MENU, SCM_HISTORY_ITEM_REF_CONTEXT_MENU
+} from '@theia/scm/lib/browser/scm-history-graph-widget';
 import { TIMELINE_ITEM_CONTEXT_MENU } from '@theia/timeline/lib/browser/timeline-tree-widget';
 import { COMMENT_CONTEXT, COMMENT_THREAD_CONTEXT, COMMENT_TITLE } from '../comments/comment-thread-widget';
 import { VIEW_ITEM_CONTEXT_MENU } from '../view/tree-view-widget';
@@ -65,6 +68,9 @@ export const implementedVSCodeContributionPoints = [
     'scm/repository',
     'scm/sourceControl',
     'scm/sourceControl/title',
+    'scm/history/title',
+    'scm/historyItem/context',
+    'scm/historyItemRef/context',
     'scm/title',
     'timeline/item/context',
     'testing/item/context',
@@ -103,6 +109,9 @@ export const codeToTheiaMappings = new Map<string, MenuPath[]>([
     ['scm/repository', [SCM_REPOSITORY_MENU]],
     ['scm/sourceControl', [SCM_SOURCE_CONTROL_MENU]],
     ['scm/sourceControl/title', [SCM_SOURCE_CONTROL_TITLE_MENU]],
+    ['scm/history/title', [SCM_HISTORY_TITLE_MENU]],
+    ['scm/historyItem/context', [SCM_HISTORY_ITEM_CONTEXT_MENU]],
+    ['scm/historyItemRef/context', [SCM_HISTORY_ITEM_REF_CONTEXT_MENU]],
     ['scm/title', [SCM_TITLE_MENU]],
     ['testing/item/context', [TEST_VIEW_CONTEXT_MENU]],
     ['testing/message/context', [TEST_RUNS_CONTEXT_MENU]],

package/src/main/browser/scm-main.ts

@@ -27,14 +27,24 @@ import {
     ScmMain,
     SourceControlProviderFeatures,
     ScmRawResourceSplices, ScmRawResourceGroup,
-    ScmActionButton as RpcScmActionButton
+    ScmActionButton as RpcScmActionButton,
+    ScmHistoryItemRefDto,
+    ScmHistoryItemDto,
+    ScmHistoryItemChangeDto,
+    ScmHistoryOptionsDto,
+    ScmHistoryItemRefsChangeEventDto
 } from '../../common/plugin-api-rpc';
-import { ScmProvider, ScmResource, ScmResourceDecorations, ScmResourceGroup, ScmCommand, ScmActionButton } from '@theia/scm/lib/browser/scm-provider';
+import {
+    ScmProvider, ScmResource, ScmResourceDecorations, ScmResourceGroup, ScmCommand, ScmActionButton,
+    ScmHistoryProvider, ScmHistoryItemRef, ScmHistoryItemRefsChangeEvent,
+    ScmHistoryOptions, ScmHistoryItem, ScmHistoryItemChange
+} from '@theia/scm/lib/browser/scm-provider';
 import { ScmRepository } from '@theia/scm/lib/browser/scm-repository';
 import { ScmService } from '@theia/scm/lib/browser/scm-service';
 import { RPCProtocol } from '../../common/rpc-protocol';
 import { interfaces } from '@theia/core/shared/inversify';
 import { Emitter, Event } from '@theia/core/lib/common/event';
+import { CancellationToken, CancellationTokenSource } from '@theia/core/lib/common/cancellation';
 import { DisposableCollection } from '@theia/core/lib/common/disposable';
 import URI from '@theia/core/lib/common/uri';
 import { URI as vscodeURI } from '@theia/core/shared/vscode-uri';
@@ -104,6 +114,198 @@ export class PluginScmResource implements ScmResource {
     }
 }
 
+function historyItemRefFromDto(dto: ScmHistoryItemRefDto): ScmHistoryItemRef {
+    return {
+        id: dto.id,
+        name: dto.name,
+        description: dto.description,
+        revision: dto.revision,
+        icon: dto.icon ? (ThemeIcon.isThemeIcon(dto.icon) ? ThemeIcon.asClassName(dto.icon) :
+            'light' in dto.icon ? vscodeURI.revive(dto.icon.light).toString() : vscodeURI.revive(dto.icon as UriComponents).toString()) : undefined,
+        category: dto.category,
+    };
+}
+
+function historyItemFromDto(dto: ScmHistoryItemDto): ScmHistoryItem {
+    return {
+        id: dto.id,
+        parentIds: dto.parentIds,
+        subject: dto.subject,
+        message: typeof dto.message === 'string' ? dto.message : dto.message?.value,
+        author: dto.author,
+        authorEmail: dto.authorEmail,
+        authorIcon: dto.authorIcon ? (ThemeIcon.isThemeIcon(dto.authorIcon) ? ThemeIcon.asClassName(dto.authorIcon) :
+            'light' in dto.authorIcon ? vscodeURI.revive(dto.authorIcon.light).toString() : vscodeURI.revive(dto.authorIcon as UriComponents).toString()) : undefined,
+        displayId: dto.displayId,
+        timestamp: dto.timestamp,
+        tooltip: typeof dto.tooltip === 'string' ? dto.tooltip : dto.tooltip?.value,
+        statistics: dto.statistics ? {
+            files: dto.statistics.files,
+            insertions: dto.statistics.insertions,
+            deletions: dto.statistics.deletions,
+        } : undefined,
+        references: dto.references ? dto.references.map(historyItemRefFromDto) : undefined,
+    };
+}
+
+function historyItemChangeFromDto(dto: ScmHistoryItemChangeDto): ScmHistoryItemChange {
+    return {
+        uri: vscodeURI.revive(dto.uri).toString(),
+        originalUri: dto.originalUri ? vscodeURI.revive(dto.originalUri).toString() : undefined,
+        modifiedUri: dto.modifiedUri ? vscodeURI.revive(dto.modifiedUri).toString() : undefined,
+        renameUri: dto.renameUri ? vscodeURI.revive(dto.renameUri).toString() : undefined,
+    };
+}
+
+export class PluginScmHistoryProvider implements ScmHistoryProvider {
+
+    private readonly onDidChangeCurrentHistoryItemRefsEmitter = new Emitter<void>();
+    readonly onDidChangeCurrentHistoryItemRefs: Event<void> = this.onDidChangeCurrentHistoryItemRefsEmitter.event;
+
+    private readonly onDidChangeHistoryItemRefsEmitter = new Emitter<ScmHistoryItemRefsChangeEvent>();
+    readonly onDidChangeHistoryItemRefs: Event<ScmHistoryItemRefsChangeEvent> = this.onDidChangeHistoryItemRefsEmitter.event;
+
+    private _currentHistoryItemRef: ScmHistoryItemRef | undefined;
+    get currentHistoryItemRef(): ScmHistoryItemRef | undefined { return this._currentHistoryItemRef; }
+
+    private _currentHistoryItemRemoteRef: ScmHistoryItemRef | undefined;
+    get currentHistoryItemRemoteRef(): ScmHistoryItemRef | undefined { return this._currentHistoryItemRemoteRef; }
+
+    private _currentHistoryItemBaseRef: ScmHistoryItemRef | undefined;
+    get currentHistoryItemBaseRef(): ScmHistoryItemRef | undefined { return this._currentHistoryItemBaseRef; }
+
+    private readonly disposables = new DisposableCollection();
+    private pendingRequests = new Set<CancellationTokenSource>();
+
+    constructor(
+        private readonly proxy: ScmExt,
+        private readonly handle: number
+    ) {
+        this.disposables.push(this.onDidChangeCurrentHistoryItemRefsEmitter);
+        this.disposables.push(this.onDidChangeHistoryItemRefsEmitter);
+    }
+
+    updateFromFeatures(features: SourceControlProviderFeatures): void {
+        if (features.currentHistoryItemRef !== undefined) {
+            this._currentHistoryItemRef = features.currentHistoryItemRef ? historyItemRefFromDto(features.currentHistoryItemRef) : undefined;
+        }
+        if (features.currentHistoryItemRemoteRef !== undefined) {
+            this._currentHistoryItemRemoteRef = features.currentHistoryItemRemoteRef ? historyItemRefFromDto(features.currentHistoryItemRemoteRef) : undefined;
+        }
+        if (features.currentHistoryItemBaseRef !== undefined) {
+            this._currentHistoryItemBaseRef = features.currentHistoryItemBaseRef ? historyItemRefFromDto(features.currentHistoryItemBaseRef) : undefined;
+        }
+    }
+
+    fireDidChangeCurrentHistoryItemRefs(): void {
+        this.onDidChangeCurrentHistoryItemRefsEmitter.fire();
+    }
+
+    fireDidChangeHistoryItemRefs(event: ScmHistoryItemRefsChangeEventDto): void {
+        this.onDidChangeHistoryItemRefsEmitter.fire({
+            added: event.added.map(historyItemRefFromDto),
+            removed: event.removed.map(historyItemRefFromDto),
+            modified: event.modified.map(historyItemRefFromDto),
+        });
+    }
+
+    async provideHistoryItemRefs(historyItemRefs: string[] | undefined, token: CancellationToken): Promise<ScmHistoryItemRef[] | undefined> {
+        const cts = new CancellationTokenSource();
+        const listener = token.onCancellationRequested(() => cts.cancel());
+        this.pendingRequests.add(cts);
+        try {
+            const result = await this.proxy.$provideHistoryItemRefs(this.handle, historyItemRefs, cts.token);
+            if (!result) {
+                return undefined;
+            }
+            return result.map(historyItemRefFromDto);
+        } finally {
+            listener.dispose();
+            this.pendingRequests.delete(cts);
+            cts.dispose();
+        }
+    }
+
+    async provideHistoryItems(options: ScmHistoryOptions, token: CancellationToken): Promise<ScmHistoryItem[] | undefined> {
+        const dto: ScmHistoryOptionsDto = {
+            skip: options.skip,
+            limit: options.limit,
+            historyItemRefs: options.historyItemRefs ? [...options.historyItemRefs] : undefined,
+            filterText: options.filterText,
+        };
+        const cts = new CancellationTokenSource();
+        const listener = token.onCancellationRequested(() => cts.cancel());
+        this.pendingRequests.add(cts);
+        try {
+            const result = await this.proxy.$provideHistoryItems(this.handle, dto, cts.token);
+            if (!result) {
+                return undefined;
+            }
+            return result.map(historyItemFromDto);
+        } finally {
+            listener.dispose();
+            this.pendingRequests.delete(cts);
+            cts.dispose();
+        }
+    }
+
+    async provideHistoryItemChanges(historyItemId: string, historyItemParentId: string | undefined, token: CancellationToken): Promise<ScmHistoryItemChange[] | undefined> {
+        const cts = new CancellationTokenSource();
+        const listener = token.onCancellationRequested(() => cts.cancel());
+        this.pendingRequests.add(cts);
+        try {
+            const result = await this.proxy.$provideHistoryItemChanges(this.handle, historyItemId, historyItemParentId, cts.token);
+            if (!result) {
+                return undefined;
+            }
+            return result.map(historyItemChangeFromDto);
+        } finally {
+            listener.dispose();
+            this.pendingRequests.delete(cts);
+            cts.dispose();
+        }
+    }
+
+    async resolveHistoryItem(historyItemId: string, token: CancellationToken): Promise<ScmHistoryItem | undefined> {
+        const cts = new CancellationTokenSource();
+        const listener = token.onCancellationRequested(() => cts.cancel());
+        this.pendingRequests.add(cts);
+        try {
+            const result = await this.proxy.$resolveHistoryItem(this.handle, historyItemId, cts.token);
+            if (!result) {
+                return undefined;
+            }
+            return historyItemFromDto(result);
+        } finally {
+            listener.dispose();
+            this.pendingRequests.delete(cts);
+            cts.dispose();
+        }
+    }
+
+    async resolveHistoryItemRefsCommonAncestor(historyItemRefs: string[], token: CancellationToken): Promise<string | undefined> {
+        const cts = new CancellationTokenSource();
+        const listener = token.onCancellationRequested(() => cts.cancel());
+        this.pendingRequests.add(cts);
+        try {
+            return await this.proxy.$resolveHistoryItemRefsCommonAncestor(this.handle, historyItemRefs, cts.token) ?? undefined;
+        } finally {
+            listener.dispose();
+            this.pendingRequests.delete(cts);
+            cts.dispose();
+        }
+    }
+
+    dispose(): void {
+        for (const cts of this.pendingRequests) {
+            cts.cancel();
+            cts.dispose();
+        }
+        this.pendingRequests.clear();
+        this.disposables.dispose();
+    }
+}
+
 export class PluginScmProvider implements ScmProvider {
 
     private _id = this.contextValue;
@@ -118,6 +320,11 @@ export class PluginScmProvider implements ScmProvider {
     private _actionButton: ScmActionButton | undefined;
     get actionButton(): ScmActionButton | undefined { return this._actionButton; }
 
+    private _historyProvider: PluginScmHistoryProvider | undefined;
+    get historyProvider(): ScmHistoryProvider | undefined {
+        return this._historyProvider;
+    }
+
     private features: SourceControlProviderFeatures = {};
 
     get providerContextValue(): string | undefined { return this.features.contextValue; }
@@ -172,8 +379,22 @@ export class PluginScmProvider implements ScmProvider {
 
     updateSourceControl(features: SourceControlProviderFeatures): void {
         this.features = { ...this.features, ...features };
+
+        if (typeof features.hasHistoryProvider !== 'undefined') {
+            if (features.hasHistoryProvider && !this._historyProvider) {
+                this._historyProvider = new PluginScmHistoryProvider(this.proxy, this.handle);
+            } else if (!features.hasHistoryProvider && this._historyProvider) {
+                this._historyProvider.dispose();
+                this._historyProvider = undefined;
+            }
+        }
+
         this.onDidChangeEmitter.fire();
 
+        if (this._historyProvider) {
+            this._historyProvider.updateFromFeatures(features);
+        }
+
         if (typeof features.commitTemplate !== 'undefined') {
             this.onDidChangeCommitTemplateEmitter.fire(this.commitTemplate!);
         }
@@ -303,7 +524,10 @@ export class PluginScmProvider implements ScmProvider {
         this.onDidChangeActionButtonEmitter.fire(actionButton);
     }
 
-    dispose(): void { }
+    dispose(): void {
+        this._historyProvider?.dispose();
+        this._historyProvider = undefined;
+    }
 }
 
 export class ScmMainImpl implements ScmMain {
@@ -546,4 +770,24 @@ export class ScmMainImpl implements ScmMain {
 
         provider.updateActionButton(converted);
     }
+
+    $onDidChangeCurrentHistoryItemRefs(sourceControlHandle: number): void {
+        const repository = this.repositories.get(sourceControlHandle);
+        if (!repository) {
+            return;
+        }
+        const provider = repository.provider as PluginScmProvider;
+        const historyProvider = provider.historyProvider as PluginScmHistoryProvider | undefined;
+        historyProvider?.fireDidChangeCurrentHistoryItemRefs();
+    }
+
+    $onDidChangeHistoryItemRefs(sourceControlHandle: number, event: ScmHistoryItemRefsChangeEventDto): void {
+        const repository = this.repositories.get(sourceControlHandle);
+        if (!repository) {
+            return;
+        }
+        const provider = repository.provider as PluginScmProvider;
+        const historyProvider = provider.historyProvider as PluginScmHistoryProvider | undefined;
+        historyProvider?.fireDidChangeHistoryItemRefs(event);
+    }
 }