@codingame/monaco-vscode-api 1.79.7-next.1 → 1.79.7-next.2

package/dist/vscode/vs/workbench/api/browser/mainThreadLogService.js

@@ -0,0 +1,76 @@
+import { __decorate, __param } from '../../../../../node_modules/tslib/tslib.es6.js';
+import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
+import { ILoggerService, parseLogLevel, ILogService, LogLevelToString, isLogLevel, log } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { MainContext, ExtHostContext } from '../common/extHost.protocol.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { CommandsRegistry } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
+import { IEnvironmentService } from 'monaco-editor/esm/vs/platform/environment/common/environment.js';
+let MainThreadLoggerService = class MainThreadLoggerService {
+    constructor(extHostContext, loggerService) {
+        this.loggerService = loggerService;
+        this.disposables = ( new DisposableStore());
+        const proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostLogLevelServiceShape));
+        this.disposables.add(loggerService.onDidChangeLogLevel(arg => {
+            if (isLogLevel(arg)) {
+                proxy.$setLogLevel(arg);
+            }
+            else {
+                proxy.$setLogLevel(arg[1], arg[0]);
+            }
+        }));
+    }
+    $log(file, messages) {
+        const logger = this.loggerService.getLogger(URI.revive(file));
+        if (!logger) {
+            throw new Error('Create the logger before logging');
+        }
+        for (const [level, message] of messages) {
+            log(logger, level, message);
+        }
+    }
+    async $createLogger(file, options) {
+        this.loggerService.createLogger(URI.revive(file), options);
+    }
+    async $registerLogger(logResource) {
+        this.loggerService.registerLogger({
+            ...logResource,
+            resource: URI.revive(logResource.resource)
+        });
+    }
+    async $deregisterLogger(resource) {
+        this.loggerService.deregisterLogger(URI.revive(resource));
+    }
+    async $setVisibility(resource, visible) {
+        this.loggerService.setVisibility(URI.revive(resource), visible);
+    }
+    $flush(file) {
+        const logger = this.loggerService.getLogger(URI.revive(file));
+        if (!logger) {
+            throw new Error('Create the logger before flushing');
+        }
+        logger.flush();
+    }
+    dispose() {
+        this.disposables.dispose();
+    }
+};
+MainThreadLoggerService = __decorate([
+    extHostNamedCustomer(MainContext.MainThreadLogger),
+    ( __param(1, ILoggerService))
+], MainThreadLoggerService);
+CommandsRegistry.registerCommand('_extensionTests.setLogLevel', function (accessor, level) {
+    const loggerService = accessor.get(ILoggerService);
+    const environmentService = accessor.get(IEnvironmentService);
+    if (environmentService.isExtensionDevelopment && !!environmentService.extensionTestsLocationURI) {
+        const logLevel = parseLogLevel(level);
+        if (logLevel !== undefined) {
+            loggerService.setLogLevel(logLevel);
+        }
+    }
+});
+CommandsRegistry.registerCommand('_extensionTests.getLogLevel', function (accessor) {
+    const logService = accessor.get(ILogService);
+    return LogLevelToString(logService.getLevel());
+});
+export { MainThreadLoggerService };

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

@@ -0,0 +1,104 @@
+import { __decorate, __param } from '../../../../../node_modules/tslib/tslib.es6.js';
+import { Action } from 'monaco-editor/esm/vs/base/common/actions.js';
+import { isCancellationError } from 'monaco-editor/esm/vs/base/common/errors.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { Severity, INotificationService } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
+import { IOpenerService } from 'monaco-editor/esm/vs/platform/opener/common/opener.js';
+import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
+import { ExtHostContext, MainContext } from '../common/extHost.protocol.js';
+import { defaultExternalUriOpenerId } from '../../contrib/externalUriOpener/common/configuration.js';
+import { ContributedExternalUriOpenersStore } from '../../contrib/externalUriOpener/common/contributedOpeners.js';
+import { IExternalUriOpenerService } from '../../contrib/externalUriOpener/common/externalUriOpenerService.js';
+import { IExtensionService } from '../../services/extensions/common/extensions.js';
+import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
+let MainThreadUriOpeners = class MainThreadUriOpeners extends Disposable {
+    constructor(context, storageService, externalUriOpenerService, extensionService, openerService, notificationService) {
+        super();
+        this.extensionService = extensionService;
+        this.openerService = openerService;
+        this.notificationService = notificationService;
+        this._registeredOpeners = ( new Map());
+        this.proxy = ( context.getProxy(ExtHostContext.ExtHostUriOpeners));
+        this._register(externalUriOpenerService.registerExternalOpenerProvider(this));
+        this._contributedExternalUriOpenersStore = this._register(( new ContributedExternalUriOpenersStore(storageService, extensionService)));
+    }
+    async *getOpeners(targetUri) {
+        if (targetUri.scheme !== Schemas.http && targetUri.scheme !== Schemas.https) {
+            return;
+        }
+        await this.extensionService.activateByEvent(`onOpenExternalUri:${targetUri.scheme}`);
+        for (const [id, openerMetadata] of this._registeredOpeners) {
+            if (( openerMetadata.schemes.has(targetUri.scheme))) {
+                yield this.createOpener(id, openerMetadata);
+            }
+        }
+    }
+    createOpener(id, metadata) {
+        return {
+            id: id,
+            label: metadata.label,
+            canOpen: (uri, token) => {
+                return this.proxy.$canOpenUri(id, uri, token);
+            },
+            openExternalUri: async (uri, ctx, token) => {
+                try {
+                    await this.proxy.$openUri(id, { resolvedUri: uri, sourceUri: ctx.sourceUri }, token);
+                }
+                catch (e) {
+                    if (!isCancellationError(e)) {
+                        const openDefaultAction = ( new Action('default', ( localize('openerFailedUseDefault', "Open using default opener")), undefined, undefined, async () => {
+                            await this.openerService.open(uri, {
+                                allowTunneling: false,
+                                allowContributedOpeners: defaultExternalUriOpenerId,
+                            });
+                        }));
+                        openDefaultAction.tooltip = ( uri.toString());
+                        this.notificationService.notify({
+                            severity: Severity.Error,
+                            message: ( localize({
+                                key: 'openerFailedMessage',
+                                comment: ['{0} is the id of the opener. {1} is the url being opened.'],
+                            }, 'Could not open uri with \'{0}\': {1}', id, ( e.toString()))),
+                            actions: {
+                                primary: [
+                                    openDefaultAction
+                                ]
+                            }
+                        });
+                    }
+                }
+                return true;
+            },
+        };
+    }
+    async $registerUriOpener(id, schemes, extensionId, label) {
+        if (( this._registeredOpeners.has(id))) {
+            throw new Error(`Opener with id '${id}' already registered`);
+        }
+        this._registeredOpeners.set(id, {
+            schemes: ( new Set(schemes)),
+            label,
+            extensionId,
+        });
+        this._contributedExternalUriOpenersStore.didRegisterOpener(id, extensionId.value);
+    }
+    async $unregisterUriOpener(id) {
+        this._registeredOpeners.delete(id);
+        this._contributedExternalUriOpenersStore.delete(id);
+    }
+    dispose() {
+        super.dispose();
+        this._registeredOpeners.clear();
+    }
+};
+MainThreadUriOpeners = __decorate([
+    extHostNamedCustomer(MainContext.MainThreadUriOpeners),
+    ( __param(1, IStorageService)),
+    ( __param(2, IExternalUriOpenerService)),
+    ( __param(3, IExtensionService)),
+    ( __param(4, IOpenerService)),
+    ( __param(5, INotificationService))
+], MainThreadUriOpeners);
+export { MainThreadUriOpeners };

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

@@ -0,0 +1,27 @@
+import { __decorate, __param } from '../../../../../node_modules/tslib/tslib.es6.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { MainThreadCustomEditors } from './mainThreadCustomEditors.js';
+import { MainThreadWebviewPanels } from './mainThreadWebviewPanels.js';
+import { MainThreadWebviews } from './mainThreadWebviews.js';
+import { MainThreadWebviewsViews } from './mainThreadWebviewViews.js';
+import { MainContext } from '../common/extHost.protocol.js';
+import { extHostCustomer } from '../../services/extensions/common/extHostCustomers.js';
+let MainThreadWebviewManager = class MainThreadWebviewManager extends Disposable {
+    constructor(context, instantiationService) {
+        super();
+        const webviews = this._register(instantiationService.createInstance(MainThreadWebviews, context));
+        context.set(MainContext.MainThreadWebviews, 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));
+        context.set(MainContext.MainThreadCustomEditors, customEditors);
+        const webviewViews = this._register(instantiationService.createInstance(MainThreadWebviewsViews, context, webviews));
+        context.set(MainContext.MainThreadWebviewViews, webviewViews);
+    }
+};
+MainThreadWebviewManager = __decorate([
+    extHostCustomer,
+    ( __param(1, IInstantiationService))
+], MainThreadWebviewManager);
+export { MainThreadWebviewManager };

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

@@ -0,0 +1,281 @@
+import { __decorate, __param } from '../../../../../node_modules/tslib/tslib.es6.js';
+import { onUnexpectedError } from 'monaco-editor/esm/vs/base/common/errors.js';
+import { Event } from 'monaco-editor/esm/vs/base/common/event.js';
+import { Disposable, DisposableMap } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { generateUuid } from 'monaco-editor/esm/vs/base/common/uuid.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
+import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
+import { reviveWebviewExtension, reviveWebviewContentOptions } from './mainThreadWebviews.js';
+import { ExtHostContext } from '../common/extHost.protocol.js';
+import { DiffEditorInput } from '../../common/editor/diffEditorInput.js';
+import { ExtensionKeyedWebviewOriginStore } from '../../contrib/webview/browser/webview.js';
+import { WebviewInput } from '../../contrib/webviewPanel/browser/webviewEditorInput.js';
+import { IWebviewWorkbenchService } from '../../contrib/webviewPanel/browser/webviewWorkbenchService.js';
+import { editorGroupToColumn } from '../../services/editor/common/editorGroupColumn.js';
+import { preferredSideBySideGroupDirection, IEditorGroupsService } from '../../services/editor/common/editorGroupsService.js';
+import { ACTIVE_GROUP, SIDE_GROUP, IEditorService } from '../../services/editor/common/editorService.js';
+import { IExtensionService } from '../../services/extensions/common/extensions.js';
+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/dist/vscode/vs/workbench/api/browser/mainThreadWebviewViews.js

@@ -0,0 +1,98 @@
+import { __decorate, __param } from '../../../../../node_modules/tslib/tslib.es6.js';
+import { onUnexpectedError } from 'monaco-editor/esm/vs/base/common/errors.js';
+import { Disposable, DisposableMap } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { generateUuid } from 'monaco-editor/esm/vs/base/common/uuid.js';
+import { reviveWebviewExtension } from './mainThreadWebviews.js';
+import { ExtHostContext } from '../common/extHost.protocol.js';
+import { IWebviewViewService } from '../../contrib/webviewView/browser/webviewViewService.js';
+import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
+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 };