@codingame/monaco-vscode-scm-service-override 1.83.15

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

@@ -0,0 +1,719 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import * as path from 'monaco-editor/esm/vs/base/common/path.js';
+import { append, $, prepend } from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { CountBadge } from 'monaco-editor/esm/vs/base/browser/ui/countBadge/countBadge.js';
+import { IconLabel } from 'monaco-editor/esm/vs/base/browser/ui/iconLabel/iconLabel.js';
+import { DisposableStore, combinedDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { ThemeIcon } from 'monaco-editor/esm/vs/base/common/themables.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { ICommandService } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { RawContextKey, ContextKeyExpr, IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { IContextMenuService } from 'monaco-editor/esm/vs/platform/contextview/browser/contextView.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { IKeybindingService } from 'monaco-editor/esm/vs/platform/keybinding/common/keybinding.js';
+import { WorkbenchCompressibleAsyncDataTree } from 'monaco-editor/esm/vs/platform/list/browser/listService.js';
+import { IOpenerService } from 'monaco-editor/esm/vs/platform/opener/common/opener.js';
+import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
+import { defaultCountBadgeStyles } from 'monaco-editor/esm/vs/platform/theme/browser/defaultStyles.js';
+import { IThemeService } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
+import { ResourceLabels } from 'vscode/vscode/vs/workbench/browser/labels';
+import { API_OPEN_DIFF_EDITOR_COMMAND_ID } from 'vscode/vscode/vs/workbench/browser/parts/editor/editorCommands';
+import { ViewPane, ViewAction } from 'vscode/vscode/vs/workbench/browser/parts/views/viewPane';
+import { IViewDescriptorService } from 'vscode/vscode/vs/workbench/common/views';
+import { RepositoryRenderer } from './scmRepositoryRenderer.js';
+import { ActionButtonRenderer } from './scmViewPane.js';
+import { getActionViewItemProvider, isSCMRepositoryArray, isSCMRepository, isSCMActionButton } from './util.js';
+import { SYNC_VIEW_PANE_ID, ISCMViewService } from 'vscode/vscode/vs/workbench/contrib/scm/common/scm';
+import { comparePaths } from 'monaco-editor/esm/vs/base/common/comparers.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+import { Iterable } from 'monaco-editor/esm/vs/base/common/iterator.js';
+import { IWorkspaceContextService } from 'monaco-editor/esm/vs/platform/workspace/common/workspace.js';
+import { basename, dirname } from 'monaco-editor/esm/vs/base/common/resources.js';
+import { ILabelService } from 'monaco-editor/esm/vs/platform/label/common/label.js';
+import { stripIcons } from 'monaco-editor/esm/vs/base/common/iconLabels.js';
+import { FileKind } from 'monaco-editor/esm/vs/platform/files/common/files.js';
+import { registerAction2, MenuId } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
+import { Codicon } from 'monaco-editor/esm/vs/base/common/codicons.js';
+import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { ResourceTree } from '../../../../base/common/resourceTree.js';
+import { IUriIdentityService } from 'monaco-editor/esm/vs/platform/uriIdentity/common/uriIdentity.js';
+
+var HistoryItemChangeRenderer_1;
+function isSCMHistoryItemGroupTreeElement(obj) {
+    return obj.type === 'historyItemGroup';
+}
+function isSCMHistoryItemTreeElement(obj) {
+    return obj.type === 'historyItem';
+}
+function isSCMHistoryItemChangeTreeElement(obj) {
+    return obj.type === 'historyItemChange';
+}
+function toDiffEditorArguments(uri, originalUri, modifiedUri) {
+    const basename = path.basename(uri.fsPath);
+    const originalQuery = JSON.parse(originalUri.query);
+    const modifiedQuery = JSON.parse(modifiedUri.query);
+    const originalShortRef = originalQuery.ref.substring(0, 8).concat(originalQuery.ref.endsWith('^') ? '^' : '');
+    const modifiedShortRef = modifiedQuery.ref.substring(0, 8).concat(modifiedQuery.ref.endsWith('^') ? '^' : '');
+    return [originalUri, modifiedUri, `${basename} (${originalShortRef}) ↔ ${basename} (${modifiedShortRef})`, null];
+}
+function getSCMResourceId(element) {
+    if (isSCMRepository(element)) {
+        const provider = element.provider;
+        return `repo:${provider.id}`;
+    }
+    else if (isSCMActionButton(element)) {
+        const provider = element.repository.provider;
+        return `actionButton:${provider.id}`;
+    }
+    else if (isSCMHistoryItemGroupTreeElement(element)) {
+        const provider = element.repository.provider;
+        return `historyItemGroup:${provider.id}/${element.id}`;
+    }
+    else if (isSCMHistoryItemTreeElement(element)) {
+        const historyItemGroup = element.historyItemGroup;
+        const provider = historyItemGroup.repository.provider;
+        return `historyItem:${provider.id}/${historyItemGroup.id}/${element.id}`;
+    }
+    else if (isSCMHistoryItemChangeTreeElement(element)) {
+        const historyItem = element.historyItem;
+        const historyItemGroup = historyItem.historyItemGroup;
+        const provider = historyItemGroup.repository.provider;
+        return `historyItemChange:${provider.id}/${historyItemGroup.id}/${historyItem.id}/${( element.uri.toString())}`;
+    }
+    else if (ResourceTree.isResourceNode(element)) {
+        const historyItem = element.context;
+        const historyItemGroup = historyItem.historyItemGroup;
+        const provider = historyItemGroup.repository.provider;
+        return element.childrenCount === 0 && element.element ?
+            `historyItemChange:${provider.id}/${historyItemGroup.id}/${historyItem.id}/${( element.element.uri.toString())}` :
+            `folder:${provider.id}/${historyItemGroup.id}/${historyItem.id}/$FOLDER/${( element.uri.toString())}`;
+    }
+    else {
+        throw new Error('Invalid tree element');
+    }
+}
+const ContextKeys = {
+    ViewMode: ( new RawContextKey('scmSyncViewMode', "list" )),
+};
+class ListDelegate {
+    getHeight(element) {
+        if (isSCMActionButton(element)) {
+            return ActionButtonRenderer.DEFAULT_HEIGHT + 10;
+        }
+        else {
+            return 22;
+        }
+    }
+    getTemplateId(element) {
+        if (isSCMRepository(element)) {
+            return RepositoryRenderer.TEMPLATE_ID;
+        }
+        else if (isSCMActionButton(element)) {
+            return ActionButtonRenderer.TEMPLATE_ID;
+        }
+        else if (isSCMHistoryItemGroupTreeElement(element)) {
+            return HistoryItemGroupRenderer.TEMPLATE_ID;
+        }
+        else if (isSCMHistoryItemTreeElement(element)) {
+            return HistoryItemRenderer.TEMPLATE_ID;
+        }
+        else if (isSCMHistoryItemChangeTreeElement(element)) {
+            return HistoryItemChangeRenderer.TEMPLATE_ID;
+        }
+        else if (ResourceTree.isResourceNode(element)) {
+            return HistoryItemChangeRenderer.TEMPLATE_ID;
+        }
+        else {
+            throw new Error('Invalid tree element');
+        }
+    }
+}
+class CompressionDelegate {
+    isIncompressible(element) {
+        if (ResourceTree.isResourceNode(element)) {
+            return element.childrenCount === 0 || !element.parent || !element.parent.parent;
+        }
+        return true;
+    }
+}
+class HistoryItemGroupRenderer {
+    static { this.TEMPLATE_ID = 'history-item-group'; }
+    get templateId() { return HistoryItemGroupRenderer.TEMPLATE_ID; }
+    renderTemplate(container) {
+        container.parentElement.parentElement.querySelector('.monaco-tl-twistie').classList.add('force-twistie');
+        const element = append(container, $('.history-item-group'));
+        const label = ( new IconLabel(element, { supportIcons: true }));
+        const countContainer = append(element, $('.count'));
+        const count = ( new CountBadge(countContainer, {}, defaultCountBadgeStyles));
+        return { label, count, disposables: ( new DisposableStore()) };
+    }
+    renderElement(node, index, templateData, height) {
+        const historyItemGroup = node.element;
+        templateData.label.setLabel(historyItemGroup.label, historyItemGroup.description);
+        templateData.count.setCount(historyItemGroup.count ?? 0);
+    }
+    disposeTemplate(templateData) {
+        templateData.disposables.dispose();
+    }
+}
+class HistoryItemRenderer {
+    static { this.TEMPLATE_ID = 'history-item'; }
+    get templateId() { return HistoryItemRenderer.TEMPLATE_ID; }
+    renderTemplate(container) {
+        container.parentElement.parentElement.querySelector('.monaco-tl-twistie').classList.add('force-twistie');
+        const element = append(container, $('.history-item'));
+        const iconLabel = ( new IconLabel(element, { supportIcons: true }));
+        const iconContainer = prepend(iconLabel.element, $('.icon-container'));
+        return { iconContainer, iconLabel, disposables: ( new DisposableStore()) };
+    }
+    renderElement(node, index, templateData, height) {
+        const historyItem = node.element;
+        templateData.iconContainer.className = 'icon-container';
+        if (historyItem.icon && ThemeIcon.isThemeIcon(historyItem.icon)) {
+            templateData.iconContainer.classList.add(...ThemeIcon.asClassNameArray(historyItem.icon));
+        }
+        templateData.iconLabel.setLabel(historyItem.label, historyItem.description);
+    }
+    disposeTemplate(templateData) {
+        templateData.disposables.dispose();
+    }
+}
+let HistoryItemChangeRenderer = class HistoryItemChangeRenderer {
+    static { HistoryItemChangeRenderer_1 = this; }
+    static { this.TEMPLATE_ID = 'historyItemChange'; }
+    get templateId() { return HistoryItemChangeRenderer_1.TEMPLATE_ID; }
+    constructor(viewMode, labels, labelService) {
+        this.viewMode = viewMode;
+        this.labels = labels;
+        this.labelService = labelService;
+    }
+    renderTemplate(container) {
+        const element = append(container, $('.change'));
+        const name = append(element, $('.name'));
+        const fileLabel = this.labels.create(name, { supportDescriptionHighlights: true, supportHighlights: true });
+        const decorationIcon = append(element, $('.decoration-icon'));
+        return { element, name, fileLabel, decorationIcon, disposables: ( new DisposableStore()) };
+    }
+    renderElement(node, index, templateData, height) {
+        const historyItemChangeOrFolder = node.element;
+        const uri = ResourceTree.isResourceNode(historyItemChangeOrFolder) ? historyItemChangeOrFolder.element?.uri ?? historyItemChangeOrFolder.uri : historyItemChangeOrFolder.uri;
+        const fileKind = ResourceTree.isResourceNode(historyItemChangeOrFolder) && historyItemChangeOrFolder.childrenCount > 0 ? FileKind.FOLDER : FileKind.FILE;
+        templateData.fileLabel.setFile(uri, {
+            fileDecorations: { colors: false, badges: true },
+            fileKind,
+            hidePath: this.viewMode() === "tree" ,
+        });
+    }
+    renderCompressedElements(node, index, templateData, height) {
+        const compressed = node.element;
+        const folder = compressed.elements[compressed.elements.length - 1];
+        const label = ( compressed.elements.map(e => e.name));
+        templateData.fileLabel.setResource({ resource: folder.uri, name: label }, {
+            fileDecorations: { colors: false, badges: true },
+            fileKind: FileKind.FOLDER,
+            separator: this.labelService.getSeparator(folder.uri.scheme)
+        });
+    }
+    disposeTemplate(templateData) {
+        templateData.disposables.dispose();
+    }
+};
+HistoryItemChangeRenderer = HistoryItemChangeRenderer_1 = ( __decorate([
+    ( __param(2, ILabelService))
+], HistoryItemChangeRenderer));
+let SCMSyncViewPaneAccessibilityProvider = class SCMSyncViewPaneAccessibilityProvider {
+    constructor(labelService, workspaceContextService) {
+        this.labelService = labelService;
+        this.workspaceContextService = workspaceContextService;
+    }
+    getAriaLabel(element) {
+        if (isSCMRepository(element)) {
+            let folderName = '';
+            if (element.provider.rootUri) {
+                const folder = this.workspaceContextService.getWorkspaceFolder(element.provider.rootUri);
+                if (folder?.uri.toString() === ( element.provider.rootUri.toString())) {
+                    folderName = folder.name;
+                }
+                else {
+                    folderName = basename(element.provider.rootUri);
+                }
+            }
+            return `${folderName} ${element.provider.label}`;
+        }
+        else if (isSCMHistoryItemGroupTreeElement(element)) {
+            return `${stripIcons(element.label).trim()}${element.description ? `, ${element.description}` : ''}`;
+        }
+        else if (isSCMActionButton(element)) {
+            return element.button?.command.title ?? '';
+        }
+        else if (isSCMHistoryItemTreeElement(element)) {
+            return `${stripIcons(element.label).trim()}${element.description ? `, ${element.description}` : ''}`;
+        }
+        else if (isSCMHistoryItemChangeTreeElement(element)) {
+            const result = [basename(element.uri)];
+            const path = this.labelService.getUriLabel(dirname(element.uri), { relative: true, noPrefix: true });
+            if (path) {
+                result.push(path);
+            }
+            return result.join(', ');
+        }
+        return '';
+    }
+    getWidgetAriaLabel() {
+        return ( localizeWithPath(
+            'vs/workbench/contrib/scm/browser/scmSyncViewPane',
+            'scmSync',
+            'Source Control Sync'
+        ));
+    }
+};
+SCMSyncViewPaneAccessibilityProvider = ( __decorate([
+    ( __param(0, ILabelService)),
+    ( __param(1, IWorkspaceContextService))
+], SCMSyncViewPaneAccessibilityProvider));
+class SCMSyncViewPaneTreeIdentityProvider {
+    getId(element) {
+        return getSCMResourceId(element);
+    }
+}
+class SCMSyncViewPaneTreeSorter {
+    compare(element, otherElement) {
+        if (isSCMRepository(element)) {
+            if (!isSCMRepository(otherElement)) {
+                throw new Error('Invalid comparison');
+            }
+            return 0;
+        }
+        if (isSCMActionButton(element)) {
+            return -1;
+        }
+        else if (isSCMActionButton(otherElement)) {
+            return 1;
+        }
+        if (isSCMHistoryItemGroupTreeElement(element)) {
+            if (!isSCMHistoryItemGroupTreeElement(otherElement)) {
+                throw new Error('Invalid comparison');
+            }
+            return 0;
+        }
+        if (isSCMHistoryItemTreeElement(element)) {
+            if (!isSCMHistoryItemTreeElement(otherElement)) {
+                throw new Error('Invalid comparison');
+            }
+            return 0;
+        }
+        const elementPath = element.uri.fsPath;
+        const otherElementPath = otherElement.uri.fsPath;
+        return comparePaths(elementPath, otherElementPath);
+    }
+}
+let SCMSyncViewPane = class SCMSyncViewPane extends ViewPane {
+    get viewModel() { return this._viewModel; }
+    constructor(options, commandService, keybindingService, contextMenuService, instantiationService, viewDescriptorService, contextKeyService, configurationService, openerService, themeService, telemetryService) {
+        super(options, keybindingService, contextMenuService, configurationService, contextKeyService, viewDescriptorService, instantiationService, openerService, themeService, telemetryService);
+        this.commandService = commandService;
+        this.disposables = ( new DisposableStore());
+    }
+    renderBody(container) {
+        super.renderBody(container);
+        this.treeContainer = append(container, $('.scm-view.scm-sync-view'));
+        this.listLabels = this.instantiationService.createInstance(ResourceLabels, { onDidChangeVisibility: this.onDidChangeBodyVisibility });
+        this._register(this.listLabels);
+        this._tree = this.instantiationService.createInstance(WorkbenchCompressibleAsyncDataTree, 'SCM Sync View', this.treeContainer, ( new ListDelegate()), ( new CompressionDelegate()), [
+            this.instantiationService.createInstance(RepositoryRenderer, getActionViewItemProvider(this.instantiationService)),
+            this.instantiationService.createInstance(ActionButtonRenderer),
+            this.instantiationService.createInstance(HistoryItemGroupRenderer),
+            this.instantiationService.createInstance(HistoryItemRenderer),
+            this.instantiationService.createInstance(HistoryItemChangeRenderer, () => this.viewModel.mode, this.listLabels),
+        ], this.instantiationService.createInstance(SCMSyncDataSource, () => this.viewModel.mode), {
+            compressionEnabled: true,
+            horizontalScrolling: false,
+            autoExpandSingleChildren: true,
+            multipleSelectionSupport: false,
+            collapseByDefault: (e) => !ResourceTree.isResourceNode(e),
+            accessibilityProvider: this.instantiationService.createInstance(SCMSyncViewPaneAccessibilityProvider),
+            identityProvider: this.instantiationService.createInstance(SCMSyncViewPaneTreeIdentityProvider),
+            sorter: this.instantiationService.createInstance(SCMSyncViewPaneTreeSorter),
+        });
+        this._register(this._tree);
+        this._register(this._tree.onDidOpen(this.onDidOpen, this));
+        this._viewModel = this.instantiationService.createInstance(SCMSyncPaneViewModel, this._tree);
+        this.treeContainer.classList.add('file-icon-themable-tree');
+        this.treeContainer.classList.add('show-file-icons');
+        this.updateIndentStyles(this.themeService.getFileIconTheme());
+        this._register(this.themeService.onDidFileIconThemeChange(this.updateIndentStyles, this));
+        this._register(this._viewModel.onDidChangeMode(this.onDidChangeMode, this));
+    }
+    layoutBody(height, width) {
+        super.layoutBody(height, width);
+        this._tree.layout(height, width);
+    }
+    onDidChangeMode() {
+        this.updateIndentStyles(this.themeService.getFileIconTheme());
+    }
+    async onDidOpen(e) {
+        if (!e.element) {
+            return;
+        }
+        if (isSCMHistoryItemChangeTreeElement(e.element)) {
+            if (e.element.originalUri && e.element.modifiedUri) {
+                await this.commandService.executeCommand(API_OPEN_DIFF_EDITOR_COMMAND_ID, ...toDiffEditorArguments(e.element.uri, e.element.originalUri, e.element.modifiedUri), e);
+            }
+        }
+        else if (ResourceTree.isResourceNode(e.element) && e.element.childrenCount === 0) {
+            if (e.element.element?.originalUri && e.element.element?.modifiedUri) {
+                await this.commandService.executeCommand(API_OPEN_DIFF_EDITOR_COMMAND_ID, ...toDiffEditorArguments(e.element.element.uri, e.element.element.originalUri, e.element.element.modifiedUri), e);
+            }
+        }
+    }
+    updateIndentStyles(theme) {
+        this.treeContainer.classList.toggle('list-view-mode', this._viewModel.mode === "list" );
+        this.treeContainer.classList.toggle('tree-view-mode', this._viewModel.mode === "tree" );
+        this.treeContainer.classList.toggle('align-icons-and-twisties', (this._viewModel.mode === "list"  && theme.hasFileIcons) || (theme.hasFileIcons && !theme.hasFolderIcons));
+    }
+    dispose() {
+        this.disposables.dispose();
+        super.dispose();
+    }
+};
+SCMSyncViewPane = ( __decorate([
+    ( __param(1, ICommandService)),
+    ( __param(2, IKeybindingService)),
+    ( __param(3, IContextMenuService)),
+    ( __param(4, IInstantiationService)),
+    ( __param(5, IViewDescriptorService)),
+    ( __param(6, IContextKeyService)),
+    ( __param(7, IConfigurationService)),
+    ( __param(8, IOpenerService)),
+    ( __param(9, IThemeService)),
+    ( __param(10, ITelemetryService))
+], SCMSyncViewPane));
+let SCMSyncPaneViewModel = class SCMSyncPaneViewModel {
+    get mode() { return this._mode; }
+    set mode(mode) {
+        if (this._mode === mode) {
+            return;
+        }
+        this._mode = mode;
+        this.refresh();
+        this.modeContextKey.set(mode);
+        this._onDidChangeMode.fire(mode);
+        this.storageService.store(`scm.syncViewMode`, mode, 1 , 0 );
+    }
+    constructor(tree, contextKeyService, scmViewService, configurationService, storageService) {
+        this.tree = tree;
+        this.configurationService = configurationService;
+        this.storageService = storageService;
+        this._onDidChangeMode = ( new Emitter());
+        this.onDidChangeMode = this._onDidChangeMode.event;
+        this.repositories = ( new Map());
+        this.historyProviders = ( new Map());
+        this.alwaysShowRepositories = false;
+        this.disposables = ( new DisposableStore());
+        configurationService.onDidChangeConfiguration(this._onDidChangeConfiguration, this, this.disposables);
+        this._onDidChangeConfiguration();
+        scmViewService.onDidChangeVisibleRepositories(this._onDidChangeVisibleRepositories, this, this.disposables);
+        this._onDidChangeVisibleRepositories({ added: scmViewService.visibleRepositories, removed: [] });
+        this._mode = this.getViewMode();
+        this.modeContextKey = ContextKeys.ViewMode.bindTo(contextKeyService);
+        this.modeContextKey.set(this._mode);
+    }
+    _onDidChangeConfiguration(e) {
+        if (!e || e.affectsConfiguration('scm.alwaysShowRepositories')) {
+            this.alwaysShowRepositories = this.configurationService.getValue('scm.alwaysShowRepositories');
+            this.refresh();
+        }
+    }
+    _onDidChangeVisibleRepositories({ added, removed }) {
+        for (const repository of added) {
+            const repositoryDisposable = repository.provider.onDidChangeHistoryProvider(() => this._onDidChangeHistoryProvider(repository));
+            this._onDidChangeHistoryProvider(repository);
+            this.repositories.set(repository, repositoryDisposable);
+        }
+        for (const repository of removed) {
+            this.historyProviders.get(repository)?.dispose();
+            this.historyProviders.delete(repository);
+            this.repositories.get(repository)?.dispose();
+            this.repositories.delete(repository);
+        }
+        this.refresh();
+    }
+    _onDidChangeHistoryProvider(repository) {
+        if (repository.provider.historyProvider) {
+            const historyProviderDisposable = combinedDisposable(repository.provider.historyProvider.onDidChangeActionButton(() => this.refresh(repository)), repository.provider.historyProvider.onDidChangeCurrentHistoryItemGroup(() => this.refresh(repository)));
+            this.historyProviders.set(repository, historyProviderDisposable);
+        }
+        else {
+            this.historyProviders.get(repository)?.dispose();
+            this.historyProviders.delete(repository);
+        }
+    }
+    getViewMode() {
+        let mode = this.configurationService.getValue('scm.defaultViewMode') === 'list' ? "list"  : "tree" ;
+        const storageMode = this.storageService.get(`scm.syncViewMode`, 1 );
+        if (typeof storageMode === 'string') {
+            mode = storageMode;
+        }
+        return mode;
+    }
+    async refresh(repository) {
+        if (this.repositories.size === 0) {
+            return;
+        }
+        if (repository) {
+            await this.tree.updateChildren(repository);
+        }
+        else if (this.repositories.size === 1 && !this.alwaysShowRepositories) {
+            await this.tree.setInput(Iterable.first(( this.repositories.keys())));
+        }
+        else {
+            const expanded = ( Array.from(( this.repositories.keys()))
+                .map(repository => `repo:${repository.provider.id}`));
+            await this.tree.setInput([...( this.repositories.keys())], { expanded });
+        }
+    }
+};
+SCMSyncPaneViewModel = ( __decorate([
+    ( __param(1, IContextKeyService)),
+    ( __param(2, ISCMViewService)),
+    ( __param(3, IConfigurationService)),
+    ( __param(4, IStorageService))
+], SCMSyncPaneViewModel));
+let SCMSyncDataSource = class SCMSyncDataSource {
+    constructor(viewMode, uriIdentityService) {
+        this.viewMode = viewMode;
+        this.uriIdentityService = uriIdentityService;
+    }
+    hasChildren(element) {
+        if (isSCMRepositoryArray(element)) {
+            return true;
+        }
+        else if (isSCMRepository(element)) {
+            return true;
+        }
+        else if (isSCMActionButton(element)) {
+            return false;
+        }
+        else if (isSCMHistoryItemGroupTreeElement(element)) {
+            return true;
+        }
+        else if (isSCMHistoryItemTreeElement(element)) {
+            return true;
+        }
+        else if (isSCMHistoryItemChangeTreeElement(element)) {
+            return false;
+        }
+        else if (ResourceTree.isResourceNode(element)) {
+            return element.childrenCount > 0;
+        }
+        else {
+            throw new Error('hasChildren not implemented.');
+        }
+    }
+    async getChildren(element) {
+        const children = [];
+        if (isSCMRepositoryArray(element)) {
+            children.push(...element);
+        }
+        else if (isSCMRepository(element)) {
+            const scmProvider = element.provider;
+            const historyProvider = scmProvider.historyProvider;
+            const historyItemGroup = historyProvider?.currentHistoryItemGroup;
+            if (!historyProvider || !historyItemGroup) {
+                return [];
+            }
+            const actionButton = historyProvider.actionButton;
+            if (actionButton) {
+                children.push({
+                    type: 'actionButton',
+                    repository: element,
+                    button: actionButton
+                });
+            }
+            children.push(...(await this.getHistoryItemGroups(element)));
+        }
+        else if (isSCMHistoryItemGroupTreeElement(element)) {
+            children.push(...(await this.getHistoryItems(element)));
+        }
+        else if (isSCMHistoryItemTreeElement(element)) {
+            children.push(...(await this.getHistoryItemChanges(element)));
+        }
+        else if (ResourceTree.isResourceNode(element)) {
+            children.push(...element.children);
+        }
+        else {
+            throw new Error('getChildren Method not implemented.');
+        }
+        return children;
+    }
+    async getHistoryItemGroups(element) {
+        const scmProvider = element.provider;
+        const historyProvider = scmProvider.historyProvider;
+        const currentHistoryItemGroup = historyProvider?.currentHistoryItemGroup;
+        if (!historyProvider || !currentHistoryItemGroup) {
+            return [];
+        }
+        const historyItemGroupBase = await historyProvider.resolveHistoryItemGroupBase(currentHistoryItemGroup.id);
+        if (!historyItemGroupBase) {
+            return [];
+        }
+        const ancestor = await historyProvider.resolveHistoryItemGroupCommonAncestor(currentHistoryItemGroup.id, historyItemGroupBase.id);
+        const children = [];
+        if (historyItemGroupBase) {
+            children.push({
+                id: historyItemGroupBase.id,
+                label: `$(cloud-download) ${historyItemGroupBase.label}`,
+                description: ( localizeWithPath(
+                    'vs/workbench/contrib/scm/browser/scmSyncViewPane',
+                    'incoming',
+                    "Incoming Changes"
+                )),
+                ancestor: ancestor?.id,
+                count: ancestor?.behind ?? 0,
+                repository: element,
+                type: 'historyItemGroup'
+            });
+        }
+        children.push({
+            id: currentHistoryItemGroup.id,
+            label: `$(cloud-upload) ${currentHistoryItemGroup.label}`,
+            description: ( localizeWithPath(
+                'vs/workbench/contrib/scm/browser/scmSyncViewPane',
+                'outgoing',
+                "Outgoing Changes"
+            )),
+            ancestor: ancestor?.id,
+            count: ancestor?.ahead ?? 0,
+            repository: element,
+            type: 'historyItemGroup'
+        });
+        return children;
+    }
+    async getHistoryItems(element) {
+        const scmProvider = element.repository.provider;
+        const historyProvider = scmProvider.historyProvider;
+        if (!historyProvider) {
+            return [];
+        }
+        const historyItems = (await historyProvider.provideHistoryItems(element.id, { limit: { id: element.ancestor } })) ?? [];
+        return ( historyItems.map(historyItem => ({
+            id: historyItem.id,
+            label: historyItem.label,
+            description: historyItem.description,
+            icon: historyItem.icon,
+            historyItemGroup: element,
+            type: 'historyItem'
+        })));
+    }
+    async getHistoryItemChanges(element) {
+        const repository = element.historyItemGroup.repository;
+        const historyProvider = repository.provider.historyProvider;
+        if (!historyProvider) {
+            return [];
+        }
+        const changes = (await historyProvider.provideHistoryItemChanges(element.id)) ?? [];
+        if (this.viewMode() === "list" ) {
+            return ( changes.map(change => ({
+                uri: change.uri,
+                originalUri: change.originalUri,
+                modifiedUri: change.modifiedUri,
+                renameUri: change.renameUri,
+                historyItem: element,
+                type: 'historyItemChange'
+            })));
+        }
+        const tree = ( new ResourceTree(
+            element,
+            repository.provider.rootUri ?? URI.file('/'),
+            this.uriIdentityService.extUri
+        ));
+        for (const change of changes) {
+            tree.add(change.uri, {
+                uri: change.uri,
+                originalUri: change.originalUri,
+                modifiedUri: change.modifiedUri,
+                renameUri: change.renameUri,
+                historyItem: element,
+                type: 'historyItemChange'
+            });
+        }
+        return [...tree.root.children];
+    }
+};
+SCMSyncDataSource = ( __decorate([
+    ( __param(1, IUriIdentityService))
+], SCMSyncDataSource));
+class RefreshAction extends ViewAction {
+    constructor() {
+        super({
+            id: 'workbench.scm.sync.action.refresh',
+            title: ( localizeWithPath('vs/workbench/contrib/scm/browser/scmSyncViewPane', 'refresh', "Refresh")),
+            viewId: SYNC_VIEW_PANE_ID,
+            f1: false,
+            icon: Codicon.refresh,
+            menu: {
+                id: MenuId.ViewTitle,
+                when: ( ContextKeyExpr.equals('view', SYNC_VIEW_PANE_ID)),
+                group: 'navigation'
+            }
+        });
+    }
+    async runInView(_, view) {
+        view.viewModel.refresh();
+    }
+}
+class SetListViewModeAction extends ViewAction {
+    constructor() {
+        super({
+            id: 'workbench.scm.sync.action.setListViewMode',
+            title: ( localizeWithPath(
+                'vs/workbench/contrib/scm/browser/scmSyncViewPane',
+                'setListViewMode',
+                "View as List"
+            )),
+            viewId: SYNC_VIEW_PANE_ID,
+            f1: false,
+            icon: Codicon.listTree,
+            toggled: ( ContextKeys.ViewMode.isEqualTo("list" )),
+            menu: {
+                id: MenuId.ViewTitle,
+                when: ( ContextKeyExpr.equals('view', SYNC_VIEW_PANE_ID)),
+                group: '1_viewmode'
+            }
+        });
+    }
+    async runInView(_, view) {
+        view.viewModel.mode = "list" ;
+    }
+}
+class SetTreeViewModeAction extends ViewAction {
+    constructor() {
+        super({
+            id: 'workbench.scm.sync.action.setTreeViewMode',
+            title: ( localizeWithPath(
+                'vs/workbench/contrib/scm/browser/scmSyncViewPane',
+                'setTreeViewMode',
+                "View as Tree"
+            )),
+            viewId: SYNC_VIEW_PANE_ID,
+            f1: false,
+            icon: Codicon.listFlat,
+            toggled: ( ContextKeys.ViewMode.isEqualTo("tree" )),
+            menu: {
+                id: MenuId.ViewTitle,
+                when: ( ContextKeyExpr.equals('view', SYNC_VIEW_PANE_ID)),
+                group: '1_viewmode'
+            }
+        });
+    }
+    async runInView(_, view) {
+        view.viewModel.mode = "tree" ;
+    }
+}
+registerAction2(RefreshAction);
+registerAction2(SetListViewModeAction);
+registerAction2(SetTreeViewModeAction);
+
+export { SCMSyncViewPane };