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

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

@@ -0,0 +1,268 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { isCancellationError } from 'vscode/vscode/vs/base/common/errors';
+import { DisposableStore } from 'vscode/vscode/vs/base/common/lifecycle';
+import { isNative } from 'vscode/vscode/vs/base/common/platform';
+import { URI } from 'vscode/vscode/vs/base/common/uri';
+import { localizeWithPath } from 'vscode/vscode/vs/nls';
+import { IEnvironmentService } from 'vscode/vscode/vs/platform/environment/common/environment';
+import { IFileService } from 'vscode/vscode/vs/platform/files/common/files';
+import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
+import { ILabelService } from 'vscode/vscode/vs/platform/label/common/label';
+import { INotificationService } from 'vscode/vscode/vs/platform/notification/common/notification';
+import { IRequestService } from 'vscode/vscode/vs/platform/request/common/request';
+import { IWorkspaceTrustManagementService, IWorkspaceTrustRequestService } from 'vscode/vscode/vs/platform/workspace/common/workspaceTrust';
+import { IWorkspaceContextService, isUntitledWorkspace } from 'vscode/vscode/vs/platform/workspace/common/workspace';
+import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
+import { checkGlobFileExists } from 'vscode/vscode/vs/workbench/services/extensions/common/workspaceContains';
+import { QueryBuilder } from 'vscode/vscode/vs/workbench/services/search/common/queryBuilder';
+import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService';
+import { ISearchService } from 'vscode/vscode/vs/workbench/services/search/common/search';
+import { IWorkspaceEditingService } from 'vscode/vscode/vs/workbench/services/workspaces/common/workspaceEditing';
+import { MainContext, ExtHostContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
+import { IEditSessionIdentityService } from 'vscode/vscode/vs/platform/workspace/common/editSessions';
+import { SideBySideEditor, EditorResourceAccessor } from 'vscode/vscode/vs/workbench/common/editor';
+import { firstOrDefault, coalesce } from 'vscode/vscode/vs/base/common/arrays';
+import { ICanonicalUriService } from 'vscode/vscode/vs/platform/workspace/common/canonicalUri';
+
+let MainThreadWorkspace = class MainThreadWorkspace {
+    constructor(extHostContext, _searchService, _contextService, _editSessionIdentityService, _canonicalUriService, _editorService, _workspaceEditingService, _notificationService, _requestService, _instantiationService, _labelService, _environmentService, fileService, _workspaceTrustManagementService, _workspaceTrustRequestService) {
+        this._searchService = _searchService;
+        this._contextService = _contextService;
+        this._editSessionIdentityService = _editSessionIdentityService;
+        this._canonicalUriService = _canonicalUriService;
+        this._editorService = _editorService;
+        this._workspaceEditingService = _workspaceEditingService;
+        this._notificationService = _notificationService;
+        this._requestService = _requestService;
+        this._instantiationService = _instantiationService;
+        this._labelService = _labelService;
+        this._environmentService = _environmentService;
+        this._workspaceTrustManagementService = _workspaceTrustManagementService;
+        this._workspaceTrustRequestService = _workspaceTrustRequestService;
+        this._toDispose = ( new DisposableStore());
+        this._activeCancelTokens = Object.create(null);
+        this._queryBuilder = this._instantiationService.createInstance(QueryBuilder);
+        this.registeredEditSessionProviders = ( new Map());
+        this.registeredCanonicalUriProviders = ( new Map());
+        this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostWorkspace));
+        const workspace = this._contextService.getWorkspace();
+        if (workspace.configuration && !isNative && !fileService.hasProvider(workspace.configuration)) {
+            this._proxy.$initializeWorkspace(this.getWorkspaceData(workspace), this.isWorkspaceTrusted());
+        }
+        else {
+            this._contextService.getCompleteWorkspace().then(workspace => this._proxy.$initializeWorkspace(this.getWorkspaceData(workspace), this.isWorkspaceTrusted()));
+        }
+        this._contextService.onDidChangeWorkspaceFolders(this._onDidChangeWorkspace, this, this._toDispose);
+        this._contextService.onDidChangeWorkbenchState(this._onDidChangeWorkspace, this, this._toDispose);
+        this._workspaceTrustManagementService.onDidChangeTrust(this._onDidGrantWorkspaceTrust, this, this._toDispose);
+    }
+    dispose() {
+        this._toDispose.dispose();
+        for (const requestId in this._activeCancelTokens) {
+            const tokenSource = this._activeCancelTokens[requestId];
+            tokenSource.cancel();
+        }
+    }
+    $updateWorkspaceFolders(extensionName, index, deleteCount, foldersToAdd) {
+        const workspaceFoldersToAdd = ( foldersToAdd.map(f => ({ uri: URI.revive(f.uri), name: f.name })));
+        this._notificationService.status(this.getStatusMessage(extensionName, workspaceFoldersToAdd.length, deleteCount), { hideAfter: 10 * 1000  });
+        return this._workspaceEditingService.updateFolders(index, deleteCount, workspaceFoldersToAdd, true);
+    }
+    getStatusMessage(extensionName, addCount, removeCount) {
+        let message;
+        const wantsToAdd = addCount > 0;
+        const wantsToDelete = removeCount > 0;
+        if (wantsToAdd && !wantsToDelete) {
+            if (addCount === 1) {
+                message = ( localizeWithPath(
+                    'vs/workbench/api/browser/mainThreadWorkspace',
+                    'folderStatusMessageAddSingleFolder',
+                    "Extension '{0}' added 1 folder to the workspace",
+                    extensionName
+                ));
+            }
+            else {
+                message = ( localizeWithPath(
+                    'vs/workbench/api/browser/mainThreadWorkspace',
+                    'folderStatusMessageAddMultipleFolders',
+                    "Extension '{0}' added {1} folders to the workspace",
+                    extensionName,
+                    addCount
+                ));
+            }
+        }
+        else if (wantsToDelete && !wantsToAdd) {
+            if (removeCount === 1) {
+                message = ( localizeWithPath(
+                    'vs/workbench/api/browser/mainThreadWorkspace',
+                    'folderStatusMessageRemoveSingleFolder',
+                    "Extension '{0}' removed 1 folder from the workspace",
+                    extensionName
+                ));
+            }
+            else {
+                message = ( localizeWithPath(
+                    'vs/workbench/api/browser/mainThreadWorkspace',
+                    'folderStatusMessageRemoveMultipleFolders',
+                    "Extension '{0}' removed {1} folders from the workspace",
+                    extensionName,
+                    removeCount
+                ));
+            }
+        }
+        else {
+            message = ( localizeWithPath(
+                'vs/workbench/api/browser/mainThreadWorkspace',
+                'folderStatusChangeFolder',
+                "Extension '{0}' changed folders of the workspace",
+                extensionName
+            ));
+        }
+        return message;
+    }
+    _onDidChangeWorkspace() {
+        this._proxy.$acceptWorkspaceData(this.getWorkspaceData(this._contextService.getWorkspace()));
+    }
+    getWorkspaceData(workspace) {
+        if (this._contextService.getWorkbenchState() === 1 ) {
+            return null;
+        }
+        return {
+            configuration: workspace.configuration || undefined,
+            isUntitled: workspace.configuration ? isUntitledWorkspace(workspace.configuration, this._environmentService) : false,
+            folders: workspace.folders,
+            id: workspace.id,
+            name: this._labelService.getWorkspaceLabel(workspace),
+            transient: workspace.transient
+        };
+    }
+    $startFileSearch(_includeFolder, options, token) {
+        const includeFolder = URI.revive(_includeFolder);
+        const workspace = this._contextService.getWorkspace();
+        const query = this._queryBuilder.file(includeFolder ? [includeFolder] : workspace.folders, options);
+        return this._searchService.fileSearch(query, token).then(result => {
+            return ( result.results.map(m => m.resource));
+        }, err => {
+            if (!isCancellationError(err)) {
+                return Promise.reject(err);
+            }
+            return null;
+        });
+    }
+    $startTextSearch(pattern, _folder, options, requestId, token) {
+        const folder = URI.revive(_folder);
+        const workspace = this._contextService.getWorkspace();
+        const folders = folder ? [folder] : ( workspace.folders.map(folder => folder.uri));
+        const query = this._queryBuilder.text(pattern, folders, options);
+        query._reason = 'startTextSearch';
+        const onProgress = (p) => {
+            if (p.results) {
+                this._proxy.$handleTextSearchResult(p, requestId);
+            }
+        };
+        const search = this._searchService.textSearch(query, token, onProgress).then(result => {
+            return { limitHit: result.limitHit };
+        }, err => {
+            if (!isCancellationError(err)) {
+                return Promise.reject(err);
+            }
+            return null;
+        });
+        return search;
+    }
+    $checkExists(folders, includes, token) {
+        return this._instantiationService.invokeFunction((accessor) => checkGlobFileExists(accessor, folders, includes, token));
+    }
+    async $save(uriComponents, options) {
+        const uri = URI.revive(uriComponents);
+        const editors = [...this._editorService.findEditors(uri, { supportSideBySide: SideBySideEditor.PRIMARY })];
+        const result = await this._editorService.save(editors, {
+            reason: 1 ,
+            saveAs: options.saveAs,
+            force: !options.saveAs
+        });
+        return firstOrDefault(this._saveResultToUris(result));
+    }
+    _saveResultToUris(result) {
+        if (!result.success) {
+            return [];
+        }
+        return coalesce(( result.editors.map(
+            editor => EditorResourceAccessor.getCanonicalUri(editor, { supportSideBySide: SideBySideEditor.PRIMARY })
+        )));
+    }
+    $saveAll(includeUntitled) {
+        return this._editorService.saveAll({ includeUntitled }).then(res => res.success);
+    }
+    $resolveProxy(url) {
+        return this._requestService.resolveProxy(url);
+    }
+    $loadCertificates() {
+        return this._requestService.loadCertificates();
+    }
+    $requestWorkspaceTrust(options) {
+        return this._workspaceTrustRequestService.requestWorkspaceTrust(options);
+    }
+    isWorkspaceTrusted() {
+        return this._workspaceTrustManagementService.isWorkspaceTrusted();
+    }
+    _onDidGrantWorkspaceTrust() {
+        this._proxy.$onDidGrantWorkspaceTrust();
+    }
+    $registerEditSessionIdentityProvider(handle, scheme) {
+        const disposable = this._editSessionIdentityService.registerEditSessionIdentityProvider({
+            scheme: scheme,
+            getEditSessionIdentifier: async (workspaceFolder, token) => {
+                return this._proxy.$getEditSessionIdentifier(workspaceFolder.uri, token);
+            },
+            provideEditSessionIdentityMatch: async (workspaceFolder, identity1, identity2, token) => {
+                return this._proxy.$provideEditSessionIdentityMatch(workspaceFolder.uri, identity1, identity2, token);
+            }
+        });
+        this.registeredEditSessionProviders.set(handle, disposable);
+        this._toDispose.add(disposable);
+    }
+    $unregisterEditSessionIdentityProvider(handle) {
+        const disposable = this.registeredEditSessionProviders.get(handle);
+        disposable?.dispose();
+        this.registeredEditSessionProviders.delete(handle);
+    }
+    $registerCanonicalUriProvider(handle, scheme) {
+        const disposable = this._canonicalUriService.registerCanonicalUriProvider({
+            scheme: scheme,
+            provideCanonicalUri: async (uri, targetScheme, token) => {
+                const result = await this._proxy.$provideCanonicalUri(uri, targetScheme, token);
+                if (result) {
+                    return URI.revive(result);
+                }
+                return result;
+            }
+        });
+        this.registeredCanonicalUriProviders.set(handle, disposable);
+        this._toDispose.add(disposable);
+    }
+    $unregisterCanonicalUriProvider(handle) {
+        const disposable = this.registeredCanonicalUriProviders.get(handle);
+        disposable?.dispose();
+        this.registeredCanonicalUriProviders.delete(handle);
+    }
+};
+MainThreadWorkspace = __decorate([
+    extHostNamedCustomer(MainContext.MainThreadWorkspace),
+    ( __param(1, ISearchService)),
+    ( __param(2, IWorkspaceContextService)),
+    ( __param(3, IEditSessionIdentityService)),
+    ( __param(4, ICanonicalUriService)),
+    ( __param(5, IEditorService)),
+    ( __param(6, IWorkspaceEditingService)),
+    ( __param(7, INotificationService)),
+    ( __param(8, IRequestService)),
+    ( __param(9, IInstantiationService)),
+    ( __param(10, ILabelService)),
+    ( __param(11, IEnvironmentService)),
+    ( __param(12, IFileService)),
+    ( __param(13, IWorkspaceTrustManagementService)),
+    ( __param(14, IWorkspaceTrustRequestService))
+], MainThreadWorkspace);
+
+export { MainThreadWorkspace };

package/vscode/src/vs/workbench/api/common/shared/dataTransferCache.js

@@ -0,0 +1,35 @@
+import { coalesce } from 'vscode/vscode/vs/base/common/arrays';
+import { VSBuffer } from 'vscode/vscode/vs/base/common/buffer';
+
+class DataTransferFileCache {
+    constructor() {
+        this.requestIdPool = 0;
+        this.dataTransferFiles = ( new Map());
+    }
+    add(dataTransfer) {
+        const requestId = this.requestIdPool++;
+        this.dataTransferFiles.set(requestId, coalesce(Array.from(dataTransfer, ([, item]) => item.asFile())));
+        return {
+            id: requestId,
+            dispose: () => {
+                this.dataTransferFiles.delete(requestId);
+            }
+        };
+    }
+    async resolveFileData(requestId, dataItemId) {
+        const files = this.dataTransferFiles.get(requestId);
+        if (!files) {
+            throw new Error('No data transfer found');
+        }
+        const file = files.find(file => file.id === dataItemId);
+        if (!file) {
+            throw new Error('No matching file found in data transfer');
+        }
+        return VSBuffer.wrap(await file.data());
+    }
+    dispose() {
+        this.dataTransferFiles.clear();
+    }
+}
+
+export { DataTransferFileCache };

package/vscode/src/vs/workbench/contrib/customEditor/common/customTextEditorModel.js

@@ -0,0 +1,76 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { Emitter } from 'vscode/vscode/vs/base/common/event';
+import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import { isEqual } from 'vscode/vscode/vs/base/common/resources';
+import { ITextModelService } from 'vscode/vscode/vs/editor/common/services/resolverService';
+import { ITextFileService } from 'vscode/vscode/vs/workbench/services/textfile/common/textfiles';
+
+var CustomTextEditorModel_1;
+let CustomTextEditorModel = CustomTextEditorModel_1 = class CustomTextEditorModel extends Disposable {
+    static async create(instantiationService, viewType, resource) {
+        return instantiationService.invokeFunction(async (accessor) => {
+            const textModelResolverService = accessor.get(ITextModelService);
+            const model = await textModelResolverService.createModelReference(resource);
+            return instantiationService.createInstance(CustomTextEditorModel_1, viewType, resource, model);
+        });
+    }
+    constructor(viewType, _resource, _model, textFileService) {
+        super();
+        this.viewType = viewType;
+        this._resource = _resource;
+        this._model = _model;
+        this.textFileService = textFileService;
+        this._onDidChangeOrphaned = this._register(( new Emitter()));
+        this.onDidChangeOrphaned = this._onDidChangeOrphaned.event;
+        this._onDidChangeReadonly = this._register(( new Emitter()));
+        this.onDidChangeReadonly = this._onDidChangeReadonly.event;
+        this._onDidChangeDirty = this._register(( new Emitter()));
+        this.onDidChangeDirty = this._onDidChangeDirty.event;
+        this._onDidChangeContent = this._register(( new Emitter()));
+        this.onDidChangeContent = this._onDidChangeContent.event;
+        this._register(_model);
+        this._textFileModel = this.textFileService.files.get(_resource);
+        if (this._textFileModel) {
+            this._register(this._textFileModel.onDidChangeOrphaned(() => this._onDidChangeOrphaned.fire()));
+            this._register(this._textFileModel.onDidChangeReadonly(() => this._onDidChangeReadonly.fire()));
+        }
+        this._register(this.textFileService.files.onDidChangeDirty(e => {
+            if (isEqual(this.resource, e.resource)) {
+                this._onDidChangeDirty.fire();
+                this._onDidChangeContent.fire();
+            }
+        }));
+    }
+    get resource() {
+        return this._resource;
+    }
+    isReadonly() {
+        return this._model.object.isReadonly();
+    }
+    get backupId() {
+        return undefined;
+    }
+    get canHotExit() {
+        return true;
+    }
+    isDirty() {
+        return this.textFileService.isDirty(this.resource);
+    }
+    isOrphaned() {
+        return !!this._textFileModel?.hasState(4 );
+    }
+    async revert(options) {
+        return this.textFileService.revert(this.resource, options);
+    }
+    saveCustomEditor(options) {
+        return this.textFileService.save(this.resource, options);
+    }
+    async saveCustomEditorAs(resource, targetResource, options) {
+        return !!(await this.textFileService.saveAs(resource, targetResource, options));
+    }
+};
+CustomTextEditorModel = CustomTextEditorModel_1 = ( __decorate([
+    ( __param(3, ITextFileService))
+], CustomTextEditorModel));
+
+export { CustomTextEditorModel };

package/vscode/src/vs/workbench/contrib/externalUriOpener/common/contributedOpeners.js

@@ -0,0 +1,83 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import { IStorageService } from 'vscode/vscode/vs/platform/storage/common/storage';
+import { Memento } from 'vscode/vscode/vs/workbench/common/memento';
+import { updateContributedOpeners } from 'vscode/vscode/vs/workbench/contrib/externalUriOpener/common/configuration';
+import { IExtensionService } from 'vscode/vscode/vs/workbench/services/extensions/common/extensions';
+
+var ContributedExternalUriOpenersStore_1;
+let ContributedExternalUriOpenersStore = class ContributedExternalUriOpenersStore extends Disposable {
+    static { ContributedExternalUriOpenersStore_1 = this; }
+    static { this.STORAGE_ID = 'externalUriOpeners'; }
+    constructor(storageService, _extensionService) {
+        super();
+        this._extensionService = _extensionService;
+        this._openers = ( new Map());
+        this._memento = ( new Memento(ContributedExternalUriOpenersStore_1.STORAGE_ID, storageService));
+        this._mementoObject = this._memento.getMemento(0 , 1 );
+        for (const [id, value] of Object.entries(this._mementoObject || {})) {
+            this.add(id, value.extensionId, { isCurrentlyRegistered: false });
+        }
+        this.invalidateOpenersOnExtensionsChanged();
+        this._register(this._extensionService.onDidChangeExtensions(() => this.invalidateOpenersOnExtensionsChanged()));
+        this._register(this._extensionService.onDidChangeExtensionsStatus(() => this.invalidateOpenersOnExtensionsChanged()));
+    }
+    didRegisterOpener(id, extensionId) {
+        this.add(id, extensionId, {
+            isCurrentlyRegistered: true
+        });
+    }
+    add(id, extensionId, options) {
+        const existing = this._openers.get(id);
+        if (existing) {
+            existing.isCurrentlyRegistered = existing.isCurrentlyRegistered || options.isCurrentlyRegistered;
+            return;
+        }
+        const entry = {
+            extensionId,
+            isCurrentlyRegistered: options.isCurrentlyRegistered
+        };
+        this._openers.set(id, entry);
+        this._mementoObject[id] = entry;
+        this._memento.saveMemento();
+        this.updateSchema();
+    }
+    delete(id) {
+        this._openers.delete(id);
+        delete this._mementoObject[id];
+        this._memento.saveMemento();
+        this.updateSchema();
+    }
+    async invalidateOpenersOnExtensionsChanged() {
+        await this._extensionService.whenInstalledExtensionsRegistered();
+        const registeredExtensions = this._extensionService.extensions;
+        for (const [id, entry] of this._openers) {
+            const extension = registeredExtensions.find(r => r.identifier.value === entry.extensionId);
+            if (extension) {
+                if (!this._extensionService.canRemoveExtension(extension)) {
+                    if (!entry.isCurrentlyRegistered) {
+                        this.delete(id);
+                    }
+                }
+            }
+            else {
+                this.delete(id);
+            }
+        }
+    }
+    updateSchema() {
+        const ids = [];
+        const descriptions = [];
+        for (const [id, entry] of this._openers) {
+            ids.push(id);
+            descriptions.push(entry.extensionId);
+        }
+        updateContributedOpeners(ids, descriptions);
+    }
+};
+ContributedExternalUriOpenersStore = ContributedExternalUriOpenersStore_1 = ( __decorate([
+    ( __param(0, IStorageService)),
+    ( __param(1, IExtensionService))
+], ContributedExternalUriOpenersStore));
+
+export { ContributedExternalUriOpenersStore };