@@ -24,28 +24,29 @@ import { Channel } from '../message-rpc/channel';
2424import { RequestHandler , RpcProtocol } from '../message-rpc/rpc-protocol' ;
2525import { ConnectionHandler } from './handler' ;
2626import { Deferred } from '../promise-util' ;
27+ import { decorate , injectable , unmanaged } from '../../../shared/inversify' ;
2728
28- export type JsonRpcServer < Client > = Disposable & {
29+ export type RpcServer < Client > = Disposable & {
2930 /**
3031 * If this server is a proxy to a remote server then
3132 * a client is used as a local object
32- * to handle JSON- RPC messages from the remote server.
33+ * to handle RPC messages from the remote server.
3334 */
3435 setClient ( client : Client | undefined ) : void ;
3536 getClient ?( ) : Client | undefined ;
3637} ;
3738
38- export interface JsonRpcConnectionEventEmitter {
39+ export interface RpcConnectionEventEmitter {
3940 readonly onDidOpenConnection : Event < void > ;
4041 readonly onDidCloseConnection : Event < void > ;
4142}
42- export type JsonRpcProxy < T > = T & JsonRpcConnectionEventEmitter ;
43+ export type RpcProxy < T > = T & RpcConnectionEventEmitter ;
4344
44- export class JsonRpcConnectionHandler < T extends object > implements ConnectionHandler {
45+ export class RpcConnectionHandler < T extends object > implements ConnectionHandler {
4546 constructor (
4647 readonly path : string ,
47- readonly targetFactory : ( proxy : JsonRpcProxy < T > ) => any ,
48- readonly factoryConstructor : new ( ) => JsonRpcProxyFactory < T > = JsonRpcProxyFactory
48+ readonly targetFactory : ( proxy : RpcProxy < T > ) => any ,
49+ readonly factoryConstructor : new ( ) => RpcProxyFactory < T > = RpcProxyFactory
4950 ) { }
5051
5152 onConnection ( connection : Channel ) : void {
@@ -63,12 +64,12 @@ export type RpcProtocolFactory = (channel: Channel, requestHandler: RequestHandl
6364const defaultRpcProtocolFactory : RpcProtocolFactory = ( channel , requestHandler ) => new RpcProtocol ( channel , requestHandler ) ;
6465
6566/**
66- * Factory for JSON- RPC proxy objects.
67+ * Factory for RPC proxy objects.
6768 *
68- * A JSON- RPC proxy exposes the programmatic interface of an object through
69- * JSON- RPC. This allows remote programs to call methods of this objects by
70- * sending JSON- RPC requests. This takes place over a bi-directional stream,
71- * where both ends can expose an object and both can call methods each other's
69+ * A RPC proxy exposes the programmatic interface of an object through
70+ * Theia's RPC protocol. This allows remote programs to call methods of this objects by
71+ * sending RPC requests. This takes place over a bi-directional stream,
72+ * where both ends can expose an object and both can call methods on each other'
7273 * exposed object.
7374 *
7475 * For example, assuming we have an object of the following type on one end:
@@ -77,45 +78,45 @@ const defaultRpcProtocolFactory: RpcProtocolFactory = (channel, requestHandler)
7778 * bar(baz: number): number { return baz + 1 }
7879 * }
7980 *
80- * which we want to expose through a JSON- RPC interface. We would do:
81+ * which we want to expose through a RPC interface. We would do:
8182 *
8283 * let target = new Foo()
83- * let factory = new JsonRpcProxyFactory <Foo>('/foo', target)
84+ * let factory = new RpcProxyFactory <Foo>('/foo', target)
8485 * factory.onConnection(connection)
8586 *
8687 * The party at the other end of the `connection`, in order to remotely call
8788 * methods on this object would do:
8889 *
89- * let factory = new JsonRpcProxyFactory <Foo>('/foo')
90+ * let factory = new RpcProxyFactory <Foo>('/foo')
9091 * factory.onConnection(connection)
9192 * let proxy = factory.createProxy();
9293 * let result = proxy.bar(42)
9394 * // result is equal to 43
9495 *
9596 * One the wire, it would look like this:
9697 *
97- * --> {"jsonrpc": "2.0 ", "id": 0 , "method": "bar", "params ": {"baz": 42} }
98- * <-- {"jsonrpc": "2.0 ", "id": 0 , "result ": 43}
99- *
98+ * --> { "type":"1 ", "id": 1 , "method": "bar", "args ": [42] }
99+ * <-- { "type":"3 ", "id": 1 , "res ": 43}
100+ *
100101 * Note that in the code of the caller, we didn't pass a target object to
101- * JsonRpcProxyFactory , because we don't want/need to expose an object.
102+ * RpcProxyFactory , because we don't want/need to expose an object.
102103 * If we had passed a target object, the other side could've called methods on
103104 * it.
104105 *
105- * @param <T> - The type of the object to expose to JSON- RPC.
106+ * @param <T> - The type of the object to expose to RPC.
106107 */
107108
108- export class JsonRpcProxyFactory < T extends object > implements ProxyHandler < T > {
109+ export class RpcProxyFactory < T extends object > implements ProxyHandler < T > {
109110
110111 protected readonly onDidOpenConnectionEmitter = new Emitter < void > ( ) ;
111112 protected readonly onDidCloseConnectionEmitter = new Emitter < void > ( ) ;
112113
113114 protected rpcDeferred : Deferred < RpcProtocol > ;
114115
115116 /**
116- * Build a new JsonRpcProxyFactory .
117+ * Build a new RpcProxyFactory .
117118 *
118- * @param target - The object to expose to JSON- RPC methods calls. If this
119+ * @param target - The object to expose to RPC methods calls. If this
119120 * is omitted, the proxy won't be able to handle requests, only send them.
120121 */
121122 constructor ( public target ?: any , protected rpcProtocolFactory = defaultRpcProtocolFactory ) {
@@ -135,10 +136,10 @@ export class JsonRpcProxyFactory<T extends object> implements ProxyHandler<T> {
135136 }
136137
137138 /**
138- * Connect a MessageConnection to the factory.
139+ * Connect a { @link Channel} to the factory by creating an { @link RpcProtocol} on top of it .
139140 *
140- * This connection will be used to send/receive JSON- RPC requests and
141- * response .
141+ * This protocol will be used to send/receive RPC requests and
142+ * responses .
142143 */
143144 listen ( channel : Channel ) : void {
144145 const protocol = this . rpcProtocolFactory ( channel , ( meth , args ) => this . onRequest ( meth , ...args ) ) ;
@@ -148,9 +149,9 @@ export class JsonRpcProxyFactory<T extends object> implements ProxyHandler<T> {
148149 }
149150
150151 /**
151- * Process an incoming JSON- RPC method call.
152+ * Process an incoming RPC method call.
152153 *
153- * onRequest is called when the JSON- RPC connection received a method call
154+ * onRequest is called when the RPC connection received a method call
154155 * request. It calls the corresponding method on [[target]].
155156 *
156157 * The return value is a Promise object that is resolved with the return
@@ -179,7 +180,7 @@ export class JsonRpcProxyFactory<T extends object> implements ProxyHandler<T> {
179180 }
180181
181182 /**
182- * Process an incoming JSON- RPC notification.
183+ * Process an incoming RPC notification.
183184 *
184185 * Same as [[onRequest]], but called on incoming notifications rather than
185186 * methods calls.
@@ -192,37 +193,37 @@ export class JsonRpcProxyFactory<T extends object> implements ProxyHandler<T> {
192193
193194 /**
194195 * Create a Proxy exposing the interface of an object of type T. This Proxy
195- * can be used to do JSON- RPC method calls on the remote target object as
196+ * can be used to do RPC method calls on the remote target object as
196197 * if it was local.
197198 *
198- * If `T` implements `JsonRpcServer ` then a client is used as a target object for a remote target object.
199+ * If `T` implements `RpcServer ` then a client is used as a target object for a remote target object.
199200 */
200- createProxy ( ) : JsonRpcProxy < T > {
201+ createProxy ( ) : RpcProxy < T > {
201202 const result = new Proxy < T > ( this as any , this ) ;
202203 return result as any ;
203204 }
204205
205206 /**
206- * Get a callable object that executes a JSON- RPC method call.
207+ * Get a callable object that executes a RPC method call.
207208 *
208209 * Getting a property on the Proxy object returns a callable that, when
209- * called, executes a JSON- RPC call. The name of the property defines the
210+ * called, executes a RPC call. The name of the property defines the
210211 * method to be called. The callable takes a variable number of arguments,
211- * which are passed in the JSON- RPC method call.
212+ * which are passed in the RPC method call.
212213 *
213214 * For example, if you have a Proxy object:
214215 *
215- * let fooProxyFactory = JsonRpcProxyFactory <Foo>('/foo')
216+ * let fooProxyFactory = RpcProxyFactory <Foo>('/foo')
216217 * let fooProxy = fooProxyFactory.createProxy()
217218 *
218219 * accessing `fooProxy.bar` will return a callable that, when called,
219- * executes a JSON- RPC method call to method `bar`. Therefore, doing
220+ * executes a RPC method call to method `bar`. Therefore, doing
220221 * `fooProxy.bar()` will call the `bar` method on the remote Foo object.
221222 *
222223 * @param target - unused.
223224 * @param p - The property accessed on the Proxy object.
224225 * @param receiver - unused.
225- * @returns A callable that executes the JSON- RPC call.
226+ * @returns A callable that executes the RPC call.
226227 */
227228 get ( target : T , p : PropertyKey , receiver : any ) : any {
228229 if ( p === 'setClient' ) {
@@ -306,3 +307,37 @@ export class JsonRpcProxyFactory<T extends object> implements ProxyHandler<T> {
306307
307308}
308309
310+ /**
311+ * @deprecated since 1.39.0 use `RpcConnectionEventEmitter` instead
312+ */
313+ export type JsonRpcConnectionEventEmitter = RpcConnectionEventEmitter ;
314+
315+ /**
316+ * @deprecated since 1.39.0 use `RpcServer` instead
317+ */
318+ export type JsonRpcServer < Client > = RpcServer < Client > ;
319+
320+ /**
321+ * @deprecated since 1.39.0 use `RpcProxy` instead
322+ */
323+ export type JsonRpcProxy < T > = RpcProxy < T > ;
324+
325+ /**
326+ * @deprecated since 1.39.0 use `RpcConnectionHandler` instead
327+ */
328+ export class JsonRpcConnectionHandler < T extends object > extends RpcConnectionHandler < T > {
329+
330+ }
331+
332+ /**
333+ * @deprecated since 1.39.0 use `RpcProxyFactory` instead
334+ */
335+ export class JsonRpcProxyFactory < T extends object > extends RpcProxyFactory < T > {
336+
337+ }
338+
339+ // eslint-disable-next-line deprecation/deprecation
340+ decorate ( injectable ( ) , JsonRpcProxyFactory ) ;
341+ // eslint-disable-next-line deprecation/deprecation
342+ decorate ( unmanaged ( ) , JsonRpcProxyFactory , 0 ) ;
343+
0 commit comments