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

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

@@ -1,185 +0,0 @@
-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

@@ -1,30 +0,0 @@
-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 };