starpc 0.3.0 → 0.3.3

package/dist/srpc/broadcast-channel.d.ts

@@ -8,6 +8,7 @@ export declare class BroadcastChannelIterable<T> implements Duplex<T> {
     sink: Sink<T>;
     source: AsyncIterable<T>;
     constructor(readChannel: BroadcastChannel, writeChannel: BroadcastChannel);
+    close(): void;
     private _createSink;
     private _createSource;
 }
@@ -17,4 +18,5 @@ export declare class BroadcastChannelConn extends DuplexConn {
     constructor(readChannel: BroadcastChannel, writeChannel: BroadcastChannel, server?: Server, connParams?: ConnParams);
     getReadChannel(): BroadcastChannel;
     getWriteChannel(): BroadcastChannel;
+    close(): void;
 }

package/dist/srpc/broadcast-channel.js

@@ -16,6 +16,11 @@ export class BroadcastChannelIterable {
         this.sink = this._createSink();
         this.source = this._createSource();
     }
+    // close closes the broadcast channels.
+    close() {
+        this.readChannel.close();
+        this.writeChannel.close();
+    }
     // _createSink initializes the sink field.
     _createSink() {
         return async (source) => {
@@ -62,4 +67,8 @@ export class BroadcastChannelConn extends DuplexConn {
     getWriteChannel() {
         return this.broadcastChannel.writeChannel;
     }
+    // close closes the read and write channels.
+    close() {
+        this.broadcastChannel.close();
+    }
 }

package/dist/srpc/client.d.ts

@@ -3,7 +3,10 @@ import type { TsProtoRpc } from './ts-proto-rpc.js';
 import type { OpenStreamFunc } from './stream.js';
 export declare class Client implements TsProtoRpc {
     private openConnFn;
-    constructor(openConnFn: OpenStreamFunc);
+    private _openConnFn?;
+    constructor(openConnFn?: OpenStreamFunc);
+    setOpenConnFn(openConnFn?: OpenStreamFunc): Promise<OpenStreamFunc>;
+    private initOpenConnFn;
     request(service: string, method: string, data: Uint8Array): Promise<Uint8Array>;
     clientStreamingRequest(service: string, method: string, data: Observable<Uint8Array>): Promise<Uint8Array>;
     serverStreamingRequest(service: string, method: string, data: Uint8Array): Observable<Uint8Array>;

package/dist/srpc/client.js

@@ -19,11 +19,45 @@ function writeClientStream(call, data) {
 }
 // Client implements the ts-proto Rpc interface with the drpcproto protocol.
 export class Client {
-    // openConnFn is the open connection function.
-    // called when starting RPC.
+    // openConnFn is a promise which contains the OpenStreamFunc.
     openConnFn;
+    // _openConnFn resolves openConnFn.
+    _openConnFn;
     constructor(openConnFn) {
-        this.openConnFn = openConnFn;
+        this.openConnFn = this.setOpenConnFn(openConnFn);
+    }
+    // setOpenConnFn updates the openConnFn for the Client.
+    setOpenConnFn(openConnFn) {
+        if (this._openConnFn) {
+            if (openConnFn) {
+                this._openConnFn(openConnFn);
+                this._openConnFn = undefined;
+            }
+        }
+        else {
+            if (openConnFn) {
+                this.openConnFn = Promise.resolve(openConnFn);
+            }
+            else {
+                this.initOpenConnFn();
+            }
+        }
+        return this.openConnFn;
+    }
+    // initOpenConnFn creates the empty Promise for openConnFn.
+    initOpenConnFn() {
+        const openPromise = new Promise((resolve, reject) => {
+            this._openConnFn = (conn, err) => {
+                if (err) {
+                    reject(err);
+                }
+                else if (conn) {
+                    resolve(conn);
+                }
+            };
+        });
+        this.openConnFn = openPromise;
+        return this.openConnFn;
     }
     // request starts a non-streaming request.
     async request(service, method, data) {
@@ -101,7 +135,8 @@ export class Client {
     // throws any error starting the rpc call
     // if data == null and data.length == 0, sends a separate data packet.
     async startRpc(rpcService, rpcMethod, data) {
-        const conn = await this.openConnFn();
+        const openConnFn = await this.openConnFn;
+        const conn = await openConnFn();
         const call = new ClientRPC(rpcService, rpcMethod);
         pipe(conn, parseLengthPrefixTransform(), decodePacketSource, call, encodePacketSource, prependLengthPrefixTransform(), conn);
         await call.writeCallStart(data || undefined);

package/dist/srpc/message-port.d.ts

@@ -8,6 +8,7 @@ export declare class MessagePortIterable<T> implements Duplex<T> {
     source: AsyncIterable<T>;
     private _source;
     constructor(port: MessagePort);
+    close(): void;
     private _createSink;
     private _createSource;
 }
@@ -16,4 +17,5 @@ export declare class MessagePortConn extends DuplexConn {
     private messagePort;
     constructor(port: MessagePort, server?: Server, connParams?: ConnParams);
     getMessagePort(): MessagePort;
+    close(): void;
 }

package/dist/srpc/message-port.js

@@ -16,6 +16,10 @@ export class MessagePortIterable {
         this._source = this._createSource();
         this.source = this._source;
     }
+    // close closes the message port.
+    close() {
+        this.port.close();
+    }
     // _createSink initializes the sink field.
     _createSink() {
         return async (source) => {
@@ -58,4 +62,8 @@ export class MessagePortConn extends DuplexConn {
     getMessagePort() {
         return this.messagePort.port;
     }
+    // close closes the message port.
+    close() {
+        this.messagePort.close();
+    }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "starpc",
-  "version": "0.3.0",
+  "version": "0.3.3",
   "description": "Streaming protobuf RPC service protocol over any two-way channel.",
   "license": "MIT",
   "author": {

package/srpc/broadcast-channel.ts

@@ -23,6 +23,12 @@ export class BroadcastChannelIterable<T> implements Duplex<T> {
     this.source = this._createSource()
   }
 
+  // close closes the broadcast channels.
+  public close() {
+    this.readChannel.close()
+    this.writeChannel.close()
+  }
+
   // _createSink initializes the sink field.
   private _createSink(): Sink<T> {
     return async (source) => {
@@ -90,4 +96,9 @@ export class BroadcastChannelConn extends DuplexConn {
   public getWriteChannel(): BroadcastChannel {
     return this.broadcastChannel.writeChannel
   }
+
+  // close closes the read and write channels.
+  public close() {
+    this.broadcastChannel.close()
+  }
 }

package/srpc/client.ts

@@ -29,12 +29,45 @@ function writeClientStream(call: ClientRPC, data: Observable<Uint8Array>) {
 
 // Client implements the ts-proto Rpc interface with the drpcproto protocol.
 export class Client implements TsProtoRpc {
-  // openConnFn is the open connection function.
-  // called when starting RPC.
-  private openConnFn: OpenStreamFunc
+  // openConnFn is a promise which contains the OpenStreamFunc.
+  private openConnFn: Promise<OpenStreamFunc>
+  // _openConnFn resolves openConnFn.
+  private _openConnFn?: (conn?: OpenStreamFunc, err?: Error) => void
 
-  constructor(openConnFn: OpenStreamFunc) {
-    this.openConnFn = openConnFn
+  constructor(openConnFn?: OpenStreamFunc) {
+    this.openConnFn = this.setOpenConnFn(openConnFn)
+  }
+
+  // setOpenConnFn updates the openConnFn for the Client.
+  public setOpenConnFn(openConnFn?: OpenStreamFunc): Promise<OpenStreamFunc> {
+    if (this._openConnFn) {
+      if (openConnFn) {
+        this._openConnFn(openConnFn)
+        this._openConnFn = undefined
+      }
+    } else {
+      if (openConnFn) {
+        this.openConnFn = Promise.resolve(openConnFn)
+      } else {
+        this.initOpenConnFn()
+      }
+    }
+    return this.openConnFn
+  }
+
+  // initOpenConnFn creates the empty Promise for openConnFn.
+  private initOpenConnFn(): Promise<OpenStreamFunc> {
+    const openPromise = new Promise<OpenStreamFunc>((resolve, reject) => {
+      this._openConnFn = (conn?: OpenStreamFunc, err?: Error) => {
+        if (err) {
+          reject(err)
+        } else if (conn) {
+          resolve(conn)
+        }
+      }
+    })
+    this.openConnFn = openPromise
+    return this.openConnFn
   }
 
   // request starts a non-streaming request.
@@ -135,7 +168,8 @@ export class Client implements TsProtoRpc {
     rpcMethod: string,
     data: Uint8Array | null
   ): Promise<ClientRPC> {
-    const conn = await this.openConnFn()
+    const openConnFn = await this.openConnFn
+    const conn = await openConnFn()
     const call = new ClientRPC(rpcService, rpcMethod)
     pipe(
       conn,

package/srpc/message-port.ts

@@ -23,6 +23,11 @@ export class MessagePortIterable<T> implements Duplex<T> {
     this.source = this._source
   }
 
+  // close closes the message port.
+  public close() {
+    this.port.close()
+  }
+
   // _createSink initializes the sink field.
   private _createSink(): Sink<T> {
     return async (source) => {
@@ -73,4 +78,9 @@ export class MessagePortConn extends DuplexConn {
   public getMessagePort(): MessagePort {
     return this.messagePort.port
   }
+
+  // close closes the message port.
+  public close() {
+    this.messagePort.close()
+  }
 }