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

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

@@ -0,0 +1,49 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import './media/scm.css.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
+import { VIEWLET_ID } from 'vscode/vscode/vs/workbench/contrib/scm/common/scm';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { IContextMenuService } from 'monaco-editor/esm/vs/platform/contextview/browser/contextView.js';
+import { IThemeService } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
+import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { IWorkbenchLayoutService } from 'vscode/vscode/vs/workbench/services/layout/browser/layoutService';
+import { IExtensionService } from 'vscode/vscode/vs/workbench/services/extensions/common/extensions';
+import { IWorkspaceContextService } from 'monaco-editor/esm/vs/platform/workspace/common/workspace.js';
+import { IViewDescriptorService } from 'vscode/vscode/vs/workbench/common/views';
+import { ViewPaneContainer } from 'vscode/vscode/vs/workbench/browser/parts/views/viewPaneContainer';
+
+let SCMViewPaneContainer = class SCMViewPaneContainer extends ViewPaneContainer {
+    constructor(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);
+    }
+    create(parent) {
+        super.create(parent);
+        parent.classList.add('scm-viewlet');
+    }
+    getOptimalWidth() {
+        return 400;
+    }
+    getTitle() {
+        return ( localizeWithPath(
+            'vs/workbench/contrib/scm/browser/scmViewPaneContainer',
+            'source control',
+            "Source Control"
+        ));
+    }
+};
+SCMViewPaneContainer = ( __decorate([
+    ( __param(0, IWorkbenchLayoutService)),
+    ( __param(1, ITelemetryService)),
+    ( __param(2, IInstantiationService)),
+    ( __param(3, IContextMenuService)),
+    ( __param(4, IThemeService)),
+    ( __param(5, IStorageService)),
+    ( __param(6, IConfigurationService)),
+    ( __param(7, IExtensionService)),
+    ( __param(8, IWorkspaceContextService)),
+    ( __param(9, IViewDescriptorService))
+], SCMViewPaneContainer));
+
+export { SCMViewPaneContainer };

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

@@ -0,0 +1,305 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { Emitter, Event } from 'monaco-editor/esm/vs/base/common/event.js';
+import { ISCMService } from 'vscode/vscode/vs/workbench/contrib/scm/common/scm';
+import { Iterable } from 'monaco-editor/esm/vs/base/common/iterator.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { SCMMenus } from './menus.js';
+import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
+import { debounce } from 'monaco-editor/esm/vs/base/common/decorators.js';
+import { IWorkspaceContextService } from 'monaco-editor/esm/vs/platform/workspace/common/workspace.js';
+import { comparePaths, compareFileNames } from 'monaco-editor/esm/vs/base/common/comparers.js';
+import { basename } from 'monaco-editor/esm/vs/base/common/resources.js';
+import { binarySearch } from 'monaco-editor/esm/vs/base/common/arrays.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { RawContextKey, IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+
+function getProviderStorageKey(provider) {
+    return `${provider.contextValue}:${provider.label}${provider.rootUri ? `:${( provider.rootUri.toString())}` : ''}`;
+}
+function getRepositoryName(workspaceContextService, repository) {
+    if (!repository.provider.rootUri) {
+        return repository.provider.label;
+    }
+    const folder = workspaceContextService.getWorkspaceFolder(repository.provider.rootUri);
+    return folder?.uri.toString() === ( repository.provider.rootUri.toString()) ? folder.name : basename(repository.provider.rootUri);
+}
+const RepositoryContextKeys = {
+    RepositorySortKey: ( new RawContextKey(
+        'scmRepositorySortKey',
+        "discoveryTime"
+    )),
+};
+let SCMViewService = class SCMViewService {
+    get repositories() {
+        return ( this._repositories.map(r => r.repository));
+    }
+    get visibleRepositories() {
+        if (this._repositoriesSortKey === "discoveryTime" ) {
+            return ( this._repositories.filter(r => r.selectionIndex !== -1)
+                .sort((r1, r2) => r1.selectionIndex - r2.selectionIndex)
+                .map(r => r.repository));
+        }
+        return ( this._repositories
+            .filter(r => r.selectionIndex !== -1)
+            .map(r => r.repository));
+    }
+    set visibleRepositories(visibleRepositories) {
+        const set = ( new Set(visibleRepositories));
+        const added = ( new Set());
+        const removed = ( new Set());
+        for (const repositoryView of this._repositories) {
+            if (!( set.has(repositoryView.repository)) && repositoryView.selectionIndex !== -1) {
+                repositoryView.selectionIndex = -1;
+                removed.add(repositoryView.repository);
+            }
+            if (( set.has(repositoryView.repository))) {
+                if (repositoryView.selectionIndex === -1) {
+                    added.add(repositoryView.repository);
+                }
+                repositoryView.selectionIndex = visibleRepositories.indexOf(repositoryView.repository);
+            }
+        }
+        if (added.size === 0 && removed.size === 0) {
+            return;
+        }
+        this._onDidSetVisibleRepositories.fire({ added, removed });
+        if (this._repositories.find(r => r.focused && r.selectionIndex === -1)) {
+            this.focus(this._repositories.find(r => r.selectionIndex !== -1)?.repository);
+        }
+    }
+    get focusedRepository() {
+        return this._repositories.find(r => r.focused)?.repository;
+    }
+    constructor(scmService, contextKeyService, instantiationService, configurationService, storageService, workspaceContextService) {
+        this.configurationService = configurationService;
+        this.storageService = storageService;
+        this.workspaceContextService = workspaceContextService;
+        this.didFinishLoading = false;
+        this.didSelectRepository = false;
+        this.disposables = ( new DisposableStore());
+        this._repositories = [];
+        this._onDidChangeRepositories = ( new Emitter());
+        this.onDidChangeRepositories = this._onDidChangeRepositories.event;
+        this._onDidSetVisibleRepositories = ( new Emitter());
+        this.onDidChangeVisibleRepositories = Event.any(this._onDidSetVisibleRepositories.event, Event.debounce(this._onDidChangeRepositories.event, (last, e) => {
+            if (!last) {
+                return e;
+            }
+            const added = ( new Set(last.added));
+            const removed = ( new Set(last.removed));
+            for (const repository of e.added) {
+                if (( removed.has(repository))) {
+                    removed.delete(repository);
+                }
+                else {
+                    added.add(repository);
+                }
+            }
+            for (const repository of e.removed) {
+                if (( added.has(repository))) {
+                    added.delete(repository);
+                }
+                else {
+                    removed.add(repository);
+                }
+            }
+            return { added, removed };
+        }, 0, undefined, undefined, undefined, this.disposables));
+        this._onDidFocusRepository = ( new Emitter());
+        this.onDidFocusRepository = this._onDidFocusRepository.event;
+        this.menus = instantiationService.createInstance(SCMMenus);
+        try {
+            this.previousState = JSON.parse(storageService.get('scm:view:visibleRepositories', 1 , ''));
+        }
+        catch {
+        }
+        this._repositoriesSortKey = this.previousState?.sortKey ?? this.getViewSortOrder();
+        this._sortKeyContextKey = RepositoryContextKeys.RepositorySortKey.bindTo(contextKeyService);
+        this._sortKeyContextKey.set(this._repositoriesSortKey);
+        scmService.onDidAddRepository(this.onDidAddRepository, this, this.disposables);
+        scmService.onDidRemoveRepository(this.onDidRemoveRepository, this, this.disposables);
+        for (const repository of scmService.repositories) {
+            this.onDidAddRepository(repository);
+        }
+        storageService.onWillSaveState(this.onWillSaveState, this, this.disposables);
+    }
+    onDidAddRepository(repository) {
+        if (!this.didFinishLoading) {
+            this.eventuallyFinishLoading();
+        }
+        const repositoryView = {
+            repository, discoveryTime: Date.now(), focused: false, selectionIndex: -1
+        };
+        let removed = Iterable.empty();
+        if (this.previousState) {
+            const index = this.previousState.all.indexOf(getProviderStorageKey(repository.provider));
+            if (index === -1) {
+                const added = [];
+                this.insertRepositoryView(this._repositories, repositoryView);
+                this._repositories.forEach((repositoryView, index) => {
+                    if (repositoryView.selectionIndex === -1) {
+                        added.push(repositoryView.repository);
+                    }
+                    repositoryView.selectionIndex = index;
+                });
+                this._onDidChangeRepositories.fire({ added, removed: Iterable.empty() });
+                this.didSelectRepository = false;
+                return;
+            }
+            if (this.previousState.visible.indexOf(index) === -1) {
+                if (this.didSelectRepository) {
+                    this.insertRepositoryView(this._repositories, repositoryView);
+                    this._onDidChangeRepositories.fire({ added: Iterable.empty(), removed: Iterable.empty() });
+                    return;
+                }
+            }
+            else {
+                if (!this.didSelectRepository) {
+                    removed = [...this.visibleRepositories];
+                    this._repositories.forEach(r => {
+                        r.focused = false;
+                        r.selectionIndex = -1;
+                    });
+                    this.didSelectRepository = true;
+                }
+            }
+        }
+        const maxSelectionIndex = this.getMaxSelectionIndex();
+        this.insertRepositoryView(this._repositories, { ...repositoryView, selectionIndex: maxSelectionIndex + 1 });
+        this._onDidChangeRepositories.fire({ added: [repositoryView.repository], removed });
+        if (!this._repositories.find(r => r.focused)) {
+            this.focus(repository);
+        }
+    }
+    onDidRemoveRepository(repository) {
+        if (!this.didFinishLoading) {
+            this.eventuallyFinishLoading();
+        }
+        const repositoriesIndex = this._repositories.findIndex(r => r.repository === repository);
+        if (repositoriesIndex === -1) {
+            return;
+        }
+        let added = Iterable.empty();
+        const repositoryView = this._repositories.splice(repositoriesIndex, 1);
+        if (this._repositories.length > 0 && this.visibleRepositories.length === 0) {
+            this._repositories[0].selectionIndex = 0;
+            added = [this._repositories[0].repository];
+        }
+        this._onDidChangeRepositories.fire({ added, removed: ( repositoryView.map(r => r.repository)) });
+        if (repositoryView.length === 1 && repositoryView[0].focused && this.visibleRepositories.length > 0) {
+            this.focus(this.visibleRepositories[0]);
+        }
+    }
+    isVisible(repository) {
+        return this._repositories.find(r => r.repository === repository)?.selectionIndex !== -1;
+    }
+    toggleVisibility(repository, visible) {
+        if (typeof visible === 'undefined') {
+            visible = !this.isVisible(repository);
+        }
+        else if (this.isVisible(repository) === visible) {
+            return;
+        }
+        if (visible) {
+            this.visibleRepositories = [...this.visibleRepositories, repository];
+        }
+        else {
+            const index = this.visibleRepositories.indexOf(repository);
+            if (index > -1) {
+                this.visibleRepositories = [
+                    ...this.visibleRepositories.slice(0, index),
+                    ...this.visibleRepositories.slice(index + 1)
+                ];
+            }
+        }
+    }
+    toggleSortKey(sortKey) {
+        this._repositoriesSortKey = sortKey;
+        this._sortKeyContextKey.set(this._repositoriesSortKey);
+        this._repositories.sort(this.compareRepositories.bind(this));
+        this._onDidChangeRepositories.fire({ added: Iterable.empty(), removed: Iterable.empty() });
+    }
+    focus(repository) {
+        if (repository && !this.isVisible(repository)) {
+            return;
+        }
+        this._repositories.forEach(r => r.focused = r.repository === repository);
+        if (this._repositories.find(r => r.focused)) {
+            this._onDidFocusRepository.fire(repository);
+        }
+    }
+    compareRepositories(op1, op2) {
+        if (this._repositoriesSortKey === "discoveryTime" ) {
+            return op1.discoveryTime - op2.discoveryTime;
+        }
+        if (this._repositoriesSortKey === 'path' && op1.repository.provider.rootUri && op2.repository.provider.rootUri) {
+            return comparePaths(op1.repository.provider.rootUri.fsPath, op2.repository.provider.rootUri.fsPath);
+        }
+        const name1 = getRepositoryName(this.workspaceContextService, op1.repository);
+        const name2 = getRepositoryName(this.workspaceContextService, op2.repository);
+        const nameComparison = compareFileNames(name1, name2);
+        if (nameComparison === 0 && op1.repository.provider.rootUri && op2.repository.provider.rootUri) {
+            return comparePaths(op1.repository.provider.rootUri.fsPath, op2.repository.provider.rootUri.fsPath);
+        }
+        return nameComparison;
+    }
+    getMaxSelectionIndex() {
+        return this._repositories.length === 0 ? -1 :
+            Math.max(...( this._repositories.map(r => r.selectionIndex)));
+    }
+    getViewSortOrder() {
+        const sortOder = this.configurationService.getValue('scm.repositories.sortOrder');
+        switch (sortOder) {
+            case 'discovery time':
+                return "discoveryTime" ;
+            case 'name':
+                return "name" ;
+            case 'path':
+                return "path" ;
+            default:
+                return "discoveryTime" ;
+        }
+    }
+    insertRepositoryView(repositories, repositoryView) {
+        const index = binarySearch(repositories, repositoryView, this.compareRepositories.bind(this));
+        repositories.splice(index < 0 ? ~index : index, 0, repositoryView);
+    }
+    onWillSaveState() {
+        if (!this.didFinishLoading) {
+            return;
+        }
+        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 );
+    }
+    eventuallyFinishLoading() {
+        this.finishLoading();
+    }
+    finishLoading() {
+        if (this.didFinishLoading) {
+            return;
+        }
+        this.didFinishLoading = true;
+        this.previousState = undefined;
+    }
+    dispose() {
+        this.disposables.dispose();
+        this._onDidChangeRepositories.dispose();
+        this._onDidSetVisibleRepositories.dispose();
+    }
+};
+SCMViewService.__decorator = ( __decorate([
+    debounce(5000)
+], SCMViewService.prototype, "eventuallyFinishLoading", null));
+SCMViewService = ( __decorate([
+    ( __param(0, ISCMService)),
+    ( __param(1, IContextKeyService)),
+    ( __param(2, IInstantiationService)),
+    ( __param(3, IConfigurationService)),
+    ( __param(4, IStorageService)),
+    ( __param(5, IWorkspaceContextService))
+], SCMViewService));
+
+export { RepositoryContextKeys, SCMViewService };

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

@@ -0,0 +1,86 @@
+import { Action } from 'monaco-editor/esm/vs/base/common/actions.js';
+import { createAndFillInActionBarActions, createAndFillInContextMenuActions, createActionViewItem } from 'monaco-editor/esm/vs/platform/actions/browser/menuEntryActionViewItem.js';
+import { equals } from 'monaco-editor/esm/vs/base/common/arrays.js';
+import { ActionViewItem } from 'monaco-editor/esm/vs/base/browser/ui/actionbar/actionViewItems.js';
+import { renderLabelWithIcons } from 'monaco-editor/esm/vs/base/browser/ui/iconLabel/iconLabels.js';
+import { reset } from 'monaco-editor/esm/vs/base/browser/dom.js';
+
+function isSCMRepositoryArray(element) {
+    return Array.isArray(element) && element.every(r => isSCMRepository(r));
+}
+function isSCMRepository(element) {
+    return !!element.provider && !!element.input;
+}
+function isSCMInput(element) {
+    return !!element.validateInput && typeof element.value === 'string';
+}
+function isSCMActionButton(element) {
+    return element.type === 'actionButton';
+}
+function isSCMResourceGroup(element) {
+    return !!element.provider && !!element.elements;
+}
+function isSCMResource(element) {
+    return !!element.sourceUri && isSCMResourceGroup(element.resourceGroup);
+}
+const compareActions = (a, b) => a.id === b.id && a.enabled === b.enabled;
+function connectPrimaryMenu(menu, callback, primaryGroup) {
+    let cachedPrimary = [];
+    let cachedSecondary = [];
+    const updateActions = () => {
+        const primary = [];
+        const secondary = [];
+        createAndFillInActionBarActions(menu, { shouldForwardArgs: true }, { primary, secondary }, primaryGroup);
+        if (equals(cachedPrimary, primary, compareActions) && equals(cachedSecondary, secondary, compareActions)) {
+            return;
+        }
+        cachedPrimary = primary;
+        cachedSecondary = secondary;
+        callback(primary, secondary);
+    };
+    updateActions();
+    return menu.onDidChange(updateActions);
+}
+function connectPrimaryMenuToInlineActionBar(menu, actionBar) {
+    return connectPrimaryMenu(menu, (primary) => {
+        actionBar.clear();
+        actionBar.push(primary, { icon: true, label: false });
+    }, 'inline');
+}
+function collectContextMenuActions(menu) {
+    const primary = [];
+    const actions = [];
+    createAndFillInContextMenuActions(menu, { shouldForwardArgs: true }, { primary, secondary: actions }, 'inline');
+    return actions;
+}
+class StatusBarAction extends Action {
+    constructor(command, commandService) {
+        super(`statusbaraction{${command.id}}`, command.title, '', true);
+        this.command = command;
+        this.commandService = commandService;
+        this.tooltip = command.tooltip || '';
+    }
+    run() {
+        return this.commandService.executeCommand(this.command.id, ...(this.command.arguments || []));
+    }
+}
+class StatusBarActionViewItem extends ActionViewItem {
+    constructor(action) {
+        super(null, action, {});
+    }
+    updateLabel() {
+        if (this.options.label && this.label) {
+            reset(this.label, ...renderLabelWithIcons(this.action.label));
+        }
+    }
+}
+function getActionViewItemProvider(instaService) {
+    return action => {
+        if (action instanceof StatusBarAction) {
+            return ( new StatusBarActionViewItem(action));
+        }
+        return createActionViewItem(instaService, action);
+    };
+}
+
+export { StatusBarAction, collectContextMenuActions, connectPrimaryMenu, connectPrimaryMenuToInlineActionBar, getActionViewItemProvider, isSCMActionButton, isSCMInput, isSCMRepository, isSCMRepositoryArray, isSCMResource, isSCMResourceGroup };

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

@@ -0,0 +1,76 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { isEqualOrParent } from 'monaco-editor/esm/vs/base/common/resources.js';
+import { score } from 'monaco-editor/esm/vs/editor/common/languageSelector.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { IUriIdentityService } from 'monaco-editor/esm/vs/platform/uriIdentity/common/uriIdentity.js';
+
+function createProviderComparer(uri) {
+    return (a, b) => {
+        if (a.rootUri && !b.rootUri) {
+            return -1;
+        }
+        else if (!a.rootUri && b.rootUri) {
+            return 1;
+        }
+        else if (!a.rootUri && !b.rootUri) {
+            return 0;
+        }
+        const aIsParent = isEqualOrParent(uri, a.rootUri);
+        const bIsParent = isEqualOrParent(uri, b.rootUri);
+        if (aIsParent && bIsParent) {
+            return a.rootUri.fsPath.length - b.rootUri.fsPath.length;
+        }
+        else if (aIsParent) {
+            return -1;
+        }
+        else if (bIsParent) {
+            return 1;
+        }
+        else {
+            return 0;
+        }
+    };
+}
+let QuickDiffService = class QuickDiffService extends Disposable {
+    constructor(uriIdentityService) {
+        super();
+        this.uriIdentityService = uriIdentityService;
+        this.quickDiffProviders = ( new Set());
+        this._onDidChangeQuickDiffProviders = this._register(( new Emitter()));
+        this.onDidChangeQuickDiffProviders = this._onDidChangeQuickDiffProviders.event;
+    }
+    addQuickDiffProvider(quickDiff) {
+        this.quickDiffProviders.add(quickDiff);
+        this._onDidChangeQuickDiffProviders.fire();
+        return {
+            dispose: () => {
+                this.quickDiffProviders.delete(quickDiff);
+                this._onDidChangeQuickDiffProviders.fire();
+            }
+        };
+    }
+    isQuickDiff(diff) {
+        return !!diff.originalResource && (typeof diff.label === 'string') && (typeof diff.isSCM === 'boolean');
+    }
+    async getQuickDiffs(uri, language = '', isSynchronized = false) {
+        const providers = Array.from(this.quickDiffProviders)
+            .filter(provider => !provider.rootUri || this.uriIdentityService.extUri.isEqualOrParent(uri, provider.rootUri))
+            .sort(createProviderComparer(uri));
+        const diffs = await Promise.all(( providers.map(async (provider) => {
+            const scoreValue = provider.selector ? score(provider.selector, uri, language, isSynchronized, undefined, undefined) : 10;
+            const diff = {
+                originalResource: scoreValue > 0 ? (await provider.getOriginalResource(uri)) ?? undefined : undefined,
+                label: provider.label,
+                isSCM: provider.isSCM
+            };
+            return diff;
+        })));
+        return diffs.filter(this.isQuickDiff);
+    }
+};
+QuickDiffService = ( __decorate([
+    ( __param(0, IUriIdentityService))
+], QuickDiffService));
+
+export { QuickDiffService };