starpc 0.31.6 → 0.31.8

package/dist/rpcstream/rpcstream_pb.d.ts

@@ -1,15 +1,46 @@
-import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from '@bufbuild/protobuf';
-import { Message, proto3 } from '@bufbuild/protobuf';
+import { Message, MessageType } from '@aptre/protobuf-es-lite';
+export declare const protobufPackage = "rpcstream";
+/**
+ * RpcStreamInit is the first message in a RPC stream.
+ *
+ * @generated from message rpcstream.RpcStreamInit
+ */
+export interface RpcStreamInit extends Message<RpcStreamInit> {
+    /**
+     * ComponentId is the identifier of the component making the request.
+     *
+     * @generated from field: string component_id = 1;
+     */
+    componentId?: string;
+}
+export declare const RpcStreamInit: MessageType<RpcStreamInit>;
+/**
+ * RpcAck is the ack message in a RPC stream.
+ *
+ * @generated from message rpcstream.RpcAck
+ */
+export interface RpcAck extends Message<RpcAck> {
+    /**
+     * Error indicates there was some error setting up the stream.
+     *
+     * @generated from field: string error = 1;
+     */
+    error?: string;
+}
+export declare const RpcAck: MessageType<RpcAck>;
 /**
  * RpcStreamPacket is a packet encapsulating data for a RPC stream.
  *
  * @generated from message rpcstream.RpcStreamPacket
  */
-export declare class RpcStreamPacket extends Message<RpcStreamPacket> {
+export interface RpcStreamPacket extends Message<RpcStreamPacket> {
     /**
      * @generated from oneof rpcstream.RpcStreamPacket.body
      */
-    body: {
+    body?: {
+        value?: undefined;
+        case: undefined;
+    } | {
         /**
          * Init is the first packet in the stream.
          * Sent by the initiator.
@@ -35,58 +66,6 @@ export declare class RpcStreamPacket extends Message<RpcStreamPacket> {
          */
         value: Uint8Array;
         case: 'data';
-    } | {
-        case: undefined;
-        value?: undefined;
     };
-    constructor(data?: PartialMessage<RpcStreamPacket>);
-    static readonly runtime: typeof proto3;
-    static readonly typeName = "rpcstream.RpcStreamPacket";
-    static readonly fields: FieldList;
-    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): RpcStreamPacket;
-    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): RpcStreamPacket;
-    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): RpcStreamPacket;
-    static equals(a: RpcStreamPacket | PlainMessage<RpcStreamPacket> | undefined, b: RpcStreamPacket | PlainMessage<RpcStreamPacket> | undefined): boolean;
-}
-/**
- * RpcStreamInit is the first message in a RPC stream.
- *
- * @generated from message rpcstream.RpcStreamInit
- */
-export declare class RpcStreamInit extends Message<RpcStreamInit> {
-    /**
-     * ComponentId is the identifier of the component making the request.
-     *
-     * @generated from field: string component_id = 1;
-     */
-    componentId: string;
-    constructor(data?: PartialMessage<RpcStreamInit>);
-    static readonly runtime: typeof proto3;
-    static readonly typeName = "rpcstream.RpcStreamInit";
-    static readonly fields: FieldList;
-    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): RpcStreamInit;
-    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): RpcStreamInit;
-    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): RpcStreamInit;
-    static equals(a: RpcStreamInit | PlainMessage<RpcStreamInit> | undefined, b: RpcStreamInit | PlainMessage<RpcStreamInit> | undefined): boolean;
-}
-/**
- * RpcAck is the ack message in a RPC stream.
- *
- * @generated from message rpcstream.RpcAck
- */
-export declare class RpcAck extends Message<RpcAck> {
-    /**
-     * Error indicates there was some error setting up the stream.
-     *
-     * @generated from field: string error = 1;
-     */
-    error: string;
-    constructor(data?: PartialMessage<RpcAck>);
-    static readonly runtime: typeof proto3;
-    static readonly typeName = "rpcstream.RpcAck";
-    static readonly fields: FieldList;
-    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): RpcAck;
-    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): RpcAck;
-    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): RpcAck;
-    static equals(a: RpcAck | PlainMessage<RpcAck> | undefined, b: RpcAck | PlainMessage<RpcAck> | undefined): boolean;
 }
+export declare const RpcStreamPacket: MessageType<RpcStreamPacket>;

package/dist/rpcstream/rpcstream_pb.js

@@ -1,24 +1,30 @@
-// @generated by protoc-gen-es v1.9.0 with parameter "target=ts,ts_nocheck=false"
+// @generated by protoc-gen-es-lite unknown with parameter "target=ts,ts_nocheck=false"
 // @generated from file github.com/aperturerobotics/starpc/rpcstream/rpcstream.proto (package rpcstream, syntax proto3)
 /* eslint-disable */
-import { Message, proto3 } from '@bufbuild/protobuf';
-/**
- * RpcStreamPacket is a packet encapsulating data for a RPC stream.
- *
- * @generated from message rpcstream.RpcStreamPacket
- */
-export class RpcStreamPacket extends Message {
-    /**
-     * @generated from oneof rpcstream.RpcStreamPacket.body
-     */
-    body = { case: undefined };
-    constructor(data) {
-        super();
-        proto3.util.initPartial(data, this);
-    }
-    static runtime = proto3;
-    static typeName = 'rpcstream.RpcStreamPacket';
-    static fields = proto3.util.newFieldList(() => [
+import { createMessageType, } from '@aptre/protobuf-es-lite';
+export const protobufPackage = 'rpcstream';
+export const RpcStreamInit = createMessageType({
+    typeName: 'rpcstream.RpcStreamInit',
+    fields: [
+        {
+            no: 1,
+            name: 'component_id',
+            kind: 'scalar',
+            T: 9 /* ScalarType.STRING */,
+        },
+    ],
+    packedByDefault: true,
+});
+export const RpcAck = createMessageType({
+    typeName: 'rpcstream.RpcAck',
+    fields: [
+        { no: 1, name: 'error', kind: 'scalar', T: 9 /* ScalarType.STRING */ },
+    ],
+    packedByDefault: true,
+});
+export const RpcStreamPacket = createMessageType({
+    typeName: 'rpcstream.RpcStreamPacket',
+    fields: [
         { no: 1, name: 'init', kind: 'message', T: RpcStreamInit, oneof: 'body' },
         { no: 2, name: 'ack', kind: 'message', T: RpcAck, oneof: 'body' },
         {
@@ -28,90 +34,6 @@ export class RpcStreamPacket extends Message {
             T: 12 /* ScalarType.BYTES */,
             oneof: 'body',
         },
-    ]);
-    static fromBinary(bytes, options) {
-        return new RpcStreamPacket().fromBinary(bytes, options);
-    }
-    static fromJson(jsonValue, options) {
-        return new RpcStreamPacket().fromJson(jsonValue, options);
-    }
-    static fromJsonString(jsonString, options) {
-        return new RpcStreamPacket().fromJsonString(jsonString, options);
-    }
-    static equals(a, b) {
-        return proto3.util.equals(RpcStreamPacket, a, b);
-    }
-}
-/**
- * RpcStreamInit is the first message in a RPC stream.
- *
- * @generated from message rpcstream.RpcStreamInit
- */
-export class RpcStreamInit extends Message {
-    /**
-     * ComponentId is the identifier of the component making the request.
-     *
-     * @generated from field: string component_id = 1;
-     */
-    componentId = '';
-    constructor(data) {
-        super();
-        proto3.util.initPartial(data, this);
-    }
-    static runtime = proto3;
-    static typeName = 'rpcstream.RpcStreamInit';
-    static fields = proto3.util.newFieldList(() => [
-        {
-            no: 1,
-            name: 'component_id',
-            kind: 'scalar',
-            T: 9 /* ScalarType.STRING */,
-        },
-    ]);
-    static fromBinary(bytes, options) {
-        return new RpcStreamInit().fromBinary(bytes, options);
-    }
-    static fromJson(jsonValue, options) {
-        return new RpcStreamInit().fromJson(jsonValue, options);
-    }
-    static fromJsonString(jsonString, options) {
-        return new RpcStreamInit().fromJsonString(jsonString, options);
-    }
-    static equals(a, b) {
-        return proto3.util.equals(RpcStreamInit, a, b);
-    }
-}
-/**
- * RpcAck is the ack message in a RPC stream.
- *
- * @generated from message rpcstream.RpcAck
- */
-export class RpcAck extends Message {
-    /**
-     * Error indicates there was some error setting up the stream.
-     *
-     * @generated from field: string error = 1;
-     */
-    error = '';
-    constructor(data) {
-        super();
-        proto3.util.initPartial(data, this);
-    }
-    static runtime = proto3;
-    static typeName = 'rpcstream.RpcAck';
-    static fields = proto3.util.newFieldList(() => [
-        { no: 1, name: 'error', kind: 'scalar', T: 9 /* ScalarType.STRING */ },
-    ]);
-    static fromBinary(bytes, options) {
-        return new RpcAck().fromBinary(bytes, options);
-    }
-    static fromJson(jsonValue, options) {
-        return new RpcAck().fromJson(jsonValue, options);
-    }
-    static fromJsonString(jsonString, options) {
-        return new RpcAck().fromJsonString(jsonString, options);
-    }
-    static equals(a, b) {
-        return proto3.util.equals(RpcAck, a, b);
-    }
-}
+    ],
+    packedByDefault: true,
+});

package/dist/srpc/client-rpc.d.ts

@@ -3,5 +3,5 @@ import { CommonRPC } from './common-rpc.js';
 export declare class ClientRPC extends CommonRPC {
     constructor(service: string, method: string);
     writeCallStart(data?: Uint8Array): Promise<void>;
-    handleCallStart(packet: Partial<CallStart>): Promise<void>;
+    handleCallStart(packet: CallStart): Promise<void>;
 }

package/dist/srpc/client-rpc.js

@@ -28,6 +28,6 @@ export class ClientRPC extends CommonRPC {
     // handleCallStart handles a CallStart packet.
     async handleCallStart(packet) {
         // we do not implement server -> client RPCs.
-        throw new Error(`unexpected server to client rpc: ${packet.rpcService}/${packet.rpcMethod}`);
+        throw new Error(`unexpected server to client rpc: ${packet.rpcService || '<empty>'}/${packet.rpcMethod || '<empty>'}`);
     }
 }

package/dist/srpc/common-rpc.d.ts

@@ -1,10 +1,9 @@
 import type { Sink, Source } from 'it-stream-types';
-import { PartialMessage } from '@bufbuild/protobuf';
 import type { CallData, CallStart } from './rpcproto_pb.js';
 import { Packet } from './rpcproto_pb.js';
 export declare class CommonRPC {
-    readonly sink: Sink<Source<PartialMessage<Packet>>>;
-    readonly source: AsyncIterable<PartialMessage<Packet>>;
+    readonly sink: Sink<Source<Packet>>;
+    readonly source: AsyncIterable<Packet>;
     readonly rpcDataSource: AsyncIterable<Uint8Array>;
     private readonly _source;
     private readonly _rpcDataSource;
@@ -16,9 +15,9 @@ export declare class CommonRPC {
     writeCallData(data?: Uint8Array, complete?: boolean, error?: string): Promise<void>;
     writeCallCancel(): Promise<void>;
     writeCallDataFromSource(dataSource: AsyncIterable<Uint8Array>): Promise<void>;
-    protected writePacket(packet: PartialMessage<Packet>): Promise<void>;
+    protected writePacket(packet: Packet): Promise<void>;
     handleMessage(message: Uint8Array): Promise<void>;
-    handlePacket(packet: PartialMessage<Packet>): Promise<void>;
+    handlePacket(packet: Packet): Promise<void>;
     handleCallStart(packet: Partial<CallStart>): Promise<void>;
     protected pushRpcData(data: Uint8Array | undefined, dataIsZero: boolean | undefined): void;
     handleCallData(packet: Partial<CallData>): Promise<void>;

package/dist/srpc/definition.d.ts

@@ -1,4 +1,5 @@
-import { MessageType, MethodKind, MethodIdempotency } from '@bufbuild/protobuf';
+import { MethodIdempotency, MethodKind } from '@bufbuild/protobuf';
+import { MessageType } from '@aptre/protobuf-es-lite';
 export type ServiceMethodDefinitions = {
     [id: string]: MethodDefinition<MessageType, MessageType, MethodKind, MethodIdempotency | undefined>;
 };

package/dist/srpc/invoker.d.ts

@@ -1,5 +1,6 @@
 import type { MethodDefinition } from './definition.js';
 import { InvokeFn } from './handler.js';
-import { Message, MessageType, MethodIdempotency, MethodKind, PartialMessage } from '@bufbuild/protobuf';
-export type MethodProto<R extends Message<R>, O extends Message<O>> = ((request: R) => Promise<O>) | ((request: R) => AsyncIterable<O>) | ((request: AsyncIterable<PartialMessage<R>>) => Promise<O>) | ((request: AsyncIterable<PartialMessage<R>>) => AsyncIterable<O>);
+import type { MessageType, Message } from '@aptre/protobuf-es-lite';
+import { MethodIdempotency, MethodKind } from '@bufbuild/protobuf';
+export type MethodProto<R extends Message<R>, O extends Message<O>> = ((request: R) => Promise<O>) | ((request: R) => AsyncIterable<O>) | ((request: AsyncIterable<Message<R>>) => Promise<O>) | ((request: AsyncIterable<Message<R>>) => AsyncIterable<O>);
 export declare function createInvokeFn<R extends Message<R>, O extends Message<O>>(methodInfo: MethodDefinition<MessageType<R>, MessageType<O>, MethodKind, MethodIdempotency | undefined>, methodProto: MethodProto<R, O>): InvokeFn;

package/dist/srpc/invoker.js

@@ -2,7 +2,7 @@ import { pushable } from 'it-pushable';
 import { pipe } from 'it-pipe';
 import { buildDecodeMessageTransform, buildEncodeMessageTransform, } from './message.js';
 import { writeToPushable } from './pushable.js';
-import { MethodKind, } from '@bufbuild/protobuf';
+import { MethodKind } from '@bufbuild/protobuf';
 // createInvokeFn builds an InvokeFn from a method definition and a function prototype.
 export function createInvokeFn(methodInfo, methodProto) {
     const requestDecode = buildDecodeMessageTransform(methodInfo.I);

package/dist/srpc/message.d.ts

@@ -1,9 +1,9 @@
+import { MessageType, Message } from '@aptre/protobuf-es-lite';
 import type { Source } from 'it-stream-types';
-import { Message, PartialMessage, MessageType } from '@bufbuild/protobuf';
-export type MessageStream<T extends Message<T>> = AsyncIterable<PartialMessage<T>>;
-export declare function memoProto<T extends Message<T>>(def: MessageType<T>): (msg: PartialMessage<T>) => Uint8Array;
+export type MessageStream<T extends Message<T>> = AsyncIterable<Message<T>>;
+export declare function memoProto<T extends Message<T>>(def: MessageType<T>): (msg: Message<T>) => Uint8Array;
 export declare function memoProtoDecode<T extends Message<T>>(def: MessageType<T>): (msg: Uint8Array) => T;
 export type DecodeMessageTransform<T> = (source: Source<Uint8Array | Uint8Array[]>) => AsyncIterable<T>;
 export declare function buildDecodeMessageTransform<T extends Message<T>>(def: MessageType<T>, memoize?: boolean): DecodeMessageTransform<T>;
-export type EncodeMessageTransform<T extends Message<T>> = (source: Source<PartialMessage<T> | Array<PartialMessage<T>>>) => AsyncIterable<Uint8Array>;
+export type EncodeMessageTransform<T extends Message<T>> = (source: Source<Message<T> | Array<Message<T>>>) => AsyncIterable<Uint8Array>;
 export declare function buildEncodeMessageTransform<T extends Message<T>>(def: MessageType<T>): EncodeMessageTransform<T>;

package/dist/srpc/message.js

@@ -2,7 +2,7 @@ import memoize from 'memoize-one';
 // memoProto returns a function that encodes the message and caches the result.
 export function memoProto(def) {
     return memoize((msg) => {
-        return new def(msg).toBinary();
+        return def.toBinary(def.create(msg));
     });
 }
 // memoProtoDecode returns a function that decodes the message and caches the result.
@@ -37,11 +37,11 @@ export function buildEncodeMessageTransform(def) {
         for await (const pkt of source) {
             if (Array.isArray(pkt)) {
                 for (const p of pkt) {
-                    yield new def(p).toBinary();
+                    yield def.toBinary(def.create(p));
                 }
             }
             else {
-                yield new def(pkt).toBinary();
+                yield def.toBinary(def.create(pkt));
             }
         }
     };

package/dist/srpc/pushable.d.ts

@@ -1,6 +1,6 @@
+import { Message } from '@aptre/protobuf-es-lite';
 import { Pushable } from 'it-pushable';
 import { Sink, Source } from 'it-stream-types';
-import { Message, PartialMessage } from '@bufbuild/protobuf';
-export declare function messagePushable<T extends Message<T>>(): Pushable<PartialMessage<T>>;
+export declare function messagePushable<T extends Message<T>>(): Pushable<T>;
 export declare function writeToPushable<T>(dataSource: AsyncIterable<T>, out: Pushable<T>): Promise<void>;
 export declare function buildPushableSink<T>(target: Pushable<T>): Sink<Source<T>, Promise<void>>;

package/dist/srpc/pushable.js

@@ -1,5 +1,5 @@
 import { pushable } from 'it-pushable';
-// messagePushable is a shortcut to build a pushable for partial messages.
+// messagePushable is a shortcut to build a pushable for messages.
 export function messagePushable() {
     return pushable({ objectMode: true });
 }

package/dist/srpc/rpcproto_pb.d.ts

@@ -1,132 +1,111 @@
-import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from '@bufbuild/protobuf';
-import { Message, proto3 } from '@bufbuild/protobuf';
-/**
- * Packet is a message sent over a srpc packet connection.
- *
- * @generated from message srpc.Packet
- */
-export declare class Packet extends Message<Packet> {
-    /**
-     * Body is the packet body.
-     *
-     * @generated from oneof srpc.Packet.body
-     */
-    body: {
-        /**
-         * CallStart initiates a new call.
-         *
-         * @generated from field: srpc.CallStart call_start = 1;
-         */
-        value: CallStart;
-        case: 'callStart';
-    } | {
-        /**
-         * CallData is a message in a streaming RPC sequence.
-         *
-         * @generated from field: srpc.CallData call_data = 2;
-         */
-        value: CallData;
-        case: 'callData';
-    } | {
-        /**
-         * CallCancel cancels the call.
-         *
-         * @generated from field: bool call_cancel = 3;
-         */
-        value: boolean;
-        case: 'callCancel';
-    } | {
-        case: undefined;
-        value?: undefined;
-    };
-    constructor(data?: PartialMessage<Packet>);
-    static readonly runtime: typeof proto3;
-    static readonly typeName = "srpc.Packet";
-    static readonly fields: FieldList;
-    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Packet;
-    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Packet;
-    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Packet;
-    static equals(a: Packet | PlainMessage<Packet> | undefined, b: Packet | PlainMessage<Packet> | undefined): boolean;
-}
+import { Message, MessageType } from '@aptre/protobuf-es-lite';
+export declare const protobufPackage = "srpc";
 /**
  * CallStart requests starting a new RPC call.
  *
  * @generated from message srpc.CallStart
  */
-export declare class CallStart extends Message<CallStart> {
+export interface CallStart extends Message<CallStart> {
     /**
      * RpcService is the service to contact.
      * Must be set.
      *
      * @generated from field: string rpc_service = 1;
      */
-    rpcService: string;
+    rpcService?: string;
     /**
      * RpcMethod is the RPC method to call.
      * Must be set.
      *
      * @generated from field: string rpc_method = 2;
      */
-    rpcMethod: string;
+    rpcMethod?: string;
     /**
      * Data contains the request or the first message in the stream.
      * Optional if streaming.
      *
      * @generated from field: bytes data = 3;
      */
-    data: Uint8Array;
+    data?: Uint8Array;
     /**
      * DataIsZero indicates Data is set with an empty message.
      *
      * @generated from field: bool data_is_zero = 4;
      */
-    dataIsZero: boolean;
-    constructor(data?: PartialMessage<CallStart>);
-    static readonly runtime: typeof proto3;
-    static readonly typeName = "srpc.CallStart";
-    static readonly fields: FieldList;
-    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): CallStart;
-    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): CallStart;
-    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): CallStart;
-    static equals(a: CallStart | PlainMessage<CallStart> | undefined, b: CallStart | PlainMessage<CallStart> | undefined): boolean;
+    dataIsZero?: boolean;
 }
+export declare const CallStart: MessageType<CallStart>;
 /**
  * CallData contains a message in a streaming RPC sequence.
  *
  * @generated from message srpc.CallData
  */
-export declare class CallData extends Message<CallData> {
+export interface CallData extends Message<CallData> {
     /**
      * Data contains the packet in the sequence.
      *
      * @generated from field: bytes data = 1;
      */
-    data: Uint8Array;
+    data?: Uint8Array;
     /**
      * DataIsZero indicates Data is set with an empty message.
      *
      * @generated from field: bool data_is_zero = 2;
      */
-    dataIsZero: boolean;
+    dataIsZero?: boolean;
     /**
      * Complete indicates the RPC call is completed.
      *
      * @generated from field: bool complete = 3;
      */
-    complete: boolean;
+    complete?: boolean;
     /**
      * Error contains any error that caused the RPC to fail.
      * If set, implies complete=true.
      *
      * @generated from field: string error = 4;
      */
-    error: string;
-    constructor(data?: PartialMessage<CallData>);
-    static readonly runtime: typeof proto3;
-    static readonly typeName = "srpc.CallData";
-    static readonly fields: FieldList;
-    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): CallData;
-    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): CallData;
-    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): CallData;
-    static equals(a: CallData | PlainMessage<CallData> | undefined, b: CallData | PlainMessage<CallData> | undefined): boolean;
+    error?: string;
+}
+export declare const CallData: MessageType<CallData>;
+/**
+ * Packet is a message sent over a srpc packet connection.
+ *
+ * @generated from message srpc.Packet
+ */
+export interface Packet extends Message<Packet> {
+    /**
+     * Body is the packet body.
+     *
+     * @generated from oneof srpc.Packet.body
+     */
+    body?: {
+        value?: undefined;
+        case: undefined;
+    } | {
+        /**
+         * CallStart initiates a new call.
+         *
+         * @generated from field: srpc.CallStart call_start = 1;
+         */
+        value: CallStart;
+        case: 'callStart';
+    } | {
+        /**
+         * CallData is a message in a streaming RPC sequence.
+         *
+         * @generated from field: srpc.CallData call_data = 2;
+         */
+        value: CallData;
+        case: 'callData';
+    } | {
+        /**
+         * CallCancel cancels the call.
+         *
+         * @generated from field: bool call_cancel = 3;
+         */
+        value: boolean;
+        case: 'callCancel';
+    };
 }
+export declare const Packet: MessageType<Packet>;