@codingame/monaco-vscode-remote-agent-service-override 3.2.3 → 4.1.0

package/vscode/src/vs/workbench/contrib/remote/browser/remoteStartEntry.contribution.js

@@ -1,6 +0,0 @@
-import { Registry } from 'vscode/vscode/vs/platform/registry/common/platform';
-import { Extensions } from 'vscode/vscode/vs/workbench/common/contributions';
-import { RemoteStartEntry } from './remoteStartEntry.js';
-
-( Registry.as(Extensions.Workbench))
-    .registerWorkbenchContribution(RemoteStartEntry, 3 );

package/vscode/src/vs/workbench/contrib/remote/browser/remoteStartEntry.js

@@ -1,97 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { localize2WithPath } from 'vscode/vscode/vs/nls';
-import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
-import { ICommandService } from 'vscode/vscode/vs/platform/commands/common/commands';
-import { IProductService } from 'vscode/vscode/vs/platform/product/common/productService';
-import { registerAction2, Action2 } from 'vscode/vscode/vs/platform/actions/common/actions';
-import { IExtensionManagementService } from 'vscode/vscode/vs/platform/extensionManagement/common/extensionManagement';
-import { ITelemetryService } from 'vscode/vscode/vs/platform/telemetry/common/telemetry';
-import { ExtensionIdentifier } from 'vscode/vscode/vs/platform/extensions/common/extensions';
-import { IWorkbenchExtensionEnablementService } from 'vscode/vscode/vs/workbench/services/extensionManagement/common/extensionManagement';
-import { RawContextKey, IContextKeyService } from 'vscode/vscode/vs/platform/contextkey/common/contextkey';
-
-var RemoteStartEntry_1;
-const showStartEntryInWeb = ( new RawContextKey('showRemoteStartEntryInWeb', false));
-let RemoteStartEntry = class RemoteStartEntry extends Disposable {
-    static { RemoteStartEntry_1 = this; }
-    static { this.REMOTE_WEB_START_ENTRY_ACTIONS_COMMAND_ID = 'workbench.action.remote.showWebStartEntryActions'; }
-    constructor(commandService, productService, extensionManagementService, extensionEnablementService, telemetryService, contextKeyService) {
-        super();
-        this.commandService = commandService;
-        this.productService = productService;
-        this.extensionManagementService = extensionManagementService;
-        this.extensionEnablementService = extensionEnablementService;
-        this.telemetryService = telemetryService;
-        this.contextKeyService = contextKeyService;
-        const remoteExtensionTips = this.productService.remoteExtensionTips?.['tunnel'];
-        this.startCommand = remoteExtensionTips?.startEntry?.startCommand ?? '';
-        this.remoteExtensionId = remoteExtensionTips?.extensionId ?? '';
-        this._init();
-        this.registerActions();
-        this.registerListeners();
-    }
-    registerActions() {
-        const category = ( localize2WithPath(
-            'vs/workbench/contrib/remote/browser/remoteStartEntry',
-            'remote.category',
-            "Remote"
-        ));
-        const startEntry = this;
-        registerAction2(class extends Action2 {
-            constructor() {
-                super({
-                    id: RemoteStartEntry_1.REMOTE_WEB_START_ENTRY_ACTIONS_COMMAND_ID,
-                    category,
-                    title: ( localize2WithPath(
-                        'vs/workbench/contrib/remote/browser/remoteStartEntry',
-                        'remote.showWebStartEntryActions',
-                        "Show Remote Start Entry for web"
-                    )),
-                    f1: false
-                });
-            }
-            async run() {
-                await startEntry.showWebRemoteStartActions();
-            }
-        });
-    }
-    registerListeners() {
-        this._register(this.extensionEnablementService.onEnablementChanged(async (result) => {
-            for (const ext of result) {
-                if (ExtensionIdentifier.equals(this.remoteExtensionId, ext.identifier.id)) {
-                    if (this.extensionEnablementService.isEnabled(ext)) {
-                        showStartEntryInWeb.bindTo(this.contextKeyService).set(true);
-                    }
-                    else {
-                        showStartEntryInWeb.bindTo(this.contextKeyService).set(false);
-                    }
-                }
-            }
-        }));
-    }
-    async _init() {
-        const installed = (await this.extensionManagementService.getInstalled()).find(value => ExtensionIdentifier.equals(value.identifier.id, this.remoteExtensionId));
-        if (installed) {
-            if (this.extensionEnablementService.isEnabled(installed)) {
-                showStartEntryInWeb.bindTo(this.contextKeyService).set(true);
-            }
-        }
-    }
-    async showWebRemoteStartActions() {
-        this.commandService.executeCommand(this.startCommand);
-        this.telemetryService.publicLog2('workbenchActionExecuted', {
-            id: this.startCommand,
-            from: 'remote start entry'
-        });
-    }
-};
-RemoteStartEntry = RemoteStartEntry_1 = ( __decorate([
-    ( __param(0, ICommandService)),
-    ( __param(1, IProductService)),
-    ( __param(2, IExtensionManagementService)),
-    ( __param(3, IWorkbenchExtensionEnablementService)),
-    ( __param(4, ITelemetryService)),
-    ( __param(5, IContextKeyService))
-], RemoteStartEntry));
-
-export { RemoteStartEntry, showStartEntryInWeb };

package/vscode/src/vs/workbench/contrib/remote/browser/showCandidate.js

@@ -1,35 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
-import { IBrowserWorkbenchEnvironmentService } from 'vscode/vscode/vs/workbench/services/environment/browser/environmentService';
-import { IRemoteExplorerService } from 'vscode/vscode/vs/workbench/services/remote/common/remoteExplorerService';
-
-let ShowCandidateContribution = class ShowCandidateContribution extends Disposable {
-    static { this.ID = 'workbench.contrib.showPortCandidate'; }
-    constructor(remoteExplorerService, environmentService) {
-        super();
-        const showPortCandidate = environmentService.options?.tunnelProvider?.showPortCandidate;
-        if (showPortCandidate) {
-            this._register(remoteExplorerService.setCandidateFilter(async (candidates) => {
-                const filters = await Promise.all(( candidates.map(
-                    candidate => showPortCandidate(candidate.host, candidate.port, candidate.detail ?? '')
-                )));
-                const filteredCandidates = [];
-                if (filters.length !== candidates.length) {
-                    return candidates;
-                }
-                for (let i = 0; i < candidates.length; i++) {
-                    if (filters[i]) {
-                        filteredCandidates.push(candidates[i]);
-                    }
-                }
-                return filteredCandidates;
-            }));
-        }
-    }
-};
-ShowCandidateContribution = ( __decorate([
-    ( __param(0, IRemoteExplorerService)),
-    ( __param(1, IBrowserWorkbenchEnvironmentService))
-], ShowCandidateContribution));
-
-export { ShowCandidateContribution };

package/vscode/src/vs/workbench/contrib/remote/browser/tunnelFactory.js

@@ -1,110 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { localizeWithPath } from 'vscode/vscode/vs/nls';
-import { TunnelPrivacyId, TunnelProtocol, ITunnelService } from 'vscode/vscode/vs/platform/tunnel/common/tunnel';
-import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
-import { IBrowserWorkbenchEnvironmentService } from 'vscode/vscode/vs/workbench/services/environment/browser/environmentService';
-import { IOpenerService } from 'vscode/vscode/vs/platform/opener/common/opener';
-import { URI } from 'vscode/vscode/vs/base/common/uri';
-import { IRemoteExplorerService } from 'vscode/vscode/vs/workbench/services/remote/common/remoteExplorerService';
-import { ILogService } from 'vscode/vscode/vs/platform/log/common/log';
-import { IContextKeyService } from 'vscode/vscode/vs/platform/contextkey/common/contextkey';
-import { forwardedPortsViewEnabled } from 'vscode/vscode/vs/workbench/services/remote/common/tunnelModel';
-
-let TunnelFactoryContribution = class TunnelFactoryContribution extends Disposable {
-    static { this.ID = 'workbench.contrib.tunnelFactory'; }
-    constructor(tunnelService, environmentService, openerService, remoteExplorerService, logService, contextKeyService) {
-        super();
-        this.openerService = openerService;
-        const tunnelFactory = environmentService.options?.tunnelProvider?.tunnelFactory;
-        if (tunnelFactory) {
-            contextKeyService.createKey(forwardedPortsViewEnabled.key, true);
-            let privacyOptions = environmentService.options?.tunnelProvider?.features?.privacyOptions ?? [];
-            if (environmentService.options?.tunnelProvider?.features?.public
-                && (privacyOptions.length === 0)) {
-                privacyOptions = [
-                    {
-                        id: 'private',
-                        label: ( localizeWithPath(
-                            'vs/workbench/contrib/remote/browser/tunnelFactory',
-                            'tunnelPrivacy.private',
-                            "Private"
-                        )),
-                        themeIcon: 'lock'
-                    },
-                    {
-                        id: 'public',
-                        label: ( localizeWithPath(
-                            'vs/workbench/contrib/remote/browser/tunnelFactory',
-                            'tunnelPrivacy.public',
-                            "Public"
-                        )),
-                        themeIcon: 'eye'
-                    }
-                ];
-            }
-            this._register(tunnelService.setTunnelProvider({
-                forwardPort: async (tunnelOptions, tunnelCreationOptions) => {
-                    let tunnelPromise;
-                    try {
-                        tunnelPromise = tunnelFactory(tunnelOptions, tunnelCreationOptions);
-                    }
-                    catch (e) {
-                        logService.trace('tunnelFactory: tunnel provider error');
-                    }
-                    if (!tunnelPromise) {
-                        return undefined;
-                    }
-                    let tunnel;
-                    try {
-                        tunnel = await tunnelPromise;
-                    }
-                    catch (e) {
-                        logService.trace('tunnelFactory: tunnel provider promise error');
-                        if (e instanceof Error) {
-                            return e.message;
-                        }
-                        return undefined;
-                    }
-                    const localAddress = tunnel.localAddress.startsWith('http') ? tunnel.localAddress : `http://${tunnel.localAddress}`;
-                    const remoteTunnel = {
-                        tunnelRemotePort: tunnel.remoteAddress.port,
-                        tunnelRemoteHost: tunnel.remoteAddress.host,
-                        localAddress: await this.resolveExternalUri(localAddress),
-                        privacy: tunnel.privacy ?? (tunnel.public ? TunnelPrivacyId.Public : TunnelPrivacyId.Private),
-                        protocol: tunnel.protocol ?? TunnelProtocol.Http,
-                        dispose: async () => { await tunnel.dispose(); }
-                    };
-                    return remoteTunnel;
-                }
-            }));
-            const tunnelInformation = environmentService.options?.tunnelProvider?.features ?
-                {
-                    features: {
-                        elevation: !!environmentService.options?.tunnelProvider?.features?.elevation,
-                        public: !!environmentService.options?.tunnelProvider?.features?.public,
-                        privacyOptions,
-                        protocol: environmentService.options?.tunnelProvider?.features?.protocol === undefined ? true : !!environmentService.options?.tunnelProvider?.features?.protocol
-                    }
-                } : undefined;
-            remoteExplorerService.setTunnelInformation(tunnelInformation);
-        }
-    }
-    async resolveExternalUri(uri) {
-        try {
-            return ( (await this.openerService.resolveExternalUri(( URI.parse(uri)))).resolved.toString());
-        }
-        catch {
-            return uri;
-        }
-    }
-};
-TunnelFactoryContribution = ( __decorate([
-    ( __param(0, ITunnelService)),
-    ( __param(1, IBrowserWorkbenchEnvironmentService)),
-    ( __param(2, IOpenerService)),
-    ( __param(3, IRemoteExplorerService)),
-    ( __param(4, ILogService)),
-    ( __param(5, IContextKeyService))
-], TunnelFactoryContribution));
-
-export { TunnelFactoryContribution };