@codingame/monaco-vscode-scm-service-override 4.1.0 → 4.1.2

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

@@ -0,0 +1,174 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import './media/scm.css.js';
+import { localizeWithPath } from 'vscode/vscode/vs/nls';
+import { Event } from 'vscode/vscode/vs/base/common/event';
+import { ViewPane } from 'vscode/vscode/vs/workbench/browser/parts/views/viewPane';
+import { append, $ } from 'vscode/vscode/vs/base/browser/dom';
+import { ISCMViewService } from 'vscode/vscode/vs/workbench/contrib/scm/common/scm';
+import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
+import { IContextMenuService } from 'vscode/vscode/vs/platform/contextview/browser/contextView';
+import { IContextKeyService } from 'vscode/vscode/vs/platform/contextkey/common/contextkey';
+import { IKeybindingService } from 'vscode/vscode/vs/platform/keybinding/common/keybinding';
+import { IThemeService } from 'vscode/vscode/vs/platform/theme/common/themeService';
+import { WorkbenchList } from 'vscode/vscode/vs/platform/list/browser/listService';
+import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration';
+import { IViewDescriptorService } from 'vscode/vscode/vs/workbench/common/views';
+import { SIDE_BAR_BACKGROUND } from 'vscode/vscode/vs/workbench/common/theme';
+import { IOpenerService } from 'vscode/vscode/vs/platform/opener/common/opener';
+import { ITelemetryService } from 'vscode/vscode/vs/platform/telemetry/common/telemetry';
+import { RepositoryRenderer, RepositoryActionRunner } from './scmRepositoryRenderer.js';
+import { getActionViewItemProvider, collectContextMenuActions } from './util.js';
+import { Iterable } from 'vscode/vscode/vs/base/common/iterator';
+import { DisposableStore } from 'vscode/vscode/vs/base/common/lifecycle';
+import { MenuId } from 'vscode/vscode/vs/platform/actions/common/actions';
+
+class ListDelegate {
+    getHeight() {
+        return 22;
+    }
+    getTemplateId() {
+        return RepositoryRenderer.TEMPLATE_ID;
+    }
+}
+let SCMRepositoriesViewPane = class SCMRepositoriesViewPane extends ViewPane {
+    constructor(options, scmViewService, keybindingService, contextMenuService, instantiationService, viewDescriptorService, contextKeyService, configurationService, openerService, themeService, telemetryService) {
+        super({ ...options, titleMenuId: MenuId.SCMSourceControlTitle }, keybindingService, contextMenuService, configurationService, contextKeyService, viewDescriptorService, instantiationService, openerService, themeService, telemetryService);
+        this.scmViewService = scmViewService;
+        this.disposables = ( new DisposableStore());
+    }
+    renderBody(container) {
+        super.renderBody(container);
+        const listContainer = append(container, $('.scm-view.scm-repositories-view'));
+        const updateProviderCountVisibility = () => {
+            const value = this.configurationService.getValue('scm.providerCountBadge');
+            listContainer.classList.toggle('hide-provider-counts', value === 'hidden');
+            listContainer.classList.toggle('auto-provider-counts', value === 'auto');
+        };
+        this._register(Event.filter(this.configurationService.onDidChangeConfiguration, e => e.affectsConfiguration('scm.providerCountBadge'), this.disposables)(updateProviderCountVisibility));
+        updateProviderCountVisibility();
+        const delegate = ( new ListDelegate());
+        const renderer = this.instantiationService.createInstance(RepositoryRenderer, MenuId.SCMSourceControlInline, getActionViewItemProvider(this.instantiationService));
+        const identityProvider = { getId: (r) => r.provider.id };
+        this.list = this.instantiationService.createInstance(WorkbenchList, `SCM Main`, listContainer, delegate, [renderer], {
+            identityProvider,
+            horizontalScrolling: false,
+            overrideStyles: {
+                listBackground: SIDE_BAR_BACKGROUND
+            },
+            accessibilityProvider: {
+                getAriaLabel(r) {
+                    return r.provider.label;
+                },
+                getWidgetAriaLabel() {
+                    return ( localizeWithPath(
+                        'vs/workbench/contrib/scm/browser/scmRepositoriesViewPane',
+                        'scm',
+                        "Source Control Repositories"
+                    ));
+                }
+            }
+        });
+        this._register(this.list);
+        this._register(this.list.onDidChangeSelection(this.onListSelectionChange, this));
+        this._register(this.list.onContextMenu(this.onListContextMenu, this));
+        this._register(this.scmViewService.onDidChangeRepositories(this.onDidChangeRepositories, this));
+        this._register(this.scmViewService.onDidChangeVisibleRepositories(this.updateListSelection, this));
+        if (this.orientation === 0 ) {
+            this._register(this.configurationService.onDidChangeConfiguration(e => {
+                if (e.affectsConfiguration('scm.repositories.visible')) {
+                    this.updateBodySize();
+                }
+            }));
+        }
+        this.onDidChangeRepositories();
+        this.updateListSelection();
+    }
+    onDidChangeRepositories() {
+        this.list.splice(0, this.list.length, this.scmViewService.repositories);
+        this.updateBodySize();
+    }
+    focus() {
+        super.focus();
+        this.list.domFocus();
+    }
+    layoutBody(height, width) {
+        super.layoutBody(height, width);
+        this.list.layout(height, width);
+    }
+    updateBodySize() {
+        if (this.orientation === 1 ) {
+            return;
+        }
+        const visibleCount = this.configurationService.getValue('scm.repositories.visible');
+        const empty = this.list.length === 0;
+        const size = Math.min(this.list.length, visibleCount) * 22;
+        this.minimumBodySize = visibleCount === 0 ? 22 : size;
+        this.maximumBodySize = visibleCount === 0 ? Number.POSITIVE_INFINITY : empty ? Number.POSITIVE_INFINITY : size;
+    }
+    onListContextMenu(e) {
+        if (!e.element) {
+            return;
+        }
+        const provider = e.element.provider;
+        const menus = this.scmViewService.menus.getRepositoryMenus(provider);
+        const menu = menus.repositoryContextMenu;
+        const actions = collectContextMenuActions(menu);
+        const actionRunner = this._register(( new RepositoryActionRunner(() => {
+            return this.list.getSelectedElements();
+        })));
+        actionRunner.onWillRun(() => this.list.domFocus());
+        this.contextMenuService.showContextMenu({
+            actionRunner,
+            getAnchor: () => e.anchor,
+            getActions: () => actions,
+            getActionsContext: () => provider
+        });
+    }
+    onListSelectionChange(e) {
+        if (e.browserEvent && e.elements.length > 0) {
+            const scrollTop = this.list.scrollTop;
+            this.scmViewService.visibleRepositories = e.elements;
+            this.list.scrollTop = scrollTop;
+        }
+    }
+    updateListSelection() {
+        const oldSelection = this.list.getSelection();
+        const oldSet = ( new Set(( Iterable.map(oldSelection, i => this.list.element(i)))));
+        const set = ( new Set(this.scmViewService.visibleRepositories));
+        const added = ( new Set(Iterable.filter(set, r => !( oldSet.has(r)))));
+        const removed = ( new Set(Iterable.filter(oldSet, r => !( set.has(r)))));
+        if (added.size === 0 && removed.size === 0) {
+            return;
+        }
+        const selection = oldSelection
+            .filter(i => !( removed.has(this.list.element(i))));
+        for (let i = 0; i < this.list.length; i++) {
+            if (( added.has(this.list.element(i)))) {
+                selection.push(i);
+            }
+        }
+        this.list.setSelection(selection);
+        if (selection.length > 0 && selection.indexOf(this.list.getFocus()[0]) === -1) {
+            this.list.setAnchor(selection[0]);
+            this.list.setFocus([selection[0]]);
+        }
+    }
+    dispose() {
+        this.disposables.dispose();
+        super.dispose();
+    }
+};
+SCMRepositoriesViewPane = ( __decorate([
+    ( __param(1, ISCMViewService)),
+    ( __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))
+], SCMRepositoriesViewPane));
+
+export { SCMRepositoriesViewPane };

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

@@ -0,0 +1,136 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import './media/scm.css.js';
+import { combinedDisposable, DisposableStore, toDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import { append, $ } from 'vscode/vscode/vs/base/browser/dom';
+import { ISCMViewService } from 'vscode/vscode/vs/workbench/contrib/scm/common/scm';
+import { CountBadge } from 'vscode/vscode/vs/base/browser/ui/countBadge/countBadge';
+import { IContextMenuService } from 'vscode/vscode/vs/platform/contextview/browser/contextView';
+import { ICommandService } from 'vscode/vscode/vs/platform/commands/common/commands';
+import { ActionRunner } from 'vscode/vscode/vs/base/common/actions';
+import { isSCMRepository, connectPrimaryMenu, StatusBarAction } from './util.js';
+import { defaultCountBadgeStyles } from 'vscode/vscode/vs/platform/theme/browser/defaultStyles';
+import { WorkbenchToolBar } from 'vscode/vscode/vs/platform/actions/browser/toolbar';
+import { MenuId, MenuItemAction, IMenuService } from 'vscode/vscode/vs/platform/actions/common/actions';
+import { IContextKeyService } from 'vscode/vscode/vs/platform/contextkey/common/contextkey';
+import { IKeybindingService } from 'vscode/vscode/vs/platform/keybinding/common/keybinding';
+import { ITelemetryService } from 'vscode/vscode/vs/platform/telemetry/common/telemetry';
+
+var RepositoryRenderer_1;
+class RepositoryActionRunner extends ActionRunner {
+    constructor(getSelectedRepositories) {
+        super();
+        this.getSelectedRepositories = getSelectedRepositories;
+    }
+    async runAction(action, context) {
+        if (!(action instanceof MenuItemAction)) {
+            return super.runAction(action, context);
+        }
+        const selection = ( this.getSelectedRepositories().map(r => r.provider));
+        const actionContext = ( selection.some(s => s === context)) ? selection : [context];
+        await action.run(...actionContext);
+    }
+}
+let RepositoryRenderer = class RepositoryRenderer {
+    static { RepositoryRenderer_1 = this; }
+    static { this.TEMPLATE_ID = 'repository'; }
+    get templateId() { return RepositoryRenderer_1.TEMPLATE_ID; }
+    constructor(toolbarMenuId, actionViewItemProvider, scmViewService, commandService, contextKeyService, contextMenuService, keybindingService, menuService, telemetryService) {
+        this.toolbarMenuId = toolbarMenuId;
+        this.actionViewItemProvider = actionViewItemProvider;
+        this.scmViewService = scmViewService;
+        this.commandService = commandService;
+        this.contextKeyService = contextKeyService;
+        this.contextMenuService = contextMenuService;
+        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 provider = append(container, $('.scm-provider'));
+        const label = append(provider, $('.label'));
+        const name = append(label, $('span.name'));
+        const description = append(label, $('span.description'));
+        const actions = append(provider, $('.actions'));
+        const toolBar = ( new WorkbenchToolBar(
+            actions,
+            { actionViewItemProvider: this.actionViewItemProvider, resetMenu: this.toolbarMenuId },
+            this.menuService,
+            this.contextKeyService,
+            this.contextMenuService,
+            this.keybindingService,
+            this.telemetryService
+        ));
+        const countContainer = append(provider, $('.count'));
+        const count = ( new CountBadge(countContainer, {}, defaultCountBadgeStyles));
+        const visibilityDisposable = toolBar.onDidChangeDropdownVisibility(e => provider.classList.toggle('active', e));
+        const templateDisposable = combinedDisposable(visibilityDisposable, toolBar);
+        return { label, name, description, countContainer, count, toolBar, elementDisposables: ( new DisposableStore()), templateDisposable };
+    }
+    renderElement(arg, index, templateData, height) {
+        const repository = isSCMRepository(arg) ? arg : arg.element;
+        templateData.name.textContent = repository.provider.name;
+        if (repository.provider.rootUri) {
+            templateData.label.title = `${repository.provider.label}: ${repository.provider.rootUri.fsPath}`;
+            templateData.description.textContent = repository.provider.label;
+        }
+        else {
+            templateData.label.title = repository.provider.label;
+            templateData.description.textContent = '';
+        }
+        let statusPrimaryActions = [];
+        let menuPrimaryActions = [];
+        let menuSecondaryActions = [];
+        const updateToolbar = () => {
+            templateData.toolBar.setActions([...statusPrimaryActions, ...menuPrimaryActions], menuSecondaryActions);
+        };
+        const onDidChangeProvider = () => {
+            const commands = repository.provider.statusBarCommands || [];
+            statusPrimaryActions = ( commands.map(c => ( new StatusBarAction(c, this.commandService))));
+            updateToolbar();
+            const count = repository.provider.count || 0;
+            templateData.countContainer.setAttribute('data-count', String(count));
+            templateData.count.setCount(count);
+        };
+        let disposed = false;
+        templateData.elementDisposables.add(toDisposable(() => disposed = true));
+        templateData.elementDisposables.add(repository.provider.onDidChange(() => {
+            if (disposed) {
+                return;
+            }
+            onDidChangeProvider();
+        }));
+        onDidChangeProvider();
+        const repositoryMenus = this.scmViewService.menus.getRepositoryMenus(repository.provider);
+        const menu = this.toolbarMenuId === MenuId.SCMTitle ? repositoryMenus.titleMenu.menu : repositoryMenus.repositoryMenu;
+        templateData.elementDisposables.add(connectPrimaryMenu(menu, (primary, secondary) => {
+            menuPrimaryActions = primary;
+            menuSecondaryActions = secondary;
+            updateToolbar();
+        }));
+        templateData.toolBar.context = repository.provider;
+    }
+    renderCompressedElements() {
+        throw new Error('Should never happen since node is incompressible');
+    }
+    disposeElement(group, index, template) {
+        template.elementDisposables.clear();
+    }
+    disposeTemplate(templateData) {
+        templateData.elementDisposables.dispose();
+        templateData.templateDisposable.dispose();
+    }
+};
+RepositoryRenderer = RepositoryRenderer_1 = ( __decorate([
+    ( __param(2, ISCMViewService)),
+    ( __param(3, ICommandService)),
+    ( __param(4, IContextKeyService)),
+    ( __param(5, IContextMenuService)),
+    ( __param(6, IKeybindingService)),
+    ( __param(7, IMenuService)),
+    ( __param(8, ITelemetryService))
+], RepositoryRenderer));
+
+export { RepositoryActionRunner, RepositoryRenderer };