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

package/src/plugin/plugin-context.ts

@@ -173,6 +173,7 @@ import { TimelineExtImpl } from './timeline';
 import { ThemingExtImpl } from './theming';
 import { CommentsExtImpl } from './comments';
 import { CustomEditorsExtImpl } from './custom-editors';
+import { WebviewViewsExtImpl } from './webview-views';
 
 export function createAPIFactory(
     rpc: RPCProtocol,
@@ -211,18 +212,36 @@ export function createAPIFactory(
     const themingExt = rpc.set(MAIN_RPC_CONTEXT.THEMING_EXT, new ThemingExtImpl(rpc));
     const commentsExt = rpc.set(MAIN_RPC_CONTEXT.COMMENTS_EXT, new CommentsExtImpl(rpc, commandRegistry, documents));
     const customEditorExt = rpc.set(MAIN_RPC_CONTEXT.CUSTOM_EDITORS_EXT, new CustomEditorsExtImpl(rpc, documents, webviewExt, workspaceExt));
+    const webviewViewsExt = rpc.set(MAIN_RPC_CONTEXT.WEBVIEW_VIEWS_EXT, new WebviewViewsExtImpl(rpc, webviewExt));
     rpc.set(MAIN_RPC_CONTEXT.DEBUG_EXT, debugExt);
 
     return function (plugin: InternalPlugin): typeof theia {
         const authentication: typeof theia.authentication = {
-            registerAuthenticationProvider(provider: theia.AuthenticationProvider): theia.Disposable {
-                return authenticationExt.registerAuthenticationProvider(provider);
+            // support older (< 1.53.0) and newer version of authentication provider registration
+            registerAuthenticationProvider(
+                id: string | theia.AuthenticationProvider, label?: string, provider?: theia.AuthenticationProvider, options?: theia.AuthenticationProviderOptions):
+                theia.Disposable {
+                // collect registration data based on registration type: new (all parameters given) vs old (data stored in provider)
+                const isNewRegistration = typeof id === 'string';
+                const regProvider = isNewRegistration ? provider! : id;
+                const regId = isNewRegistration ? id : regProvider.id;
+                const regLabel = isNewRegistration ? label! : regProvider.label;
+                const regOptions = isNewRegistration ? options : { supportsMultipleAccounts: regProvider.supportsMultipleAccounts };
+
+                // ensure that all methods of the new AuthenticationProvider are available or delegate otherwise
+                if (!regProvider['createSession']) {
+                    regProvider['createSession'] = (scopes: string[]) => regProvider.login(scopes);
+                }
+                if (!regProvider['removeSession']) {
+                    regProvider['removeSession'] = (sessionId: string) => regProvider.logout(sessionId);
+                }
+                return authenticationExt.registerAuthenticationProvider(regId, regLabel, regProvider, regOptions);
             },
             get onDidChangeAuthenticationProviders(): theia.Event<theia.AuthenticationProvidersChangeEvent> {
                 return authenticationExt.onDidChangeAuthenticationProviders;
             },
             getProviderIds(): Thenable<ReadonlyArray<string>> {
-                return authenticationExt.getProviderIds();
+                return Promise.resolve(authenticationExt.providerIds);
             },
             get providerIds(): string[] {
                 return authenticationExt.providerIds;
@@ -238,6 +257,10 @@ export function createAPIFactory(
             },
             get onDidChangeSessions(): theia.Event<theia.AuthenticationSessionsChangeEvent> {
                 return authenticationExt.onDidChangeSessions;
+            },
+            async hasSession(providerId: string, scopes: readonly string[]): Promise<boolean> {
+                const session = await authenticationExt.getSession(plugin, providerId, scopes, { silent: true });
+                return !!session;
             }
         };
         const commands: typeof theia.commands = {
@@ -390,8 +413,22 @@ export function createAPIFactory(
             showInputBox(options?: theia.InputBoxOptions, token?: theia.CancellationToken): PromiseLike<string | undefined> {
                 return quickOpenExt.showInput(options, token);
             },
-            createStatusBarItem(alignment?: theia.StatusBarAlignment, priority?: number): theia.StatusBarItem {
-                return statusBarMessageRegistryExt.createStatusBarItem(alignment, priority);
+            createStatusBarItem(alignmentOrId?: theia.StatusBarAlignment | string, priorityOrAlignment?: number | theia.StatusBarAlignment,
+                priorityArg?: number): theia.StatusBarItem {
+                let id: string | undefined;
+                let alignment: number | undefined;
+                let priority: number | undefined;
+
+                if (typeof alignmentOrId === 'string') {
+                    id = alignmentOrId;
+                    alignment = priorityOrAlignment;
+                    priority = priorityArg;
+                } else {
+                    alignment = alignmentOrId;
+                    priority = priorityOrAlignment;
+                }
+
+                return statusBarMessageRegistryExt.createStatusBarItem(alignment, priority, id);
             },
             createOutputChannel(name: string): theia.OutputChannel {
                 return outputChannelRegistryExt.createOutputChannel(name, pluginToPluginInfo(plugin));
@@ -410,6 +447,15 @@ export function createAPIFactory(
                 options: { webviewOptions?: theia.WebviewPanelOptions, supportsMultipleEditorsPerDocument?: boolean } = {}): theia.Disposable {
                 return customEditorExt.registerCustomEditorProvider(viewType, provider, options, plugin);
             },
+            registerWebviewViewProvider(viewType: string,
+                provider: theia.WebviewViewProvider,
+                options?: {
+                    webviewOptions?: {
+                        retainContextWhenHidden?: boolean
+                    }
+                }): theia.Disposable {
+                return webviewViewsExt.registerWebviewViewProvider(viewType, provider, plugin, options?.webviewOptions);
+            },
             get state(): theia.WindowState {
                 return windowStateExt.getWindowState();
             },
@@ -571,6 +617,15 @@ export function createAPIFactory(
             },
             registerTimelineProvider(scheme: string | string[], provider: theia.TimelineProvider): theia.Disposable {
                 return timelineExt.registerTimelineProvider(plugin, scheme, provider);
+            },
+            get isTrusted(): boolean {
+                return workspaceExt.trusted;
+            },
+            async requestWorkspaceTrust(options?: theia.WorkspaceTrustRequestOptions): Promise<boolean | undefined> {
+                return workspaceExt.requestWorkspaceTrust(options);
+            },
+            get onDidGrantWorkspaceTrust(): theia.Event<void> {
+                return workspaceExt.onDidGrantWorkspaceTrust;
             }
         };
 
@@ -1043,7 +1098,7 @@ export class PluginExt<T> extends Plugin<T> implements ExtensionPlugin<T> {
     extensionUri: theia.Uri;
     extensionKind: ExtensionKind;
 
-    constructor(protected readonly pluginManager: PluginManager, plugin: InternalPlugin) {
+    constructor(protected override readonly pluginManager: PluginManager, plugin: InternalPlugin) {
         super(pluginManager, plugin);
 
         this.extensionPath = this.pluginPath;
@@ -1051,15 +1106,15 @@ export class PluginExt<T> extends Plugin<T> implements ExtensionPlugin<T> {
         this.extensionKind = ExtensionKind.UI; // stub as a local extension (not running on a remote workspace)
     }
 
-    get isActive(): boolean {
+    override get isActive(): boolean {
         return this.pluginManager.isActive(this.id);
     }
 
-    get exports(): T {
+    override get exports(): T {
         return <T>this.pluginManager.getPluginExport(this.id);
     }
 
-    activate(): PromiseLike<T> {
+    override activate(): PromiseLike<T> {
         return this.pluginManager.activatePlugin(this.id).then(() => this.exports);
     }
 }

package/src/plugin/plugin-manager.ts

@@ -91,7 +91,8 @@ export class PluginManagerExtImpl implements PluginManagerExt, PluginManager {
         'onWebviewPanel',
         'onFileSystem',
         'onCustomEditor',
-        'onStartupFinished'
+        'onStartupFinished',
+        'onAuthenticationRequest'
     ]);
 
     private configStorage: ConfigStorage | undefined;

package/src/plugin/quick-open.ts

@@ -492,11 +492,12 @@ export class InputBoxExt extends QuickInputExt implements InputBox {
     private _prompt: string | undefined;
     private _validationMessage: string | undefined;
 
-    constructor(readonly quickOpen: QuickOpenExtImpl,
-        readonly quickOpenMain: QuickOpenMain,
-        readonly plugin: Plugin,
-        onDispose: () => void) {
-
+    constructor(
+        override readonly quickOpen: QuickOpenExtImpl,
+        override readonly quickOpenMain: QuickOpenMain,
+        override readonly plugin: Plugin,
+        onDispose: () => void
+    ) {
         super(quickOpen, quickOpenMain, plugin, onDispose);
 
         this.buttons = [];
@@ -533,7 +534,7 @@ export class InputBoxExt extends QuickInputExt implements InputBox {
         }
     }
 
-    async show(): Promise<void> {
+    override async show(): Promise<void> {
         super.show();
 
         const update = (value: string) => {
@@ -584,11 +585,12 @@ export class QuickPickExt<T extends theia.QuickPickItem> extends QuickInputExt i
     private readonly _onDidChangeActiveEmitter = new Emitter<T[]>();
     private readonly _onDidChangeSelectionEmitter = new Emitter<T[]>();
 
-    constructor(readonly quickOpen: QuickOpenExtImpl,
-        readonly quickOpenMain: QuickOpenMain,
-        readonly plugin: Plugin,
-        onDispose: () => void) {
-
+    constructor(
+        override readonly quickOpen: QuickOpenExtImpl,
+        override readonly quickOpenMain: QuickOpenMain,
+        override readonly plugin: Plugin,
+        onDispose: () => void
+    ) {
         super(quickOpen, quickOpenMain, plugin, onDispose);
         this.buttons = [];
 

package/src/plugin/status-bar/status-bar-item.ts

@@ -20,7 +20,7 @@ import { UUID } from '@theia/core/shared/@phosphor/coreutils';
 
 export class StatusBarItemImpl implements theia.StatusBarItem {
 
-    private readonly id = StatusBarItemImpl.nextId();
+    private _id: string;
 
     private _alignment: StatusBarAlignment;
     private _priority: number;
@@ -37,10 +37,16 @@ export class StatusBarItemImpl implements theia.StatusBarItem {
 
     constructor(_proxy: StatusBarMessageRegistryMain,
         alignment: StatusBarAlignment = StatusBarAlignment.Left,
-        priority: number = 0) {
+        priority: number = 0,
+        id = StatusBarItemImpl.nextId()) {
         this._proxy = _proxy;
         this._alignment = alignment;
         this._priority = priority;
+        this._id = id;
+    }
+
+    public get id(): string {
+        return this._id;
     }
 
     public get alignment(): theia.StatusBarAlignment {

package/src/plugin/status-bar-message-registry.ts

@@ -57,9 +57,10 @@ export class StatusBarMessageRegistryExt {
 
     }
 
-    createStatusBarItem(alignment?: StatusBarAlignment, priority?: number): StatusBarItem {
-        return new StatusBarItemImpl(this.proxy, alignment, priority);
+    createStatusBarItem(alignment?: StatusBarAlignment, priority?: number, id?: string): StatusBarItem {
+        return new StatusBarItemImpl(this.proxy, alignment, priority, id);
     }
+
 }
 
 // copied from https://github.com/Microsoft/vscode/blob/6c8f02b41db9ae5c4d15df767d47755e5c73b9d5/src/vs/workbench/api/node/extHostStatusBar.ts#L122

package/src/plugin/types-impl.ts

@@ -68,7 +68,7 @@ export class URI extends CodeURI implements theia.Uri {
     /**
      * Override to create the correct class.
      */
-    with(change: {
+    override with(change: {
         scheme?: string;
         authority?: string | null;
         path?: string | null;
@@ -90,19 +90,19 @@ export class URI extends CodeURI implements theia.Uri {
      * Override to create the correct class.
      * @param data
      */
-    static revive(data: UriComponents | CodeURI): URI;
-    static revive(data: UriComponents | CodeURI | null): URI | null;
-    static revive(data: UriComponents | CodeURI | undefined): URI | undefined
-    static revive(data: UriComponents | CodeURI | undefined | null): URI | undefined | null {
+    static override revive(data: UriComponents | CodeURI): URI;
+    static override revive(data: UriComponents | CodeURI | null): URI | null;
+    static override revive(data: UriComponents | CodeURI | undefined): URI | undefined
+    static override revive(data: UriComponents | CodeURI | undefined | null): URI | undefined | null {
         const uri = CodeURI.revive(data);
         return uri ? new URI(uri) : undefined;
     }
 
-    static parse(value: string, _strict?: boolean): URI {
+    static override parse(value: string, _strict?: boolean): URI {
         return new URI(CodeURI.parse(value, _strict));
     }
 
-    static file(path: string): URI {
+    static override file(path: string): URI {
         return new URI(CodeURI.file(path));
     }
 
@@ -111,7 +111,7 @@ export class URI extends CodeURI implements theia.Uri {
      * transferring via JSON.stringify(). Making the CodeURI instance
      * makes sure we transfer this object as a vscode-uri URI.
      */
-    toJSON(): UriComponents {
+    override toJSON(): UriComponents {
         return CodeURI.from(this).toJSON();
     }
 }

package/src/plugin/webview-views.ts

@@ -0,0 +1,213 @@
+/********************************************************************************
+ * 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 of the code is copied and modified from https://github.com/microsoft/vscode/blob/e1f0f8f51390dea5df9096718fb6b647ed5a9534/src/vs/workbench/api/common/extHostWebviewView.ts
+
+import { Disposable } from './types-impl';
+import { RPCProtocol } from '../common/rpc-protocol';
+import { PLUGIN_RPC_CONTEXT, WebviewViewsMain, WebviewViewsExt, Plugin } from '../common/plugin-api-rpc';
+import { CancellationToken } from '@theia/core/lib/common/cancellation';
+import { WebviewImpl, WebviewsExtImpl } from './webviews';
+import { WebviewViewProvider } from '@theia/plugin';
+import { Emitter, Event } from '@theia/core/lib/common/event';
+import * as theia from '@theia/plugin';
+
+export class WebviewViewsExtImpl implements WebviewViewsExt {
+
+    private readonly proxy: WebviewViewsMain;
+
+    protected readonly viewProviders = new Map<string, {
+        readonly provider: WebviewViewProvider;
+        readonly plugin: Plugin;
+    }>();
+    protected readonly webviewViews = new Map<string, WebviewViewExtImpl>();
+
+    constructor(rpc: RPCProtocol,
+        private readonly webviewsExt: WebviewsExtImpl) {
+        this.proxy = rpc.getProxy(PLUGIN_RPC_CONTEXT.WEBVIEW_VIEWS_MAIN);
+    }
+
+    registerWebviewViewProvider(
+        viewType: string,
+        provider: WebviewViewProvider,
+        plugin: Plugin,
+        webviewOptions?: {
+            retainContextWhenHidden?: boolean
+        }
+    ): Disposable {
+        if (this.viewProviders.has(viewType)) {
+            throw new Error(`View provider for '${viewType}' already registered`);
+        }
+
+        this.viewProviders.set(viewType, { provider: provider, plugin: plugin });
+
+        this.proxy.$registerWebviewViewProvider(viewType, {
+            retainContextWhenHidden: webviewOptions?.retainContextWhenHidden,
+            serializeBuffersForPostMessage: false,
+        });
+
+        return new Disposable(() => {
+            this.viewProviders.delete(viewType);
+            this.proxy.$unregisterWebviewViewProvider(viewType);
+        });
+    }
+
+    async $resolveWebviewView(handle: string,
+        viewType: string,
+        title: string | undefined,
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        state: any,
+        cancellation: CancellationToken
+    ): Promise<void> {
+        const entry = this.viewProviders.get(viewType);
+        if (!entry) {
+            throw new Error(`No view provider found for '${viewType}'`);
+        }
+
+        const { provider, plugin } = entry;
+
+        const webviewNoPanel = this.webviewsExt.createNewWebview({}, plugin, handle);
+        const revivedView = new WebviewViewExtImpl(handle, this.proxy, viewType, title, webviewNoPanel, true);
+        this.webviewViews.set(handle, revivedView);
+        await provider.resolveWebviewView(revivedView, { state }, cancellation);
+    }
+
+    async $onDidChangeWebviewViewVisibility(
+        handle: string,
+        visible: boolean
+    ): Promise<void> {
+        const webviewView = this.getWebviewView(handle);
+        webviewView.setVisible(visible);
+        webviewView.onDidChangeVisibilityEmitter.fire(visible);
+    }
+
+    async $disposeWebviewView(handle: string): Promise<void> {
+        const webviewView = this.getWebviewView(handle);
+        this.webviewViews.delete(handle);
+        webviewView.dispose();
+
+        this.webviewsExt.deleteWebview(handle);
+    }
+
+    protected getWebviewView(handle: string): WebviewViewExtImpl {
+        const entry = this.webviewViews.get(handle);
+        if (!entry) {
+            throw new Error('No webview found');
+        }
+
+        return entry;
+    }
+}
+
+export class WebviewViewExtImpl implements theia.WebviewView {
+
+    readonly onDidChangeVisibilityEmitter = new Emitter<boolean>();
+    readonly onDidChangeVisibility = this.onDidChangeVisibilityEmitter.event;
+
+    readonly onDidDisposeEmitter = new Emitter<void>();
+    readonly onDidDispose = this.onDidDisposeEmitter.event;
+
+    readonly handle: string;
+    readonly proxy: WebviewViewsMain;
+
+    readonly _viewType: string;
+    readonly _webview: WebviewImpl;
+
+    _isDisposed = false;
+    _isVisible: boolean;
+    _title: string | undefined;
+    _description: string | undefined;
+
+    constructor(
+        handle: string,
+        proxy: WebviewViewsMain,
+        viewType: string,
+        title: string | undefined,
+        webview: WebviewImpl,
+        isVisible: boolean,
+    ) {
+        this._viewType = viewType;
+        this._title = title;
+        this.handle = handle;
+        this.proxy = proxy;
+        this._webview = webview;
+        this._isVisible = isVisible;
+    }
+    onDispose: Event<void>;
+
+    dispose(): void {
+        if (this._isDisposed) {
+            return;
+        }
+
+        this._isDisposed = true;
+        this.onDidDisposeEmitter.fire();
+    }
+
+    get title(): string | undefined {
+        this.assertNotDisposed();
+        return this._title;
+    }
+
+    set title(value: string | undefined) {
+        this.assertNotDisposed();
+        if (this.title !== value) {
+            this.title = value;
+            this.proxy.$setWebviewViewTitle(this.handle, value);
+        }
+    }
+
+    get description(): string | undefined {
+        this.assertNotDisposed();
+        return this._description;
+    }
+
+    set description(value: string | undefined) {
+        this.assertNotDisposed();
+        if (this._description !== value) {
+            this._description = value;
+            this.proxy.$setWebviewViewDescription(this.handle, value);
+        }
+    }
+
+    get visible(): boolean { return this._isVisible; }
+    get webview(): WebviewImpl { return this._webview; }
+    get viewType(): string { return this._viewType; }
+
+    setVisible(visible: boolean): void {
+        if (visible === this._isVisible || this._isDisposed) {
+            return;
+        }
+
+        this._isVisible = visible;
+        this.onDidChangeVisibilityEmitter.fire(this._isVisible);
+    }
+
+    show(preserveFocus?: boolean): void {
+        this.assertNotDisposed();
+        this.proxy.$show(this.handle, !!preserveFocus);
+    }
+
+    protected assertNotDisposed(): void {
+        if (this._isDisposed) {
+            throw new Error('Webview is disposed');
+        }
+    }
+}
+

package/src/plugin/webviews.ts

@@ -27,12 +27,16 @@ import { PluginIconPath } from './plugin-icon-path';
 export class WebviewsExtImpl implements WebviewsExt {
     private readonly proxy: WebviewsMain;
     private readonly webviewPanels = new Map<string, WebviewPanelImpl>();
+    private readonly webviews = new Map<string, WebviewImpl>();
     private readonly serializers = new Map<string, {
         serializer: theia.WebviewPanelSerializer,
         plugin: Plugin
     }>();
     private initData: WebviewInitData | undefined;
 
+    readonly onDidDisposeEmitter = new Emitter<void>();
+    readonly onDidDispose: Event<void> = this.onDidDisposeEmitter.event;
+
     constructor(
         rpc: RPCProtocol,
         private readonly workspace: WorkspaceExtImpl,
@@ -49,6 +53,11 @@ export class WebviewsExtImpl implements WebviewsExt {
         const panel = this.getWebviewPanel(handle);
         if (panel) {
             panel.webview.onMessageEmitter.fire(message);
+        } else {
+            const webview = this.getWebview(handle);
+            if (webview) {
+                webview.onMessageEmitter.fire(message);
+            }
         }
     }
     $onDidChangeWebviewPanelViewState(handle: string, newState: WebviewPanelViewState): void {
@@ -128,6 +137,19 @@ export class WebviewsExtImpl implements WebviewsExt {
         return panel;
     }
 
+    createNewWebview(
+        options: theia.WebviewPanelOptions & theia.WebviewOptions,
+        plugin: Plugin,
+        viewId: string
+    ): WebviewImpl {
+        if (!this.initData) {
+            throw new Error('Webviews are not initialized');
+        }
+        const webview = new WebviewImpl(viewId, this.proxy, options, this.initData, this.workspace, plugin);
+        this.webviews.set(viewId, webview);
+        return webview;
+    }
+
     registerWebviewPanelSerializer(
         viewType: string,
         serializer: theia.WebviewPanelSerializer,
@@ -152,6 +174,14 @@ export class WebviewsExtImpl implements WebviewsExt {
         }
         return undefined;
     }
+
+    public deleteWebview(handle: string): void {
+        this.webviews.delete(handle);
+    }
+
+    public getWebview(handle: string): WebviewImpl | undefined {
+        return this.webviews.get(handle);
+    }
 }
 
 export class WebviewImpl implements theia.Webview {

package/src/plugin/workspace.ts

@@ -56,6 +56,10 @@ export class WorkspaceExtImpl implements WorkspaceExt {
     private searchInWorkspaceEmitter: Emitter<{ result?: theia.TextSearchResult, searchId: number }> = new Emitter<{ result?: theia.TextSearchResult, searchId: number }>();
     protected workspaceSearchSequence: number = 0;
 
+    private _trusted?: boolean = undefined;
+    private didGrantWorkspaceTrustEmitter = new Emitter<void>();
+    public readonly onDidGrantWorkspaceTrust: Event<void> = this.didGrantWorkspaceTrustEmitter.event;
+
     constructor(rpc: RPCProtocol,
         private editorsAndDocuments: EditorsAndDocumentsExtImpl,
         private messageService: MessageRegistryExt) {
@@ -418,4 +422,23 @@ export class WorkspaceExtImpl implements WorkspaceExt {
             this.workspaceFileUri = URI.parse(workspace.resource.toString());
         }
     }
+
+    get trusted(): boolean {
+        if (this._trusted === undefined) {
+            this.requestWorkspaceTrust();
+        }
+        return !!this._trusted;
+    }
+
+    requestWorkspaceTrust(options?: theia.WorkspaceTrustRequestOptions): Promise<boolean | undefined> {
+        return this.proxy.$requestWorkspaceTrust(options);
+    }
+
+    $onWorkspaceTrustChanged(trust: boolean | undefined): void {
+        if (!this._trusted && trust) {
+            this._trusted = trust;
+            this.didGrantWorkspaceTrustEmitter.fire();
+        }
+    }
+
 }