@codingame/monaco-vscode-scm-service-override 9.0.2 → 10.0.0

package/vscode/src/vs/workbench/contrib/scm/browser/scmHistoryViewPane.js

@@ -1,20 +1,19 @@
 import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
 import './media/scm.css.js';
-import { Event } from 'vscode/vscode/vs/base/common/event';
 import { language } from 'vscode/vscode/vs/base/common/platform';
-import { append, $ } from 'vscode/vscode/vs/base/browser/dom';
-import { getDefaultHoverDelegate } from 'vscode/vscode/vs/base/browser/ui/hover/hoverDelegateFactory';
+import { $, reset, append, h } from 'vscode/vscode/vs/base/browser/dom';
 import { IconLabel } from 'vscode/vscode/vs/base/browser/ui/iconLabel/iconLabel';
 import { fromNow } from 'vscode/vscode/vs/base/common/date';
 import { createMatches } from 'vscode/vscode/vs/base/common/filters';
 import { MarkdownString } from 'vscode/vscode/vs/base/common/htmlContent';
-import { DisposableStore, combinedDisposable, Disposable, DisposableMap } from 'vscode/vscode/vs/base/common/lifecycle';
+import { DisposableStore, Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
 import { observableValue } from 'vscode/vscode/vs/base/common/observableInternal/base';
-import 'vscode/vscode/vs/base/common/observableInternal/derived';
+import { tail, delta, groupBy as groupBy$1 } from 'vscode/vscode/vs/base/common/arrays';
+import { Event } from 'vscode/vscode/vs/base/common/event';
 import { autorun, autorunWithStore } from 'vscode/vscode/vs/base/common/observableInternal/autorun';
-import 'vscode/vscode/vs/base/common/observableInternal/utils';
-import 'vscode/vscode/vs/base/common/cancellation';
-import { tail } from 'vscode/vscode/vs/base/common/arrays';
+import { derived } from 'vscode/vscode/vs/base/common/observableInternal/derived';
+import { waitForState } from 'vscode/vscode/vs/base/common/observableInternal/utilsCancellation';
+import { observableFromEvent, constObservable, latestChangedValue, observableSignal, runOnChange } from 'vscode/vscode/vs/base/common/observableInternal/utils';
 import { ThemeIcon } from 'vscode/vscode/vs/base/common/themables';
 import { localize } from 'vscode/vscode/vs/nls';
 import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration.service';
@@ -26,11 +25,10 @@ import { IHoverService } from 'vscode/vscode/vs/platform/hover/browser/hover.ser
 import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
 import { IKeybindingService } from 'vscode/vscode/vs/platform/keybinding/common/keybinding.service';
 import { WorkbenchAsyncDataTree } from 'vscode/vscode/vs/platform/list/browser/listService';
-import { observableConfigValue } from 'vscode/vscode/vs/platform/observable/common/platformObservableUtils';
 import { IOpenerService } from 'vscode/vscode/vs/platform/opener/common/opener.service';
 import { ITelemetryService } from 'vscode/vscode/vs/platform/telemetry/common/telemetry.service';
-import { registerColor } from 'vscode/vscode/vs/platform/theme/common/colorUtils';
-import 'vscode/vscode/vs/platform/theme/common/colors/baseColors';
+import { asCssVariable } from 'vscode/vscode/vs/platform/theme/common/colorUtils';
+import { foreground } from 'vscode/vscode/vs/platform/theme/common/colors/baseColors';
 import 'vscode/vscode/vs/platform/theme/common/colors/chartsColors';
 import 'vscode/vscode/vs/platform/theme/common/colors/editorColors';
 import 'vscode/vscode/vs/platform/theme/common/colors/inputColors';
@@ -41,59 +39,234 @@ import 'vscode/vscode/vs/platform/theme/common/colors/miscColors';
 import 'vscode/vscode/vs/platform/theme/common/colors/quickpickColors';
 import 'vscode/vscode/vs/platform/theme/common/colors/searchColors';
 import { IThemeService } from 'vscode/vscode/vs/platform/theme/common/themeService.service';
-import { ViewAction, ViewPane } from 'vscode/vscode/vs/workbench/browser/parts/views/viewPane';
-import { ViewContainerLocation } from 'vscode/vscode/vs/workbench/common/views';
+import { ViewAction, ViewPane, ViewPaneShowActions } from 'vscode/vscode/vs/workbench/browser/parts/views/viewPane';
 import { IViewDescriptorService } from 'vscode/vscode/vs/workbench/common/views.service';
-import { renderSCMHistoryItemGraph, historyItemGroupLocal, historyItemGroupRemote, historyItemGroupBase, historyItemGroupHoverLabelForeground, SWIMLANE_WIDTH, renderSCMHistoryGraphPlaceholder, toISCMHistoryItemViewModelArray } from './scmHistory.js';
-import { RepositoryActionRunner } from './scmRepositoryRenderer.js';
-import { isSCMRepository, isSCMHistoryItemViewModelTreeElement, isSCMHistoryItemLoadMoreTreeElement, connectPrimaryMenu, isSCMViewService, getActionViewItemProvider, collectContextMenuActions } from './util.js';
+import { renderSCMHistoryItemGraph, historyItemHoverLabelForeground, historyItemHoverDefaultLabelBackground, historyItemHoverAdditionsForeground, historyItemHoverDeletionsForeground, historyItemHoverDefaultLabelForeground, SWIMLANE_WIDTH, renderSCMHistoryGraphPlaceholder, toISCMHistoryItemViewModelArray } from 'vscode/vscode/vs/workbench/contrib/scm/browser/scmHistory';
+import { getHistoryItemEditorTitle, isSCMHistoryItemViewModelTreeElement, isSCMHistoryItemLoadMoreTreeElement, isSCMRepository, getProviderKey } from 'vscode/vscode/vs/workbench/contrib/scm/browser/util';
 import { HISTORY_VIEW_PANE_ID } from 'vscode/vscode/vs/workbench/contrib/scm/common/scm';
 import { ISCMService, ISCMViewService } from 'vscode/vscode/vs/workbench/contrib/scm/common/scm.service';
 import { stripIcons } from 'vscode/vscode/vs/base/common/iconLabels';
-import { Position } from 'vscode/vscode/vs/workbench/services/layout/browser/layoutService';
 import { IWorkbenchLayoutService } from 'vscode/vscode/vs/workbench/services/layout/browser/layoutService.service';
-import { HoverPosition } from 'vscode/vscode/vs/base/browser/ui/hover/hoverWidget';
-import { registerAction2, MenuId, MenuItemAction } from 'vscode/vscode/vs/platform/actions/common/actions';
-import { IMenuService } from 'vscode/vscode/vs/platform/actions/common/actions.service';
-import { Iterable } from 'vscode/vscode/vs/base/common/iterator';
+import { registerAction2, MenuId, Action2 } from 'vscode/vscode/vs/platform/actions/common/actions';
 import { Sequencer, Throttler } from 'vscode/vscode/vs/base/common/async';
 import { URI } from 'vscode/vscode/vs/base/common/uri';
 import { ICommandService } from 'vscode/vscode/vs/platform/commands/common/commands.service';
 import { ActionRunner } from 'vscode/vscode/vs/base/common/actions';
 import { Codicon } from 'vscode/vscode/vs/base/common/codicons';
-import { ContextKeys } from './scmViewPane.js';
-import { WorkbenchToolBar } from 'vscode/vscode/vs/platform/actions/browser/toolbar';
 import { IProgressService } from 'vscode/vscode/vs/platform/progress/common/progress.service';
+import { ContextKeys } from './scmViewPane.js';
+import { ActionViewItem } from 'vscode/vscode/vs/base/browser/ui/actionbar/actionViewItems';
+import { IQuickInputService } from 'vscode/vscode/vs/platform/quickinput/common/quickInput.service';
+import { Iterable } from 'vscode/vscode/vs/base/common/iterator';
+import { clamp } from 'vscode/vscode/vs/base/common/numbers';
+import { observableConfigValue } from 'vscode/vscode/vs/platform/observable/common/platformObservableUtils';
+import { compare } from 'vscode/vscode/vs/base/common/strings';
+import { IClipboardService } from 'vscode/vscode/vs/platform/clipboard/common/clipboardService.service';
+import { getDefaultHoverDelegate } from 'vscode/vscode/vs/base/browser/ui/hover/hoverDelegateFactory';
+import { IStorageService } from 'vscode/vscode/vs/platform/storage/common/storage.service';
+import { INotificationService } from 'vscode/vscode/vs/platform/notification/common/notification.service';
+import { IExtensionService } from 'vscode/vscode/vs/workbench/services/extensions/common/extensions.service';
+import { groupBy } from 'vscode/vscode/vs/base/common/collections';
 
-var RepositoryRenderer_1, HistoryItemRenderer_1, HistoryItemLoadMoreRenderer_1;
-const historyItemAdditionsForeground = registerColor('scmGraph.historyItemHoverAdditionsForeground', 'gitDecoration.addedResourceForeground', ( localize(6467, "History item hover additions foreground color.")));
-const historyItemDeletionsForeground = registerColor('scmGraph.historyItemHoverDeletionsForeground', 'gitDecoration.deletedResourceForeground', ( localize(6468, "History item hover deletions foreground color.")));
+var HistoryItemRenderer_1, HistoryItemLoadMoreRenderer_1;
+const PICK_REPOSITORY_ACTION_ID = 'workbench.scm.action.graph.pickRepository';
+const PICK_HISTORY_ITEM_REFS_ACTION_ID = 'workbench.scm.action.graph.pickHistoryItemRefs';
+class SCMRepositoryActionViewItem extends ActionViewItem {
+    constructor(_repository, action, options) {
+        super(null, action, { ...options, icon: false, label: true });
+        this._repository = _repository;
+    }
+    updateLabel() {
+        if (this.options.label && this.label) {
+            this.label.classList.add('scm-graph-repository-picker');
+            const icon = $('.icon');
+            icon.classList.add(...ThemeIcon.asClassNameArray(Codicon.repo));
+            const name = $('.name');
+            name.textContent = this._repository.provider.name;
+            reset(this.label, icon, name);
+        }
+    }
+    getTooltip() {
+        return this._repository.provider.name;
+    }
+}
+class SCMHistoryItemRefsActionViewItem extends ActionViewItem {
+    constructor(_repository, _historyItemsFilter, action, options) {
+        super(null, action, { ...options, icon: false, label: true });
+        this._repository = _repository;
+        this._historyItemsFilter = _historyItemsFilter;
+    }
+    updateLabel() {
+        if (this.options.label && this.label) {
+            this.label.classList.add('scm-graph-history-item-picker');
+            const icon = $('.icon');
+            icon.classList.add(...ThemeIcon.asClassNameArray(Codicon.gitBranch));
+            const name = $('.name');
+            if (this._historyItemsFilter === 'all') {
+                name.textContent = ( localize(6622, "All"));
+            }
+            else if (this._historyItemsFilter === 'auto') {
+                name.textContent = ( localize(6623, "Auto"));
+            }
+            else if (this._historyItemsFilter.length === 1) {
+                name.textContent = this._historyItemsFilter[0].name;
+            }
+            else {
+                name.textContent = ( localize(6624, "{0} Items", this._historyItemsFilter.length));
+            }
+            reset(this.label, icon, name);
+        }
+    }
+    getTooltip() {
+        if (this._historyItemsFilter === 'all') {
+            return ( localize(6625, "All history item references"));
+        }
+        else if (this._historyItemsFilter === 'auto') {
+            const historyProvider = this._repository.provider.historyProvider.get();
+            return [
+                historyProvider?.historyItemRef.get()?.name,
+                historyProvider?.historyItemRemoteRef.get()?.name,
+                historyProvider?.historyItemBaseRef.get()?.name
+            ].filter(ref => !!ref).join(', ');
+        }
+        else if (this._historyItemsFilter.length === 1) {
+            return this._historyItemsFilter[0].name;
+        }
+        else {
+            return ( (this._historyItemsFilter.map(ref => ref.name))).join(', ');
+        }
+    }
+}
 registerAction2(class extends ViewAction {
     constructor() {
         super({
-            id: 'workbench.scm.action.refreshGraph',
-            title: ( localize(6469, "Refresh")),
+            id: PICK_REPOSITORY_ACTION_ID,
+            title: ( localize(6626, "Repository Picker")),
             viewId: HISTORY_VIEW_PANE_ID,
             f1: false,
-            icon: Codicon.refresh,
             menu: {
                 id: MenuId.SCMHistoryTitle,
-                when: ( (ContextKeyExpr.or(
-                     (ContextKeyExpr.has('scmRepository')),
-                     (ContextKeyExpr.and(
-                         (ContextKeys.RepositoryVisibilityCount.isEqualTo(1)),
-                         (ContextKeyExpr.equals('config.scm.alwaysShowRepositories', false))
-                    ))
+                when: ( (ContextKeyExpr.and(
+                     (ContextKeyExpr.has('scm.providerCount')),
+                    ContextKeyExpr.greater('scm.providerCount', 1)
                 ))),
                 group: 'navigation',
+                order: 0
+            }
+        });
+    }
+    async runInView(_, view) {
+        view.pickRepository();
+    }
+});
+registerAction2(class extends ViewAction {
+    constructor() {
+        super({
+            id: PICK_HISTORY_ITEM_REFS_ACTION_ID,
+            title: ( localize(6627, "History Item Reference Picker")),
+            icon: Codicon.gitBranch,
+            viewId: HISTORY_VIEW_PANE_ID,
+            precondition: ( (ContextKeys.SCMHistoryItemCount.notEqualsTo(0))),
+            f1: false,
+            menu: {
+                id: MenuId.SCMHistoryTitle,
+                group: 'navigation',
+                order: 1
+            }
+        });
+    }
+    async runInView(_, view) {
+        view.pickHistoryItemRef();
+    }
+});
+registerAction2(class extends ViewAction {
+    constructor() {
+        super({
+            id: 'workbench.scm.action.graph.revealCurrentHistoryItem',
+            title: ( localize(6628, "Go to Current History Item")),
+            icon: Codicon.target,
+            viewId: HISTORY_VIEW_PANE_ID,
+            precondition: ( (ContextKeys.SCMHistoryItemCount.notEqualsTo(0))),
+            f1: false,
+            menu: {
+                id: MenuId.SCMHistoryTitle,
+                group: 'navigation',
+                order: 2
+            }
+        });
+    }
+    async runInView(_, view) {
+        view.revealCurrentHistoryItem();
+    }
+});
+registerAction2(class extends ViewAction {
+    constructor() {
+        super({
+            id: 'workbench.scm.action.graph.refresh',
+            title: ( localize(6629, "Refresh")),
+            viewId: HISTORY_VIEW_PANE_ID,
+            f1: false,
+            icon: Codicon.refresh,
+            menu: {
+                id: MenuId.SCMHistoryTitle,
+                group: 'navigation',
                 order: 1000
             }
         });
     }
-    async runInView(accessor, view, provider) {
-        const scmService = accessor.get(ISCMService);
-        const repository = provider ? scmService.getRepository(provider.id) : undefined;
-        view.refresh(repository);
+    async runInView(_, view) {
+        view.refresh();
+    }
+});
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: 'workbench.scm.action.graph.viewChanges',
+            title: ( localize(6630, "View Changes")),
+            f1: false,
+            menu: [
+                {
+                    id: MenuId.SCMChangesContext,
+                    group: '0_view',
+                    when: ( (ContextKeyExpr.equals('config.multiDiffEditor.experimental.enabled', true)))
+                }
+            ]
+        });
+    }
+    async run(accessor, provider, ...historyItems) {
+        const commandService = accessor.get(ICommandService);
+        if (!provider || historyItems.length === 0) {
+            return;
+        }
+        const historyItem = historyItems[0];
+        const historyItemLast = historyItems[historyItems.length - 1];
+        const historyProvider = provider.historyProvider.get();
+        if (historyItems.length > 1) {
+            const ancestor = await historyProvider?.resolveHistoryItemRefsCommonAncestor([historyItem.id, historyItemLast.id]);
+            if (!ancestor || (ancestor !== historyItem.id && ancestor !== historyItemLast.id)) {
+                return;
+            }
+        }
+        const historyItemParentId = historyItemLast.parentIds.length > 0 ? historyItemLast.parentIds[0] : undefined;
+        const historyItemChanges = await historyProvider?.provideHistoryItemChanges(historyItem.id, historyItemParentId);
+        if (!historyItemChanges?.length) {
+            return;
+        }
+        const title = historyItems.length === 1 ?
+            getHistoryItemEditorTitle(historyItem) :
+            ( localize(
+                6631,
+                "All Changes ({0} ↔ {1})",
+                historyItemLast.displayId ?? historyItemLast.id,
+                historyItem.displayId ?? historyItem.id
+            ));
+        const rootUri = provider.rootUri;
+        const path = rootUri ? rootUri.path : provider.label;
+        const multiDiffSourceUri = ( (URI.from(
+            { scheme: 'scm-history-item', path: `${path}/${historyItemParentId}..${historyItem.id}` },
+            true
+        )));
+        commandService.executeCommand('_workbench.openMultiDiffEditor', { title, multiDiffSourceUri, resources: historyItemChanges });
     }
 });
 class ListDelegate {
@@ -101,10 +274,7 @@ class ListDelegate {
         return 22;
     }
     getTemplateId(element) {
-        if (isSCMRepository(element)) {
-            return RepositoryRenderer.TEMPLATE_ID;
-        }
-        else if (isSCMHistoryItemViewModelTreeElement(element)) {
+        if (isSCMHistoryItemViewModelTreeElement(element)) {
             return HistoryItemRenderer.TEMPLATE_ID;
         }
         else if (isSCMHistoryItemLoadMoreTreeElement(element)) {
@@ -115,94 +285,17 @@ class ListDelegate {
         }
     }
 }
-let RepositoryRenderer = class RepositoryRenderer {
-    static { RepositoryRenderer_1 = this; }
-    static { this.TEMPLATE_ID = 'repository'; }
-    get templateId() { return RepositoryRenderer_1.TEMPLATE_ID; }
-    constructor(description, actionRunner, actionViewItemProvider, commandService, contextKeyService, contextMenuService, hoverService, keybindingService, menuService, telemetryService) {
-        this.description = description;
-        this.actionRunner = actionRunner;
-        this.actionViewItemProvider = actionViewItemProvider;
-        this.commandService = commandService;
-        this.contextKeyService = contextKeyService;
-        this.contextMenuService = contextMenuService;
-        this.hoverService = hoverService;
-        this.keybindingService = keybindingService;
-        this.menuService = menuService;
-        this.telemetryService = telemetryService;
-    }
-    renderTemplate(container) {
-        if (container.classList.contains('monaco-tl-contents')) {
-            container.parentElement.parentElement.querySelector('.monaco-tl-twistie').classList.add('force-twistie');
-        }
-        const element = append(container, $('.scm-provider'));
-        const label = ( (new IconLabel(element)));
-        const labelCustomHover = this.hoverService.setupManagedHover(getDefaultHoverDelegate('mouse'), label.element, '', {});
-        const stateLabel = append(element, $('div.state-label.monaco-count-badge.long'));
-        const toolBar = ( (new WorkbenchToolBar(
-            append(element, $('.actions')),
-            { actionRunner: this.actionRunner, actionViewItemProvider: this.actionViewItemProvider, resetMenu: MenuId.SCMHistoryTitle },
-            this.menuService,
-            this.contextKeyService,
-            this.contextMenuService,
-            this.keybindingService,
-            this.commandService,
-            this.telemetryService
-        )));
-        return { label, labelCustomHover, stateLabel, toolBar, elementDisposables: ( (new DisposableStore())), templateDisposable: combinedDisposable(labelCustomHover, toolBar) };
-    }
-    renderElement(arg, index, templateData, height) {
-        const repository = isSCMRepository(arg) ? arg : arg.element;
-        templateData.elementDisposables.add(autorun(reader => {
-            const description = this.description(repository).read(reader);
-            templateData.stateLabel.style.display = description !== '' ? '' : 'none';
-            templateData.stateLabel.textContent = description;
-        }));
-        templateData.label.setLabel(repository.provider.name);
-        templateData.labelCustomHover.update(repository.provider.rootUri ? `${repository.provider.label}: ${repository.provider.rootUri.fsPath}` : repository.provider.label);
-        templateData.elementDisposables.add(autorunWithStore((reader, store) => {
-            const currentHistoryItemGroup = repository.provider.historyProvider.read(reader)?.currentHistoryItemGroup.read(reader);
-            if (!currentHistoryItemGroup) {
-                templateData.toolBar.setActions([], []);
-                return;
-            }
-            const contextKeyService = this.contextKeyService.createOverlay([
-                ['scmRepository', repository.id],
-                ['scmProvider', repository.provider.contextValue],
-                ['scmHistoryItemGroupHasRemote', !!currentHistoryItemGroup.remote],
-            ]);
-            const menu = this.menuService.createMenu(MenuId.SCMHistoryTitle, contextKeyService);
-            store.add(connectPrimaryMenu(menu, (primary, secondary) => {
-                templateData.toolBar.setActions(primary, secondary);
-            }));
-        }));
-        templateData.toolBar.context = repository.provider;
-    }
-    disposeElement(group, index, template) {
-        template.elementDisposables.clear();
-    }
-    disposeTemplate(templateData) {
-        templateData.elementDisposables.dispose();
-        templateData.templateDisposable.dispose();
-    }
-};
-RepositoryRenderer = RepositoryRenderer_1 = ( (__decorate([
-    ( (__param(3, ICommandService))),
-    ( (__param(4, IContextKeyService))),
-    ( (__param(5, IContextMenuService))),
-    ( (__param(6, IHoverService))),
-    ( (__param(7, IKeybindingService))),
-    ( (__param(8, IMenuService))),
-    ( (__param(9, ITelemetryService)))
-], RepositoryRenderer)));
 let HistoryItemRenderer = class HistoryItemRenderer {
     static { HistoryItemRenderer_1 = this; }
     static { this.TEMPLATE_ID = 'history-item'; }
     get templateId() { return HistoryItemRenderer_1.TEMPLATE_ID; }
-    constructor(hoverDelegate, hoverService, themeService) {
+    constructor(hoverDelegate, _clipboardService, _configurationService, _hoverService, _themeService) {
         this.hoverDelegate = hoverDelegate;
-        this.hoverService = hoverService;
-        this.themeService = themeService;
+        this._clipboardService = _clipboardService;
+        this._configurationService = _configurationService;
+        this._hoverService = _hoverService;
+        this._themeService = _themeService;
+        this._badgesConfig = observableConfigValue('scm.graph.badges', 'filter', this._configurationService);
     }
     renderTemplate(container) {
         container.parentElement.parentElement.querySelector('.monaco-tl-twistie').classList.add('force-no-twistie');
@@ -219,39 +312,77 @@ let HistoryItemRenderer = class HistoryItemRenderer {
     renderElement(node, index, templateData, height) {
         const historyItemViewModel = node.element.historyItemViewModel;
         const historyItem = historyItemViewModel.historyItem;
-        const historyItemHover = this.hoverService.setupManagedHover(this.hoverDelegate, templateData.element, this.getTooltip(node.element));
+        const historyItemHover = this._hoverService.setupManagedHover(this.hoverDelegate, templateData.element, this._getHoverContent(node.element), {
+            actions: this._getHoverActions(historyItem),
+        });
         templateData.elementDisposables.add(historyItemHover);
         templateData.graphContainer.textContent = '';
+        templateData.graphContainer.classList.toggle('current', historyItemViewModel.isCurrent);
         templateData.graphContainer.appendChild(renderSCMHistoryItemGraph(historyItemViewModel));
-        const [matches, descriptionMatches] = this.processMatches(historyItemViewModel, node.filterData);
-        templateData.label.setLabel(historyItem.message, historyItem.author, { matches, descriptionMatches });
-        templateData.labelContainer.textContent = '';
-        if (historyItem.labels) {
-            const labels = this.getLabels(node.element.repository);
-            for (const label of historyItem.labels) {
-                if (label.icon && ThemeIcon.isThemeIcon(label.icon) && labels.includes(label.title)) {
-                    const icon = append(templateData.labelContainer, $('div.label'));
-                    icon.classList.add(...ThemeIcon.asClassNameArray(label.icon));
+        const provider = node.element.repository.provider;
+        const historyItemRef = provider.historyProvider.get()?.historyItemRef?.get();
+        const extraClasses = historyItemRef?.revision === historyItem.id ? ['history-item-current'] : [];
+        const [matches, descriptionMatches] = this._processMatches(historyItemViewModel, node.filterData);
+        templateData.label.setLabel(historyItem.subject, historyItem.author, { matches, descriptionMatches, extraClasses });
+        this._renderBadges(historyItem, templateData);
+    }
+    _renderBadges(historyItem, templateData) {
+        templateData.elementDisposables.add(autorun(reader => {
+            const labelConfig = this._badgesConfig.read(reader);
+            const firstColoredRef = historyItem.references?.find(ref => ref.color);
+            templateData.labelContainer.textContent = '';
+            const historyItemRefsByColor = groupBy((historyItem.references ?? []), ref => ref.color ? ref.color : '');
+            for (const [key, historyItemRefs] of Object.entries(historyItemRefsByColor)) {
+                if (key === '' && labelConfig !== 'all') {
+                    continue;
+                }
+                const historyItemRefByIconId = groupBy(historyItemRefs, ref => ThemeIcon.isThemeIcon(ref.icon) ? ref.icon.id : '');
+                for (const [key, historyItemRefs] of Object.entries(historyItemRefByIconId)) {
+                    if (key === '' || historyItemRefs.length === 0) {
+                        continue;
+                    }
+                    this._renderBadge(historyItemRefs[0], historyItemRefs[0] === firstColoredRef, templateData);
                 }
             }
-        }
+        }));
     }
-    getLabels(repository) {
-        const currentHistoryItemGroup = repository.provider.historyProvider.get()?.currentHistoryItemGroup.get();
-        if (!currentHistoryItemGroup) {
-            return [];
+    _renderBadge(historyItemRef, showDescription, templateData) {
+        if (!ThemeIcon.isThemeIcon(historyItemRef.icon)) {
+            return;
         }
+        const elements = h('div.label', {
+            style: {
+                color: historyItemRef.color ? asCssVariable(historyItemHoverLabelForeground) : asCssVariable(foreground),
+                backgroundColor: historyItemRef.color ? asCssVariable(historyItemRef.color) : asCssVariable(historyItemHoverDefaultLabelBackground)
+            }
+        }, [
+            h('div.icon@icon'),
+            h('div.description@description')
+        ]);
+        elements.icon.classList.add(...ThemeIcon.asClassNameArray(historyItemRef.icon));
+        elements.description.textContent = historyItemRef.name;
+        elements.description.style.display = showDescription ? '' : 'none';
+        append(templateData.labelContainer, elements.root);
+    }
+    _getHoverActions(historyItem) {
         return [
-            currentHistoryItemGroup.name,
-            currentHistoryItemGroup.remote?.name,
-            currentHistoryItemGroup.base?.name
-        ]
-            .filter(l => l !== undefined);
-    }
-    getTooltip(element) {
-        const colorTheme = this.themeService.getColorTheme();
+            {
+                commandId: 'workbench.scm.action.graph.copyHistoryItemId',
+                iconClass: 'codicon.codicon-copy',
+                label: historyItem.displayId ?? historyItem.id,
+                run: () => this._clipboardService.writeText(historyItem.id)
+            },
+            {
+                commandId: 'workbench.scm.action.graph.copyHistoryItemMessage',
+                iconClass: 'codicon.codicon-copy',
+                label: ( localize(6632, "Message")),
+                run: () => this._clipboardService.writeText(historyItem.message)
+            }
+        ];
+    }
+    _getHoverContent(element) {
+        const colorTheme = this._themeService.getColorTheme();
         const historyItem = element.historyItemViewModel.historyItem;
-        const currentHistoryItemGroup = element.repository.provider.historyProvider.get()?.currentHistoryItemGroup?.get();
         const markdown = ( (new MarkdownString('', { isTrusted: true, supportThemeIcons: true })));
         if (historyItem.author) {
             markdown.appendMarkdown(`$(account) **${historyItem.author}**`);
@@ -265,42 +396,33 @@ let HistoryItemRenderer = class HistoryItemRenderer {
         if (historyItem.statistics) {
             markdown.appendMarkdown(`---\n\n`);
             markdown.appendMarkdown(`<span>${historyItem.statistics.files === 1 ?
-                ( localize(6470, "{0} file changed", historyItem.statistics.files)) :
-                ( localize(6471, "{0} files changed", historyItem.statistics.files))}</span>`);
+                ( localize(6633, "{0} file changed", historyItem.statistics.files)) :
+                ( localize(6634, "{0} files changed", historyItem.statistics.files))}</span>`);
             if (historyItem.statistics.insertions) {
-                const historyItemAdditionsForegroundColor = colorTheme.getColor(historyItemAdditionsForeground);
-                markdown.appendMarkdown(`,&nbsp;<span style="color:${historyItemAdditionsForegroundColor};">${historyItem.statistics.insertions === 1 ?
-                    ( localize(6472, "{0} insertion{1}", historyItem.statistics.insertions, '(+)')) :
-                    ( localize(6473, "{0} insertions{1}", historyItem.statistics.insertions, '(+)'))}</span>`);
+                const additionsForegroundColor = colorTheme.getColor(historyItemHoverAdditionsForeground);
+                markdown.appendMarkdown(`,&nbsp;<span style="color:${additionsForegroundColor};">${historyItem.statistics.insertions === 1 ?
+                    ( localize(6635, "{0} insertion{1}", historyItem.statistics.insertions, '(+)')) :
+                    ( localize(6636, "{0} insertions{1}", historyItem.statistics.insertions, '(+)'))}</span>`);
             }
             if (historyItem.statistics.deletions) {
-                const historyItemDeletionsForegroundColor = colorTheme.getColor(historyItemDeletionsForeground);
-                markdown.appendMarkdown(`,&nbsp;<span style="color:${historyItemDeletionsForegroundColor};">${historyItem.statistics.deletions === 1 ?
-                    ( localize(6474, "{0} deletion{1}", historyItem.statistics.deletions, '(-)')) :
-                    ( localize(6475, "{0} deletions{1}", historyItem.statistics.deletions, '(-)'))}</span>`);
-            }
-        }
-        const labels = this.getLabels(element.repository);
-        const historyItemLabels = (historyItem.labels ?? [])
-            .filter(l => labels.includes(l.title));
-        if (historyItemLabels.length > 0) {
-            const historyItemGroupLocalColor = colorTheme.getColor(historyItemGroupLocal);
-            const historyItemGroupRemoteColor = colorTheme.getColor(historyItemGroupRemote);
-            const historyItemGroupBaseColor = colorTheme.getColor(historyItemGroupBase);
-            const historyItemGroupHoverLabelForegroundColor = colorTheme.getColor(historyItemGroupHoverLabelForeground);
+                const deletionsForegroundColor = colorTheme.getColor(historyItemHoverDeletionsForeground);
+                markdown.appendMarkdown(`,&nbsp;<span style="color:${deletionsForegroundColor};">${historyItem.statistics.deletions === 1 ?
+                    ( localize(6637, "{0} deletion{1}", historyItem.statistics.deletions, '(-)')) :
+                    ( localize(6638, "{0} deletions{1}", historyItem.statistics.deletions, '(-)'))}</span>`);
+            }
+        }
+        if ((historyItem.references ?? []).length > 0) {
             markdown.appendMarkdown(`\n\n---\n\n`);
-            markdown.appendMarkdown(( (historyItemLabels.map(label => {
-                const historyItemGroupHoverLabelBackgroundColor = label.title === currentHistoryItemGroup?.name ? historyItemGroupLocalColor :
-                    label.title === currentHistoryItemGroup?.remote?.name ? historyItemGroupRemoteColor :
-                        label.title === currentHistoryItemGroup?.base?.name ? historyItemGroupBaseColor :
-                            undefined;
-                const historyItemGroupHoverLabelIconId = ThemeIcon.isThemeIcon(label.icon) ? label.icon.id : '';
-                return `<span style="color:${historyItemGroupHoverLabelForegroundColor};background-color:${historyItemGroupHoverLabelBackgroundColor};border-radius:2px;">&nbsp;$(${historyItemGroupHoverLabelIconId})&nbsp;${label.title}&nbsp;</span>`;
+            markdown.appendMarkdown(( ((historyItem.references ?? []).map(ref => {
+                const labelIconId = ThemeIcon.isThemeIcon(ref.icon) ? ref.icon.id : '';
+                const labelBackgroundColor = ref.color ? asCssVariable(ref.color) : asCssVariable(historyItemHoverDefaultLabelBackground);
+                const labelForegroundColor = ref.color ? asCssVariable(historyItemHoverLabelForeground) : asCssVariable(historyItemHoverDefaultLabelForeground);
+                return `<span style="color:${labelForegroundColor};background-color:${labelBackgroundColor};border-radius:10px;">&nbsp;$(${labelIconId})&nbsp;${ref.name}&nbsp;&nbsp;</span>`;
             }))).join('&nbsp;&nbsp;'));
         }
         return { markdown, markdownNotSupportedFallback: historyItem.message };
     }
-    processMatches(historyItemViewModel, filterData) {
+    _processMatches(historyItemViewModel, filterData) {
         if (!filterData) {
             return [undefined, undefined];
         }
@@ -317,18 +439,19 @@ let HistoryItemRenderer = class HistoryItemRenderer {
     }
 };
 HistoryItemRenderer = HistoryItemRenderer_1 = ( (__decorate([
-    ( (__param(1, IHoverService))),
-    ( (__param(2, IThemeService)))
+    ( (__param(1, IClipboardService))),
+    ( (__param(2, IConfigurationService))),
+    ( (__param(3, IHoverService))),
+    ( (__param(4, IThemeService)))
 ], HistoryItemRenderer)));
 let HistoryItemLoadMoreRenderer = class HistoryItemLoadMoreRenderer {
     static { HistoryItemLoadMoreRenderer_1 = this; }
     static { this.TEMPLATE_ID = 'historyItemLoadMore'; }
     get templateId() { return HistoryItemLoadMoreRenderer_1.TEMPLATE_ID; }
-    constructor(_loadingMore, _loadMoreCallback, _configurationService, _scmViewService) {
-        this._loadingMore = _loadingMore;
+    constructor(_isLoadingMore, _loadMoreCallback, _configurationService) {
+        this._isLoadingMore = _isLoadingMore;
         this._loadMoreCallback = _loadMoreCallback;
         this._configurationService = _configurationService;
-        this._scmViewService = _scmViewService;
     }
     renderTemplate(container) {
         container.parentElement.parentElement.querySelector('.monaco-tl-twistie').classList.add('force-no-twistie');
@@ -339,70 +462,33 @@ let HistoryItemLoadMoreRenderer = class HistoryItemLoadMoreRenderer {
         return { element, graphPlaceholder, historyItemPlaceholderContainer, historyItemPlaceholderLabel, elementDisposables: ( (new DisposableStore())), disposables: ( (new DisposableStore())) };
     }
     renderElement(element, index, templateData, height) {
-        const repositoryCount = this._scmViewService.visibleRepositories.length;
-        const alwaysShowRepositories = this._configurationService.getValue('scm.alwaysShowRepositories') === true;
         templateData.graphPlaceholder.textContent = '';
         templateData.graphPlaceholder.style.width = `${SWIMLANE_WIDTH * (element.element.graphColumns.length + 1)}px`;
         templateData.graphPlaceholder.appendChild(renderSCMHistoryGraphPlaceholder(element.element.graphColumns));
-        templateData.historyItemPlaceholderContainer.classList.toggle('shimmer', repositoryCount === 1 && !alwaysShowRepositories);
-        if (repositoryCount > 1 || alwaysShowRepositories) {
-            templateData.elementDisposables.add(autorun(reader => {
-                const loadingMore = this._loadingMore(element.element.repository).read(reader);
-                const icon = `$(${loadingMore ? 'loading~spin' : 'fold-down'})`;
-                templateData.historyItemPlaceholderLabel.setLabel(( localize(6476, "{0} Load More...", icon)));
-            }));
+        const pageOnScroll = this._configurationService.getValue('scm.graph.pageOnScroll') === true;
+        templateData.historyItemPlaceholderContainer.classList.toggle('shimmer', pageOnScroll);
+        if (pageOnScroll) {
+            templateData.historyItemPlaceholderLabel.setLabel('');
+            this._loadMoreCallback();
         }
         else {
-            templateData.historyItemPlaceholderLabel.setLabel('');
-            this._loadMoreCallback(element.element.repository);
+            templateData.elementDisposables.add(autorun(reader => {
+                const isLoadingMore = this._isLoadingMore.read(reader);
+                const icon = `$(${isLoadingMore ? 'loading~spin' : 'fold-down'})`;
+                templateData.historyItemPlaceholderLabel.setLabel(( localize(6639, "{0} Load More...", icon)));
+            }));
         }
     }
+    disposeElement(element, index, templateData, height) {
+        templateData.elementDisposables.clear();
+    }
     disposeTemplate(templateData) {
         templateData.disposables.dispose();
     }
 };
 HistoryItemLoadMoreRenderer = HistoryItemLoadMoreRenderer_1 = ( (__decorate([
-    ( (__param(2, IConfigurationService))),
-    ( (__param(3, ISCMViewService)))
+    ( (__param(2, IConfigurationService)))
 ], HistoryItemLoadMoreRenderer)));
-class HistoryItemActionRunner extends ActionRunner {
-    constructor(getSelectedHistoryItems) {
-        super();
-        this.getSelectedHistoryItems = getSelectedHistoryItems;
-    }
-    async runAction(action, context) {
-        if (!(action instanceof MenuItemAction)) {
-            return super.runAction(action, context);
-        }
-        const args = [];
-        args.push(context.repository.provider);
-        const selection = this.getSelectedHistoryItems();
-        const contextIsSelected = ( (selection.some(s => s === context)));
-        if (contextIsSelected && selection.length > 1) {
-            args.push(...( (selection.map(h => ({
-                id: h.historyItemViewModel.historyItem.id,
-                parentIds: h.historyItemViewModel.historyItem.parentIds,
-                message: h.historyItemViewModel.historyItem.message,
-                author: h.historyItemViewModel.historyItem.author,
-                icon: h.historyItemViewModel.historyItem.icon,
-                timestamp: h.historyItemViewModel.historyItem.timestamp,
-                statistics: h.historyItemViewModel.historyItem.statistics,
-            })))));
-        }
-        else {
-            args.push({
-                id: context.historyItemViewModel.historyItem.id,
-                parentIds: context.historyItemViewModel.historyItem.parentIds,
-                message: context.historyItemViewModel.historyItem.message,
-                author: context.historyItemViewModel.historyItem.author,
-                icon: context.historyItemViewModel.historyItem.icon,
-                timestamp: context.historyItemViewModel.historyItem.timestamp,
-                statistics: context.historyItemViewModel.historyItem.statistics,
-            });
-        }
-        await action.run(...args);
-    }
-}
 let HistoryItemHoverDelegate = class HistoryItemHoverDelegate extends WorkbenchHoverDelegate {
     constructor(_viewContainerLocation, layoutService, configurationService, hoverService) {
         super('element', true, () => this.getHoverOptions(), configurationService, hoverService);
@@ -412,14 +498,14 @@ let HistoryItemHoverDelegate = class HistoryItemHoverDelegate extends WorkbenchH
     getHoverOptions() {
         const sideBarPosition = this.layoutService.getSideBarPosition();
         let hoverPosition;
-        if (this._viewContainerLocation === ViewContainerLocation.Sidebar) {
-            hoverPosition = sideBarPosition === Position.LEFT ? HoverPosition.RIGHT : HoverPosition.LEFT;
+        if (this._viewContainerLocation === 0 ) {
+            hoverPosition = sideBarPosition === 0  ? 1  : 0 ;
         }
-        else if (this._viewContainerLocation === ViewContainerLocation.AuxiliaryBar) {
-            hoverPosition = sideBarPosition === Position.LEFT ? HoverPosition.LEFT : HoverPosition.RIGHT;
+        else if (this._viewContainerLocation === 2 ) {
+            hoverPosition = sideBarPosition === 0  ? 0  : 1 ;
         }
         else {
-            hoverPosition = HoverPosition.RIGHT;
+            hoverPosition = 1 ;
         }
         return { additionalClasses: ['history-item-hover'], position: { hoverPosition, forcePosition: true } };
     }
@@ -443,7 +529,7 @@ SCMHistoryViewPaneActionRunner = ( (__decorate([
 ], SCMHistoryViewPaneActionRunner)));
 class SCMHistoryTreeAccessibilityProvider {
     getWidgetAriaLabel() {
-        return ( localize(6477, "Source Control History"));
+        return ( localize(6640, "Source Control History"));
     }
     getAriaLabel(element) {
         if (isSCMRepository(element)) {
@@ -494,179 +580,609 @@ class SCMHistoryTreeKeyboardNavigationLabelProvider {
         }
     }
 }
-let SCMHistoryTreeDataSource = class SCMHistoryTreeDataSource extends Disposable {
-    constructor(_configurationService, _scmViewService) {
+class SCMHistoryTreeDataSource extends Disposable {
+    async getChildren(inputOrElement) {
+        if (!(inputOrElement instanceof SCMHistoryViewModel)) {
+            return [];
+        }
+        const children = [];
+        const historyItems = await inputOrElement.getHistoryItems();
+        children.push(...historyItems);
+        const repository = inputOrElement.repository.get();
+        const lastHistoryItem = tail(historyItems);
+        if (repository && lastHistoryItem && lastHistoryItem.historyItemViewModel.outputSwimlanes.length > 0) {
+            children.push({
+                repository,
+                graphColumns: lastHistoryItem.historyItemViewModel.outputSwimlanes,
+                type: 'historyItemLoadMore'
+            });
+        }
+        return children;
+    }
+    hasChildren(inputOrElement) {
+        return inputOrElement instanceof SCMHistoryViewModel;
+    }
+}
+let SCMHistoryViewModel = class SCMHistoryViewModel extends Disposable {
+    constructor(_configurationService, _contextKeyService, _extensionService, _scmService, _scmViewService, _storageService) {
         super();
         this._configurationService = _configurationService;
+        this._contextKeyService = _contextKeyService;
+        this._extensionService = _extensionService;
+        this._scmService = _scmService;
         this._scmViewService = _scmViewService;
-        this._state = ( (new Map()));
-    }
-    async getChildren(inputOrElement) {
-        const repositoryCount = this._scmViewService.visibleRepositories.length;
-        const alwaysShowRepositories = this._configurationService.getValue('scm.alwaysShowRepositories') === true;
-        if (isSCMViewService(inputOrElement) && (repositoryCount > 1 || alwaysShowRepositories)) {
-            return this._scmViewService.visibleRepositories;
-        }
-        else if ((isSCMViewService(inputOrElement) && repositoryCount === 1 && !alwaysShowRepositories) || isSCMRepository(inputOrElement)) {
-            const children = [];
-            inputOrElement = isSCMRepository(inputOrElement) ? inputOrElement : this._scmViewService.visibleRepositories[0];
-            const historyItems = await this._getHistoryItems(inputOrElement);
-            children.push(...historyItems);
-            const lastHistoryItem = tail(historyItems);
-            if (lastHistoryItem && lastHistoryItem.historyItemViewModel.outputSwimlanes.length > 0) {
-                children.push({
-                    repository: inputOrElement,
-                    graphColumns: lastHistoryItem.historyItemViewModel.outputSwimlanes,
-                    type: 'historyItemLoadMore'
-                });
+        this._storageService = _storageService;
+        this._closedRepository = observableFromEvent(this, this._scmService.onDidRemoveRepository, repository => repository);
+        this._firstRepository = this._scmService.repositoryCount > 0 ?
+            constObservable(Iterable.first(this._scmService.repositories)) :
+            observableFromEvent(this, Event.once(this._scmService.onDidAddRepository), repository => repository);
+        this._selectedRepository = observableValue(this, 'auto');
+        this._graphRepository = derived(reader => {
+            const selectedRepository = this._selectedRepository.read(reader);
+            if (selectedRepository !== 'auto') {
+                return selectedRepository;
             }
-            return children;
-        }
-        return [];
+            return this._scmViewService.activeRepository.read(reader);
+        });
+        this.repository = latestChangedValue(this, [this._firstRepository, this._graphRepository]);
+        this.onDidChangeHistoryItemsFilter = observableSignal(this);
+        this.isViewModelEmpty = observableValue(this, false);
+        this._repositoryState = ( (new Map()));
+        this._repositoryFilterState = ( (new Map()));
+        this._repositoryFilterState = this._loadHistoryItemsFilterState();
+        this._extensionService.onWillStop(this._saveHistoryItemsFilterState, this, this._store);
+        this._storageService.onWillSaveState(this._saveHistoryItemsFilterState, this, this._store);
+        this._scmHistoryItemCountCtx = ContextKeys.SCMHistoryItemCount.bindTo(this._contextKeyService);
+        this._register(autorun(reader => {
+            const repository = this._closedRepository.read(reader);
+            if (!repository) {
+                return;
+            }
+            if (this.repository.get() === repository) {
+                this._selectedRepository.set(Iterable.first(this._scmService.repositories) ?? 'auto', undefined);
+            }
+            this._repositoryState.delete(repository);
+        }));
     }
-    hasChildren(inputOrElement) {
-        if (isSCMViewService(inputOrElement)) {
-            return this._scmViewService.visibleRepositories.length !== 0;
+    clearRepositoryState() {
+        const repository = this.repository.get();
+        if (!repository) {
+            return;
         }
-        else if (isSCMRepository(inputOrElement)) {
-            return true;
+        this._repositoryState.delete(repository);
+    }
+    getHistoryItemsFilter() {
+        const repository = this.repository.get();
+        if (!repository) {
+            return;
         }
-        else if (isSCMHistoryItemViewModelTreeElement(inputOrElement)) {
-            return false;
+        const filterState = this._repositoryFilterState.get(getProviderKey(repository.provider)) ?? 'auto';
+        if (filterState === 'all' || filterState === 'auto') {
+            return filterState;
         }
-        else if (isSCMHistoryItemLoadMoreTreeElement(inputOrElement)) {
-            return false;
+        const repositoryState = this._repositoryState.get(repository);
+        return repositoryState?.historyItemsFilter;
+    }
+    getCurrentHistoryItemTreeElement() {
+        const repository = this.repository.get();
+        if (!repository) {
+            return undefined;
         }
-        else {
-            throw ( (new Error('hasChildren not implemented.')));
+        const state = this._repositoryState.get(repository);
+        if (!state) {
+            return undefined;
         }
+        const historyProvider = repository?.provider.historyProvider.get();
+        const historyItemRef = historyProvider?.historyItemRef.get();
+        return state.viewModels
+            .find(viewModel => viewModel.historyItemViewModel.historyItem.id === historyItemRef?.revision);
     }
-    clearState(repository) {
+    loadMore(cursor) {
+        const repository = this.repository.get();
         if (!repository) {
-            this._state.clear();
             return;
         }
-        this._state.delete(repository);
-    }
-    loadMore(repository) {
-        const state = this._state.get(repository);
+        const state = this._repositoryState.get(repository);
         if (!state) {
             return;
         }
-        this._state.set(repository, { ...state, loadMore: true });
+        this._repositoryState.set(repository, { ...state, loadMore: cursor ?? true });
     }
-    async _getHistoryItems(element) {
-        let state = this._state.get(element);
-        const historyProvider = element.provider.historyProvider.get();
-        const currentHistoryItemGroup = state?.currentHistoryItemGroup ?? historyProvider?.currentHistoryItemGroup.get();
-        if (!historyProvider || !currentHistoryItemGroup) {
+    async getHistoryItems() {
+        const repository = this.repository.get();
+        const historyProvider = repository?.provider.historyProvider.get();
+        if (!repository || !historyProvider) {
+            this._scmHistoryItemCountCtx.set(0);
+            this.isViewModelEmpty.set(true, undefined);
             return [];
         }
-        if (!state || state.loadMore) {
-            const historyItemGroupIds = [
-                currentHistoryItemGroup.revision ?? currentHistoryItemGroup.id,
-                ...(currentHistoryItemGroup.remote ? [currentHistoryItemGroup.remote.revision ?? currentHistoryItemGroup.remote.id] : []),
-                ...(currentHistoryItemGroup.base ? [currentHistoryItemGroup.base.revision ?? currentHistoryItemGroup.base.id] : []),
-            ];
-            const existingHistoryItems = state?.items ?? [];
-            const historyItems = (await historyProvider.provideHistoryItems2({
-                historyItemGroupIds, limit: 50, skip: existingHistoryItems.length
-            })) ?? [];
-            state = {
-                currentHistoryItemGroup,
-                items: [...existingHistoryItems, ...historyItems],
-                loadMore: false
-            };
-            this._state.set(element, state);
-        }
-        const colorMap = ( (new Map([
-            [currentHistoryItemGroup.name, historyItemGroupLocal]
-        ])));
-        if (currentHistoryItemGroup.remote) {
-            colorMap.set(currentHistoryItemGroup.remote.name, historyItemGroupRemote);
-        }
-        if (currentHistoryItemGroup.base) {
-            colorMap.set(currentHistoryItemGroup.base.name, historyItemGroupBase);
-        }
-        return (
-             (toISCMHistoryItemViewModelArray(state.items, colorMap)
+        let state = this._repositoryState.get(repository);
+        if (!state || state.loadMore !== false) {
+            const historyItems = state?.viewModels
+                .map(vm => vm.historyItemViewModel.historyItem) ?? [];
+            const historyItemRefs = state?.historyItemsFilter ??
+                (await this._resolveHistoryItemFilter(repository, historyProvider));
+            const limit = clamp(this._configurationService.getValue('scm.graph.pageSize'), 1, 1000);
+            const historyItemRefIds = ( (historyItemRefs.map(ref => ref.revision ?? ref.id)));
+            do {
+                historyItems.push(...((await historyProvider.provideHistoryItems({
+                    historyItemRefs: historyItemRefIds, limit, skip: historyItems.length
+                })) ?? []));
+            } while (typeof state?.loadMore === 'string' && !historyItems.find(item => item.id === state?.loadMore));
+            const colorMap = this._getGraphColorMap(historyItemRefs);
+            const viewModels = ( (toISCMHistoryItemViewModelArray(historyItems, colorMap, historyProvider.historyItemRef.get())
                 .map(historyItemViewModel => ({
-                repository: element,
+                repository,
                 historyItemViewModel,
-                type: 'historyItem2'
-            })))
+                type: 'historyItemViewModel'
+            }))));
+            state = { historyItemsFilter: historyItemRefs, viewModels, loadMore: false };
+            this._repositoryState.set(repository, state);
+            this._scmHistoryItemCountCtx.set(viewModels.length);
+            this.isViewModelEmpty.set(viewModels.length === 0, undefined);
+        }
+        return state.viewModels;
+    }
+    setRepository(repository) {
+        this._selectedRepository.set(repository, undefined);
+    }
+    setHistoryItemsFilter(filter) {
+        const repository = this.repository.get();
+        if (!repository) {
+            return;
+        }
+        if (filter !== 'auto') {
+            this._repositoryFilterState.set(getProviderKey(repository.provider), filter);
+        }
+        else {
+            this._repositoryFilterState.delete(getProviderKey(repository.provider));
+        }
+        this._saveHistoryItemsFilterState();
+        this.onDidChangeHistoryItemsFilter.trigger(undefined);
+    }
+    _getGraphColorMap(historyItemRefs) {
+        const repository = this.repository.get();
+        const historyProvider = repository?.provider.historyProvider.get();
+        const historyItemRef = historyProvider?.historyItemRef.get();
+        const historyItemRemoteRef = historyProvider?.historyItemRemoteRef.get();
+        const historyItemBaseRef = historyProvider?.historyItemBaseRef.get();
+        const colorMap = ( (new Map()));
+        if (historyItemRef) {
+            colorMap.set(historyItemRef.id, historyItemRef.color);
+            if (historyItemRemoteRef) {
+                colorMap.set(historyItemRemoteRef.id, historyItemRemoteRef.color);
+            }
+            if (historyItemBaseRef) {
+                colorMap.set(historyItemBaseRef.id, historyItemBaseRef.color);
+            }
+        }
+        for (const ref of historyItemRefs) {
+            if (!( (colorMap.has(ref.id)))) {
+                colorMap.set(ref.id, undefined);
+            }
+        }
+        return colorMap;
+    }
+    async _resolveHistoryItemFilter(repository, historyProvider) {
+        const historyItemRefs = [];
+        const historyItemsFilter = this._repositoryFilterState.get(getProviderKey(repository.provider)) ?? 'auto';
+        switch (historyItemsFilter) {
+            case 'all':
+                historyItemRefs.push(...((await historyProvider.provideHistoryItemRefs()) ?? []));
+                break;
+            case 'auto':
+                historyItemRefs.push(...[
+                    historyProvider.historyItemRef.get(),
+                    historyProvider.historyItemRemoteRef.get(),
+                    historyProvider.historyItemBaseRef.get(),
+                ].filter(ref => !!ref));
+                break;
+            default: {
+                const refs = ((await historyProvider.provideHistoryItemRefs(historyItemsFilter)) ?? [])
+                    .filter(ref => ( (historyItemsFilter.some(filter => filter === ref.id))));
+                if (refs.length === 0) {
+                    historyItemRefs.push(...[
+                        historyProvider.historyItemRef.get(),
+                        historyProvider.historyItemRemoteRef.get(),
+                        historyProvider.historyItemBaseRef.get(),
+                    ].filter(ref => !!ref));
+                    this._repositoryFilterState.delete(getProviderKey(repository.provider));
+                }
+                else {
+                    historyItemRefs.push(...refs);
+                    this._repositoryFilterState.set(getProviderKey(repository.provider), ( (refs.map(ref => ref.id))));
+                }
+                this._saveHistoryItemsFilterState();
+                break;
+            }
+        }
+        return historyItemRefs;
+    }
+    _loadHistoryItemsFilterState() {
+        try {
+            const filterData = this._storageService.get('scm.graphView.referencesFilter', 1 );
+            if (filterData) {
+                return (
+                     (new Map(JSON.parse(filterData)))
+                );
+            }
+        }
+        catch { }
+        return (
+             (new Map())
         );
     }
+    _saveHistoryItemsFilterState() {
+        const filter = Array.from(this._repositoryFilterState.entries());
+        this._storageService.store('scm.graphView.referencesFilter', JSON.stringify(filter), 1 , 0 );
+    }
     dispose() {
-        this._state.clear();
+        this._repositoryState.clear();
         super.dispose();
     }
 };
-SCMHistoryTreeDataSource = ( (__decorate([
+SCMHistoryViewModel = ( (__decorate([
     ( (__param(0, IConfigurationService))),
+    ( (__param(1, IContextKeyService))),
+    ( (__param(2, IExtensionService))),
+    ( (__param(3, ISCMService))),
+    ( (__param(4, ISCMViewService))),
+    ( (__param(5, IStorageService)))
+], SCMHistoryViewModel)));
+let RepositoryPicker = class RepositoryPicker extends Disposable {
+    constructor(_quickInputService, _scmViewService) {
+        super();
+        this._quickInputService = _quickInputService;
+        this._scmViewService = _scmViewService;
+        this._autoQuickPickItem = {
+            label: ( localize(6623, "Auto")),
+            description: ( localize(6641, "Show the source control graph for the active repository")),
+            repository: 'auto'
+        };
+    }
+    async pickRepository() {
+        const picks = [
+            this._autoQuickPickItem,
+            { type: 'separator' }
+        ];
+        picks.push(...( (this._scmViewService.repositories.map(r => ({
+            label: r.provider.name,
+            description: r.provider.rootUri?.fsPath,
+            iconClass: ThemeIcon.asClassName(Codicon.repo),
+            repository: r
+        })))));
+        return this._quickInputService.pick(picks, {
+            placeHolder: ( localize(6642, "Select the repository to view, type to filter all repositories"))
+        });
+    }
+};
+RepositoryPicker = ( (__decorate([
+    ( (__param(0, IQuickInputService))),
     ( (__param(1, ISCMViewService)))
-], SCMHistoryTreeDataSource)));
+], RepositoryPicker)));
+let HistoryItemRefPicker = class HistoryItemRefPicker extends Disposable {
+    constructor(_historyProvider, _historyItemsFilter, _quickInputService) {
+        super();
+        this._historyProvider = _historyProvider;
+        this._historyItemsFilter = _historyItemsFilter;
+        this._quickInputService = _quickInputService;
+        this._allQuickPickItem = {
+            id: 'all',
+            label: ( localize(6622, "All")),
+            description: ( localize(6625, "All history item references")),
+            historyItemRef: 'all'
+        };
+        this._autoQuickPickItem = {
+            id: 'auto',
+            label: ( localize(6623, "Auto")),
+            description: ( localize(6643, "Current history item reference(s)")),
+            historyItemRef: 'auto'
+        };
+    }
+    async pickHistoryItemRef() {
+        const quickPick = this._quickInputService.createQuickPick({ useSeparators: true });
+        this._store.add(quickPick);
+        quickPick.placeholder = ( localize(6644, "Select one/more history item references to view, type to filter"));
+        quickPick.canSelectMany = true;
+        quickPick.hideCheckAll = true;
+        quickPick.busy = true;
+        quickPick.show();
+        const items = await this._createQuickPickItems();
+        let selectedItems = [];
+        if (this._historyItemsFilter === 'all') {
+            selectedItems.push(this._allQuickPickItem);
+        }
+        else if (this._historyItemsFilter === 'auto') {
+            selectedItems.push(this._autoQuickPickItem);
+        }
+        else {
+            let index = 0;
+            while (index < items.length) {
+                if (items[index].type === 'separator') {
+                    index++;
+                    continue;
+                }
+                if (( (this._historyItemsFilter.some(ref => ref.id === items[index].id)))) {
+                    const item = items.splice(index, 1);
+                    selectedItems.push(...item);
+                }
+                else {
+                    index++;
+                }
+            }
+            items.splice(2, 0, { type: 'separator' }, ...selectedItems);
+        }
+        quickPick.items = items;
+        quickPick.selectedItems = selectedItems;
+        quickPick.busy = false;
+        return (
+             (new Promise(resolve => {
+                this._store.add(quickPick.onDidChangeSelection(items => {
+                    const { added } = delta(selectedItems, items, (a, b) => compare(a.id ?? '', b.id ?? ''));
+                    if (added.length > 0) {
+                        if (added[0].historyItemRef === 'all' || added[0].historyItemRef === 'auto') {
+                            quickPick.selectedItems = [added[0]];
+                        }
+                        else {
+                            quickPick.selectedItems = [...quickPick.selectedItems
+                                    .filter(i => i.historyItemRef !== 'all' && i.historyItemRef !== 'auto')];
+                        }
+                    }
+                    selectedItems = [...quickPick.selectedItems];
+                }));
+                this._store.add(quickPick.onDidAccept(() => {
+                    if (selectedItems.length === 0) {
+                        resolve(undefined);
+                    }
+                    else if (selectedItems.length === 1 && selectedItems[0].historyItemRef === 'all') {
+                        resolve('all');
+                    }
+                    else if (selectedItems.length === 1 && selectedItems[0].historyItemRef === 'auto') {
+                        resolve('auto');
+                    }
+                    else {
+                        resolve(( (selectedItems.map(item => item.historyItemRef.id))));
+                    }
+                    quickPick.hide();
+                }));
+                this._store.add(quickPick.onDidHide(() => {
+                    resolve(undefined);
+                    this.dispose();
+                }));
+            }))
+        );
+    }
+    async _createQuickPickItems() {
+        const picks = [
+            this._allQuickPickItem, this._autoQuickPickItem
+        ];
+        const historyItemRefs = (await this._historyProvider.provideHistoryItemRefs()) ?? [];
+        const historyItemRefsByCategory = groupBy$1(historyItemRefs, (a, b) => compare(a.category ?? '', b.category ?? ''));
+        for (const refs of historyItemRefsByCategory) {
+            if (refs.length === 0) {
+                continue;
+            }
+            picks.push({ type: 'separator', label: refs[0].category });
+            picks.push(...( (refs.map(ref => {
+                return {
+                    id: ref.id,
+                    label: ref.name,
+                    description: ref.description,
+                    iconClass: ThemeIcon.isThemeIcon(ref.icon) ?
+                        ThemeIcon.asClassName(ref.icon) : undefined,
+                    historyItemRef: ref
+                };
+            }))));
+        }
+        return picks;
+    }
+};
+HistoryItemRefPicker = ( (__decorate([
+    ( (__param(2, IQuickInputService)))
+], HistoryItemRefPicker)));
 let SCMHistoryViewPane = class SCMHistoryViewPane extends ViewPane {
-    constructor(options, _commandService, _scmViewService, _progressService, configurationService, contextMenuService, keybindingService, instantiationService, viewDescriptorService, contextKeyService, openerService, themeService, telemetryService, hoverService) {
-        super({ ...options, titleMenuId: MenuId.SCMHistoryTitle }, keybindingService, contextMenuService, configurationService, contextKeyService, viewDescriptorService, instantiationService, openerService, themeService, telemetryService, hoverService);
+    constructor(options, _commandService, _instantiationService, _notificationService, _progressService, configurationService, contextMenuService, keybindingService, instantiationService, viewDescriptorService, contextKeyService, openerService, themeService, telemetryService, hoverService) {
+        super({
+            ...options,
+            titleMenuId: MenuId.SCMHistoryTitle,
+            showActions: ViewPaneShowActions.WhenExpanded
+        }, keybindingService, contextMenuService, configurationService, contextKeyService, viewDescriptorService, instantiationService, openerService, themeService, telemetryService, hoverService);
         this._commandService = _commandService;
-        this._scmViewService = _scmViewService;
+        this._instantiationService = _instantiationService;
+        this._notificationService = _notificationService;
         this._progressService = _progressService;
-        this._repositoryDescription = ( (new Map()));
-        this._repositoryLoadMore = ( (new Map()));
-        this._repositories = ( (new DisposableMap()));
+        this._repositoryIsLoadingMore = observableValue(this, false);
+        this._repositoryOutdated = observableValue(this, false);
         this._visibilityDisposables = ( (new DisposableStore()));
         this._treeOperationSequencer = ( (new Sequencer()));
+        this._treeLoadMoreSequencer = ( (new Sequencer()));
         this._updateChildrenThrottler = ( (new Throttler()));
-        this._providerCountBadgeConfig = observableConfigValue('scm.providerCountBadge', 'hidden', this.configurationService);
-        this._scmHistoryItemGroupHasRemoteContextKey = this.scopedContextKeyService.createKey('scmHistoryItemGroupHasRemote', undefined);
+        this._scmProviderCtx = ContextKeys.SCMProvider.bindTo(this.scopedContextKeyService);
         this._actionRunner = this.instantiationService.createInstance(SCMHistoryViewPaneActionRunner);
         this._register(this._actionRunner);
         this._register(this._updateChildrenThrottler);
     }
-    layoutBody(height, width) {
-        super.layoutBody(height, width);
-        this._tree.layout(height, width);
+    renderHeaderTitle(container) {
+        super.renderHeaderTitle(container, this.title);
+        const element = h('div.scm-graph-view-badge-container', [
+            h('div.scm-graph-view-badge.monaco-count-badge.long@badge')
+        ]);
+        element.badge.textContent = 'Outdated';
+        container.appendChild(element.root);
+        this._register(this.hoverService.setupManagedHover(getDefaultHoverDelegate('mouse'), element.root, {
+            markdown: {
+                value: ( localize(6645, "Please refresh the graph using the refresh action ($(refresh)).")),
+                supportThemeIcons: true
+            },
+            markdownNotSupportedFallback: undefined
+        }));
+        this._register(autorun(reader => {
+            const outdated = this._repositoryOutdated.read(reader);
+            element.root.style.display = outdated ? '' : 'none';
+        }));
     }
     renderBody(container) {
         super.renderBody(container);
         this._treeContainer = append(container, $('.scm-view.scm-history-view'));
         this._treeContainer.classList.add('file-icon-themable-tree');
-        this._register(autorun(reader => {
-            const providerCountBadgeConfig = this._providerCountBadgeConfig.read(reader);
-            this._treeContainer.classList.toggle('hide-provider-counts', providerCountBadgeConfig === 'hidden');
-            this._treeContainer.classList.toggle('auto-provider-counts', providerCountBadgeConfig === 'auto');
-        }));
         this._createTree(this._treeContainer);
-        this.onDidChangeBodyVisibility(visible => {
-            if (visible) {
-                this._treeOperationSequencer.queue(async () => {
-                    await this._tree.setInput(this._scmViewService);
-                    Event.filter(this.configurationService.onDidChangeConfiguration, e => e.affectsConfiguration('scm.alwaysShowRepositories'), this._visibilityDisposables)(() => {
-                        this.updateActions();
-                        this.refresh();
-                    }, this, this._visibilityDisposables);
-                    this._scmViewService.onDidChangeVisibleRepositories(this._onDidChangeVisibleRepositories, this, this._visibilityDisposables);
-                    this._onDidChangeVisibleRepositories({ added: this._scmViewService.visibleRepositories, removed: Iterable.empty() });
-                    this._tree.scrollTop = 0;
-                });
-            }
-            else {
-                this._treeDataSource.clearState();
+        this.onDidChangeBodyVisibility(async (visible) => {
+            if (!visible) {
                 this._visibilityDisposables.clear();
-                this._repositories.clearAndDisposeAll();
+                return;
             }
+            this._treeViewModel = this.instantiationService.createInstance(SCMHistoryViewModel);
+            this._visibilityDisposables.add(this._treeViewModel);
+            await this._progressService.withProgress({ location: this.id }, async () => {
+                const firstRepositoryInitialized = derived(this, reader => {
+                    const repository = this._treeViewModel.repository.read(reader);
+                    const historyProvider = repository?.provider.historyProvider.read(reader);
+                    const historyItemRef = historyProvider?.historyItemRef.read(reader);
+                    return historyItemRef !== undefined ? true : undefined;
+                });
+                await waitForState(firstRepositoryInitialized);
+                await this._treeOperationSequencer.queue(async () => {
+                    await this._tree.setInput(this._treeViewModel);
+                    this._tree.scrollTop = 0;
+                });
+            });
+            this._visibilityDisposables.add(autorun(reader => {
+                this._treeViewModel.isViewModelEmpty.read(reader);
+                this._onDidChangeViewWelcomeState.fire();
+            }));
+            let isFirstRun = true;
+            this._visibilityDisposables.add(autorunWithStore((reader, store) => {
+                const repository = this._treeViewModel.repository.read(reader);
+                const historyProvider = repository?.provider.historyProvider.read(reader);
+                if (!repository || !historyProvider) {
+                    return;
+                }
+                this._scmProviderCtx.set(repository.provider.contextValue);
+                const historyItemRefId = derived(reader => {
+                    return historyProvider.historyItemRef.read(reader)?.id;
+                });
+                store.add(runOnChange(historyItemRefId, () => {
+                    this.refresh();
+                }));
+                store.add(runOnChange(historyProvider.historyItemRefChanges, changes => {
+                    if (changes.silent) {
+                        if (this._tree.scrollTop === 0) {
+                            this.refresh();
+                            return;
+                        }
+                        this._repositoryOutdated.set(true, undefined);
+                        return;
+                    }
+                    this.refresh();
+                }));
+                store.add(runOnChange(this._treeViewModel.onDidChangeHistoryItemsFilter, () => {
+                    this.refresh();
+                }));
+                if (!isFirstRun) {
+                    this.refresh();
+                }
+                isFirstRun = false;
+            }));
         });
     }
+    layoutBody(height, width) {
+        super.layoutBody(height, width);
+        this._tree.layout(height, width);
+    }
     getActionRunner() {
         return this._actionRunner;
     }
-    async refresh(repository) {
-        this._treeDataSource.clearState(repository);
-        await this._updateChildren(repository);
-        this._setRepositoryDescription(repository, '');
+    getActionsContext() {
+        return this._treeViewModel?.repository.get()?.provider;
+    }
+    getActionViewItem(action, options) {
+        if (action.id === PICK_REPOSITORY_ACTION_ID) {
+            const repository = this._treeViewModel?.repository.get();
+            if (repository) {
+                return (
+                     (new SCMRepositoryActionViewItem(repository, action, options))
+                );
+            }
+        }
+        else if (action.id === PICK_HISTORY_ITEM_REFS_ACTION_ID) {
+            const repository = this._treeViewModel?.repository.get();
+            const historyItemsFilter = this._treeViewModel?.getHistoryItemsFilter();
+            if (repository && historyItemsFilter) {
+                return (
+                     (new SCMHistoryItemRefsActionViewItem(repository, historyItemsFilter, action, options))
+                );
+            }
+        }
+        return super.getActionViewItem(action, options);
+    }
+    focus() {
+        super.focus();
+        const fakeKeyboardEvent = ( (new KeyboardEvent('keydown')));
+        this._tree.focusFirst(fakeKeyboardEvent);
+        this._tree.domFocus();
+    }
+    shouldShowWelcome() {
+        return this._treeViewModel?.isViewModelEmpty.get() === true;
+    }
+    async refresh() {
+        this._treeViewModel.clearRepositoryState();
+        await this._updateChildren();
+        this.updateActions();
+        this._repositoryOutdated.set(false, undefined);
         this._tree.scrollTop = 0;
     }
+    async pickRepository() {
+        const picker = this._instantiationService.createInstance(RepositoryPicker);
+        const result = await picker.pickRepository();
+        if (result) {
+            this._treeViewModel.setRepository(result.repository);
+        }
+    }
+    async pickHistoryItemRef() {
+        const repository = this._treeViewModel.repository.get();
+        const historyProvider = repository?.provider.historyProvider.get();
+        const historyItemsFilter = this._treeViewModel.getHistoryItemsFilter();
+        if (!historyProvider || !historyItemsFilter) {
+            return;
+        }
+        const picker = this._instantiationService.createInstance(HistoryItemRefPicker, historyProvider, historyItemsFilter);
+        const result = await picker.pickHistoryItemRef();
+        if (result) {
+            this._treeViewModel.setHistoryItemsFilter(result);
+        }
+    }
+    async revealCurrentHistoryItem() {
+        const repository = this._treeViewModel.repository.get();
+        const historyProvider = repository?.provider.historyProvider.get();
+        const historyItemRef = historyProvider?.historyItemRef.get();
+        const historyItemFilter = this._treeViewModel.getHistoryItemsFilter();
+        if (!repository || !historyItemRef?.revision || !historyItemFilter) {
+            return;
+        }
+        if (Array.isArray(historyItemFilter) &&
+            !historyItemFilter.find(ref => ref.id === historyItemRef.id)) {
+            this._notificationService.info(( localize(
+                6646,
+                "The current history item is not present in the source control graph. Please use the history item references picker to expand the set of history items in the graph."
+            )));
+            return;
+        }
+        const revealTreeNode = () => {
+            const historyItemTreeElement = this._treeViewModel.getCurrentHistoryItemTreeElement();
+            if (historyItemTreeElement && this._tree.hasNode(historyItemTreeElement)) {
+                this._tree.reveal(historyItemTreeElement, 0.5);
+                this._tree.setSelection([historyItemTreeElement]);
+                this._tree.setFocus([historyItemTreeElement]);
+                return true;
+            }
+            return false;
+        };
+        if (revealTreeNode()) {
+            return;
+        }
+        await this._loadMore(historyItemRef.revision);
+        revealTreeNode();
+    }
     _createTree(container) {
         this._treeIdentityProvider = ( (new SCMHistoryTreeIdentityProvider()));
         const historyItemHoverDelegate = this.instantiationService.createInstance(HistoryItemHoverDelegate, this.viewDescriptorService.getViewLocationById(this.id));
@@ -674,13 +1190,12 @@ let SCMHistoryViewPane = class SCMHistoryViewPane extends ViewPane {
         this._treeDataSource = this.instantiationService.createInstance(SCMHistoryTreeDataSource);
         this._register(this._treeDataSource);
         this._tree = this.instantiationService.createInstance(WorkbenchAsyncDataTree, 'SCM History Tree', container, ( (new ListDelegate())), [
-            this.instantiationService.createInstance(RepositoryRenderer, repository => this._getRepositoryDescription(repository), this._actionRunner, getActionViewItemProvider(this.instantiationService)),
             this.instantiationService.createInstance(HistoryItemRenderer, historyItemHoverDelegate),
-            this.instantiationService.createInstance(HistoryItemLoadMoreRenderer, repository => this._getLoadMore(repository), repository => this._loadMoreCallback(repository)),
+            this.instantiationService.createInstance(HistoryItemLoadMoreRenderer, this._repositoryIsLoadingMore, () => this._loadMore()),
         ], this._treeDataSource, {
             accessibilityProvider: ( (new SCMHistoryTreeAccessibilityProvider())),
             identityProvider: this._treeIdentityProvider,
-            collapseByDefault: (e) => !isSCMRepository(e),
+            collapseByDefault: (e) => false,
             keyboardNavigationLabelProvider: ( (new SCMHistoryTreeKeyboardNavigationLabelProvider())),
             horizontalScrolling: false,
             multipleSelectionSupport: false,
@@ -693,16 +1208,13 @@ let SCMHistoryViewPane = class SCMHistoryViewPane extends ViewPane {
         if (!e.element) {
             return;
         }
-        else if (isSCMRepository(e.element)) {
-            this._scmViewService.focus(e.element);
-        }
         else if (isSCMHistoryItemViewModelTreeElement(e.element)) {
             const historyItem = e.element.historyItemViewModel.historyItem;
             const historyItemParentId = historyItem.parentIds.length > 0 ? historyItem.parentIds[0] : undefined;
             const historyProvider = e.element.repository.provider.historyProvider.get();
             const historyItemChanges = await historyProvider?.provideHistoryItemChanges(historyItem.id, historyItemParentId);
             if (historyItemChanges) {
-                const title = `${historyItem.id.substring(0, 8)} - ${historyItem.message}`;
+                const title = getHistoryItemEditorTitle(historyItem);
                 const rootUri = e.element.repository.provider.rootUri;
                 const path = rootUri ? rootUri.path : e.element.repository.provider.label;
                 const multiDiffSourceUri = ( (URI.from(
@@ -711,169 +1223,70 @@ let SCMHistoryViewPane = class SCMHistoryViewPane extends ViewPane {
                 )));
                 await this._commandService.executeCommand('_workbench.openMultiDiffEditor', { title, multiDiffSourceUri, resources: historyItemChanges });
             }
-            this._scmViewService.focus(e.element.repository);
         }
         else if (isSCMHistoryItemLoadMoreTreeElement(e.element)) {
-            const repositoryCount = this._scmViewService.visibleRepositories.length;
-            const alwaysShowRepositories = this.configurationService.getValue('scm.alwaysShowRepositories') === true;
-            if (repositoryCount > 1 || alwaysShowRepositories) {
-                this._loadMoreCallback(e.element.repository);
+            const pageOnScroll = this.configurationService.getValue('scm.graph.pageOnScroll') === true;
+            if (!pageOnScroll) {
+                this._loadMore();
                 this._tree.setSelection([]);
             }
         }
     }
     _onContextMenu(e) {
         const element = e.element;
-        if (!element) {
+        if (!element || !isSCMHistoryItemViewModelTreeElement(element)) {
             return;
         }
-        let actions = [];
-        let context = element;
-        let actionRunner = ( (new HistoryItemActionRunner(() => this._getSelectedHistoryItems())));
-        if (isSCMRepository(element)) {
-            const menus = this._scmViewService.menus.getRepositoryMenus(element.provider);
-            const menu = menus.repositoryContextMenu;
-            actions = collectContextMenuActions(menu);
-            actionRunner = ( (new RepositoryActionRunner(() => this._getSelectedRepositories())));
-            context = element.provider;
-        }
-        else if (isSCMHistoryItemViewModelTreeElement(element)) {
-            const menus = this._scmViewService.menus.getRepositoryMenus(element.repository.provider);
-            const menu = menus.historyProviderMenu?.getHistoryItemMenu2(element);
-            actions = menu ? collectContextMenuActions(menu) : [];
-        }
-        actionRunner.onWillRun(() => this._tree.domFocus());
         this.contextMenuService.showContextMenu({
+            contextKeyService: this.scopedContextKeyService,
+            menuId: MenuId.SCMChangesContext,
+            menuActionOptions: {
+                arg: element.repository.provider,
+                shouldForwardArgs: true
+            },
             getAnchor: () => e.anchor,
-            getActions: () => actions,
-            getActionsContext: () => context,
-            actionRunner
+            getActionsContext: () => element.historyItemViewModel.historyItem
         });
     }
-    _onDidChangeVisibleRepositories({ added, removed }) {
-        for (const repository of added) {
-            const repositoryDisposables = ( (new DisposableStore()));
-            repositoryDisposables.add(autorun(reader => {
-                const historyProvider = repository.provider.historyProvider.read(reader);
-                const currentHistoryItemGroupId = historyProvider?.currentHistoryItemGroupId.read(reader);
-                const currentHistoryItemGroupRevision = historyProvider?.currentHistoryItemGroupRevision.read(reader);
-                const currentHistoryItemGroupRemoteId = historyProvider?.currentHistoryItemGroupRemoteId.read(reader);
-                if (this._scmViewService.visibleRepositories.length === 1) {
-                    this._scmHistoryItemGroupHasRemoteContextKey.set(!!currentHistoryItemGroupRemoteId);
-                }
-                else {
-                    this._scmHistoryItemGroupHasRemoteContextKey.reset();
-                }
-                if (!currentHistoryItemGroupId && !currentHistoryItemGroupRevision && !currentHistoryItemGroupRemoteId) {
-                    return;
-                }
-                this.refresh(repository);
-            }));
-            repositoryDisposables.add(autorun(reader => {
-                const historyProvider = repository.provider.historyProvider.read(reader);
-                const currentHistoryItemGroupRemoteRevision = historyProvider?.currentHistoryItemGroupRemoteRevision.read(reader);
-                if (!currentHistoryItemGroupRemoteRevision) {
-                    return;
-                }
-                if (this._tree.scrollTop === 0) {
-                    this.refresh(repository);
-                    return;
-                }
-                const description = ( localize(6478, "OUTDATED"));
-                this._setRepositoryDescription(this._isRepositoryNodeVisible() ? repository : undefined, description);
-            }));
-            this._repositories.set(repository, repositoryDisposables);
-        }
-        for (const repository of removed) {
-            this._treeDataSource.clearState(repository);
-            this._repositoryDescription.delete(repository);
-            this._repositoryLoadMore.delete(repository);
-            this._repositories.deleteAndDispose(repository);
-        }
-        this._updateChildren();
-    }
-    _getSelectedRepositories() {
-        const focusedRepositories = this._tree.getFocus().filter(r => !!r && isSCMRepository(r));
-        const selectedRepositories = this._tree.getSelection().filter(r => !!r && isSCMRepository(r));
-        return Array.from(( (new Set([...focusedRepositories, ...selectedRepositories]))));
-    }
-    _getSelectedHistoryItems() {
-        return this._tree.getSelection()
-            .filter(r => !!r && isSCMHistoryItemViewModelTreeElement(r));
-    }
-    _getLoadMore(repository) {
-        let loadMore = this._repositoryLoadMore.get(repository);
-        if (!loadMore) {
-            loadMore = observableValue(this, false);
-            this._repositoryLoadMore.set(repository, loadMore);
-        }
-        return loadMore;
-    }
-    async _loadMoreCallback(repository) {
-        const loadMore = this._getLoadMore(repository);
-        if (loadMore.get()) {
-            return;
-        }
-        loadMore.set(true, undefined);
-        this._treeDataSource.loadMore(repository);
-        await this._updateChildren(repository);
-        loadMore.set(false, undefined);
-    }
-    _getRepositoryDescription(repository) {
-        let description = this._repositoryDescription.get(repository);
-        if (!description) {
-            description = observableValue(this, '');
-            this._repositoryDescription.set(repository, description);
-        }
-        return description;
-    }
-    _setRepositoryDescription(repository, description) {
-        if (!repository) {
-            this.updateTitleDescription(description);
-        }
-        else {
-            this._getRepositoryDescription(repository).set(description, undefined);
-        }
-    }
-    _isRepositoryNodeVisible() {
-        const repositoryCount = this._scmViewService.visibleRepositories.length;
-        const alwaysShowRepositories = this.configurationService.getValue('scm.alwaysShowRepositories') === true;
-        return alwaysShowRepositories || repositoryCount > 1;
+    async _loadMore(cursor) {
+        return this._treeLoadMoreSequencer.queue(async () => {
+            if (this._repositoryIsLoadingMore.get()) {
+                return;
+            }
+            this._repositoryIsLoadingMore.set(true, undefined);
+            this._treeViewModel.loadMore(cursor);
+            await this._updateChildren();
+            this._repositoryIsLoadingMore.set(false, undefined);
+        });
     }
-    _updateChildren(element) {
+    _updateChildren() {
         return this._updateChildrenThrottler.queue(() => this._treeOperationSequencer.queue(async () => {
             await this._progressService.withProgress({ location: this.id }, async () => {
-                if (element && this._tree.hasNode(element)) {
-                    await this._tree.updateChildren(element, undefined, undefined, {
-                    });
-                }
-                else {
-                    await this._tree.updateChildren(undefined, undefined, undefined, {
-                    });
-                }
+                await this._tree.updateChildren(undefined, undefined, undefined, {
+                });
             });
         }));
     }
     dispose() {
         this._visibilityDisposables.dispose();
-        this._repositories.dispose();
         super.dispose();
     }
 };
 SCMHistoryViewPane = ( (__decorate([
     ( (__param(1, ICommandService))),
-    ( (__param(2, ISCMViewService))),
-    ( (__param(3, IProgressService))),
-    ( (__param(4, IConfigurationService))),
-    ( (__param(5, IContextMenuService))),
-    ( (__param(6, IKeybindingService))),
-    ( (__param(7, IInstantiationService))),
-    ( (__param(8, IViewDescriptorService))),
-    ( (__param(9, IContextKeyService))),
-    ( (__param(10, IOpenerService))),
-    ( (__param(11, IThemeService))),
-    ( (__param(12, ITelemetryService))),
-    ( (__param(13, IHoverService)))
+    ( (__param(2, IInstantiationService))),
+    ( (__param(3, INotificationService))),
+    ( (__param(4, IProgressService))),
+    ( (__param(5, IConfigurationService))),
+    ( (__param(6, IContextMenuService))),
+    ( (__param(7, IKeybindingService))),
+    ( (__param(8, IInstantiationService))),
+    ( (__param(9, IViewDescriptorService))),
+    ( (__param(10, IContextKeyService))),
+    ( (__param(11, IOpenerService))),
+    ( (__param(12, IThemeService))),
+    ( (__param(13, ITelemetryService))),
+    ( (__param(14, IHoverService)))
 ], SCMHistoryViewPane)));
 
 export { SCMHistoryViewPane };