@theia/plugin-ext 1.33.0-next.2 → 1.33.0-next.20

package/src/common/plugin-protocol.ts

@@ -838,7 +838,7 @@ export function buildFrontendModuleName(plugin: PluginPackage | PluginModel): st
 
 export const HostedPluginClient = Symbol('HostedPluginClient');
 export interface HostedPluginClient {
-    postMessage(pluginHost: string, message: string): Promise<void>;
+    postMessage(pluginHost: string, buffer: Uint8Array): Promise<void>;
 
     log(logPart: LogPart): void;
 
@@ -901,7 +901,7 @@ export interface HostedPluginServer extends JsonRpcServer<HostedPluginClient> {
 
     getExtPluginAPI(): Promise<ExtPluginApi[]>;
 
-    onMessage(targetHost: string, message: string): Promise<void>;
+    onMessage(targetHost: string, message: Uint8Array): Promise<void>;
 
 }
 
@@ -944,9 +944,9 @@ export interface PluginServer {
 export const ServerPluginRunner = Symbol('ServerPluginRunner');
 export interface ServerPluginRunner {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    acceptMessage(pluginHostId: string, jsonMessage: string): boolean;
+    acceptMessage(pluginHostId: string, jsonMessage: Uint8Array): boolean;
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    onMessage(pluginHostId: string, jsonMessage: string): void;
+    onMessage(pluginHostId: string, jsonMessage: Uint8Array): void;
     setClient(client: HostedPluginClient): void;
     setDefault(defaultRunner: ServerPluginRunner): void;
     clientClosed(): void;

package/src/common/proxy-handler.ts

@@ -0,0 +1,126 @@
+/********************************************************************************
+ * Copyright (C) 2022 STMicroelectronics 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
+ ********************************************************************************/
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { Channel, RpcProtocol, RpcProtocolOptions } from '@theia/core/';
+import { RpcMessageDecoder, RpcMessageEncoder } from '@theia/core/lib/common/message-rpc/rpc-message-encoder';
+import { Deferred } from '@theia/core/lib/common/promise-util';
+
+export interface RpcHandlerOptions {
+    id: string
+    encoder: RpcMessageEncoder,
+    decoder: RpcMessageDecoder
+}
+export interface ProxyHandlerOptions extends RpcHandlerOptions {
+    channelProvider: () => Promise<Channel>,
+}
+
+export interface InvocationHandlerOptions extends RpcHandlerOptions {
+    target: any
+}
+/**
+ * A proxy handler that will send any method invocation on the proxied object
+ * as a rcp protocol message over a channel.
+ */
+export class ClientProxyHandler<T extends object> implements ProxyHandler<T> {
+    private rpcDeferred: Deferred<RpcProtocol> = new Deferred();
+    private isRpcInitialized = false;
+
+    readonly id: string;
+    private readonly channelProvider: () => Promise<Channel>;
+    private readonly encoder: RpcMessageEncoder;
+    private readonly decoder: RpcMessageDecoder;
+
+    constructor(options: ProxyHandlerOptions) {
+        Object.assign(this, options);
+    }
+
+    private initializeRpc(): void {
+        const clientOptions: RpcProtocolOptions = { encoder: this.encoder, decoder: this.decoder, mode: 'clientOnly' };
+        this.channelProvider().then(channel => {
+            const rpc = new RpcProtocol(channel, undefined, clientOptions);
+            this.rpcDeferred.resolve(rpc);
+            this.isRpcInitialized = true;
+        });
+    }
+
+    get(target: any, name: string, receiver: any): any {
+        if (!this.isRpcInitialized) {
+            this.initializeRpc();
+        }
+
+        if (target[name] || name.charCodeAt(0) !== 36 /* CharCode.DollarSign */) {
+            return target[name];
+        }
+        const isNotify = this.isNotification(name);
+        return (...args: any[]) => {
+            const method = name.toString();
+            return this.rpcDeferred.promise.then(async (connection: RpcProtocol) => {
+                if (isNotify) {
+                    connection.sendNotification(method, args);
+                } else {
+                    return await connection.sendRequest(method, args) as Promise<any>;
+                }
+            });
+        };
+    }
+
+    /**
+     * Return whether the given property represents a notification. If true,
+     * the promise returned from the invocation will resolve immediately to `undefined`
+     *
+     * A property leads to a notification rather than a method call if its name
+     * begins with `notify` or `on`.
+     *
+     * @param p - The property being called on the proxy.
+     * @return Whether `p` represents a notification.
+     */
+    protected isNotification(p: PropertyKey): boolean {
+        let propertyString = p.toString();
+        if (propertyString.charCodeAt(0) === 36/* CharCode.DollarSign */) {
+            propertyString = propertyString.substring(1);
+        }
+        return propertyString.startsWith('notify') || propertyString.startsWith('on');
+    }
+}
+
+export class RpcInvocationHandler {
+    readonly id: string;
+    readonly target: any;
+
+    private rpcDeferred: Deferred<RpcProtocol> = new Deferred();
+    private readonly encoder: RpcMessageEncoder;
+    private readonly decoder: RpcMessageDecoder;
+
+    constructor(options: InvocationHandlerOptions) {
+        Object.assign(this, options);
+    }
+
+    listen(channel: Channel): void {
+        const serverOptions: RpcProtocolOptions = { encoder: this.encoder, decoder: this.decoder, mode: 'serverOnly' };
+        const server = new RpcProtocol(channel, (method: string, args: any[]) => this.handleRequest(method, args), serverOptions);
+        server.onNotification((e: { method: string, args: any }) => this.onNotification(e.method, e.args));
+        this.rpcDeferred.resolve(server);
+    }
+
+    protected handleRequest(method: string, args: any[]): Promise<any> {
+        return this.rpcDeferred.promise.then(() => this.target[method](...args));
+    }
+
+    protected onNotification(method: string, args: any[]): void {
+        this.target[method](...args);
+    }
+}
+

package/src/common/reference-map.ts

@@ -0,0 +1,38 @@
+// *****************************************************************************
+// Copyright (C) 2022 Ericsson 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
+// *****************************************************************************
+
+// copied from hhttps://github.com/microsoft/vscode/blob/6261075646f055b99068d3688932416f2346dd3b/src/vs/workbench/api/common/extHostLanguageFeatures.ts#L1291-L1310.
+
+export class ReferenceMap<T> {
+    private readonly _references = new Map<number, T>();
+    private _idPool = 1;
+
+    createReferenceId(value: T): number {
+        const id = this._idPool++;
+        this._references.set(id, value);
+        return id;
+    }
+
+    disposeReferenceId(referenceId: number): T | undefined {
+        const value = this._references.get(referenceId);
+        this._references.delete(referenceId);
+        return value;
+    }
+
+    get(referenceId: number): T | undefined {
+        return this._references.get(referenceId);
+    }
+}