starpc 0.13.3 → 0.14.1

package/dist/e2e/mock/mock.pb.d.ts

@@ -0,0 +1,94 @@
+import Long from 'long';
+import _m0 from 'protobufjs/minimal.js';
+export declare const protobufPackage = "e2e.mock";
+/** MockMsg is the mock message body. */
+export interface MockMsg {
+    body: string;
+}
+export declare const MockMsg: {
+    encode(message: MockMsg, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): MockMsg;
+    encodeTransform(source: AsyncIterable<MockMsg | MockMsg[]> | Iterable<MockMsg | MockMsg[]>): AsyncIterable<Uint8Array>;
+    decodeTransform(source: AsyncIterable<Uint8Array | Uint8Array[]> | Iterable<Uint8Array | Uint8Array[]>): AsyncIterable<MockMsg>;
+    fromJSON(object: any): MockMsg;
+    toJSON(message: MockMsg): unknown;
+    fromPartial<I extends {
+        body?: string | undefined;
+    } & {
+        body?: string | undefined;
+    } & { [K in Exclude<keyof I, "body">]: never; }>(object: I): MockMsg;
+};
+/** Mock service mocks some RPCs for the e2e tests. */
+export interface Mock {
+    /** MockRequest runs a mock unary request. */
+    MockRequest(request: MockMsg): Promise<MockMsg>;
+}
+export declare class MockClientImpl implements Mock {
+    private readonly rpc;
+    private readonly service;
+    constructor(rpc: Rpc, opts?: {
+        service?: string;
+    });
+    MockRequest(request: MockMsg): Promise<MockMsg>;
+}
+/** Mock service mocks some RPCs for the e2e tests. */
+export declare type MockDefinition = typeof MockDefinition;
+export declare const MockDefinition: {
+    readonly name: "Mock";
+    readonly fullName: "e2e.mock.Mock";
+    readonly methods: {
+        /** MockRequest runs a mock unary request. */
+        readonly mockRequest: {
+            readonly name: "MockRequest";
+            readonly requestType: {
+                encode(message: MockMsg, writer?: _m0.Writer): _m0.Writer;
+                decode(input: _m0.Reader | Uint8Array, length?: number): MockMsg;
+                encodeTransform(source: AsyncIterable<MockMsg | MockMsg[]> | Iterable<MockMsg | MockMsg[]>): AsyncIterable<Uint8Array>;
+                decodeTransform(source: AsyncIterable<Uint8Array | Uint8Array[]> | Iterable<Uint8Array | Uint8Array[]>): AsyncIterable<MockMsg>;
+                fromJSON(object: any): MockMsg;
+                toJSON(message: MockMsg): unknown;
+                fromPartial<I extends {
+                    body?: string | undefined;
+                } & {
+                    body?: string | undefined;
+                } & { [K in Exclude<keyof I, "body">]: never; }>(object: I): MockMsg;
+            };
+            readonly requestStream: false;
+            readonly responseType: {
+                encode(message: MockMsg, writer?: _m0.Writer): _m0.Writer;
+                decode(input: _m0.Reader | Uint8Array, length?: number): MockMsg;
+                encodeTransform(source: AsyncIterable<MockMsg | MockMsg[]> | Iterable<MockMsg | MockMsg[]>): AsyncIterable<Uint8Array>;
+                decodeTransform(source: AsyncIterable<Uint8Array | Uint8Array[]> | Iterable<Uint8Array | Uint8Array[]>): AsyncIterable<MockMsg>;
+                fromJSON(object: any): MockMsg;
+                toJSON(message: MockMsg): unknown;
+                fromPartial<I extends {
+                    body?: string | undefined;
+                } & {
+                    body?: string | undefined;
+                } & { [K in Exclude<keyof I, "body">]: never; }>(object: I): MockMsg;
+            };
+            readonly responseStream: false;
+            readonly options: {};
+        };
+    };
+};
+interface Rpc {
+    request(service: string, method: string, data: Uint8Array): Promise<Uint8Array>;
+}
+declare type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+export declare type DeepPartial<T> = T extends Builtin ? T : T extends Long ? string | number | Long : T extends Array<infer U> ? Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {
+    $case: string;
+} ? {
+    [K in keyof Omit<T, '$case'>]?: DeepPartial<T[K]>;
+} & {
+    $case: T['$case'];
+} : T extends {} ? {
+    [K in keyof T]?: DeepPartial<T[K]>;
+} : Partial<T>;
+declare type KeysOfUnion<T> = T extends T ? keyof T : never;
+export declare type Exact<P, I extends P> = P extends Builtin ? P : P & {
+    [K in keyof P]: Exact<P[K], I[K]>;
+} & {
+    [K in Exclude<keyof I, KeysOfUnion<P>>]: never;
+};
+export {};

package/dist/e2e/mock/mock.pb.js

@@ -0,0 +1,107 @@
+/* eslint-disable */
+import Long from 'long';
+import _m0 from 'protobufjs/minimal.js';
+export const protobufPackage = 'e2e.mock';
+function createBaseMockMsg() {
+    return { body: '' };
+}
+export const MockMsg = {
+    encode(message, writer = _m0.Writer.create()) {
+        if (message.body !== '') {
+            writer.uint32(10).string(message.body);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseMockMsg();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.body = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    // encodeTransform encodes a source of message objects.
+    // Transform<MockMsg, Uint8Array>
+    async *encodeTransform(source) {
+        for await (const pkt of source) {
+            if (Array.isArray(pkt)) {
+                for (const p of pkt) {
+                    yield* [MockMsg.encode(p).finish()];
+                }
+            }
+            else {
+                yield* [MockMsg.encode(pkt).finish()];
+            }
+        }
+    },
+    // decodeTransform decodes a source of encoded messages.
+    // Transform<Uint8Array, MockMsg>
+    async *decodeTransform(source) {
+        for await (const pkt of source) {
+            if (Array.isArray(pkt)) {
+                for (const p of pkt) {
+                    yield* [MockMsg.decode(p)];
+                }
+            }
+            else {
+                yield* [MockMsg.decode(pkt)];
+            }
+        }
+    },
+    fromJSON(object) {
+        return { body: isSet(object.body) ? String(object.body) : '' };
+    },
+    toJSON(message) {
+        const obj = {};
+        message.body !== undefined && (obj.body = message.body);
+        return obj;
+    },
+    fromPartial(object) {
+        const message = createBaseMockMsg();
+        message.body = object.body ?? '';
+        return message;
+    },
+};
+export class MockClientImpl {
+    constructor(rpc, opts) {
+        this.service = opts?.service || 'e2e.mock.Mock';
+        this.rpc = rpc;
+        this.MockRequest = this.MockRequest.bind(this);
+    }
+    MockRequest(request) {
+        const data = MockMsg.encode(request).finish();
+        const promise = this.rpc.request(this.service, 'MockRequest', data);
+        return promise.then((data) => MockMsg.decode(new _m0.Reader(data)));
+    }
+}
+export const MockDefinition = {
+    name: 'Mock',
+    fullName: 'e2e.mock.Mock',
+    methods: {
+        /** MockRequest runs a mock unary request. */
+        mockRequest: {
+            name: 'MockRequest',
+            requestType: MockMsg,
+            requestStream: false,
+            responseType: MockMsg,
+            responseStream: false,
+            options: {},
+        },
+    },
+};
+if (_m0.util.Long !== Long) {
+    _m0.util.Long = Long;
+    _m0.configure();
+}
+function isSet(value) {
+    return value !== null && value !== undefined;
+}

package/dist/echo/echo.pb.d.ts

@@ -1,6 +1,6 @@
-import Long from "long";
-import _m0 from "protobufjs/minimal.js";
-import { RpcStreamPacket } from "../rpcstream/rpcstream.pb.js";
+import Long from 'long';
+import _m0 from 'protobufjs/minimal.js';
+import { RpcStreamPacket } from '../rpcstream/rpcstream.pb.js';
 export declare const protobufPackage = "echo";
 /** EchoMsg is the message body for Echo. */
 export interface EchoMsg {
@@ -325,9 +325,9 @@ declare type Builtin = Date | Function | Uint8Array | string | number | boolean
 export declare type DeepPartial<T> = T extends Builtin ? T : T extends Long ? string | number | Long : T extends Array<infer U> ? Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {
     $case: string;
 } ? {
-    [K in keyof Omit<T, "$case">]?: DeepPartial<T[K]>;
+    [K in keyof Omit<T, '$case'>]?: DeepPartial<T[K]>;
 } & {
-    $case: T["$case"];
+    $case: T['$case'];
 } : T extends {} ? {
     [K in keyof T]?: DeepPartial<T[K]>;
 } : Partial<T>;

package/dist/echo/echo.pb.js

@@ -1,14 +1,14 @@
 /* eslint-disable */
-import Long from "long";
-import _m0 from "protobufjs/minimal.js";
-import { RpcStreamPacket } from "../rpcstream/rpcstream.pb.js";
-export const protobufPackage = "echo";
+import Long from 'long';
+import _m0 from 'protobufjs/minimal.js';
+import { RpcStreamPacket } from '../rpcstream/rpcstream.pb.js';
+export const protobufPackage = 'echo';
 function createBaseEchoMsg() {
-    return { body: "" };
+    return { body: '' };
 }
 export const EchoMsg = {
     encode(message, writer = _m0.Writer.create()) {
-        if (message.body !== "") {
+        if (message.body !== '') {
             writer.uint32(10).string(message.body);
         }
         return writer;
@@ -59,7 +59,7 @@ export const EchoMsg = {
         }
     },
     fromJSON(object) {
-        return { body: isSet(object.body) ? String(object.body) : "" };
+        return { body: isSet(object.body) ? String(object.body) : '' };
     },
     toJSON(message) {
         const obj = {};
@@ -68,13 +68,13 @@ export const EchoMsg = {
     },
     fromPartial(object) {
         const message = createBaseEchoMsg();
-        message.body = object.body ?? "";
+        message.body = object.body ?? '';
         return message;
     },
 };
 export class EchoerClientImpl {
     constructor(rpc, opts) {
-        this.service = opts?.service || "echo.Echoer";
+        this.service = opts?.service || 'echo.Echoer';
         this.rpc = rpc;
         this.Echo = this.Echo.bind(this);
         this.EchoServerStream = this.EchoServerStream.bind(this);
@@ -84,37 +84,37 @@ export class EchoerClientImpl {
     }
     Echo(request) {
         const data = EchoMsg.encode(request).finish();
-        const promise = this.rpc.request(this.service, "Echo", data);
+        const promise = this.rpc.request(this.service, 'Echo', data);
         return promise.then((data) => EchoMsg.decode(new _m0.Reader(data)));
     }
     EchoServerStream(request) {
         const data = EchoMsg.encode(request).finish();
-        const result = this.rpc.serverStreamingRequest(this.service, "EchoServerStream", data);
+        const result = this.rpc.serverStreamingRequest(this.service, 'EchoServerStream', data);
         return EchoMsg.decodeTransform(result);
     }
     EchoClientStream(request) {
         const data = EchoMsg.encodeTransform(request);
-        const promise = this.rpc.clientStreamingRequest(this.service, "EchoClientStream", data);
+        const promise = this.rpc.clientStreamingRequest(this.service, 'EchoClientStream', data);
         return promise.then((data) => EchoMsg.decode(new _m0.Reader(data)));
     }
     EchoBidiStream(request) {
         const data = EchoMsg.encodeTransform(request);
-        const result = this.rpc.bidirectionalStreamingRequest(this.service, "EchoBidiStream", data);
+        const result = this.rpc.bidirectionalStreamingRequest(this.service, 'EchoBidiStream', data);
         return EchoMsg.decodeTransform(result);
     }
     RpcStream(request) {
         const data = RpcStreamPacket.encodeTransform(request);
-        const result = this.rpc.bidirectionalStreamingRequest(this.service, "RpcStream", data);
+        const result = this.rpc.bidirectionalStreamingRequest(this.service, 'RpcStream', data);
         return RpcStreamPacket.decodeTransform(result);
     }
 }
 export const EchoerDefinition = {
-    name: "Echoer",
-    fullName: "echo.Echoer",
+    name: 'Echoer',
+    fullName: 'echo.Echoer',
     methods: {
         /** Echo returns the given message. */
         echo: {
-            name: "Echo",
+            name: 'Echo',
             requestType: EchoMsg,
             requestStream: false,
             responseType: EchoMsg,
@@ -123,7 +123,7 @@ export const EchoerDefinition = {
         },
         /** EchoServerStream is an example of a server -> client one-way stream. */
         echoServerStream: {
-            name: "EchoServerStream",
+            name: 'EchoServerStream',
             requestType: EchoMsg,
             requestStream: false,
             responseType: EchoMsg,
@@ -132,7 +132,7 @@ export const EchoerDefinition = {
         },
         /** EchoClientStream is an example of client->server one-way stream. */
         echoClientStream: {
-            name: "EchoClientStream",
+            name: 'EchoClientStream',
             requestType: EchoMsg,
             requestStream: true,
             responseType: EchoMsg,
@@ -141,7 +141,7 @@ export const EchoerDefinition = {
         },
         /** EchoBidiStream is an example of a two-way stream. */
         echoBidiStream: {
-            name: "EchoBidiStream",
+            name: 'EchoBidiStream',
             requestType: EchoMsg,
             requestStream: true,
             responseType: EchoMsg,
@@ -150,7 +150,7 @@ export const EchoerDefinition = {
         },
         /** RpcStream opens a nested rpc call stream. */
         rpcStream: {
-            name: "RpcStream",
+            name: 'RpcStream',
             requestType: RpcStreamPacket,
             requestStream: true,
             responseType: RpcStreamPacket,

package/dist/rpcstream/rpcstream.pb.d.ts

@@ -1,16 +1,16 @@
-import Long from "long";
-import _m0 from "protobufjs/minimal.js";
+import Long from 'long';
+import _m0 from 'protobufjs/minimal.js';
 export declare const protobufPackage = "rpcstream";
 /** RpcStreamPacket is a packet encapsulating data for a RPC stream. */
 export interface RpcStreamPacket {
     body?: {
-        $case: "init";
+        $case: 'init';
         init: RpcStreamInit;
     } | {
-        $case: "ack";
+        $case: 'ack';
         ack: RpcAck;
     } | {
-        $case: "data";
+        $case: 'data';
         data: Uint8Array;
     };
 }
@@ -116,9 +116,9 @@ declare type Builtin = Date | Function | Uint8Array | string | number | boolean
 export declare type DeepPartial<T> = T extends Builtin ? T : T extends Long ? string | number | Long : T extends Array<infer U> ? Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {
     $case: string;
 } ? {
-    [K in keyof Omit<T, "$case">]?: DeepPartial<T[K]>;
+    [K in keyof Omit<T, '$case'>]?: DeepPartial<T[K]>;
 } & {
-    $case: T["$case"];
+    $case: T['$case'];
 } : T extends {} ? {
     [K in keyof T]?: DeepPartial<T[K]>;
 } : Partial<T>;

package/dist/rpcstream/rpcstream.pb.js

@@ -1,19 +1,19 @@
 /* eslint-disable */
-import Long from "long";
-import _m0 from "protobufjs/minimal.js";
-export const protobufPackage = "rpcstream";
+import Long from 'long';
+import _m0 from 'protobufjs/minimal.js';
+export const protobufPackage = 'rpcstream';
 function createBaseRpcStreamPacket() {
     return { body: undefined };
 }
 export const RpcStreamPacket = {
     encode(message, writer = _m0.Writer.create()) {
-        if (message.body?.$case === "init") {
+        if (message.body?.$case === 'init') {
             RpcStreamInit.encode(message.body.init, writer.uint32(10).fork()).ldelim();
         }
-        if (message.body?.$case === "ack") {
+        if (message.body?.$case === 'ack') {
             RpcAck.encode(message.body.ack, writer.uint32(18).fork()).ldelim();
         }
-        if (message.body?.$case === "data") {
+        if (message.body?.$case === 'data') {
             writer.uint32(26).bytes(message.body.data);
         }
         return writer;
@@ -26,13 +26,19 @@ export const RpcStreamPacket = {
             const tag = reader.uint32();
             switch (tag >>> 3) {
                 case 1:
-                    message.body = { $case: "init", init: RpcStreamInit.decode(reader, reader.uint32()) };
+                    message.body = {
+                        $case: 'init',
+                        init: RpcStreamInit.decode(reader, reader.uint32()),
+                    };
                     break;
                 case 2:
-                    message.body = { $case: "ack", ack: RpcAck.decode(reader, reader.uint32()) };
+                    message.body = {
+                        $case: 'ack',
+                        ack: RpcAck.decode(reader, reader.uint32()),
+                    };
                     break;
                 case 3:
-                    message.body = { $case: "data", data: reader.bytes() };
+                    message.body = { $case: 'data', data: reader.bytes() };
                     break;
                 default:
                     reader.skipType(tag & 7);
@@ -72,43 +78,60 @@ export const RpcStreamPacket = {
     fromJSON(object) {
         return {
             body: isSet(object.init)
-                ? { $case: "init", init: RpcStreamInit.fromJSON(object.init) }
+                ? { $case: 'init', init: RpcStreamInit.fromJSON(object.init) }
                 : isSet(object.ack)
-                    ? { $case: "ack", ack: RpcAck.fromJSON(object.ack) }
+                    ? { $case: 'ack', ack: RpcAck.fromJSON(object.ack) }
                     : isSet(object.data)
-                        ? { $case: "data", data: bytesFromBase64(object.data) }
+                        ? { $case: 'data', data: bytesFromBase64(object.data) }
                         : undefined,
         };
     },
     toJSON(message) {
         const obj = {};
-        message.body?.$case === "init" &&
-            (obj.init = message.body?.init ? RpcStreamInit.toJSON(message.body?.init) : undefined);
-        message.body?.$case === "ack" && (obj.ack = message.body?.ack ? RpcAck.toJSON(message.body?.ack) : undefined);
-        message.body?.$case === "data" &&
-            (obj.data = message.body?.data !== undefined ? base64FromBytes(message.body?.data) : undefined);
+        message.body?.$case === 'init' &&
+            (obj.init = message.body?.init
+                ? RpcStreamInit.toJSON(message.body?.init)
+                : undefined);
+        message.body?.$case === 'ack' &&
+            (obj.ack = message.body?.ack
+                ? RpcAck.toJSON(message.body?.ack)
+                : undefined);
+        message.body?.$case === 'data' &&
+            (obj.data =
+                message.body?.data !== undefined
+                    ? base64FromBytes(message.body?.data)
+                    : undefined);
         return obj;
     },
     fromPartial(object) {
         const message = createBaseRpcStreamPacket();
-        if (object.body?.$case === "init" && object.body?.init !== undefined && object.body?.init !== null) {
-            message.body = { $case: "init", init: RpcStreamInit.fromPartial(object.body.init) };
+        if (object.body?.$case === 'init' &&
+            object.body?.init !== undefined &&
+            object.body?.init !== null) {
+            message.body = {
+                $case: 'init',
+                init: RpcStreamInit.fromPartial(object.body.init),
+            };
         }
-        if (object.body?.$case === "ack" && object.body?.ack !== undefined && object.body?.ack !== null) {
-            message.body = { $case: "ack", ack: RpcAck.fromPartial(object.body.ack) };
+        if (object.body?.$case === 'ack' &&
+            object.body?.ack !== undefined &&
+            object.body?.ack !== null) {
+            message.body = { $case: 'ack', ack: RpcAck.fromPartial(object.body.ack) };
         }
-        if (object.body?.$case === "data" && object.body?.data !== undefined && object.body?.data !== null) {
-            message.body = { $case: "data", data: object.body.data };
+        if (object.body?.$case === 'data' &&
+            object.body?.data !== undefined &&
+            object.body?.data !== null) {
+            message.body = { $case: 'data', data: object.body.data };
         }
         return message;
     },
 };
 function createBaseRpcStreamInit() {
-    return { componentId: "" };
+    return { componentId: '' };
 }
 export const RpcStreamInit = {
     encode(message, writer = _m0.Writer.create()) {
-        if (message.componentId !== "") {
+        if (message.componentId !== '') {
             writer.uint32(10).string(message.componentId);
         }
         return writer;
@@ -159,7 +182,9 @@ export const RpcStreamInit = {
         }
     },
     fromJSON(object) {
-        return { componentId: isSet(object.componentId) ? String(object.componentId) : "" };
+        return {
+            componentId: isSet(object.componentId) ? String(object.componentId) : '',
+        };
     },
     toJSON(message) {
         const obj = {};
@@ -168,16 +193,16 @@ export const RpcStreamInit = {
     },
     fromPartial(object) {
         const message = createBaseRpcStreamInit();
-        message.componentId = object.componentId ?? "";
+        message.componentId = object.componentId ?? '';
         return message;
     },
 };
 function createBaseRpcAck() {
-    return { error: "" };
+    return { error: '' };
 }
 export const RpcAck = {
     encode(message, writer = _m0.Writer.create()) {
-        if (message.error !== "") {
+        if (message.error !== '') {
             writer.uint32(10).string(message.error);
         }
         return writer;
@@ -228,7 +253,7 @@ export const RpcAck = {
         }
     },
     fromJSON(object) {
-        return { error: isSet(object.error) ? String(object.error) : "" };
+        return { error: isSet(object.error) ? String(object.error) : '' };
     },
     toJSON(message) {
         const obj = {};
@@ -237,28 +262,28 @@ export const RpcAck = {
     },
     fromPartial(object) {
         const message = createBaseRpcAck();
-        message.error = object.error ?? "";
+        message.error = object.error ?? '';
         return message;
     },
 };
 var globalThis = (() => {
-    if (typeof globalThis !== "undefined") {
+    if (typeof globalThis !== 'undefined') {
         return globalThis;
     }
-    if (typeof self !== "undefined") {
+    if (typeof self !== 'undefined') {
         return self;
     }
-    if (typeof window !== "undefined") {
+    if (typeof window !== 'undefined') {
         return window;
     }
-    if (typeof global !== "undefined") {
+    if (typeof global !== 'undefined') {
         return global;
     }
-    throw "Unable to locate global object";
+    throw 'Unable to locate global object';
 })();
 function bytesFromBase64(b64) {
     if (globalThis.Buffer) {
-        return Uint8Array.from(globalThis.Buffer.from(b64, "base64"));
+        return Uint8Array.from(globalThis.Buffer.from(b64, 'base64'));
     }
     else {
         const bin = globalThis.atob(b64);
@@ -271,14 +296,14 @@ function bytesFromBase64(b64) {
 }
 function base64FromBytes(arr) {
     if (globalThis.Buffer) {
-        return globalThis.Buffer.from(arr).toString("base64");
+        return globalThis.Buffer.from(arr).toString('base64');
     }
     else {
         const bin = [];
         arr.forEach((byte) => {
             bin.push(String.fromCharCode(byte));
         });
-        return globalThis.btoa(bin.join(""));
+        return globalThis.btoa(bin.join(''));
     }
 }
 if (_m0.util.Long !== Long) {

package/dist/srpc/client.d.ts

@@ -1,11 +1,9 @@
 import type { TsProtoRpc } from './ts-proto-rpc.js';
 import type { OpenStreamFunc } from './stream.js';
 export declare class Client implements TsProtoRpc {
-    private openStreamFn;
-    private _openStreamFn?;
+    private openStreamCtr;
     constructor(openStreamFn?: OpenStreamFunc);
-    setOpenStreamFn(openStreamFn?: OpenStreamFunc): Promise<OpenStreamFunc>;
-    private initOpenStreamFn;
+    setOpenStreamFn(openStreamFn?: OpenStreamFunc): void;
     request(service: string, method: string, data: Uint8Array): Promise<Uint8Array>;
     clientStreamingRequest(service: string, method: string, data: AsyncIterable<Uint8Array>): Promise<Uint8Array>;
     serverStreamingRequest(service: string, method: string, data: Uint8Array): AsyncIterable<Uint8Array>;

package/dist/srpc/client.js

@@ -4,43 +4,15 @@ import { ClientRPC } from './client-rpc.js';
 import { writeToPushable } from './pushable.js';
 import { decodePacketSource, encodePacketSource, parseLengthPrefixTransform, prependLengthPrefixTransform, } from './packet.js';
 import { combineUint8ArrayListTransform } from './array-list.js';
+import { OpenStreamCtr } from './open-stream-ctr.js';
 // Client implements the ts-proto Rpc interface with the drpcproto protocol.
 export class Client {
     constructor(openStreamFn) {
-        this.openStreamFn = this.setOpenStreamFn(openStreamFn);
+        this.openStreamCtr = new OpenStreamCtr(openStreamFn || undefined);
     }
     // setOpenStreamFn updates the openStreamFn for the Client.
     setOpenStreamFn(openStreamFn) {
-        if (this._openStreamFn) {
-            if (openStreamFn) {
-                this._openStreamFn(openStreamFn);
-                this._openStreamFn = undefined;
-            }
-        }
-        else {
-            if (openStreamFn) {
-                this.openStreamFn = Promise.resolve(openStreamFn);
-            }
-            else {
-                this.initOpenStreamFn();
-            }
-        }
-        return this.openStreamFn;
-    }
-    // initOpenStreamFn creates the empty Promise for openStreamFn.
-    initOpenStreamFn() {
-        const openPromise = new Promise((resolve, reject) => {
-            this._openStreamFn = (conn, err) => {
-                if (err) {
-                    reject(err);
-                }
-                else if (conn) {
-                    resolve(conn);
-                }
-            };
-        });
-        this.openStreamFn = openPromise;
-        return this.openStreamFn;
+        this.openStreamCtr.set(openStreamFn || undefined);
     }
     // request starts a non-streaming request.
     async request(service, method, data) {
@@ -98,7 +70,7 @@ 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 openStreamFn = await this.openStreamFn;
+        const openStreamFn = await this.openStreamCtr.wait();
         const conn = await openStreamFn();
         const call = new ClientRPC(rpcService, rpcMethod);
         pipe(conn, parseLengthPrefixTransform(), combineUint8ArrayListTransform(), decodePacketSource, call, encodePacketSource, prependLengthPrefixTransform(), conn);