@codingame/monaco-vscode-extensions-service-override
Version:
VSCode public API plugged on the monaco editor - extensions service-override
261 lines (258 loc) • 13.3 kB
JavaScript
import { __decorate, __param } from 'vscode/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 { localize } from 'vscode/vscode/vs/nls';
import { IEnvironmentService } from 'vscode/vscode/vs/platform/environment/common/environment.service';
import { IFileService } from 'vscode/vscode/vs/platform/files/common/files.service';
import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
import { ILabelService } from 'vscode/vscode/vs/platform/label/common/label.service';
import { INotificationService } from 'vscode/vscode/vs/platform/notification/common/notification.service';
import { IRequestService } from 'vscode/vscode/vs/platform/request/common/request.service';
import { IWorkspaceTrustManagementService, IWorkspaceTrustRequestService } from 'vscode/vscode/vs/platform/workspace/common/workspaceTrust.service';
import { WorkbenchState, isUntitledWorkspace } from 'vscode/vscode/vs/platform/workspace/common/workspace';
import { IWorkspaceContextService } from 'vscode/vscode/vs/platform/workspace/common/workspace.service';
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.service';
import { ISearchService } from 'vscode/vscode/vs/workbench/services/search/common/search.service';
import { IWorkspaceEditingService } from 'vscode/vscode/vs/workbench/services/workspaces/common/workspaceEditing.service';
import { ExtHostContext, MainContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
import { IEditSessionIdentityService } from 'vscode/vscode/vs/platform/workspace/common/editSessions.service';
import { SideBySideEditor, SaveReason, 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.service';
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 = ( localize(4868, "Extension '{0}' added 1 folder to the workspace", extensionName));
}
else {
message = ( localize(
4869,
"Extension '{0}' added {1} folders to the workspace",
extensionName,
addCount
));
}
}
else if (wantsToDelete && !wantsToAdd) {
if (removeCount === 1) {
message = ( localize(4870, "Extension '{0}' removed 1 folder from the workspace", extensionName));
}
else {
message = ( localize(
4871,
"Extension '{0}' removed {1} folders from the workspace",
extensionName,
removeCount
));
}
}
else {
message = ( localize(4872, "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() === WorkbenchState.EMPTY) {
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: SaveReason.EXPLICIT,
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);
}
$lookupAuthorization(authInfo) {
return this._requestService.lookupAuthorization(authInfo);
}
$lookupKerberosAuthorization(url) {
return this._requestService.lookupKerberosAuthorization(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 };