@codingame/monaco-vscode-scm-service-override 22.1.8 → 23.0.0

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

@@ -12,52 +12,304 @@ import { IContextMenuService } from '@codingame/monaco-vscode-api/vscode/vs/plat
 import { IContextKeyService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service';
 import { IKeybindingService } from '@codingame/monaco-vscode-api/vscode/vs/platform/keybinding/common/keybinding.service';
 import { IThemeService } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/themeService.service';
-import { Disposable, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { combinedDisposable, DisposableStore, Disposable, DisposableMap } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
 import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
 import { IViewDescriptorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/views.service';
 import { IOpenerService } from '@codingame/monaco-vscode-api/vscode/vs/platform/opener/common/opener.service';
 import { RepositoryRenderer, RepositoryActionRunner } from './scmRepositoryRenderer.js';
-import { isSCMRepository, getActionViewItemProvider, collectContextMenuActions } from '@codingame/monaco-vscode-5084de40-f866-5cb5-9d9b-33a10f6f235d-common/vscode/vs/workbench/contrib/scm/browser/util';
+import { isSCMRepository, isSCMArtifactGroupTreeElement, isSCMArtifactTreeElement, isSCMArtifactNode, connectPrimaryMenu, getActionViewItemProvider, collectContextMenuActions } from '@codingame/monaco-vscode-bc6f260d-ec63-5c95-9446-1ca7d0872719-common/vscode/vs/workbench/contrib/scm/browser/util';
 import { Orientation } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/sash/sash';
 import { Iterable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/iterator';
 import { MenuId } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions';
+import { IMenuService } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions.service';
 import { IHoverService } from '@codingame/monaco-vscode-api/vscode/vs/platform/hover/browser/hover.service';
 import { observableConfigValue } from '@codingame/monaco-vscode-api/vscode/vs/platform/observable/common/platformObservableUtils';
 import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
-import { Sequencer } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { Sequencer, Throttler } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { IconLabel } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/iconLabel/iconLabel';
+import { SCMViewService } from './scmViewService.js';
+import { ThemeIcon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/themables';
+import { WorkbenchToolBar } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/browser/toolbar';
+import { ITelemetryService } from '@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service';
+import { ICommandService } from '@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands.service';
+import { ResourceTree } from '@codingame/monaco-vscode-bc6f260d-ec63-5c95-9446-1ca7d0872719-common/vscode/vs/base/common/resourceTree';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { basename } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
 import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
-import { observableFromEvent } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableFromEvent';
+import { runOnChange } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/utils/runOnChange';
 import { observableSignalFromEvent } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableSignalFromEvent';
 
+var ArtifactGroupRenderer_1, ArtifactRenderer_1;
 registerCss(scm);
 class ListDelegate {
     getHeight() {
         return 22;
     }
-    getTemplateId() {
-        return RepositoryRenderer.TEMPLATE_ID;
+    getTemplateId(element) {
+        if (isSCMRepository(element)) {
+            return RepositoryRenderer.TEMPLATE_ID;
+        }
+        else if (isSCMArtifactGroupTreeElement(element)) {
+            return ArtifactGroupRenderer.TEMPLATE_ID;
+        }
+        else if (isSCMArtifactTreeElement(element) || isSCMArtifactNode(element)) {
+            return ArtifactRenderer.TEMPLATE_ID;
+        }
+        else {
+            throw ( new Error('Invalid tree element'));
+        }
     }
 }
+let ArtifactGroupRenderer = class ArtifactGroupRenderer {
+    static { ArtifactGroupRenderer_1 = this; }
+    static { this.TEMPLATE_ID = 'artifactGroup'; }
+    get templateId() { return ArtifactGroupRenderer_1.TEMPLATE_ID; }
+    constructor(_contextMenuService, _contextKeyService, _keybindingService, _menuService, _commandService, _scmViewService, _telemetryService) {
+        this._contextMenuService = _contextMenuService;
+        this._contextKeyService = _contextKeyService;
+        this._keybindingService = _keybindingService;
+        this._menuService = _menuService;
+        this._commandService = _commandService;
+        this._scmViewService = _scmViewService;
+        this._telemetryService = _telemetryService;
+    }
+    renderTemplate(container) {
+        const element = append(container, $('.scm-artifact-group'));
+        const icon = append(element, $('.icon'));
+        const label = ( new IconLabel(element, { supportIcons: false }));
+        const actionsContainer = append(element, $('.actions'));
+        const actionBar = ( new WorkbenchToolBar(
+            actionsContainer,
+            undefined,
+            this._menuService,
+            this._contextKeyService,
+            this._contextMenuService,
+            this._keybindingService,
+            this._commandService,
+            this._telemetryService
+        ));
+        return { icon, label, actionBar, elementDisposables: ( new DisposableStore()), templateDisposable: combinedDisposable(label, actionBar) };
+    }
+    renderElement(node, index, templateData) {
+        const provider = node.element.repository.provider;
+        const artifactGroup = node.element.artifactGroup;
+        templateData.icon.className = ThemeIcon.isThemeIcon(artifactGroup.icon)
+            ? `icon ${ThemeIcon.asClassName(artifactGroup.icon)}`
+            : '';
+        templateData.label.setLabel(artifactGroup.name);
+        const repositoryMenus = this._scmViewService.menus.getRepositoryMenus(provider);
+        templateData.elementDisposables.add(connectPrimaryMenu(repositoryMenus.getArtifactGroupMenu(artifactGroup), primary => {
+            templateData.actionBar.setActions(primary);
+        }, 'inline', provider));
+        templateData.actionBar.context = artifactGroup;
+    }
+    renderCompressedElements(node, index, templateData, details) {
+        throw ( new Error('Should never happen since node is incompressible'));
+    }
+    disposeElement(element, index, templateData, details) {
+        templateData.elementDisposables.clear();
+    }
+    disposeTemplate(templateData) {
+        templateData.elementDisposables.dispose();
+        templateData.templateDisposable.dispose();
+    }
+};
+ArtifactGroupRenderer = ArtifactGroupRenderer_1 = ( __decorate([
+    ( __param(0, IContextMenuService)),
+    ( __param(1, IContextKeyService)),
+    ( __param(2, IKeybindingService)),
+    ( __param(3, IMenuService)),
+    ( __param(4, ICommandService)),
+    ( __param(5, ISCMViewService)),
+    ( __param(6, ITelemetryService))
+], ArtifactGroupRenderer));
+let ArtifactRenderer = class ArtifactRenderer {
+    static { ArtifactRenderer_1 = this; }
+    static { this.TEMPLATE_ID = 'artifact'; }
+    get templateId() { return ArtifactRenderer_1.TEMPLATE_ID; }
+    constructor(_contextMenuService, _contextKeyService, _keybindingService, _menuService, _commandService, _scmViewService, _telemetryService) {
+        this._contextMenuService = _contextMenuService;
+        this._contextKeyService = _contextKeyService;
+        this._keybindingService = _keybindingService;
+        this._menuService = _menuService;
+        this._commandService = _commandService;
+        this._scmViewService = _scmViewService;
+        this._telemetryService = _telemetryService;
+    }
+    renderTemplate(container) {
+        const element = append(container, $('.scm-artifact'));
+        const icon = append(element, $('.icon'));
+        const label = ( new IconLabel(element, { supportIcons: false }));
+        const actionsContainer = append(element, $('.actions'));
+        const actionBar = ( new WorkbenchToolBar(
+            actionsContainer,
+            undefined,
+            this._menuService,
+            this._contextKeyService,
+            this._contextMenuService,
+            this._keybindingService,
+            this._commandService,
+            this._telemetryService
+        ));
+        return { icon, label, actionBar, elementDisposables: ( new DisposableStore()), templateDisposable: combinedDisposable(label, actionBar) };
+    }
+    renderElement(nodeOrElement, index, templateData) {
+        const artifactOrFolder = nodeOrElement.element;
+        if (isSCMArtifactTreeElement(artifactOrFolder)) {
+            const artifact = artifactOrFolder.artifact;
+            const artifactIcon = artifact.icon ?? artifactOrFolder.group.icon;
+            templateData.icon.className = ThemeIcon.isThemeIcon(artifactIcon)
+                ? `icon ${ThemeIcon.asClassName(artifactIcon)}`
+                : '';
+            const artifactLabel = artifact.name.split('/').pop() ?? artifact.name;
+            templateData.label.setLabel(artifactLabel, artifact.description);
+        }
+        else if (isSCMArtifactNode(artifactOrFolder)) {
+            templateData.icon.className = `icon ${ThemeIcon.asClassName(Codicon.folder)}`;
+            templateData.label.setLabel(basename(artifactOrFolder.uri));
+        }
+        this._renderActionBar(artifactOrFolder, templateData);
+    }
+    renderCompressedElements(node, index, templateData, details) {
+        const compressed = node.element;
+        const artifactOrFolder = compressed.elements[compressed.elements.length - 1];
+        if (isSCMArtifactTreeElement(artifactOrFolder)) {
+            const artifact = artifactOrFolder.artifact;
+            const artifactIcon = artifact.icon ?? artifactOrFolder.group.icon;
+            templateData.icon.className = ThemeIcon.isThemeIcon(artifactIcon)
+                ? `icon ${ThemeIcon.asClassName(artifactIcon)}`
+                : '';
+            templateData.label.setLabel(artifact.name, artifact.description);
+        }
+        else if (isSCMArtifactNode(artifactOrFolder)) {
+            templateData.icon.className = `icon ${ThemeIcon.asClassName(Codicon.folder)}`;
+            templateData.label.setLabel(artifactOrFolder.uri.fsPath.substring(1));
+        }
+        this._renderActionBar(artifactOrFolder, templateData);
+    }
+    _renderActionBar(artifactOrFolder, templateData) {
+        if (isSCMArtifactTreeElement(artifactOrFolder)) {
+            const artifact = artifactOrFolder.artifact;
+            const provider = artifactOrFolder.repository.provider;
+            const repositoryMenus = this._scmViewService.menus.getRepositoryMenus(provider);
+            templateData.elementDisposables.add(connectPrimaryMenu(repositoryMenus.getArtifactMenu(artifactOrFolder.group, artifact), primary => {
+                templateData.actionBar.setActions(primary);
+            }, 'inline', provider));
+            templateData.actionBar.context = artifact;
+        }
+        else if (ResourceTree.isResourceNode(artifactOrFolder)) {
+            templateData.actionBar.setActions([]);
+            templateData.actionBar.context = undefined;
+        }
+    }
+    disposeElement(element, index, templateData, details) {
+        templateData.elementDisposables.clear();
+    }
+    disposeTemplate(templateData) {
+        templateData.elementDisposables.dispose();
+        templateData.templateDisposable.dispose();
+    }
+};
+ArtifactRenderer = ArtifactRenderer_1 = ( __decorate([
+    ( __param(0, IContextMenuService)),
+    ( __param(1, IContextKeyService)),
+    ( __param(2, IKeybindingService)),
+    ( __param(3, IMenuService)),
+    ( __param(4, ICommandService)),
+    ( __param(5, ISCMViewService)),
+    ( __param(6, ITelemetryService))
+], ArtifactRenderer));
 let RepositoryTreeDataSource = class RepositoryTreeDataSource extends Disposable {
     constructor(scmViewService) {
         super();
         this.scmViewService = scmViewService;
     }
-    getChildren(inputOrElement) {
-        const parentId = isSCMRepository(inputOrElement)
-            ? inputOrElement.provider.id
-            : undefined;
-        const repositories = this.scmViewService.repositories
-            .filter(r => r.provider.parentId === parentId);
-        return repositories;
+    async getChildren(inputOrElement) {
+        if (this.scmViewService.explorerEnabledConfig.get() === false) {
+            const parentId = isSCMRepository(inputOrElement)
+                ? inputOrElement.provider.id
+                : undefined;
+            const repositories = this.scmViewService.repositories
+                .filter(r => r.provider.parentId === parentId);
+            return repositories;
+        }
+        if (inputOrElement instanceof SCMViewService) {
+            const repositories = this.scmViewService.repositories
+                .filter(r => r.provider.parentId === undefined);
+            if (repositories.length !== this.scmViewService.repositories.length) {
+                for (const repository of repositories) {
+                    const childRepositories = this.scmViewService.repositories
+                        .filter(r => r.provider.parentId === repository.provider.id);
+                    if (childRepositories.length === 0) {
+                        continue;
+                    }
+                    const repositoryIndex = repositories.indexOf(repository);
+                    repositories.splice(repositoryIndex + 1, 0, ...childRepositories);
+                }
+            }
+            return repositories;
+        }
+        else if (isSCMRepository(inputOrElement)) {
+            const artifactGroups = (await inputOrElement.provider.artifactProvider.get()?.provideArtifactGroups()) ?? [];
+            return ( artifactGroups.map(group => ({
+                repository: inputOrElement,
+                artifactGroup: group,
+                type: 'artifactGroup'
+            })));
+        }
+        else if (isSCMArtifactGroupTreeElement(inputOrElement)) {
+            const repository = inputOrElement.repository;
+            const artifacts = (await repository.provider.artifactProvider.get()?.provideArtifacts(inputOrElement.artifactGroup.id)) ?? [];
+            const artifactsTree = ( new ResourceTree(inputOrElement));
+            for (const artifact of artifacts) {
+                artifactsTree.add(( URI.from({
+                    scheme: 'scm-artifact', path: artifact.name
+                })), {
+                    repository,
+                    group: inputOrElement.artifactGroup,
+                    artifact,
+                    type: 'artifact'
+                });
+            }
+            return ( Iterable.map(artifactsTree.root.children, node => node.element ?? node));
+        }
+        else if (isSCMArtifactNode(inputOrElement)) {
+            return ( Iterable.map(
+                inputOrElement.children,
+                node => node.element && node.childrenCount === 0 ? node.element : node
+            ));
+        }
+        else ;
+        return [];
     }
     hasChildren(inputOrElement) {
-        const parentId = isSCMRepository(inputOrElement)
-            ? inputOrElement.provider.id
-            : undefined;
-        const repositories = this.scmViewService.repositories
-            .filter(r => r.provider.parentId === parentId);
-        return repositories.length > 0;
+        if (this.scmViewService.explorerEnabledConfig.get() === false) {
+            const parentId = isSCMRepository(inputOrElement)
+                ? inputOrElement.provider.id
+                : undefined;
+            const repositories = this.scmViewService.repositories
+                .filter(r => r.provider.parentId === parentId);
+            return repositories.length > 0;
+        }
+        if (inputOrElement instanceof SCMViewService) {
+            return this.scmViewService.repositories.length > 0;
+        }
+        else if (isSCMRepository(inputOrElement)) {
+            return true;
+        }
+        else if (isSCMArtifactGroupTreeElement(inputOrElement)) {
+            return true;
+        }
+        else if (isSCMArtifactTreeElement(inputOrElement)) {
+            return false;
+        }
+        else if (isSCMArtifactNode(inputOrElement)) {
+            return inputOrElement.childrenCount > 0;
+        }
+        else {
+            return false;
+        }
     }
 };
 RepositoryTreeDataSource = ( __decorate([
@@ -65,7 +317,31 @@ RepositoryTreeDataSource = ( __decorate([
 ], RepositoryTreeDataSource));
 class RepositoryTreeIdentityProvider {
     getId(element) {
-        return element.provider.id;
+        if (isSCMRepository(element)) {
+            return `repo:${element.provider.id}`;
+        }
+        else if (isSCMArtifactGroupTreeElement(element)) {
+            return `artifactGroup:${element.repository.provider.id}/${element.artifactGroup.id}`;
+        }
+        else if (isSCMArtifactTreeElement(element)) {
+            return `artifact:${element.repository.provider.id}/${element.group.id}/${element.artifact.id}`;
+        }
+        else if (isSCMArtifactNode(element)) {
+            return `artifactFolder:${element.context.repository.provider.id}/${element.context.artifactGroup.id}/${element.uri.fsPath}`;
+        }
+        else {
+            throw ( new Error('Invalid tree element'));
+        }
+    }
+}
+class RepositoriesTreeCompressionDelegate {
+    isIncompressible(element) {
+        if (ResourceTree.isResourceNode(element)) {
+            return element.childrenCount > 1;
+        }
+        else {
+            return true;
+        }
     }
 }
 let SCMRepositoriesViewPane = class SCMRepositoriesViewPane extends ViewPane {
@@ -74,9 +350,12 @@ let SCMRepositoriesViewPane = class SCMRepositoriesViewPane extends ViewPane {
         this.scmService = scmService;
         this.scmViewService = scmViewService;
         this.treeOperationSequencer = ( new Sequencer());
+        this.updateChildrenThrottler = ( new Throttler());
         this.visibilityDisposables = ( new DisposableStore());
+        this.repositoryDisposables = ( new DisposableMap());
         this.visibleCountObs = observableConfigValue('scm.repositories.visible', 10, this.configurationService);
         this.providerCountBadgeObs = observableConfigValue('scm.providerCountBadge', 'hidden', this.configurationService);
+        this._register(this.updateChildrenThrottler);
     }
     renderBody(container) {
         super.renderBody(container);
@@ -98,20 +377,11 @@ let SCMRepositoriesViewPane = class SCMRepositoriesViewPane extends ViewPane {
                     const visibleCount = this.visibleCountObs.read(reader);
                     this.updateBodySize(this.tree.contentHeight, visibleCount);
                 }));
-                const addedRepositoryObs = observableFromEvent(this, this.scmService.onDidAddRepository, e => e);
-                const removedRepositoryObs = observableFromEvent(this, this.scmService.onDidRemoveRepository, e => e);
-                this.visibilityDisposables.add(autorun(async (reader) => {
-                    const addedRepository = addedRepositoryObs.read(reader);
-                    const removedRepository = removedRepositoryObs.read(reader);
-                    if (addedRepository === undefined && removedRepository === undefined) {
-                        await this.updateChildren();
-                        return;
-                    }
-                    if (addedRepository) {
-                        await this.updateRepository(addedRepository);
-                    }
-                    if (removedRepository) {
-                        await this.updateRepository(removedRepository);
+                this.visibilityDisposables.add(runOnChange(this.scmViewService.explorerEnabledConfig, async () => {
+                    await this.updateChildren();
+                    this.updateBodySize(this.tree.contentHeight);
+                    if (this.scmViewService.repositories.length === 1) {
+                        await this.treeOperationSequencer.queue(() => this.tree.expand(this.scmViewService.repositories[0]));
                     }
                 }));
                 const onDidChangeVisibleRepositoriesSignal = observableSignalFromEvent(this, this.scmViewService.onDidChangeVisibleRepositories);
@@ -119,6 +389,11 @@ let SCMRepositoriesViewPane = class SCMRepositoriesViewPane extends ViewPane {
                     onDidChangeVisibleRepositoriesSignal.read(reader);
                     await this.treeOperationSequencer.queue(() => this.updateTreeSelection());
                 }));
+                this.scmService.onDidAddRepository(this.onDidAddRepository, this, this.visibilityDisposables);
+                this.scmService.onDidRemoveRepository(this.onDidRemoveRepository, this, this.visibilityDisposables);
+                for (const repository of this.scmService.repositories) {
+                    this.onDidAddRepository(repository);
+                }
             });
         }, this, this._store);
     }
@@ -134,78 +409,155 @@ let SCMRepositoriesViewPane = class SCMRepositoriesViewPane extends ViewPane {
         this.treeIdentityProvider = ( new RepositoryTreeIdentityProvider());
         this.treeDataSource = this.instantiationService.createInstance(RepositoryTreeDataSource);
         this._register(this.treeDataSource);
-        const compressionEnabled = observableConfigValue('scm.compactFolders', true, this.configurationService);
-        this.tree = this.instantiationService.createInstance(WorkbenchCompressibleAsyncDataTree, 'SCM Repositories', container, ( new ListDelegate()), {
-            isIncompressible: () => true
-        }, [
-            this.instantiationService.createInstance(RepositoryRenderer, MenuId.SCMSourceControlInline, getActionViewItemProvider(this.instantiationService))
+        this.tree = this.instantiationService.createInstance(WorkbenchCompressibleAsyncDataTree, 'SCM Repositories', container, ( new ListDelegate()), ( new RepositoriesTreeCompressionDelegate()), [
+            this.instantiationService.createInstance(RepositoryRenderer, MenuId.SCMSourceControlInline, getActionViewItemProvider(this.instantiationService)),
+            this.instantiationService.createInstance(ArtifactGroupRenderer),
+            this.instantiationService.createInstance(ArtifactRenderer)
         ], this.treeDataSource, {
             identityProvider: this.treeIdentityProvider,
             horizontalScrolling: false,
             collapseByDefault: (e) => {
-                if (isSCMRepository(e) && e.provider.parentId === undefined) {
-                    return false;
+                if (this.scmViewService.explorerEnabledConfig.get() === false) {
+                    if (isSCMRepository(e) && e.provider.parentId === undefined) {
+                        return false;
+                    }
+                    return true;
+                }
+                if (isSCMArtifactNode(e)) {
+                    return !(e.childrenCount === 1 && Iterable.first(e.children)?.element === undefined);
+                }
+                else {
+                    return true;
                 }
-                return true;
             },
-            compressionEnabled: compressionEnabled.get(),
+            compressionEnabled: true,
             overrideStyles: this.getLocationBasedColors().listOverrideStyles,
-            expandOnDoubleClick: false,
+            multipleSelectionSupport: this.scmViewService.selectionModeConfig.get() === 'multiple',
+            expandOnDoubleClick: true,
             expandOnlyOnTwistieClick: true,
             accessibilityProvider: {
-                getAriaLabel(r) {
-                    return r.provider.label;
+                getAriaLabel(element) {
+                    if (isSCMRepository(element)) {
+                        return element.provider.label;
+                    }
+                    else if (isSCMArtifactGroupTreeElement(element)) {
+                        return element.artifactGroup.name;
+                    }
+                    else if (isSCMArtifactTreeElement(element)) {
+                        return element.artifact.name;
+                    }
+                    else {
+                        return '';
+                    }
                 },
                 getWidgetAriaLabel() {
-                    return localize(10148, "Source Control Repositories");
+                    return localize(10423, "Source Control Repositories");
                 }
             }
         });
         this._register(this.tree);
+        this._register(autorun(reader => {
+            const selectionMode = this.scmViewService.selectionModeConfig.read(reader);
+            this.tree.updateOptions({ multipleSelectionSupport: selectionMode === 'multiple' });
+        }));
         this._register(this.tree.onDidChangeSelection(this.onTreeSelectionChange, this));
         this._register(this.tree.onDidChangeFocus(this.onTreeDidChangeFocus, this));
         this._register(this.tree.onDidFocus(this.onDidTreeFocus, this));
         this._register(this.tree.onContextMenu(this.onTreeContextMenu, this));
         this._register(this.tree.onDidChangeContentHeight(this.onTreeContentHeightChange, this));
     }
+    async onDidAddRepository(repository) {
+        const disposables = ( new DisposableStore());
+        disposables.add(autorun(async (reader) => {
+            const explorerEnabled = this.scmViewService.explorerEnabledConfig.read(reader);
+            const artifactsProvider = repository.provider.artifactProvider.read(reader);
+            if (!explorerEnabled || !artifactsProvider) {
+                return;
+            }
+            reader.store.add(artifactsProvider.onDidChangeArtifacts(async (groups) => {
+                await this.updateRepository(repository);
+            }));
+        }));
+        disposables.add(autorun(async (reader) => {
+            const historyProvider = repository.provider.historyProvider.read(reader);
+            if (!historyProvider) {
+                return;
+            }
+            reader.store.add(runOnChange(historyProvider.historyItemRef, async () => {
+                await this.updateRepository(repository);
+            }));
+        }));
+        await this.updateRepository(repository);
+        this.repositoryDisposables.set(repository, disposables);
+    }
+    async onDidRemoveRepository(repository) {
+        await this.updateRepository(repository);
+        this.repositoryDisposables.deleteAndDispose(repository);
+    }
     onTreeContextMenu(e) {
         if (!e.element) {
             return;
         }
-        const provider = e.element.provider;
-        const menus = this.scmViewService.menus.getRepositoryMenus(provider);
-        const menu = menus.getRepositoryContextMenu(e.element);
-        const actions = collectContextMenuActions(menu);
-        const disposables = ( new DisposableStore());
-        const actionRunner = ( new RepositoryActionRunner(() => {
-            return this.tree.getSelection();
-        }));
-        disposables.add(actionRunner);
-        disposables.add(actionRunner.onWillRun(() => this.tree.domFocus()));
-        this.contextMenuService.showContextMenu({
-            actionRunner,
-            getAnchor: () => e.anchor,
-            getActions: () => actions,
-            getActionsContext: () => provider,
-            onHide: () => disposables.dispose()
-        });
+        if (isSCMRepository(e.element)) {
+            const provider = e.element.provider;
+            const menus = this.scmViewService.menus.getRepositoryMenus(provider);
+            const menu = menus.getRepositoryContextMenu(e.element);
+            const actions = collectContextMenuActions(menu);
+            const disposables = ( new DisposableStore());
+            const actionRunner = ( new RepositoryActionRunner(() => {
+                return this.getTreeSelection();
+            }));
+            disposables.add(actionRunner);
+            disposables.add(actionRunner.onWillRun(() => this.tree.domFocus()));
+            this.contextMenuService.showContextMenu({
+                actionRunner,
+                getAnchor: () => e.anchor,
+                getActions: () => actions,
+                getActionsContext: () => provider,
+                onHide: () => disposables.dispose()
+            });
+        }
+        else if (isSCMArtifactTreeElement(e.element)) {
+            const provider = e.element.repository.provider;
+            const artifact = e.element.artifact;
+            const menus = this.scmViewService.menus.getRepositoryMenus(provider);
+            const menu = menus.getArtifactMenu(e.element.group, artifact);
+            const actions = collectContextMenuActions(menu, provider);
+            this.contextMenuService.showContextMenu({
+                getAnchor: () => e.anchor,
+                getActions: () => actions,
+                getActionsContext: () => artifact
+            });
+        }
     }
     onTreeSelectionChange(e) {
         if (e.browserEvent && e.elements.length > 0) {
             const scrollTop = this.tree.scrollTop;
-            this.scmViewService.visibleRepositories = e.elements;
+            if (e.elements.every(e => isSCMRepository(e))) {
+                this.scmViewService.visibleRepositories = e.elements;
+            }
+            else if (e.elements.every(e => isSCMArtifactGroupTreeElement(e) || isSCMArtifactTreeElement(e))) {
+                this.scmViewService.visibleRepositories = ( e.elements.map(e => e.repository));
+            }
             this.tree.scrollTop = scrollTop;
         }
     }
     onTreeDidChangeFocus(e) {
         if (e.browserEvent && e.elements.length > 0) {
-            this.scmViewService.focus(e.elements[0]);
+            if (isSCMRepository(e.elements[0])) {
+                this.scmViewService.focus(e.elements[0]);
+            }
         }
     }
     onDidTreeFocus() {
         const focused = this.tree.getFocus();
         if (focused.length > 0) {
-            this.scmViewService.focus(focused[0]);
+            if (isSCMRepository(focused[0])) {
+                this.scmViewService.focus(focused[0]);
+            }
+            else if (isSCMArtifactGroupTreeElement(focused[0]) || isSCMArtifactTreeElement(focused[0])) {
+                this.scmViewService.focus(focused[0].repository);
+            }
         }
     }
     onTreeContentHeightChange(height) {
@@ -213,24 +565,27 @@ let SCMRepositoriesViewPane = class SCMRepositoriesViewPane extends ViewPane {
         this.treeOperationSequencer.queue(() => this.updateTreeSelection());
     }
     async updateChildren(element) {
-        await this.treeOperationSequencer.queue(async () => {
+        return this.updateChildrenThrottler.queue(() => this.treeOperationSequencer.queue(async () => {
             if (element && this.tree.hasNode(element)) {
                 await this.tree.updateChildren(element, true);
             }
             else {
                 await this.tree.updateChildren(undefined, true);
             }
-        });
+        }));
     }
     async expand(element) {
         await this.treeOperationSequencer.queue(() => this.tree.expand(element, true));
     }
     async updateRepository(repository) {
-        if (repository.provider.parentId === undefined) {
-            await this.updateChildren();
-            return;
+        if (this.scmViewService.explorerEnabledConfig.get() === false) {
+            if (repository.provider.parentId === undefined) {
+                await this.updateChildren();
+                return;
+            }
+            await this.updateParentRepository(repository);
         }
-        await this.updateParentRepository(repository);
+        await this.updateChildren();
     }
     async updateParentRepository(repository) {
         const parentRepository = this.scmViewService.repositories
@@ -245,14 +600,20 @@ let SCMRepositoriesViewPane = class SCMRepositoriesViewPane extends ViewPane {
         if (this.orientation === Orientation.HORIZONTAL) {
             return;
         }
-        visibleCount = visibleCount ?? this.visibleCountObs.get();
-        const empty = this.scmViewService.repositories.length === 0;
-        const size = Math.min(contentHeight / 22, visibleCount) * 22;
-        this.minimumBodySize = visibleCount === 0 ? 22 : size;
-        this.maximumBodySize = visibleCount === 0 ? Number.POSITIVE_INFINITY : empty ? Number.POSITIVE_INFINITY : size;
+        if (this.scmViewService.explorerEnabledConfig.get() === false) {
+            visibleCount = visibleCount ?? this.visibleCountObs.get();
+            const empty = this.scmViewService.repositories.length === 0;
+            const size = Math.min(contentHeight / 22, visibleCount) * 22;
+            this.minimumBodySize = visibleCount === 0 ? 22 : size;
+            this.maximumBodySize = visibleCount === 0 ? Number.POSITIVE_INFINITY : empty ? Number.POSITIVE_INFINITY : size;
+        }
+        else {
+            this.minimumBodySize = 120;
+            this.maximumBodySize = Number.POSITIVE_INFINITY;
+        }
     }
     async updateTreeSelection() {
-        const oldSelection = this.tree.getSelection();
+        const oldSelection = this.getTreeSelection();
         const oldSet = ( new Set(oldSelection));
         const set = ( new Set(this.scmViewService.visibleRepositories));
         const added = ( new Set(Iterable.filter(set, r => !( oldSet.has(r)))));
@@ -274,6 +635,23 @@ let SCMRepositoriesViewPane = class SCMRepositoriesViewPane extends ViewPane {
             this.tree.setFocus([visibleSelection[0]]);
         }
     }
+    getTreeSelection() {
+        return ( this.tree.getSelection()
+            .map(e => {
+            if (isSCMRepository(e)) {
+                return e;
+            }
+            else if (isSCMArtifactGroupTreeElement(e) || isSCMArtifactTreeElement(e)) {
+                return e.repository;
+            }
+            else if (isSCMArtifactNode(e)) {
+                return e.context.repository;
+            }
+            else {
+                throw ( new Error('Invalid tree element'));
+            }
+        }));
+    }
     dispose() {
         this.visibilityDisposables.dispose();
         super.dispose();