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

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

@@ -0,0 +1,879 @@
+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 { 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 { observableValue } from 'vscode/vscode/vs/base/common/observableInternal/base';
+import 'vscode/vscode/vs/base/common/observableInternal/derived';
+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 { 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';
+import { ContextKeyExpr } from 'vscode/vscode/vs/platform/contextkey/common/contextkey';
+import { IContextKeyService } from 'vscode/vscode/vs/platform/contextkey/common/contextkey.service';
+import { IContextMenuService } from 'vscode/vscode/vs/platform/contextview/browser/contextView.service';
+import { WorkbenchHoverDelegate } from 'vscode/vscode/vs/platform/hover/browser/hover';
+import { IHoverService } from 'vscode/vscode/vs/platform/hover/browser/hover.service';
+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 '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';
+import 'vscode/vscode/vs/platform/theme/common/colors/listColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/menuColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/minimapColors';
+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 { 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 { 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 { 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';
+
+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.")));
+registerAction2(class extends ViewAction {
+    constructor() {
+        super({
+            id: 'workbench.scm.action.refreshGraph',
+            title: ( localize(6469, "Refresh")),
+            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))
+                    ))
+                ))),
+                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);
+    }
+});
+class ListDelegate {
+    getHeight() {
+        return 22;
+    }
+    getTemplateId(element) {
+        if (isSCMRepository(element)) {
+            return RepositoryRenderer.TEMPLATE_ID;
+        }
+        else if (isSCMHistoryItemViewModelTreeElement(element)) {
+            return HistoryItemRenderer.TEMPLATE_ID;
+        }
+        else if (isSCMHistoryItemLoadMoreTreeElement(element)) {
+            return HistoryItemLoadMoreRenderer.TEMPLATE_ID;
+        }
+        else {
+            throw ( (new Error('Unknown element')));
+        }
+    }
+}
+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) {
+        this.hoverDelegate = hoverDelegate;
+        this.hoverService = hoverService;
+        this.themeService = themeService;
+    }
+    renderTemplate(container) {
+        container.parentElement.parentElement.querySelector('.monaco-tl-twistie').classList.add('force-no-twistie');
+        const element = append(container, $('.history-item'));
+        const graphContainer = append(element, $('.graph-container'));
+        const iconLabel = ( (new IconLabel(
+            element,
+            { supportIcons: true, supportHighlights: true, supportDescriptionHighlights: true }
+        )));
+        const labelContainer = append(element, $('.label-container'));
+        element.appendChild(labelContainer);
+        return { element, graphContainer, label: iconLabel, labelContainer, elementDisposables: ( (new DisposableStore())), disposables: ( (new DisposableStore())) };
+    }
+    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));
+        templateData.elementDisposables.add(historyItemHover);
+        templateData.graphContainer.textContent = '';
+        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));
+                }
+            }
+        }
+    }
+    getLabels(repository) {
+        const currentHistoryItemGroup = repository.provider.historyProvider.get()?.currentHistoryItemGroup.get();
+        if (!currentHistoryItemGroup) {
+            return [];
+        }
+        return [
+            currentHistoryItemGroup.name,
+            currentHistoryItemGroup.remote?.name,
+            currentHistoryItemGroup.base?.name
+        ]
+            .filter(l => l !== undefined);
+    }
+    getTooltip(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}**`);
+            if (historyItem.timestamp) {
+                const dateFormatter = new Intl.DateTimeFormat(language, { year: 'numeric', month: 'long', day: 'numeric', hour: 'numeric', minute: 'numeric' });
+                markdown.appendMarkdown(`, $(history) ${fromNow(historyItem.timestamp, true, true)} (${dateFormatter.format(historyItem.timestamp)})`);
+            }
+            markdown.appendMarkdown('\n\n');
+        }
+        markdown.appendMarkdown(`${historyItem.message}\n\n`);
+        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>`);
+            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>`);
+            }
+            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);
+            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>`;
+            }))).join('&nbsp;&nbsp;'));
+        }
+        return { markdown, markdownNotSupportedFallback: historyItem.message };
+    }
+    processMatches(historyItemViewModel, filterData) {
+        if (!filterData) {
+            return [undefined, undefined];
+        }
+        return [
+            historyItemViewModel.historyItem.message === filterData.label ? createMatches(filterData.score) : undefined,
+            historyItemViewModel.historyItem.author === filterData.label ? createMatches(filterData.score) : undefined
+        ];
+    }
+    disposeElement(element, index, templateData, height) {
+        templateData.elementDisposables.clear();
+    }
+    disposeTemplate(templateData) {
+        templateData.disposables.dispose();
+    }
+};
+HistoryItemRenderer = HistoryItemRenderer_1 = ( (__decorate([
+    ( (__param(1, IHoverService))),
+    ( (__param(2, 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;
+        this._loadMoreCallback = _loadMoreCallback;
+        this._configurationService = _configurationService;
+        this._scmViewService = _scmViewService;
+    }
+    renderTemplate(container) {
+        container.parentElement.parentElement.querySelector('.monaco-tl-twistie').classList.add('force-no-twistie');
+        const element = append(container, $('.history-item-load-more'));
+        const graphPlaceholder = append(element, $('.graph-placeholder'));
+        const historyItemPlaceholderContainer = append(element, $('.history-item-placeholder'));
+        const historyItemPlaceholderLabel = ( (new IconLabel(historyItemPlaceholderContainer, { supportIcons: true })));
+        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)));
+            }));
+        }
+        else {
+            templateData.historyItemPlaceholderLabel.setLabel('');
+            this._loadMoreCallback(element.element.repository);
+        }
+    }
+    disposeTemplate(templateData) {
+        templateData.disposables.dispose();
+    }
+};
+HistoryItemLoadMoreRenderer = HistoryItemLoadMoreRenderer_1 = ( (__decorate([
+    ( (__param(2, IConfigurationService))),
+    ( (__param(3, ISCMViewService)))
+], 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);
+        this._viewContainerLocation = _viewContainerLocation;
+        this.layoutService = layoutService;
+    }
+    getHoverOptions() {
+        const sideBarPosition = this.layoutService.getSideBarPosition();
+        let hoverPosition;
+        if (this._viewContainerLocation === ViewContainerLocation.Sidebar) {
+            hoverPosition = sideBarPosition === Position.LEFT ? HoverPosition.RIGHT : HoverPosition.LEFT;
+        }
+        else if (this._viewContainerLocation === ViewContainerLocation.AuxiliaryBar) {
+            hoverPosition = sideBarPosition === Position.LEFT ? HoverPosition.LEFT : HoverPosition.RIGHT;
+        }
+        else {
+            hoverPosition = HoverPosition.RIGHT;
+        }
+        return { additionalClasses: ['history-item-hover'], position: { hoverPosition, forcePosition: true } };
+    }
+};
+HistoryItemHoverDelegate = ( (__decorate([
+    ( (__param(1, IWorkbenchLayoutService))),
+    ( (__param(2, IConfigurationService))),
+    ( (__param(3, IHoverService)))
+], HistoryItemHoverDelegate)));
+let SCMHistoryViewPaneActionRunner = class SCMHistoryViewPaneActionRunner extends ActionRunner {
+    constructor(_progressService) {
+        super();
+        this._progressService = _progressService;
+    }
+    runAction(action, context) {
+        return this._progressService.withProgress({ location: HISTORY_VIEW_PANE_ID }, async () => await super.runAction(action, context));
+    }
+};
+SCMHistoryViewPaneActionRunner = ( (__decorate([
+    ( (__param(0, IProgressService)))
+], SCMHistoryViewPaneActionRunner)));
+class SCMHistoryTreeAccessibilityProvider {
+    getWidgetAriaLabel() {
+        return ( localize(6477, "Source Control History"));
+    }
+    getAriaLabel(element) {
+        if (isSCMRepository(element)) {
+            return `${element.provider.name} ${element.provider.label}`;
+        }
+        else if (isSCMHistoryItemViewModelTreeElement(element)) {
+            const historyItem = element.historyItemViewModel.historyItem;
+            return `${stripIcons(historyItem.message).trim()}${historyItem.author ? `, ${historyItem.author}` : ''}`;
+        }
+        else {
+            return '';
+        }
+    }
+}
+class SCMHistoryTreeIdentityProvider {
+    getId(element) {
+        if (isSCMRepository(element)) {
+            const provider = element.provider;
+            return `repo:${provider.id}`;
+        }
+        else if (isSCMHistoryItemViewModelTreeElement(element)) {
+            const provider = element.repository.provider;
+            const historyItem = element.historyItemViewModel.historyItem;
+            return `historyItem:${provider.id}/${historyItem.id}/${historyItem.parentIds.join(',')}`;
+        }
+        else if (isSCMHistoryItemLoadMoreTreeElement(element)) {
+            const provider = element.repository.provider;
+            return `historyItemLoadMore:${provider.id}}`;
+        }
+        else {
+            throw ( (new Error('Invalid tree element')));
+        }
+    }
+}
+class SCMHistoryTreeKeyboardNavigationLabelProvider {
+    getKeyboardNavigationLabel(element) {
+        if (isSCMRepository(element)) {
+            return undefined;
+        }
+        else if (isSCMHistoryItemViewModelTreeElement(element)) {
+            return [element.historyItemViewModel.historyItem.message, element.historyItemViewModel.historyItem.author];
+        }
+        else if (isSCMHistoryItemLoadMoreTreeElement(element)) {
+            return '';
+        }
+        else {
+            throw ( (new Error('Invalid tree element')));
+        }
+    }
+}
+let SCMHistoryTreeDataSource = class SCMHistoryTreeDataSource extends Disposable {
+    constructor(_configurationService, _scmViewService) {
+        super();
+        this._configurationService = _configurationService;
+        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'
+                });
+            }
+            return children;
+        }
+        return [];
+    }
+    hasChildren(inputOrElement) {
+        if (isSCMViewService(inputOrElement)) {
+            return this._scmViewService.visibleRepositories.length !== 0;
+        }
+        else if (isSCMRepository(inputOrElement)) {
+            return true;
+        }
+        else if (isSCMHistoryItemViewModelTreeElement(inputOrElement)) {
+            return false;
+        }
+        else if (isSCMHistoryItemLoadMoreTreeElement(inputOrElement)) {
+            return false;
+        }
+        else {
+            throw ( (new Error('hasChildren not implemented.')));
+        }
+    }
+    clearState(repository) {
+        if (!repository) {
+            this._state.clear();
+            return;
+        }
+        this._state.delete(repository);
+    }
+    loadMore(repository) {
+        const state = this._state.get(repository);
+        if (!state) {
+            return;
+        }
+        this._state.set(repository, { ...state, loadMore: 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) {
+            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)
+                .map(historyItemViewModel => ({
+                repository: element,
+                historyItemViewModel,
+                type: 'historyItem2'
+            })))
+        );
+    }
+    dispose() {
+        this._state.clear();
+        super.dispose();
+    }
+};
+SCMHistoryTreeDataSource = ( (__decorate([
+    ( (__param(0, IConfigurationService))),
+    ( (__param(1, ISCMViewService)))
+], SCMHistoryTreeDataSource)));
+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);
+        this._commandService = _commandService;
+        this._scmViewService = _scmViewService;
+        this._progressService = _progressService;
+        this._repositoryDescription = ( (new Map()));
+        this._repositoryLoadMore = ( (new Map()));
+        this._repositories = ( (new DisposableMap()));
+        this._visibilityDisposables = ( (new DisposableStore()));
+        this._treeOperationSequencer = ( (new Sequencer()));
+        this._updateChildrenThrottler = ( (new Throttler()));
+        this._providerCountBadgeConfig = observableConfigValue('scm.providerCountBadge', 'hidden', this.configurationService);
+        this._scmHistoryItemGroupHasRemoteContextKey = this.scopedContextKeyService.createKey('scmHistoryItemGroupHasRemote', undefined);
+        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);
+    }
+    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._visibilityDisposables.clear();
+                this._repositories.clearAndDisposeAll();
+            }
+        });
+    }
+    getActionRunner() {
+        return this._actionRunner;
+    }
+    async refresh(repository) {
+        this._treeDataSource.clearState(repository);
+        await this._updateChildren(repository);
+        this._setRepositoryDescription(repository, '');
+        this._tree.scrollTop = 0;
+    }
+    _createTree(container) {
+        this._treeIdentityProvider = ( (new SCMHistoryTreeIdentityProvider()));
+        const historyItemHoverDelegate = this.instantiationService.createInstance(HistoryItemHoverDelegate, this.viewDescriptorService.getViewLocationById(this.id));
+        this._register(historyItemHoverDelegate);
+        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._treeDataSource, {
+            accessibilityProvider: ( (new SCMHistoryTreeAccessibilityProvider())),
+            identityProvider: this._treeIdentityProvider,
+            collapseByDefault: (e) => !isSCMRepository(e),
+            keyboardNavigationLabelProvider: ( (new SCMHistoryTreeKeyboardNavigationLabelProvider())),
+            horizontalScrolling: false,
+            multipleSelectionSupport: false,
+        });
+        this._register(this._tree);
+        this._tree.onDidOpen(this._onDidOpen, this, this._store);
+        this._tree.onContextMenu(this._onContextMenu, this, this._store);
+    }
+    async _onDidOpen(e) {
+        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 rootUri = e.element.repository.provider.rootUri;
+                const path = rootUri ? rootUri.path : e.element.repository.provider.label;
+                const multiDiffSourceUri = ( (URI.from(
+                    { scheme: 'scm-history-item', path: `${path}/${historyItemParentId}..${historyItem.id}` },
+                    true
+                )));
+                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);
+                this._tree.setSelection([]);
+            }
+        }
+    }
+    _onContextMenu(e) {
+        const element = e.element;
+        if (!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({
+            getAnchor: () => e.anchor,
+            getActions: () => actions,
+            getActionsContext: () => context,
+            actionRunner
+        });
+    }
+    _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;
+    }
+    _updateChildren(element) {
+        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, {
+                    });
+                }
+            });
+        }));
+    }
+    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)))
+], SCMHistoryViewPane)));
+
+export { SCMHistoryViewPane };