justrun-ws 0.2.2 → 0.3.0

package/lib/common/DataWrapper.js

@@ -1,29 +1,29 @@
 export class DataWrapper {
     constructor(a, needParse) {
         if (needParse) {
-            this.x = a;
+            this._ = a;
         }
         else {
-            this.y = a;
+            this.A = a;
         }
     }
     get data() {
-        if (!this.y) {
-            this.y = this.decode(this.x);
+        if (!this.A) {
+            this.A = this.decode(this._);
         }
-        return this.y;
+        return this.A;
     }
     set data(b) {
-        this.y = b;
-        this.x = undefined;
+        this.A = b;
+        this._ = undefined;
     }
     get buff() {
-        if (!this.x) {
-            this.x = this.encode(this.y);
+        if (!this._) {
+            this._ = this.encode(this.A);
         }
-        return this.x;
+        return this._;
     }
-    x;
-    y;
+    _;
+    A;
 }
 //# sourceMappingURL=DataWrapper.js.map

package/lib/common/List.js

@@ -1,52 +1,52 @@
 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();
+        this.D = new ListNode();
     }
-    get f() {
-        return this._.getNext();
+    get e() {
+        return this.D.getNext();
     }
     get a() {
-        return this._.getPrev();
+        return this.D.getPrev();
     }
-    P(node) {
-        return node === this._;
+    Y(node) {
+        return node === this.D;
     }
-    Q(node) {
-        node.insertAfter(this._);
+    Z(node) {
+        node.insertAfter(this.D);
     }
-    a6(node) {
-        node.insertBefore(this._);
+    ar(node) {
+        node.insertBefore(this.D);
     }
-    _;
+    D;
 }
 //# sourceMappingURL=List.js.map

package/lib/common/utils.js

@@ -1,18 +1,18 @@
-export const j = (f) => {
-    return new Promise((d) => setTimeout(d, f));
+export const i = (d) => {
+    return new Promise((f) => setTimeout(f, d));
 };
 export const l = () => { };
-export const k = (i = 0x100000000) => {
-    return (Math.random() * i) >>> 0;
+export const j = (e = 0x100000000) => {
+    return (Math.random() * e) >>> 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) => {
+export const z = (h) => {
     let a = 0;
     let b = 0;
     while (a < h.length) {

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 d = new Error(NetErrorString.g);
+export class i {
+    constructor(wrapperCtor, e, f = true) {
+        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 y(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);
@@ -28,13 +28,13 @@ export class n {
             }
         }
         else {
-            b(conn, c);
+            b(conn, d);
         }
         if (conn.context === undefined) {
             await conn.close();
         }
     }
-    async r(conn, message) {
+    async q(conn, message) {
         if (conn.context !== undefined || !this.w) {
             try {
                 return await this.v(conn, message);
@@ -46,29 +46,29 @@ export class n {
             }
         }
         else {
-            b(conn, c);
+            b(conn, d);
         }
     }
-    l;
+    n;
     v;
     w;
 }
-export class o {
-    constructor(wrapperCtor, d, e = true) {
-        this.l = wrapperCtor;
-        this.v = d;
-        this.w = e;
+export class j {
+    constructor(wrapperCtor, e, f = true) {
+        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 y(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 {
@@ -84,7 +84,7 @@ export class o {
             }
         }
         else {
-            error = b(conn, c);
+            error = b(conn, d);
         }
         try {
             if (!error) {
@@ -101,7 +101,7 @@ export class o {
             await conn.close(err);
         }
     }
-    async r(conn, request) {
+    async q(conn, request) {
         if (conn.context !== undefined || !this.w) {
             try {
                 return await this.v(conn, request);
@@ -115,9 +115,9 @@ export class o {
                 }
             }
         }
-        throw b(conn, c);
+        throw b(conn, d);
     }
-    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>;
@@ -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",
@@ -134,9 +132,14 @@ export declare enum NetErrorString {
 	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>;
 export declare class WsClient<PkgTypeT extends number | string> {
-	constructor(getConnStr: (shard?: number) => string, opts: TypedPkgHubOpts<PkgTypeT>);
+	constructor(connUrl: string, opts: TypedPkgHubOpts<PkgTypeT>);
+	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 +147,42 @@ 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;
+	startConnect(delay?: number): Promise<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 _authProvider?;
 	private _connectDelay?;
 	private _listenerArr?;
 }
+export declare class JustrunAuthProvider implements IAuthProvider {
+	constructor(allowAnonymous: boolean, authUrl: string, getConnUrl: (address: string, sid: string, kick?: boolean) => string, authStateCb: (cid: string, sid: 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>;
+	resetKickedState(forceKick: boolean): void;
+	private onConnStatus;
+	private extendToken;
+	private onSysMessage;
+	private readAuthInfo;
+	private sendAuthRequest;
+	private _cid;
+	private _sid;
+	private _allowAnonymous;
+	private _authUrl;
+	private _kickedState;
+	private _currConnAddr;
+	private _conn?;
+	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,57 +1,57 @@
-import { y } from '../common/utils';
+import { z } from '../common/utils';
 import { NetErrorString } from './NetErrorString';
-export class r {
-    o() {
+export class q {
+    b() {
         return null;
     }
-    P(D) {
-        this.D = D;
+    I(H) {
+        this.H = H;
     }
-    async Q(t) {
+    async J(t) {
         return false;
     }
-    async R() {
+    async L() {
         return false;
     }
-    async c(e) {
-        const f = new WebSocket(e);
-        return new Promise((d, i) => {
-            f.onerror = (k) => {
-                i(new Error(NetErrorString.m));
+    async d(e) {
+        const g = new WebSocket(e);
+        return new Promise((f, j) => {
+            g.onerror = (r) => {
+                j(new Error(NetErrorString.l));
             };
-            f.onopen = () => {
-                d(this.a4(f, true));
+            g.onopen = () => {
+                f(this.am(g, 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));
+    am = (g, p) => {
+        const c = new s(g);
+        const { conn, A, o } = this.H(c, p);
+        g.onmessage = (k) => {
+            k.data.arrayBuffer().then((buff) => {
+                A(new Uint8Array(buff));
             });
         };
-        f.onerror = (k) => {
-            n(new Error(NetErrorString.m));
+        g.onerror = (r) => {
+            o(new Error(NetErrorString.l));
         };
-        f.onclose = (j) => {
-            if (j.code === 1000) {
-                n();
+        g.onclose = (k) => {
+            if (k.code === 1000) {
+                o();
             }
             else {
-                n(new Error(j.reason));
+                o(new Error(k.reason));
             }
         };
         return conn;
     };
-    D(a, u) {
+    H(a, u) {
         throw new Error('Need to call "setConnWrapperMaker" before using');
     }
 }
 class s {
-    constructor(f) {
-        this.g = f;
+    constructor(g) {
+        this.i = g;
     }
     get localAddress() {
         return;
@@ -68,36 +68,36 @@ class s {
     get remotePort() {
         return;
     }
-    async N(buff) {
-        if (this.g) {
-            return this.g.send(buff);
+    async D(buff) {
+        if (this.i) {
+            return this.i.send(buff);
         }
-        throw new Error(NetErrorString.l);
+        throw new Error(NetErrorString.m);
     }
-    async p(h) {
-        if (this.g) {
-            const buff = y(h);
-            return this.g.send(buff);
+    async n(h) {
+        if (this.i) {
+            const buff = z(h);
+            return this.i.send(buff);
         }
-        throw new Error(NetErrorString.l);
+        throw new Error(NetErrorString.m);
     }
     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(3000, 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 h {
+    constructor(c) {
+        this.a9 = 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.d()).sendErrorResponse(error, requestId);
     }
     async sendResponse(request, requestId) {
-        return (this.a ?? await this.c()).sendResponse(request, requestId);
+        return (this.a ?? await this.d()).sendResponse(request, requestId);
     }
     async sendMessage(message) {
-        return (this.a ?? await this.c()).sendMessage(message);
+        return (this.a ?? await this.d()).sendMessage(message);
     }
     async sendRequest(request) {
-        return (this.a ?? await this.c()).sendRequest(request);
+        return (this.a ?? await this.d()).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 an() {
         if (!this.a) {
-            await this.c();
+            await this.d();
         }
     }
-    a5() {
+    ao() {
         this.a = undefined;
     }
-    async c() {
-        let { p } = this;
-        if (!p) {
-            p = this.p = new Promise((d, i) => {
-                this.a1().then((conn) => {
+    async d() {
+        let { q } = this;
+        if (!q) {
+            q = this.q = new Promise((f, j) => {
+                this.a9().then((conn) => {
                     if (conn) {
-                        d(conn);
+                        f(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;
+    a9;
     a;
-    p;
+    q;
 }
 //# sourceMappingURL=LazyConn.js.map

package/lib/net/NetErrorString.js

@@ -1,14 +1,14 @@
 export var NetErrorString;
 (function (NetErrorString) {
-    NetErrorString["I"] = "AuthTimeout";
+    NetErrorString["H"] = "AuthTimeout";
     NetErrorString["a"] = "BadRequest";
-    NetErrorString["k"] = "ConnectFailed";
-    NetErrorString["a1"] = "ConnectionClosed";
+    NetErrorString["p"] = "ConnectFailed";
+    NetErrorString["Y"] = "ConnectionClosed";
     NetErrorString["b"] = "InvalidConnString";
-    NetErrorString["l"] = "InvalidConnection";
-    NetErrorString["D"] = "InvalidPackage";
+    NetErrorString["m"] = "InvalidConnection";
+    NetErrorString["$"] = "InvalidPackage";
     NetErrorString["g"] = "NotAuthenticated";
-    NetErrorString["a2"] = "Timeout";
-    NetErrorString["m"] = "UnknownError";
+    NetErrorString["Z"] = "Timeout";
+    NetErrorString["l"] = "UnknownError";
 })(NetErrorString || (NetErrorString = {}));
 //# sourceMappingURL=NetErrorString.js.map