justrun-ws 0.1.3 → 0.2.1

package/lib/net/LazyConn.js

@@ -1,16 +1,16 @@
-export class LazyConn {
-    constructor(c) {
-        this.A = c;
+export class g {
+    constructor(e) {
+        this.a1 = e;
     }
     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();
+        }
+    }
+    a5() {
+        this.a = undefined;
+    }
+    async c() {
+        let { p } = this;
+        if (!p) {
+            p = this.p = new Promise((d, i) => {
+                this.a1().then((conn) => {
                     if (conn) {
-                        f(conn);
-                        this.b = conn;
-                        this.i = undefined;
+                        d(conn);
+                        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

package/lib/net/NetErrorString.js

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

package/lib/net/PackageWrapper.js

@@ -39,33 +39,33 @@ class EventWrapper extends PkgWrapper {
     }
 }
 class RequestWrapper extends PkgWrapper {
-    constructor(b, needParse) {
-        super(b, needParse);
+    constructor(a, needParse) {
+        super(a, needParse);
     }
     isRequest() {
         return true;
     }
     get resp() {
-        if (!this.r) {
-            this.r = this.decodeResponse(this.s);
+        if (!this.z) {
+            this.z = this.decodeResponse(this.$);
         }
-        return this.r;
+        return this.z;
     }
-    set resp(a) {
-        this.r = a;
-        this.s = undefined;
+    set resp(b) {
+        this.z = b;
+        this.$ = undefined;
     }
     get respBuff() {
-        if (!this.s) {
-            this.s = this.encodeResponse(this.r);
+        if (!this.$) {
+            this.$ = this.encodeResponse(this.z);
         }
-        return this.s;
+        return this.$;
     }
-    set respBuff(a) {
-        this.r = undefined;
-        this.s = a;
+    set respBuff(b) {
+        this.z = undefined;
+        this.$ = b;
     }
-    r;
-    s;
+    z;
+    $;
 }
 //# sourceMappingURL=PackageWrapper.js.map

package/lib/net/TimeoutMonitor.js

@@ -1,70 +1,70 @@
 import { ListNode, c } from '../common/List';
-import { i } from '../common/utils';
+import { l } from '../common/utils';
 export class MonitorConn extends ListNode {
 }
 export class TimeoutMonitor {
-    constructor(e, h, f) {
-        this.D = e;
-        this.y = h;
-        this.w = f;
-        this.j = 0;
-        this.x = 0;
-        this.o = [];
+    constructor(e, h, g) {
+        this.R = e;
+        this.I = h;
+        this.E = g;
+        this.o = 0;
+        this.F = 0;
+        this.r = [];
         if (e === 0) {
-            this.insert = i;
-            this.update = i;
-            this.remove = i;
+            this.insert = l;
+            this.update = l;
+            this.remove = l;
             return;
         }
-        for (let b = 0; b < f; b++) {
-            this.o.push(new c());
+        for (let a = 0; a < g; a++) {
+            this.r.push(new c());
         }
     }
     insert(conn) {
-        if (!this.x) {
-            this.E = setInterval(this.M, this.D);
+        if (!this.F) {
+            this.S = setInterval(this.a2, this.R);
         }
-        this.x++;
-        this.o[this.j].C(conn);
+        this.F++;
+        this.r[this.o].Q(conn);
     }
     update(conn) {
         conn.remove();
-        this.o[this.j].C(conn);
+        this.r[this.o].Q(conn);
     }
     remove(conn) {
         conn.remove();
-        this.x--;
-        if (!this.x) {
-            clearInterval(this.E);
+        this.F--;
+        if (!this.F) {
+            clearInterval(this.S);
         }
     }
-    M = () => {
-        const { y, w, o } = this;
-        this.j++;
-        if (this.j === w) {
-            this.j = 0;
+    a2 = () => {
+        const { I, E, r } = this;
+        this.o++;
+        if (this.o === E) {
+            this.o = 0;
         }
-        if (y) {
-            let d = this.j + y;
-            if (d >= w) {
-                d -= w;
+        if (I) {
+            let d = this.o + I;
+            if (d >= E) {
+                d -= E;
             }
-            const a = o[d];
-            for (let node = a.g; !a.B(node); node = node.getNext()) {
+            const b = r[d];
+            for (let node = b.f; !b.P(node); node = node.getNext()) {
                 node.keepAlive();
             }
         }
-        const a = o[this.j];
-        for (let node = a.g; !a.B(node); node = node.getNext()) {
+        const b = r[this.o];
+        for (let node = b.f; !b.P(node); node = node.getNext()) {
             node.timeout();
         }
     };
-    D;
-    y;
-    w;
-    j;
-    x;
+    R;
+    I;
     E;
     o;
+    F;
+    S;
+    r;
 }
 //# sourceMappingURL=TimeoutMonitor.js.map