@meshagent/meshagent 0.37.1 → 0.38.0

package/dist/node/protocol.d.ts

@@ -1,45 +1,75 @@
 import WebSocket from "isomorphic-ws";
-export type UpdateCallback = (update: Uint8Array, origin?: any) => void;
+export declare enum ProtocolCloseKind {
+    CLIENT = "client",
+    SERVER = "server",
+    ERROR = "error"
+}
+export declare class ProtocolReconnectUnsupportedException extends Error {
+    constructor(message: string);
+}
+export declare class ProtocolCloseException extends Error {
+    readonly closeCode: number;
+    readonly reason?: string;
+    constructor({ closeCode, reason }: {
+        closeCode: number;
+        reason?: string;
+    });
+}
+export declare class ProtocolHandshakeException extends Error {
+    readonly statusCode: number;
+    readonly statusText?: string;
+    constructor({ statusCode, statusText }: {
+        statusCode: number;
+        statusText?: string;
+    });
+}
 export interface ProtocolChannel {
-    start(onDataReceived: (data: Uint8Array) => void, { onDone, onError }: {
+    start(onDataReceived: (data: Uint8Array) => void, params: {
         onDone?: () => void;
-        onError?: (error: any) => void;
+        onError?: (error: unknown) => void;
     }): void;
     dispose(): void;
     sendData(data: Uint8Array): Promise<void>;
 }
 export declare class StreamProtocolChannel implements ProtocolChannel {
-    input: ProtocolMessageStream<Uint8Array>;
-    output: ProtocolMessageStream<Uint8Array>;
+    readonly input: ProtocolMessageStream<Uint8Array>;
+    readonly output: ProtocolMessageStream<Uint8Array>;
     started: boolean;
     private _iterator;
-    constructor({ input, output }: {
+    constructor({ input, output, }: {
         input: ProtocolMessageStream<Uint8Array>;
         output: ProtocolMessageStream<Uint8Array>;
     });
     start(onDataReceived: (data: Uint8Array) => void, { onDone, onError }: {
         onDone?: () => void;
-        onError?: (error: any) => void;
+        onError?: (error: unknown) => void;
     }): void;
     dispose(): void;
     sendData(data: Uint8Array): Promise<void>;
 }
 export declare class WebSocketProtocolChannel implements ProtocolChannel {
-    url: string;
-    jwt: string;
+    readonly url: string;
+    readonly jwt: string;
     webSocket: WebSocket | null;
-    onDataReceived?: (data: Uint8Array) => void;
     private _opened;
+    private _finished;
+    private _onDataReceived?;
+    private _doneHandler?;
+    private _errorHandler?;
+    private readonly _onUnexpectedResponse;
     constructor({ url, jwt }: {
         url: string;
         jwt: string;
     });
     start(onDataReceived: (data: Uint8Array) => void, { onDone, onError }: {
         onDone?: () => void;
-        onError?: (error: any) => void;
+        onError?: (error: unknown) => void;
     }): void;
+    private _finish;
     private _onOpen;
-    private _onData;
+    private _onMessage;
+    private _onClose;
+    private _onError;
     dispose(): void;
     sendData(data: Uint8Array): Promise<void>;
 }
@@ -47,45 +77,72 @@ export declare class ProtocolMessageStream<T> {
     private _messages;
     private _messageAdded;
     private _closed;
-    add(message: T): Promise<void>;
+    add(message: T): void;
     close(): void;
-    stream(): AsyncGenerator<T>;
+    stream(): AsyncGenerator<T, void, void>;
 }
-export type MessageHandler = (protocol: Protocol, messageId: number, type: string, data?: Uint8Array) => Promise<void> | void;
-export declare class Protocol {
-    channel: ProtocolChannel;
-    handlers: {
-        [type: string]: MessageHandler;
-    };
+export type MessageHandler = (protocol: Protocol, messageId: number, type: string, data: Uint8Array) => Promise<void> | void;
+export type ProtocolFactory = () => Protocol;
+export declare class Protocol<T extends ProtocolChannel = ProtocolChannel> {
+    readonly channel: T;
+    readonly handlers: Record<string, MessageHandler>;
     private _id;
     private _send;
+    private _done;
+    private _sendError;
+    private _sendLoop;
+    private _open;
+    private _closed;
+    private _closeKind;
+    private _closeReason;
     private _recvPacketId;
     private _recvState;
     private _recvPacketTotal;
     private _recvMessageId;
     private _recvType;
     private _recvPackets;
-    private _iterator;
     constructor({ channel }: {
-        channel: ProtocolChannel;
+        channel: T;
     });
+    get url(): string | null;
+    get token(): string | null;
+    get isOpen(): boolean;
+    get isClosed(): boolean;
+    get closeKind(): ProtocolCloseKind | null;
+    get closeReason(): string | null;
+    get done(): Promise<unknown>;
+    waitForClose(): Promise<void>;
+    static createFactory<TProtocol extends Protocol, TArgs extends unknown[]>(this: new (...args: TArgs) => TProtocol, ...args: TArgs): ProtocolFactory;
+    private _setCloseState;
     addHandler(type: string, handler: MessageHandler): void;
-    removeHandler(type: string): void;
-    handleMessage(messageId: number, type: string, data?: Uint8Array): Promise<void>;
+    removeHandler(type: string, handler: MessageHandler): void;
+    getHandler(type: string): MessageHandler | undefined;
+    handleMessage(messageId: number, type: string, data: Uint8Array): Promise<void>;
     getNextMessageId(): number;
+    sendNowait(type: string, data: Uint8Array, { id }?: {
+        id?: number;
+    }): number;
     send(type: string, data: Uint8Array, id?: number): Promise<void>;
-    sendJson(object: any): Promise<void>;
-    start({ onMessage, onDone, onError }?: {
+    sendJson(object: unknown): Promise<void>;
+    start({ onMessage, onDone, onError, }?: {
         onMessage?: MessageHandler;
         onDone?: () => void;
-        onError?: (error: any) => void;
+        onError?: (error: unknown) => void;
     }): void;
+    close(): void;
     dispose(): void;
+    private _shutdown;
+    private _runSendLoop;
     onDataReceived(dataPacket: Uint8Array): void;
+    private _dispatchMessage;
 }
-export declare class WebSocketClientProtocol extends Protocol {
+export declare class WebSocketClientProtocol extends Protocol<WebSocketProtocolChannel> {
+    private readonly _url;
+    private readonly _token;
     constructor({ url, token }: {
         url: string;
         token: string;
     });
+    get url(): string;
+    get token(): string;
 }