@codingame/monaco-vscode-scm-service-override 4.5.1 → 5.0.0

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

@@ -15,6 +15,7 @@ import { IWorkspaceContextService } from 'vscode/vscode/vs/platform/workspace/co
 import { IViewDescriptorService } from 'vscode/vscode/vs/workbench/common/views.service';
 import { ViewPaneContainer } from 'vscode/vscode/vs/workbench/browser/parts/views/viewPaneContainer';
 
+const _moduleId = "vs/workbench/contrib/scm/browser/scmViewPaneContainer";
 let SCMViewPaneContainer = class SCMViewPaneContainer extends ViewPaneContainer {
     constructor(scmViewService, layoutService, telemetryService, instantiationService, contextMenuService, themeService, storageService, configurationService, extensionService, contextService, viewDescriptorService) {
         super(VIEWLET_ID, { mergeViewWithContainerWhenSingleView: true }, instantiationService, configurationService, layoutService, contextMenuService, telemetryService, extensionService, themeService, storageService, contextService, viewDescriptorService);
@@ -28,28 +29,24 @@ let SCMViewPaneContainer = class SCMViewPaneContainer extends ViewPaneContainer
         return 400;
     }
     getTitle() {
-        return ( localizeWithPath(
-            'vs/workbench/contrib/scm/browser/scmViewPaneContainer',
-            'source control',
-            "Source Control"
-        ));
+        return ( localizeWithPath(_moduleId, 0, "Source Control"));
     }
     getActionsContext() {
         return this.scmViewService.visibleRepositories.length === 1 ? this.scmViewService.visibleRepositories[0].provider : undefined;
     }
 };
-SCMViewPaneContainer = ( __decorate([
-    ( __param(0, ISCMViewService)),
-    ( __param(1, IWorkbenchLayoutService)),
-    ( __param(2, ITelemetryService)),
-    ( __param(3, IInstantiationService)),
-    ( __param(4, IContextMenuService)),
-    ( __param(5, IThemeService)),
-    ( __param(6, IStorageService)),
-    ( __param(7, IConfigurationService)),
-    ( __param(8, IExtensionService)),
-    ( __param(9, IWorkspaceContextService)),
-    ( __param(10, IViewDescriptorService))
-], SCMViewPaneContainer));
+SCMViewPaneContainer = ( (__decorate([
+    ( (__param(0, ISCMViewService))),
+    ( (__param(1, IWorkbenchLayoutService))),
+    ( (__param(2, ITelemetryService))),
+    ( (__param(3, IInstantiationService))),
+    ( (__param(4, IContextMenuService))),
+    ( (__param(5, IThemeService))),
+    ( (__param(6, IStorageService))),
+    ( (__param(7, IConfigurationService))),
+    ( (__param(8, IExtensionService))),
+    ( (__param(9, IWorkspaceContextService))),
+    ( (__param(10, IViewDescriptorService)))
+], SCMViewPaneContainer)));
 
 export { SCMViewPaneContainer };

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

@@ -14,6 +14,7 @@ import { binarySearch } from 'vscode/vscode/vs/base/common/arrays';
 import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration.service';
 import { RawContextKey } from 'vscode/vscode/vs/platform/contextkey/common/contextkey';
 import { IContextKeyService } from 'vscode/vscode/vs/platform/contextkey/common/contextkey.service';
+import { IExtensionService } from 'vscode/vscode/vs/workbench/services/extensions/common/extensions.service';
 
 function getProviderStorageKey(provider) {
     return `${provider.contextValue}:${provider.label}${provider.rootUri ? `:${( provider.rootUri.toString())}` : ''}`;
@@ -72,7 +73,7 @@ let SCMViewService = class SCMViewService {
     get focusedRepository() {
         return this._repositories.find(r => r.focused)?.repository;
     }
-    constructor(scmService, contextKeyService, instantiationService, configurationService, storageService, workspaceContextService) {
+    constructor(scmService, contextKeyService, extensionService, instantiationService, configurationService, storageService, workspaceContextService) {
         this.configurationService = configurationService;
         this.storageService = storageService;
         this.workspaceContextService = workspaceContextService;
@@ -124,6 +125,10 @@ let SCMViewService = class SCMViewService {
             this.onDidAddRepository(repository);
         }
         storageService.onWillSaveState(this.onWillSaveState, this, this.disposables);
+        extensionService.onWillStop(() => {
+            this.onWillSaveState();
+            this.didFinishLoading = false;
+        }, this, this.disposables);
     }
     onDidAddRepository(repository) {
         if (!this.didFinishLoading) {
@@ -133,7 +138,7 @@ let SCMViewService = class SCMViewService {
             repository, discoveryTime: Date.now(), focused: false, selectionIndex: -1
         };
         let removed = Iterable.empty();
-        if (this.previousState) {
+        if (this.previousState && !this.didFinishLoading) {
             const index = this.previousState.all.indexOf(getProviderStorageKey(repository.provider));
             if (index === -1) {
                 const added = [];
@@ -272,8 +277,8 @@ let SCMViewService = class SCMViewService {
         }
         const all = ( this.repositories.map(r => getProviderStorageKey(r.provider)));
         const visible = ( this.visibleRepositories.map(r => all.indexOf(getProviderStorageKey(r.provider))));
-        const raw = JSON.stringify({ all, sortKey: this._repositoriesSortKey, visible });
-        this.storageService.store('scm:view:visibleRepositories', raw, 1 , 1 );
+        this.previousState = { all, sortKey: this._repositoriesSortKey, visible };
+        this.storageService.store('scm:view:visibleRepositories', JSON.stringify(this.previousState), 1 , 1 );
     }
     eventuallyFinishLoading() {
         this.finishLoading();
@@ -283,7 +288,6 @@ let SCMViewService = class SCMViewService {
             return;
         }
         this.didFinishLoading = true;
-        this.previousState = undefined;
     }
     dispose() {
         this.disposables.dispose();
@@ -297,10 +301,11 @@ SCMViewService.__decorator = ( __decorate([
 SCMViewService = ( __decorate([
     ( __param(0, ISCMService)),
     ( __param(1, IContextKeyService)),
-    ( __param(2, IInstantiationService)),
-    ( __param(3, IConfigurationService)),
-    ( __param(4, IStorageService)),
-    ( __param(5, IWorkspaceContextService))
+    ( __param(2, IExtensionService)),
+    ( __param(3, IInstantiationService)),
+    ( __param(4, IConfigurationService)),
+    ( __param(5, IStorageService)),
+    ( __param(6, IWorkspaceContextService))
 ], SCMViewService));
 
 export { RepositoryContextKeys, SCMViewService };

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

@@ -117,5 +117,8 @@ function getActionViewItemProvider(instaService) {
         return createActionViewItem(instaService, action, options);
     };
 }
+function getProviderKey(provider) {
+    return `${provider.contextValue}:${provider.label}${provider.rootUri ? `:${( provider.rootUri.toString())}` : ''}`;
+}
 
-export { StatusBarAction, collectContextMenuActions, connectPrimaryMenu, connectPrimaryMenuToInlineActionBar, getActionViewItemProvider, isSCMActionButton, isSCMHistoryItemChangeNode, isSCMHistoryItemChangeTreeElement, isSCMHistoryItemGroupTreeElement, isSCMHistoryItemTreeElement, isSCMInput, isSCMRepository, isSCMResource, isSCMResourceGroup, isSCMResourceNode, isSCMViewSeparator, isSCMViewService, toDiffEditorArguments };
+export { StatusBarAction, collectContextMenuActions, connectPrimaryMenu, connectPrimaryMenuToInlineActionBar, getActionViewItemProvider, getProviderKey, isSCMActionButton, isSCMHistoryItemChangeNode, isSCMHistoryItemChangeTreeElement, isSCMHistoryItemGroupTreeElement, isSCMHistoryItemTreeElement, isSCMInput, isSCMRepository, isSCMResource, isSCMResourceGroup, isSCMResourceNode, isSCMViewSeparator, isSCMViewService, toDiffEditorArguments };

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

@@ -0,0 +1,118 @@
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+import { Event } from 'vscode/vscode/vs/base/common/event';
+import { DisposableMap, DisposableStore } from 'vscode/vscode/vs/base/common/lifecycle';
+import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration.service';
+import { IStorageService } from 'vscode/vscode/vs/platform/storage/common/storage.service';
+import { getProviderKey } from './util.js';
+import { ISCMService } from 'vscode/vscode/vs/workbench/contrib/scm/common/scm.service';
+import { IEditorGroupsService } from 'vscode/vscode/vs/workbench/services/editor/common/editorGroupsService.service';
+
+let SCMWorkingSetController = class SCMWorkingSetController {
+    static { this.ID = 'workbench.contrib.scmWorkingSets'; }
+    constructor(configurationService, editorGroupsService, scmService, storageService) {
+        this.configurationService = configurationService;
+        this.editorGroupsService = editorGroupsService;
+        this.scmService = scmService;
+        this.storageService = storageService;
+        this._repositoryDisposables = ( new DisposableMap());
+        this._scmServiceDisposables = ( new DisposableStore());
+        this._disposables = ( new DisposableStore());
+        const onDidChangeConfiguration = Event.filter(configurationService.onDidChangeConfiguration, e => e.affectsConfiguration('scm.workingSets.enabled'), this._disposables);
+        this._disposables.add(Event.runAndSubscribe(onDidChangeConfiguration, () => this._onDidChangeConfiguration()));
+    }
+    _onDidChangeConfiguration() {
+        if (!this.configurationService.getValue('scm.workingSets.enabled')) {
+            this.storageService.remove('scm.workingSets', 1 );
+            this._scmServiceDisposables.clear();
+            this._repositoryDisposables.clearAndDisposeAll();
+            return;
+        }
+        this._workingSets = this._loadWorkingSets();
+        this.scmService.onDidAddRepository(this._onDidAddRepository, this, this._scmServiceDisposables);
+        this.scmService.onDidRemoveRepository(this._onDidRemoveRepository, this, this._scmServiceDisposables);
+        for (const repository of this.scmService.repositories) {
+            this._onDidAddRepository(repository);
+        }
+    }
+    _onDidAddRepository(repository) {
+        const disposables = ( new DisposableStore());
+        disposables.add(Event.runAndSubscribe(repository.provider.onDidChangeHistoryProvider, () => {
+            if (!repository.provider.historyProvider) {
+                return;
+            }
+            disposables.add(Event.runAndSubscribe(repository.provider.historyProvider.onDidChangeCurrentHistoryItemGroup, async () => {
+                if (!repository.provider.historyProvider?.currentHistoryItemGroup?.id) {
+                    return;
+                }
+                const providerKey = getProviderKey(repository.provider);
+                const currentHistoryItemGroupId = repository.provider.historyProvider.currentHistoryItemGroup.id;
+                const repositoryWorkingSets = this._workingSets.get(providerKey);
+                if (!repositoryWorkingSets) {
+                    this._workingSets.set(providerKey, { currentHistoryItemGroupId, editorWorkingSets: ( new Map()) });
+                    return;
+                }
+                if (repositoryWorkingSets.currentHistoryItemGroupId === currentHistoryItemGroupId) {
+                    return;
+                }
+                this._saveWorkingSet(providerKey, currentHistoryItemGroupId, repositoryWorkingSets);
+                await this._restoreWorkingSet(providerKey, currentHistoryItemGroupId);
+            }));
+        }));
+        this._repositoryDisposables.set(repository, disposables);
+    }
+    _onDidRemoveRepository(repository) {
+        this._workingSets.delete(getProviderKey(repository.provider));
+        this._repositoryDisposables.deleteAndDispose(repository);
+    }
+    _loadWorkingSets() {
+        const workingSets = ( new Map());
+        const workingSetsRaw = this.storageService.get('scm.workingSets', 1 );
+        if (!workingSetsRaw) {
+            return workingSets;
+        }
+        for (const serializedWorkingSet of JSON.parse(workingSetsRaw)) {
+            workingSets.set(serializedWorkingSet.providerKey, {
+                currentHistoryItemGroupId: serializedWorkingSet.currentHistoryItemGroupId,
+                editorWorkingSets: ( new Map(serializedWorkingSet.editorWorkingSets))
+            });
+        }
+        return workingSets;
+    }
+    _saveWorkingSet(providerKey, currentHistoryItemGroupId, repositoryWorkingSets) {
+        const previousHistoryItemGroupId = repositoryWorkingSets.currentHistoryItemGroupId;
+        const editorWorkingSets = repositoryWorkingSets.editorWorkingSets;
+        const editorWorkingSet = this.editorGroupsService.saveWorkingSet(previousHistoryItemGroupId);
+        this._workingSets.set(providerKey, { currentHistoryItemGroupId, editorWorkingSets: editorWorkingSets.set(previousHistoryItemGroupId, editorWorkingSet) });
+        const workingSets = [];
+        for (const [providerKey, { currentHistoryItemGroupId, editorWorkingSets }] of this._workingSets) {
+            workingSets.push({ providerKey, currentHistoryItemGroupId, editorWorkingSets: [...editorWorkingSets] });
+        }
+        this.storageService.store('scm.workingSets', JSON.stringify(workingSets), 1 , 1 );
+    }
+    async _restoreWorkingSet(providerKey, currentHistoryItemGroupId) {
+        const workingSets = this._workingSets.get(providerKey);
+        if (!workingSets) {
+            return;
+        }
+        let editorWorkingSetId = workingSets.editorWorkingSets.get(currentHistoryItemGroupId);
+        if (!editorWorkingSetId && this.configurationService.getValue('scm.workingSets.default') === 'empty') {
+            editorWorkingSetId = 'empty';
+        }
+        if (editorWorkingSetId) {
+            await this.editorGroupsService.applyWorkingSet(editorWorkingSetId);
+        }
+    }
+    dispose() {
+        this._repositoryDisposables.dispose();
+        this._scmServiceDisposables.dispose();
+        this._disposables.dispose();
+    }
+};
+SCMWorkingSetController = ( __decorate([
+    ( __param(0, IConfigurationService)),
+    ( __param(1, IEditorGroupsService)),
+    ( __param(2, ISCMService)),
+    ( __param(3, IStorageService))
+], SCMWorkingSetController));
+
+export { SCMWorkingSetController };

package/vscode/src/vs/workbench/contrib/scm/common/scmService.js

@@ -285,7 +285,7 @@ let SCMService = class SCMService {
     registerSCMProvider(provider) {
         this.logService.trace('SCMService#registerSCMProvider');
         if (( this._repositories.has(provider.id))) {
-            throw new Error(`SCM Provider ${provider.id} already exists.`);
+            throw ( new Error(`SCM Provider ${provider.id} already exists.`));
         }
         const disposable = toDisposable(() => {
             this._repositories.delete(provider.id);