justrun-ws 0.2.3 → 0.3.1

package/lib/common/List.js

@@ -1,50 +1,50 @@
 export class ListNode {
     constructor() {
-        this.e = this;
-        this.i = this;
+        this.b = this;
+        this.j = this;
     }
     getPrev() {
-        return this.e;
+        return this.b;
     }
     getNext() {
-        return this.i;
+        return this.j;
     }
     insertBefore(node) {
-        this.i = node;
-        this.e = node.e;
-        node.e = this;
-        this.e.i = this;
+        this.j = node;
+        this.b = node.b;
+        node.b = this;
+        this.b.j = this;
     }
     insertAfter(node) {
-        this.e = node;
-        this.i = node.i;
-        node.i = this;
-        this.i.e = this;
+        this.b = node;
+        this.j = node.j;
+        node.j = this;
+        this.j.b = this;
     }
     remove() {
-        this.e.i = this.i;
-        this.i.e = this.e;
+        this.b.j = this.j;
+        this.j.b = this.b;
     }
-    e;
-    i;
+    b;
+    j;
 }
 export class c {
     constructor() {
         this._ = new ListNode();
     }
-    get f() {
+    get e() {
         return this._.getNext();
     }
     get a() {
         return this._.getPrev();
     }
-    P(node) {
+    V(node) {
         return node === this._;
     }
-    Q(node) {
+    W(node) {
         node.insertAfter(this._);
     }
-    a6(node) {
+    am(node) {
         node.insertBefore(this._);
     }
     _;

package/lib/common/utils.js

@@ -1,16 +1,16 @@
-export const j = (f) => {
-    return new Promise((d) => setTimeout(d, f));
+export const i = (e) => {
+    return new Promise((d) => setTimeout(d, e));
 };
 export const l = () => { };
-export const k = (i = 0x100000000) => {
-    return (Math.random() * i) >>> 0;
+export const j = (g = 0x100000000) => {
+    return (Math.random() * g) >>> 0;
 };
-export const m = (e) => {
-    let c = 5381, a = 0;
-    while (a < e.length) {
-        c = ((c << 5) + c) + e.charCodeAt(a++);
+export const k = (c) => {
+    let hash = 5381, a = 0;
+    while (a < c.length) {
+        hash = ((hash << 5) + hash) + c.charCodeAt(a++);
     }
-    return c >>> 0;
+    return hash >>> 0;
 };
 export const y = (h) => {
     let a = 0;
@@ -18,13 +18,13 @@ export const y = (h) => {
     while (a < h.length) {
         b += h[a++].length;
     }
-    const g = new Uint8Array(b);
+    const f = new Uint8Array(b);
     b = 0;
     while (a > 0) {
         const buff = h[--a];
-        g.set(buff, b);
+        f.set(buff, b);
         b += buff.length;
     }
-    return g;
+    return f;
 };
 //# sourceMappingURL=utils.js.map

package/lib/common/varUintOps.js

@@ -1,34 +1,34 @@
 export const o = (b) => {
-    let g = 1;
+    let f = 1;
     while (b >>>= 7) {
-        g++;
+        f++;
     }
-    return g;
+    return f;
 };
 export const j = (i) => {
     let b;
     let a = 0;
-    let g = 0;
+    let f = 0;
     while (a < i.length) {
-        g++;
+        f++;
         b = i[a++];
         while (b >>>= 7) {
-            g++;
+            f++;
         }
     }
-    return g;
+    return f;
 };
 export const p = (buffer, e = 0) => {
     let c;
     let d = e;
     let b = 0;
-    let f = 0;
+    let g = 0;
     do {
         c = buffer[d++];
-        b |= (c & 127) << f;
-        f += 7;
+        b |= (c & 127) << g;
+        g += 7;
     } while (c & 128);
-    if (c !== undefined && f <= 35) {
+    if (c !== undefined && g <= 35) {
         return {
             b: b,
             k: d - e,
@@ -43,18 +43,18 @@ export const l = (n, buffer, e = 0) => {
     let c;
     let d = e;
     let b = 0;
-    let f = 0;
+    let g = 0;
     const h = [];
     for (a = 0; a < n; a++) {
         do {
             c = buffer[d++];
-            b |= (c & 127) << f;
-            f += 7;
+            b |= (c & 127) << g;
+            g += 7;
         } while (c & 128);
-        if (c !== undefined && f <= 35) {
+        if (c !== undefined && g <= 35) {
             h.push(b);
             b = 0;
-            f = 0;
+            g = 0;
         }
         else {
             throw new Error('Parsing failed');

package/lib/handler/SimpleHandler.js

@@ -1,22 +1,22 @@
 import { NetErrorString } from '../net/NetErrorString';
 import { b } from './common';
-const c = new Error(NetErrorString.g);
-export class n {
-    constructor(wrapperCtor, d, e = true) {
-        this.l = wrapperCtor;
-        this.v = d;
-        this.w = e;
+const c = new Error(NetErrorString.NotAuthenticated);
+export class h {
+    constructor(wrapperCtor, e, f) {
+        this.n = wrapperCtor;
+        this.v = e;
+        this.w = !f;
     }
     get pkgType() {
-        return this.l.pkgType;
+        return this.n.pkgType;
     }
-    get m() {
-        return this.l.name;
+    get k() {
+        return this.n.name;
     }
-    async _(conn, a) {
+    async x(conn, a) {
         const { buff, bodyOffset } = a;
-        const h = buff.subarray(bodyOffset);
-        const message = new this.l(h, true);
+        const body = buff.subarray(bodyOffset);
+        const message = new this.n(body, true);
         if (conn.context !== undefined || !this.w) {
             try {
                 await this.v(conn, message);
@@ -34,7 +34,7 @@ export class n {
             await conn.close();
         }
     }
-    async r(conn, message) {
+    async q(conn, message) {
         if (conn.context !== undefined || !this.w) {
             try {
                 return await this.v(conn, message);
@@ -49,26 +49,26 @@ export class n {
             b(conn, c);
         }
     }
-    l;
+    n;
     v;
     w;
 }
-export class o {
-    constructor(wrapperCtor, d, e = true) {
-        this.l = wrapperCtor;
-        this.v = d;
-        this.w = e;
+export class i {
+    constructor(wrapperCtor, e, f) {
+        this.n = wrapperCtor;
+        this.v = e;
+        this.w = !f;
     }
     get pkgType() {
-        return this.l.pkgType;
+        return this.n.pkgType;
     }
-    get m() {
-        return this.l.name;
+    get k() {
+        return this.n.name;
     }
-    async _(conn, a) {
+    async x(conn, a) {
         const { buff, requestId, bodyOffset } = a;
-        const h = buff.subarray(bodyOffset);
-        const request = new this.l(h, true);
+        const body = buff.subarray(bodyOffset);
+        const request = new this.n(body, true);
         let error;
         if (conn.context !== undefined || !this.w) {
             try {
@@ -97,11 +97,11 @@ export class o {
                 await conn.close();
             }
         }
-        catch (err) {
-            await conn.close(err);
+        catch {
+            return;
         }
     }
-    async r(conn, request) {
+    async q(conn, request) {
         if (conn.context !== undefined || !this.w) {
             try {
                 return await this.v(conn, request);
@@ -117,7 +117,7 @@ export class o {
         }
         throw b(conn, c);
     }
-    l;
+    n;
     v;
     w;
 }

package/lib/index.d.ts

@@ -1,5 +1,12 @@
 // Generated by dts-bundle-generator v9.5.1
 
+export interface ISocket {
+	readonly localAddress?: string;
+	readonly localPort?: number;
+	readonly remoteAddress?: string;
+	readonly remoteFamily?: string;
+	readonly remotePort?: number;
+}
 export interface IWrapper<DataT> {
 	get buff(): Uint8Array;
 	get data(): DataT;
@@ -46,11 +53,7 @@ export type RequestWrapperCtor<RequestT, ResponseT, WrapperT extends RequestWrap
 export interface IConn<ConnContextT = void> {
 	context?: ConnContextT | undefined;
 	readonly id: number;
-	readonly localAddress?: string;
-	readonly localPort?: number;
-	readonly remoteAddress?: string;
-	readonly remoteFamily?: string;
-	readonly remotePort?: number;
+	readonly socket?: ISocket;
 	sendMessage<MessageT>(message: MessageWrapper<MessageT>): Promise<void>;
 	sendRequest<RequestT, ResponseT>(request: RequestWrapper<RequestT, ResponseT>): Promise<void>;
 	sendErrorResponse<ErrorT>(error: ErrorWrapper<ErrorT>, requestId: number): Promise<void>;
@@ -73,18 +76,18 @@ declare class ListNode {
 	private _prev;
 	private _next;
 }
-declare abstract class MonitorConn extends ListNode {
-	abstract keepAlive(): void;
-	abstract timeout(): void;
+declare abstract class MonitorItem extends ListNode {
+	abstract warnTimeout(): void;
+	abstract onTimeout(): void;
 }
 export declare class TimeoutMonitor {
-	constructor(tickMilSec: number, aliveTick: number, timeoutTick: number);
-	insert(conn: MonitorConn): void;
-	update(conn: MonitorConn): void;
-	remove(conn: MonitorConn): void;
+	constructor(tickMilSec: number, warningTick: number, timeoutTick: number);
+	insert(item: MonitorItem): void;
+	update(item: MonitorItem): void;
+	remove(item: MonitorItem): void;
 	private check;
 	private _tickMilSec;
-	private _aliveTick;
+	private _warningTick;
 	private _timeoutTick;
 	private _currentTick;
 	private _monitorCount;
@@ -116,11 +119,6 @@ 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",
@@ -131,12 +129,24 @@ export declare enum NetErrorString {
 	InvalidConnection = "InvalidConnection",
 	InvalidPackage = "InvalidPackage",
 	NotAuthenticated = "NotAuthenticated",
+	NotFound = "NotFound",
 	Timeout = "Timeout",
 	UnknownError = "UnknownError"
 }
-export declare const createNumPkgTypeClient: (getConnStr: (shard?: number) => string, timeoutMonitor?: TimeoutMonitor) => WsClient<number>;
+export interface IAuthProvider {
+	init<PkgTypeT extends number | string>(proxyPrivatePkgType: PkgTypeT, client: WsClient<PkgTypeT>): Promise<void>;
+	preConnect(): Promise<string>;
+}
+export declare const createNumPkgTypeClient: (connUrl: string, timeoutMonitor?: TimeoutMonitor) => WsClient<number>;
+declare enum ClientConnState {
+	NotConnected = 0,
+	Connecting = 1,
+	Connected = 2
+}
 export declare class WsClient<PkgTypeT extends number | string> {
-	constructor(getConnStr: (shard?: number) => string, opts: TypedPkgHubOpts<PkgTypeT>);
+	constructor(connUrl: string, opts: TypedPkgHubOpts<PkgTypeT>);
+	getConnState(): ClientConnState;
+	enableAuthenticate(proxyPrivatePkgType: PkgTypeT, authProvider: IAuthProvider): void;
 	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;
@@ -144,22 +154,39 @@ export declare class WsClient<PkgTypeT extends number | string> {
 	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;
+	onConnectionStatus(listener: (isOpen: boolean, conn: IConn<string>, active: boolean, err?: Error) => void): void;
 	private connect;
 	private onConnOpen;
 	private onConnClose;
+	private _connUrl;
 	private _pkgHub;
 	private _conn;
-	private _cid;
 	private _connState;
-	private _getConnStr;
-	private _originConnect;
-	private _connectDelay?;
+	private _authProvider?;
 	private _listenerArr?;
 }
+export declare class JustrunAuthProvider implements IAuthProvider {
+	constructor(authUrl: string, getConnUrl: (address: string, sid: string, kick?: boolean) => string, authStateCb: (cid: string, sid: string, connErr?: string) => void);
+	init<PkgTypeT extends number | string>(proxyPrivatePkgType: PkgTypeT, client: WsClient<PkgTypeT>): Promise<void>;
+	preConnect(): Promise<string>;
+	authWithCredential(type: "signin" | "signup", id: string, hash: string, extra: string): Promise<void>;
+	authWithOAuth2(returnTo: string, oauthUrl: string, clientId: string, scope: string): void;
+	resetAuthState(): Promise<void>;
+	resetConnState(forceKick: boolean): void;
+	private onConnStatus;
+	private extendToken;
+	private onSysMessage;
+	private readAuthInfo;
+	private sendAuthRequest;
+	private _cid;
+	private _sid;
+	private _authUrl;
+	private _currConnAddr;
+	private _conn?;
+	private _connErr?;
+	private _extendTokenTimer?;
+	private _getConnUrl;
+	private _authStateCb;
+}
 
 export {};

package/lib/index.js

@@ -3,5 +3,6 @@ export { JsonError, JsonMessage, JsonRequest } from './net/JsonPackageWrapper';
 export { NetErrorString } from './net/NetErrorString';
 export { ErrorWrapper, EventWrapper, MessageWrapper, RequestWrapper } from './net/PackageWrapper';
 export { TimeoutMonitor } from './net/TimeoutMonitor';
+export { JustrunAuthProvider } from './JustRunAuthProvider';
 export { createNumPkgTypeClient, WsClient } from './WsClient';
 //# sourceMappingURL=index.js.map

package/lib/net/BrowserWsNet.js

@@ -1,103 +1,97 @@
 import { y } from '../common/utils';
 import { NetErrorString } from './NetErrorString';
-export class r {
-    o() {
+export class m {
+    b() {
         return null;
     }
-    P(D) {
-        this.D = D;
+    init(E) {
+        this.E = E;
     }
-    async Q(t) {
+    async I(r) {
         return false;
     }
-    async R() {
+    async J() {
         return false;
     }
-    async c(e) {
-        const f = new WebSocket(e);
-        return new Promise((d, i) => {
-            f.onerror = (k) => {
-                i(new Error(NetErrorString.m));
+    async g(c) {
+        const f = new WebSocket(c);
+        return new Promise((d, j) => {
+            f.onerror = (l) => {
+                j(new Error(NetErrorString.UnknownError));
             };
             f.onopen = () => {
-                d(this.a4(f, true));
+                d(this.ai(f, true));
             };
         });
     }
-    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));
+    ai = (f, p) => {
+        const e = new q(f);
+        const { conn, _, o } = this.E(e, p);
+        f.onmessage = (k) => {
+            k.data.arrayBuffer().then((buff) => {
+                _(new Uint8Array(buff));
             });
         };
-        f.onerror = (k) => {
-            n(new Error(NetErrorString.m));
+        f.onerror = (l) => {
+            o(new Error(NetErrorString.UnknownError));
         };
-        f.onclose = (j) => {
-            if (j.code === 1000) {
-                n();
+        f.onclose = (k) => {
+            if (k.code === 1000) {
+                o();
             }
             else {
-                n(new Error(j.reason));
+                o(new Error(k.reason));
             }
         };
         return conn;
     };
-    D(a, u) {
+    E(a, s) {
         throw new Error('Need to call "setConnWrapperMaker" before using');
     }
 }
-class s {
+class q {
     constructor(f) {
-        this.g = f;
-    }
-    get localAddress() {
-        return;
-    }
-    get localPort() {
-        return;
-    }
-    get remoteAddress() {
-        return;
-    }
-    get remoteFamily() {
-        return;
-    }
-    get remotePort() {
-        return;
+        this.i = f;
+    }
+    get socket() {
+        return {
+            localAddress: '',
+            localPort: 0,
+            remoteAddress: '',
+            remoteFamily: '',
+            remotePort: 0,
+        };
     }
-    async N(buff) {
-        if (this.g) {
-            return this.g.send(buff);
+    async F(buff) {
+        if (this.i) {
+            return this.i.send(buff);
         }
-        throw new Error(NetErrorString.l);
+        throw new Error(NetErrorString.InvalidConnection);
     }
-    async p(h) {
-        if (this.g) {
+    async n(h) {
+        if (this.i) {
             const buff = y(h);
-            return this.g.send(buff);
+            return this.i.send(buff);
         }
-        throw new Error(NetErrorString.l);
+        throw new Error(NetErrorString.InvalidConnection);
     }
     async close(err) {
-        const { g } = this;
-        if (g) {
-            this.g = undefined;
+        const { i } = this;
+        if (i) {
+            this.i = undefined;
             if (!err) {
-                if (g.readyState === WebSocket.OPEN) {
-                    g.close(1000);
+                if (i.readyState <= WebSocket.OPEN) {
+                    i.close(1000);
                 }
             }
             else {
-                g.close(3000, err.message);
+                i.close(1006, err.message);
             }
         }
     }
-    O() {
-        return !this.g;
+    G() {
+        return !this.i;
     }
-    g;
+    i;
 }
 //# sourceMappingURL=BrowserWsNet.js.map

package/lib/net/LazyConn.js

@@ -1,6 +1,6 @@
-export class g {
-    constructor(e) {
-        this.a1 = e;
+export class e {
+    constructor(c) {
+        this.a6 = c;
     }
     get id() {
         return this.a?.id ?? -1;
@@ -19,16 +19,16 @@ export class g {
     remoteFamily;
     remotePort;
     async sendErrorResponse(error, requestId) {
-        return (this.a ?? await this.c()).sendErrorResponse(error, requestId);
+        return (this.a ?? await this.g()).sendErrorResponse(error, requestId);
     }
     async sendResponse(request, requestId) {
-        return (this.a ?? await this.c()).sendResponse(request, requestId);
+        return (this.a ?? await this.g()).sendResponse(request, requestId);
     }
     async sendMessage(message) {
-        return (this.a ?? await this.c()).sendMessage(message);
+        return (this.a ?? await this.g()).sendMessage(message);
     }
     async sendRequest(request) {
-        return (this.a ?? await this.c()).sendRequest(request);
+        return (this.a ?? await this.g()).sendRequest(request);
     }
     async close(err) {
         const { a } = this;
@@ -37,41 +37,41 @@ export class g {
             await a.close(err);
             return;
         }
-        if (this.p) {
-            await this.p.then((conn) => {
+        if (this.q) {
+            await this.q.then((conn) => {
                 this.a = undefined;
                 conn.close(err);
             }, () => this.a = undefined);
         }
     }
-    async reconnect() {
+    async aq() {
         if (!this.a) {
-            await this.c();
+            await this.g();
         }
     }
-    a5() {
+    aj() {
         this.a = undefined;
     }
-    async c() {
-        let { p } = this;
-        if (!p) {
-            p = this.p = new Promise((d, i) => {
-                this.a1().then((conn) => {
+    async g() {
+        let { q } = this;
+        if (!q) {
+            q = this.q = new Promise((d, j) => {
+                this.a6().then((conn) => {
                     if (conn) {
                         d(conn);
                         this.a = conn;
-                        this.p = undefined;
+                        this.q = undefined;
                     }
                     else {
-                        i(new Error('Connect failed'));
+                        j(new Error('Connect failed'));
                     }
                 });
             });
         }
-        return await p;
+        return await q;
     }
-    a1;
+    a6;
     a;
-    p;
+    q;
 }
 //# sourceMappingURL=LazyConn.js.map