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

package/vscode/src/vs/workbench/api/browser/mainThreadSCM.js

@@ -0,0 +1,493 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { URI } from 'vscode/vscode/vs/base/common/uri';
+import { Emitter, Event } from 'vscode/vscode/vs/base/common/event';
+import { DisposableStore, dispose, combinedDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import { ISCMService, ISCMViewService } from 'vscode/vscode/vs/workbench/contrib/scm/common/scm';
+import { MainContext, ExtHostContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
+import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
+import { CancellationToken } from 'vscode/vscode/vs/base/common/cancellation';
+import { ThemeIcon } from 'vscode/vscode/vs/base/common/themables';
+import { IQuickDiffService } from 'vscode/vscode/vs/workbench/contrib/scm/common/quickDiff';
+import { ResourceTree } from 'vscode/vscode/vs/base/common/resourceTree';
+import { IUriIdentityService } from 'vscode/vscode/vs/platform/uriIdentity/common/uriIdentity';
+import { IWorkspaceContextService } from 'vscode/vscode/vs/platform/workspace/common/workspace';
+import { basename } from 'vscode/vscode/vs/base/common/resources';
+
+function getIconFromIconDto(iconDto) {
+    if (iconDto === undefined) {
+        return undefined;
+    }
+    else if (URI.isUri(iconDto)) {
+        return URI.revive(iconDto);
+    }
+    else if (ThemeIcon.isThemeIcon(iconDto)) {
+        return iconDto;
+    }
+    else {
+        const icon = iconDto;
+        return { light: URI.revive(icon.light), dark: URI.revive(icon.dark) };
+    }
+}
+class MainThreadSCMResourceGroup {
+    get resourceTree() {
+        if (!this._resourceTree) {
+            const rootUri = this.provider.rootUri ?? URI.file('/');
+            this._resourceTree = ( new ResourceTree(this, rootUri, this._uriIdentService.extUri));
+            for (const resource of this.resources) {
+                this._resourceTree.add(resource.sourceUri, resource);
+            }
+        }
+        return this._resourceTree;
+    }
+    get hideWhenEmpty() { return !!this.features.hideWhenEmpty; }
+    constructor(sourceControlHandle, handle, provider, features, label, id, multiDiffEditorEnableViewChanges, _uriIdentService) {
+        this.sourceControlHandle = sourceControlHandle;
+        this.handle = handle;
+        this.provider = provider;
+        this.features = features;
+        this.label = label;
+        this.id = id;
+        this.multiDiffEditorEnableViewChanges = multiDiffEditorEnableViewChanges;
+        this._uriIdentService = _uriIdentService;
+        this.resources = [];
+        this._onDidChange = ( new Emitter());
+        this.onDidChange = this._onDidChange.event;
+        this._onDidChangeResources = ( new Emitter());
+        this.onDidChangeResources = this._onDidChangeResources.event;
+    }
+    toJSON() {
+        return {
+            $mid: 4 ,
+            sourceControlHandle: this.sourceControlHandle,
+            groupHandle: this.handle
+        };
+    }
+    splice(start, deleteCount, toInsert) {
+        this.resources.splice(start, deleteCount, ...toInsert);
+        this._resourceTree = undefined;
+        this._onDidChangeResources.fire();
+    }
+    $updateGroup(features) {
+        this.features = { ...this.features, ...features };
+        this._onDidChange.fire();
+    }
+    $updateGroupLabel(label) {
+        this.label = label;
+        this._onDidChange.fire();
+    }
+}
+class MainThreadSCMResource {
+    constructor(proxy, sourceControlHandle, groupHandle, handle, sourceUri, resourceGroup, decorations, contextValue, command, multiDiffEditorOriginalUri, multiDiffEditorModifiedUri) {
+        this.proxy = proxy;
+        this.sourceControlHandle = sourceControlHandle;
+        this.groupHandle = groupHandle;
+        this.handle = handle;
+        this.sourceUri = sourceUri;
+        this.resourceGroup = resourceGroup;
+        this.decorations = decorations;
+        this.contextValue = contextValue;
+        this.command = command;
+        this.multiDiffEditorOriginalUri = multiDiffEditorOriginalUri;
+        this.multiDiffEditorModifiedUri = multiDiffEditorModifiedUri;
+    }
+    open(preserveFocus) {
+        return this.proxy.$executeResourceCommand(this.sourceControlHandle, this.groupHandle, this.handle, preserveFocus);
+    }
+    toJSON() {
+        return {
+            $mid: 3 ,
+            sourceControlHandle: this.sourceControlHandle,
+            groupHandle: this.groupHandle,
+            handle: this.handle
+        };
+    }
+}
+class MainThreadSCMHistoryProvider {
+    get currentHistoryItemGroup() { return this._currentHistoryItemGroup; }
+    set currentHistoryItemGroup(historyItemGroup) {
+        this._currentHistoryItemGroup = historyItemGroup;
+        this._onDidChangeCurrentHistoryItemGroup.fire();
+    }
+    constructor(proxy, handle) {
+        this.proxy = proxy;
+        this.handle = handle;
+        this._onDidChangeCurrentHistoryItemGroup = ( new Emitter());
+        this.onDidChangeCurrentHistoryItemGroup = this._onDidChangeCurrentHistoryItemGroup.event;
+    }
+    async resolveHistoryItemGroupCommonAncestor(historyItemGroupId1, historyItemGroupId2) {
+        return this.proxy.$resolveHistoryItemGroupCommonAncestor(this.handle, historyItemGroupId1, historyItemGroupId2, CancellationToken.None);
+    }
+    async provideHistoryItems(historyItemGroupId, options) {
+        const historyItems = await this.proxy.$provideHistoryItems(this.handle, historyItemGroupId, options, CancellationToken.None);
+        return historyItems?.map(historyItem => ({ ...historyItem, icon: getIconFromIconDto(historyItem.icon) }));
+    }
+    async provideHistoryItemSummary(historyItemId, historyItemParentId) {
+        const historyItem = await this.proxy.$provideHistoryItemSummary(this.handle, historyItemId, historyItemParentId, CancellationToken.None);
+        return historyItem ? { ...historyItem, icon: getIconFromIconDto(historyItem.icon) } : undefined;
+    }
+    async provideHistoryItemChanges(historyItemId, historyItemParentId) {
+        const changes = await this.proxy.$provideHistoryItemChanges(this.handle, historyItemId, historyItemParentId, CancellationToken.None);
+        return changes?.map(change => ({
+            uri: URI.revive(change.uri),
+            originalUri: change.originalUri && URI.revive(change.originalUri),
+            modifiedUri: change.modifiedUri && URI.revive(change.modifiedUri),
+            renameUri: change.renameUri && URI.revive(change.renameUri)
+        }));
+    }
+}
+class MainThreadSCMProvider {
+    static { this.ID_HANDLE = 0; }
+    get id() { return this._id; }
+    get handle() { return this._handle; }
+    get label() { return this._label; }
+    get rootUri() { return this._rootUri; }
+    get inputBoxDocumentUri() { return this._inputBoxDocumentUri; }
+    get contextValue() { return this._providerId; }
+    get commitTemplate() { return this.features.commitTemplate || ''; }
+    get historyProvider() { return this._historyProvider; }
+    get acceptInputCommand() { return this.features.acceptInputCommand; }
+    get actionButton() { return this.features.actionButton ?? undefined; }
+    get statusBarCommands() { return this.features.statusBarCommands; }
+    get count() { return this.features.count; }
+    get name() { return this._name ?? this._label; }
+    get onDidChangeStatusBarCommands() { return this._onDidChangeStatusBarCommands.event; }
+    constructor(proxy, _handle, _providerId, _label, _rootUri, _inputBoxDocumentUri, _quickDiffService, _uriIdentService, _workspaceContextService) {
+        this.proxy = proxy;
+        this._handle = _handle;
+        this._providerId = _providerId;
+        this._label = _label;
+        this._rootUri = _rootUri;
+        this._inputBoxDocumentUri = _inputBoxDocumentUri;
+        this._quickDiffService = _quickDiffService;
+        this._uriIdentService = _uriIdentService;
+        this._workspaceContextService = _workspaceContextService;
+        this._id = `scm${MainThreadSCMProvider.ID_HANDLE++}`;
+        this.groups = [];
+        this._onDidChangeResourceGroups = ( new Emitter());
+        this.onDidChangeResourceGroups = this._onDidChangeResourceGroups.event;
+        this._onDidChangeResources = ( new Emitter());
+        this.onDidChangeResources = this._onDidChangeResources.event;
+        this._groupsByHandle = Object.create(null);
+        this.features = {};
+        this._onDidChangeCommitTemplate = ( new Emitter());
+        this.onDidChangeCommitTemplate = this._onDidChangeCommitTemplate.event;
+        this._onDidChangeStatusBarCommands = ( new Emitter());
+        this._onDidChangeHistoryProvider = ( new Emitter());
+        this.onDidChangeHistoryProvider = this._onDidChangeHistoryProvider.event;
+        this._onDidChange = ( new Emitter());
+        this.onDidChange = this._onDidChange.event;
+        this.isSCM = true;
+        if (_rootUri) {
+            const folder = this._workspaceContextService.getWorkspaceFolder(_rootUri);
+            if (folder?.uri.toString() === ( _rootUri.toString())) {
+                this._name = folder.name;
+            }
+            else if (_rootUri.path !== '/') {
+                this._name = basename(_rootUri);
+            }
+        }
+    }
+    $updateSourceControl(features) {
+        this.features = { ...this.features, ...features };
+        this._onDidChange.fire();
+        if (typeof features.commitTemplate !== 'undefined') {
+            this._onDidChangeCommitTemplate.fire(this.commitTemplate);
+        }
+        if (typeof features.statusBarCommands !== 'undefined') {
+            this._onDidChangeStatusBarCommands.fire(this.statusBarCommands);
+        }
+        if (features.hasQuickDiffProvider && !this._quickDiff) {
+            this._quickDiff = this._quickDiffService.addQuickDiffProvider({
+                label: features.quickDiffLabel ?? this.label,
+                rootUri: this.rootUri,
+                isSCM: this.isSCM,
+                getOriginalResource: (uri) => this.getOriginalResource(uri)
+            });
+        }
+        else if (features.hasQuickDiffProvider === false && this._quickDiff) {
+            this._quickDiff.dispose();
+            this._quickDiff = undefined;
+        }
+        if (features.hasHistoryProvider && !this._historyProvider) {
+            this._historyProvider = ( new MainThreadSCMHistoryProvider(this.proxy, this.handle));
+            this._onDidChangeHistoryProvider.fire();
+        }
+        else if (features.hasHistoryProvider === false && this._historyProvider) {
+            this._historyProvider = undefined;
+            this._onDidChangeHistoryProvider.fire();
+        }
+    }
+    $registerGroups(_groups) {
+        const groups = ( _groups.map(([handle, id, label, features, multiDiffEditorEnableViewChanges]) => {
+            const group = ( new MainThreadSCMResourceGroup(
+                this.handle,
+                handle,
+                this,
+                features,
+                label,
+                id,
+                multiDiffEditorEnableViewChanges,
+                this._uriIdentService
+            ));
+            this._groupsByHandle[handle] = group;
+            return group;
+        }));
+        this.groups.splice(this.groups.length, 0, ...groups);
+        this._onDidChangeResourceGroups.fire();
+    }
+    $updateGroup(handle, features) {
+        const group = this._groupsByHandle[handle];
+        if (!group) {
+            return;
+        }
+        group.$updateGroup(features);
+    }
+    $updateGroupLabel(handle, label) {
+        const group = this._groupsByHandle[handle];
+        if (!group) {
+            return;
+        }
+        group.$updateGroupLabel(label);
+    }
+    $spliceGroupResourceStates(splices) {
+        for (const [groupHandle, groupSlices] of splices) {
+            const group = this._groupsByHandle[groupHandle];
+            if (!group) {
+                console.warn(`SCM group ${groupHandle} not found in provider ${this.label}`);
+                continue;
+            }
+            groupSlices.reverse();
+            for (const [start, deleteCount, rawResources] of groupSlices) {
+                const resources = ( rawResources.map(rawResource => {
+                    const [handle, sourceUri, icons, tooltip, strikeThrough, faded, contextValue, command, multiDiffEditorOriginalUri, multiDiffEditorModifiedUri] = rawResource;
+                    const [light, dark] = icons;
+                    const icon = ThemeIcon.isThemeIcon(light) ? light : URI.revive(light);
+                    const iconDark = (ThemeIcon.isThemeIcon(dark) ? dark : URI.revive(dark)) || icon;
+                    const decorations = {
+                        icon: icon,
+                        iconDark: iconDark,
+                        tooltip,
+                        strikeThrough,
+                        faded
+                    };
+                    return ( new MainThreadSCMResource(
+                        this.proxy,
+                        this.handle,
+                        groupHandle,
+                        handle,
+                        URI.revive(sourceUri),
+                        group,
+                        decorations,
+                        contextValue || undefined,
+                        command,
+                        URI.revive(multiDiffEditorOriginalUri),
+                        URI.revive(multiDiffEditorModifiedUri)
+                    ));
+                }));
+                group.splice(start, deleteCount, resources);
+            }
+        }
+        this._onDidChangeResources.fire();
+    }
+    $unregisterGroup(handle) {
+        const group = this._groupsByHandle[handle];
+        if (!group) {
+            return;
+        }
+        delete this._groupsByHandle[handle];
+        this.groups.splice(this.groups.indexOf(group), 1);
+        this._onDidChangeResourceGroups.fire();
+    }
+    async getOriginalResource(uri) {
+        if (!this.features.hasQuickDiffProvider) {
+            return null;
+        }
+        const result = await this.proxy.$provideOriginalResource(this.handle, uri, CancellationToken.None);
+        return result && URI.revive(result);
+    }
+    $onDidChangeHistoryProviderCurrentHistoryItemGroup(currentHistoryItemGroup) {
+        if (!this._historyProvider) {
+            return;
+        }
+        this._historyProvider.currentHistoryItemGroup = currentHistoryItemGroup ?? undefined;
+    }
+    toJSON() {
+        return {
+            $mid: 5 ,
+            handle: this.handle
+        };
+    }
+    dispose() {
+        this._quickDiff?.dispose();
+    }
+}
+let MainThreadSCM = class MainThreadSCM {
+    constructor(extHostContext, scmService, scmViewService, quickDiffService, _uriIdentService, workspaceContextService) {
+        this.scmService = scmService;
+        this.scmViewService = scmViewService;
+        this.quickDiffService = quickDiffService;
+        this._uriIdentService = _uriIdentService;
+        this.workspaceContextService = workspaceContextService;
+        this._repositories = ( new Map());
+        this._repositoryDisposables = ( new Map());
+        this._disposables = ( new DisposableStore());
+        this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostSCM));
+    }
+    dispose() {
+        dispose(( this._repositories.values()));
+        this._repositories.clear();
+        dispose(( this._repositoryDisposables.values()));
+        this._repositoryDisposables.clear();
+        this._disposables.dispose();
+    }
+    $registerSourceControl(handle, id, label, rootUri, inputBoxDocumentUri) {
+        const provider = ( new MainThreadSCMProvider(
+            this._proxy,
+            handle,
+            id,
+            label,
+            rootUri ? URI.revive(rootUri) : undefined,
+            URI.revive(inputBoxDocumentUri),
+            this.quickDiffService,
+            this._uriIdentService,
+            this.workspaceContextService
+        ));
+        const repository = this.scmService.registerSCMProvider(provider);
+        this._repositories.set(handle, repository);
+        const disposable = combinedDisposable(Event.filter(this.scmViewService.onDidFocusRepository, r => r === repository)(_ => this._proxy.$setSelectedSourceControl(handle)), repository.input.onDidChange(({ value }) => this._proxy.$onInputBoxValueChange(handle, value)));
+        if (this.scmViewService.focusedRepository === repository) {
+            setTimeout(() => this._proxy.$setSelectedSourceControl(handle), 0);
+        }
+        if (repository.input.value) {
+            setTimeout(() => this._proxy.$onInputBoxValueChange(handle, repository.input.value), 0);
+        }
+        this._repositoryDisposables.set(handle, disposable);
+    }
+    $updateSourceControl(handle, features) {
+        const repository = this._repositories.get(handle);
+        if (!repository) {
+            return;
+        }
+        const provider = repository.provider;
+        provider.$updateSourceControl(features);
+    }
+    $unregisterSourceControl(handle) {
+        const repository = this._repositories.get(handle);
+        if (!repository) {
+            return;
+        }
+        this._repositoryDisposables.get(handle).dispose();
+        this._repositoryDisposables.delete(handle);
+        repository.dispose();
+        this._repositories.delete(handle);
+    }
+    $registerGroups(sourceControlHandle, groups, splices) {
+        const repository = this._repositories.get(sourceControlHandle);
+        if (!repository) {
+            return;
+        }
+        const provider = repository.provider;
+        provider.$registerGroups(groups);
+        provider.$spliceGroupResourceStates(splices);
+    }
+    $updateGroup(sourceControlHandle, groupHandle, features) {
+        const repository = this._repositories.get(sourceControlHandle);
+        if (!repository) {
+            return;
+        }
+        const provider = repository.provider;
+        provider.$updateGroup(groupHandle, features);
+    }
+    $updateGroupLabel(sourceControlHandle, groupHandle, label) {
+        const repository = this._repositories.get(sourceControlHandle);
+        if (!repository) {
+            return;
+        }
+        const provider = repository.provider;
+        provider.$updateGroupLabel(groupHandle, label);
+    }
+    $spliceResourceStates(sourceControlHandle, splices) {
+        const repository = this._repositories.get(sourceControlHandle);
+        if (!repository) {
+            return;
+        }
+        const provider = repository.provider;
+        provider.$spliceGroupResourceStates(splices);
+    }
+    $unregisterGroup(sourceControlHandle, handle) {
+        const repository = this._repositories.get(sourceControlHandle);
+        if (!repository) {
+            return;
+        }
+        const provider = repository.provider;
+        provider.$unregisterGroup(handle);
+    }
+    $setInputBoxValue(sourceControlHandle, value) {
+        const repository = this._repositories.get(sourceControlHandle);
+        if (!repository) {
+            return;
+        }
+        repository.input.setValue(value, false);
+    }
+    $setInputBoxPlaceholder(sourceControlHandle, placeholder) {
+        const repository = this._repositories.get(sourceControlHandle);
+        if (!repository) {
+            return;
+        }
+        repository.input.placeholder = placeholder;
+    }
+    $setInputBoxEnablement(sourceControlHandle, enabled) {
+        const repository = this._repositories.get(sourceControlHandle);
+        if (!repository) {
+            return;
+        }
+        repository.input.enabled = enabled;
+    }
+    $setInputBoxVisibility(sourceControlHandle, visible) {
+        const repository = this._repositories.get(sourceControlHandle);
+        if (!repository) {
+            return;
+        }
+        repository.input.visible = visible;
+    }
+    $showValidationMessage(sourceControlHandle, message, type) {
+        const repository = this._repositories.get(sourceControlHandle);
+        if (!repository) {
+            return;
+        }
+        repository.input.showValidationMessage(message, type);
+    }
+    $setValidationProviderIsEnabled(sourceControlHandle, enabled) {
+        const repository = this._repositories.get(sourceControlHandle);
+        if (!repository) {
+            return;
+        }
+        if (enabled) {
+            repository.input.validateInput = async (value, pos) => {
+                const result = await this._proxy.$validateInput(sourceControlHandle, value, pos);
+                return result && { message: result[0], type: result[1] };
+            };
+        }
+        else {
+            repository.input.validateInput = async () => undefined;
+        }
+    }
+    $onDidChangeHistoryProviderCurrentHistoryItemGroup(sourceControlHandle, historyItemGroup) {
+        const repository = this._repositories.get(sourceControlHandle);
+        if (!repository) {
+            return;
+        }
+        const provider = repository.provider;
+        provider.$onDidChangeHistoryProviderCurrentHistoryItemGroup(historyItemGroup);
+    }
+};
+MainThreadSCM = __decorate([
+    extHostNamedCustomer(MainContext.MainThreadSCM),
+    ( __param(1, ISCMService)),
+    ( __param(2, ISCMViewService)),
+    ( __param(3, IQuickDiffService)),
+    ( __param(4, IUriIdentityService)),
+    ( __param(5, IWorkspaceContextService))
+], MainThreadSCM);
+
+export { MainThreadSCM };

package/vscode/src/vs/workbench/api/browser/mainThreadSaveParticipant.js

@@ -0,0 +1,49 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { shouldSynchronizeModel } from 'vscode/vscode/vs/editor/common/model';
+import { localizeWithPath } from 'vscode/vscode/vs/nls';
+import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
+import { extHostCustomer } from '../../services/extensions/common/extHostCustomers.js';
+import { ITextFileService } from 'vscode/vscode/vs/workbench/services/textfile/common/textfiles';
+import { ExtHostContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
+import { raceCancellationError } from 'vscode/vscode/vs/base/common/async';
+
+class ExtHostSaveParticipant {
+    constructor(extHostContext) {
+        this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostDocumentSaveParticipant));
+    }
+    async participate(editorModel, context, _progress, token) {
+        if (!editorModel.textEditorModel || !shouldSynchronizeModel(editorModel.textEditorModel)) {
+            return undefined;
+        }
+        const p = ( new Promise((resolve, reject) => {
+            setTimeout(() => reject(( new Error(( localizeWithPath(
+                'vs/workbench/api/browser/mainThreadSaveParticipant',
+                'timeout.onWillSave',
+                "Aborted onWillSaveTextDocument-event after 1750ms"
+            ))))), 1750);
+            this._proxy.$participateInSave(editorModel.resource, context.reason).then(values => {
+                if (!values.every(success => success)) {
+                    return Promise.reject(( new Error('listener failed')));
+                }
+                return undefined;
+            }).then(resolve, reject);
+        }));
+        return raceCancellationError(p, token);
+    }
+}
+let SaveParticipant = class SaveParticipant {
+    constructor(extHostContext, instantiationService, _textFileService) {
+        this._textFileService = _textFileService;
+        this._saveParticipantDisposable = this._textFileService.files.addSaveParticipant(instantiationService.createInstance(ExtHostSaveParticipant, extHostContext));
+    }
+    dispose() {
+        this._saveParticipantDisposable.dispose();
+    }
+};
+SaveParticipant = __decorate([
+    extHostCustomer,
+    ( __param(1, IInstantiationService)),
+    ( __param(2, ITextFileService))
+], SaveParticipant);
+
+export { SaveParticipant };