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

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

@@ -1,283 +0,0 @@
-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

@@ -1,100 +0,0 @@
-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

@@ -1,135 +0,0 @@
-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

@@ -1,57 +0,0 @@
-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 };