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

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

@@ -0,0 +1,280 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { equals } from 'vscode/vscode/vs/base/common/arrays';
+import { Emitter } from 'vscode/vscode/vs/base/common/event';
+import { DisposableStore, dispose } from 'vscode/vscode/vs/base/common/lifecycle';
+import './media/scm.css.js';
+import { localizeWithPath } from 'vscode/vscode/vs/nls';
+import { createAndFillInActionBarActions } from 'vscode/vscode/vs/platform/actions/browser/menuEntryActionViewItem';
+import { MenuRegistry, MenuId, IMenuService } from 'vscode/vscode/vs/platform/actions/common/actions';
+import { IContextKeyService } from 'vscode/vscode/vs/platform/contextkey/common/contextkey';
+import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
+import { ServiceCollection } from 'vscode/vscode/vs/platform/instantiation/common/serviceCollection';
+import { ISCMService } from 'vscode/vscode/vs/workbench/contrib/scm/common/scm';
+
+function actionEquals(a, b) {
+    return a.id === b.id;
+}
+const repositoryMenuDisposables = ( new DisposableStore());
+MenuRegistry.onDidChangeMenu(e => {
+    if (( e.has(MenuId.SCMTitle))) {
+        repositoryMenuDisposables.clear();
+        for (const menuItem of MenuRegistry.getMenuItems(MenuId.SCMTitle)) {
+            repositoryMenuDisposables.add(MenuRegistry.appendMenuItem(MenuId.SCMSourceControlInline, menuItem));
+        }
+    }
+});
+let SCMTitleMenu = class SCMTitleMenu {
+    get actions() { return this._actions; }
+    get secondaryActions() { return this._secondaryActions; }
+    constructor(menuService, contextKeyService) {
+        this._actions = [];
+        this._secondaryActions = [];
+        this._onDidChangeTitle = ( new Emitter());
+        this.onDidChangeTitle = this._onDidChangeTitle.event;
+        this.disposables = ( new DisposableStore());
+        this.menu = menuService.createMenu(MenuId.SCMTitle, contextKeyService);
+        this.disposables.add(this.menu);
+        this.menu.onDidChange(this.updateTitleActions, this, this.disposables);
+        this.updateTitleActions();
+    }
+    updateTitleActions() {
+        const primary = [];
+        const secondary = [];
+        createAndFillInActionBarActions(this.menu, { shouldForwardArgs: true }, { primary, secondary });
+        if (equals(primary, this._actions, actionEquals) && equals(secondary, this._secondaryActions, actionEquals)) {
+            return;
+        }
+        this._actions = primary;
+        this._secondaryActions = secondary;
+        this._onDidChangeTitle.fire();
+    }
+    dispose() {
+        this.disposables.dispose();
+    }
+};
+SCMTitleMenu = ( __decorate([
+    ( __param(0, IMenuService)),
+    ( __param(1, IContextKeyService))
+], SCMTitleMenu));
+class SCMMenusItem {
+    get resourceGroupMenu() {
+        if (!this._resourceGroupMenu) {
+            this._resourceGroupMenu = this.menuService.createMenu(MenuId.SCMResourceGroupContext, this.contextKeyService);
+        }
+        return this._resourceGroupMenu;
+    }
+    get resourceFolderMenu() {
+        if (!this._resourceFolderMenu) {
+            this._resourceFolderMenu = this.menuService.createMenu(MenuId.SCMResourceFolderContext, this.contextKeyService);
+        }
+        return this._resourceFolderMenu;
+    }
+    constructor(contextKeyService, menuService) {
+        this.contextKeyService = contextKeyService;
+        this.menuService = menuService;
+    }
+    getResourceMenu(resource) {
+        if (typeof resource.contextValue === 'undefined') {
+            if (!this.genericResourceMenu) {
+                this.genericResourceMenu = this.menuService.createMenu(MenuId.SCMResourceContext, this.contextKeyService);
+            }
+            return this.genericResourceMenu;
+        }
+        if (!this.contextualResourceMenus) {
+            this.contextualResourceMenus = ( new Map());
+        }
+        let item = this.contextualResourceMenus.get(resource.contextValue);
+        if (!item) {
+            const contextKeyService = this.contextKeyService.createOverlay([['scmResourceState', resource.contextValue]]);
+            const menu = this.menuService.createMenu(MenuId.SCMResourceContext, contextKeyService);
+            item = {
+                menu, dispose() {
+                    menu.dispose();
+                }
+            };
+            this.contextualResourceMenus.set(resource.contextValue, item);
+        }
+        return item.menu;
+    }
+    dispose() {
+        this._resourceGroupMenu?.dispose();
+        this._resourceFolderMenu?.dispose();
+        this.genericResourceMenu?.dispose();
+        if (this.contextualResourceMenus) {
+            dispose(( this.contextualResourceMenus.values()));
+            this.contextualResourceMenus.clear();
+            this.contextualResourceMenus = undefined;
+        }
+    }
+}
+let SCMRepositoryMenus = class SCMRepositoryMenus {
+    get repositoryContextMenu() {
+        if (!this._repositoryContextMenu) {
+            this._repositoryContextMenu = this.menuService.createMenu(MenuId.SCMSourceControl, this.contextKeyService);
+            this.disposables.add(this._repositoryContextMenu);
+        }
+        return this._repositoryContextMenu;
+    }
+    get historyProviderMenu() {
+        if (this.provider.historyProvider && !this._historyProviderMenu) {
+            this._historyProviderMenu = ( new SCMHistoryProviderMenus(this.contextKeyService, this.menuService));
+            this.disposables.add(this._historyProviderMenu);
+        }
+        return this._historyProviderMenu;
+    }
+    constructor(provider, contextKeyService, instantiationService, menuService) {
+        this.provider = provider;
+        this.menuService = menuService;
+        this.resourceGroupMenusItems = ( new Map());
+        this.disposables = ( new DisposableStore());
+        this.contextKeyService = contextKeyService.createOverlay([
+            ['scmProvider', provider.contextValue],
+            ['scmProviderRootUri', provider.rootUri?.toString()],
+            ['scmProviderHasRootUri', !!provider.rootUri],
+        ]);
+        const serviceCollection = ( new ServiceCollection([IContextKeyService, this.contextKeyService]));
+        instantiationService = instantiationService.createChild(serviceCollection);
+        this.titleMenu = instantiationService.createInstance(SCMTitleMenu);
+        this.disposables.add(this.titleMenu);
+        this.repositoryMenu = menuService.createMenu(MenuId.SCMSourceControlInline, this.contextKeyService);
+        this.disposables.add(this.repositoryMenu);
+        provider.onDidChangeResourceGroups(this.onDidChangeResourceGroups, this, this.disposables);
+        this.onDidChangeResourceGroups();
+    }
+    getResourceGroupMenu(group) {
+        return this.getOrCreateResourceGroupMenusItem(group).resourceGroupMenu;
+    }
+    getResourceMenu(resource) {
+        return this.getOrCreateResourceGroupMenusItem(resource.resourceGroup).getResourceMenu(resource);
+    }
+    getResourceFolderMenu(group) {
+        return this.getOrCreateResourceGroupMenusItem(group).resourceFolderMenu;
+    }
+    getOrCreateResourceGroupMenusItem(group) {
+        let result = this.resourceGroupMenusItems.get(group);
+        if (!result) {
+            const contextKeyService = this.contextKeyService.createOverlay([
+                ['scmResourceGroup', group.id],
+                ['multiDiffEditorEnableViewChanges', group.multiDiffEditorEnableViewChanges],
+            ]);
+            result = ( new SCMMenusItem(contextKeyService, this.menuService));
+            this.resourceGroupMenusItems.set(group, result);
+        }
+        return result;
+    }
+    onDidChangeResourceGroups() {
+        for (const resourceGroup of ( this.resourceGroupMenusItems.keys())) {
+            if (!this.provider.groups.includes(resourceGroup)) {
+                this.resourceGroupMenusItems.get(resourceGroup)?.dispose();
+                this.resourceGroupMenusItems.delete(resourceGroup);
+            }
+        }
+    }
+    dispose() {
+        this.disposables.dispose();
+        this.resourceGroupMenusItems.forEach(item => item.dispose());
+    }
+};
+SCMRepositoryMenus = ( __decorate([
+    ( __param(1, IContextKeyService)),
+    ( __param(2, IInstantiationService)),
+    ( __param(3, IMenuService))
+], SCMRepositoryMenus));
+let SCMHistoryProviderMenus = class SCMHistoryProviderMenus {
+    constructor(contextKeyService, menuService) {
+        this.contextKeyService = contextKeyService;
+        this.menuService = menuService;
+        this.historyItemMenus = ( new Map());
+        this.disposables = ( new DisposableStore());
+    }
+    getHistoryItemMenu(historyItem) {
+        return this.getOrCreateHistoryItemMenu(historyItem);
+    }
+    getHistoryItemGroupMenu(historyItemGroup) {
+        return historyItemGroup.direction === 'incoming' ?
+            this.menuService.createMenu(MenuId.SCMIncomingChanges, this.contextKeyService) :
+            this.getOutgoingHistoryItemGroupMenu(MenuId.SCMOutgoingChanges, historyItemGroup);
+    }
+    getHistoryItemGroupContextMenu(historyItemGroup) {
+        return historyItemGroup.direction === 'incoming' ?
+            this.menuService.createMenu(MenuId.SCMIncomingChangesContext, this.contextKeyService) :
+            this.getOutgoingHistoryItemGroupMenu(MenuId.SCMOutgoingChangesContext, historyItemGroup);
+    }
+    getOrCreateHistoryItemMenu(historyItem) {
+        let result = this.historyItemMenus.get(historyItem);
+        if (!result) {
+            let menuId;
+            if (historyItem.historyItemGroup.direction === 'incoming') {
+                menuId = historyItem.type === 'allChanges' ?
+                    MenuId.SCMIncomingChangesAllChangesContext :
+                    MenuId.SCMIncomingChangesHistoryItemContext;
+            }
+            else {
+                menuId = historyItem.type === 'allChanges' ?
+                    MenuId.SCMOutgoingChangesAllChangesContext :
+                    MenuId.SCMOutgoingChangesHistoryItemContext;
+            }
+            const contextKeyService = this.contextKeyService.createOverlay([
+                ['scmHistoryItemFileCount', historyItem.statistics?.files ?? 0],
+            ]);
+            result = this.menuService.createMenu(menuId, contextKeyService);
+            this.historyItemMenus.set(historyItem, result);
+        }
+        return result;
+    }
+    getOutgoingHistoryItemGroupMenu(menuId, historyItemGroup) {
+        const contextKeyService = this.contextKeyService.createOverlay([
+            ['scmHistoryItemGroupHasUpstream', !!historyItemGroup.repository.provider.historyProvider?.currentHistoryItemGroup?.base],
+        ]);
+        return this.menuService.createMenu(menuId, contextKeyService);
+    }
+    dispose() {
+        this.disposables.dispose();
+    }
+};
+SCMHistoryProviderMenus = ( __decorate([
+    ( __param(0, IContextKeyService)),
+    ( __param(1, IMenuService))
+], SCMHistoryProviderMenus));
+let SCMMenus = class SCMMenus {
+    constructor(scmService, instantiationService) {
+        this.instantiationService = instantiationService;
+        this.disposables = ( new DisposableStore());
+        this.menus = ( new Map());
+        this.titleMenu = instantiationService.createInstance(SCMTitleMenu);
+        scmService.onDidRemoveRepository(this.onDidRemoveRepository, this, this.disposables);
+    }
+    onDidRemoveRepository(repository) {
+        const menus = this.menus.get(repository.provider);
+        menus?.dispose();
+        this.menus.delete(repository.provider);
+    }
+    getRepositoryMenus(provider) {
+        let result = this.menus.get(provider);
+        if (!result) {
+            const menus = this.instantiationService.createInstance(SCMRepositoryMenus, provider);
+            const dispose = () => {
+                menus.dispose();
+                this.menus.delete(provider);
+            };
+            result = { menus, dispose };
+            this.menus.set(provider, result);
+        }
+        return result.menus;
+    }
+    dispose() {
+        this.disposables.dispose();
+    }
+};
+SCMMenus = ( __decorate([
+    ( __param(0, ISCMService)),
+    ( __param(1, IInstantiationService))
+], SCMMenus));
+MenuRegistry.appendMenuItem(MenuId.SCMResourceContext, {
+    title: ( localizeWithPath('vs/workbench/contrib/scm/browser/menus', 'miShare', "Share")),
+    submenu: MenuId.SCMResourceContextShare,
+    group: '45_share',
+    order: 3,
+});
+
+export { SCMHistoryProviderMenus, SCMMenus, SCMRepositoryMenus, SCMTitleMenu };