@replit/river 0.10.0 → 0.10.1

package/dist/router/server.js

@@ -1,260 +0,0 @@
-import { pushable } from 'it-pushable';
-import { ControlMessagePayloadSchema, isStreamClose, isStreamOpen, reply, closeStream, } from '../transport/message';
-import { log } from '../logging';
-import { Value } from '@sinclair/typebox/value';
-import { Err, UNCAUGHT_ERROR, } from './result';
-class RiverServer {
-    transport;
-    services;
-    contextMap;
-    // map of streamId to ProcStream
-    streamMap;
-    // map of client to their open streams by streamId
-    clientStreams;
-    constructor(transport, services, extendedContext) {
-        this.transport = transport;
-        this.services = services;
-        this.contextMap = new Map();
-        for (const service of Object.values(services)) {
-            this.contextMap.set(service, {
-                ...extendedContext,
-                state: service.state,
-            });
-        }
-        this.streamMap = new Map();
-        this.clientStreams = new Map();
-        this.transport.addEventListener('message', this.handler);
-        this.transport.addEventListener('connectionStatus', this.onDisconnect);
-    }
-    get streams() {
-        return this.streamMap;
-    }
-    handler = async (message) => {
-        if (message.to !== this.transport.clientId) {
-            log?.info(`${this.transport.clientId} -- got msg with destination that isn't the server, ignoring`);
-            return;
-        }
-        let procStream = this.streamMap.get(message.streamId);
-        const isInitMessage = !procStream;
-        // create a proc stream if it doesnt exist
-        procStream ||= this.createNewProcStream(message);
-        if (!procStream) {
-            // if we fail to create a proc stream, just abort
-            return;
-        }
-        await this.pushToStream(procStream, message, isInitMessage);
-    };
-    // cleanup streams on unexpected disconnections
-    onDisconnect = async (evt) => {
-        if (evt.status !== 'disconnect') {
-            return;
-        }
-        const disconnectedClientId = evt.conn.connectedTo;
-        log?.info(`${this.transport.clientId} -- got unexpected disconnect from ${disconnectedClientId}, cleaning up streams`);
-        const streamsFromThisClient = this.clientStreams.get(disconnectedClientId);
-        if (!streamsFromThisClient) {
-            return;
-        }
-        await Promise.all(Array.from(streamsFromThisClient).map(this.cleanupStream));
-        this.clientStreams.delete(disconnectedClientId);
-    };
-    async close() {
-        this.transport.removeEventListener('message', this.handler);
-        this.transport.removeEventListener('connectionStatus', this.onDisconnect);
-        await Promise.all([...this.streamMap.keys()].map(this.cleanupStream));
-    }
-    createNewProcStream(message) {
-        if (!isStreamOpen(message.controlFlags)) {
-            log?.warn(`${this.transport.clientId} -- couldn't find a matching procedure stream for ${message.serviceName}.${message.procedureName}:${message.streamId}`);
-            return;
-        }
-        if (!message.serviceName || !(message.serviceName in this.services)) {
-            log?.warn(`${this.transport.clientId} -- couldn't find service ${message.serviceName}`);
-            return;
-        }
-        const service = this.services[message.serviceName];
-        const serviceContext = this.getContext(service);
-        if (!message.procedureName ||
-            !(message.procedureName in service.procedures)) {
-            log?.warn(`${this.transport.clientId} -- couldn't find a matching procedure for ${message.serviceName}.${message.procedureName}`);
-            return;
-        }
-        const procedure = service.procedures[message.procedureName];
-        const incoming = pushable({ objectMode: true });
-        const outgoing = pushable({ objectMode: true });
-        const outputHandler = 
-        // sending outgoing messages back to client
-        (async () => {
-            for await (const response of outgoing) {
-                this.transport.send(reply(message, response));
-            }
-            // we ended, send a close bit back to the client
-            // only subscriptions and streams have streams the
-            // handler can close
-            if (procedure.type === 'subscription' || procedure.type === 'stream') {
-                this.transport.send(closeStream(this.transport.clientId, message.from, message.streamId));
-            }
-        })();
-        const errorHandler = (err) => {
-            const errorMsg = err instanceof Error ? err.message : `[coerced to error] ${err}`;
-            log?.error(`${this.transport.clientId} -- procedure ${message.serviceName}.${message.procedureName}:${message.streamId} threw an error: ${errorMsg}`);
-            outgoing.push(Err({
-                code: UNCAUGHT_ERROR,
-                message: errorMsg,
-            }));
-        };
-        // pump incoming message stream -> handler -> outgoing message stream
-        let inputHandler;
-        const procHasInitMessage = 'init' in procedure;
-        if (procedure.type === 'stream') {
-            if (procHasInitMessage) {
-                inputHandler = (async () => {
-                    const initMessage = await incoming.next();
-                    if (initMessage.done) {
-                        return;
-                    }
-                    return procedure
-                        .handler(serviceContext, initMessage.value, incoming, outgoing)
-                        .catch(errorHandler);
-                })();
-            }
-            else {
-                inputHandler = procedure
-                    .handler(serviceContext, incoming, outgoing)
-                    .catch(errorHandler);
-            }
-        }
-        else if (procedure.type === 'rpc') {
-            inputHandler = (async () => {
-                const inputMessage = await incoming.next();
-                if (inputMessage.done) {
-                    return;
-                }
-                try {
-                    const outputMessage = await procedure.handler(serviceContext, inputMessage.value);
-                    outgoing.push(outputMessage);
-                }
-                catch (err) {
-                    errorHandler(err);
-                }
-            })();
-        }
-        else if (procedure.type === 'subscription') {
-            inputHandler = (async () => {
-                const inputMessage = await incoming.next();
-                if (inputMessage.done) {
-                    return;
-                }
-                try {
-                    await procedure.handler(serviceContext, inputMessage.value, outgoing);
-                }
-                catch (err) {
-                    errorHandler(err);
-                }
-            })();
-        }
-        else if (procedure.type === 'upload') {
-            if (procHasInitMessage) {
-                inputHandler = (async () => {
-                    const initMessage = await incoming.next();
-                    if (initMessage.done) {
-                        return;
-                    }
-                    try {
-                        const outputMessage = await procedure.handler(serviceContext, initMessage.value, incoming);
-                        outgoing.push(outputMessage);
-                    }
-                    catch (err) {
-                        errorHandler(err);
-                    }
-                })();
-            }
-            else {
-                inputHandler = (async () => {
-                    try {
-                        const outputMessage = await procedure.handler(serviceContext, incoming);
-                        outgoing.push(outputMessage);
-                    }
-                    catch (err) {
-                        errorHandler(err);
-                    }
-                })();
-            }
-        }
-        else {
-            // procedure is inferred to be never here as this is not a valid procedure type
-            // we cast just to log
-            log?.warn(`${this.transport.clientId} -- got request for invalid procedure type ${procedure.type} at ${message.serviceName}.${message.procedureName}`);
-            return;
-        }
-        const procStream = {
-            id: message.streamId,
-            incoming,
-            outgoing,
-            serviceName: message.serviceName,
-            procedureName: message.procedureName,
-            procedure,
-            promises: { inputHandler, outputHandler },
-        };
-        this.streamMap.set(message.streamId, procStream);
-        // add this stream to ones from that client so we can clean it up in the case of a disconnect without close
-        const streamsFromThisClient = this.clientStreams.get(message.from) ?? new Set();
-        streamsFromThisClient.add(message.streamId);
-        this.clientStreams.set(message.from, streamsFromThisClient);
-        return procStream;
-    }
-    async pushToStream(procStream, message, isInit) {
-        const procedure = procStream.procedure;
-        const procHasInitMessage = 'init' in procedure;
-        if ((isInit &&
-            procHasInitMessage &&
-            Value.Check(procedure.init, message.payload)) ||
-            Value.Check(procedure.input, message.payload)) {
-            procStream.incoming.push(message.payload);
-        }
-        else if (!Value.Check(ControlMessagePayloadSchema, message.payload)) {
-            log?.error(`${this.transport.clientId} -- procedure ${procStream.serviceName}.${procStream.procedureName} received invalid payload: ${JSON.stringify(message.payload)}`);
-        }
-        if (isStreamClose(message.controlFlags)) {
-            await this.cleanupStream(message.streamId);
-            const streamsFromThisClient = this.clientStreams.get(message.from);
-            if (streamsFromThisClient) {
-                streamsFromThisClient.delete(message.streamId);
-                if (streamsFromThisClient.size === 0) {
-                    this.clientStreams.delete(message.from);
-                }
-            }
-        }
-    }
-    getContext(service) {
-        const context = this.contextMap.get(service);
-        if (!context) {
-            const err = `${this.transport.clientId} -- no context found for ${service.name}`;
-            log?.error(err);
-            throw new Error(err);
-        }
-        return context;
-    }
-    cleanupStream = async (id) => {
-        const stream = this.streamMap.get(id);
-        if (!stream) {
-            return;
-        }
-        stream.incoming.end();
-        await stream.promises.inputHandler;
-        stream.outgoing.end();
-        await stream.promises.outputHandler;
-        this.streamMap.delete(id);
-    };
-}
-/**
- * Creates a server instance that listens for incoming messages from a transport and routes them to the appropriate service and procedure.
- * The server tracks the state of each service along with open streams and the extended context object.
- * @param transport - The transport to listen to.
- * @param services - An object containing all the services to be registered on the server.
- * @param extendedContext - An optional object containing additional context to be passed to all services.
- * @returns A promise that resolves to a server instance with the registered services.
- */
-export function createServer(transport, services, extendedContext) {
-    return new RiverServer(transport, services, extendedContext);
-}

package/dist/transport/events.d.ts

@@ -1,19 +0,0 @@
-import { OpaqueTransportMessage } from './message';
-import { Connection } from './transport';
-export interface EventMap {
-    message: OpaqueTransportMessage;
-    connectionStatus: {
-        status: 'connect' | 'disconnect';
-        conn: Connection;
-    };
-}
-export type EventTypes = keyof EventMap;
-export type EventHandler<K extends EventTypes> = (event: EventMap[K]) => void;
-export declare class EventDispatcher<T extends EventTypes> {
-    private eventListeners;
-    numberOfListeners<K extends T>(eventType: K): number;
-    addEventListener<K extends T>(eventType: K, handler: EventHandler<K>): void;
-    removeEventListener<K extends T>(eventType: K, handler: EventHandler<K>): void;
-    dispatchEvent<K extends T>(eventType: K, event: EventMap[K]): void;
-}
-//# sourceMappingURL=events.d.ts.map

package/dist/transport/events.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"events.d.ts","sourceRoot":"","sources":["../../transport/events.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,sBAAsB,EAAE,MAAM,WAAW,CAAC;AACnD,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAEzC,MAAM,WAAW,QAAQ;IACvB,OAAO,EAAE,sBAAsB,CAAC;IAChC,gBAAgB,EAAE;QAChB,MAAM,EAAE,SAAS,GAAG,YAAY,CAAC;QACjC,IAAI,EAAE,UAAU,CAAC;KAClB,CAAC;CACH;AAED,MAAM,MAAM,UAAU,GAAG,MAAM,QAAQ,CAAC;AACxC,MAAM,MAAM,YAAY,CAAC,CAAC,SAAS,UAAU,IAAI,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC;AAE9E,qBAAa,eAAe,CAAC,CAAC,SAAS,UAAU;IAC/C,OAAO,CAAC,cAAc,CAA2C;IAEjE,iBAAiB,CAAC,CAAC,SAAS,CAAC,EAAE,SAAS,EAAE,CAAC;IAI3C,gBAAgB,CAAC,CAAC,SAAS,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE,OAAO,EAAE,YAAY,CAAC,CAAC,CAAC;IAQpE,mBAAmB,CAAC,CAAC,SAAS,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE,OAAO,EAAE,YAAY,CAAC,CAAC,CAAC;IAOvE,aAAa,CAAC,CAAC,SAAS,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE,KAAK,EAAE,QAAQ,CAAC,CAAC,CAAC;CAQ5D"}

package/dist/transport/events.js

@@ -1,26 +0,0 @@
-export class EventDispatcher {
-    eventListeners = {};
-    numberOfListeners(eventType) {
-        return this.eventListeners[eventType]?.size ?? 0;
-    }
-    addEventListener(eventType, handler) {
-        if (!this.eventListeners[eventType]) {
-            this.eventListeners[eventType] = new Set();
-        }
-        this.eventListeners[eventType]?.add(handler);
-    }
-    removeEventListener(eventType, handler) {
-        const handlers = this.eventListeners[eventType];
-        if (handlers) {
-            this.eventListeners[eventType]?.delete(handler);
-        }
-    }
-    dispatchEvent(eventType, event) {
-        const handlers = this.eventListeners[eventType];
-        if (handlers) {
-            for (const handler of handlers) {
-                handler(event);
-            }
-        }
-    }
-}

package/dist/transport/impls/stdio/stdio.d.ts

@@ -1,33 +0,0 @@
-/// <reference types="node" />
-import { Codec } from '../../../codec';
-import { TransportClientId } from '../../message';
-import { Connection, Transport } from '../../transport';
-export declare class StdioConnection extends Connection {
-    output: NodeJS.WritableStream;
-    constructor(transport: Transport<StdioConnection>, connectedTo: TransportClientId, output: NodeJS.WritableStream);
-    send(payload: Uint8Array): boolean;
-    close(): Promise<void>;
-}
-interface Options {
-    codec: Codec;
-}
-/**
- * A transport implementation that uses standard input and output streams.
- * @extends Transport
- */
-export declare class StdioTransport extends Transport<StdioConnection> {
-    clientId: TransportClientId;
-    input: NodeJS.ReadableStream;
-    output: NodeJS.WritableStream;
-    /**
-     * Constructs a new StdioTransport instance.
-     * @param clientId - The ID of the client associated with this transport.
-     * @param input - The readable stream to use as input. Defaults to process.stdin.
-     * @param output - The writable stream to use as output. Defaults to process.stdout.
-     */
-    constructor(clientId: TransportClientId, input?: NodeJS.ReadableStream, output?: NodeJS.WritableStream, providedOptions?: Partial<Options>);
-    setupConnectionStatusListeners(): void;
-    createNewConnection(to: TransportClientId): Promise<void>;
-}
-export {};
-//# sourceMappingURL=stdio.d.ts.map

package/dist/transport/impls/stdio/stdio.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"stdio.d.ts","sourceRoot":"","sources":["../../../../transport/impls/stdio/stdio.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAC;AAGvC,OAAO,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAClD,OAAO,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAKxD,qBAAa,eAAgB,SAAQ,UAAU;IAC7C,MAAM,EAAE,MAAM,CAAC,cAAc,CAAC;gBAG5B,SAAS,EAAE,SAAS,CAAC,eAAe,CAAC,EACrC,WAAW,EAAE,iBAAiB,EAC9B,MAAM,EAAE,MAAM,CAAC,cAAc;IAM/B,IAAI,CAAC,OAAO,EAAE,UAAU;IAOlB,KAAK;CAGZ;AAED,UAAU,OAAO;IACf,KAAK,EAAE,KAAK,CAAC;CACd;AAMD;;;GAGG;AACH,qBAAa,cAAe,SAAQ,SAAS,CAAC,eAAe,CAAC;IAC5D,QAAQ,EAAE,iBAAiB,CAAC;IAC5B,KAAK,EAAE,MAAM,CAAC,cAAc,CAAiB;IAC7C,MAAM,EAAE,MAAM,CAAC,cAAc,CAAkB;IAE/C;;;;;OAKG;gBAED,QAAQ,EAAE,iBAAiB,EAC3B,KAAK,GAAE,MAAM,CAAC,cAA8B,EAC5C,MAAM,GAAE,MAAM,CAAC,cAA+B,EAC9C,eAAe,CAAC,EAAE,OAAO,CAAC,OAAO,CAAC;IAUpC,8BAA8B,IAAI,IAAI;IAwBhC,mBAAmB,CAAC,EAAE,EAAE,iBAAiB;CAShD"}

package/dist/transport/impls/stdio/stdio.js

@@ -1,75 +0,0 @@
-import { NaiveJsonCodec } from '../../../codec/json';
-import { log } from '../../../logging';
-import { Connection, Transport } from '../../transport';
-import readline from 'readline';
-const newlineBuff = new TextEncoder().encode('\n');
-export class StdioConnection extends Connection {
-    output;
-    constructor(transport, connectedTo, output) {
-        super(transport, connectedTo);
-        this.output = output;
-    }
-    send(payload) {
-        const out = new Uint8Array(payload.length + newlineBuff.length);
-        out.set(payload, 0);
-        out.set(newlineBuff, payload.length);
-        return this.output.write(out);
-    }
-    async close() {
-        this.output.end();
-    }
-}
-const defaultOptions = {
-    codec: NaiveJsonCodec,
-};
-/**
- * A transport implementation that uses standard input and output streams.
- * @extends Transport
- */
-export class StdioTransport extends Transport {
-    clientId;
-    input = process.stdin;
-    output = process.stdout;
-    /**
-     * Constructs a new StdioTransport instance.
-     * @param clientId - The ID of the client associated with this transport.
-     * @param input - The readable stream to use as input. Defaults to process.stdin.
-     * @param output - The writable stream to use as output. Defaults to process.stdout.
-     */
-    constructor(clientId, input = process.stdin, output = process.stdout, providedOptions) {
-        const options = { ...defaultOptions, ...providedOptions };
-        super(options.codec, clientId);
-        this.clientId = clientId;
-        this.input = input;
-        this.output = output;
-        this.setupConnectionStatusListeners();
-    }
-    setupConnectionStatusListeners() {
-        let conn = undefined;
-        const rl = readline.createInterface({
-            input: this.input,
-        });
-        const encoder = new TextEncoder();
-        rl.on('line', (msg) => {
-            const parsedMsg = this.parseMsg(encoder.encode(msg));
-            if (parsedMsg && !this.connections.has(parsedMsg.from)) {
-                conn = new StdioConnection(this, parsedMsg.from, this.output);
-                this.onConnect(conn);
-            }
-            this.handleMsg(parsedMsg);
-        });
-        rl.on('close', () => {
-            if (conn) {
-                this.onDisconnect(conn);
-            }
-        });
-    }
-    async createNewConnection(to) {
-        if (this.state === 'destroyed') {
-            throw new Error('cant reopen a destroyed connection');
-        }
-        log?.info(`${this.clientId} -- establishing a new stream to ${to}`);
-        const conn = new StdioConnection(this, to, this.output);
-        this.onConnect(conn);
-    }
-}

package/dist/transport/impls/stdio/stdio.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=stdio.test.d.ts.map

package/dist/transport/impls/stdio/stdio.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"stdio.test.d.ts","sourceRoot":"","sources":["../../../../transport/impls/stdio/stdio.test.ts"],"names":[],"mappings":""}

package/dist/transport/impls/stdio/stdio.test.js

@@ -1,24 +0,0 @@
-import { describe, test, expect } from 'vitest';
-import stream from 'node:stream';
-import { StdioTransport } from './stdio';
-import { payloadToTransportMessage, waitForMessage, } from '../../../util/testHelpers';
-import { ensureTransportIsClean } from '../../../__tests__/fixtures/cleanup';
-describe('sending and receiving across node streams works', () => {
-    test('basic send/receive', async () => {
-        const clientToServer = new stream.PassThrough();
-        const serverToClient = new stream.PassThrough();
-        const serverTransport = new StdioTransport('abc', clientToServer, serverToClient);
-        const clientTransport = new StdioTransport('def', serverToClient, clientToServer);
-        const msg = {
-            msg: 'cool',
-            test: 123,
-        };
-        const p = waitForMessage(serverTransport);
-        clientTransport.send(payloadToTransportMessage(msg, 'stream', clientTransport.clientId, serverTransport.clientId));
-        await expect(p).resolves.toStrictEqual(msg);
-        await clientTransport.close();
-        await serverTransport.close();
-        await ensureTransportIsClean(clientTransport);
-        await ensureTransportIsClean(serverTransport);
-    });
-});

package/dist/transport/impls/ws/client.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../../../transport/impls/ws/client.ts"],"names":[],"mappings":";AAAA,OAAO,SAAS,MAAM,eAAe,CAAC;AACtC,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAE5C,OAAO,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAElD,OAAO,EAAE,KAAK,KAAK,EAAE,MAAM,gBAAgB,CAAC;AAC5C,OAAO,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAC;AAEnD,UAAU,OAAO;IACf,eAAe,EAAE,MAAM,CAAC;IACxB,gBAAgB,EAAE,MAAM,CAAC;IACzB,KAAK,EAAE,KAAK,CAAC;CACd;AAQD,KAAK,eAAe,GAAG;IAAE,EAAE,EAAE,SAAS,CAAA;CAAE,GAAG;IAAE,GAAG,EAAE,MAAM,CAAA;CAAE,CAAC;AAE3D;;;;GAIG;AACH,qBAAa,wBAAyB,SAAQ,SAAS,CAAC,mBAAmB,CAAC;IAC1E;;OAEG;IACH,QAAQ,EAAE,CAAC,EAAE,EAAE,iBAAiB,KAAK,OAAO,CAAC,SAAS,CAAC,CAAC;IACxD,OAAO,EAAE,OAAO,CAAC;IACjB,QAAQ,EAAE,iBAAiB,CAAC;IAC5B,iBAAiB,EAAE,GAAG,CAAC,iBAAiB,EAAE,OAAO,CAAC,eAAe,CAAC,CAAC,CAAC;IACpE,eAAe,EAAE,OAAO,CAAQ;IAEhC;;;;;OAKG;gBAED,QAAQ,EAAE,MAAM,OAAO,CAAC,SAAS,CAAC,EAClC,QAAQ,EAAE,iBAAiB,EAC3B,QAAQ,EAAE,iBAAiB,EAC3B,eAAe,CAAC,EAAE,OAAO,CAAC,OAAO,CAAC;IAWpC,8BAA8B,IAAI,IAAI;IAIhC,mBAAmB,CAAC,EAAE,EAAE,MAAM,EAAE,OAAO,SAAI;CA6ElD"}

package/dist/transport/impls/ws/connection.d.ts

@@ -1,11 +0,0 @@
-/// <reference types="ws" />
-import { TransportClientId } from '../../message';
-import { Connection, Transport } from '../../transport';
-import WebSocket from 'isomorphic-ws';
-export declare class WebSocketConnection extends Connection {
-    ws: WebSocket;
-    constructor(transport: Transport<WebSocketConnection>, connectedTo: TransportClientId, ws: WebSocket);
-    send(payload: Uint8Array): boolean;
-    close(): Promise<void>;
-}
-//# sourceMappingURL=connection.d.ts.map

package/dist/transport/impls/ws/connection.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"connection.d.ts","sourceRoot":"","sources":["../../../../transport/impls/ws/connection.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAClD,OAAO,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AACxD,OAAO,SAAS,MAAM,eAAe,CAAC;AAEtC,qBAAa,mBAAoB,SAAQ,UAAU;IACjD,EAAE,EAAE,SAAS,CAAC;gBAGZ,SAAS,EAAE,SAAS,CAAC,mBAAmB,CAAC,EACzC,WAAW,EAAE,iBAAiB,EAC9B,EAAE,EAAE,SAAS;IAUf,IAAI,CAAC,OAAO,EAAE,UAAU;IASlB,KAAK;CAGZ"}

package/dist/transport/impls/ws/connection.js

@@ -1,23 +0,0 @@
-import { Connection } from '../../transport';
-export class WebSocketConnection extends Connection {
-    ws;
-    constructor(transport, connectedTo, ws) {
-        super(transport, connectedTo);
-        this.ws = ws;
-        ws.binaryType = 'arraybuffer';
-        // take over the onmessage for this websocket
-        this.ws.onmessage = (msg) => transport.onMessage(msg.data);
-    }
-    send(payload) {
-        if (this.ws.readyState === this.ws.OPEN) {
-            this.ws.send(payload);
-            return true;
-        }
-        else {
-            return false;
-        }
-    }
-    async close() {
-        this.ws.close();
-    }
-}

package/dist/transport/impls/ws/server.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../../../transport/impls/ws/server.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAkB,MAAM,gBAAgB,CAAC;AAEvD,OAAO,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAClD,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAC5C,OAAO,EAAE,MAAM,EAAE,MAAM,IAAI,CAAC;AAC5B,OAAO,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAC1C,OAAO,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAC;AAEnD,UAAU,OAAO;IACf,KAAK,EAAE,KAAK,CAAC;CACd;AAMD,qBAAa,wBAAyB,SAAQ,SAAS,CAAC,mBAAmB,CAAC;IAC1E,GAAG,EAAE,MAAM,CAAC;IACZ,QAAQ,EAAE,iBAAiB,CAAC;gBAG1B,GAAG,EAAE,MAAM,EACX,QAAQ,EAAE,iBAAiB,EAC3B,eAAe,CAAC,EAAE,OAAO,CAAC,OAAO,CAAC;IASpC,iBAAiB,OAAQ,SAAS,UA6BhC;IAEF,8BAA8B,IAAI,IAAI;IAIhC,mBAAmB,CAAC,EAAE,EAAE,MAAM;IAM9B,KAAK;CAIZ"}

package/dist/transport/impls/ws/ws.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=ws.test.d.ts.map

package/dist/transport/impls/ws/ws.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ws.test.d.ts","sourceRoot":"","sources":["../../../../transport/impls/ws/ws.test.ts"],"names":[],"mappings":""}