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

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

@@ -1,223 +0,0 @@
-import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
-import { localizeWithPath } from 'vscode/vscode/vs/nls';
-import { MainContext, ExtHostContext, CandidatePortSource } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
-import { TunnelDtoConverter } from 'vscode/vscode/vs/workbench/api/common/extHostTunnelService';
-import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
-import { IRemoteExplorerService, PORT_AUTO_FORWARD_SETTING, PORT_AUTO_SOURCE_SETTING, PORT_AUTO_SOURCE_SETTING_OUTPUT } from 'vscode/vscode/vs/workbench/services/remote/common/remoteExplorerService';
-import { ITunnelService, TunnelProtocol } from 'vscode/vscode/vs/platform/tunnel/common/tunnel';
-import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
-import { INotificationService, Severity } from 'vscode/vscode/vs/platform/notification/common/notification';
-import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration';
-import { ILogService } from 'vscode/vscode/vs/platform/log/common/log';
-import { IRemoteAgentService } from 'vscode/vscode/vs/workbench/services/remote/common/remoteAgentService';
-import { Registry } from 'vscode/vscode/vs/platform/registry/common/platform';
-import { Extensions } from 'vscode/vscode/vs/platform/configuration/common/configurationRegistry';
-import { IContextKeyService } from 'vscode/vscode/vs/platform/contextkey/common/contextkey';
-import { TunnelSource, TunnelCloseReason, forwardedPortsViewEnabled, makeAddress } from 'vscode/vscode/vs/workbench/services/remote/common/tunnelModel';
-
-let MainThreadTunnelService = class MainThreadTunnelService extends Disposable {
-    constructor(extHostContext, remoteExplorerService, tunnelService, notificationService, configurationService, logService, remoteAgentService, contextKeyService) {
-        super();
-        this.remoteExplorerService = remoteExplorerService;
-        this.tunnelService = tunnelService;
-        this.notificationService = notificationService;
-        this.configurationService = configurationService;
-        this.logService = logService;
-        this.remoteAgentService = remoteAgentService;
-        this.contextKeyService = contextKeyService;
-        this.elevateionRetry = false;
-        this.portsAttributesProviders = ( new Map());
-        this._alreadyRegistered = false;
-        this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostTunnelService));
-        this._register(tunnelService.onTunnelOpened(() => this._proxy.$onDidTunnelsChange()));
-        this._register(tunnelService.onTunnelClosed(() => this._proxy.$onDidTunnelsChange()));
-    }
-    processFindingEnabled() {
-        return (!!this.configurationService.getValue(PORT_AUTO_FORWARD_SETTING) || this.tunnelService.hasTunnelProvider)
-            && (this.configurationService.getValue(PORT_AUTO_SOURCE_SETTING) !== PORT_AUTO_SOURCE_SETTING_OUTPUT);
-    }
-    async $setRemoteTunnelService(processId) {
-        this.remoteExplorerService.namedProcesses.set(processId, 'Code Extension Host');
-        if (this.remoteExplorerService.portsFeaturesEnabled) {
-            this._proxy.$registerCandidateFinder(this.processFindingEnabled());
-        }
-        else {
-            this._register(this.remoteExplorerService.onEnabledPortsFeatures(() => this._proxy.$registerCandidateFinder(this.processFindingEnabled())));
-        }
-        this._register(this.configurationService.onDidChangeConfiguration(async (e) => {
-            if (e.affectsConfiguration(PORT_AUTO_FORWARD_SETTING) || e.affectsConfiguration(PORT_AUTO_SOURCE_SETTING)) {
-                return this._proxy.$registerCandidateFinder(this.processFindingEnabled());
-            }
-        }));
-        this._register(this.tunnelService.onAddedTunnelProvider(() => {
-            return this._proxy.$registerCandidateFinder(this.processFindingEnabled());
-        }));
-    }
-    async $registerPortsAttributesProvider(selector, providerHandle) {
-        this.portsAttributesProviders.set(providerHandle, selector);
-        if (!this._alreadyRegistered) {
-            this.remoteExplorerService.tunnelModel.addAttributesProvider(this);
-            this._alreadyRegistered = true;
-        }
-    }
-    async $unregisterPortsAttributesProvider(providerHandle) {
-        this.portsAttributesProviders.delete(providerHandle);
-    }
-    async providePortAttributes(ports, pid, commandLine, token) {
-        if (this.portsAttributesProviders.size === 0) {
-            return [];
-        }
-        const appropriateHandles = ( Array.from(this.portsAttributesProviders.entries()).filter(entry => {
-            const selector = entry[1];
-            const portRange = (typeof selector.portRange === 'number') ? [selector.portRange, selector.portRange + 1] : selector.portRange;
-            const portInRange = portRange ? ( ports.some(port => portRange[0] <= port && port < portRange[1])) : true;
-            const commandMatches = !selector.commandPattern || (commandLine && (commandLine.match(selector.commandPattern)));
-            return portInRange && commandMatches;
-        }).map(entry => entry[0]));
-        if (appropriateHandles.length === 0) {
-            return [];
-        }
-        return this._proxy.$providePortAttributes(appropriateHandles, ports, pid, commandLine, token);
-    }
-    async $openTunnel(tunnelOptions, source) {
-        const tunnel = await this.remoteExplorerService.forward({
-            remote: tunnelOptions.remoteAddress,
-            local: tunnelOptions.localAddressPort,
-            name: tunnelOptions.label,
-            source: {
-                source: TunnelSource.Extension,
-                description: source
-            },
-            elevateIfNeeded: false
-        });
-        if (!tunnel || (typeof tunnel === 'string')) {
-            return undefined;
-        }
-        if (!this.elevateionRetry
-            && (tunnelOptions.localAddressPort !== undefined)
-            && (tunnel.tunnelLocalPort !== undefined)
-            && this.tunnelService.isPortPrivileged(tunnelOptions.localAddressPort)
-            && (tunnel.tunnelLocalPort !== tunnelOptions.localAddressPort)
-            && this.tunnelService.canElevate) {
-            this.elevationPrompt(tunnelOptions, tunnel, source);
-        }
-        return TunnelDtoConverter.fromServiceTunnel(tunnel);
-    }
-    async elevationPrompt(tunnelOptions, tunnel, source) {
-        return this.notificationService.prompt(Severity.Info, ( localizeWithPath(
-            'vs/workbench/api/browser/mainThreadTunnelService',
-            'remote.tunnel.openTunnel',
-            "The extension {0} has forwarded port {1}. You'll need to run as superuser to use port {2} locally.",
-            source,
-            tunnelOptions.remoteAddress.port,
-            tunnelOptions.localAddressPort
-        )), [{
-                label: ( localizeWithPath(
-                    'vs/workbench/api/browser/mainThreadTunnelService',
-                    'remote.tunnelsView.elevationButton',
-                    "Use Port {0} as Sudo...",
-                    tunnel.tunnelRemotePort
-                )),
-                run: async () => {
-                    this.elevateionRetry = true;
-                    await this.remoteExplorerService.close({ host: tunnel.tunnelRemoteHost, port: tunnel.tunnelRemotePort }, TunnelCloseReason.Other);
-                    await this.remoteExplorerService.forward({
-                        remote: tunnelOptions.remoteAddress,
-                        local: tunnelOptions.localAddressPort,
-                        name: tunnelOptions.label,
-                        source: {
-                            source: TunnelSource.Extension,
-                            description: source
-                        },
-                        elevateIfNeeded: true
-                    });
-                    this.elevateionRetry = false;
-                }
-            }]);
-    }
-    async $closeTunnel(remote) {
-        return this.remoteExplorerService.close(remote, TunnelCloseReason.Other);
-    }
-    async $getTunnels() {
-        return ( (await this.tunnelService.tunnels).map(tunnel => {
-            return {
-                remoteAddress: { port: tunnel.tunnelRemotePort, host: tunnel.tunnelRemoteHost },
-                localAddress: tunnel.localAddress,
-                privacy: tunnel.privacy,
-                protocol: tunnel.protocol
-            };
-        }));
-    }
-    async $onFoundNewCandidates(candidates) {
-        this.remoteExplorerService.onFoundNewCandidates(candidates);
-    }
-    async $setTunnelProvider(features) {
-        const tunnelProvider = {
-            forwardPort: (tunnelOptions, tunnelCreationOptions) => {
-                const forward = this._proxy.$forwardPort(tunnelOptions, tunnelCreationOptions);
-                return forward.then(tunnelOrError => {
-                    if (!tunnelOrError) {
-                        return undefined;
-                    }
-                    else if (typeof tunnelOrError === 'string') {
-                        return tunnelOrError;
-                    }
-                    const tunnel = tunnelOrError;
-                    this.logService.trace(`ForwardedPorts: (MainThreadTunnelService) New tunnel established by tunnel provider: ${tunnel?.remoteAddress.host}:${tunnel?.remoteAddress.port}`);
-                    return {
-                        tunnelRemotePort: tunnel.remoteAddress.port,
-                        tunnelRemoteHost: tunnel.remoteAddress.host,
-                        localAddress: typeof tunnel.localAddress === 'string' ? tunnel.localAddress : makeAddress(tunnel.localAddress.host, tunnel.localAddress.port),
-                        tunnelLocalPort: typeof tunnel.localAddress !== 'string' ? tunnel.localAddress.port : undefined,
-                        public: tunnel.public,
-                        privacy: tunnel.privacy,
-                        protocol: tunnel.protocol ?? TunnelProtocol.Http,
-                        dispose: async (silent) => {
-                            this.logService.trace(`ForwardedPorts: (MainThreadTunnelService) Closing tunnel from tunnel provider: ${tunnel?.remoteAddress.host}:${tunnel?.remoteAddress.port}`);
-                            return this._proxy.$closeTunnel({ host: tunnel.remoteAddress.host, port: tunnel.remoteAddress.port }, silent);
-                        }
-                    };
-                });
-            }
-        };
-        if (features) {
-            this.tunnelService.setTunnelFeatures(features);
-        }
-        this.tunnelService.setTunnelProvider(tunnelProvider);
-        this.contextKeyService.createKey(forwardedPortsViewEnabled.key, true);
-    }
-    async $setCandidateFilter() {
-        this.remoteExplorerService.setCandidateFilter((candidates) => {
-            return this._proxy.$applyCandidateFilter(candidates);
-        });
-    }
-    async $setCandidatePortSource(source) {
-        this.remoteAgentService.getEnvironment().then(() => {
-            switch (source) {
-                case CandidatePortSource.None: {
-                    ( Registry.as(Extensions.Configuration))
-                        .registerDefaultConfigurations([{ overrides: { 'remote.autoForwardPorts': false } }]);
-                    break;
-                }
-                case CandidatePortSource.Output: {
-                    ( Registry.as(Extensions.Configuration))
-                        .registerDefaultConfigurations([{ overrides: { 'remote.autoForwardPortsSource': PORT_AUTO_SOURCE_SETTING_OUTPUT } }]);
-                    break;
-                }
-            }
-        }).catch(() => {
-        });
-    }
-};
-MainThreadTunnelService = __decorate([
-    extHostNamedCustomer(MainContext.MainThreadTunnelService),
-    ( __param(1, IRemoteExplorerService)),
-    ( __param(2, ITunnelService)),
-    ( __param(3, INotificationService)),
-    ( __param(4, IConfigurationService)),
-    ( __param(5, ILogService)),
-    ( __param(6, IRemoteAgentService)),
-    ( __param(7, IContextKeyService))
-], MainThreadTunnelService);
-
-export { MainThreadTunnelService };

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

@@ -1,110 +0,0 @@
-import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
-import { Action } from 'vscode/vscode/vs/base/common/actions';
-import { isCancellationError } from 'vscode/vscode/vs/base/common/errors';
-import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
-import { Schemas } from 'vscode/vscode/vs/base/common/network';
-import { localizeWithPath } from 'vscode/vscode/vs/nls';
-import { INotificationService, Severity } from 'vscode/vscode/vs/platform/notification/common/notification';
-import { IOpenerService } from 'vscode/vscode/vs/platform/opener/common/opener';
-import { IStorageService } from 'vscode/vscode/vs/platform/storage/common/storage';
-import { MainContext, ExtHostContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
-import { defaultExternalUriOpenerId } from 'vscode/vscode/vs/workbench/contrib/externalUriOpener/common/configuration';
-import { ContributedExternalUriOpenersStore } from '../../contrib/externalUriOpener/common/contributedOpeners.js';
-import { IExternalUriOpenerService } from 'vscode/vscode/vs/workbench/contrib/externalUriOpener/common/externalUriOpenerService';
-import { IExtensionService } from 'vscode/vscode/vs/workbench/services/extensions/common/extensions';
-import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
-
-let MainThreadUriOpeners = class MainThreadUriOpeners extends Disposable {
-    constructor(context, storageService, externalUriOpenerService, extensionService, openerService, notificationService) {
-        super();
-        this.extensionService = extensionService;
-        this.openerService = openerService;
-        this.notificationService = notificationService;
-        this._registeredOpeners = ( new Map());
-        this.proxy = ( context.getProxy(ExtHostContext.ExtHostUriOpeners));
-        this._register(externalUriOpenerService.registerExternalOpenerProvider(this));
-        this._contributedExternalUriOpenersStore = this._register(( new ContributedExternalUriOpenersStore(storageService, extensionService)));
-    }
-    async *getOpeners(targetUri) {
-        if (targetUri.scheme !== Schemas.http && targetUri.scheme !== Schemas.https) {
-            return;
-        }
-        await this.extensionService.activateByEvent(`onOpenExternalUri:${targetUri.scheme}`);
-        for (const [id, openerMetadata] of this._registeredOpeners) {
-            if (( openerMetadata.schemes.has(targetUri.scheme))) {
-                yield this.createOpener(id, openerMetadata);
-            }
-        }
-    }
-    createOpener(id, metadata) {
-        return {
-            id: id,
-            label: metadata.label,
-            canOpen: (uri, token) => {
-                return this.proxy.$canOpenUri(id, uri, token);
-            },
-            openExternalUri: async (uri, ctx, token) => {
-                try {
-                    await this.proxy.$openUri(id, { resolvedUri: uri, sourceUri: ctx.sourceUri }, token);
-                }
-                catch (e) {
-                    if (!isCancellationError(e)) {
-                        const openDefaultAction = ( new Action('default', ( localizeWithPath(
-                            'vs/workbench/api/browser/mainThreadUriOpeners',
-                            'openerFailedUseDefault',
-                            "Open using default opener"
-                        )), undefined, undefined, async () => {
-                            await this.openerService.open(uri, {
-                                allowTunneling: false,
-                                allowContributedOpeners: defaultExternalUriOpenerId,
-                            });
-                        }));
-                        openDefaultAction.tooltip = ( uri.toString());
-                        this.notificationService.notify({
-                            severity: Severity.Error,
-                            message: ( localizeWithPath('vs/workbench/api/browser/mainThreadUriOpeners', {
-                                key: 'openerFailedMessage',
-                                comment: ['{0} is the id of the opener. {1} is the url being opened.'],
-                            }, 'Could not open uri with \'{0}\': {1}', id, ( e.toString()))),
-                            actions: {
-                                primary: [
-                                    openDefaultAction
-                                ]
-                            }
-                        });
-                    }
-                }
-                return true;
-            },
-        };
-    }
-    async $registerUriOpener(id, schemes, extensionId, label) {
-        if (( this._registeredOpeners.has(id))) {
-            throw new Error(`Opener with id '${id}' already registered`);
-        }
-        this._registeredOpeners.set(id, {
-            schemes: ( new Set(schemes)),
-            label,
-            extensionId,
-        });
-        this._contributedExternalUriOpenersStore.didRegisterOpener(id, extensionId.value);
-    }
-    async $unregisterUriOpener(id) {
-        this._registeredOpeners.delete(id);
-        this._contributedExternalUriOpenersStore.delete(id);
-    }
-    dispose() {
-        super.dispose();
-        this._registeredOpeners.clear();
-    }
-};
-MainThreadUriOpeners = __decorate([
-    extHostNamedCustomer(MainContext.MainThreadUriOpeners),
-    ( __param(1, IStorageService)),
-    ( __param(2, IExternalUriOpenerService)),
-    ( __param(3, IExtensionService)),
-    ( __param(4, IOpenerService)),
-    ( __param(5, INotificationService))
-], MainThreadUriOpeners);
-
-export { MainThreadUriOpeners };

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

@@ -1,61 +0,0 @@
-import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
-import { MainContext, ExtHostContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
-import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
-import { IURLService } from 'vscode/vscode/vs/platform/url/common/url';
-import { IExtensionUrlHandler } from 'vscode/vscode/vs/workbench/services/extensions/browser/extensionUrlHandler';
-import { ExtensionIdentifier } from 'vscode/vscode/vs/platform/extensions/common/extensions';
-
-class ExtensionUrlHandler {
-    constructor(proxy, handle, extensionId, extensionDisplayName) {
-        this.proxy = proxy;
-        this.handle = handle;
-        this.extensionId = extensionId;
-        this.extensionDisplayName = extensionDisplayName;
-    }
-    handleURL(uri, options) {
-        if (!ExtensionIdentifier.equals(this.extensionId, uri.authority)) {
-            return Promise.resolve(false);
-        }
-        return Promise.resolve(this.proxy.$handleExternalUri(this.handle, uri)).then(() => true);
-    }
-}
-let MainThreadUrls = class MainThreadUrls {
-    constructor(context, urlService, extensionUrlHandler) {
-        this.urlService = urlService;
-        this.extensionUrlHandler = extensionUrlHandler;
-        this.handlers = ( new Map());
-        this.proxy = ( context.getProxy(ExtHostContext.ExtHostUrls));
-    }
-    $registerUriHandler(handle, extensionId, extensionDisplayName) {
-        const handler = ( new ExtensionUrlHandler(this.proxy, handle, extensionId, extensionDisplayName));
-        const disposable = this.urlService.registerHandler(handler);
-        this.handlers.set(handle, { extensionId, disposable });
-        this.extensionUrlHandler.registerExtensionHandler(extensionId, handler);
-        return Promise.resolve(undefined);
-    }
-    $unregisterUriHandler(handle) {
-        const tuple = this.handlers.get(handle);
-        if (!tuple) {
-            return Promise.resolve(undefined);
-        }
-        const { extensionId, disposable } = tuple;
-        this.extensionUrlHandler.unregisterExtensionHandler(extensionId);
-        this.handlers.delete(handle);
-        disposable.dispose();
-        return Promise.resolve(undefined);
-    }
-    async $createAppUri(uri) {
-        return this.urlService.create(uri);
-    }
-    dispose() {
-        this.handlers.forEach(({ disposable }) => disposable.dispose());
-        this.handlers.clear();
-    }
-};
-MainThreadUrls = __decorate([
-    extHostNamedCustomer(MainContext.MainThreadUrls),
-    ( __param(1, IURLService)),
-    ( __param(2, IExtensionUrlHandler))
-], MainThreadUrls);
-
-export { MainThreadUrls };

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

@@ -1,29 +0,0 @@
-import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
-import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
-import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
-import { MainThreadCustomEditors } from './mainThreadCustomEditors.js';
-import { MainThreadWebviewPanels } from './mainThreadWebviewPanels.js';
-import { MainThreadWebviews } from './mainThreadWebviews.js';
-import { MainThreadWebviewsViews } from './mainThreadWebviewViews.js';
-import { MainContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
-import { extHostCustomer } from '../../services/extensions/common/extHostCustomers.js';
-
-let MainThreadWebviewManager = class MainThreadWebviewManager extends Disposable {
-    constructor(context, instantiationService) {
-        super();
-        const webviews = this._register(instantiationService.createInstance(MainThreadWebviews, context));
-        context.set(MainContext.MainThreadWebviews, webviews);
-        const webviewPanels = this._register(instantiationService.createInstance(MainThreadWebviewPanels, context, webviews));
-        context.set(MainContext.MainThreadWebviewPanels, webviewPanels);
-        const customEditors = this._register(instantiationService.createInstance(MainThreadCustomEditors, context, webviews, webviewPanels));
-        context.set(MainContext.MainThreadCustomEditors, customEditors);
-        const webviewViews = this._register(instantiationService.createInstance(MainThreadWebviewsViews, context, webviews));
-        context.set(MainContext.MainThreadWebviewViews, webviewViews);
-    }
-};
-MainThreadWebviewManager = __decorate([
-    extHostCustomer,
-    ( __param(1, IInstantiationService))
-], MainThreadWebviewManager);
-
-export { MainThreadWebviewManager };