wspromisify/dist/bundle.d.ts

Wraps your WebSockets into Promise-based class with full d.ts typings on client & server

// Generated by dts-bundle-generator v9.5.1

import { AnyFunc } from 'pepka';

declare namespace wsc {
	interface DataObject {
		[key: string]: any;
	}
	type WSEvent = "open" | "message" | "message-ext" | "close" | "error" | "timeout" | "reconnect" | "send" | "ping";
	/** Minimal socket-like interface. */
	interface Socket {
		readyState: number;
		send(...any: any[]): void;
		close(): void;
		addEventListener: WebSocket["addEventListener"];
		removeEventListener: WebSocket["removeEventListener"];
	}
	type AsyncErrCode = Promise<number | null | {}>;
	type EventHandler = (e: any) => void;
	type Predicate = (data: any) => boolean;
	type DataPipe = (message: any) => any;
	interface TimeFnParams {
		base: number;
		max: number;
		jitter: number;
	}
	interface Config {
		log(event: string, time?: number | null, message?: any): void;
		log(event: string, message?: any): void;
		timer: boolean;
		url: string;
		timeout: number;
		reconnect: {
			stop_after: number;
			on_timeout: boolean;
			on_break: boolean;
			time_fn: import("pepka").AnyFunc<number, [
				params: wsc.TimeFnParams,
				attempt: number
			]>;
			params: {
				base: number;
				max: number;
				jitter: number;
			};
		} | false;
		max_idle_time: number;
		lazy: boolean;
		socket: Socket | null;
		adapter: (host: string, protocols?: string[]) => Socket;
		encode: (key: string, message: any, config: Config) => any;
		decode: (rawMessage: any) => {
			[id_or_data_key: string]: string;
		};
		protocols: string[];
		pipes: DataPipe[];
		server: {
			id_key: string;
			data_key: string;
		};
		ping: {
			interval: number;
			timeout?: number;
			in: string | Uint8Array;
			out: string | Uint8Array;
		} | false;
	}
	type UserConfig = import("type-fest").PartialDeep<Config> & ({
		socket: Config["socket"];
	} | Pick<Config, "url">);
	type SendOptions = Partial<{
		top: any;
	}>;
	interface Message {
		msg: any;
		ff(x: any): any;
		sent_time: number | null;
	}
}
declare const label_message_ext = "message-ext";
export type EventHandler<T extends keyof WebSocketEventMap> = AnyFunc<any, [
	WebSocketEventMap[T]
]>;
export type RouteHandler<T> = AnyFunc<any, [
	data: T,
	next: AnyFunc
]>;
export type EventHandlers = {
	open: EventHandler<"open">[];
	close: EventHandler<"close">[];
	error: EventHandler<"error">[];
	message: AnyFunc<any, [
		WebSocketEventMap["message"] & {
			data: any;
		}
	]>[];
	[label_message_ext]: AnyFunc<any, [
		WebSocketEventMap["message"] & {
			data: any;
		}
	]>[];
	timeout: AnyFunc<any, [
		data: any
	]>[];
};
export declare class WebSocketClient<T extends Uint8Array | string = string> {
	private ws;
	private intentionally_closed;
	private reconnect_timeout;
	private queue;
	private handlers;
	private config;
	private ping_timer;
	private idle_timer;
	private zombie_timer;
	private router;
	private get opened();
	private call;
	private log;
	private resetPing;
	private resetZombieProbe;
	private resetIdle;
	private _reconnecting;
	private reconnect_start;
	private reconnect;
	private resetReconnect;
	private initSocket;
	private _opening;
	/** returns status if won't open or null if ok. */
	private connect;
	get socket(): wsc.Socket | null;
	ready(timeout?: number): Promise<void>;
	on(event_name: keyof EventHandlers, handler: wsc.EventHandler, predicate?: wsc.Predicate, raw?: boolean): wsc.EventHandler;
	off(event_name: keyof EventHandlers, handler: wsc.EventHandler, raw?: boolean): void;
	private terminate;
	close(timeout?: number): wsc.AsyncErrCode;
	open(): Promise<number | null> | undefined;
	addEventListener(e: keyof EventHandlers, cb: wsc.EventHandler, opts?: {
		predicate?: wsc.Predicate;
		raw?: boolean;
	}): wsc.EventHandler;
	removeEventListener(e: keyof EventHandlers, handler: wsc.EventHandler, opts?: {
		predicate?: wsc.Predicate;
		raw?: boolean;
	}): void;
	private prepareMessage;
	/**  .send(your_data) wraps request to server with {id: `unique_id`, data: `actually your data`},
	  returns a Promise that will be rejected after a timeout or
	  resolved if server returns the same signature: {id: `same_hash`, data: `response data`}.
	*/
	send<RequestDataType = any, ResponseDataType = any>(message_data: RequestDataType, opts?: wsc.SendOptions): Promise<ResponseDataType>;
	stream<RequestDataType = any, ResponseDataType = any>(message_data: RequestDataType, opts?: wsc.SendOptions): AsyncGenerator<ResponseDataType, void, unknown>;
	route(handler: RouteHandler<T>): void;
	constructor(user_config: wsc.UserConfig);
}

export {};