starpc 0.2.2 → 0.3.0

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

@@ -1,6 +1,7 @@
 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;
@@ -11,8 +12,8 @@ export declare class BroadcastChannelIterable<T> implements Duplex<T> {
     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;

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
@@ -47,20 +46,20 @@ 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;
     }
 }

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,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.2",
+  "version": "0.3.0",
   "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> {
@@ -62,9 +63,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 +73,21 @@ 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
   }
 }

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,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
+  }
+}