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

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

@@ -0,0 +1,38 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { Disposable, DisposableMap } from 'vscode/vscode/vs/base/common/lifecycle';
+import { revive } from 'vscode/vscode/vs/base/common/marshalling';
+import { MainContext, ExtHostContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
+import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
+import { IUserDataProfileImportExportService } from 'vscode/vscode/vs/workbench/services/userDataProfile/common/userDataProfile';
+
+let MainThreadProfileContentHandlers = class MainThreadProfileContentHandlers extends Disposable {
+    constructor(context, userDataProfileImportExportService) {
+        super();
+        this.userDataProfileImportExportService = userDataProfileImportExportService;
+        this.registeredHandlers = this._register(( new DisposableMap()));
+        this.proxy = ( context.getProxy(ExtHostContext.ExtHostProfileContentHandlers));
+    }
+    async $registerProfileContentHandler(id, name, description, extensionId) {
+        this.registeredHandlers.set(id, this.userDataProfileImportExportService.registerProfileContentHandler(id, {
+            name,
+            description,
+            extensionId,
+            saveProfile: async (name, content, token) => {
+                const result = await this.proxy.$saveProfile(id, name, content, token);
+                return result ? revive(result) : null;
+            },
+            readProfile: async (uri, token) => {
+                return this.proxy.$readProfile(id, uri, token);
+            },
+        }));
+    }
+    async $unregisterProfileContentHandler(id) {
+        this.registeredHandlers.deleteAndDispose(id);
+    }
+};
+MainThreadProfileContentHandlers = __decorate([
+    extHostNamedCustomer(MainContext.MainThreadProfileContentHandlers),
+    ( __param(1, IUserDataProfileImportExportService))
+], MainThreadProfileContentHandlers);
+
+export { MainThreadProfileContentHandlers };

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

@@ -0,0 +1,68 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { IProgressService } from 'vscode/vscode/vs/platform/progress/common/progress';
+import { MainContext, ExtHostContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
+import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
+import { Action } from 'vscode/vscode/vs/base/common/actions';
+import { ICommandService } from 'vscode/vscode/vs/platform/commands/common/commands';
+import { localizeWithPath } from 'vscode/vscode/vs/nls';
+
+class ManageExtensionAction extends Action {
+    constructor(extensionId, label, commandService) {
+        super(extensionId, label, undefined, true, () => {
+            return commandService.executeCommand('_extensions.manage', extensionId);
+        });
+    }
+}
+let MainThreadProgress = class MainThreadProgress {
+    constructor(extHostContext, progressService, _commandService) {
+        this._commandService = _commandService;
+        this._progress = ( new Map());
+        this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostProgress));
+        this._progressService = progressService;
+    }
+    dispose() {
+        this._progress.forEach(handle => handle.resolve());
+        this._progress.clear();
+    }
+    async $startProgress(handle, options, extensionId) {
+        const task = this._createTask(handle);
+        if (options.location === 15  && extensionId) {
+            const notificationOptions = {
+                ...options,
+                location: 15 ,
+                secondaryActions: [( new ManageExtensionAction(extensionId, ( localizeWithPath(
+                    'vs/workbench/api/browser/mainThreadProgress',
+                    'manageExtension',
+                    "Manage Extension"
+                )), this._commandService))]
+            };
+            options = notificationOptions;
+        }
+        this._progressService.withProgress(options, task, () => this._proxy.$acceptProgressCanceled(handle));
+    }
+    $progressReport(handle, message) {
+        const entry = this._progress.get(handle);
+        entry?.progress.report(message);
+    }
+    $progressEnd(handle) {
+        const entry = this._progress.get(handle);
+        if (entry) {
+            entry.resolve();
+            this._progress.delete(handle);
+        }
+    }
+    _createTask(handle) {
+        return (progress) => {
+            return ( new Promise(resolve => {
+                this._progress.set(handle, { resolve, progress });
+            }));
+        };
+    }
+};
+MainThreadProgress = __decorate([
+    extHostNamedCustomer(MainContext.MainThreadProgress),
+    ( __param(1, IProgressService)),
+    ( __param(2, ICommandService))
+], MainThreadProgress);
+
+export { MainThreadProgress };

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

@@ -0,0 +1,42 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { CancellationToken } from 'vscode/vscode/vs/base/common/cancellation';
+import { DisposableMap } from 'vscode/vscode/vs/base/common/lifecycle';
+import { URI } from 'vscode/vscode/vs/base/common/uri';
+import { MainContext, ExtHostContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
+import { IQuickDiffService } from 'vscode/vscode/vs/workbench/contrib/scm/common/quickDiff';
+import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
+
+let MainThreadQuickDiff = class MainThreadQuickDiff {
+    constructor(extHostContext, quickDiffService) {
+        this.quickDiffService = quickDiffService;
+        this.providerDisposables = ( new DisposableMap());
+        this.proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostQuickDiff));
+    }
+    async $registerQuickDiffProvider(handle, selector, label, rootUri) {
+        const provider = {
+            label,
+            rootUri: URI.revive(rootUri),
+            selector,
+            isSCM: false,
+            getOriginalResource: async (uri) => {
+                return URI.revive(await this.proxy.$provideOriginalResource(handle, uri, CancellationToken.None));
+            }
+        };
+        const disposable = this.quickDiffService.addQuickDiffProvider(provider);
+        this.providerDisposables.set(handle, disposable);
+    }
+    async $unregisterQuickDiffProvider(handle) {
+        if (( this.providerDisposables.has(handle))) {
+            this.providerDisposables.deleteAndDispose(handle);
+        }
+    }
+    dispose() {
+        this.providerDisposables.dispose();
+    }
+};
+MainThreadQuickDiff = __decorate([
+    extHostNamedCustomer(MainContext.MainThreadQuickDiff),
+    ( __param(1, IQuickDiffService))
+], MainThreadQuickDiff);
+
+export { MainThreadQuickDiff };

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

@@ -0,0 +1,185 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { IQuickInputService } from 'vscode/vscode/vs/platform/quickinput/common/quickInput';
+import { MainContext, ExtHostContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
+import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
+import { URI } from 'vscode/vscode/vs/base/common/uri';
+
+function reviveIconPathUris(iconPath) {
+    iconPath.dark = URI.revive(iconPath.dark);
+    if (iconPath.light) {
+        iconPath.light = URI.revive(iconPath.light);
+    }
+}
+let MainThreadQuickOpen = class MainThreadQuickOpen {
+    constructor(extHostContext, quickInputService) {
+        this._items = {};
+        this.sessions = ( new Map());
+        this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostQuickOpen));
+        this._quickInputService = quickInputService;
+    }
+    dispose() {
+    }
+    $show(instance, options, token) {
+        const contents = ( new Promise((resolve, reject) => {
+            this._items[instance] = { resolve, reject };
+        }));
+        options = {
+            ...options,
+            onDidFocus: el => {
+                if (el) {
+                    this._proxy.$onItemSelected(el.handle);
+                }
+            }
+        };
+        if (options.canPickMany) {
+            return this._quickInputService.pick(contents, options, token).then(items => {
+                if (items) {
+                    return ( items.map(item => item.handle));
+                }
+                return undefined;
+            });
+        }
+        else {
+            return this._quickInputService.pick(contents, options, token).then(item => {
+                if (item) {
+                    return item.handle;
+                }
+                return undefined;
+            });
+        }
+    }
+    $setItems(instance, items) {
+        if (this._items[instance]) {
+            this._items[instance].resolve(items);
+            delete this._items[instance];
+        }
+        return Promise.resolve();
+    }
+    $setError(instance, error) {
+        if (this._items[instance]) {
+            this._items[instance].reject(error);
+            delete this._items[instance];
+        }
+        return Promise.resolve();
+    }
+    $input(options, validateInput, token) {
+        const inputOptions = Object.create(null);
+        if (options) {
+            inputOptions.title = options.title;
+            inputOptions.password = options.password;
+            inputOptions.placeHolder = options.placeHolder;
+            inputOptions.valueSelection = options.valueSelection;
+            inputOptions.prompt = options.prompt;
+            inputOptions.value = options.value;
+            inputOptions.ignoreFocusLost = options.ignoreFocusOut;
+        }
+        if (validateInput) {
+            inputOptions.validateInput = (value) => {
+                return this._proxy.$validateInput(value);
+            };
+        }
+        return this._quickInputService.input(inputOptions, token);
+    }
+    $createOrUpdate(params) {
+        const sessionId = params.id;
+        let session = this.sessions.get(sessionId);
+        if (!session) {
+            const input = params.type === 'quickPick' ? this._quickInputService.createQuickPick() : this._quickInputService.createInputBox();
+            input.onDidAccept(() => {
+                this._proxy.$onDidAccept(sessionId);
+            });
+            input.onDidTriggerButton(button => {
+                this._proxy.$onDidTriggerButton(sessionId, button.handle);
+            });
+            input.onDidChangeValue(value => {
+                this._proxy.$onDidChangeValue(sessionId, value);
+            });
+            input.onDidHide(() => {
+                this._proxy.$onDidHide(sessionId);
+            });
+            if (params.type === 'quickPick') {
+                const quickpick = input;
+                quickpick.onDidChangeActive(items => {
+                    this._proxy.$onDidChangeActive(sessionId, ( items.map(item => item.handle)));
+                });
+                quickpick.onDidChangeSelection(items => {
+                    this._proxy.$onDidChangeSelection(sessionId, ( items.map(item => item.handle)));
+                });
+                quickpick.onDidTriggerItemButton((e) => {
+                    this._proxy.$onDidTriggerItemButton(sessionId, e.item.handle, e.button.handle);
+                });
+            }
+            session = {
+                input,
+                handlesToItems: ( new Map())
+            };
+            this.sessions.set(sessionId, session);
+        }
+        const { input, handlesToItems } = session;
+        for (const param in params) {
+            if (param === 'id' || param === 'type') {
+                continue;
+            }
+            if (param === 'visible') {
+                if (params.visible) {
+                    input.show();
+                }
+                else {
+                    input.hide();
+                }
+            }
+            else if (param === 'items') {
+                handlesToItems.clear();
+                params[param].forEach((item) => {
+                    if (item.type === 'separator') {
+                        return;
+                    }
+                    if (item.buttons) {
+                        item.buttons = ( item.buttons.map((button) => {
+                            if (button.iconPath) {
+                                reviveIconPathUris(button.iconPath);
+                            }
+                            return button;
+                        }));
+                    }
+                    handlesToItems.set(item.handle, item);
+                });
+                input[param] = params[param];
+            }
+            else if (param === 'activeItems' || param === 'selectedItems') {
+                input[param] = ( params[param]
+                    .filter((handle) => ( handlesToItems.has(handle)))
+                    .map((handle) => handlesToItems.get(handle)));
+            }
+            else if (param === 'buttons') {
+                input[param] = ( params.buttons.map(button => {
+                    if (button.handle === -1) {
+                        return this._quickInputService.backButton;
+                    }
+                    if (button.iconPath) {
+                        reviveIconPathUris(button.iconPath);
+                    }
+                    return button;
+                }));
+            }
+            else {
+                input[param] = params[param];
+            }
+        }
+        return Promise.resolve(undefined);
+    }
+    $dispose(sessionId) {
+        const session = this.sessions.get(sessionId);
+        if (session) {
+            session.input.dispose();
+            this.sessions.delete(sessionId);
+        }
+        return Promise.resolve(undefined);
+    }
+};
+MainThreadQuickOpen = __decorate([
+    extHostNamedCustomer(MainContext.MainThreadQuickOpen),
+    ( __param(1, IQuickInputService))
+], MainThreadQuickOpen);
+
+export { MainThreadQuickOpen };

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

@@ -0,0 +1,30 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { extHostCustomer } from '../../services/extensions/common/extHostCustomers.js';
+import { ExtHostContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
+import { IRemoteAuthorityResolverService } from 'vscode/vscode/vs/platform/remote/common/remoteAuthorityResolver';
+import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import { IWorkbenchEnvironmentService } from 'vscode/vscode/vs/workbench/services/environment/common/environmentService';
+
+let MainThreadRemoteConnectionData = class MainThreadRemoteConnectionData extends Disposable {
+    constructor(extHostContext, _environmentService, remoteAuthorityResolverService) {
+        super();
+        this._environmentService = _environmentService;
+        this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostExtensionService));
+        const remoteAuthority = this._environmentService.remoteAuthority;
+        if (remoteAuthority) {
+            this._register(remoteAuthorityResolverService.onDidChangeConnectionData(() => {
+                const connectionData = remoteAuthorityResolverService.getConnectionData(remoteAuthority);
+                if (connectionData) {
+                    this._proxy.$updateRemoteConnectionData(connectionData);
+                }
+            }));
+        }
+    }
+};
+MainThreadRemoteConnectionData = __decorate([
+    extHostCustomer,
+    ( __param(1, IWorkbenchEnvironmentService)),
+    ( __param(2, IRemoteAuthorityResolverService))
+], MainThreadRemoteConnectionData);
+
+export { MainThreadRemoteConnectionData };