justrun-ws 0.1.2 → 0.2.0

package/lib/handler/SimpleHandler.js

@@ -1,91 +1,88 @@
-import { a, c } from './common';
-export class SimpleMessageHandler {
-    constructor(wrapperCtor, d, e = true) {
-        this.g = wrapperCtor;
-        this.m = d;
-        this.n = e;
+import { c, b } from './common';
+export class j {
+    constructor(wrapperCtor, d, f = true) {
+        this.l = wrapperCtor;
+        this.x = d;
+        this.y = f;
     }
     get pkgType() {
-        return this.g.pkgType;
+        return this.l.pkgType;
     }
-    get pkgName() {
-        return this.g.name;
+    get m() {
+        return this.l.name;
     }
-    async run(conn, parseResult) {
-        const { buff, bodyOffset } = parseResult;
-        const b = buff.subarray(bodyOffset);
-        const message = new this.g(b, true);
-        if (conn.context !== undefined || !this.n) {
+    async $(conn, a) {
+        const { buff, bodyOffset } = a;
+        const h = buff.subarray(bodyOffset);
+        const message = new this.l(h, true);
+        if (conn.context !== undefined || !this.y) {
             try {
-                await this.m(conn, message);
+                await this.x(conn, message);
             }
             catch (err) {
                 if (!err.isError) {
-                    this.wrapUncaughtError(conn, err);
+                    b(conn, err);
                 }
             }
         }
         else {
-            this.wrapUncaughtError(conn, a);
+            b(conn, c);
         }
         if (conn.context === undefined) {
             await conn.close();
         }
     }
-    async runLocal(conn, message) {
-        if (conn.context !== undefined || !this.n) {
+    async r(conn, message) {
+        if (conn.context !== undefined || !this.y) {
             try {
-                return await this.m(conn, message);
+                return await this.x(conn, message);
             }
             catch (err) {
                 if (!err.isError) {
-                    this.wrapUncaughtError(conn, err);
+                    b(conn, err);
                 }
             }
         }
         else {
-            this.wrapUncaughtError(conn, a);
+            b(conn, c);
         }
     }
-    wrapUncaughtError(conn, err) {
-        return c(conn, err);
-    }
-    g;
-    m;
-    n;
+    l;
+    x;
+    y;
 }
-export class h {
-    constructor(wrapperCtor, d, e = true) {
-        this.g = wrapperCtor;
-        this.m = d;
-        this.n = e;
+export class n {
+    constructor(wrapperCtor, d, f = true) {
+        this.l = wrapperCtor;
+        this.x = d;
+        this.y = f;
     }
     get pkgType() {
-        return this.g.pkgType;
+        return this.l.pkgType;
     }
-    get pkgName() {
-        return this.g.name;
+    get m() {
+        return this.l.name;
     }
-    async run(conn, parseResult) {
-        const { buff, requestId, bodyOffset } = parseResult;
-        const b = buff.subarray(bodyOffset);
-        const request = new this.g(b, true);
+    async $(conn, a) {
+        const { buff, requestId, bodyOffset } = a;
+        const h = buff.subarray(bodyOffset);
+        const request = new this.l(h, true);
         let error;
-        if (conn.context !== undefined || !this.n) {
+        if (conn.context !== undefined || !this.y) {
             try {
-                await this.m(conn, request);
+                await this.x(conn, request);
             }
             catch (err) {
                 if (err.isError) {
                     error = err;
                 }
                 else {
-                    error = this.wrapUncaughtError(conn, err);
+                    error = b(conn, err);
                 }
             }
         }
         else {
-            error = this.wrapUncaughtError(conn, a);
+            error = b(conn, c);
         }
         try {
             if (!error) {
@@ -102,27 +99,24 @@ export class h {
             await conn.close(err);
         }
     }
-    async runLocal(conn, request) {
-        if (conn.context !== undefined || !this.n) {
+    async r(conn, request) {
+        if (conn.context !== undefined || !this.y) {
             try {
-                return await this.m(conn, request);
+                return await this.x(conn, request);
             }
             catch (err) {
                 if (err.isError) {
                     throw err;
                 }
                 else {
-                    throw this.wrapUncaughtError(conn, err);
+                    throw b(conn, err);
                 }
             }
         }
-        throw this.wrapUncaughtError(conn, a);
-    }
-    wrapUncaughtError(conn, err) {
-        return c(conn, err);
+        throw b(conn, c);
     }
-    g;
-    m;
-    n;
+    l;
+    x;
+    y;
 }
 //# sourceMappingURL=SimpleHandler.js.map

package/lib/handler/common.js

@@ -1,14 +1,11 @@
 import { JsonError } from '../net/JsonPackageWrapper';
-export class f extends JsonError {
+export class CommonError extends JsonError {
 }
-export const a = { message: 'Connection is not authenticated' };
-let e = (b, err) => {
-    return new f(err.message);
+export const c = new Error('Connection is not authenticated');
+export let b = (a, err) => {
+    return new CommonError(err.message);
 };
-export const c = (conn, err) => {
-    return e(conn, err);
-};
-export const h = (handler) => {
-    e = handler;
+export const handleUncaughtErrorWith = (handler) => {
+    b = handler;
 };
 //# sourceMappingURL=common.js.map

package/lib/index.d.ts

@@ -43,34 +43,6 @@ export declare abstract class RequestWrapper<RequestT, ResponseT> extends PkgWra
 export type ErrorWrapperCtor<ErrorT, WrapperT extends ErrorWrapper<ErrorT> = ErrorWrapper<ErrorT>> = new (error: ErrorT | Uint8Array, needParse?: true) => WrapperT;
 export type MessageWrapperCtor<MessageT, WrapperT extends MessageWrapper<MessageT> = MessageWrapper<MessageT>> = new (message: MessageT | Uint8Array, needParse?: true) => WrapperT;
 export type RequestWrapperCtor<RequestT, ResponseT, WrapperT extends RequestWrapper<RequestT, ResponseT> = RequestWrapper<RequestT, ResponseT>> = new (request: RequestT | Uint8Array, needParse?: true, _response?: ResponseT) => WrapperT;
-export interface AddressInfo {
-	address: string;
-	family: string;
-	port: number;
-}
-export interface IRawPkgConn {
-	readonly localAddress?: string;
-	readonly localPort?: number;
-	readonly remoteAddress?: string;
-	readonly remoteFamily?: string;
-	readonly remotePort?: number;
-	sendPkgBuff(buff: Uint8Array): Promise<void>;
-	sendPkgBuffV(buffVector: Uint8Array[]): Promise<void>;
-	close(err?: Error): Promise<void>;
-	hadClosed(): boolean;
-}
-export interface IPkgConnWrapper<ConnWrapperT> {
-	readonly conn: ConnWrapperT;
-	onPkgBuff: (buff: Uint8Array) => void;
-	onClose: (err?: Error) => void;
-}
-export interface INet<ConnWrapperT> {
-	address(): AddressInfo | null;
-	setConnWrapperMaker(makeWrapper: (conn: IRawPkgConn, isActive?: boolean) => IPkgConnWrapper<ConnWrapperT>): void;
-	startListen(connStr?: string): Promise<boolean>;
-	stopListen(): Promise<boolean>;
-	connect(connStr: string): Promise<ConnWrapperT>;
-}
 export interface IConn<ConnContextT = void> {
 	context?: ConnContextT | undefined;
 	readonly id: number;
@@ -85,90 +57,12 @@ export interface IConn<ConnContextT = void> {
 	sendResponse<RequestT, ResponseT>(request: RequestWrapper<RequestT, ResponseT>, requestId: number): Promise<void>;
 	close(err?: Error): Promise<void>;
 }
-export interface IPkgHub<ConnContextT = void, HubContextT = void> {
-	context?: HubContextT | undefined;
-	address(): AddressInfo | null;
-	getConn(connId: number): IConn<ConnContextT> | undefined;
-	connect(connStr: string): Promise<IConn<ConnContextT>>;
-	connectLocal(): Promise<IConn<ConnContextT>>;
-	startServer(connStr?: string): Promise<boolean>;
-	stopServer(): Promise<boolean>;
-}
 export type ParseResult<PkgTypeT extends number | string> = {
 	buff: Uint8Array;
 	pkgType: PkgTypeT;
 	requestId: number;
 	bodyOffset: number;
 };
-export interface IPkgHandler<PkgTypeT extends number | string, ConnContextT = void> {
-	get pkgType(): PkgTypeT;
-	get pkgName(): string;
-	run(conn: IConn<ConnContextT>, parseResult: ParseResult<PkgTypeT>): void | Promise<void>;
-	wrapUncaughtError(conn: IConn<unknown>, err: Error): ErrorWrapper<unknown>;
-}
-export interface IMessageHandler<PkgTypeT extends number | string, MessageT, WrapperT extends MessageWrapper<MessageT>, ConnContextT = void> extends IPkgHandler<PkgTypeT, ConnContextT> {
-	runLocal(conn: IConn<ConnContextT>, message: WrapperT): void | Promise<void>;
-}
-export interface IRequestHandler<PkgTypeT extends number | string, RequestT, ResponseT, WrapperT extends RequestWrapper<RequestT, ResponseT>, ConnContextT = void> extends IPkgHandler<PkgTypeT, ConnContextT> {
-	runLocal(conn: IConn<ConnContextT>, request: WrapperT): void | Promise<void>;
-}
-export type HandleFunc<WrapperT, ConnContextT> = (conn: IConn<ConnContextT>, wrapper: WrapperT) => void | Promise<void>;
-export declare class SimpleMessageHandler<PkgTypeT extends number | string, MessageT, WrapperT extends MessageWrapper<MessageT>, ConnContextT> implements IMessageHandler<PkgTypeT, MessageT, WrapperT, ConnContextT> {
-	constructor(wrapperCtor: MessageWrapperCtor<MessageT, WrapperT>, handleFunc: HandleFunc<WrapperT, ConnContextT>, checkContext?: boolean);
-	get pkgType(): PkgTypeT;
-	get pkgName(): string;
-	run(conn: IConn<ConnContextT>, parseResult: ParseResult<PkgTypeT>): Promise<void>;
-	runLocal(conn: IConn<ConnContextT>, message: WrapperT): Promise<void>;
-	wrapUncaughtError(conn: IConn<unknown>, err: Error): ErrorWrapper<unknown>;
-	private _wrapperCtor;
-	private _handleFunc;
-	private _checkContext;
-}
-export declare class BrowserWsNet<ConnWrapperT> implements INet<ConnWrapperT> {
-	address(): AddressInfo | null;
-	setConnWrapperMaker(makeWrapper: (conn: IRawPkgConn, isActive?: boolean) => IPkgConnWrapper<ConnWrapperT>): void;
-	startListen(_connStr?: string): Promise<boolean>;
-	stopListen(): Promise<boolean>;
-	connect(connStr: string): Promise<ConnWrapperT>;
-	private setupConn;
-	private makeWrapper;
-}
-export declare const makeNumTypePkgBuff: (pkgType: number, requestId: number, encoded: Uint8Array[]) => void;
-export declare const parseNumTypePkgBuff: (buff: Uint8Array) => ParseResult<number>;
-export declare abstract class JsonError<ErrorT> extends ErrorWrapper<ErrorT> {
-	protected encode(data: ErrorT): Uint8Array;
-	protected decode(buffer: Uint8Array): ErrorT;
-}
-export declare abstract class JsonMessage<MessageT> extends MessageWrapper<MessageT> {
-	protected encode(data: MessageT): Uint8Array;
-	protected decode(buffer: Uint8Array): MessageT;
-}
-export declare abstract class JsonRequest<RequestT, ResponseT> extends RequestWrapper<RequestT, ResponseT> {
-	protected encode(data: RequestT): Uint8Array;
-	protected decode(buffer: Uint8Array): RequestT;
-	protected encodeResponse(response: ResponseT): Uint8Array;
-	protected decodeResponse(buffer: Uint8Array): ResponseT;
-}
-export declare class LazyConn<ConnContextT> implements IConn<ConnContextT> {
-	constructor(connectFunc: () => Promise<IConn<ConnContextT> | undefined>);
-	get id(): number;
-	get context(): ConnContextT | undefined;
-	set context(val: ConnContextT | undefined);
-	localAddress?: string | undefined;
-	localPort?: number | undefined;
-	remoteAddress?: string | undefined;
-	remoteFamily?: string | undefined;
-	remotePort?: number | undefined;
-	sendErrorResponse<ErrorT>(error: ErrorWrapper<ErrorT>, requestId: number): Promise<void>;
-	sendResponse<RequestT, ResponseT>(request: RequestWrapper<RequestT, ResponseT>, requestId: number): Promise<void>;
-	sendMessage<MessageT>(message: MessageWrapper<MessageT>): Promise<void>;
-	sendRequest<RequestT, ResponseT>(request: RequestWrapper<RequestT, ResponseT>): Promise<void>;
-	close(err?: Error): Promise<void>;
-	private connect;
-	private _connectFunc;
-	private _conn?;
-	private _waitingConn?;
-}
 declare class ListNode {
 	constructor();
 	getPrev<SelfT extends ListNode>(this: SelfT): SelfT;
@@ -203,38 +97,57 @@ export type TypedPkgHubOpts<PkgTypeT extends number | string> = {
 	makePkgBuff: (pkgType: PkgTypeT, requestId: number, encoded: Uint8Array[]) => void;
 	parsePkgBuff: (buff: Uint8Array) => ParseResult<PkgTypeT>;
 };
-export declare class TypedPkgHub<PkgTypeT extends number | string, ConnContextT = void, HubContextT = void> implements IPkgHub<ConnContextT, HubContextT> {
-	constructor(net: INet<IConn<ConnContextT>>, opts: TypedPkgHubOpts<PkgTypeT>);
-	readonly responsePkgType: PkgTypeT;
-	context?: HubContextT | undefined;
-	onConnOpen?: (pkgHub: IPkgHub<ConnContextT, HubContextT>, conn: IConn<ConnContextT>, activeOpen: boolean) => void;
-	onConnClose?: (pkgHub: IPkgHub<ConnContextT, HubContextT>, conn: IConn<ConnContextT>, activeClose: boolean, err?: Error) => void;
-	address(): AddressInfo | null;
-	getConn(connId: number): IConn<ConnContextT> | undefined;
-	connect(connStr: string): Promise<IConn<ConnContextT>>;
-	connectLocal(): Promise<IConn<ConnContextT>>;
-	startServer(connStr?: string): Promise<boolean>;
-	stopServer(): Promise<boolean>;
-	sendMessageLocal<MessageT>(conn: IConn<ConnContextT>, message: MessageWrapper<MessageT>): void | Promise<void>;
-	sendRequestLocal<RequestT, ResponseT>(conn: IConn<ConnContextT>, request: RequestWrapper<RequestT, ResponseT>): void | Promise<void>;
+export declare abstract class JsonError<ErrorT> extends ErrorWrapper<ErrorT> {
+	protected encode(data: ErrorT): Uint8Array;
+	protected decode(buffer: Uint8Array): ErrorT;
+}
+export declare abstract class JsonMessage<MessageT> extends MessageWrapper<MessageT> {
+	protected encode(data: MessageT): Uint8Array;
+	protected decode(buffer: Uint8Array): MessageT;
+}
+export declare abstract class JsonRequest<RequestT, ResponseT> extends RequestWrapper<RequestT, ResponseT> {
+	protected encode(data: RequestT): Uint8Array;
+	protected decode(buffer: Uint8Array): RequestT;
+	protected encodeResponse(response: ResponseT): Uint8Array;
+	protected decodeResponse(buffer: Uint8Array): ResponseT;
+}
+export declare class CommonError extends JsonError<string> {
+}
+export interface DoneResp<ResultT extends string | number | boolean = boolean> {
+	result: ResultT;
+}
+export interface IAuthResp {
+	cid: string;
+	token: string;
+	shard?: number;
+}
+export declare const handleUncaughtErrorWith: (handler: (conn: IConn<unknown>, err: Error) => ErrorWrapper<unknown>) => void;
+export declare const createNumPkgTypeClient: (getConnStr: (shard?: number) => string, timeoutMonitor?: TimeoutMonitor) => WsClient<number>;
+export declare class WsClient<PkgTypeT extends number | string> {
+	constructor(getConnStr: (shard?: number) => string, opts: TypedPkgHubOpts<PkgTypeT>);
 	registerError<ErrorT>(pkgType: PkgTypeT, wrapperCtor: ErrorWrapperCtor<ErrorT>): void;
 	registerMessage<MessageT>(pkgType: PkgTypeT, wrapperCtor: MessageWrapperCtor<MessageT>): void;
 	registerRequest<RequestT, ResponseT>(pkgType: PkgTypeT, wrapperCtor: RequestWrapperCtor<RequestT, ResponseT>): void;
-	handleMessageWith<MessageT, WrapperT extends MessageWrapper<MessageT>>(handler: IMessageHandler<PkgTypeT, MessageT, WrapperT, ConnContextT>): IPkgHandler<PkgTypeT, ConnContextT>;
-	handleRequestWith<RequestT, ResponseT, WrapperT extends RequestWrapper<RequestT, ResponseT>>(handler: IRequestHandler<PkgTypeT, RequestT, ResponseT, WrapperT, ConnContextT>): IPkgHandler<PkgTypeT, ConnContextT>;
-	removeHandler(handler: IPkgHandler<PkgTypeT, ConnContextT>): boolean;
-	private connPkgBuffCallback;
-	private connClosedCallback;
-	private onResponse;
-	private _connOpts;
-	private _nextConnId;
-	private _makePkgBuff;
-	private _parsePkgBuff;
-	private _net;
-	private _connMap;
-	private _handlerMap;
-	private _errorWrapperMap;
-	private _timeoutMonitor?;
+	handleMessageWith<MessageT, WrapperT extends MessageWrapper<MessageT>>(wrapperCtor: MessageWrapperCtor<MessageT, WrapperT>, handler: (message: MessageT) => void | Promise<void>): void;
+	handleRequestWith<RequestT, ResponseT, WrapperT extends RequestWrapper<RequestT, ResponseT>>(wrapperCtor: RequestWrapperCtor<RequestT, ResponseT, WrapperT>, handler: (request: RequestT) => ResponseT | Promise<ResponseT>): void;
+	sendMessage<MessageT>(message: MessageWrapper<MessageT>): Promise<void>;
+	sendRequest<RequestT, ResponseT>(request: RequestWrapper<RequestT, ResponseT>): Promise<ResponseT>;
+	sendCustomAuthRequest<RequestT, ResponseT extends IAuthResp>(_request: RequestWrapper<RequestT, ResponseT>): Promise<ResponseT>;
+	resetAuthState(): void;
+	enableAuthenticate(proxyAuthPkgType: PkgTypeT, authStatusCallback: (cid: string) => void, allowAnonymous?: true): void;
+	reconnect(delay?: number): void;
+	onConnectionStatus(listener: (isOpen: boolean, active: boolean, err?: Error) => void): void;
+	private connect;
+	private onConnOpen;
+	private onConnClose;
+	private _pkgHub;
+	private _conn;
+	private _cid;
+	private _connState;
+	private _getConnStr;
+	private _originConnect;
+	private _connectDelay?;
+	private _listenerArr?;
 }
 
 export {};

package/lib/index.js

@@ -1,9 +1,6 @@
-export { SimpleMessageHandler } from './handler/SimpleHandler';
-export { BrowserWsNet } from './net/BrowserWsNet';
-export { makeNumTypePkgBuff, parseNumTypePkgBuff } from './net/hubPkgSerializer';
+export { CommonError, handleUncaughtErrorWith } from './handler/common';
 export { JsonError, JsonMessage, JsonRequest } from './net/JsonPackageWrapper';
-export { LazyConn } from './net/LazyConn';
 export { ErrorWrapper, EventWrapper, MessageWrapper, RequestWrapper } from './net/PackageWrapper';
 export { TimeoutMonitor } from './net/TimeoutMonitor';
-export { TypedPkgHub } from './net/TypedPkgHub';
+export { createNumPkgTypeClient, WsClient } from './WsClient';
 //# sourceMappingURL=index.js.map

package/lib/net/BrowserWsNet.js

@@ -1,53 +1,56 @@
-import { l } from '../common/utils';
-export class BrowserWsNet {
-    address() {
+import { y } from '../common/utils';
+export class l {
+    o() {
         return null;
     }
-    setConnWrapperMaker(makeWrapper) {
-        this.makeWrapper = makeWrapper;
+    N(C) {
+        this.C = C;
     }
-    async startListen(_connStr) {
+    async O(r) {
         return false;
     }
-    async stopListen() {
+    async P() {
         return false;
     }
-    async connect(connStr) {
-        const c = new WebSocket(connStr);
-        return new Promise((f, g) => {
-            c.onerror = (h) => {
-                g(new Error('WebSocket error'));
+    async c(d) {
+        const e = new WebSocket(d);
+        return new Promise((f, i) => {
+            e.onerror = (k) => {
+                i(new Error('WebSocket error'));
             };
-            c.onopen = () => {
-                f(this.L(c, true));
+            e.onopen = () => {
+                f(this.a9(e, true));
             };
         });
     }
-    L = (c, isActive) => {
-        const a = new i(c);
-        const { conn, onPkgBuff, onClose } = this.makeWrapper(a, isActive);
-        c.onmessage = (e) => {
-            e.data.arrayBuffer().then((buff) => {
-                onPkgBuff(new Uint8Array(buff));
+    a9 = (e, q) => {
+        const b = new m(e);
+        const { conn, D, n } = this.C(b, q);
+        e.onmessage = (j) => {
+            j.data.arrayBuffer().then((buff) => {
+                D(new Uint8Array(buff));
             });
         };
-        c.onerror = (h) => {
-            onClose(new Error('WebSocket error'));
+        e.onerror = (k) => {
+            n(new Error('WebSocket error'));
         };
-        c.onclose = (e) => {
-            if (e.code === 1000) {
-                onClose();
+        e.onclose = (j) => {
+            if (j.code === 1000) {
+                n();
+            }
+            else {
+                n(new Error(j.reason));
             }
         };
         return conn;
     };
-    makeWrapper(b, j) {
+    C(a, s) {
         throw new Error('Need to call "setConnWrapperMaker" before using');
     }
 }
-class i {
-    constructor(c) {
-        this.d = c;
+class m {
+    constructor(e) {
+        this.g = e;
     }
     get localAddress() {
         return;
@@ -64,36 +67,36 @@ class i {
     get remotePort() {
         return;
     }
-    async sendPkgBuff(buff) {
-        if (this.d) {
-            return this.d.send(buff);
+    async I(buff) {
+        if (this.g) {
+            return this.g.send(buff);
         }
         throw new Error('Invalid socket');
     }
-    async sendPkgBuffV(buffVector) {
-        if (this.d) {
-            const buff = l(buffVector);
-            return this.d.send(buff);
+    async p(h) {
+        if (this.g) {
+            const buff = y(h);
+            return this.g.send(buff);
         }
         throw new Error('Invalid socket');
     }
     async close(err) {
-        const { d } = this;
-        if (d) {
-            this.d = undefined;
+        const { g } = this;
+        if (g) {
+            this.g = undefined;
             if (!err) {
-                if (d.readyState === WebSocket.OPEN) {
-                    d.close(1000);
+                if (g.readyState === WebSocket.OPEN) {
+                    g.close(1000);
                 }
             }
             else {
-                d.close(3000, err.message);
+                g.close(3000, err.message);
             }
         }
     }
-    hadClosed() {
-        return !this.d;
+    J() {
+        return !this.g;
     }
-    d;
+    g;
 }
 //# sourceMappingURL=BrowserWsNet.js.map

package/lib/net/LazyConn.js

@@ -1,16 +1,16 @@
-export class LazyConn {
-    constructor(c) {
-        this.A = c;
+export class g {
+    constructor(d) {
+        this.a1 = d;
     }
     get id() {
-        return this.b?.id ?? -1;
+        return this.a?.id ?? -1;
     }
     get context() {
-        return this.b?.context;
+        return this.a?.context;
     }
-    set context(a) {
-        if (this.b) {
-            this.b.context = a;
+    set context(b) {
+        if (this.a) {
+            this.a.context = b;
         }
     }
     localAddress;
@@ -19,48 +19,59 @@ export class LazyConn {
     remoteFamily;
     remotePort;
     async sendErrorResponse(error, requestId) {
-        return (this.b ?? await this.connect()).sendErrorResponse(error, requestId);
+        return (this.a ?? await this.c()).sendErrorResponse(error, requestId);
     }
     async sendResponse(request, requestId) {
-        return (this.b ?? await this.connect()).sendResponse(request, requestId);
+        return (this.a ?? await this.c()).sendResponse(request, requestId);
     }
     async sendMessage(message) {
-        return (this.b ?? await this.connect()).sendMessage(message);
+        return (this.a ?? await this.c()).sendMessage(message);
     }
     async sendRequest(request) {
-        return (this.b ?? await this.connect()).sendRequest(request);
+        return (this.a ?? await this.c()).sendRequest(request);
     }
     async close(err) {
-        const { b } = this;
-        if (b) {
-            this.b = undefined;
-            await b.close(err);
+        const { a } = this;
+        if (a) {
+            this.a = undefined;
+            await a.close(err);
             return;
         }
-        if (this.i) {
-            await this.i.then((conn) => conn.close(err).then(() => this.b = undefined), () => this.b = undefined);
+        if (this.p) {
+            await this.p.then((conn) => {
+                this.a = undefined;
+                conn.close(err);
+            }, () => this.a = undefined);
         }
     }
-    async connect() {
-        let { i } = this;
-        if (!i) {
-            i = this.i = new Promise((f, g) => {
-                this.A().then((conn) => {
+    async reconnect() {
+        if (!this.a) {
+            await this.c();
+        }
+    }
+    aa() {
+        this.a = undefined;
+    }
+    async c() {
+        let { p } = this;
+        if (!p) {
+            p = this.p = new Promise((f, i) => {
+                this.a1().then((conn) => {
                     if (conn) {
                         f(conn);
-                        this.b = conn;
-                        this.i = undefined;
+                        this.a = conn;
+                        this.p = undefined;
                     }
                     else {
-                        g(new Error('Connect failed'));
+                        i(new Error('Connect failed'));
                     }
                 });
             });
         }
-        return await i;
+        return await p;
     }
-    A;
-    b;
-    i;
+    a1;
+    a;
+    p;
 }
 //# sourceMappingURL=LazyConn.js.map