justrun-ws 0.2.3 → 0.3.1

package/lib/net/NetErrorString.js

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

package/lib/net/TimeoutMonitor.js

@@ -1,16 +1,16 @@
 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(e, h, g) {
-        this.R = e;
-        this.I = h;
-        this.E = g;
-        this.o = 0;
-        this.F = 0;
+    constructor(f, h, g) {
+        this.X = f;
+        this.J = h;
+        this.F = g;
+        this.p = 0;
+        this.G = 0;
         this.r = [];
-        if (e === 0) {
+        if (f === 0) {
             this.insert = l;
             this.update = l;
             this.remove = l;
@@ -20,51 +20,51 @@ export class TimeoutMonitor {
             this.r.push(new c());
         }
     }
-    insert(conn) {
-        if (!this.F) {
-            this.S = setInterval(this.a2, this.R);
+    insert(item) {
+        if (!this.G) {
+            this.Y = setInterval(this.a8, this.X);
         }
-        this.F++;
-        this.r[this.o].Q(conn);
+        this.G++;
+        this.r[this.p].W(item);
     }
-    update(conn) {
-        conn.remove();
-        this.r[this.o].Q(conn);
+    update(item) {
+        item.remove();
+        this.r[this.p].W(item);
     }
-    remove(conn) {
-        conn.remove();
-        this.F--;
-        if (!this.F) {
-            clearInterval(this.S);
+    remove(item) {
+        item.remove();
+        this.G--;
+        if (!this.G) {
+            clearInterval(this.Y);
         }
     }
-    a2 = () => {
-        const { I, E, r } = this;
-        this.o++;
-        if (this.o === E) {
-            this.o = 0;
+    a8 = () => {
+        const { J, F, r } = this;
+        this.p++;
+        if (this.p === F) {
+            this.p = 0;
         }
-        if (I) {
-            let d = this.o + I;
-            if (d >= E) {
-                d -= E;
+        if (J) {
+            let d = this.p + J;
+            if (d >= F) {
+                d -= F;
             }
             const b = r[d];
-            for (let node = b.f; !b.P(node); node = node.getNext()) {
-                node.keepAlive();
+            for (let node = b.e; !b.V(node); node = node.getNext()) {
+                node.warnTimeout();
             }
         }
-        const b = r[this.o];
-        for (let node = b.f; !b.P(node); node = node.getNext()) {
-            node.timeout();
+        const b = r[this.p];
+        for (let node = b.e; !b.V(node); node = node.getNext()) {
+            node.onTimeout();
         }
     };
-    R;
-    I;
-    E;
-    o;
+    X;
+    J;
     F;
-    S;
+    p;
+    G;
+    Y;
     r;
 }
 //# sourceMappingURL=TimeoutMonitor.js.map

package/lib/net/TypedPkgHub.js

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

package/lib/net/hubPkgSerializer.js

@@ -1,12 +1,12 @@
 import { j, l, m } from '../common/varUintOps';
-export const p = (pkgType, requestId, encoded) => {
+export const n = (pkgType, requestId, encoded) => {
     const i = [requestId, pkgType];
     const b = j(i);
     const a = new Uint8Array(b);
     m(i, a);
     encoded.push(a);
 };
-export const s = (buff) => {
+export const o = (buff) => {
     const { h: [requestId, pkgType], k: bodyOffset } = l(2, buff);
     const result = { buff, pkgType, requestId, bodyOffset };
     return result;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "justrun-ws",
-  "version": "0.2.3",
+  "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"