goscript 0.1.4 → 0.2.1

package/dist/gs/github.com/aperturerobotics/starpc/srpc/index.js

@@ -1,926 +0,0 @@
-import * as $ from '@goscript/builtin/index.js';
-import * as context from '@goscript/context/index.js';
-import * as io from '@goscript/io/index.js';
-export const ErrReset = $.newError('stream reset');
-export const ErrUnimplemented = $.newError('unimplemented');
-export const ErrCompleted = $.newError('unexpected packet after rpc was completed');
-export const ErrUnrecognizedPacket = $.newError('unrecognized packet type');
-export const ErrEmptyPacket = $.newError('invalid empty packet');
-export const ErrInvalidMessage = $.newError('invalid message');
-export const ErrEmptyMethodID = $.newError('method id empty');
-export const ErrEmptyServiceID = $.newError('service id empty');
-export const ErrNoAvailableClients = $.newError('no available rpc clients');
-export const ErrNilWriter = $.newError('writer cannot be nil');
-export class RawMessage {
-    data;
-    copyData;
-    constructor(init) {
-        this.data = init?.data ?? null;
-        this.copyData = init?.copy ?? false;
-    }
-    GetData() {
-        return this.data;
-    }
-    SetData(data) {
-        if (!this.copyData) {
-            this.data = data;
-            return;
-        }
-        const next = new Uint8Array($.len(data));
-        $.copy(next, data);
-        this.data = next;
-    }
-    Clear() {
-        this.data = $.goSlice(this.data, 0, 0);
-    }
-    Reset() {
-        this.data = null;
-    }
-    MarshalVT() {
-        if (!this.copyData) {
-            return [this.data, null];
-        }
-        const next = new Uint8Array($.len(this.data));
-        $.copy(next, this.data);
-        return [next, null];
-    }
-    UnmarshalVT(data) {
-        this.SetData(data);
-        return null;
-    }
-    SizeVT() {
-        return $.len(this.data);
-    }
-    MarshalToSizedBufferVT(dAtA) {
-        if ($.len(dAtA) !== $.len(this.data)) {
-            return [0, $.newError('invalid buffer length')];
-        }
-        $.copy(dAtA, this.data);
-        return [$.len(dAtA), null];
-    }
-    clone() {
-        const cloned = new RawMessage({ copy: this.copyData });
-        cloned.SetData(this.data);
-        return $.markAsStructValue(cloned);
-    }
-}
-export function NewRawMessage(data, copy) {
-    return new RawMessage({ data, copy });
-}
-$.registerInterfaceType('srpc.Client', null, [
-    {
-        name: 'ExecCall',
-        args: [
-            { name: 'ctx', type: 'context.Context' },
-            { name: 'service', type: { kind: $.TypeKind.Basic, name: 'string' } },
-            { name: 'method', type: { kind: $.TypeKind.Basic, name: 'string' } },
-            { name: 'in', type: 'srpc.Message' },
-            { name: 'out', type: 'srpc.Message' },
-        ],
-        returns: [{ name: '_r0', type: 'error' }],
-    },
-    {
-        name: 'NewStream',
-        args: [
-            { name: 'ctx', type: 'context.Context' },
-            { name: 'service', type: { kind: $.TypeKind.Basic, name: 'string' } },
-            { name: 'method', type: { kind: $.TypeKind.Basic, name: 'string' } },
-            { name: 'firstMsg', type: 'srpc.Message' },
-        ],
-        returns: [
-            { name: '_r0', type: 'srpc.Stream' },
-            { name: '_r1', type: 'error' },
-        ],
-    },
-]);
-export class ClientSet {
-    clients;
-    constructor(init) {
-        this.clients = init?.clients ?? null;
-    }
-    async ExecCall(ctx, service, method, input, output) {
-        return this.execCall(ctx, (client) => client.ExecCall(ctx, service, method, input, output));
-    }
-    async NewStream(ctx, service, method, firstMsg) {
-        let stream = null;
-        const err = await this.execCall(ctx, async (client) => {
-            const [next, callErr] = await client.NewStream(ctx, service, method, firstMsg);
-            stream = next;
-            return callErr;
-        });
-        return [stream, err];
-    }
-    async execCall(ctx, call) {
-        let anyClient = false;
-        for (let i = 0; i < $.len(this.clients); i++) {
-            const client = this.clients[i];
-            if (client == null) {
-                continue;
-            }
-            anyClient = true;
-            const err = await call(client);
-            if (err == null) {
-                return null;
-            }
-            if (err === context.Canceled && contextErr(ctx) === context.Canceled) {
-                return context.Canceled;
-            }
-            if (err.Error() === ErrUnimplemented.Error()) {
-                continue;
-            }
-            return err;
-        }
-        return anyClient ? ErrUnimplemented : ErrNoAvailableClients;
-    }
-}
-export function NewClientSet(clients) {
-    return new ClientSet({ clients });
-}
-export class PrefixClient {
-    client;
-    serviceIDPrefixes;
-    constructor(clientOrInit, serviceIDPrefixes) {
-        if (clientOrInit != null &&
-            typeof clientOrInit === 'object' &&
-            'client' in clientOrInit) {
-            this.client = clientOrInit.client ?? null;
-            this.serviceIDPrefixes = clientOrInit.serviceIDPrefixes ?? null;
-            return;
-        }
-        this.client = clientOrInit;
-        this.serviceIDPrefixes = serviceIDPrefixes ?? null;
-    }
-    async ExecCall(ctx, service, method, input, output) {
-        const [stripped, err] = this.stripCheckServiceIDPrefix(service);
-        if (err != null) {
-            return err;
-        }
-        if (this.client == null) {
-            return ErrNoAvailableClients;
-        }
-        return this.client.ExecCall(ctx, stripped, method, input, output);
-    }
-    async NewStream(ctx, service, method, firstMsg) {
-        const [stripped, err] = this.stripCheckServiceIDPrefix(service);
-        if (err != null) {
-            return [null, err];
-        }
-        if (this.client == null) {
-            return [null, ErrNoAvailableClients];
-        }
-        return this.client.NewStream(ctx, stripped, method, firstMsg);
-    }
-    stripCheckServiceIDPrefix(service) {
-        if ($.len(this.serviceIDPrefixes) === 0) {
-            return [service, null];
-        }
-        const [stripped, matched] = CheckStripPrefix(service, this.serviceIDPrefixes);
-        if (matched === '') {
-            return [service, ErrUnimplemented];
-        }
-        return [stripped, null];
-    }
-}
-export function NewPrefixClient(client, serviceIDPrefixes) {
-    return new PrefixClient(client, serviceIDPrefixes);
-}
-class emptyStream {
-    ctx;
-    closed = false;
-    constructor(ctx = context.Background()) {
-        this.ctx = ctx;
-    }
-    Context() {
-        return this.ctx;
-    }
-    MsgSend(_msg) {
-        return this.closed ? ErrCompleted : null;
-    }
-    MsgRecv(_msg) {
-        return this.closed ? io.EOF : io.EOF;
-    }
-    CloseSend() {
-        this.closed = true;
-        return null;
-    }
-    Close() {
-        this.closed = true;
-        return null;
-    }
-}
-class memoryStream {
-    ctx;
-    recv;
-    sent = null;
-    sentQueue = [];
-    waiters = [];
-    closed = false;
-    recvConsumed = false;
-    constructor(ctx, recv) {
-        this.ctx = ctx;
-        this.recv = recv;
-    }
-    Context() {
-        return this.ctx;
-    }
-    MsgSend(msg) {
-        this.sent = msg;
-        const waiter = this.waiters.shift();
-        if (waiter != null) {
-            waiter(msg);
-            return null;
-        }
-        this.sentQueue.push(msg);
-        return null;
-    }
-    MsgRecv(msg) {
-        if (!this.recvConsumed) {
-            this.recvConsumed = true;
-            if (msg != null && this.recv != null) {
-                Object.assign(msg, this.recv);
-            }
-            return null;
-        }
-        const next = this.sentQueue.shift();
-        if (next !== undefined) {
-            if (msg != null && next != null) {
-                Object.assign(msg, next);
-            }
-            return null;
-        }
-        if (this.closed) {
-            return io.EOF;
-        }
-        return new Promise((resolve) => {
-            this.waiters.push((sent) => {
-                if (msg != null && sent != null) {
-                    Object.assign(msg, sent);
-                }
-                resolve(null);
-            });
-        });
-    }
-    CloseSend() {
-        return null;
-    }
-    Close() {
-        this.closed = true;
-        for (const waiter of this.waiters.splice(0)) {
-            waiter(null);
-        }
-        return null;
-    }
-    CopySentTo(output) {
-        if (output != null && this.sent != null) {
-            Object.assign(output, this.sent);
-            return;
-        }
-        const next = this.sentQueue.shift();
-        if (output != null && next != null) {
-            Object.assign(output, next);
-        }
-    }
-}
-class streamQueue {
-    queue = [];
-    waiters = [];
-    closed = false;
-    send(msg) {
-        if (this.closed) {
-            return ErrCompleted;
-        }
-        const waiter = this.waiters.shift();
-        if (waiter != null) {
-            waiter(msg, null);
-            return null;
-        }
-        this.queue.push(msg);
-        return null;
-    }
-    recv(msg) {
-        const next = this.queue.shift();
-        if (next !== undefined) {
-            if (msg != null && next != null) {
-                Object.assign(msg, next);
-            }
-            return null;
-        }
-        if (this.closed) {
-            return io.EOF;
-        }
-        return new Promise((resolve) => {
-            this.waiters.push((sent, err) => {
-                if (msg != null && sent != null) {
-                    Object.assign(msg, sent);
-                }
-                resolve(err);
-            });
-        });
-    }
-    close() {
-        this.closed = true;
-        for (const waiter of this.waiters.splice(0)) {
-            waiter(null, io.EOF);
-        }
-        return null;
-    }
-}
-class pairedMemoryStream {
-    ctx;
-    incoming;
-    outgoing;
-    constructor(ctx, incoming, outgoing) {
-        this.ctx = ctx;
-        this.incoming = incoming;
-        this.outgoing = outgoing;
-    }
-    Context() {
-        return this.ctx;
-    }
-    MsgSend(msg) {
-        return this.outgoing.send(msg);
-    }
-    MsgRecv(msg) {
-        return this.incoming.recv(msg);
-    }
-    CloseSend() {
-        return this.outgoing.close();
-    }
-    Close() {
-        const incomingErr = this.incoming.close();
-        const outgoingErr = this.outgoing.close();
-        return incomingErr ?? outgoingErr;
-    }
-}
-class streamWithClose {
-    stream;
-    closeFn;
-    constructor(stream, closeFn) {
-        this.stream = stream;
-        this.closeFn = closeFn;
-    }
-    Context() {
-        return this.stream.Context();
-    }
-    MsgSend(msg) {
-        return this.stream.MsgSend(msg);
-    }
-    MsgRecv(msg) {
-        return this.stream.MsgRecv(msg);
-    }
-    CloseSend() {
-        return this.stream.CloseSend();
-    }
-    async Close() {
-        const err = await this.stream.Close();
-        const closeErr = await this.closeFn();
-        return err ?? closeErr;
-    }
-}
-export function NewStreamWithClose(stream, close) {
-    return new streamWithClose(stream ?? new emptyStream(), close);
-}
-export async function InvokeMethod(fn, serviceID, methodID, stream) {
-    if (fn == null) {
-        return [false, null];
-    }
-    return fn(serviceID, methodID, stream);
-}
-export async function InvokerFunc_InvokeMethod(fn, serviceID, methodID, stream) {
-    return InvokeMethod(fn, serviceID, methodID, stream);
-}
-export async function InvokerSlice_InvokeMethod(s, serviceID, methodID, stream) {
-    for (let i = 0; i < $.len(s); i++) {
-        const invoker = s[i];
-        if (invoker == null) {
-            continue;
-        }
-        const [handled, err] = await invoker.InvokeMethod(serviceID, methodID, stream);
-        if (handled || err != null) {
-            return [true, err];
-        }
-    }
-    return [false, null];
-}
-class defaultMux {
-    fallback;
-    services = new Map();
-    constructor(fallback) {
-        this.fallback = fallback;
-    }
-    Register(handler) {
-        if (handler == null) {
-            return ErrUnimplemented;
-        }
-        const serviceID = handler.GetServiceID();
-        if (serviceID === '') {
-            return ErrEmptyServiceID;
-        }
-        let methods = this.services.get(serviceID);
-        if (methods === undefined) {
-            methods = new Map();
-            this.services.set(serviceID, methods);
-        }
-        const methodIDs = handler.GetMethodIDs();
-        for (let i = 0; i < $.len(methodIDs); i++) {
-            const methodID = methodIDs[i];
-            if (methodID !== '') {
-                methods.set(methodID, handler);
-            }
-        }
-        return null;
-    }
-    HasService(serviceID) {
-        return serviceID !== '' && (this.services.get(serviceID)?.size ?? 0) !== 0;
-    }
-    HasServiceMethod(serviceID, methodID) {
-        if (serviceID === '' || methodID === '') {
-            return false;
-        }
-        return this.services.get(serviceID)?.has(methodID) ?? false;
-    }
-    async InvokeMethod(serviceID, methodID, stream) {
-        let handler;
-        if (serviceID === '') {
-            for (const methods of this.services.values()) {
-                handler = methods.get(methodID);
-                if (handler !== undefined) {
-                    break;
-                }
-            }
-        }
-        else {
-            handler = this.services.get(serviceID)?.get(methodID);
-        }
-        if (handler !== undefined) {
-            return handler.InvokeMethod(serviceID, methodID, stream);
-        }
-        for (let i = 0; i < $.len(this.fallback); i++) {
-            const invoker = this.fallback[i];
-            if (invoker == null) {
-                continue;
-            }
-            const [handled, err] = await invoker.InvokeMethod(serviceID, methodID, stream);
-            if (handled || err != null) {
-                return [handled, err];
-            }
-        }
-        return [false, null];
-    }
-}
-export function NewMux(...fallbackInvokers) {
-    return new defaultMux(fallbackInvokers);
-}
-export class PrefixInvoker {
-    inv;
-    serviceIDPrefixes;
-    constructor(invOrInit, serviceIDPrefixes) {
-        if (invOrInit != null &&
-            typeof invOrInit === 'object' &&
-            'inv' in invOrInit) {
-            this.inv = invOrInit.inv ?? null;
-            this.serviceIDPrefixes = invOrInit.serviceIDPrefixes ?? null;
-            return;
-        }
-        this.inv = invOrInit;
-        this.serviceIDPrefixes = serviceIDPrefixes ?? null;
-    }
-    async InvokeMethod(serviceID, methodID, stream) {
-        if ($.len(this.serviceIDPrefixes) !== 0) {
-            const [strippedID, matchedPrefix] = CheckStripPrefix(serviceID, this.serviceIDPrefixes);
-            if (matchedPrefix === '') {
-                return [false, null];
-            }
-            serviceID = strippedID;
-        }
-        if (this.inv == null) {
-            return [false, null];
-        }
-        return this.inv.InvokeMethod(serviceID, methodID, stream);
-    }
-}
-export function NewPrefixInvoker(inv, serviceIDPrefixes) {
-    return new PrefixInvoker(inv, serviceIDPrefixes);
-}
-export function CheckStripPrefix(serviceID, serviceIDPrefixes) {
-    for (let i = 0; i < $.len(serviceIDPrefixes); i++) {
-        const prefix = serviceIDPrefixes[i];
-        if (prefix !== '' && serviceID.startsWith(prefix)) {
-            return [serviceID.slice(prefix.length), prefix];
-        }
-    }
-    return [serviceID, ''];
-}
-export class Server {
-    invoker;
-    constructor(init) {
-        this.invoker = init?.invoker ?? null;
-    }
-    GetInvoker() {
-        return this.invoker;
-    }
-    HandleStream(_ctx, _rwc) { }
-    AcceptMuxedConn(_ctx, _conn) {
-        return null;
-    }
-}
-export function NewServer(invoker) {
-    return new Server({ invoker });
-}
-class transportClient {
-    openStream;
-    constructor(openStream) {
-        this.openStream = openStream;
-    }
-    async ExecCall(ctx, service, method, input, output) {
-        if (this.openStream == null) {
-            return ErrNoAvailableClients;
-        }
-        const writerResult = await this.openStream(ctx, () => null, () => undefined);
-        if (writerResult == null) {
-            return ErrNoAvailableClients;
-        }
-        const writer = writerResult[0];
-        const err = writerResult[1];
-        if (err != null) {
-            return err;
-        }
-        if (input != null) {
-            const [data, marshalErr] = input.MarshalVT();
-            if (marshalErr != null) {
-                return marshalErr;
-            }
-            const writeErr = await writer?.WritePacket(NewCallStartPacket(service, method, data, $.len(data) === 0));
-            if (writeErr != null) {
-                return writeErr;
-            }
-        }
-        if (output != null) {
-            output.Reset();
-        }
-        return (await writer?.Close()) ?? null;
-    }
-    async NewStream(ctx, service, method, firstMsg) {
-        if (this.openStream == null) {
-            return [null, ErrNoAvailableClients];
-        }
-        const writerResult = await this.openStream(ctx, () => null, () => undefined);
-        if (writerResult == null) {
-            return [null, ErrNoAvailableClients];
-        }
-        const writer = writerResult[0];
-        const err = writerResult[1];
-        if (err != null) {
-            return [null, err];
-        }
-        if (firstMsg != null) {
-            const [data, marshalErr] = firstMsg.MarshalVT();
-            if (marshalErr != null) {
-                return [null, marshalErr];
-            }
-            const writeErr = await writer?.WritePacket(NewCallStartPacket(service, method, data, $.len(data) === 0));
-            if (writeErr != null) {
-                return [null, writeErr];
-            }
-        }
-        return [
-            NewStreamWithClose(new emptyStream(ctx), () => writer?.Close() ?? null),
-            null,
-        ];
-    }
-}
-export function NewClient(openStream) {
-    if (openStream?.__server != null) {
-        return NewClientWithInvoker(openStream.__server.GetInvoker());
-    }
-    return new transportClient(openStream);
-}
-class invokerClient {
-    invoker;
-    contextFn;
-    constructor(invoker, contextFn = null) {
-        this.invoker = invoker;
-        this.contextFn = contextFn;
-    }
-    async ExecCall(ctx, service, method, input, output) {
-        if (this.invoker == null) {
-            return ErrNoAvailableClients;
-        }
-        const stream = new memoryStream(this.contextFn == null ? ctx : this.contextFn(ctx), input);
-        const [handled, err] = await this.invoker.InvokeMethod(service, method, stream);
-        if (err != null) {
-            return err;
-        }
-        if (!handled) {
-            return ErrUnimplemented;
-        }
-        stream.CopySentTo(output);
-        return null;
-    }
-    async NewStream(ctx, service, method, firstMsg) {
-        if (this.invoker == null) {
-            return [null, ErrNoAvailableClients];
-        }
-        const streamCtx = this.contextFn == null ? ctx : this.contextFn(ctx);
-        const clientInput = new streamQueue();
-        const serverInput = new streamQueue();
-        const clientStream = new pairedMemoryStream(streamCtx, clientInput, serverInput);
-        const serverStream = new pairedMemoryStream(streamCtx, serverInput, clientInput);
-        if (firstMsg != null) {
-            const err = serverInput.send(firstMsg);
-            if (err != null) {
-                return [null, err];
-            }
-        }
-        const pending = Promise.resolve(this.invoker.InvokeMethod(service, method, serverStream));
-        pending.then(([handled, err]) => {
-            if (!handled || err != null) {
-                clientStream.Close();
-                return;
-            }
-            serverStream.CloseSend();
-        });
-        return [clientStream, null];
-    }
-}
-export function NewClientWithInvoker(invoker, contextFn = null) {
-    return new invokerClient(invoker, contextFn);
-}
-class streamWithContext {
-    stream;
-    ctx;
-    constructor(stream, ctx) {
-        this.stream = stream;
-        this.ctx = ctx;
-    }
-    Context() {
-        return this.ctx;
-    }
-    MsgSend(msg) {
-        return this.stream.MsgSend(msg);
-    }
-    MsgRecv(msg) {
-        return this.stream.MsgRecv(msg);
-    }
-    CloseSend() {
-        return this.stream.CloseSend();
-    }
-    Close() {
-        return this.stream.Close();
-    }
-}
-export function NewStreamWithContext(stream, ctx) {
-    return new streamWithContext(stream ?? new emptyStream(ctx), ctx);
-}
-export class ServerRPC {
-    ctx;
-    invoker;
-    writer;
-    constructor(ctx, invoker, writer) {
-        this.ctx = ctx;
-        this.invoker = invoker;
-        this.writer = writer;
-    }
-    async HandlePacketData(data) {
-        const pkt = new Packet();
-        const err = pkt.UnmarshalVT(data);
-        if (err != null) {
-            return err;
-        }
-        return this.HandlePacket(pkt);
-    }
-    async HandlePacket(pkt) {
-        if (pkt == null) {
-            return null;
-        }
-        const body = pkt.GetBody();
-        if (body instanceof Packet_CallStart) {
-            return this.HandleCallStart(body.CallStart);
-        }
-        return null;
-    }
-    async HandleCallStart(pkt) {
-        if (pkt == null || this.invoker == null) {
-            return ErrUnimplemented;
-        }
-        const stream = new emptyStream(this.ctx);
-        const [handled, err] = await this.invoker.InvokeMethod(pkt.GetRpcService(), pkt.GetRpcMethod(), stream);
-        const callErr = err ?? (handled ? null : ErrUnimplemented);
-        await this.writer?.WritePacket(NewCallDataPacket(null, false, true, callErr));
-        return callErr;
-    }
-    HandleStreamClose(_closeErr) { }
-    Wait(_ctx) {
-        return null;
-    }
-}
-export function NewServerRPC(ctx, invoker, writer) {
-    return new ServerRPC(ctx, invoker, writer);
-}
-export class PacketReadWriter {
-    rw;
-    constructor(rw) {
-        this.rw = rw;
-    }
-    Write(data) {
-        if (this.rw == null) {
-            return [0, ErrNilWriter];
-        }
-        return this.rw.Write(data);
-    }
-    WritePacket(_packet) {
-        return this.rw == null ? ErrNilWriter : null;
-    }
-    ReadPump(_cb, closed) {
-        if (closed != null) {
-            closed(null);
-        }
-    }
-    ReadToHandler(_cb) {
-        return null;
-    }
-    Close() {
-        return this.rw?.Close() ?? null;
-    }
-}
-export function NewPacketReadWriter(rw) {
-    return new PacketReadWriter(rw);
-}
-export function NewServerPipe(server) {
-    const openStream = ((_ctx, _msgHandler, _closeHandler) => [
-        new closedPacketWriter(),
-        null,
-    ]);
-    if (server != null) {
-        openStream.__server = server;
-    }
-    return openStream;
-}
-export class MuxedConn {
-    rwc;
-    outbound;
-    constructor(rwc = null, outbound = false) {
-        this.rwc = rwc;
-        this.outbound = outbound;
-    }
-    Close() {
-        return this.rwc?.Close() ?? null;
-    }
-}
-class closedPacketWriter {
-    WritePacket(_packet) {
-        return ErrUnimplemented;
-    }
-    Close() {
-        return null;
-    }
-}
-export function NewOpenStreamWithMuxedConn(_conn) {
-    return () => [new closedPacketWriter(), null];
-}
-export function NewMuxedConn(rwc, outbound, _yamuxConf) {
-    return [new MuxedConn(rwc, outbound), null];
-}
-export function NewWebSocketConn(_ctx, conn, isServer, yamuxConf) {
-    return NewMuxedConn(conn, !isServer, yamuxConf);
-}
-export function NewClientWithMuxedConn(_conn) {
-    return NewClientWithInvoker(null);
-}
-export function NewMuxedConnWithRwc(_ctx, _rwc, _outbound, _yamuxConf) {
-    return [new MuxedConn(_rwc, _outbound), null];
-}
-class clientInvoker {
-    client;
-    constructor(client) {
-        this.client = client;
-    }
-    async InvokeMethod(serviceID, methodID, stream) {
-        if (this.client == null || stream == null) {
-            return [false, null];
-        }
-        const [remote, err] = await this.client.NewStream(stream.Context(), serviceID, methodID, null);
-        await remote?.Close();
-        return [true, err];
-    }
-}
-export function NewClientInvoker(client) {
-    return new clientInvoker(client);
-}
-export class Packet {
-    Body = null;
-    GetBody() {
-        return this.Body;
-    }
-    MarshalVT() {
-        return [new Uint8Array(), null];
-    }
-    UnmarshalVT(_data) {
-        return null;
-    }
-    SizeVT() {
-        return 0;
-    }
-    MarshalToSizedBufferVT(_data) {
-        return [0, null];
-    }
-    Reset() {
-        this.Body = null;
-    }
-}
-export class CallStart {
-    RpcService = '';
-    RpcMethod = '';
-    Data = null;
-    DataIsZero = false;
-    GetRpcService() {
-        return this.RpcService;
-    }
-    GetRpcMethod() {
-        return this.RpcMethod;
-    }
-    GetData() {
-        return this.Data;
-    }
-    GetDataIsZero() {
-        return this.DataIsZero;
-    }
-}
-export class CallData {
-    Data = null;
-    DataIsZero = false;
-    Complete = false;
-    Error = '';
-    GetData() {
-        return this.Data;
-    }
-    GetDataIsZero() {
-        return this.DataIsZero;
-    }
-    GetComplete() {
-        return this.Complete;
-    }
-    GetError() {
-        return this.Error;
-    }
-}
-export class Packet_CallStart {
-    CallStart;
-    constructor(CallStart = null) {
-        this.CallStart = CallStart;
-    }
-}
-export class Packet_CallData {
-    CallData;
-    constructor(CallData = null) {
-        this.CallData = CallData;
-    }
-}
-export class Packet_CallCancel {
-    CallCancel;
-    constructor(CallCancel = true) {
-        this.CallCancel = CallCancel;
-    }
-}
-export function NewPacketDataHandler(handler) {
-    return (data) => {
-        const pkt = new Packet();
-        const err = pkt.UnmarshalVT(data);
-        if (err != null) {
-            return err;
-        }
-        return handler?.(pkt) ?? null;
-    };
-}
-export function NewCallStartPacket(service, method, data, dataIsZero) {
-    const pkt = new Packet();
-    pkt.Body = new Packet_CallStart(Object.assign(new CallStart(), {
-        RpcService: service,
-        RpcMethod: method,
-        Data: data,
-        DataIsZero: dataIsZero,
-    }));
-    return pkt;
-}
-export function NewCallDataPacket(data, dataIsZero, complete, err) {
-    const pkt = new Packet();
-    pkt.Body = new Packet_CallData(Object.assign(new CallData(), {
-        Data: data,
-        DataIsZero: dataIsZero,
-        Complete: complete || err != null,
-        Error: err?.Error() ?? '',
-    }));
-    return pkt;
-}
-export function NewCallCancelPacket() {
-    const pkt = new Packet();
-    pkt.Body = new Packet_CallCancel(true);
-    return pkt;
-}
-function contextErr(ctx) {
-    if (ctx == null) {
-        return null;
-    }
-    return ctx.Err();
-}
-//# sourceMappingURL=index.js.map