@codingame/monaco-vscode-extensions-service-override 25.1.2 → 26.0.0

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

@@ -21,7 +21,16 @@ import { TunnelSource, TunnelCloseReason, makeAddress, forwardedPortsFeaturesEna
 import Severity from '@codingame/monaco-vscode-api/vscode/vs/base/common/severity';
 
 let MainThreadTunnelService = class MainThreadTunnelService extends Disposable {
-    constructor(extHostContext, remoteExplorerService, tunnelService, notificationService, configurationService, logService, remoteAgentService, contextKeyService) {
+    constructor(
+        extHostContext,
+        remoteExplorerService,
+        tunnelService,
+        notificationService,
+        configurationService,
+        logService,
+        remoteAgentService,
+        contextKeyService
+    ) {
         super();
         this.remoteExplorerService = remoteExplorerService;
         this.tunnelService = tunnelService;
@@ -38,18 +47,18 @@ let MainThreadTunnelService = class MainThreadTunnelService extends Disposable {
         this._register(tunnelService.onTunnelClosed(() => this._proxy.$onDidTunnelsChange()));
     }
     processFindingEnabled() {
-        return (!!this.configurationService.getValue(PORT_AUTO_FORWARD_SETTING) || this.tunnelService.hasTunnelProvider)
-            && (this.configurationService.getValue(PORT_AUTO_SOURCE_SETTING) !== PORT_AUTO_SOURCE_SETTING_OUTPUT);
+        return (!!this.configurationService.getValue(PORT_AUTO_FORWARD_SETTING) || this.tunnelService.hasTunnelProvider) && (this.configurationService.getValue(PORT_AUTO_SOURCE_SETTING) !== PORT_AUTO_SOURCE_SETTING_OUTPUT);
     }
     async $setRemoteTunnelService(processId) {
-        this.remoteExplorerService.namedProcesses.set(processId, 'Code Extension Host');
+        this.remoteExplorerService.namedProcesses.set(processId, "Code Extension Host");
         if (this.remoteExplorerService.portsFeaturesEnabled === PortsEnablement.AdditionalFeatures) {
             this._proxy.$registerCandidateFinder(this.processFindingEnabled());
+        } else {
+            this._register(
+                this.remoteExplorerService.onEnabledPortsFeatures(() => this._proxy.$registerCandidateFinder(this.processFindingEnabled()))
+            );
         }
-        else {
-            this._register(this.remoteExplorerService.onEnabledPortsFeatures(() => this._proxy.$registerCandidateFinder(this.processFindingEnabled())));
-        }
-        this._register(this.configurationService.onDidChangeConfiguration(async (e) => {
+        this._register(this.configurationService.onDidChangeConfiguration(async e => {
             if ((this.remoteExplorerService.portsFeaturesEnabled === PortsEnablement.AdditionalFeatures) && (e.affectsConfiguration(PORT_AUTO_FORWARD_SETTING) || e.affectsConfiguration(PORT_AUTO_SOURCE_SETTING))) {
                 return this._proxy.$registerCandidateFinder(this.processFindingEnabled());
             }
@@ -76,7 +85,7 @@ let MainThreadTunnelService = class MainThreadTunnelService extends Disposable {
         }
         const appropriateHandles = ( Array.from(this.portsAttributesProviders.entries()).filter(entry => {
             const selector = entry[1];
-            const portRange = (typeof selector.portRange === 'number') ? [selector.portRange, selector.portRange + 1] : selector.portRange;
+            const portRange = (typeof selector.portRange === "number") ? [selector.portRange, selector.portRange + 1] : selector.portRange;
             const portInRange = portRange ? ( ports.some(port => portRange[0] <= port && port < portRange[1])) : true;
             const commandMatches = !selector.commandPattern || (commandLine && (commandLine.match(selector.commandPattern)));
             return portInRange && commandMatches;
@@ -97,44 +106,42 @@ let MainThreadTunnelService = class MainThreadTunnelService extends Disposable {
             },
             elevateIfNeeded: false
         });
-        if (!tunnel || (typeof tunnel === 'string')) {
+        if (!tunnel || (typeof tunnel === "string")) {
             return undefined;
         }
-        if (!this.elevateionRetry
-            && (tunnelOptions.localAddressPort !== undefined)
-            && (tunnel.tunnelLocalPort !== undefined)
-            && this.tunnelService.isPortPrivileged(tunnelOptions.localAddressPort)
-            && (tunnel.tunnelLocalPort !== tunnelOptions.localAddressPort)
-            && this.tunnelService.canElevate) {
+        if (!this.elevateionRetry && (tunnelOptions.localAddressPort !== undefined) && (tunnel.tunnelLocalPort !== undefined) && this.tunnelService.isPortPrivileged(tunnelOptions.localAddressPort) && (tunnel.tunnelLocalPort !== tunnelOptions.localAddressPort) && this.tunnelService.canElevate) {
             this.elevationPrompt(tunnelOptions, tunnel, source);
         }
         return TunnelDtoConverter.fromServiceTunnel(tunnel);
     }
     async elevationPrompt(tunnelOptions, tunnel, source) {
         return this.notificationService.prompt(Severity.Info, ( localize(
-            2554,
+            2557,
             "The extension {0} has forwarded port {1}. You'll need to run as superuser to use port {2} locally.",
             source,
             tunnelOptions.remoteAddress.port,
             tunnelOptions.localAddressPort
         )), [{
-                label: ( localize(2555, "Use Port {0} as Sudo...", tunnel.tunnelRemotePort)),
-                run: async () => {
-                    this.elevateionRetry = true;
-                    await this.remoteExplorerService.close({ host: tunnel.tunnelRemoteHost, port: tunnel.tunnelRemotePort }, TunnelCloseReason.Other);
-                    await this.remoteExplorerService.forward({
-                        remote: tunnelOptions.remoteAddress,
-                        local: tunnelOptions.localAddressPort,
-                        name: tunnelOptions.label,
-                        source: {
-                            source: TunnelSource.Extension,
-                            description: source
-                        },
-                        elevateIfNeeded: true
-                    });
-                    this.elevateionRetry = false;
-                }
-            }]);
+            label: ( localize(2558, "Use Port {0} as Sudo...", tunnel.tunnelRemotePort)),
+            run: async () => {
+                this.elevateionRetry = true;
+                await this.remoteExplorerService.close({
+                    host: tunnel.tunnelRemoteHost,
+                    port: tunnel.tunnelRemotePort
+                }, TunnelCloseReason.Other);
+                await this.remoteExplorerService.forward({
+                    remote: tunnelOptions.remoteAddress,
+                    local: tunnelOptions.localAddressPort,
+                    name: tunnelOptions.label,
+                    source: {
+                        source: TunnelSource.Extension,
+                        description: source
+                    },
+                    elevateIfNeeded: true
+                });
+                this.elevateionRetry = false;
+            }
+        }]);
     }
     async $closeTunnel(remote) {
         return this.remoteExplorerService.close(remote, TunnelCloseReason.Other);
@@ -142,7 +149,10 @@ let MainThreadTunnelService = class MainThreadTunnelService extends Disposable {
     async $getTunnels() {
         return ( (await this.tunnelService.tunnels).map(tunnel => {
             return {
-                remoteAddress: { port: tunnel.tunnelRemotePort, host: tunnel.tunnelRemoteHost },
+                remoteAddress: {
+                    port: tunnel.tunnelRemotePort,
+                    host: tunnel.tunnelRemoteHost
+                },
                 localAddress: tunnel.localAddress,
                 privacy: tunnel.privacy,
                 protocol: tunnel.protocol
@@ -159,23 +169,29 @@ let MainThreadTunnelService = class MainThreadTunnelService extends Disposable {
                 return forward.then(tunnelOrError => {
                     if (!tunnelOrError) {
                         return undefined;
-                    }
-                    else if (typeof tunnelOrError === 'string') {
+                    } else if (typeof tunnelOrError === "string") {
                         return tunnelOrError;
                     }
                     const tunnel = tunnelOrError;
-                    this.logService.trace(`ForwardedPorts: (MainThreadTunnelService) New tunnel established by tunnel provider: ${tunnel?.remoteAddress.host}:${tunnel?.remoteAddress.port}`);
+                    this.logService.trace(
+                        `ForwardedPorts: (MainThreadTunnelService) New tunnel established by tunnel provider: ${tunnel?.remoteAddress.host}:${tunnel?.remoteAddress.port}`
+                    );
                     return {
                         tunnelRemotePort: tunnel.remoteAddress.port,
                         tunnelRemoteHost: tunnel.remoteAddress.host,
-                        localAddress: typeof tunnel.localAddress === 'string' ? tunnel.localAddress : makeAddress(tunnel.localAddress.host, tunnel.localAddress.port),
-                        tunnelLocalPort: typeof tunnel.localAddress !== 'string' ? tunnel.localAddress.port : undefined,
+                        localAddress: typeof tunnel.localAddress === "string" ? tunnel.localAddress : makeAddress(tunnel.localAddress.host, tunnel.localAddress.port),
+                        tunnelLocalPort: typeof tunnel.localAddress !== "string" ? tunnel.localAddress.port : undefined,
                         public: tunnel.public,
                         privacy: tunnel.privacy,
                         protocol: tunnel.protocol ?? TunnelProtocol.Http,
-                        dispose: async (silent) => {
-                            this.logService.trace(`ForwardedPorts: (MainThreadTunnelService) Closing tunnel from tunnel provider: ${tunnel?.remoteAddress.host}:${tunnel?.remoteAddress.port}`);
-                            return this._proxy.$closeTunnel({ host: tunnel.remoteAddress.host, port: tunnel.remoteAddress.port }, silent);
+                        dispose: async silent => {
+                            this.logService.trace(
+                                `ForwardedPorts: (MainThreadTunnelService) Closing tunnel from tunnel provider: ${tunnel?.remoteAddress.host}:${tunnel?.remoteAddress.port}`
+                            );
+                            return this._proxy.$closeTunnel({
+                                host: tunnel.remoteAddress.host,
+                                port: tunnel.remoteAddress.port
+                            }, silent);
                         }
                     };
                 });
@@ -193,42 +209,44 @@ let MainThreadTunnelService = class MainThreadTunnelService extends Disposable {
         return this.tunnelService.hasTunnelProvider;
     }
     async $setCandidateFilter() {
-        this.remoteExplorerService.setCandidateFilter((candidates) => {
+        this.remoteExplorerService.setCandidateFilter(candidates => {
             return this._proxy.$applyCandidateFilter(candidates);
         });
     }
     async $setCandidatePortSource(source) {
         this.remoteAgentService.getEnvironment().then(() => {
             switch (source) {
-                case CandidatePortSource.None: {
-                    ( Registry.as(Extensions.Configuration))
-                        .registerDefaultConfigurations([{ overrides: { 'remote.autoForwardPorts': false } }]);
+            case CandidatePortSource.None:
+                {
+                    ( Registry.as(Extensions.Configuration)).registerDefaultConfigurations([{
+                        overrides: {
+                            "remote.autoForwardPorts": false
+                        }
+                    }]);
                     break;
                 }
-                case CandidatePortSource.Output: {
-                    ( Registry.as(Extensions.Configuration))
-                        .registerDefaultConfigurations([{ overrides: { 'remote.autoForwardPortsSource': PORT_AUTO_SOURCE_SETTING_OUTPUT } }]);
+            case CandidatePortSource.Output:
+                {
+                    ( Registry.as(Extensions.Configuration)).registerDefaultConfigurations([{
+                        overrides: {
+                            "remote.autoForwardPortsSource": PORT_AUTO_SOURCE_SETTING_OUTPUT
+                        }
+                    }]);
                     break;
                 }
-                case CandidatePortSource.Hybrid: {
-                    ( Registry.as(Extensions.Configuration))
-                        .registerDefaultConfigurations([{ overrides: { 'remote.autoForwardPortsSource': PORT_AUTO_SOURCE_SETTING_HYBRID } }]);
+            case CandidatePortSource.Hybrid:
+                {
+                    ( Registry.as(Extensions.Configuration)).registerDefaultConfigurations([{
+                        overrides: {
+                            "remote.autoForwardPortsSource": PORT_AUTO_SOURCE_SETTING_HYBRID
+                        }
+                    }]);
                     break;
                 }
             }
-        }).catch(() => {
-        });
+        }).catch(() => {});
     }
 };
-MainThreadTunnelService = __decorate([
-    extHostNamedCustomer(MainContext.MainThreadTunnelService),
-    ( __param(1, IRemoteExplorerService)),
-    ( __param(2, ITunnelService)),
-    ( __param(3, INotificationService)),
-    ( __param(4, IConfigurationService)),
-    ( __param(5, ILogService)),
-    ( __param(6, IRemoteAgentService)),
-    ( __param(7, IContextKeyService))
-], MainThreadTunnelService);
+MainThreadTunnelService = __decorate([extHostNamedCustomer(MainContext.MainThreadTunnelService), ( __param(1, IRemoteExplorerService)), ( __param(2, ITunnelService)), ( __param(3, INotificationService)), ( __param(4, IConfigurationService)), ( __param(5, ILogService)), ( __param(6, IRemoteAgentService)), ( __param(7, IContextKeyService))], MainThreadTunnelService);
 
 export { MainThreadTunnelService };

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

@@ -18,7 +18,14 @@ import { extHostNamedCustomer } from '../../services/extensions/common/extHostCu
 import Severity from '@codingame/monaco-vscode-api/vscode/vs/base/common/severity';
 
 let MainThreadUriOpeners = class MainThreadUriOpeners extends Disposable {
-    constructor(context, storageService, externalUriOpenerService, extensionService, openerService, notificationService) {
+    constructor(
+        context,
+        storageService,
+        externalUriOpenerService,
+        extensionService,
+        openerService,
+        notificationService
+    ) {
         super();
         this.extensionService = extensionService;
         this.openerService = openerService;
@@ -48,30 +55,30 @@ let MainThreadUriOpeners = class MainThreadUriOpeners extends Disposable {
             },
             openExternalUri: async (uri, ctx, token) => {
                 try {
-                    await this.proxy.$openUri(id, { resolvedUri: uri, sourceUri: ctx.sourceUri }, token);
-                }
-                catch (e) {
+                    await this.proxy.$openUri(id, {
+                        resolvedUri: uri,
+                        sourceUri: ctx.sourceUri
+                    }, token);
+                } catch (e) {
                     if (!isCancellationError(e)) {
-                        const openDefaultAction = ( new Action('default', ( localize(2556, "Open using default opener")), undefined, undefined, async () => {
+                        const openDefaultAction = ( new Action("default", ( localize(2559, "Open using default opener")), undefined, undefined, async () => {
                             await this.openerService.open(uri, {
                                 allowTunneling: false,
-                                allowContributedOpeners: defaultExternalUriOpenerId,
+                                allowContributedOpeners: defaultExternalUriOpenerId
                             });
                         }));
                         openDefaultAction.tooltip = ( uri.toString());
                         this.notificationService.notify({
                             severity: Severity.Error,
-                            message: ( localize(2557, 'Could not open uri with \'{0}\': {1}', id, (e.toString()))),
+                            message: ( localize(2560, "Could not open uri with '{0}': {1}", id, (e.toString()))),
                             actions: {
-                                primary: [
-                                    openDefaultAction
-                                ]
+                                primary: [openDefaultAction]
                             }
                         });
                     }
                 }
                 return true;
-            },
+            }
         };
     }
     async $registerUriOpener(id, schemes, extensionId, label) {
@@ -81,7 +88,7 @@ let MainThreadUriOpeners = class MainThreadUriOpeners extends Disposable {
         this._registeredOpeners.set(id, {
             schemes: ( new Set(schemes)),
             label,
-            extensionId,
+            extensionId
         });
         this._contributedExternalUriOpenersStore.didRegisterOpener(id, extensionId.value);
     }
@@ -94,13 +101,6 @@ let MainThreadUriOpeners = class MainThreadUriOpeners extends Disposable {
         this._registeredOpeners.clear();
     }
 };
-MainThreadUriOpeners = __decorate([
-    extHostNamedCustomer(MainContext.MainThreadUriOpeners),
-    ( __param(1, IStorageService)),
-    ( __param(2, IExternalUriOpenerService)),
-    ( __param(3, IExtensionService)),
-    ( __param(4, IOpenerService)),
-    ( __param(5, INotificationService))
-], MainThreadUriOpeners);
+MainThreadUriOpeners = __decorate([extHostNamedCustomer(MainContext.MainThreadUriOpeners), ( __param(1, IStorageService)), ( __param(2, IExternalUriOpenerService)), ( __param(3, IExtensionService)), ( __param(4, IOpenerService)), ( __param(5, INotificationService))], MainThreadUriOpeners);
 
 export { MainThreadUriOpeners };

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

@@ -34,7 +34,10 @@ let MainThreadUrls = class MainThreadUrls extends Disposable {
     async $registerUriHandler(handle, extensionId, extensionDisplayName) {
         const handler = ( new ExtensionUrlHandler(this.proxy, handle, extensionId, extensionDisplayName));
         const disposable = this.urlService.registerHandler(handler);
-        this.handlers.set(handle, { extensionId, disposable });
+        this.handlers.set(handle, {
+            extensionId,
+            disposable
+        });
         this.extensionUrlHandler.registerExtensionHandler(extensionId, handler);
         return undefined;
     }
@@ -43,7 +46,10 @@ let MainThreadUrls = class MainThreadUrls extends Disposable {
         if (!tuple) {
             return undefined;
         }
-        const { extensionId, disposable } = tuple;
+        const {
+            extensionId,
+            disposable
+        } = tuple;
         this.extensionUrlHandler.unregisterExtensionHandler(extensionId);
         this.handlers.delete(handle);
         disposable.dispose();
@@ -54,15 +60,14 @@ let MainThreadUrls = class MainThreadUrls extends Disposable {
     }
     dispose() {
         super.dispose();
-        this.handlers.forEach(({ disposable }) => disposable.dispose());
+        this.handlers.forEach((
+            {
+                disposable
+            }
+        ) => disposable.dispose());
         this.handlers.clear();
     }
 };
-MainThreadUrls = __decorate([
-    extHostNamedCustomer(MainContext.MainThreadUrls),
-    ( __param(1, ITrustedDomainService)),
-    ( __param(2, IURLService)),
-    ( __param(3, IExtensionUrlHandler))
-], MainThreadUrls);
+MainThreadUrls = __decorate([extHostNamedCustomer(MainContext.MainThreadUrls), ( __param(1, ITrustedDomainService)), ( __param(2, IURLService)), ( __param(3, IExtensionUrlHandler))], MainThreadUrls);
 
 export { MainThreadUrls };

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

@@ -15,19 +15,27 @@ let MainThreadWebviewManager = class MainThreadWebviewManager extends Disposable
         super();
         const webviews = this._register(instantiationService.createInstance(MainThreadWebviews, context));
         context.set(MainContext.MainThreadWebviews, webviews);
-        const webviewPanels = this._register(instantiationService.createInstance(MainThreadWebviewPanels, context, webviews));
+        const webviewPanels = this._register(
+            instantiationService.createInstance(MainThreadWebviewPanels, context, webviews)
+        );
         context.set(MainContext.MainThreadWebviewPanels, webviewPanels);
-        const customEditors = this._register(instantiationService.createInstance(MainThreadCustomEditors, context, webviews, webviewPanels));
+        const customEditors = this._register(
+            instantiationService.createInstance(MainThreadCustomEditors, context, webviews, webviewPanels)
+        );
         context.set(MainContext.MainThreadCustomEditors, customEditors);
-        const webviewViews = this._register(instantiationService.createInstance(MainThreadWebviewsViews, context, webviews));
+        const webviewViews = this._register(
+            instantiationService.createInstance(MainThreadWebviewsViews, context, webviews)
+        );
         context.set(MainContext.MainThreadWebviewViews, webviewViews);
-        const chatOutputRenderers = this._register(instantiationService.createInstance(MainThreadChatOutputRenderer, context, webviews));
-        context.set(MainContext.MainThreadChatOutputRenderer, chatOutputRenderers);
+        const chatOutputRenderers = this._register(
+            instantiationService.createInstance(MainThreadChatOutputRenderer, context, webviews)
+        );
+        context.set(
+            MainContext.MainThreadChatOutputRenderer,
+            chatOutputRenderers
+        );
     }
 };
-MainThreadWebviewManager = __decorate([
-    extHostCustomer,
-    ( __param(1, IInstantiationService))
-], MainThreadWebviewManager);
+MainThreadWebviewManager = __decorate([extHostCustomer, ( __param(1, IInstantiationService))], MainThreadWebviewManager);
 
 export { MainThreadWebviewManager };

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

@@ -58,42 +58,59 @@ class WebviewViewTypeTransformer {
         return this.prefix + viewType;
     }
     toExternal(viewType) {
-        return viewType.startsWith(this.prefix)
-            ? viewType.substr(this.prefix.length)
-            : undefined;
+        return viewType.startsWith(this.prefix) ? viewType.substr(this.prefix.length) : undefined;
     }
 }
 let MainThreadWebviewPanels = class MainThreadWebviewPanels extends Disposable {
-    constructor(context, _mainThreadWebviews, _configurationService, _editorGroupService, _editorService, extensionService, storageService, _webviewWorkbenchService) {
+    constructor(
+        context,
+        _mainThreadWebviews,
+        _configurationService,
+        _editorGroupService,
+        _editorService,
+        extensionService,
+        storageService,
+        _webviewWorkbenchService
+    ) {
         super();
         this._mainThreadWebviews = _mainThreadWebviews;
         this._configurationService = _configurationService;
         this._editorGroupService = _editorGroupService;
         this._editorService = _editorService;
         this._webviewWorkbenchService = _webviewWorkbenchService;
-        this.webviewPanelViewType = ( new WebviewViewTypeTransformer('mainThreadWebview-'));
+        this.webviewPanelViewType = ( new WebviewViewTypeTransformer("mainThreadWebview-"));
         this._webviewInputs = ( new WebviewInputStore());
         this._revivers = this._register(( new DisposableMap()));
-        this.webviewOriginStore = ( new ExtensionKeyedWebviewOriginStore('mainThreadWebviewPanel.origins', storageService));
+        this.webviewOriginStore = ( new ExtensionKeyedWebviewOriginStore("mainThreadWebviewPanel.origins", storageService));
         this._proxy = ( context.getProxy(ExtHostContext.ExtHostWebviewPanels));
-        this._register(Event.any(_editorService.onDidActiveEditorChange, _editorService.onDidVisibleEditorsChange, _editorGroupService.onDidAddGroup, _editorGroupService.onDidRemoveGroup, _editorGroupService.onDidMoveGroup)(() => {
+        this._register(Event.any(
+            _editorService.onDidActiveEditorChange,
+            _editorService.onDidVisibleEditorsChange,
+            _editorGroupService.onDidAddGroup,
+            _editorGroupService.onDidRemoveGroup,
+            _editorGroupService.onDidMoveGroup
+        )(() => {
             this.updateWebviewViewStates(this._editorService.activeEditor);
         }));
         this._register(_webviewWorkbenchService.onDidChangeActiveWebviewEditor(input => {
             this.updateWebviewViewStates(input);
         }));
         this._register(_webviewWorkbenchService.registerResolver({
-            canResolve: (webview) => {
+            canResolve: webview => {
                 const viewType = this.webviewPanelViewType.toExternal(webview.viewType);
-                if (typeof viewType === 'string') {
+                if (typeof viewType === "string") {
                     extensionService.activateByEvent(`onWebviewPanel:${viewType}`);
                 }
                 return false;
             },
-            resolveWebview: () => { throw ( new Error('not implemented')); }
+            resolveWebview: () => {
+                throw ( new Error("not implemented"));
+            }
         }));
     }
-    get webviewInputs() { return this._webviewInputs; }
+    get webviewInputs() {
+        return this._webviewInputs;
+    }
     addWebviewInput(handle, input, options) {
         this._webviewInputs.add(handle, input);
         this._mainThreadWebviews.addWebview(handle, input.webview, options);
@@ -120,7 +137,9 @@ let MainThreadWebviewPanels = class MainThreadWebviewPanels extends Disposable {
             contentOptions: reviveWebviewContentOptions(initData.webviewOptions),
             extension
         }, this.webviewPanelViewType.fromExternal(viewType), initData.title, undefined, mainThreadShowOptions);
-        this.addWebviewInput(handle, webview, { serializeBuffersForPostMessage: initData.serializeBuffersForPostMessage });
+        this.addWebviewInput(handle, webview, {
+            serializeBuffersForPostMessage: initData.serializeBuffersForPostMessage
+        });
     }
     $disposeWebview(handle) {
         const webview = this.tryGetWebviewInput(handle);
@@ -147,9 +166,7 @@ let MainThreadWebviewPanels = class MainThreadWebviewPanels extends Disposable {
         this._webviewWorkbenchService.revealWebview(webview, targetGroup, !!showOptions.preserveFocus);
     }
     getTargetGroupFromShowOptions(showOptions) {
-        if (typeof showOptions.viewColumn === 'undefined'
-            || showOptions.viewColumn === ACTIVE_GROUP
-            || (this._editorGroupService.count === 1 && this._editorGroupService.activeGroup.isEmpty)) {
+        if (typeof showOptions.viewColumn === "undefined" || showOptions.viewColumn === ACTIVE_GROUP || (this._editorGroupService.count === 1 && this._editorGroupService.activeGroup.isEmpty)) {
             return ACTIVE_GROUP;
         }
         if (showOptions.viewColumn === SIDE_GROUP) {
@@ -160,7 +177,9 @@ let MainThreadWebviewPanels = class MainThreadWebviewPanels extends Disposable {
             if (groupInColumn) {
                 return groupInColumn.id;
             }
-            const newGroup = this._editorGroupService.findGroup({ location: GroupLocation.LAST });
+            const newGroup = this._editorGroupService.findGroup({
+                location: GroupLocation.LAST
+            });
             if (newGroup) {
                 const direction = preferredSideBySideGroupDirection(this._configurationService);
                 return this._editorGroupService.addGroup(newGroup, direction);
@@ -173,13 +192,15 @@ let MainThreadWebviewPanels = class MainThreadWebviewPanels extends Disposable {
             throw ( new Error(`Reviver for ${viewType} already registered`));
         }
         this._revivers.set(viewType, this._webviewWorkbenchService.registerResolver({
-            canResolve: (webviewInput) => {
+            canResolve: webviewInput => {
                 return webviewInput.viewType === this.webviewPanelViewType.fromExternal(viewType);
             },
-            resolveWebview: async (webviewInput) => {
+            resolveWebview: async webviewInput => {
                 const viewType = this.webviewPanelViewType.toExternal(webviewInput.viewType);
                 if (!viewType) {
-                    webviewInput.webview.setHtml(this._mainThreadWebviews.getWebviewResolvedFailedContent(webviewInput.viewType));
+                    webviewInput.webview.setHtml(
+                        this._mainThreadWebviews.getWebviewResolvedFailedContent(webviewInput.viewType)
+                    );
                     return;
                 }
                 const handle = generateUuid();
@@ -188,9 +209,8 @@ let MainThreadWebviewPanels = class MainThreadWebviewPanels extends Disposable {
                 if (webviewInput.webview.state) {
                     try {
                         state = JSON.parse(webviewInput.webview.state);
-                    }
-                    catch (e) {
-                        console.error('Could not load webview state', e, webviewInput.webview.state);
+                    } catch (e) {
+                        console.error("Could not load webview state", e, webviewInput.webview.state);
                     }
                 }
                 try {
@@ -199,10 +219,9 @@ let MainThreadWebviewPanels = class MainThreadWebviewPanels extends Disposable {
                         state,
                         panelOptions: webviewInput.webview.options,
                         webviewOptions: webviewInput.webview.contentOptions,
-                        active: webviewInput === this._editorService.activeEditor,
+                        active: webviewInput === this._editorService.activeEditor
                     }, editorGroupToColumn(this._editorGroupService, webviewInput.group || 0));
-                }
-                catch (error) {
+                } catch (error) {
                     onUnexpectedError(error);
                     webviewInput.webview.setHtml(this._mainThreadWebviews.getWebviewResolvedFailedContent(viewType));
                 }
@@ -230,7 +249,7 @@ let MainThreadWebviewPanels = class MainThreadWebviewPanels extends Disposable {
                 viewStates[handle] = {
                     visible: topLevelInput === group.activeEditor,
                     active: editorInput === activeEditorInput,
-                    position: editorGroupToColumn(this._editorGroupService, group.id),
+                    position: editorGroupToColumn(this._editorGroupService, group.id)
                 };
             }
         };
@@ -239,8 +258,7 @@ let MainThreadWebviewPanels = class MainThreadWebviewPanels extends Disposable {
                 if (input instanceof DiffEditorInput) {
                     updateViewStatesForInput(group, input, input.primary);
                     updateViewStatesForInput(group, input, input.secondary);
-                }
-                else {
+                } else {
                     updateViewStatesForInput(group, input, input);
                 }
             }
@@ -253,14 +271,7 @@ let MainThreadWebviewPanels = class MainThreadWebviewPanels extends Disposable {
         return this._webviewInputs.getInputForHandle(handle);
     }
 };
-MainThreadWebviewPanels = ( __decorate([
-    ( __param(2, IConfigurationService)),
-    ( __param(3, IEditorGroupsService)),
-    ( __param(4, IEditorService)),
-    ( __param(5, IExtensionService)),
-    ( __param(6, IStorageService)),
-    ( __param(7, IWebviewWorkbenchService))
-], MainThreadWebviewPanels));
+MainThreadWebviewPanels = ( __decorate([( __param(2, IConfigurationService)), ( __param(3, IEditorGroupsService)), ( __param(4, IEditorService)), ( __param(5, IExtensionService)), ( __param(6, IStorageService)), ( __param(7, IWebviewWorkbenchService))], MainThreadWebviewPanels));
 function reviveWebviewIcon(value) {
     if (!value) {
         return undefined;
@@ -270,13 +281,13 @@ function reviveWebviewIcon(value) {
     }
     return {
         light: URI.revive(value.light),
-        dark: URI.revive(value.dark),
+        dark: URI.revive(value.dark)
     };
 }
 function reviveWebviewOptions(panelOptions) {
     return {
         enableFindWidget: panelOptions.enableFindWidget,
-        retainContextWhenHidden: panelOptions.retainContextWhenHidden,
+        retainContextWhenHidden: panelOptions.retainContextWhenHidden
     };
 }
 

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

@@ -43,14 +43,15 @@ let MainThreadWebviewsViews = class MainThreadWebviewsViews extends Disposable {
             resolve: async (webviewView, cancellation) => {
                 const handle = generateUuid();
                 this._webviewViews.set(handle, webviewView);
-                this.mainThreadWebviews.addWebview(handle, webviewView.webview, { serializeBuffersForPostMessage: options.serializeBuffersForPostMessage });
+                this.mainThreadWebviews.addWebview(handle, webviewView.webview, {
+                    serializeBuffersForPostMessage: options.serializeBuffersForPostMessage
+                });
                 let state = undefined;
                 if (webviewView.webview.state) {
                     try {
                         state = JSON.parse(webviewView.webview.state);
-                    }
-                    catch (e) {
-                        console.error('Could not load webview state', e, webviewView.webview.state);
+                    } catch (e) {
+                        console.error("Could not load webview state", e, webviewView.webview.state);
                     }
                 }
                 webviewView.webview.extension = extension;
@@ -66,14 +67,13 @@ let MainThreadWebviewsViews = class MainThreadWebviewsViews extends Disposable {
                     this._webviewViews.deleteAndDispose(handle);
                     subscriptions.dispose();
                 }));
-                this._telemetryService.publicLog2('webviews:createWebviewView', {
+                this._telemetryService.publicLog2("webviews:createWebviewView", {
                     extensionId: extension.id.value,
-                    id: viewType,
+                    id: viewType
                 });
                 try {
                     await this._proxy.$resolveWebviewView(handle, viewType, webviewView.title, state, cancellation);
-                }
-                catch (error) {
+                } catch (error) {
                     onUnexpectedError(error);
                     webviewView.webview.setHtml(this.mainThreadWebviews.getWebviewResolvedFailedContent(viewType));
                 }
@@ -90,14 +90,11 @@ let MainThreadWebviewsViews = class MainThreadWebviewsViews extends Disposable {
     getWebviewView(handle) {
         const webviewView = this._webviewViews.get(handle);
         if (!webviewView) {
-            throw ( new Error('unknown webview view'));
+            throw ( new Error("unknown webview view"));
         }
         return webviewView;
     }
 };
-MainThreadWebviewsViews = ( __decorate([
-    ( __param(2, ITelemetryService)),
-    ( __param(3, IWebviewViewService))
-], MainThreadWebviewsViews));
+MainThreadWebviewsViews = ( __decorate([( __param(2, ITelemetryService)), ( __param(3, IWebviewViewService))], MainThreadWebviewsViews));
 
 export { MainThreadWebviewsViews };