rsocket-browser/dist/index.d.mts

The RSocket client implementation over websocket with browser compatibility based on Uint8Array

import { Mono, Flux, Sink, Publisher, Subscription, Subscriber } from 'reactor-core-ts';
import { Metadata, MimeType, Frame } from 'rsocket-frames-ts';

interface RSocket<M, P> {
    fireAndForget(metadata?: Mono<M>, payload?: Mono<P>): void;
    requestResponse<R>(metadata?: Mono<M>, payload?: Mono<P>): Mono<R>;
    requestStream<R>(metadata?: Mono<M>, payload?: Mono<P>): Flux<R>;
    requestChannel<R>(payloads: Flux<P>, metadata?: Mono<M>, payload?: Mono<P>): Flux<R>;
    metadataPush(metadata: Mono<Metadata<any>>): void;
    disconnect(): void;
}

declare class Emitter<T> implements Sink<T>, Publisher<T>, Subscription {
    private readonly sink;
    private readonly handlers;
    private readonly subscription;
    addEmitHandler(type: 'next', handler: (value: T) => void): void;
    addEmitHandler(type: 'error', handler: (value: Error) => void): void;
    addEmitHandler(type: 'complete', handler: () => void): void;
    removeEmitHandler(type: 'next', handler: (value: T) => void): void;
    removeEmitHandler(type: 'error', handler: (value: Error) => void): void;
    removeEmitHandler(type: 'complete', handler: () => void): void;
    next(value: T): void;
    error(error: Error): void;
    complete(): void;
    subscribe(subscriber: Subscriber<T>): Subscription;
    unsubscribe(): void;
    request(count: number): void;
}

type ConnectionOptions<M, P> = {
    url: string;
    setup: {
        keepAlive: number;
        lifetime: number;
        mimetype: {
            metadata: MimeType<M>;
            payload: MimeType<P>;
        };
        version?: {
            major?: number;
            minor?: number;
        };
    };
};
declare class Connection<M, P> implements RSocket<M, P> {
    protected readonly options: ConnectionOptions<M, P>;
    protected readonly requests: Emitter<Frame>;
    protected readonly responses: Emitter<Frame>;
    constructor(options: ConnectionOptions<M, P>, metadata?: Mono<M>, payload?: Mono<P>);
    private _streamId;
    protected get streamId(): number;
    fireAndForget(metadata?: Mono<M>, payload?: Mono<P>): void;
    requestResponse<R>(metadata?: Mono<M>, payload?: Mono<P>): Mono<R>;
    requestStream<R>(metadata?: Mono<M>, payload?: Mono<P>): Flux<R>;
    requestChannel<R>(payloads: Flux<P>, metadata?: Mono<M>, payload?: Mono<P>): Flux<R>;
    metadataPush(metadata: Mono<Metadata<any>>): void;
    disconnect(): void;
    protected websocket(): void;
    protected setup(metadata?: Mono<M>, payload?: Mono<P>): void;
    protected keepAlive(): void;
    private normalize;
}

export { Connection, type ConnectionOptions, type RSocket };