justrun-ws 0.1.3 → 0.2.1

package/lib/handler/SimpleHandler.js

@@ -1,88 +1,90 @@
-import { c, a } from './common';
-export class SimpleMessageHandler {
+import { NetErrorString } from '../net/NetErrorString';
+import { b } from './common';
+const c = new Error(NetErrorString.g);
+export class n {
     constructor(wrapperCtor, d, e = true) {
-        this.g = wrapperCtor;
-        this.m = d;
-        this.n = e;
+        this.l = wrapperCtor;
+        this.v = d;
+        this.w = e;
     }
     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.w) {
             try {
-                await this.m(conn, message);
+                await this.v(conn, message);
             }
             catch (err) {
                 if (!err.isError) {
-                    a(conn, err);
+                    b(conn, err);
                 }
             }
         }
         else {
-            a(conn, c);
+            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.w) {
             try {
-                return await this.m(conn, message);
+                return await this.v(conn, message);
             }
             catch (err) {
                 if (!err.isError) {
-                    a(conn, err);
+                    b(conn, err);
                 }
             }
         }
         else {
-            a(conn, c);
+            b(conn, c);
         }
     }
-    g;
-    m;
-    n;
+    l;
+    v;
+    w;
 }
-export class h {
+export class o {
     constructor(wrapperCtor, d, e = true) {
-        this.g = wrapperCtor;
-        this.m = d;
-        this.n = e;
+        this.l = wrapperCtor;
+        this.v = d;
+        this.w = e;
     }
     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.w) {
             try {
-                await this.m(conn, request);
+                await this.v(conn, request);
             }
             catch (err) {
                 if (err.isError) {
                     error = err;
                 }
                 else {
-                    error = a(conn, err);
+                    error = b(conn, err);
                 }
             }
         }
         else {
-            error = a(conn, c);
+            error = b(conn, c);
         }
         try {
             if (!error) {
@@ -99,24 +101,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.w) {
             try {
-                return await this.m(conn, request);
+                return await this.v(conn, request);
             }
             catch (err) {
                 if (err.isError) {
                     throw err;
                 }
                 else {
-                    throw a(conn, err);
+                    throw b(conn, err);
                 }
             }
         }
-        throw a(conn, c);
+        throw b(conn, c);
     }
-    g;
-    m;
-    n;
+    l;
+    v;
+    w;
 }
 //# sourceMappingURL=SimpleHandler.js.map

package/lib/handler/common.js

@@ -1,11 +1,10 @@
 import { JsonError } from '../net/JsonPackageWrapper';
 export class CommonError extends JsonError {
 }
-export const c = new Error('Connection is not authenticated');
-export let a = (b, err) => {
+export let b = (a, err) => {
     return new CommonError(err.message);
 };
 export const handleUncaughtErrorWith = (handler) => {
-    a = 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,97 +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>;
-}
-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 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 ClientPkg {
-	cid: string;
-}
-export declare const handleUncaughtErrorWith: (handler: (conn: IConn<unknown>, err: Error) => ErrorWrapper<unknown>) => 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>;
-	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 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;
@@ -210,38 +97,69 @@ 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 enum NetErrorString {
+	AuthTimeout = "AuthTimeout",
+	BadRequest = "BadRequest",
+	ConnectFailed = "ConnectFailed",
+	ConnectionClosed = "ConnectionClosed",
+	InvalidConnString = "InvalidConnString",
+	InvalidConnection = "InvalidConnection",
+	InvalidPackage = "InvalidPackage",
+	NotAuthenticated = "NotAuthenticated",
+	Timeout = "Timeout",
+	UnknownError = "UnknownError"
+}
+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,10 +1,7 @@
 export { CommonError, handleUncaughtErrorWith } from './handler/common';
-export { SimpleMessageHandler } from './handler/SimpleHandler';
-export { BrowserWsNet } from './net/BrowserWsNet';
-export { makeNumTypePkgBuff, parseNumTypePkgBuff } from './net/hubPkgSerializer';
 export { JsonError, JsonMessage, JsonRequest } from './net/JsonPackageWrapper';
-export { LazyConn } from './net/LazyConn';
+export { NetErrorString } from './net/NetErrorString';
 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,57 @@
-import { l } from '../common/utils';
-export class BrowserWsNet {
-    address() {
+import { y } from '../common/utils';
+import { NetErrorString } from './NetErrorString';
+export class r {
+    o() {
         return null;
     }
-    setConnWrapperMaker(makeWrapper) {
-        this.makeWrapper = makeWrapper;
+    P(D) {
+        this.D = D;
     }
-    async startListen(_connStr) {
+    async Q(t) {
         return false;
     }
-    async stopListen() {
+    async R() {
         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(e) {
+        const f = new WebSocket(e);
+        return new Promise((d, i) => {
+            f.onerror = (k) => {
+                i(new Error(NetErrorString.m));
             };
-            c.onopen = () => {
-                f(this.L(c, true));
+            f.onopen = () => {
+                d(this.a4(f, 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));
+    a4 = (f, q) => {
+        const b = new s(f);
+        const { conn, E, n } = this.D(b, q);
+        f.onmessage = (j) => {
+            j.data.arrayBuffer().then((buff) => {
+                E(new Uint8Array(buff));
             });
         };
-        c.onerror = (h) => {
-            onClose(new Error('WebSocket error'));
+        f.onerror = (k) => {
+            n(new Error(NetErrorString.m));
         };
-        c.onclose = (e) => {
-            if (e.code === 1000) {
-                onClose();
+        f.onclose = (j) => {
+            if (j.code === 1000) {
+                n();
+            }
+            else {
+                n(new Error(j.reason));
             }
         };
         return conn;
     };
-    makeWrapper(b, j) {
+    D(a, u) {
         throw new Error('Need to call "setConnWrapperMaker" before using');
     }
 }
-class i {
-    constructor(c) {
-        this.d = c;
+class s {
+    constructor(f) {
+        this.g = f;
     }
     get localAddress() {
         return;
@@ -64,36 +68,36 @@ class i {
     get remotePort() {
         return;
     }
-    async sendPkgBuff(buff) {
-        if (this.d) {
-            return this.d.send(buff);
+    async N(buff) {
+        if (this.g) {
+            return this.g.send(buff);
         }
-        throw new Error('Invalid socket');
+        throw new Error(NetErrorString.l);
     }
-    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');
+        throw new Error(NetErrorString.l);
     }
     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;
+    O() {
+        return !this.g;
     }
-    d;
+    g;
 }
 //# sourceMappingURL=BrowserWsNet.js.map