justrun-ws 0.3.0 → 0.3.1

package/lib/net/PackageWrapper.js

@@ -46,26 +46,26 @@ class RequestWrapper extends PkgWrapper {
         return true;
     }
     get resp() {
-        if (!this.B) {
-            this.B = this.decodeResponse(this.C);
+        if (!this.z) {
+            this.z = this.decodeResponse(this.$);
         }
-        return this.B;
+        return this.z;
     }
     set resp(b) {
-        this.B = b;
-        this.C = undefined;
+        this.z = b;
+        this.$ = undefined;
     }
     get respBuff() {
-        if (!this.C) {
-            this.C = this.encodeResponse(this.B);
+        if (!this.$) {
+            this.$ = this.encodeResponse(this.z);
         }
-        return this.C;
+        return this.$;
     }
     set respBuff(b) {
-        this.B = undefined;
-        this.C = b;
+        this.z = undefined;
+        this.$ = b;
     }
-    B;
-    C;
+    z;
+    $;
 }
 //# sourceMappingURL=PackageWrapper.js.map

package/lib/net/TimeoutMonitor.js

@@ -1,14 +1,14 @@
 import { ListNode, c } from '../common/List';
 import { l } from '../common/utils';
-export class MonitorConn extends ListNode {
+export class MonitorItem extends ListNode {
 }
 export class TimeoutMonitor {
     constructor(f, h, g) {
-        this.a0 = f;
-        this.O = h;
-        this.I = g;
+        this.X = f;
+        this.J = h;
+        this.F = g;
         this.p = 0;
-        this.J = 0;
+        this.G = 0;
         this.r = [];
         if (f === 0) {
             this.insert = l;
@@ -20,51 +20,51 @@ export class TimeoutMonitor {
             this.r.push(new c());
         }
     }
-    insert(conn) {
-        if (!this.J) {
-            this.a1 = setInterval(this.ab, this.a0);
+    insert(item) {
+        if (!this.G) {
+            this.Y = setInterval(this.a8, this.X);
         }
-        this.J++;
-        this.r[this.p].Z(conn);
+        this.G++;
+        this.r[this.p].W(item);
     }
-    update(conn) {
-        conn.remove();
-        this.r[this.p].Z(conn);
+    update(item) {
+        item.remove();
+        this.r[this.p].W(item);
     }
-    remove(conn) {
-        conn.remove();
-        this.J--;
-        if (!this.J) {
-            clearInterval(this.a1);
+    remove(item) {
+        item.remove();
+        this.G--;
+        if (!this.G) {
+            clearInterval(this.Y);
         }
     }
-    ab = () => {
-        const { O, I, r } = this;
+    a8 = () => {
+        const { J, F, r } = this;
         this.p++;
-        if (this.p === I) {
+        if (this.p === F) {
             this.p = 0;
         }
-        if (O) {
-            let d = this.p + O;
-            if (d >= I) {
-                d -= I;
+        if (J) {
+            let d = this.p + J;
+            if (d >= F) {
+                d -= F;
             }
             const b = r[d];
-            for (let node = b.e; !b.Y(node); node = node.getNext()) {
-                node.keepAlive();
+            for (let node = b.e; !b.V(node); node = node.getNext()) {
+                node.warnTimeout();
             }
         }
         const b = r[this.p];
-        for (let node = b.e; !b.Y(node); node = node.getNext()) {
-            node.timeout();
+        for (let node = b.e; !b.V(node); node = node.getNext()) {
+            node.onTimeout();
         }
     };
-    a0;
-    O;
-    I;
-    p;
+    X;
     J;
-    a1;
+    F;
+    p;
+    G;
+    Y;
     r;
 }
 //# sourceMappingURL=TimeoutMonitor.js.map

package/lib/net/TypedPkgHub.js

@@ -1,92 +1,92 @@
-import { z, l } from '../common/utils';
+import { y, l } from '../common/utils';
 import { NetErrorString } from './NetErrorString';
-import { MonitorConn } from './TimeoutMonitor';
+import { MonitorItem } from './TimeoutMonitor';
 export class u {
-    constructor(B, v) {
+    constructor(C, v) {
         const { responsePkgType, timeoutMonitor, makePkgBuff, parsePkgBuff } = v;
         this.responsePkgType = responsePkgType;
         this.s = 0;
         this.t = new Map();
         this.h = new Map();
-        this.T = new Map();
-        this.a2 = makePkgBuff;
-        this.a3 = parsePkgBuff;
-        this.E = B;
-        this.P = timeoutMonitor;
-        const M = this;
-        M.y = this.ac;
+        this.R = new Map();
+        this.Z = makePkgBuff;
+        this.a0 = parsePkgBuff;
+        this.A = C;
+        this.K = timeoutMonitor;
+        const E = this;
+        E.x = this.a9;
         const r = [];
-        this.a2(responsePkgType, 0x200000, r);
-        this.a4 = {
+        this.Z(responsePkgType, 0x200000, r);
+        this.a1 = {
             makePkgBuff: makePkgBuff,
             responsePkgType: responsePkgType,
-            r: z(r),
+            r: y(r),
         };
-        this.h.set(responsePkgType, M);
-        this.E.I((c, p) => {
+        this.h.set(responsePkgType, E);
+        this.A.init((e, p) => {
             do {
                 this.s++;
             } while (this.t.has(this.s & 0x1fffff));
-            const conn = new w(this.a4, c, this.s & 0x1fffff);
+            const conn = new z(this.a1, e, this.s & 0x1fffff);
             this.t.set(conn.id, conn);
-            this.P?.insert(conn);
-            const g = {
+            this.K?.insert(conn);
+            const f = {
                 conn,
-                A: (buff) => this.ad(conn, buff),
-                o: (err) => this.ae(conn, err),
+                _: (buff) => this.aa(conn, buff),
+                o: (err) => this.ab(conn, err),
             };
-            this.Q?.(this, conn, !!p);
-            return g;
+            this.L?.(this, conn, !!p);
+            return f;
         });
     }
     responsePkgType;
     context;
-    Q;
-    K;
+    L;
+    H;
     b() {
-        return this.E.b();
+        return this.A.b();
     }
-    S(x) {
-        return this.t.get(x);
+    P(w) {
+        return this.t.get(w);
     }
-    d(e) {
-        return this.E.d(e);
+    g(c) {
+        return this.A.g(c);
     }
-    async V() {
+    async Q() {
         do {
             this.s++;
         } while (this.t.has(this.s & 0x1fffff));
-        const conn = new a0(this.s & 0x1fffff, this);
+        const conn = new V(this.s & 0x1fffff, this);
         this.t.set(conn.id, conn);
         return conn;
     }
-    async W(e) {
-        return this.E.J(e);
+    async T(c) {
+        return this.A.I(c);
     }
-    async X() {
-        return this.E.L();
+    async U() {
+        return this.A.J();
     }
-    af(conn, message) {
+    ac(conn, message) {
         const pkgType = message.constructor.pkgType;
         const handler = this.h.get(pkgType);
         if (handler) {
             return handler?.q(conn, message);
         }
-        throw new Error(NetErrorString.$);
+        throw new Error(NetErrorString.InvalidPackage);
     }
-    ag(conn, request) {
+    ad(conn, request) {
         const pkgType = request.constructor.pkgType;
         const handler = this.h.get(pkgType);
         if (handler) {
             return handler?.q(conn, request);
         }
-        throw new Error(NetErrorString.$);
+        throw new Error(NetErrorString.InvalidPackage);
     }
     registerError(pkgType, wrapperCtor) {
         wrapperCtor.registerPkgType(pkgType);
-        this.T.set(pkgType, wrapperCtor);
-        const a1 = this.h.get(this.responsePkgType);
-        this.h.set(pkgType, a1);
+        this.R.set(pkgType, wrapperCtor);
+        const W = this.h.get(this.responsePkgType);
+        this.h.set(pkgType, W);
     }
     registerMessage(pkgType, wrapperCtor) {
         wrapperCtor.registerPkgType(pkgType);
@@ -116,171 +116,171 @@ export class u {
         this.h.set(pkgType, handler);
         return handler;
     }
-    at(handler) {
+    an(handler) {
         const pkgType = handler.pkgType;
-        const a8 = this.h.get(pkgType);
-        if (a8 === handler) {
+        const X = this.h.get(pkgType);
+        if (X === handler) {
             this.h.delete(pkgType);
             return true;
         }
         return false;
     }
-    ad(conn, buff) {
-        this.P?.update(conn);
-        const a = this.a3(buff);
+    aa(conn, buff) {
+        this.K?.update(conn);
+        const a = this.a0(buff);
         const handler = this.h.get(a.pkgType);
         if (handler) {
-            handler.y(conn, a);
+            handler.x(conn, a);
             return;
         }
-        conn.close(new Error(NetErrorString.$));
+        conn.close(new Error(NetErrorString.InvalidPackage));
     }
-    ae(conn, err) {
-        const x = conn.id;
-        this.t.delete(x);
-        this.P?.remove(conn);
+    ab(conn, err) {
+        const w = conn.id;
+        this.t.delete(w);
+        this.K?.remove(conn);
         conn.o(err);
-        this.K?.(this, conn, conn.c.G(), err);
+        this.H?.(this, conn, conn.e.G(), err);
     }
-    ac(conn, a) {
+    a9(conn, a) {
         try {
             const { buff, pkgType, requestId, bodyOffset } = a;
             if (pkgType === this.responsePkgType) {
                 const body = buff.subarray(bodyOffset);
-                conn.a5(requestId, body);
+                conn.a2(requestId, body);
             }
             else {
-                const R = this.T.get(pkgType);
-                if (R) {
+                const N = this.R.get(pkgType);
+                if (N) {
                     const body = buff.subarray(bodyOffset);
-                    const a9 = new R(body, true);
-                    conn.ah(requestId, a9);
+                    const Y = new N(body, true);
+                    conn.ae(requestId, Y);
                 }
             }
         }
         catch {
-            conn.close(new Error(NetErrorString.$));
+            conn.close(new Error(NetErrorString.InvalidPackage));
         }
     }
-    a4;
+    a1;
     s;
-    a2;
-    a3;
-    E;
+    Z;
+    a0;
+    A;
     t;
     h;
-    T;
-    P;
+    R;
+    K;
 }
-class w extends MonitorConn {
-    constructor(v, c, id) {
+class z extends MonitorItem {
+    constructor(v, e, id) {
         super();
         this.id = id;
-        this.c = c;
-        this.F = v;
-        this.a6 = 0;
+        this.e = e;
+        this.B = v;
+        this.a3 = 0;
     }
     context;
     id;
-    c;
+    e;
     get socket() {
-        return this.c.socket;
+        return this.e.socket;
     }
     sendMessage(message) {
         const pkgType = message.constructor.pkgType;
         const encoded = [message.buff];
-        this.F.makePkgBuff(pkgType, 0, encoded);
-        return this.c.n(encoded);
+        this.B.makePkgBuff(pkgType, 0, encoded);
+        return this.e.n(encoded);
     }
     sendRequest(request) {
         this.m = new Map();
-        this.sendRequest = this.a7;
-        this.a5 = this.ai;
-        this.o = this.aj;
-        return this.a7(request);
+        this.sendRequest = this.a4;
+        this.a2 = this.af;
+        this.o = this.ag;
+        return this.a4(request);
     }
     sendErrorResponse(error, requestId) {
         const pkgType = error.constructor.pkgType;
         const encoded = [error.buff];
-        this.F.makePkgBuff(pkgType, requestId, encoded);
-        return this.c.n(encoded);
+        this.B.makePkgBuff(pkgType, requestId, encoded);
+        return this.e.n(encoded);
     }
     sendResponse(request, requestId) {
         const encoded = [request.respBuff];
-        const { makePkgBuff, responsePkgType } = this.F;
+        const { makePkgBuff, responsePkgType } = this.B;
         makePkgBuff(responsePkgType, requestId, encoded);
-        return this.c.n(encoded);
+        return this.e.n(encoded);
     }
     async close(err) {
-        await this.c.close(err);
+        await this.e.close(err);
     }
-    a5(requestId, an) {
+    a2(requestId, ai) {
         if (requestId === 0x200000 && this.context === undefined) {
-            this.close(new Error(NetErrorString.H));
+            this.close(new Error(NetErrorString.AuthTimeout));
         }
     }
-    ah(requestId, error) {
+    ae(requestId, error) {
         const i = this.m.get(requestId);
         if (i) {
             this.m.delete(requestId);
             return i.j(error);
         }
     }
-    keepAlive() {
-        this.c.D(this.F.r).catch(l);
+    warnTimeout() {
+        this.e.F(this.B.r).catch(l);
     }
-    timeout() {
-        this.close(new Error(NetErrorString.Z));
+    onTimeout() {
+        this.close(new Error(NetErrorString.Timeout));
     }
-    o(aa) {
+    o(a5) {
     }
-    async a7(request) {
-        const requestId = (this.a6++) & 0x1fffff;
+    async a4(request) {
+        const requestId = (this.a3++) & 0x1fffff;
         const pkgType = request.constructor.pkgType;
         const encoded = [request.buff];
-        this.F.makePkgBuff(pkgType, requestId, encoded);
-        const ab = new Promise((f, j) => {
-            const ak = { f, j };
-            this.m.set(requestId, ak);
-            this.c.n(encoded).catch((err) => {
+        this.B.makePkgBuff(pkgType, requestId, encoded);
+        const a6 = new Promise((d, j) => {
+            const a7 = { d, j };
+            this.m.set(requestId, a7);
+            this.e.n(encoded).catch((err) => {
                 this.m.delete(requestId);
                 j(err);
             });
         });
-        request.respBuff = await ab;
+        request.respBuff = await a6;
     }
-    ai(requestId, body) {
+    af(requestId, body) {
         const i = this.m.get(requestId);
         if (i) {
             this.m.delete(requestId);
-            i.f(body);
+            i.d(body);
             return;
         }
         if (requestId === 0x200000 && this.context === undefined) {
-            this.close(new Error(NetErrorString.H));
+            this.close(new Error(NetErrorString.AuthTimeout));
         }
     }
-    aj(err) {
-        const C = this.m;
-        if (C.size > 0) {
+    ag(err) {
+        const D = this.m;
+        if (D.size > 0) {
             if (!err) {
-                err = new Error(NetErrorString.Y);
+                err = new Error(NetErrorString.ConnectionClosed);
             }
-            for (const [requestId, i] of C) {
-                C.delete(requestId);
+            for (const [requestId, i] of D) {
+                D.delete(requestId);
                 i.j(err);
             }
         }
         this.m = undefined;
     }
-    F;
+    B;
     m;
-    a6;
+    a3;
 }
-class a0 {
-    constructor(id, al) {
+class V {
+    constructor(id, a8) {
         this.id = id;
-        this.U = al;
+        this.S = a8;
     }
     context;
     id;
@@ -289,19 +289,19 @@ class a0 {
         return 'Local';
     }
     async sendMessage(message) {
-        return this.U.af(this, message);
+        return this.S.ac(this, message);
     }
     async sendRequest(request) {
-        return this.U.ag(this, request);
+        return this.S.ad(this, request);
     }
-    sendErrorResponse(ao, am) {
+    sendErrorResponse(aj, ah) {
         throw null;
     }
-    sendResponse(ap, am) {
+    sendResponse(ak, ah) {
         throw null;
     }
-    async close(aa) {
+    async close(a5) {
     }
-    U;
+    S;
 }
 //# sourceMappingURL=TypedPkgHub.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "justrun-ws",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "scripts": {
     "start": "webpack serve"
   },
@@ -24,14 +24,13 @@
   "devDependencies": {
     "@eslint/eslintrc": "^3.2.0",
     "@eslint/js": "^9.19.0",
-    "@types/jest": "^29.5.1",
     "@typescript-eslint/eslint-plugin": "^8.25.0",
     "@typescript-eslint/parser": "^8.25.0",
     "dts-bundle-generator": "^9.5.1",
     "eslint": "^9.21.0",
     "eslint-plugin-import": "^2.31.0",
-    "globals": "^15.14.0",
-    "minify-ts": "^1.2.4",
+    "globals": "^16.5.0",
+    "minify-ts": "^1.2.5",
     "ts-loader": "^9.5.2",
     "webpack": "^5.98.0",
     "webpack-cli": "^6.0.1"