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

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

@@ -0,0 +1,283 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { onUnexpectedError } from 'vscode/vscode/vs/base/common/errors';
+import { Event } from 'vscode/vscode/vs/base/common/event';
+import { Disposable, DisposableMap } from 'vscode/vscode/vs/base/common/lifecycle';
+import { URI } from 'vscode/vscode/vs/base/common/uri';
+import { generateUuid } from 'vscode/vscode/vs/base/common/uuid';
+import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration';
+import { IStorageService } from 'vscode/vscode/vs/platform/storage/common/storage';
+import { ITelemetryService } from 'vscode/vscode/vs/platform/telemetry/common/telemetry';
+import { reviveWebviewExtension, reviveWebviewContentOptions } from './mainThreadWebviews.js';
+import { ExtHostContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
+import { DiffEditorInput } from 'vscode/vscode/vs/workbench/common/editor/diffEditorInput';
+import { ExtensionKeyedWebviewOriginStore } from 'vscode/vscode/vs/workbench/contrib/webview/browser/webview';
+import { WebviewInput } from 'vscode/vscode/vs/workbench/contrib/webviewPanel/browser/webviewEditorInput';
+import { IWebviewWorkbenchService } from 'vscode/vscode/vs/workbench/contrib/webviewPanel/browser/webviewWorkbenchService';
+import { editorGroupToColumn } from 'vscode/vscode/vs/workbench/services/editor/common/editorGroupColumn';
+import { IEditorGroupsService, preferredSideBySideGroupDirection } from 'vscode/vscode/vs/workbench/services/editor/common/editorGroupsService';
+import { IEditorService, ACTIVE_GROUP, SIDE_GROUP } from 'vscode/vscode/vs/workbench/services/editor/common/editorService';
+import { IExtensionService } from 'vscode/vscode/vs/workbench/services/extensions/common/extensions';
+
+class WebviewInputStore {
+    constructor() {
+        this._handlesToInputs = ( new Map());
+        this._inputsToHandles = ( new Map());
+    }
+    add(handle, input) {
+        this._handlesToInputs.set(handle, input);
+        this._inputsToHandles.set(input, handle);
+    }
+    getHandleForInput(input) {
+        return this._inputsToHandles.get(input);
+    }
+    getInputForHandle(handle) {
+        return this._handlesToInputs.get(handle);
+    }
+    delete(handle) {
+        const input = this.getInputForHandle(handle);
+        this._handlesToInputs.delete(handle);
+        if (input) {
+            this._inputsToHandles.delete(input);
+        }
+    }
+    get size() {
+        return this._handlesToInputs.size;
+    }
+    [Symbol.iterator]() {
+        return ( this._handlesToInputs.values());
+    }
+}
+class WebviewViewTypeTransformer {
+    constructor(prefix) {
+        this.prefix = prefix;
+    }
+    fromExternal(viewType) {
+        return this.prefix + viewType;
+    }
+    toExternal(viewType) {
+        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, _telemetryService, _webviewWorkbenchService) {
+        super();
+        this._mainThreadWebviews = _mainThreadWebviews;
+        this._configurationService = _configurationService;
+        this._editorGroupService = _editorGroupService;
+        this._editorService = _editorService;
+        this._telemetryService = _telemetryService;
+        this._webviewWorkbenchService = _webviewWorkbenchService;
+        this.webviewPanelViewType = ( new WebviewViewTypeTransformer('mainThreadWebview-'));
+        this._webviewInputs = ( new WebviewInputStore());
+        this._revivers = this._register(( new DisposableMap()));
+        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.updateWebviewViewStates(this._editorService.activeEditor);
+        }));
+        this._register(_webviewWorkbenchService.onDidChangeActiveWebviewEditor(input => {
+            this.updateWebviewViewStates(input);
+        }));
+        this._register(_webviewWorkbenchService.registerResolver({
+            canResolve: (webview) => {
+                const viewType = this.webviewPanelViewType.toExternal(webview.viewType);
+                if (typeof viewType === 'string') {
+                    extensionService.activateByEvent(`onWebviewPanel:${viewType}`);
+                }
+                return false;
+            },
+            resolveWebview: () => { throw new Error('not implemented'); }
+        }));
+    }
+    get webviewInputs() { return this._webviewInputs; }
+    addWebviewInput(handle, input, options) {
+        this._webviewInputs.add(handle, input);
+        this._mainThreadWebviews.addWebview(handle, input.webview, options);
+        input.webview.onDidDispose(() => {
+            this._proxy.$onDidDisposeWebviewPanel(handle).finally(() => {
+                this._webviewInputs.delete(handle);
+            });
+        });
+    }
+    $createWebviewPanel(extensionData, handle, viewType, initData, showOptions) {
+        const targetGroup = this.getTargetGroupFromShowOptions(showOptions);
+        const mainThreadShowOptions = showOptions ? {
+            preserveFocus: !!showOptions.preserveFocus,
+            group: targetGroup
+        } : {};
+        const extension = reviveWebviewExtension(extensionData);
+        const origin = this.webviewOriginStore.getOrigin(viewType, extension.id);
+        const webview = this._webviewWorkbenchService.openWebview({
+            origin,
+            providedViewType: viewType,
+            title: initData.title,
+            options: reviveWebviewOptions(initData.panelOptions),
+            contentOptions: reviveWebviewContentOptions(initData.webviewOptions),
+            extension
+        }, this.webviewPanelViewType.fromExternal(viewType), initData.title, mainThreadShowOptions);
+        this.addWebviewInput(handle, webview, { serializeBuffersForPostMessage: initData.serializeBuffersForPostMessage });
+        const payload = {
+            extensionId: extension.id.value,
+            viewType
+        };
+        this._telemetryService.publicLog2('webviews:createWebviewPanel', payload);
+    }
+    $disposeWebview(handle) {
+        const webview = this.tryGetWebviewInput(handle);
+        if (!webview) {
+            return;
+        }
+        webview.dispose();
+    }
+    $setTitle(handle, value) {
+        this.tryGetWebviewInput(handle)?.setName(value);
+    }
+    $setIconPath(handle, value) {
+        const webview = this.tryGetWebviewInput(handle);
+        if (webview) {
+            webview.iconPath = reviveWebviewIcon(value);
+        }
+    }
+    $reveal(handle, showOptions) {
+        const webview = this.tryGetWebviewInput(handle);
+        if (!webview || webview.isDisposed()) {
+            return;
+        }
+        const targetGroup = this.getTargetGroupFromShowOptions(showOptions);
+        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)) {
+            return ACTIVE_GROUP;
+        }
+        if (showOptions.viewColumn === SIDE_GROUP) {
+            return SIDE_GROUP;
+        }
+        if (showOptions.viewColumn >= 0) {
+            const groupInColumn = this._editorGroupService.getGroups(2 )[showOptions.viewColumn];
+            if (groupInColumn) {
+                return groupInColumn.id;
+            }
+            const newGroup = this._editorGroupService.findGroup({ location: 1  });
+            if (newGroup) {
+                const direction = preferredSideBySideGroupDirection(this._configurationService);
+                return this._editorGroupService.addGroup(newGroup, direction);
+            }
+        }
+        return ACTIVE_GROUP;
+    }
+    $registerSerializer(viewType, options) {
+        if (( this._revivers.has(viewType))) {
+            throw new Error(`Reviver for ${viewType} already registered`);
+        }
+        this._revivers.set(viewType, this._webviewWorkbenchService.registerResolver({
+            canResolve: (webviewInput) => {
+                return webviewInput.viewType === this.webviewPanelViewType.fromExternal(viewType);
+            },
+            resolveWebview: async (webviewInput) => {
+                const viewType = this.webviewPanelViewType.toExternal(webviewInput.viewType);
+                if (!viewType) {
+                    webviewInput.webview.setHtml(this._mainThreadWebviews.getWebviewResolvedFailedContent(webviewInput.viewType));
+                    return;
+                }
+                const handle = generateUuid();
+                this.addWebviewInput(handle, webviewInput, options);
+                let state = undefined;
+                if (webviewInput.webview.state) {
+                    try {
+                        state = JSON.parse(webviewInput.webview.state);
+                    }
+                    catch (e) {
+                        console.error('Could not load webview state', e, webviewInput.webview.state);
+                    }
+                }
+                try {
+                    await this._proxy.$deserializeWebviewPanel(handle, viewType, {
+                        title: webviewInput.getTitle(),
+                        state,
+                        panelOptions: webviewInput.webview.options,
+                        webviewOptions: webviewInput.webview.contentOptions,
+                        active: webviewInput === this._editorService.activeEditor,
+                    }, editorGroupToColumn(this._editorGroupService, webviewInput.group || 0));
+                }
+                catch (error) {
+                    onUnexpectedError(error);
+                    webviewInput.webview.setHtml(this._mainThreadWebviews.getWebviewResolvedFailedContent(viewType));
+                }
+            }
+        }));
+    }
+    $unregisterSerializer(viewType) {
+        if (!( this._revivers.has(viewType))) {
+            throw new Error(`No reviver for ${viewType} registered`);
+        }
+        this._revivers.deleteAndDispose(viewType);
+    }
+    updateWebviewViewStates(activeEditorInput) {
+        if (!this._webviewInputs.size) {
+            return;
+        }
+        const viewStates = {};
+        const updateViewStatesForInput = (group, topLevelInput, editorInput) => {
+            if (!(editorInput instanceof WebviewInput)) {
+                return;
+            }
+            editorInput.updateGroup(group.id);
+            const handle = this._webviewInputs.getHandleForInput(editorInput);
+            if (handle) {
+                viewStates[handle] = {
+                    visible: topLevelInput === group.activeEditor,
+                    active: editorInput === activeEditorInput,
+                    position: editorGroupToColumn(this._editorGroupService, group.id),
+                };
+            }
+        };
+        for (const group of this._editorGroupService.groups) {
+            for (const input of group.editors) {
+                if (input instanceof DiffEditorInput) {
+                    updateViewStatesForInput(group, input, input.primary);
+                    updateViewStatesForInput(group, input, input.secondary);
+                }
+                else {
+                    updateViewStatesForInput(group, input, input);
+                }
+            }
+        }
+        if (( Object.keys(viewStates)).length) {
+            this._proxy.$onDidChangeWebviewPanelViewStates(viewStates);
+        }
+    }
+    tryGetWebviewInput(handle) {
+        return this._webviewInputs.getInputForHandle(handle);
+    }
+};
+MainThreadWebviewPanels = ( __decorate([
+    ( __param(2, IConfigurationService)),
+    ( __param(3, IEditorGroupsService)),
+    ( __param(4, IEditorService)),
+    ( __param(5, IExtensionService)),
+    ( __param(6, IStorageService)),
+    ( __param(7, ITelemetryService)),
+    ( __param(8, IWebviewWorkbenchService))
+], MainThreadWebviewPanels));
+function reviveWebviewIcon(value) {
+    if (!value) {
+        return undefined;
+    }
+    return {
+        light: URI.revive(value.light),
+        dark: URI.revive(value.dark),
+    };
+}
+function reviveWebviewOptions(panelOptions) {
+    return {
+        enableFindWidget: panelOptions.enableFindWidget,
+        retainContextWhenHidden: panelOptions.retainContextWhenHidden,
+    };
+}
+
+export { MainThreadWebviewPanels };

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

@@ -0,0 +1,100 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { onUnexpectedError } from 'vscode/vscode/vs/base/common/errors';
+import { Disposable, DisposableMap } from 'vscode/vscode/vs/base/common/lifecycle';
+import { generateUuid } from 'vscode/vscode/vs/base/common/uuid';
+import { reviveWebviewExtension } from './mainThreadWebviews.js';
+import { ExtHostContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
+import { IWebviewViewService } from 'vscode/vscode/vs/workbench/contrib/webviewView/browser/webviewViewService';
+import { ITelemetryService } from 'vscode/vscode/vs/platform/telemetry/common/telemetry';
+
+let MainThreadWebviewsViews = class MainThreadWebviewsViews extends Disposable {
+    constructor(context, mainThreadWebviews, _telemetryService, _webviewViewService) {
+        super();
+        this.mainThreadWebviews = mainThreadWebviews;
+        this._telemetryService = _telemetryService;
+        this._webviewViewService = _webviewViewService;
+        this._webviewViews = this._register(( new DisposableMap()));
+        this._webviewViewProviders = this._register(( new DisposableMap()));
+        this._proxy = ( context.getProxy(ExtHostContext.ExtHostWebviewViews));
+    }
+    $setWebviewViewTitle(handle, value) {
+        const webviewView = this.getWebviewView(handle);
+        webviewView.title = value;
+    }
+    $setWebviewViewDescription(handle, value) {
+        const webviewView = this.getWebviewView(handle);
+        webviewView.description = value;
+    }
+    $setWebviewViewBadge(handle, badge) {
+        const webviewView = this.getWebviewView(handle);
+        webviewView.badge = badge;
+    }
+    $show(handle, preserveFocus) {
+        const webviewView = this.getWebviewView(handle);
+        webviewView.show(preserveFocus);
+    }
+    $registerWebviewViewProvider(extensionData, viewType, options) {
+        if (( this._webviewViewProviders.has(viewType))) {
+            throw new Error(`View provider for ${viewType} already registered`);
+        }
+        const extension = reviveWebviewExtension(extensionData);
+        const registration = this._webviewViewService.register(viewType, {
+            resolve: async (webviewView, cancellation) => {
+                const handle = generateUuid();
+                this._webviewViews.set(handle, webviewView);
+                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);
+                    }
+                }
+                webviewView.webview.extension = extension;
+                if (options) {
+                    webviewView.webview.options = options;
+                }
+                webviewView.onDidChangeVisibility(visible => {
+                    this._proxy.$onDidChangeWebviewViewVisibility(handle, visible);
+                });
+                webviewView.onDispose(() => {
+                    this._proxy.$disposeWebviewView(handle);
+                    this._webviewViews.deleteAndDispose(handle);
+                });
+                this._telemetryService.publicLog2('webviews:createWebviewView', {
+                    extensionId: extension.id.value,
+                    id: viewType,
+                });
+                try {
+                    await this._proxy.$resolveWebviewView(handle, viewType, webviewView.title, state, cancellation);
+                }
+                catch (error) {
+                    onUnexpectedError(error);
+                    webviewView.webview.setHtml(this.mainThreadWebviews.getWebviewResolvedFailedContent(viewType));
+                }
+            }
+        });
+        this._webviewViewProviders.set(viewType, registration);
+    }
+    $unregisterWebviewViewProvider(viewType) {
+        if (!( this._webviewViewProviders.has(viewType))) {
+            throw new Error(`No view provider for ${viewType} registered`);
+        }
+        this._webviewViewProviders.deleteAndDispose(viewType);
+    }
+    getWebviewView(handle) {
+        const webviewView = this._webviewViews.get(handle);
+        if (!webviewView) {
+            throw new Error('unknown webview view');
+        }
+        return webviewView;
+    }
+};
+MainThreadWebviewsViews = ( __decorate([
+    ( __param(2, ITelemetryService)),
+    ( __param(3, IWebviewViewService))
+], MainThreadWebviewsViews));
+
+export { MainThreadWebviewsViews };

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

@@ -0,0 +1,135 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { Disposable, DisposableStore } from 'vscode/vscode/vs/base/common/lifecycle';
+import { Schemas } from 'vscode/vscode/vs/base/common/network';
+import { isWeb } from 'vscode/vscode/vs/base/common/platform';
+import { escape } from 'vscode/vscode/vs/base/common/strings';
+import { URI } from 'vscode/vscode/vs/base/common/uri';
+import { localizeWithPath } from 'vscode/vscode/vs/nls';
+import { IOpenerService } from 'vscode/vscode/vs/platform/opener/common/opener';
+import { IProductService } from 'vscode/vscode/vs/platform/product/common/productService';
+import { ExtHostContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
+import { deserializeWebviewMessage, serializeWebviewMessage } from 'vscode/vscode/vs/workbench/api/common/extHostWebviewMessaging';
+import { SerializableObjectWithBuffers } from 'vscode/vscode/vs/workbench/services/extensions/common/proxyIdentifier';
+
+var MainThreadWebviews_1;
+let MainThreadWebviews = class MainThreadWebviews extends Disposable {
+    static { MainThreadWebviews_1 = this; }
+    static { this.standardSupportedLinkSchemes = ( new Set([
+        Schemas.http,
+        Schemas.https,
+        Schemas.mailto,
+        Schemas.vscode,
+        'vscode-insider',
+    ])); }
+    constructor(context, _openerService, _productService) {
+        super();
+        this._openerService = _openerService;
+        this._productService = _productService;
+        this._webviews = ( new Map());
+        this._proxy = ( context.getProxy(ExtHostContext.ExtHostWebviews));
+    }
+    addWebview(handle, webview, options) {
+        if (( this._webviews.has(handle))) {
+            throw new Error('Webview already registered');
+        }
+        this._webviews.set(handle, webview);
+        this.hookupWebviewEventDelegate(handle, webview, options);
+    }
+    $setHtml(handle, value) {
+        this.tryGetWebview(handle)?.setHtml(value);
+    }
+    $setOptions(handle, options) {
+        const webview = this.tryGetWebview(handle);
+        if (webview) {
+            webview.contentOptions = reviveWebviewContentOptions(options);
+        }
+    }
+    async $postMessage(handle, jsonMessage, ...buffers) {
+        const webview = this.tryGetWebview(handle);
+        if (!webview) {
+            return false;
+        }
+        const { message, arrayBuffers } = deserializeWebviewMessage(jsonMessage, buffers);
+        return webview.postMessage(message, arrayBuffers);
+    }
+    hookupWebviewEventDelegate(handle, webview, options) {
+        const disposables = ( new DisposableStore());
+        disposables.add(webview.onDidClickLink((uri) => this.onDidClickLink(handle, uri)));
+        disposables.add(webview.onMessage((message) => {
+            const serialized = serializeWebviewMessage(message.message, options);
+            this._proxy.$onMessage(handle, serialized.message, ( new SerializableObjectWithBuffers(serialized.buffers)));
+        }));
+        disposables.add(webview.onMissingCsp((extension) => this._proxy.$onMissingCsp(handle, extension.value)));
+        disposables.add(webview.onDidDispose(() => {
+            disposables.dispose();
+            this._webviews.delete(handle);
+        }));
+    }
+    onDidClickLink(handle, link) {
+        const webview = this.getWebview(handle);
+        if (this.isSupportedLink(webview, ( URI.parse(link)))) {
+            this._openerService.open(link, { fromUserGesture: true, allowContributedOpeners: true, allowCommands: Array.isArray(webview.contentOptions.enableCommandUris) || webview.contentOptions.enableCommandUris === true, fromWorkspace: true });
+        }
+    }
+    isSupportedLink(webview, link) {
+        if (( MainThreadWebviews_1.standardSupportedLinkSchemes.has(link.scheme))) {
+            return true;
+        }
+        if (!isWeb && this._productService.urlProtocol === link.scheme) {
+            return true;
+        }
+        if (link.scheme === Schemas.command) {
+            if (Array.isArray(webview.contentOptions.enableCommandUris)) {
+                return webview.contentOptions.enableCommandUris.includes(link.path);
+            }
+            return webview.contentOptions.enableCommandUris === true;
+        }
+        return false;
+    }
+    tryGetWebview(handle) {
+        return this._webviews.get(handle);
+    }
+    getWebview(handle) {
+        const webview = this.tryGetWebview(handle);
+        if (!webview) {
+            throw new Error(`Unknown webview handle:${handle}`);
+        }
+        return webview;
+    }
+    getWebviewResolvedFailedContent(viewType) {
+        return `<!DOCTYPE html>
+		<html>
+			<head>
+				<meta http-equiv="Content-type" content="text/html;charset=UTF-8">
+				<meta http-equiv="Content-Security-Policy" content="default-src 'none';">
+			</head>
+			<body>${( localizeWithPath(
+            'vs/workbench/api/browser/mainThreadWebviews',
+            'errorMessage',
+            "An error occurred while loading view: {0}",
+            escape(viewType)
+        ))}</body>
+		</html>`;
+    }
+};
+MainThreadWebviews = MainThreadWebviews_1 = ( __decorate([
+    ( __param(1, IOpenerService)),
+    ( __param(2, IProductService))
+], MainThreadWebviews));
+function reviveWebviewExtension(extensionData) {
+    return {
+        id: extensionData.id,
+        location: URI.revive(extensionData.location),
+    };
+}
+function reviveWebviewContentOptions(webviewOptions) {
+    return {
+        allowScripts: webviewOptions.enableScripts,
+        allowForms: webviewOptions.enableForms,
+        enableCommandUris: webviewOptions.enableCommandUris,
+        localResourceRoots: Array.isArray(webviewOptions.localResourceRoots) ? ( webviewOptions.localResourceRoots.map(r => URI.revive(r))) : undefined,
+        portMapping: webviewOptions.portMapping,
+    };
+}
+
+export { MainThreadWebviews, reviveWebviewContentOptions, reviveWebviewExtension };

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

@@ -0,0 +1,57 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { Event } from 'vscode/vscode/vs/base/common/event';
+import { DisposableStore } from 'vscode/vscode/vs/base/common/lifecycle';
+import { URI } from 'vscode/vscode/vs/base/common/uri';
+import { IOpenerService } from 'vscode/vscode/vs/platform/opener/common/opener';
+import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
+import { MainContext, ExtHostContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
+import { IHostService } from 'vscode/vscode/vs/workbench/services/host/browser/host';
+import { IUserActivityService } from 'vscode/vscode/vs/workbench/services/userActivity/common/userActivityService';
+
+let MainThreadWindow = class MainThreadWindow {
+    constructor(extHostContext, hostService, openerService, userActivityService) {
+        this.hostService = hostService;
+        this.openerService = openerService;
+        this.userActivityService = userActivityService;
+        this.disposables = ( new DisposableStore());
+        this.proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostWindow));
+        Event.latch(hostService.onDidChangeFocus)(this.proxy.$onDidChangeWindowFocus, this.proxy, this.disposables);
+        userActivityService.onDidChangeIsActive(this.proxy.$onDidChangeWindowActive, this.proxy, this.disposables);
+    }
+    dispose() {
+        this.disposables.dispose();
+    }
+    $getInitialState() {
+        return Promise.resolve({
+            isFocused: this.hostService.hasFocus,
+            isActive: this.userActivityService.isActive,
+        });
+    }
+    async $openUri(uriComponents, uriString, options) {
+        const uri = ( URI.from(uriComponents));
+        let target;
+        if (uriString && ( ( URI.parse(uriString)).toString()) === ( uri.toString())) {
+            target = uriString;
+        }
+        else {
+            target = uri;
+        }
+        return this.openerService.open(target, {
+            openExternal: true,
+            allowTunneling: options.allowTunneling,
+            allowContributedOpeners: options.allowContributedOpeners,
+        });
+    }
+    async $asExternalUri(uriComponents, options) {
+        const result = await this.openerService.resolveExternalUri(URI.revive(uriComponents), options);
+        return result.resolved;
+    }
+};
+MainThreadWindow = __decorate([
+    extHostNamedCustomer(MainContext.MainThreadWindow),
+    ( __param(1, IHostService)),
+    ( __param(2, IOpenerService)),
+    ( __param(3, IUserActivityService))
+], MainThreadWindow);
+
+export { MainThreadWindow };