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

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

@@ -0,0 +1,831 @@
+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$1 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$1.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 };