starpc 0.2.2 → 0.3.2

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

@@ -1,19 +1,22 @@
 import type { Duplex, Sink } from 'it-stream-types';
-import { Conn, ConnParams } from './conn';
-import { Server } from './server';
+import { ConnParams } from './conn.js';
+import { Server } from './server.js';
+import { DuplexConn } from './conn-duplex.js';
 export declare class BroadcastChannelIterable<T> implements Duplex<T> {
     readonly readChannel: BroadcastChannel;
     readonly writeChannel: BroadcastChannel;
     sink: Sink<T>;
     source: AsyncIterable<T>;
     constructor(readChannel: BroadcastChannel, writeChannel: BroadcastChannel);
+    close(): void;
     private _createSink;
     private _createSource;
 }
 export declare function newBroadcastChannelIterable<T>(readName: string, writeName: string): BroadcastChannelIterable<T>;
-export declare class BroadcastChannelConn extends Conn {
-    private channel;
+export declare class BroadcastChannelConn extends DuplexConn {
+    private broadcastChannel;
     constructor(readChannel: BroadcastChannel, writeChannel: BroadcastChannel, server?: Server, connParams?: ConnParams);
     getReadChannel(): BroadcastChannel;
     getWriteChannel(): BroadcastChannel;
+    close(): void;
 }

package/dist/srpc/broadcast-channel.js

@@ -1,6 +1,5 @@
-import { Conn } from './conn';
 import { EventIterator } from 'event-iterator';
-import { pipe } from 'it-pipe';
+import { DuplexConn } from './conn-duplex.js';
 // BroadcastChannelIterable is a AsyncIterable wrapper for BroadcastChannel.
 export class BroadcastChannelIterable {
     // readChannel is the incoming broadcast channel
@@ -17,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) => {
@@ -47,20 +51,24 @@ export function newBroadcastChannelIterable(readName, writeName) {
 // BroadcastChannelConn implements a connection with a BroadcastChannel.
 //
 // expects Uint8Array objects over the BroadcastChannel.
-export class BroadcastChannelConn extends Conn {
-    // channel is the broadcast channel iterable
-    channel;
+export class BroadcastChannelConn extends DuplexConn {
+    // broadcastChannel is the broadcast channel iterable
+    broadcastChannel;
     constructor(readChannel, writeChannel, server, connParams) {
-        super(server, connParams);
-        this.channel = new BroadcastChannelIterable(readChannel, writeChannel);
-        pipe(this, this.channel, this);
+        const broadcastChannel = new BroadcastChannelIterable(readChannel, writeChannel);
+        super(broadcastChannel, server, connParams);
+        this.broadcastChannel = broadcastChannel;
     }
     // getReadChannel returns the read BroadcastChannel.
     getReadChannel() {
-        return this.channel.readChannel;
+        return this.broadcastChannel.readChannel;
     }
     // getWriteChannel returns the write BroadcastChannel.
     getWriteChannel() {
-        return this.channel.writeChannel;
+        return this.broadcastChannel.writeChannel;
+    }
+    // close closes the read and write channels.
+    close() {
+        this.broadcastChannel.close();
     }
 }

package/dist/srpc/client.d.ts

@@ -4,6 +4,7 @@ import type { OpenStreamFunc } from './stream.js';
 export declare class Client implements TsProtoRpc {
     private openConnFn;
     constructor(openConnFn: OpenStreamFunc);
+    setOpenConnFn(openConnFn: OpenStreamFunc): void;
     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

@@ -25,6 +25,10 @@ export class Client {
     constructor(openConnFn) {
         this.openConnFn = openConnFn;
     }
+    // setOpenConnFn updates the openConnFn for the Client.
+    setOpenConnFn(openConnFn) {
+        this.openConnFn = openConnFn;
+    }
     // request starts a non-streaming request.
     async request(service, method, data) {
         const call = await this.startRpc(service, method, data);

package/dist/srpc/conn-duplex.d.ts

@@ -0,0 +1,8 @@
+import type { Duplex } from 'it-stream-types';
+import { Conn, ConnParams } from './conn.js';
+import { Server } from './server';
+export declare class DuplexConn extends Conn {
+    private channel;
+    constructor(duplex: Duplex<Uint8Array>, server?: Server, connParams?: ConnParams);
+    getChannelDuplex(): Duplex<Uint8Array>;
+}

package/dist/srpc/conn-duplex.js

@@ -0,0 +1,18 @@
+import { pipe } from 'it-pipe';
+import { Conn } from './conn.js';
+// DuplexConn wraps any Duplex<Uint8Array> into a Conn.
+//
+// expects Uint8Array objects
+export class DuplexConn extends Conn {
+    // channel is the iterable
+    channel;
+    constructor(duplex, server, connParams) {
+        super(server, connParams);
+        this.channel = duplex;
+        pipe(this, this.channel, this);
+    }
+    // getChannelDuplex returns the Duplex channel.
+    getChannelDuplex() {
+        return this.channel;
+    }
+}

package/dist/srpc/index.d.ts

@@ -5,4 +5,5 @@ export { Conn, ConnParams } from './conn.js';
 export { Handler, InvokeFn, createHandler, createInvokeFn } from './handler.js';
 export { Mux, createMux } from './mux.js';
 export { WebSocketConn } from './websocket.js';
-export { BroadcastChannelIterable, newBroadcastChannelIterable, BroadcastChannelConn, } from './broadcast-channel';
+export { BroadcastChannelIterable, newBroadcastChannelIterable, BroadcastChannelConn, } from './broadcast-channel.js';
+export { MessagePortIterable, newMessagePortIterable, MessagePortConn, } from './message-port.js';

package/dist/srpc/index.js

@@ -4,4 +4,5 @@ export { Conn } from './conn.js';
 export { createHandler, createInvokeFn } from './handler.js';
 export { createMux } from './mux.js';
 export { WebSocketConn } from './websocket.js';
-export { BroadcastChannelIterable, newBroadcastChannelIterable, BroadcastChannelConn, } from './broadcast-channel';
+export { BroadcastChannelIterable, newBroadcastChannelIterable, BroadcastChannelConn, } from './broadcast-channel.js';
+export { MessagePortIterable, newMessagePortIterable, MessagePortConn, } from './message-port.js';

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

@@ -0,0 +1,21 @@
+import type { Duplex, Sink } from 'it-stream-types';
+import { ConnParams } from './conn.js';
+import { DuplexConn } from './conn-duplex.js';
+import { Server } from './server';
+export declare class MessagePortIterable<T> implements Duplex<T> {
+    readonly port: MessagePort;
+    sink: Sink<T>;
+    source: AsyncIterable<T>;
+    private _source;
+    constructor(port: MessagePort);
+    close(): void;
+    private _createSink;
+    private _createSource;
+}
+export declare function newMessagePortIterable<T>(port: MessagePort): MessagePortIterable<T>;
+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

@@ -0,0 +1,69 @@
+import { EventIterator } from 'event-iterator';
+import { DuplexConn } from './conn-duplex.js';
+// MessagePortIterable is a AsyncIterable wrapper for MessagePort.
+export class MessagePortIterable {
+    // port is the message port
+    port;
+    // sink is the sink for incoming messages.
+    sink;
+    // source is the source for outgoing messages.
+    source;
+    // _source is the EventIterator for source.
+    _source;
+    constructor(port) {
+        this.port = port;
+        this.sink = this._createSink();
+        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) => {
+            for await (const msg of source) {
+                this.port.postMessage(msg);
+            }
+        };
+    }
+    // _createSource initializes the source field.
+    _createSource() {
+        return new EventIterator((queue) => {
+            const messageListener = (ev) => {
+                if (ev.data) {
+                    queue.push(ev.data);
+                }
+            };
+            this.port.addEventListener('message', messageListener);
+            return () => {
+                this.port.removeEventListener('message', messageListener);
+            };
+        });
+    }
+}
+// newMessagePortIterable constructs a MessagePortIterable with a channel name.
+export function newMessagePortIterable(port) {
+    return new MessagePortIterable(port);
+}
+// MessagePortConn implements a connection with a MessagePort.
+//
+// expects Uint8Array objects over the MessagePort.
+export class MessagePortConn extends DuplexConn {
+    // messagePort is the message port iterable.
+    messagePort;
+    constructor(port, server, connParams) {
+        const messagePort = new MessagePortIterable(port);
+        super(messagePort, server, connParams);
+        this.messagePort = messagePort;
+    }
+    // getMessagePort returns the MessagePort.
+    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.2.2",
+  "version": "0.3.2",
   "description": "Streaming protobuf RPC service protocol over any two-way channel.",
   "license": "MIT",
   "author": {

package/srpc/broadcast-channel.ts

@@ -1,8 +1,9 @@
 import type { Duplex, Sink } from 'it-stream-types'
-import { Conn, ConnParams } from './conn'
 import { EventIterator } from 'event-iterator'
-import { pipe } from 'it-pipe'
-import { Server } from './server'
+
+import { ConnParams } from './conn.js'
+import { Server } from './server.js'
+import { DuplexConn } from './conn-duplex.js'
 
 // BroadcastChannelIterable is a AsyncIterable wrapper for BroadcastChannel.
 export class BroadcastChannelIterable<T> implements Duplex<T> {
@@ -22,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) => {
@@ -62,9 +69,9 @@ export function newBroadcastChannelIterable<T>(
 // BroadcastChannelConn implements a connection with a BroadcastChannel.
 //
 // expects Uint8Array objects over the BroadcastChannel.
-export class BroadcastChannelConn extends Conn {
-  // channel is the broadcast channel iterable
-  private channel: BroadcastChannelIterable<Uint8Array>
+export class BroadcastChannelConn extends DuplexConn {
+  // broadcastChannel is the broadcast channel iterable
+  private broadcastChannel: BroadcastChannelIterable<Uint8Array>
 
   constructor(
     readChannel: BroadcastChannel,
@@ -72,21 +79,26 @@ export class BroadcastChannelConn extends Conn {
     server?: Server,
     connParams?: ConnParams
   ) {
-    super(server, connParams)
-    this.channel = new BroadcastChannelIterable<Uint8Array>(
+    const broadcastChannel = new BroadcastChannelIterable<Uint8Array>(
       readChannel,
       writeChannel
     )
-    pipe(this, this.channel, this)
+    super(broadcastChannel, server, connParams)
+    this.broadcastChannel = broadcastChannel
   }
 
   // getReadChannel returns the read BroadcastChannel.
   public getReadChannel(): BroadcastChannel {
-    return this.channel.readChannel
+    return this.broadcastChannel.readChannel
   }
 
   // getWriteChannel returns the write BroadcastChannel.
   public getWriteChannel(): BroadcastChannel {
-    return this.channel.writeChannel
+    return this.broadcastChannel.writeChannel
+  }
+
+  // close closes the read and write channels.
+  public close() {
+    this.broadcastChannel.close()
   }
 }

package/srpc/client.ts

@@ -37,6 +37,11 @@ export class Client implements TsProtoRpc {
     this.openConnFn = openConnFn
   }
 
+  // setOpenConnFn updates the openConnFn for the Client.
+  public setOpenConnFn(openConnFn: OpenStreamFunc) {
+    this.openConnFn = openConnFn
+  }
+
   // request starts a non-streaming request.
   public async request(
     service: string,

package/srpc/conn-duplex.ts

@@ -0,0 +1,28 @@
+import { pipe } from 'it-pipe'
+import type { Duplex } from 'it-stream-types'
+
+import { Conn, ConnParams } from './conn.js'
+import { Server } from './server'
+
+// DuplexConn wraps any Duplex<Uint8Array> into a Conn.
+//
+// expects Uint8Array objects
+export class DuplexConn extends Conn {
+  // channel is the iterable
+  private channel: Duplex<Uint8Array>
+
+  constructor(
+    duplex: Duplex<Uint8Array>,
+    server?: Server,
+    connParams?: ConnParams
+  ) {
+    super(server, connParams)
+    this.channel = duplex
+    pipe(this, this.channel, this)
+  }
+
+  // getChannelDuplex returns the Duplex channel.
+  public getChannelDuplex(): Duplex<Uint8Array> {
+    return this.channel
+  }
+}

package/srpc/index.ts

@@ -9,4 +9,10 @@ export {
   BroadcastChannelIterable,
   newBroadcastChannelIterable,
   BroadcastChannelConn,
-} from './broadcast-channel'
+} from './broadcast-channel.js'
+
+export {
+  MessagePortIterable,
+  newMessagePortIterable,
+  MessagePortConn,
+} from './message-port.js'

package/srpc/message-port.ts

@@ -0,0 +1,86 @@
+import type { Duplex, Sink } from 'it-stream-types'
+import { EventIterator } from 'event-iterator'
+
+import { ConnParams } from './conn.js'
+import { DuplexConn } from './conn-duplex.js'
+import { Server } from './server'
+
+// MessagePortIterable is a AsyncIterable wrapper for MessagePort.
+export class MessagePortIterable<T> implements Duplex<T> {
+  // port is the message port
+  public readonly port: MessagePort
+  // sink is the sink for incoming messages.
+  public sink: Sink<T>
+  // source is the source for outgoing messages.
+  public source: AsyncIterable<T>
+  // _source is the EventIterator for source.
+  private _source: EventIterator<T>
+
+  constructor(port: MessagePort) {
+    this.port = port
+    this.sink = this._createSink()
+    this._source = this._createSource()
+    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) => {
+      for await (const msg of source) {
+        this.port.postMessage(msg)
+      }
+    }
+  }
+
+  // _createSource initializes the source field.
+  private _createSource() {
+    return new EventIterator<T>((queue) => {
+      const messageListener = (ev: MessageEvent<T>) => {
+        if (ev.data) {
+          queue.push(ev.data)
+        }
+      }
+
+      this.port.addEventListener('message', messageListener)
+      return () => {
+        this.port.removeEventListener('message', messageListener)
+      }
+    })
+  }
+}
+
+// newMessagePortIterable constructs a MessagePortIterable with a channel name.
+export function newMessagePortIterable<T>(
+  port: MessagePort
+): MessagePortIterable<T> {
+  return new MessagePortIterable<T>(port)
+}
+
+// MessagePortConn implements a connection with a MessagePort.
+//
+// expects Uint8Array objects over the MessagePort.
+export class MessagePortConn extends DuplexConn {
+  // messagePort is the message port iterable.
+  private messagePort: MessagePortIterable<Uint8Array>
+
+  constructor(port: MessagePort, server?: Server, connParams?: ConnParams) {
+    const messagePort = new MessagePortIterable<Uint8Array>(port)
+    super(messagePort, server, connParams)
+    this.messagePort = messagePort
+  }
+
+  // getMessagePort returns the MessagePort.
+  public getMessagePort(): MessagePort {
+    return this.messagePort.port
+  }
+
+  // close closes the message port.
+  public close() {
+    this.messagePort.close()
+  }
+}