@replit/river 0.9.3 → 0.10.1

package/dist/__tests__/typescript-stress.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"typescript-stress.test.d.ts","sourceRoot":"","sources":["../../__tests__/typescript-stress.test.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,SAAS,EAAE,sBAAsB,EAAS,MAAM,sBAAsB,CAAC;AAEhF,OAAO,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AAsC/D,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmDlB,CAAC;AAGhB,qBAAa,aAAc,SAAQ,SAAS,CAAC,UAAU,CAAC;gBAC1C,QAAQ,EAAE,MAAM;IAI5B,IAAI,CAAC,GAAG,EAAE,sBAAsB,GAAG,SAAS;IAK5C,8BAA8B;IACxB,mBAAmB;IACnB,KAAK;CACZ"}

package/dist/__tests__/typescript-stress.test.js

@@ -1,123 +0,0 @@
-import { describe, expect, test } from 'vitest';
-import { ServiceBuilder, serializeService } from '../router/builder';
-import { Type } from '@sinclair/typebox';
-import { reply } from '../transport/message';
-import { createServer } from '../router/server';
-import { Transport } from '../transport/transport';
-import { NaiveJsonCodec } from '../codec/json';
-import { createClient } from '../router/client';
-import { Ok } from '../router/result';
-const input = Type.Union([
-    Type.Object({ a: Type.Number() }),
-    Type.Object({ c: Type.String() }),
-]);
-const output = Type.Object({ b: Type.Union([Type.Number(), Type.String()]) });
-const errors = Type.Union([
-    Type.Object({
-        code: Type.Literal('ERROR1'),
-        message: Type.String(),
-    }),
-    Type.Object({
-        code: Type.Literal('ERROR2'),
-        message: Type.String(),
-    }),
-]);
-const fnBody = {
-    type: 'rpc',
-    input,
-    output,
-    errors,
-    async handler(_state, msg) {
-        if ('c' in msg.payload) {
-            return reply(msg, Ok({ b: msg.payload.c }));
-        }
-        else {
-            return reply(msg, Ok({ b: msg.payload.a }));
-        }
-    },
-};
-// typescript is limited to max 50 constraints
-// see: https://github.com/microsoft/TypeScript/issues/33541
-export const StupidlyLargeService = () => ServiceBuilder.create('test')
-    .defineProcedure('f1', fnBody)
-    .defineProcedure('f2', fnBody)
-    .defineProcedure('f3', fnBody)
-    .defineProcedure('f4', fnBody)
-    .defineProcedure('f5', fnBody)
-    .defineProcedure('f6', fnBody)
-    .defineProcedure('f7', fnBody)
-    .defineProcedure('f8', fnBody)
-    .defineProcedure('f9', fnBody)
-    .defineProcedure('f10', fnBody)
-    .defineProcedure('f11', fnBody)
-    .defineProcedure('f12', fnBody)
-    .defineProcedure('f13', fnBody)
-    .defineProcedure('f14', fnBody)
-    .defineProcedure('f15', fnBody)
-    .defineProcedure('f16', fnBody)
-    .defineProcedure('f17', fnBody)
-    .defineProcedure('f18', fnBody)
-    .defineProcedure('f19', fnBody)
-    .defineProcedure('f20', fnBody)
-    .defineProcedure('f21', fnBody)
-    .defineProcedure('f22', fnBody)
-    .defineProcedure('f23', fnBody)
-    .defineProcedure('f24', fnBody)
-    .defineProcedure('f25', fnBody)
-    .defineProcedure('f26', fnBody)
-    .defineProcedure('f27', fnBody)
-    .defineProcedure('f28', fnBody)
-    .defineProcedure('f29', fnBody)
-    .defineProcedure('f30', fnBody)
-    .defineProcedure('f31', fnBody)
-    .defineProcedure('f32', fnBody)
-    .defineProcedure('f33', fnBody)
-    .defineProcedure('f34', fnBody)
-    .defineProcedure('f35', fnBody)
-    .defineProcedure('f36', fnBody)
-    .defineProcedure('f37', fnBody)
-    .defineProcedure('f38', fnBody)
-    .defineProcedure('f39', fnBody)
-    .defineProcedure('f40', fnBody)
-    .defineProcedure('f41', fnBody)
-    .defineProcedure('f42', fnBody)
-    .defineProcedure('f43', fnBody)
-    .defineProcedure('f44', fnBody)
-    .defineProcedure('f45', fnBody)
-    .defineProcedure('f46', fnBody)
-    .defineProcedure('f47', fnBody)
-    .defineProcedure('f48', fnBody)
-    .defineProcedure('f49', fnBody)
-    .finalize();
-// mock transport
-export class MockTransport extends Transport {
-    constructor(clientId) {
-        super(NaiveJsonCodec, clientId);
-    }
-    send(msg) {
-        const id = msg.id;
-        return id;
-    }
-    setupConnectionStatusListeners() { }
-    async createNewConnection() { }
-    async close() { }
-}
-describe("ensure typescript doesn't give up trying to infer the types for large services", () => {
-    test('service with many procedures hits typescript limit', () => {
-        expect(serializeService(StupidlyLargeService())).toBeTruthy();
-    });
-    test('serverclient should support many services with many procedures', async () => {
-        const listing = {
-            a: StupidlyLargeService(),
-            b: StupidlyLargeService(),
-            c: StupidlyLargeService(),
-            d: StupidlyLargeService(),
-        };
-        const server = await createServer(new MockTransport('SERVER'), listing);
-        const client = createClient(new MockTransport('client'));
-        expect(client.d.f48.rpc({ a: 0 })).toBeTruthy();
-        expect(client.a.f2.rpc({ c: 'abc' })).toBeTruthy();
-        expect(server).toBeTruthy();
-        expect(client).toBeTruthy();
-    });
-});

package/dist/codec/binary.d.ts

@@ -1,7 +0,0 @@
-import { Codec } from './types';
-/**
- * Binary codec, uses [msgpack](https://www.npmjs.com/package/@msgpack/msgpack) under the hood
- * @type {Codec}
- */
-export declare const BinaryCodec: Codec;
-//# sourceMappingURL=binary.d.ts.map

package/dist/codec/binary.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"binary.d.ts","sourceRoot":"","sources":["../../codec/binary.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAEhC;;;GAGG;AACH,eAAO,MAAM,WAAW,EAAE,KAczB,CAAC"}

package/dist/codec/binary.js

@@ -1,20 +0,0 @@
-import { decode, encode } from '@msgpack/msgpack';
-/**
- * Binary codec, uses [msgpack](https://www.npmjs.com/package/@msgpack/msgpack) under the hood
- * @type {Codec}
- */
-export const BinaryCodec = {
-    toBuffer: encode,
-    fromBuffer: (buff) => {
-        try {
-            const res = decode(buff);
-            if (typeof res !== 'object') {
-                return null;
-            }
-            return res;
-        }
-        catch {
-            return null;
-        }
-    },
-};

package/dist/codec/codec.test.d.ts

@@ -1,5 +0,0 @@
-export declare const codecs: {
-    name: string;
-    codec: import("./types").Codec;
-}[];
-//# sourceMappingURL=codec.test.d.ts.map

package/dist/codec/codec.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"codec.test.d.ts","sourceRoot":"","sources":["../../codec/codec.test.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,MAAM;;;GAGlB,CAAC"}

package/dist/codec/codec.test.js

@@ -1,41 +0,0 @@
-import { BinaryCodec } from './binary';
-import { NaiveJsonCodec } from './json';
-import { describe, test, expect } from 'vitest';
-export const codecs = [
-    { name: 'naive', codec: NaiveJsonCodec },
-    { name: 'binary', codec: BinaryCodec },
-];
-describe.each(codecs)('codec -- $name', ({ codec }) => {
-    test('empty object', () => {
-        const msg = {};
-        expect(codec.fromBuffer(codec.toBuffer(msg))).toStrictEqual(msg);
-    });
-    test('simple test', () => {
-        const msg = { abc: 123, def: 'cool' };
-        expect(codec.fromBuffer(codec.toBuffer(msg))).toStrictEqual(msg);
-    });
-    test('deeply nested test', () => {
-        const msg = {
-            array: [{ object: true }],
-            deeply: {
-                nested: {
-                    nice: null,
-                },
-            },
-        };
-        expect(codec.fromBuffer(codec.toBuffer(msg))).toStrictEqual(msg);
-    });
-    test('buffer test', () => {
-        const msg = {
-            buff: Uint8Array.from([0, 42, 100, 255]),
-        };
-        expect(codec.fromBuffer(codec.toBuffer(msg))).toStrictEqual(msg);
-    });
-    test('invalid json returns null', () => {
-        const encoder = new TextEncoder();
-        expect(codec.fromBuffer(encoder.encode(''))).toBeNull();
-        expect(codec.fromBuffer(encoder.encode('['))).toBeNull();
-        expect(codec.fromBuffer(encoder.encode('[{}'))).toBeNull();
-        expect(codec.fromBuffer(encoder.encode('{"a":1}[]'))).toBeNull();
-    });
-});

package/dist/codec/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../codec/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AACvC,OAAO,EAAE,cAAc,EAAE,MAAM,QAAQ,CAAC;AACxC,YAAY,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC"}

package/dist/codec/json.d.ts

@@ -1,7 +0,0 @@
-import { Codec } from './types';
-/**
- * Naive JSON codec implementation using JSON.stringify and JSON.parse.
- * @type {Codec}
- */
-export declare const NaiveJsonCodec: Codec;
-//# sourceMappingURL=json.d.ts.map

package/dist/codec/json.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"json.d.ts","sourceRoot":"","sources":["../../codec/json.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAwBhC;;;GAGG;AACH,eAAO,MAAM,cAAc,EAAE,KA0B5B,CAAC"}

package/dist/codec/json.js

@@ -1,51 +0,0 @@
-const encoder = new TextEncoder();
-const decoder = new TextDecoder();
-// Convert Uint8Array to base64
-function uint8ArrayToBase64(uint8Array) {
-    let binary = '';
-    uint8Array.forEach((byte) => {
-        binary += String.fromCharCode(byte);
-    });
-    return btoa(binary);
-}
-// Convert base64 to Uint8Array
-function base64ToUint8Array(base64) {
-    const binaryString = atob(base64);
-    const uint8Array = new Uint8Array(binaryString.length);
-    for (let i = 0; i < binaryString.length; i++) {
-        uint8Array[i] = binaryString.charCodeAt(i);
-    }
-    return uint8Array;
-}
-/**
- * Naive JSON codec implementation using JSON.stringify and JSON.parse.
- * @type {Codec}
- */
-export const NaiveJsonCodec = {
-    toBuffer: (obj) => {
-        return encoder.encode(JSON.stringify(obj, function replacer(key) {
-            let val = this[key];
-            if (val instanceof Uint8Array) {
-                return { $t: uint8ArrayToBase64(val) };
-            }
-            else {
-                return val;
-            }
-        }));
-    },
-    fromBuffer: (buff) => {
-        try {
-            return JSON.parse(decoder.decode(buff), function reviver(_key, val) {
-                if (val?.$t) {
-                    return base64ToUint8Array(val.$t);
-                }
-                else {
-                    return val;
-                }
-            });
-        }
-        catch {
-            return null;
-        }
-    },
-};

package/dist/codec/types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../codec/types.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,MAAM,WAAW,KAAK;IACpB;;;;OAIG;IACH,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU,CAAC;IAClC;;;;OAIG;IACH,UAAU,CAAC,GAAG,EAAE,UAAU,GAAG,MAAM,GAAG,IAAI,CAAC;CAC5C"}

package/dist/codec/types.js

@@ -1 +0,0 @@
-export {};

package/dist/logging/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../logging/index.ts"],"names":[],"mappings":"AAAA,QAAA,MAAM,aAAa;;;;CAIT,CAAC;AAEX,KAAK,YAAY,GAAG,MAAM,OAAO,aAAa,CAAC;AAC/C,MAAM,MAAM,MAAM,GAAG;IACnB,QAAQ,EAAE,YAAY,CAAC;CACxB,GAAG;KACD,GAAG,IAAI,YAAY,GAAG,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI;CAC7C,CAAC;AAEF;;GAEG;AACH,eAAO,IAAI,GAAG,EAAE,MAAM,GAAG,SAAS,CAAC;AAGnC;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,EAAE,KAAK,CAAC,EAAE,OAAO,QAoBvE;AAED;;;GAGG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,YAAY,QAI3C"}

package/dist/router/builder.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"builder.d.ts","sourceRoot":"","sources":["../../router/builder.ts"],"names":[],"mappings":"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"}

package/dist/router/builder.js

@@ -1,91 +0,0 @@
-import { Type } from '@sinclair/typebox';
-/**
- * Serializes a service object into its corresponding JSON Schema Draft 7 type.
- * @param {AnyService} s - The service object to serialize.
- * @returns A plain object representing the serialized service.
- */
-export function serializeService(s) {
-    return {
-        name: s.name,
-        state: s.state,
-        procedures: Object.fromEntries(Object.entries(s.procedures).map(([procName, procDef]) => [
-            procName,
-            {
-                input: Type.Strict(procDef.input),
-                output: Type.Strict(procDef.output),
-                // Only add the `errors` field if it is non-never.
-                ...('errors' in procDef
-                    ? {
-                        errors: Type.Strict(procDef.errors),
-                    }
-                    : {}),
-                type: procDef.type,
-                // Only add the `init` field if the type declares it.
-                ...('init' in procDef
-                    ? {
-                        init: Type.Strict(procDef.init),
-                    }
-                    : {}),
-            },
-        ])),
-    };
-}
-/**
- * A builder class for creating River Services.
- * You must call the finalize method to get the finalized schema for use in a service router.
- * @template T The type of the service.
- */
-export class ServiceBuilder {
-    schema;
-    constructor(schema) {
-        this.schema = schema;
-    }
-    /**
-     * Finalizes the schema for the service.
-     * @returns {T} The finalized schema for the service.
-     */
-    finalize() {
-        return this.schema;
-    }
-    /**
-     * Sets the initial state for the service.
-     * @template InitState The type of the initial state.
-     * @param {InitState} state The initial state for the service.
-     * @returns {ServiceBuilder<{ name: T['name']; state: InitState; procedures: T['procedures']; }>} A new ServiceBuilder instance with the updated schema.
-     */
-    initialState(state) {
-        return new ServiceBuilder({
-            ...this.schema,
-            state,
-        });
-    }
-    /**
-     * Defines a new procedure for the service.
-     * @param {ProcName} procName The name of the procedure.
-     * @param {Procedure<T['state'], Ty, I, O, E, Init>} procDef The definition of the procedure.
-     * @returns {ServiceBuilder<{ name: T['name']; state: T['state']; procedures: T['procedures'] & { [k in ProcName]: Procedure<T['state'], Ty, I, O, E, Init>; }; }>} A new ServiceBuilder instance with the updated schema.
-     */
-    defineProcedure(procName, procDef) {
-        const newProcedure = { [procName]: procDef };
-        const procedures = {
-            ...this.schema.procedures,
-            ...newProcedure,
-        };
-        return new ServiceBuilder({
-            ...this.schema,
-            procedures,
-        });
-    }
-    /**
-     * Creates a new instance of ServiceBuilder.
-     * @param {Name} name The name of the service.
-     * @returns {ServiceBuilder<{ name: Name; state: {}; procedures: {}; }>} A new instance of ServiceBuilder.
-     */
-    static create(name) {
-        return new ServiceBuilder({
-            name,
-            state: {},
-            procedures: {},
-        });
-    }
-}

package/dist/router/client.d.ts

@@ -1,68 +0,0 @@
-import { Connection, Transport } from '../transport/transport';
-import { AnyService, ProcErrors, ProcHasInit, ProcInit, ProcInput, ProcOutput, ProcType } from './builder';
-import type { Pushable } from 'it-pushable';
-import { Server } from './server';
-import { TransportClientId } from '../transport/message';
-import { Static } from '@sinclair/typebox';
-import { Result } from './result';
-type AsyncIter<T> = AsyncGenerator<T, T, unknown>;
-/**
- * A helper type to transform an actual service type into a type
- * we can case to in the proxy.
- * @template Router - The type of the Router.
- */
-type ServiceClient<Router extends AnyService> = {
-    [ProcName in keyof Router['procedures']]: ProcType<Router, ProcName> extends 'rpc' ? {
-        rpc: (input: Static<ProcInput<Router, ProcName>>) => Promise<Result<Static<ProcOutput<Router, ProcName>>, Static<ProcErrors<Router, ProcName>>>>;
-    } : ProcType<Router, ProcName> extends 'upload' ? ProcHasInit<Router, ProcName> extends true ? {
-        upload: (init: Static<ProcInit<Router, ProcName>>) => Promise<[
-            Pushable<Static<ProcInput<Router, ProcName>>>,
-            Promise<Result<Static<ProcOutput<Router, ProcName>>, Static<ProcErrors<Router, ProcName>>>>
-        ]>;
-    } : {
-        upload: () => Promise<[
-            Pushable<Static<ProcInput<Router, ProcName>>>,
-            Promise<Result<Static<ProcOutput<Router, ProcName>>, Static<ProcErrors<Router, ProcName>>>>
-        ]>;
-    } : ProcType<Router, ProcName> extends 'stream' ? ProcHasInit<Router, ProcName> extends true ? {
-        stream: (init: Static<ProcInit<Router, ProcName>>) => Promise<[
-            Pushable<Static<ProcInput<Router, ProcName>>>,
-            AsyncIter<Result<Static<ProcOutput<Router, ProcName>>, Static<ProcErrors<Router, ProcName>>>>,
-            () => void
-        ]>;
-    } : {
-        stream: () => Promise<[
-            Pushable<Static<ProcInput<Router, ProcName>>>,
-            AsyncIter<Result<Static<ProcOutput<Router, ProcName>>, Static<ProcErrors<Router, ProcName>>>>,
-            () => void
-        ]>;
-    } : ProcType<Router, ProcName> extends 'subscription' ? {
-        subscribe: (input: Static<ProcInput<Router, ProcName>>) => Promise<[
-            AsyncIter<Result<Static<ProcOutput<Router, ProcName>>, Static<ProcErrors<Router, ProcName>>>>,
-            () => void
-        ]>;
-    } : never;
-};
-/**
- * Defines a type that represents a client for a server with a set of services.
- * @template Srv - The type of the server.
- */
-export type ServerClient<Srv extends Server<Record<string, AnyService>>> = {
-    [SvcName in keyof Srv['services']]: ServiceClient<Srv['services'][SvcName]>;
-};
-/**
- * Creates a client for a given server using the provided transport.
- * Note that the client only needs the type of the server, not the actual
- * server definition itself.
- *
- * This relies on a proxy to dynamically create the client, so the client
- * will be typed as if it were the actual server with the appropriate services
- * and procedures.
- *
- * @template Srv - The type of the server.
- * @param {Transport} transport - The transport to use for communication.
- * @returns The client for the server.
- */
-export declare const createClient: <Srv extends Server<Record<string, AnyService>>>(transport: Transport<Connection>, serverId?: TransportClientId) => ServerClient<Srv>;
-export {};
-//# sourceMappingURL=client.d.ts.map

package/dist/router/client.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../router/client.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AAC/D,OAAO,EACL,UAAU,EACV,UAAU,EACV,WAAW,EACX,QAAQ,EACR,SAAS,EACT,UAAU,EACV,QAAQ,EACT,MAAM,WAAW,CAAC;AAEnB,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAC5C,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAClC,OAAO,EAIL,iBAAiB,EAGlB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAG3C,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAGlC,KAAK,SAAS,CAAC,CAAC,IAAI,cAAc,CAAC,CAAC,EAAE,CAAC,EAAE,OAAO,CAAC,CAAC;AAElD;;;;GAIG;AACH,KAAK,aAAa,CAAC,MAAM,SAAS,UAAU,IAAI;KAC7C,QAAQ,IAAI,MAAM,MAAM,CAAC,YAAY,CAAC,GAAG,QAAQ,CAChD,MAAM,EACN,QAAQ,CACT,SAAS,KAAK,GACX;QACE,GAAG,EAAE,CACH,KAAK,EAAE,MAAM,CAAC,SAAS,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC,KACvC,OAAO,CACV,MAAM,CACJ,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC,EACpC,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC,CACrC,CACF,CAAC;KACH,GACD,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC,SAAS,QAAQ,GAC3C,WAAW,CAAC,MAAM,EAAE,QAAQ,CAAC,SAAS,IAAI,GACxC;QACE,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,CAAC,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC,KAAK,OAAO,CAC3D;YACE,QAAQ,CAAC,MAAM,CAAC,SAAS,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC;YAC7C,OAAO,CACL,MAAM,CACJ,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC,EACpC,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC,CACrC,CACF;SACF,CACF,CAAC;KACH,GACD;QACE,MAAM,EAAE,MAAM,OAAO,CACnB;YACE,QAAQ,CAAC,MAAM,CAAC,SAAS,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC;YAC7C,OAAO,CACL,MAAM,CACJ,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC,EACpC,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC,CACrC,CACF;SACF,CACF,CAAC;KACH,GACH,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC,SAAS,QAAQ,GAC3C,WAAW,CAAC,MAAM,EAAE,QAAQ,CAAC,SAAS,IAAI,GACxC;QACE,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,CAAC,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC,KAAK,OAAO,CAC3D;YACE,QAAQ,CAAC,MAAM,CAAC,SAAS,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC;YAC7C,SAAS,CACP,MAAM,CACJ,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC,EACpC,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC,CACrC,CACF;YACD,MAAM,IAAI;SACX,CACF,CAAC;KACH,GACD;QACE,MAAM,EAAE,MAAM,OAAO,CACnB;YACE,QAAQ,CAAC,MAAM,CAAC,SAAS,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC;YAC7C,SAAS,CACP,MAAM,CACJ,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC,EACpC,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC,CACrC,CACF;YACD,MAAM,IAAI;SACX,CACF,CAAC;KACH,GACH,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC,SAAS,cAAc,GACjD;QACE,SAAS,EAAE,CAAC,KAAK,EAAE,MAAM,CAAC,SAAS,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC,KAAK,OAAO,CAChE;YACE,SAAS,CACP,MAAM,CACJ,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC,EACpC,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC,CACrC,CACF;YACD,MAAM,IAAI;SACX,CACF,CAAC;KACH,GACD,KAAK;CACV,CAAC;AAEF;;;GAGG;AACH,MAAM,MAAM,YAAY,CAAC,GAAG,SAAS,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC,IAAI;KACxE,OAAO,IAAI,MAAM,GAAG,CAAC,UAAU,CAAC,GAAG,aAAa,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC,OAAO,CAAC,CAAC;CAC5E,CAAC;AAgCF;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,YAAY,8DACZ,UAAU,UAAU,CAAC,aACtB,iBAAiB,sBAuLA,CAAC"}

package/dist/router/client.js

@@ -1,159 +0,0 @@
-import { pushable } from 'it-pushable';
-import { msg, isStreamClose, closeStream, } from '../transport/message';
-import { waitForMessage } from '../transport';
-import { nanoid } from 'nanoid';
-const noop = () => { };
-function _createRecursiveProxy(callback, path) {
-    const proxy = new Proxy(noop, {
-        // property access, recurse and add field to path
-        get(_obj, key) {
-            if (typeof key !== 'string')
-                return undefined;
-            return _createRecursiveProxy(callback, [...path, key]);
-        },
-        // hit the end, let's invoke the handler
-        apply(_target, _this, args) {
-            return callback({
-                path,
-                args,
-            });
-        },
-    });
-    return proxy;
-}
-/**
- * Creates a client for a given server using the provided transport.
- * Note that the client only needs the type of the server, not the actual
- * server definition itself.
- *
- * This relies on a proxy to dynamically create the client, so the client
- * will be typed as if it were the actual server with the appropriate services
- * and procedures.
- *
- * @template Srv - The type of the server.
- * @param {Transport} transport - The transport to use for communication.
- * @returns The client for the server.
- */
-export const createClient = (transport, serverId = 'SERVER') => _createRecursiveProxy(async (opts) => {
-    const [serviceName, procName, procType] = [...opts.path];
-    if (!(serviceName && procName && procType)) {
-        throw new Error('invalid river call, ensure the service and procedure you are calling exists');
-    }
-    const [input] = opts.args;
-    const streamId = nanoid();
-    function belongsToSameStream(msg) {
-        return msg.streamId === streamId;
-    }
-    if (procType === 'stream') {
-        const inputStream = pushable({ objectMode: true });
-        const outputStream = pushable({ objectMode: true });
-        let firstMessage = true;
-        if (input) {
-            const m = msg(transport.clientId, serverId, streamId, input, serviceName, procName);
-            // first message needs the open bit.
-            m.controlFlags = 2 /* ControlFlags.StreamOpenBit */;
-            transport.send(m);
-            firstMessage = false;
-        }
-        // input -> transport
-        // this gets cleaned up on inputStream.end() which is called by closeHandler
-        (async () => {
-            for await (const rawIn of inputStream) {
-                const m = msg(transport.clientId, serverId, streamId, rawIn);
-                if (firstMessage) {
-                    m.serviceName = serviceName;
-                    m.procedureName = procName;
-                    m.controlFlags |= 2 /* ControlFlags.StreamOpenBit */;
-                    firstMessage = false;
-                }
-                transport.send(m);
-            }
-            transport.send(closeStream(transport.clientId, serverId, streamId));
-        })();
-        // transport -> output
-        const listener = (msg) => {
-            if (!belongsToSameStream(msg)) {
-                return;
-            }
-            if (isStreamClose(msg.controlFlags)) {
-                outputStream.end();
-                transport.removeEventListener('message', listener);
-            }
-            else {
-                outputStream.push(msg.payload);
-            }
-        };
-        transport.addEventListener('message', listener);
-        const closeHandler = () => {
-            inputStream.end();
-            outputStream.end();
-            transport.send(closeStream(transport.clientId, serverId, streamId));
-            transport.removeEventListener('message', listener);
-        };
-        return [inputStream, outputStream, closeHandler];
-    }
-    else if (procType === 'rpc') {
-        const m = msg(transport.clientId, serverId, streamId, input, serviceName, procName);
-        // rpc is a stream open + close
-        m.controlFlags |=
-            2 /* ControlFlags.StreamOpenBit */ | 4 /* ControlFlags.StreamClosedBit */;
-        transport.send(m);
-        return waitForMessage(transport, belongsToSameStream);
-    }
-    else if (procType === 'subscribe') {
-        const m = msg(transport.clientId, serverId, streamId, input, serviceName, procName);
-        m.controlFlags |= 2 /* ControlFlags.StreamOpenBit */;
-        transport.send(m);
-        // transport -> output
-        const outputStream = pushable({ objectMode: true });
-        const listener = (msg) => {
-            if (!belongsToSameStream(msg)) {
-                return;
-            }
-            if (isStreamClose(msg.controlFlags)) {
-                outputStream.end();
-                transport.removeEventListener('message', listener);
-            }
-            else {
-                outputStream.push(msg.payload);
-            }
-        };
-        transport.addEventListener('message', listener);
-        const closeHandler = () => {
-            outputStream.end();
-            transport.send(closeStream(transport.clientId, serverId, streamId));
-            transport.removeEventListener('message', listener);
-        };
-        return [outputStream, closeHandler];
-    }
-    else if (procType === 'upload') {
-        const inputStream = pushable({ objectMode: true });
-        let firstMessage = true;
-        if (input) {
-            const m = msg(transport.clientId, serverId, streamId, input, serviceName, procName);
-            // first message needs the open bit.
-            m.controlFlags = 2 /* ControlFlags.StreamOpenBit */;
-            transport.send(m);
-            firstMessage = false;
-        }
-        // input -> transport
-        // this gets cleaned up on inputStream.end(), which the caller should call.
-        (async () => {
-            for await (const rawIn of inputStream) {
-                const m = msg(transport.clientId, serverId, streamId, rawIn);
-                if (firstMessage) {
-                    m.controlFlags |= 2 /* ControlFlags.StreamOpenBit */;
-                    m.serviceName = serviceName;
-                    m.procedureName = procName;
-                    firstMessage = false;
-                }
-                transport.send(m);
-            }
-            transport.send(closeStream(transport.clientId, serverId, streamId));
-        })();
-        return [inputStream, waitForMessage(transport, belongsToSameStream)];
-    }
-    else {
-        throw new Error(`invalid river call, unknown procedure type ${procType}`);
-    }
-}, []);