@theia/plugin-ext 1.23.0-next.3 → 1.23.0-next.35

package/src/main/browser/plugin-authentication-service.ts

@@ -0,0 +1,71 @@
+/********************************************************************************
+ * Copyright (C) 2022 EclipseSource and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the Eclipse
+ * Public License v. 2.0 are satisfied: GNU General Public License, version 2
+ * with the GNU Classpath Exception which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ ********************************************************************************/
+
+import { AuthenticationProvider, AuthenticationService, AuthenticationServiceImpl, AuthenticationSession } from '@theia/core/lib/browser/authentication-service';
+import { inject } from '@theia/core/shared/inversify';
+import { Deferred, timeoutReject } from '@theia/core/lib/common/promise-util';
+import { HostedPluginSupport } from '../../hosted/browser/hosted-plugin';
+
+export function getAuthenticationProviderActivationEvent(id: string): string { return `onAuthenticationRequest:${id}`; }
+
+/**
+ * Plugin authentiction service that aims to activate additional plugins if sessions are created or queried.
+ */
+export class PluginAuthenticationServiceImpl extends AuthenticationServiceImpl implements AuthenticationService {
+    @inject(HostedPluginSupport) protected readonly pluginService: HostedPluginSupport;
+
+    override async getSessions(id: string, scopes?: string[]): Promise<ReadonlyArray<AuthenticationSession>> {
+        await this.tryActivateProvider(id);
+        return super.getSessions(id, scopes);
+    }
+
+    override async login(id: string, scopes: string[]): Promise<AuthenticationSession> {
+        await this.tryActivateProvider(id);
+        return super.login(id, scopes);
+    }
+
+    protected async tryActivateProvider(providerId: string): Promise<AuthenticationProvider> {
+        this.pluginService.activateByEvent(getAuthenticationProviderActivationEvent(providerId));
+
+        const provider = this.authenticationProviders.get(providerId);
+        if (provider) {
+            return provider;
+        }
+
+        // When activate has completed, the extension has made the call to `registerAuthenticationProvider`.
+        // However, activate cannot block on this, so the renderer may not have gotten the event yet.
+        return Promise.race([
+            this.waitForProviderRegistration(providerId),
+            timeoutReject<AuthenticationProvider>(5000, 'Timed out waiting for authentication provider to register')
+        ]);
+    }
+
+    protected async waitForProviderRegistration(providerId: string): Promise<AuthenticationProvider> {
+        const waitForRegistration = new Deferred<AuthenticationProvider>();
+        const registration = this.onDidRegisterAuthenticationProvider(info => {
+            if (info.id === providerId) {
+                registration.dispose();
+                const provider = this.authenticationProviders.get(providerId);
+                if (provider) {
+                    waitForRegistration.resolve(provider);
+                } else {
+                    waitForRegistration.reject(new Error(`No authentication provider '${providerId}' is currently registered.`));
+                }
+            }
+        });
+        return waitForRegistration.promise;
+    }
+}

package/src/main/browser/plugin-ext-frontend-module.ts

@@ -21,7 +21,7 @@ import '../../../src/main/browser/style/comments.css';
 import { ContainerModule } from '@theia/core/shared/inversify';
 import {
     FrontendApplicationContribution, WidgetFactory, bindViewContribution,
-    ViewContainerIdentifier, ViewContainer, createTreeContainer, TreeImpl, TreeWidget, TreeModelImpl, LabelProviderContribution
+    ViewContainerIdentifier, ViewContainer, createTreeContainer, TreeWidget, LabelProviderContribution
 } from '@theia/core/lib/browser';
 import { MaybePromise, CommandContribution, ResourceResolver, bindContributionProvider } from '@theia/core/lib/common';
 import { WebSocketConnectionProvider } from '@theia/core/lib/browser/messaging';
@@ -76,6 +76,8 @@ import { CustomEditorWidget } from './custom-editors/custom-editor-widget';
 import { CustomEditorService } from './custom-editors/custom-editor-service';
 import { UndoRedoService } from './custom-editors/undo-redo-service';
 import { WebviewFrontendSecurityWarnings } from './webview/webview-frontend-security-warnings';
+import { PluginAuthenticationServiceImpl } from './plugin-authentication-service';
+import { AuthenticationService } from '@theia/core/lib/browser/authentication-service';
 
 export default new ContainerModule((bind, unbind, isBound, rebind) => {
 
@@ -145,21 +147,21 @@ export default new ContainerModule((bind, unbind, isBound, rebind) => {
     bind(WidgetFactory).toDynamicValue(({ container }) => ({
         id: PLUGIN_VIEW_DATA_FACTORY_ID,
         createWidget: (identifier: TreeViewWidgetIdentifier) => {
-            const child = createTreeContainer(container, {
+            const props = {
                 contextMenuPath: VIEW_ITEM_CONTEXT_MENU,
                 expandOnlyOnExpansionToggleClick: true,
                 expansionTogglePadding: 22,
                 globalSelection: true,
                 leftPadding: 8,
                 search: true
+            };
+            const child = createTreeContainer(container, {
+                props,
+                tree: PluginTree,
+                model: PluginTreeModel,
+                widget: TreeViewWidget,
             });
             child.bind(TreeViewWidgetIdentifier).toConstantValue(identifier);
-            child.bind(PluginTree).toSelf();
-            child.rebind(TreeImpl).toService(PluginTree);
-            child.bind(PluginTreeModel).toSelf();
-            child.rebind(TreeModelImpl).toService(PluginTreeModel);
-            child.bind(TreeViewWidget).toSelf();
-            child.rebind(TreeWidget).toService(TreeViewWidget);
             return child.get(TreeWidget);
         }
     })).inSingletonScope();
@@ -234,4 +236,7 @@ export default new ContainerModule((bind, unbind, isBound, rebind) => {
 
     bind(WebviewFrontendSecurityWarnings).toSelf().inSingletonScope();
     bind(FrontendApplicationContribution).toService(WebviewFrontendSecurityWarnings);
+
+    bind(PluginAuthenticationServiceImpl).toSelf().inSingletonScope();
+    rebind(AuthenticationService).toService(PluginAuthenticationServiceImpl);
 });

package/src/main/browser/plugin-ext-widget.tsx

@@ -52,7 +52,7 @@ export class PluginWidget extends ReactWidget {
         this.toDispose.push(this.pluginService.onDidChangePlugins(() => this.update()));
     }
 
-    protected onActivateRequest(msg: Message): void {
+    protected override onActivateRequest(msg: Message): void {
         super.onActivateRequest(msg);
         this.node.focus();
     }

package/src/main/browser/view/plugin-view-registry.ts

@@ -20,7 +20,7 @@ import {
     ViewContainerIdentifier, ViewContainerTitleOptions, Widget, FrontendApplicationContribution,
     StatefulWidget, CommonMenus, BaseWidget, TreeViewWelcomeWidget, codicon, ViewContainerPart
 } from '@theia/core/lib/browser';
-import { ViewContainer, View, ViewWelcome } from '../../../common';
+import { ViewContainer, View, ViewWelcome, PluginViewType } from '../../../common';
 import { PluginSharedStyle } from '../plugin-shared-style';
 import { DebugWidget } from '@theia/debug/lib/browser/view/debug-widget';
 import { PluginViewWidget, PluginViewWidgetIdentifier } from './plugin-view-widget';
@@ -31,7 +31,7 @@ import { DebugFrontendApplicationContribution } from '@theia/debug/lib/browser/d
 import { Disposable, DisposableCollection } from '@theia/core/lib/common/disposable';
 import { CommandRegistry } from '@theia/core/lib/common/command';
 import { MenuModelRegistry } from '@theia/core/lib/common/menu';
-import { Emitter } from '@theia/core/lib/common/event';
+import { Emitter, Event } from '@theia/core/lib/common/event';
 import { ContextKeyService } from '@theia/core/lib/browser/context-key-service';
 import { ViewContextKeyService } from './view-context-key-service';
 import { PROBLEMS_WIDGET_ID } from '@theia/markers/lib/browser/problem/problem-widget';
@@ -41,6 +41,11 @@ import { TERMINAL_WIDGET_FACTORY_ID } from '@theia/terminal/lib/browser/terminal
 import { TreeViewWidget } from './tree-view-widget';
 import { SEARCH_VIEW_CONTAINER_ID } from '@theia/search-in-workspace/lib/browser/search-in-workspace-factory';
 
+import { WebviewView, WebviewViewResolver } from '../webview-views/webview-views';
+import { WebviewWidget, WebviewWidgetIdentifier } from '../webview/webview';
+import { CancellationToken } from '@theia/core/lib/common/cancellation';
+import { v4 } from 'uuid';
+
 export const PLUGIN_VIEW_FACTORY_ID = 'plugin-view';
 export const PLUGIN_VIEW_CONTAINER_FACTORY_ID = 'plugin-view-container';
 export const PLUGIN_VIEW_DATA_FACTORY_ID = 'plugin-view-data';
@@ -95,6 +100,8 @@ export class PluginViewRegistry implements FrontendApplicationContribution {
     private readonly viewDataProviders = new Map<string, ViewDataProvider>();
     private readonly viewDataState = new Map<string, object>();
 
+    private readonly webviewViewResolvers = new Map<string, WebviewViewResolver>();
+
     @postConstruct()
     protected init(): void {
         // VS Code Viewlets
@@ -333,6 +340,63 @@ export class PluginViewRegistry implements FrontendApplicationContribution {
         return toDispose;
     }
 
+    async registerWebviewView(viewId: string, resolver: WebviewViewResolver): Promise<Disposable> {
+        if (this.webviewViewResolvers.has(viewId)) {
+            throw new Error(`View resolver already registered for ${viewId}`);
+        }
+        this.webviewViewResolvers.set(viewId, resolver);
+
+        const webviewView = await this.createNewWebviewView();
+        const token = CancellationToken.None;
+        this.getView(viewId).then(async view => {
+            if (view) {
+                if (view.isVisible) {
+                    await this.prepareView(view, webviewView.webview.identifier.id);
+                } else {
+                    const toDisposeOnDidExpandView = new DisposableCollection(this.onDidExpandView(async id => {
+                        if (id === viewId) {
+                            dispose();
+                            await this.prepareView(view, webviewView.webview.identifier.id);
+                        }
+                    }));
+                    const dispose = () => toDisposeOnDidExpandView.dispose();
+                    view.disposed.connect(dispose);
+                    toDisposeOnDidExpandView.push(Disposable.create(() => view.disposed.disconnect(dispose)));
+                }
+            }
+        });
+
+        resolver.resolve(webviewView, token);
+
+        return Disposable.create(() => {
+            this.webviewViewResolvers.delete(viewId);
+        });
+    }
+
+    async createNewWebviewView(): Promise<WebviewView> {
+        const webview = await this.widgetManager.getOrCreateWidget<WebviewWidget>(
+            WebviewWidget.FACTORY_ID, <WebviewWidgetIdentifier>{ id: v4() });
+        webview.setContentOptions({ allowScripts: true });
+
+        let _description: string | undefined;
+
+        return {
+            webview,
+
+            get onDidChangeVisibility(): Event<boolean> { return webview.onDidChangeVisibility; },
+            get onDidDispose(): Event<void> { return webview.onDidDispose; },
+
+            get title(): string | undefined { return webview.title.label; },
+            set title(value: string | undefined) { webview.title.label = value || ''; },
+
+            get description(): string | undefined { return _description; },
+            set description(value: string | undefined) { _description = value; },
+
+            dispose: webview.dispose,
+            show: webview.show
+        };
+    }
+
     registerViewWelcome(viewWelcome: ViewWelcome): Disposable {
         const toDispose = new DisposableCollection();
 
@@ -409,7 +473,7 @@ export class PluginViewRegistry implements FrontendApplicationContribution {
         return this.getView(viewId);
     }
 
-    protected async prepareView(widget: PluginViewWidget): Promise<void> {
+    protected async prepareView(widget: PluginViewWidget, webviewId?: string): Promise<void> {
         const data = this.views.get(widget.options.viewId);
         if (!data) {
             return;
@@ -419,7 +483,7 @@ export class PluginViewRegistry implements FrontendApplicationContribution {
             widget.title.label = view.name;
         }
         const currentDataWidget = widget.widgets[0];
-        const viewDataWidget = await this.createViewDataWidget(view.id);
+        const viewDataWidget = await this.createViewDataWidget(view.id, webviewId);
         if (widget.isDisposed) {
             // eslint-disable-next-line no-unused-expressions
             viewDataWidget?.dispose();
@@ -701,8 +765,12 @@ export class PluginViewRegistry implements FrontendApplicationContribution {
         return toDispose;
     }
 
-    protected async createViewDataWidget(viewId: string): Promise<Widget | undefined> {
+    protected async createViewDataWidget(viewId: string, webviewId?: string): Promise<Widget | undefined> {
         const view = this.views.get(viewId);
+        if (view?.[1]?.type === PluginViewType.Webview) {
+            const webviewWidget = this.widgetManager.getWidget(WebviewWidget.FACTORY_ID, <WebviewWidgetIdentifier>{ id: webviewId });
+            return webviewWidget;
+        }
         const provider = this.viewDataProviders.get(viewId);
         if (!view || !provider) {
             return undefined;

package/src/main/browser/view/plugin-view-widget.ts

@@ -66,7 +66,7 @@ export class PluginViewWidget extends Panel implements StatefulWidget, Descripti
         this.toDispose.push(localContext);
     }
 
-    protected onActivateRequest(msg: Message): void {
+    protected override onActivateRequest(msg: Message): void {
         super.onActivateRequest(msg);
         const widget = this.widgets[0];
         if (widget) {
@@ -144,17 +144,17 @@ export class PluginViewWidget extends Panel implements StatefulWidget, Descripti
         }
     }
 
-    addWidget(widget: Widget): void {
+    override addWidget(widget: Widget): void {
         super.addWidget(widget);
         this.updateWidgetMessage();
     }
 
-    insertWidget(index: number, widget: Widget): void {
+    override insertWidget(index: number, widget: Widget): void {
         super.insertWidget(index, widget);
         this.updateWidgetMessage();
     }
 
-    dispose(): void {
+    override dispose(): void {
         this.toDispose.dispose();
         super.dispose();
     }

package/src/main/browser/view/tree-view-widget.tsx

@@ -118,7 +118,7 @@ export class PluginTree extends TreeImpl {
         return this._isEmpty;
     }
 
-    protected async resolveChildren(parent: CompositeTreeNode): Promise<TreeNode[]> {
+    protected override async resolveChildren(parent: CompositeTreeNode): Promise<TreeNode[]> {
         if (!this._proxy) {
             return super.resolveChildren(parent);
         }
@@ -204,7 +204,7 @@ export class PluginTree extends TreeImpl {
 export class PluginTreeModel extends TreeModelImpl {
 
     @inject(PluginTree)
-    protected readonly tree: PluginTree;
+    protected override readonly tree: PluginTree;
 
     set proxy(proxy: TreeViewsExt | undefined) {
         this.tree.proxy = proxy;
@@ -242,7 +242,7 @@ export class TreeViewWidget extends TreeViewWelcomeWidget {
     readonly identifier: TreeViewWidgetIdentifier;
 
     @inject(PluginTreeModel)
-    readonly model: PluginTreeModel;
+    override readonly model: PluginTreeModel;
 
     @inject(ContextKeyService)
     protected readonly contextKeyService: ContextKeyService;
@@ -250,11 +250,8 @@ export class TreeViewWidget extends TreeViewWelcomeWidget {
     @inject(TooltipService)
     protected readonly tooltipService: TooltipService;
 
-    protected readonly onDidChangeVisibilityEmitter = new Emitter<boolean>();
-    readonly onDidChangeVisibility = this.onDidChangeVisibilityEmitter.event;
-
     @postConstruct()
-    protected init(): void {
+    protected override init(): void {
         super.init();
         this.id = this.identifier.id;
         this.addClass('theia-tree-view');
@@ -265,7 +262,7 @@ export class TreeViewWidget extends TreeViewWelcomeWidget {
         this.toDispose.push(this.onDidChangeVisibilityEmitter);
     }
 
-    protected renderIcon(node: TreeNode, props: NodeProps): React.ReactNode {
+    protected override renderIcon(node: TreeNode, props: NodeProps): React.ReactNode {
         const icon = this.toNodeIcon(node);
         if (icon) {
             return <div className={icon + ' theia-tree-view-icon'}></div>;
@@ -273,7 +270,7 @@ export class TreeViewWidget extends TreeViewWelcomeWidget {
         return undefined;
     }
 
-    protected renderCaption(node: TreeViewNode, props: NodeProps): React.ReactNode {
+    protected override renderCaption(node: TreeViewNode, props: NodeProps): React.ReactNode {
         const classes = [TREE_NODE_SEGMENT_CLASS];
         if (!this.hasTrailingSuffixes(node)) {
             classes.push(TREE_NODE_SEGMENT_GROW_CLASS);
@@ -325,7 +322,7 @@ export class TreeViewWidget extends TreeViewWelcomeWidget {
         return React.createElement('div', attrs, ...children);
     }
 
-    protected renderTailDecorations(node: TreeViewNode, props: NodeProps): React.ReactNode {
+    protected override renderTailDecorations(node: TreeViewNode, props: NodeProps): React.ReactNode {
         return this.contextKeys.with({ view: this.id, viewItem: node.contextValue }, () => {
             const menu = this.menus.getMenu(VIEW_ITEM_INLINE_MENU);
             const arg = this.toTreeViewSelection(node);
@@ -352,30 +349,30 @@ export class TreeViewWidget extends TreeViewWelcomeWidget {
         }} />;
     }
 
-    protected toContextMenuArgs(node: SelectableTreeNode): [TreeViewSelection] {
+    protected override toContextMenuArgs(node: SelectableTreeNode): [TreeViewSelection] {
         return [this.toTreeViewSelection(node)];
     }
 
-    setFlag(flag: Widget.Flag): void {
+    override setFlag(flag: Widget.Flag): void {
         super.setFlag(flag);
         if (flag === Widget.Flag.IsVisible) {
             this.onDidChangeVisibilityEmitter.fire(this.isVisible);
         }
     }
 
-    clearFlag(flag: Widget.Flag): void {
+    override clearFlag(flag: Widget.Flag): void {
         super.clearFlag(flag);
         if (flag === Widget.Flag.IsVisible) {
             this.onDidChangeVisibilityEmitter.fire(this.isVisible);
         }
     }
 
-    handleEnter(event: KeyboardEvent): void {
+    override handleEnter(event: KeyboardEvent): void {
         super.handleEnter(event);
         this.tryExecuteCommand();
     }
 
-    handleClickEvent(node: TreeNode, event: React.MouseEvent<HTMLElement>): void {
+    override handleClickEvent(node: TreeNode, event: React.MouseEvent<HTMLElement>): void {
         super.handleClickEvent(node, event);
         // If clicked on item (not collapsable icon) - execute command or toggle expansion if item has no command
         const commandMap = this.findCommands(node);
@@ -418,7 +415,7 @@ export class TreeViewWidget extends TreeViewWelcomeWidget {
         this.update();
     }
 
-    protected render(): React.ReactNode {
+    protected override render(): React.ReactNode {
         const node = React.createElement('div', this.createContainerAttributes(), this.renderSearchInfo(), this.renderTree(this.model));
         this.tooltipService.update();
         return node;
@@ -431,7 +428,7 @@ export class TreeViewWidget extends TreeViewWelcomeWidget {
         return undefined;
     }
 
-    shouldShowWelcomeView(): boolean {
+    override shouldShowWelcomeView(): boolean {
         return (this.model.proxy === undefined || this.model.isTreeEmpty) && this.message === undefined;
     }
 }

package/src/main/browser/view-column-service.ts

@@ -32,7 +32,7 @@ export class ViewColumnService {
     ) {
         let oldColumnValues = new Map<string, number>();
         const update = async () => {
-            await new Promise((resolve => setTimeout(() => resolve())));
+            await new Promise<void>((resolve => setTimeout(resolve)));
             this.updateViewColumns();
             this.viewColumnIds.forEach((ids: string[], viewColumn: number) => {
                 ids.forEach((id: string) => {

package/src/main/browser/webview/webview.ts

@@ -198,14 +198,14 @@ export class WebviewWidget extends BaseWidget implements StatefulWidget {
         }));
     }
 
-    protected onBeforeAttach(msg: Message): void {
+    protected override onBeforeAttach(msg: Message): void {
         super.onBeforeAttach(msg);
         this.doShow();
         // iframe has to be reloaded when moved to another DOM element
         this.toDisposeOnDetach.push(Disposable.create(() => this.forceHide()));
     }
 
-    protected onAfterAttach(msg: Message): void {
+    protected override onAfterAttach(msg: Message): void {
         super.onAfterAttach(msg);
         this.addEventListener(this.node, 'focus', () => {
             if (this.element) {
@@ -214,12 +214,12 @@ export class WebviewWidget extends BaseWidget implements StatefulWidget {
         });
     }
 
-    protected onBeforeShow(msg: Message): void {
+    protected override onBeforeShow(msg: Message): void {
         super.onBeforeShow(msg);
         this.doShow();
     }
 
-    protected onAfterHide(msg: Message): void {
+    protected override onAfterHide(msg: Message): void {
         super.onAfterHide(msg);
         this.doHide();
     }
@@ -410,7 +410,7 @@ export class WebviewWidget extends BaseWidget implements StatefulWidget {
             });
     }
 
-    protected onActivateRequest(msg: Message): void {
+    protected override onActivateRequest(msg: Message): void {
         super.onActivateRequest(msg);
         this.node.focus();
     }

package/src/main/browser/webview-views/webview-views-main.ts

@@ -0,0 +1,142 @@
+/********************************************************************************
+ * Copyright (C) 2021 SAP SE or an SAP affiliate company and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the Eclipse
+ * Public License v. 2.0 are satisfied: GNU General Public License, version 2
+ * with the GNU Classpath Exception which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ ********************************************************************************/
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+// some code copied and modified from https://github.com/microsoft/vscode/blob/e1f0f8f51390dea5df9096718fb6b647ed5a9534/src/vs/workbench/api/browser/mainThreadWebviewViews.ts
+
+import { inject, interfaces } from '@theia/core/shared/inversify';
+import { WebviewViewsMain, MAIN_RPC_CONTEXT, WebviewViewsExt } from '../../../common/plugin-api-rpc';
+import { RPCProtocol } from '../../../common/rpc-protocol';
+import { Disposable, DisposableCollection, ILogger } from '@theia/core';
+import { WebviewView } from './webview-views';
+import { CancellationToken } from '@theia/core/lib/common/cancellation';
+import { WebviewsMainImpl } from '../webviews-main';
+import { Widget, WidgetManager } from '@theia/core/lib/browser';
+import { PluginViewRegistry } from '../view/plugin-view-registry';
+
+export class WebviewViewsMainImpl implements WebviewViewsMain, Disposable {
+
+    protected readonly proxy: WebviewViewsExt;
+    protected readonly toDispose = new DisposableCollection(
+        Disposable.create(() => { /* mark as not disposed */ })
+    );
+
+    protected readonly webviewViews = new Map<string, WebviewView>();
+    protected readonly webviewViewProviders = new Map<string, Disposable>();
+    protected readonly widgetManager: WidgetManager;
+    protected readonly pluginViewRegistry: PluginViewRegistry;
+
+    @inject(ILogger)
+    protected readonly logger: ILogger;
+
+    constructor(rpc: RPCProtocol,
+        container: interfaces.Container,
+        readonly webviewsMain: WebviewsMainImpl
+    ) {
+        this.proxy = rpc.getProxy(MAIN_RPC_CONTEXT.WEBVIEW_VIEWS_EXT);
+        this.widgetManager = container.get(WidgetManager);
+        this.pluginViewRegistry = container.get(PluginViewRegistry);
+    }
+
+    dispose(): void {
+        this.toDispose.dispose();
+    }
+
+    async $registerWebviewViewProvider(viewType: string, options: { retainContextWhenHidden?: boolean, serializeBuffersForPostMessage: boolean }): Promise<void> {
+
+        if (this.webviewViewProviders.has(viewType)) {
+            throw new Error(`View provider for ${viewType} already registered`);
+        }
+
+        const registration = await this.pluginViewRegistry.registerWebviewView(viewType, {
+            resolve: async (webviewView: WebviewView, cancellation: CancellationToken) => {
+                const handle = webviewView.webview.identifier.id;
+                this.webviewViews.set(handle, webviewView);
+                this.webviewsMain.hookWebview(webviewView.webview);
+
+                let state: string | undefined;
+                if (webviewView.webview.state) {
+                    try {
+                        state = JSON.parse(webviewView.webview.state);
+                        console.log(state);
+                    } catch (e) {
+                        console.error('Could not load webview state', e, webviewView.webview.state);
+                    }
+                }
+                if (options) {
+                    webviewView.webview.options = options;
+                }
+
+                webviewView.onDidChangeVisibility(visible => {
+                    this.proxy.$onDidChangeWebviewViewVisibility(handle, visible);
+                });
+
+                webviewView.onDidDispose(() => {
+                    this.proxy.$disposeWebviewView(handle);
+                    this.webviewViews.delete(handle);
+                });
+
+                try {
+                    this.proxy.$resolveWebviewView(handle, viewType, webviewView.title, state, cancellation);
+                } catch (error) {
+                    this.logger.error(`Error resolving webview view '${viewType}': ${error}`);
+                    webviewView.webview.setHTML('failed to load plugin webview view');
+                }
+            }
+        });
+
+        this.webviewViewProviders.set(viewType, registration);
+    }
+
+    protected getWebview(handle: string): Widget | undefined {
+        return this.widgetManager.tryGetWidget(handle);
+    }
+
+    $unregisterWebviewViewProvider(viewType: string): void {
+        const provider = this.webviewViewProviders.get(viewType);
+        if (!provider) {
+            throw new Error(`No view provider for ${viewType} registered`);
+        }
+        provider.dispose();
+        this.webviewViewProviders.delete(viewType);
+    }
+
+    $setWebviewViewTitle(handle: string, value: string | undefined): void {
+        const webviewView = this.getWebviewView(handle);
+        webviewView.title = value;
+    }
+
+    $setWebviewViewDescription(handle: string, value: string | undefined): void {
+        const webviewView = this.getWebviewView(handle);
+        webviewView.description = value;
+    }
+
+    $show(handle: string, preserveFocus: boolean): void {
+        const webviewView = this.getWebviewView(handle);
+        webviewView.show(preserveFocus);
+    }
+
+    protected getWebviewView(handle: string): WebviewView {
+        const webviewView = this.webviewViews.get(handle);
+        if (!webviewView) {
+            throw new Error(`No webview view registered for handle '${handle}'`);
+        }
+        return webviewView;
+    }
+
+}

package/src/main/browser/webview-views/webview-views.ts

@@ -0,0 +1,38 @@
+/********************************************************************************
+ * Copyright (C) 2021 SAP SE or an SAP affiliate company and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the Eclipse
+ * Public License v. 2.0 are satisfied: GNU General Public License, version 2
+ * with the GNU Classpath Exception which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ ********************************************************************************/
+/*---------------------------------------------------------------------------------------------
+*  Copyright (c) Microsoft Corporation. All rights reserved.
+*  Licensed under the MIT License. See License.txt in the project root for license information.
+*--------------------------------------------------------------------------------------------*/
+// copied and modified from https://github.com/microsoft/vscode/blob/a4a4cf5ace4472bc4f5176396bb290cafa15c518/src/vs/workbench/contrib/webviewView/browser/webviewViewService.ts
+
+import { CancellationToken, Event } from '@theia/core/lib/common';
+import { WebviewWidget } from '../webview/webview';
+
+export interface WebviewView {
+    title?: string;
+    description?: string;
+    readonly webview: WebviewWidget;
+    readonly onDidChangeVisibility: Event<boolean>;
+    readonly onDidDispose: Event<void>;
+
+    dispose(): void;
+    show(preserveFocus: boolean): void;
+}
+
+export interface WebviewViewResolver {
+    resolve(webviewView: WebviewView, cancellation: CancellationToken): Promise<void>;
+}