starpc 0.2.0 → 0.3.0

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

@@ -1,17 +1,20 @@
 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 channel: BroadcastChannel;
+    readonly readChannel: BroadcastChannel;
+    readonly writeChannel: BroadcastChannel;
     sink: Sink<T>;
     source: AsyncIterable<T>;
-    constructor(channel: BroadcastChannel);
+    constructor(readChannel: BroadcastChannel, writeChannel: BroadcastChannel);
     private _createSink;
     private _createSource;
 }
-export declare function newBroadcastChannelIterable<T>(name: string): BroadcastChannelIterable<T>;
-export declare class BroadcastChannelConn extends Conn {
-    private channel;
-    constructor(channel: BroadcastChannel, server?: Server, connParams?: ConnParams);
-    getBroadcastChannel(): BroadcastChannel;
+export declare function newBroadcastChannelIterable<T>(readName: string, writeName: string): BroadcastChannelIterable<T>;
+export declare class BroadcastChannelConn extends DuplexConn {
+    private broadcastChannel;
+    constructor(readChannel: BroadcastChannel, writeChannel: BroadcastChannel, server?: Server, connParams?: ConnParams);
+    getReadChannel(): BroadcastChannel;
+    getWriteChannel(): BroadcastChannel;
 }

package/dist/srpc/broadcast-channel.js

@@ -1,16 +1,18 @@
-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 {
-    // channel is the broadcast channel
-    channel;
+    // readChannel is the incoming broadcast channel
+    readChannel;
+    // writeChannel is the outgoing broadcast channel
+    writeChannel;
     // sink is the sink for incoming messages.
     sink;
     // source is the source for outgoing messages.
     source;
-    constructor(channel) {
-        this.channel = channel;
+    constructor(readChannel, writeChannel) {
+        this.readChannel = readChannel;
+        this.writeChannel = writeChannel;
         this.sink = this._createSink();
         this.source = this._createSource();
     }
@@ -18,7 +20,7 @@ export class BroadcastChannelIterable {
     _createSink() {
         return async (source) => {
             for await (const msg of source) {
-                this.channel.postMessage(msg);
+                this.writeChannel.postMessage(msg);
             }
         };
     }
@@ -30,31 +32,34 @@ export class BroadcastChannelIterable {
                     queue.push(ev.data);
                 }
             };
-            this.channel.addEventListener('message', messageListener);
+            this.readChannel.addEventListener('message', messageListener);
             return () => {
-                this.channel.removeEventListener('message', messageListener);
+                this.readChannel.removeEventListener('message', messageListener);
             };
         });
     }
 }
 // newBroadcastChannelIterable constructs a BroadcastChannelIterable with a channel name.
-export function newBroadcastChannelIterable(name) {
-    const channel = new BroadcastChannel(name);
-    return new BroadcastChannelIterable(channel);
+export function newBroadcastChannelIterable(readName, writeName) {
+    return new BroadcastChannelIterable(new BroadcastChannel(readName), new BroadcastChannel(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;
-    constructor(channel, server, connParams) {
-        super(server, connParams);
-        this.channel = new BroadcastChannelIterable(channel);
-        pipe(this, this.channel, this);
+export class BroadcastChannelConn extends DuplexConn {
+    // broadcastChannel is the broadcast channel iterable
+    broadcastChannel;
+    constructor(readChannel, writeChannel, server, connParams) {
+        const broadcastChannel = new BroadcastChannelIterable(readChannel, writeChannel);
+        super(broadcastChannel, server, connParams);
+        this.broadcastChannel = broadcastChannel;
     }
-    // getBroadcastChannel returns the BroadcastChannel.
-    getBroadcastChannel() {
-        return this.channel.channel;
+    // getReadChannel returns the read BroadcastChannel.
+    getReadChannel() {
+        return this.broadcastChannel.readChannel;
+    }
+    // getWriteChannel returns the write BroadcastChannel.
+    getWriteChannel() {
+        return this.broadcastChannel.writeChannel;
     }
 }

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

@@ -1,7 +1,9 @@
 export type { OpenStreamFunc } from './stream.js';
 export { Client } from './client.js';
 export { Server } from './server.js';
-export { Conn } from './conn.js';
+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.js';
+export { MessagePortIterable, newMessagePortIterable, MessagePortConn, } from './message-port.js';

package/dist/srpc/index.js

@@ -4,3 +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.js';
+export { MessagePortIterable, newMessagePortIterable, MessagePortConn, } from './message-port.js';

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

@@ -0,0 +1,19 @@
+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);
+    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;
+}

package/dist/srpc/message-port.js

@@ -0,0 +1,61 @@
+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;
+    }
+    // _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;
+    }
+}

package/package.json

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

package/srpc/broadcast-channel.ts

@@ -1,20 +1,24 @@
 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> {
-  // channel is the broadcast channel
-  public readonly channel: BroadcastChannel
+  // readChannel is the incoming broadcast channel
+  public readonly readChannel: BroadcastChannel
+  // writeChannel is the outgoing broadcast channel
+  public readonly writeChannel: BroadcastChannel
   // sink is the sink for incoming messages.
   public sink: Sink<T>
   // source is the source for outgoing messages.
   public source: AsyncIterable<T>
 
-  constructor(channel: BroadcastChannel) {
-    this.channel = channel
+  constructor(readChannel: BroadcastChannel, writeChannel: BroadcastChannel) {
+    this.readChannel = readChannel
+    this.writeChannel = writeChannel
     this.sink = this._createSink()
     this.source = this._createSource()
   }
@@ -23,7 +27,7 @@ export class BroadcastChannelIterable<T> implements Duplex<T> {
   private _createSink(): Sink<T> {
     return async (source) => {
       for await (const msg of source) {
-        this.channel.postMessage(msg)
+        this.writeChannel.postMessage(msg)
       }
     }
   }
@@ -36,10 +40,10 @@ export class BroadcastChannelIterable<T> implements Duplex<T> {
           queue.push(ev.data)
         }
       }
-      this.channel.addEventListener('message', messageListener)
+      this.readChannel.addEventListener('message', messageListener)
 
       return () => {
-        this.channel.removeEventListener('message', messageListener)
+        this.readChannel.removeEventListener('message', messageListener)
       }
     })
   }
@@ -47,31 +51,43 @@ export class BroadcastChannelIterable<T> implements Duplex<T> {
 
 // newBroadcastChannelIterable constructs a BroadcastChannelIterable with a channel name.
 export function newBroadcastChannelIterable<T>(
-  name: string
+  readName: string,
+  writeName: string
 ): BroadcastChannelIterable<T> {
-  const channel = new BroadcastChannel(name)
-  return new BroadcastChannelIterable<T>(channel)
+  return new BroadcastChannelIterable<T>(
+    new BroadcastChannel(readName),
+    new BroadcastChannel(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
-  private channel: BroadcastChannelIterable<Uint8Array>
+export class BroadcastChannelConn extends DuplexConn {
+  // broadcastChannel is the broadcast channel iterable
+  private broadcastChannel: BroadcastChannelIterable<Uint8Array>
 
   constructor(
-    channel: BroadcastChannel,
+    readChannel: BroadcastChannel,
+    writeChannel: BroadcastChannel,
     server?: Server,
     connParams?: ConnParams
   ) {
-    super(server, connParams)
-    this.channel = new BroadcastChannelIterable<Uint8Array>(channel)
-    pipe(this, this.channel, this)
+    const broadcastChannel = new BroadcastChannelIterable<Uint8Array>(
+      readChannel,
+      writeChannel
+    )
+    super(broadcastChannel, server, connParams)
+    this.broadcastChannel = broadcastChannel
+  }
+
+  // getReadChannel returns the read BroadcastChannel.
+  public getReadChannel(): BroadcastChannel {
+    return this.broadcastChannel.readChannel
   }
 
-  // getBroadcastChannel returns the BroadcastChannel.
-  public getBroadcastChannel(): BroadcastChannel {
-    return this.channel.channel
+  // getWriteChannel returns the write BroadcastChannel.
+  public getWriteChannel(): BroadcastChannel {
+    return this.broadcastChannel.writeChannel
   }
 }

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

@@ -1,7 +1,18 @@
 export type { OpenStreamFunc } from './stream.js'
 export { Client } from './client.js'
 export { Server } from './server.js'
-export { Conn } from './conn.js'
+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.js'
+
+export {
+  MessagePortIterable,
+  newMessagePortIterable,
+  MessagePortConn,
+} from './message-port.js'

package/srpc/message-port.ts

@@ -0,0 +1,76 @@
+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
+  }
+
+  // _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
+  }
+}