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

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

@@ -1,831 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import './media/remoteViewlet.css.js';
-import { localize2WithPath, localizeWithPath } from 'vscode/vscode/vs/nls';
-import { append, $, disposableWindowInterval } from 'vscode/vscode/vs/base/browser/dom';
-import { URI } from 'vscode/vscode/vs/base/common/uri';
-import { IWorkbenchLayoutService } from 'vscode/vscode/vs/workbench/services/layout/browser/layoutService';
-import { ITelemetryService } from 'vscode/vscode/vs/platform/telemetry/common/telemetry';
-import { IWorkspaceContextService } from 'vscode/vscode/vs/platform/workspace/common/workspace';
-import { IStorageService } from 'vscode/vscode/vs/platform/storage/common/storage';
-import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration';
-import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
-import { IThemeService } from 'vscode/vscode/vs/platform/theme/common/themeService';
-import { ThemeIcon } from 'vscode/vscode/vs/base/common/themables';
-import { IContextMenuService } from 'vscode/vscode/vs/platform/contextview/browser/contextView';
-import { isProposedApiEnabled, IExtensionService } from 'vscode/vscode/vs/workbench/services/extensions/common/extensions';
-import { FilterViewPaneContainer } from 'vscode/vscode/vs/workbench/browser/parts/views/viewsViewlet';
-import { VIEWLET_ID } from 'vscode/vscode/vs/workbench/contrib/remote/browser/remoteExplorer';
-import { IContextKeyService } from 'vscode/vscode/vs/platform/contextkey/common/contextkey';
-import { Extensions, IViewDescriptorService } from 'vscode/vscode/vs/workbench/common/views';
-import { Registry } from 'vscode/vscode/vs/platform/registry/common/platform';
-import { IOpenerService } from 'vscode/vscode/vs/platform/opener/common/opener';
-import { IQuickInputService } from 'vscode/vscode/vs/platform/quickinput/common/quickInput';
-import { ICommandService } from 'vscode/vscode/vs/platform/commands/common/commands';
-import { IProgressService } from 'vscode/vscode/vs/platform/progress/common/progress';
-import { IRemoteAgentService } from 'vscode/vscode/vs/workbench/services/remote/common/remoteAgentService';
-import '../../../../../../../override/vs/platform/dialogs/common/dialogs.js';
-import Severity from 'vscode/vscode/vs/base/common/severity';
-import { ReloadWindowAction } from 'vscode/vscode/vs/workbench/browser/actions/windowActions';
-import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
-import { SwitchRemoteViewItem } from './explorerViewItems.js';
-import { isStringArray } from 'vscode/vscode/vs/base/common/types';
-import { IRemoteExplorerService } from 'vscode/vscode/vs/workbench/services/remote/common/remoteExplorerService';
-import { IWorkbenchEnvironmentService } from 'vscode/vscode/vs/workbench/services/environment/common/environmentService';
-import { ViewPane } from 'vscode/vscode/vs/workbench/browser/parts/views/viewPane';
-import { WorkbenchAsyncDataTree } from 'vscode/vscode/vs/platform/list/browser/listService';
-import { IKeybindingService } from 'vscode/vscode/vs/platform/keybinding/common/keybinding';
-import { Event, Emitter } from 'vscode/vscode/vs/base/common/event';
-import { SyncDescriptor } from 'vscode/vscode/vs/platform/instantiation/common/descriptors';
-import { remoteExplorerViewIcon, getStartedIcon, documentationIcon, reviewIssuesIcon, reportIssuesIcon } from 'vscode/vscode/vs/workbench/contrib/remote/browser/remoteIcons';
-import { ILogService } from 'vscode/vscode/vs/platform/log/common/log';
-import { ITimerService } from 'vscode/vscode/vs/workbench/services/timer/browser/timerService';
-import { getRemoteName } from 'vscode/vscode/vs/platform/remote/common/remoteHosts';
-import { getVirtualWorkspaceLocation } from 'vscode/vscode/vs/platform/workspace/common/virtualWorkspace';
-import { IWalkthroughsService } from 'vscode/vscode/vs/workbench/contrib/welcomeGettingStarted/browser/gettingStartedService';
-import { Schemas } from 'vscode/vscode/vs/base/common/network';
-import { mainWindow } from 'vscode/vscode/vs/base/browser/window';
-import { IDialogService } from 'vscode/vscode/vs/platform/dialogs/common/dialogs';
-
-class HelpTreeVirtualDelegate {
-    getHeight(element) {
-        return 22;
-    }
-    getTemplateId(element) {
-        return 'HelpItemTemplate';
-    }
-}
-class HelpTreeRenderer {
-    constructor() {
-        this.templateId = 'HelpItemTemplate';
-    }
-    renderTemplate(container) {
-        container.classList.add('remote-help-tree-node-item');
-        const icon = append(container, $('.remote-help-tree-node-item-icon'));
-        const parent = container;
-        return { parent, icon };
-    }
-    renderElement(element, index, templateData, height) {
-        const container = templateData.parent;
-        append(container, templateData.icon);
-        templateData.icon.classList.add(...element.element.iconClasses);
-        const labelContainer = append(container, $('.help-item-label'));
-        labelContainer.innerText = element.element.label;
-    }
-    disposeTemplate(templateData) {
-    }
-}
-class HelpDataSource {
-    hasChildren(element) {
-        return element instanceof HelpModel;
-    }
-    getChildren(element) {
-        if (element instanceof HelpModel && element.items) {
-            return element.items;
-        }
-        return [];
-    }
-}
-class HelpModel {
-    constructor(viewModel, openerService, quickInputService, commandService, remoteExplorerService, environmentService, workspaceContextService, walkthroughsService) {
-        this.viewModel = viewModel;
-        this.openerService = openerService;
-        this.quickInputService = quickInputService;
-        this.commandService = commandService;
-        this.remoteExplorerService = remoteExplorerService;
-        this.environmentService = environmentService;
-        this.workspaceContextService = workspaceContextService;
-        this.walkthroughsService = walkthroughsService;
-        this.updateItems();
-        viewModel.onDidChangeHelpInformation(() => this.updateItems());
-    }
-    createHelpItemValue(info, infoKey) {
-        return ( new HelpItemValue(
-            this.commandService,
-            this.walkthroughsService,
-            info.extensionDescription,
-            (typeof info.remoteName === 'string') ? [info.remoteName] : info.remoteName,
-            info.virtualWorkspace,
-            info[infoKey]
-        ));
-    }
-    updateItems() {
-        const helpItems = [];
-        const getStarted = this.viewModel.helpInformation.filter(info => info.getStarted);
-        if (getStarted.length) {
-            const helpItemValues = ( getStarted.map((info) => this.createHelpItemValue(info, 'getStarted')));
-            const getStartedHelpItem = this.items?.find(item => item.icon === getStartedIcon) ?? ( new GetStartedHelpItem(getStartedIcon, ( localizeWithPath(
-                'vs/workbench/contrib/remote/browser/remote',
-                'remote.help.getStarted',
-                "Get Started"
-            )), helpItemValues, this.quickInputService, this.environmentService, this.openerService, this.remoteExplorerService, this.workspaceContextService, this.commandService));
-            getStartedHelpItem.values = helpItemValues;
-            helpItems.push(getStartedHelpItem);
-        }
-        const documentation = this.viewModel.helpInformation.filter(info => info.documentation);
-        if (documentation.length) {
-            const helpItemValues = ( documentation.map((info) => this.createHelpItemValue(info, 'documentation')));
-            const documentationHelpItem = this.items?.find(item => item.icon === documentationIcon) ?? ( new HelpItem(documentationIcon, ( localizeWithPath(
-                'vs/workbench/contrib/remote/browser/remote',
-                'remote.help.documentation',
-                "Read Documentation"
-            )), helpItemValues, this.quickInputService, this.environmentService, this.openerService, this.remoteExplorerService, this.workspaceContextService));
-            documentationHelpItem.values = helpItemValues;
-            helpItems.push(documentationHelpItem);
-        }
-        const issues = this.viewModel.helpInformation.filter(info => info.issues);
-        if (issues.length) {
-            const helpItemValues = ( issues.map((info) => this.createHelpItemValue(info, 'issues')));
-            const reviewIssuesHelpItem = this.items?.find(item => item.icon === reviewIssuesIcon) ?? ( new HelpItem(reviewIssuesIcon, ( localizeWithPath(
-                'vs/workbench/contrib/remote/browser/remote',
-                'remote.help.issues',
-                "Review Issues"
-            )), helpItemValues, this.quickInputService, this.environmentService, this.openerService, this.remoteExplorerService, this.workspaceContextService));
-            reviewIssuesHelpItem.values = helpItemValues;
-            helpItems.push(reviewIssuesHelpItem);
-        }
-        if (helpItems.length) {
-            const helpItemValues = ( this.viewModel.helpInformation.map(info => this.createHelpItemValue(info, 'reportIssue')));
-            const issueReporterItem = this.items?.find(item => item.icon === reportIssuesIcon) ?? ( new IssueReporterItem(reportIssuesIcon, ( localizeWithPath(
-                'vs/workbench/contrib/remote/browser/remote',
-                'remote.help.report',
-                "Report Issue"
-            )), helpItemValues, this.quickInputService, this.environmentService, this.commandService, this.openerService, this.remoteExplorerService, this.workspaceContextService));
-            issueReporterItem.values = helpItemValues;
-            helpItems.push(issueReporterItem);
-        }
-        if (helpItems.length) {
-            this.items = helpItems;
-        }
-    }
-}
-class HelpItemValue {
-    constructor(commandService, walkthroughService, extensionDescription, remoteAuthority, virtualWorkspace, urlOrCommandOrId) {
-        this.commandService = commandService;
-        this.walkthroughService = walkthroughService;
-        this.extensionDescription = extensionDescription;
-        this.remoteAuthority = remoteAuthority;
-        this.virtualWorkspace = virtualWorkspace;
-        this.urlOrCommandOrId = urlOrCommandOrId;
-    }
-    get description() {
-        return this.getUrl().then(() => this._description);
-    }
-    get url() {
-        return this.getUrl();
-    }
-    async getUrl() {
-        if (this._url === undefined) {
-            if (typeof this.urlOrCommandOrId === 'string') {
-                const url = ( URI.parse(this.urlOrCommandOrId));
-                if (url.authority) {
-                    this._url = this.urlOrCommandOrId;
-                }
-                else {
-                    const urlCommand = this.commandService.executeCommand(this.urlOrCommandOrId).then((result) => {
-                        this._url = result;
-                        return this._url;
-                    });
-                    const emptyString = ( new Promise(resolve => setTimeout(() => resolve(''), 500)));
-                    this._url = await Promise.race([urlCommand, emptyString]);
-                }
-            }
-            else if (this.urlOrCommandOrId?.id) {
-                try {
-                    const walkthroughId = `${this.extensionDescription.id}#${this.urlOrCommandOrId.id}`;
-                    const walkthrough = await this.walkthroughService.getWalkthrough(walkthroughId);
-                    this._description = walkthrough.title;
-                    this._url = walkthroughId;
-                }
-                catch { }
-            }
-        }
-        if (this._url === undefined) {
-            this._url = '';
-        }
-        return this._url;
-    }
-}
-class HelpItemBase {
-    constructor(icon, label, values, quickInputService, environmentService, remoteExplorerService, workspaceContextService) {
-        this.icon = icon;
-        this.label = label;
-        this.values = values;
-        this.quickInputService = quickInputService;
-        this.environmentService = environmentService;
-        this.remoteExplorerService = remoteExplorerService;
-        this.workspaceContextService = workspaceContextService;
-        this.iconClasses = [];
-        this.iconClasses.push(...ThemeIcon.asClassNameArray(icon));
-        this.iconClasses.push('remote-help-tree-node-item-icon');
-    }
-    async getActions() {
-        return (await Promise.all(( this.values.map(async (value) => {
-            return {
-                label: value.extensionDescription.displayName || value.extensionDescription.identifier.value,
-                description: (await value.description) ?? (await value.url),
-                url: await value.url,
-                extensionDescription: value.extensionDescription
-            };
-        })))).filter(item => item.description);
-    }
-    async handleClick() {
-        const remoteAuthority = this.environmentService.remoteAuthority;
-        if (remoteAuthority) {
-            for (let i = 0; i < this.remoteExplorerService.targetType.length; i++) {
-                if (remoteAuthority.startsWith(this.remoteExplorerService.targetType[i])) {
-                    for (const value of this.values) {
-                        if (value.remoteAuthority) {
-                            for (const authority of value.remoteAuthority) {
-                                if (remoteAuthority.startsWith(authority)) {
-                                    await this.takeAction(value.extensionDescription, await value.url);
-                                    return;
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-        }
-        else {
-            const virtualWorkspace = getVirtualWorkspaceLocation(this.workspaceContextService.getWorkspace())?.scheme;
-            if (virtualWorkspace) {
-                for (let i = 0; i < this.remoteExplorerService.targetType.length; i++) {
-                    for (const value of this.values) {
-                        if (value.virtualWorkspace && value.remoteAuthority) {
-                            for (const authority of value.remoteAuthority) {
-                                if (this.remoteExplorerService.targetType[i].startsWith(authority) && virtualWorkspace.startsWith(value.virtualWorkspace)) {
-                                    await this.takeAction(value.extensionDescription, await value.url);
-                                    return;
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-        }
-        if (this.values.length > 1) {
-            const actions = await this.getActions();
-            if (actions.length) {
-                const action = await this.quickInputService.pick(actions, { placeHolder: ( localizeWithPath(
-                    'vs/workbench/contrib/remote/browser/remote',
-                    'pickRemoteExtension',
-                    "Select url to open"
-                )) });
-                if (action) {
-                    await this.takeAction(action.extensionDescription, action.url);
-                }
-            }
-        }
-        else {
-            await this.takeAction(this.values[0].extensionDescription, await this.values[0].url);
-        }
-    }
-}
-class GetStartedHelpItem extends HelpItemBase {
-    constructor(icon, label, values, quickInputService, environmentService, openerService, remoteExplorerService, workspaceContextService, commandService) {
-        super(icon, label, values, quickInputService, environmentService, remoteExplorerService, workspaceContextService);
-        this.openerService = openerService;
-        this.commandService = commandService;
-    }
-    async takeAction(extensionDescription, urlOrWalkthroughId) {
-        if ([Schemas.http, Schemas.https].includes(( URI.parse(urlOrWalkthroughId)).scheme)) {
-            this.openerService.open(urlOrWalkthroughId, { allowCommands: true });
-            return;
-        }
-        this.commandService.executeCommand('workbench.action.openWalkthrough', urlOrWalkthroughId);
-    }
-}
-class HelpItem extends HelpItemBase {
-    constructor(icon, label, values, quickInputService, environmentService, openerService, remoteExplorerService, workspaceContextService) {
-        super(icon, label, values, quickInputService, environmentService, remoteExplorerService, workspaceContextService);
-        this.openerService = openerService;
-    }
-    async takeAction(extensionDescription, url) {
-        await this.openerService.open(( URI.parse(url)), { allowCommands: true });
-    }
-}
-class IssueReporterItem extends HelpItemBase {
-    constructor(icon, label, values, quickInputService, environmentService, commandService, openerService, remoteExplorerService, workspaceContextService) {
-        super(icon, label, values, quickInputService, environmentService, remoteExplorerService, workspaceContextService);
-        this.commandService = commandService;
-        this.openerService = openerService;
-    }
-    async getActions() {
-        return Promise.all(( this.values.map(async (value) => {
-            return {
-                label: value.extensionDescription.displayName || value.extensionDescription.identifier.value,
-                description: '',
-                url: await value.url,
-                extensionDescription: value.extensionDescription
-            };
-        })));
-    }
-    async takeAction(extensionDescription, url) {
-        if (!url) {
-            await this.commandService.executeCommand('workbench.action.openIssueReporter', [extensionDescription.identifier.value]);
-        }
-        else {
-            await this.openerService.open(( URI.parse(url)));
-        }
-    }
-}
-let HelpPanel = class HelpPanel extends ViewPane {
-    static { this.ID = '~remote.helpPanel'; }
-    static { this.TITLE = ( localize2WithPath(
-        'vs/workbench/contrib/remote/browser/remote',
-        'remote.help',
-        "Help and feedback"
-    )); }
-    constructor(viewModel, options, keybindingService, contextMenuService, contextKeyService, configurationService, instantiationService, viewDescriptorService, openerService, quickInputService, commandService, remoteExplorerService, environmentService, themeService, telemetryService, workspaceContextService, walkthroughsService) {
-        super(options, keybindingService, contextMenuService, configurationService, contextKeyService, viewDescriptorService, instantiationService, openerService, themeService, telemetryService);
-        this.viewModel = viewModel;
-        this.quickInputService = quickInputService;
-        this.commandService = commandService;
-        this.remoteExplorerService = remoteExplorerService;
-        this.environmentService = environmentService;
-        this.workspaceContextService = workspaceContextService;
-        this.walkthroughsService = walkthroughsService;
-    }
-    renderBody(container) {
-        super.renderBody(container);
-        container.classList.add('remote-help');
-        const treeContainer = document.createElement('div');
-        treeContainer.classList.add('remote-help-content');
-        container.appendChild(treeContainer);
-        this.tree = this.instantiationService.createInstance(WorkbenchAsyncDataTree, 'RemoteHelp', treeContainer, ( new HelpTreeVirtualDelegate()), [( new HelpTreeRenderer())], ( new HelpDataSource()), {
-            accessibilityProvider: {
-                getAriaLabel: (item) => {
-                    return item.label;
-                },
-                getWidgetAriaLabel: () => ( localizeWithPath('vs/workbench/contrib/remote/browser/remote', 'remotehelp', "Remote Help"))
-            }
-        });
-        const model = ( new HelpModel(
-            this.viewModel,
-            this.openerService,
-            this.quickInputService,
-            this.commandService,
-            this.remoteExplorerService,
-            this.environmentService,
-            this.workspaceContextService,
-            this.walkthroughsService
-        ));
-        this.tree.setInput(model);
-        this._register(Event.debounce(this.tree.onDidOpen, (last, event) => event, 75, true)(e => {
-            e.element?.handleClick();
-        }));
-    }
-    layoutBody(height, width) {
-        super.layoutBody(height, width);
-        this.tree.layout(height, width);
-    }
-};
-HelpPanel = ( __decorate([
-    ( __param(2, IKeybindingService)),
-    ( __param(3, IContextMenuService)),
-    ( __param(4, IContextKeyService)),
-    ( __param(5, IConfigurationService)),
-    ( __param(6, IInstantiationService)),
-    ( __param(7, IViewDescriptorService)),
-    ( __param(8, IOpenerService)),
-    ( __param(9, IQuickInputService)),
-    ( __param(10, ICommandService)),
-    ( __param(11, IRemoteExplorerService)),
-    ( __param(12, IWorkbenchEnvironmentService)),
-    ( __param(13, IThemeService)),
-    ( __param(14, ITelemetryService)),
-    ( __param(15, IWorkspaceContextService)),
-    ( __param(16, IWalkthroughsService))
-], HelpPanel));
-class HelpPanelDescriptor {
-    constructor(viewModel) {
-        this.id = HelpPanel.ID;
-        this.name = HelpPanel.TITLE;
-        this.canToggleVisibility = true;
-        this.hideByDefault = false;
-        this.group = 'help@50';
-        this.order = -10;
-        this.ctorDescriptor = ( new SyncDescriptor(HelpPanel, [viewModel]));
-    }
-}
-let RemoteViewPaneContainer = class RemoteViewPaneContainer extends FilterViewPaneContainer {
-    constructor(layoutService, telemetryService, contextService, storageService, configurationService, instantiationService, themeService, contextMenuService, extensionService, remoteExplorerService, viewDescriptorService) {
-        super(VIEWLET_ID, remoteExplorerService.onDidChangeTargetType, configurationService, layoutService, telemetryService, storageService, instantiationService, themeService, contextMenuService, extensionService, contextService, viewDescriptorService);
-        this.remoteExplorerService = remoteExplorerService;
-        this.helpPanelDescriptor = ( new HelpPanelDescriptor(this));
-        this.helpInformation = [];
-        this._onDidChangeHelpInformation = ( new Emitter());
-        this.onDidChangeHelpInformation = this._onDidChangeHelpInformation.event;
-        this.hasRegisteredHelpView = false;
-        this.addConstantViewDescriptors([this.helpPanelDescriptor]);
-        this._register(this.remoteSwitcher = this.instantiationService.createInstance(SwitchRemoteViewItem));
-        this.remoteExplorerService.onDidChangeHelpInformation(extensions => {
-            this._setHelpInformation(extensions);
-        });
-        this._setHelpInformation(this.remoteExplorerService.helpInformation);
-        const viewsRegistry = ( Registry.as(Extensions.ViewsRegistry));
-        this.remoteSwitcher.createOptionItems(viewsRegistry.getViews(this.viewContainer));
-        this._register(viewsRegistry.onViewsRegistered(e => {
-            const remoteViews = [];
-            for (const view of e) {
-                if (view.viewContainer.id === VIEWLET_ID) {
-                    remoteViews.push(...view.views);
-                }
-            }
-            if (remoteViews.length > 0) {
-                this.remoteSwitcher.createOptionItems(remoteViews);
-            }
-        }));
-        this._register(viewsRegistry.onViewsDeregistered(e => {
-            if (e.viewContainer.id === VIEWLET_ID) {
-                this.remoteSwitcher.removeOptionItems(e.views);
-            }
-        }));
-    }
-    _setHelpInformation(extensions) {
-        const helpInformation = [];
-        for (const extension of extensions) {
-            this._handleRemoteInfoExtensionPoint(extension, helpInformation);
-        }
-        this.helpInformation = helpInformation;
-        this._onDidChangeHelpInformation.fire();
-        const viewsRegistry = ( Registry.as(Extensions.ViewsRegistry));
-        if (this.helpInformation.length && !this.hasRegisteredHelpView) {
-            const view = viewsRegistry.getView(this.helpPanelDescriptor.id);
-            if (!view) {
-                viewsRegistry.registerViews([this.helpPanelDescriptor], this.viewContainer);
-            }
-            this.hasRegisteredHelpView = true;
-        }
-        else if (this.hasRegisteredHelpView) {
-            viewsRegistry.deregisterViews([this.helpPanelDescriptor], this.viewContainer);
-            this.hasRegisteredHelpView = false;
-        }
-    }
-    _handleRemoteInfoExtensionPoint(extension, helpInformation) {
-        if (!isProposedApiEnabled(extension.description, 'contribRemoteHelp')) {
-            return;
-        }
-        if (!extension.value.documentation && !extension.value.getStarted && !extension.value.issues) {
-            return;
-        }
-        helpInformation.push({
-            extensionDescription: extension.description,
-            getStarted: extension.value.getStarted,
-            documentation: extension.value.documentation,
-            reportIssue: extension.value.reportIssue,
-            issues: extension.value.issues,
-            remoteName: extension.value.remoteName,
-            virtualWorkspace: extension.value.virtualWorkspace
-        });
-    }
-    getFilterOn(viewDescriptor) {
-        return isStringArray(viewDescriptor.remoteAuthority) ? viewDescriptor.remoteAuthority[0] : viewDescriptor.remoteAuthority;
-    }
-    setFilter(viewDescriptor) {
-        this.remoteExplorerService.targetType = isStringArray(viewDescriptor.remoteAuthority) ? viewDescriptor.remoteAuthority : [viewDescriptor.remoteAuthority];
-    }
-    getTitle() {
-        const title = ( localizeWithPath(
-            'vs/workbench/contrib/remote/browser/remote',
-            'remote.explorer',
-            "Remote Explorer"
-        ));
-        return title;
-    }
-};
-RemoteViewPaneContainer = ( __decorate([
-    ( __param(0, IWorkbenchLayoutService)),
-    ( __param(1, ITelemetryService)),
-    ( __param(2, IWorkspaceContextService)),
-    ( __param(3, IStorageService)),
-    ( __param(4, IConfigurationService)),
-    ( __param(5, IInstantiationService)),
-    ( __param(6, IThemeService)),
-    ( __param(7, IContextMenuService)),
-    ( __param(8, IExtensionService)),
-    ( __param(9, IRemoteExplorerService)),
-    ( __param(10, IViewDescriptorService))
-], RemoteViewPaneContainer));
-( Registry.as(Extensions.ViewContainersRegistry)).registerViewContainer({
-    id: VIEWLET_ID,
-    title: ( localize2WithPath(
-        'vs/workbench/contrib/remote/browser/remote',
-        'remote.explorer',
-        "Remote Explorer"
-    )),
-    ctorDescriptor: ( new SyncDescriptor(RemoteViewPaneContainer)),
-    hideIfEmpty: true,
-    viewOrderDelegate: {
-        getOrder: (group) => {
-            if (!group) {
-                return;
-            }
-            let matches = /^targets@(\d+)$/.exec(group);
-            if (matches) {
-                return -1000;
-            }
-            matches = /^details(@(\d+))?$/.exec(group);
-            if (matches) {
-                return -500 + Number(matches[2]);
-            }
-            matches = /^help(@(\d+))?$/.exec(group);
-            if (matches) {
-                return -10;
-            }
-            return;
-        }
-    },
-    icon: remoteExplorerViewIcon,
-    order: 4
-}, 0 );
-let RemoteMarkers = class RemoteMarkers {
-    constructor(remoteAgentService, timerService) {
-        remoteAgentService.getEnvironment().then(remoteEnv => {
-            if (remoteEnv) {
-                timerService.setPerformanceMarks('server', remoteEnv.marks);
-            }
-        });
-    }
-};
-RemoteMarkers = ( __decorate([
-    ( __param(0, IRemoteAgentService)),
-    ( __param(1, ITimerService))
-], RemoteMarkers));
-class VisibleProgress {
-    get lastReport() {
-        return this._lastReport;
-    }
-    constructor(progressService, location, initialReport, buttons, onDidCancel) {
-        this.location = location;
-        this._isDisposed = false;
-        this._lastReport = initialReport;
-        this._currentProgressPromiseResolve = null;
-        this._currentProgress = null;
-        this._currentTimer = null;
-        const promise = ( new Promise((resolve) => this._currentProgressPromiseResolve = resolve));
-        progressService.withProgress({ location: location, buttons: buttons }, (progress) => { if (!this._isDisposed) {
-            this._currentProgress = progress;
-        } return promise; }, (choice) => onDidCancel(choice, this._lastReport));
-        if (this._lastReport) {
-            this.report();
-        }
-    }
-    dispose() {
-        this._isDisposed = true;
-        if (this._currentProgressPromiseResolve) {
-            this._currentProgressPromiseResolve();
-            this._currentProgressPromiseResolve = null;
-        }
-        this._currentProgress = null;
-        if (this._currentTimer) {
-            this._currentTimer.dispose();
-            this._currentTimer = null;
-        }
-    }
-    report(message) {
-        if (message) {
-            this._lastReport = message;
-        }
-        if (this._lastReport && this._currentProgress) {
-            this._currentProgress.report({ message: this._lastReport });
-        }
-    }
-    startTimer(completionTime) {
-        this.stopTimer();
-        this._currentTimer = ( new ReconnectionTimer(this, completionTime));
-    }
-    stopTimer() {
-        if (this._currentTimer) {
-            this._currentTimer.dispose();
-            this._currentTimer = null;
-        }
-    }
-}
-class ReconnectionTimer {
-    constructor(parent, completionTime) {
-        this._parent = parent;
-        this._completionTime = completionTime;
-        this._renderInterval = disposableWindowInterval(mainWindow, () => this._render(), 1000);
-        this._render();
-    }
-    dispose() {
-        this._renderInterval.dispose();
-    }
-    _render() {
-        const remainingTimeMs = this._completionTime - Date.now();
-        if (remainingTimeMs < 0) {
-            return;
-        }
-        const remainingTime = Math.ceil(remainingTimeMs / 1000);
-        if (remainingTime === 1) {
-            this._parent.report(( localizeWithPath(
-                'vs/workbench/contrib/remote/browser/remote',
-                'reconnectionWaitOne',
-                "Attempting to reconnect in {0} second...",
-                remainingTime
-            )));
-        }
-        else {
-            this._parent.report(( localizeWithPath(
-                'vs/workbench/contrib/remote/browser/remote',
-                'reconnectionWaitMany',
-                "Attempting to reconnect in {0} seconds...",
-                remainingTime
-            )));
-        }
-    }
-}
-const DISCONNECT_PROMPT_TIME = 40 * 1000;
-let RemoteAgentConnectionStatusListener = class RemoteAgentConnectionStatusListener extends Disposable {
-    constructor(remoteAgentService, progressService, dialogService, commandService, quickInputService, logService, environmentService, telemetryService) {
-        super();
-        this._reloadWindowShown = false;
-        const connection = remoteAgentService.getConnection();
-        if (connection) {
-            let quickInputVisible = false;
-            quickInputService.onShow(() => quickInputVisible = true);
-            quickInputService.onHide(() => quickInputVisible = false);
-            let visibleProgress = null;
-            let reconnectWaitEvent = null;
-            let disposableListener = null;
-            function showProgress(location, buttons, initialReport = null) {
-                if (visibleProgress) {
-                    visibleProgress.dispose();
-                    visibleProgress = null;
-                }
-                if (!location) {
-                    location = quickInputVisible ? 15  : 20 ;
-                }
-                return ( new VisibleProgress(progressService, location, initialReport, ( buttons.map(button => button.label)), (choice, lastReport) => {
-                    if (typeof choice !== 'undefined' && buttons[choice]) {
-                        buttons[choice].callback();
-                    }
-                    else {
-                        if (location === 20 ) {
-                            visibleProgress = showProgress(15 , buttons, lastReport);
-                        }
-                        else {
-                            hideProgress();
-                        }
-                    }
-                }));
-            }
-            function hideProgress() {
-                if (visibleProgress) {
-                    visibleProgress.dispose();
-                    visibleProgress = null;
-                }
-            }
-            let reconnectionToken = '';
-            let lastIncomingDataTime = 0;
-            let reconnectionAttempts = 0;
-            const reconnectButton = {
-                label: ( localizeWithPath(
-                    'vs/workbench/contrib/remote/browser/remote',
-                    'reconnectNow',
-                    "Reconnect Now"
-                )),
-                callback: () => {
-                    reconnectWaitEvent?.skipWait();
-                }
-            };
-            const reloadButton = {
-                label: ( localizeWithPath(
-                    'vs/workbench/contrib/remote/browser/remote',
-                    'reloadWindow',
-                    "Reload Window"
-                )),
-                callback: () => {
-                    telemetryService.publicLog2('remoteReconnectionReload', {
-                        remoteName: getRemoteName(environmentService.remoteAuthority),
-                        reconnectionToken: reconnectionToken,
-                        millisSinceLastIncomingData: Date.now() - lastIncomingDataTime,
-                        attempt: reconnectionAttempts
-                    });
-                    commandService.executeCommand(ReloadWindowAction.ID);
-                }
-            };
-            connection.onDidStateChange((e) => {
-                visibleProgress?.stopTimer();
-                if (disposableListener) {
-                    disposableListener.dispose();
-                    disposableListener = null;
-                }
-                switch (e.type) {
-                    case 0 :
-                        reconnectionToken = e.reconnectionToken;
-                        lastIncomingDataTime = Date.now() - e.millisSinceLastIncomingData;
-                        reconnectionAttempts = 0;
-                        telemetryService.publicLog2('remoteConnectionLost', {
-                            remoteName: getRemoteName(environmentService.remoteAuthority),
-                            reconnectionToken: e.reconnectionToken,
-                        });
-                        if (visibleProgress || e.millisSinceLastIncomingData > DISCONNECT_PROMPT_TIME) {
-                            if (!visibleProgress) {
-                                visibleProgress = showProgress(null, [reconnectButton, reloadButton]);
-                            }
-                            visibleProgress.report(( localizeWithPath(
-                                'vs/workbench/contrib/remote/browser/remote',
-                                'connectionLost',
-                                "Connection Lost"
-                            )));
-                        }
-                        break;
-                    case 1 :
-                        if (visibleProgress) {
-                            reconnectWaitEvent = e;
-                            visibleProgress = showProgress(null, [reconnectButton, reloadButton]);
-                            visibleProgress.startTimer(Date.now() + 1000 * e.durationSeconds);
-                        }
-                        break;
-                    case 2 :
-                        reconnectionToken = e.reconnectionToken;
-                        lastIncomingDataTime = Date.now() - e.millisSinceLastIncomingData;
-                        reconnectionAttempts = e.attempt;
-                        telemetryService.publicLog2('remoteReconnectionRunning', {
-                            remoteName: getRemoteName(environmentService.remoteAuthority),
-                            reconnectionToken: e.reconnectionToken,
-                            millisSinceLastIncomingData: e.millisSinceLastIncomingData,
-                            attempt: e.attempt
-                        });
-                        if (visibleProgress || e.millisSinceLastIncomingData > DISCONNECT_PROMPT_TIME) {
-                            visibleProgress = showProgress(null, [reloadButton]);
-                            visibleProgress.report(( localizeWithPath(
-                                'vs/workbench/contrib/remote/browser/remote',
-                                'reconnectionRunning',
-                                "Disconnected. Attempting to reconnect..."
-                            )));
-                            disposableListener = quickInputService.onShow(() => {
-                                if (visibleProgress && visibleProgress.location === 20 ) {
-                                    visibleProgress = showProgress(15 , [reloadButton], visibleProgress.lastReport);
-                                }
-                            });
-                        }
-                        break;
-                    case 3 :
-                        reconnectionToken = e.reconnectionToken;
-                        lastIncomingDataTime = Date.now() - e.millisSinceLastIncomingData;
-                        reconnectionAttempts = e.attempt;
-                        telemetryService.publicLog2('remoteReconnectionPermanentFailure', {
-                            remoteName: getRemoteName(environmentService.remoteAuthority),
-                            reconnectionToken: e.reconnectionToken,
-                            millisSinceLastIncomingData: e.millisSinceLastIncomingData,
-                            attempt: e.attempt,
-                            handled: e.handled
-                        });
-                        hideProgress();
-                        if (e.handled) {
-                            logService.info(`Error handled: Not showing a notification for the error.`);
-                            console.log(`Error handled: Not showing a notification for the error.`);
-                        }
-                        else if (!this._reloadWindowShown) {
-                            this._reloadWindowShown = true;
-                            dialogService.confirm({
-                                type: Severity.Error,
-                                message: ( localizeWithPath(
-                                    'vs/workbench/contrib/remote/browser/remote',
-                                    'reconnectionPermanentFailure',
-                                    "Cannot reconnect. Please reload the window."
-                                )),
-                                primaryButton: ( localizeWithPath(
-                                    'vs/workbench/contrib/remote/browser/remote',
-                                    { key: 'reloadWindow.dialog', comment: ['&& denotes a mnemonic'] },
-                                    "&&Reload Window"
-                                ))
-                            }).then(result => {
-                                if (result.confirmed) {
-                                    commandService.executeCommand(ReloadWindowAction.ID);
-                                }
-                            });
-                        }
-                        break;
-                    case 4 :
-                        reconnectionToken = e.reconnectionToken;
-                        lastIncomingDataTime = Date.now() - e.millisSinceLastIncomingData;
-                        reconnectionAttempts = e.attempt;
-                        telemetryService.publicLog2('remoteConnectionGain', {
-                            remoteName: getRemoteName(environmentService.remoteAuthority),
-                            reconnectionToken: e.reconnectionToken,
-                            millisSinceLastIncomingData: e.millisSinceLastIncomingData,
-                            attempt: e.attempt
-                        });
-                        hideProgress();
-                        break;
-                }
-            });
-        }
-    }
-};
-RemoteAgentConnectionStatusListener = ( __decorate([
-    ( __param(0, IRemoteAgentService)),
-    ( __param(1, IProgressService)),
-    ( __param(2, IDialogService)),
-    ( __param(3, ICommandService)),
-    ( __param(4, IQuickInputService)),
-    ( __param(5, ILogService)),
-    ( __param(6, IWorkbenchEnvironmentService)),
-    ( __param(7, ITelemetryService))
-], RemoteAgentConnectionStatusListener));
-
-export { RemoteAgentConnectionStatusListener, RemoteMarkers };