justrun-ws 0.2.3 → 0.3.0

package/lib/net/PackageWrapper.js

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

package/lib/net/TimeoutMonitor.js

@@ -3,14 +3,14 @@ import { l } from '../common/utils';
 export class MonitorConn 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.a0 = f;
+        this.O = h;
+        this.I = g;
+        this.p = 0;
+        this.J = 0;
         this.r = [];
-        if (e === 0) {
+        if (f === 0) {
             this.insert = l;
             this.update = l;
             this.remove = l;
@@ -21,50 +21,50 @@ export class TimeoutMonitor {
         }
     }
     insert(conn) {
-        if (!this.F) {
-            this.S = setInterval(this.a2, this.R);
+        if (!this.J) {
+            this.a1 = setInterval(this.ab, this.a0);
         }
-        this.F++;
-        this.r[this.o].Q(conn);
+        this.J++;
+        this.r[this.p].Z(conn);
     }
     update(conn) {
         conn.remove();
-        this.r[this.o].Q(conn);
+        this.r[this.p].Z(conn);
     }
     remove(conn) {
         conn.remove();
-        this.F--;
-        if (!this.F) {
-            clearInterval(this.S);
+        this.J--;
+        if (!this.J) {
+            clearInterval(this.a1);
         }
     }
-    a2 = () => {
-        const { I, E, r } = this;
-        this.o++;
-        if (this.o === E) {
-            this.o = 0;
+    ab = () => {
+        const { O, I, r } = this;
+        this.p++;
+        if (this.p === I) {
+            this.p = 0;
         }
-        if (I) {
-            let d = this.o + I;
-            if (d >= E) {
-                d -= E;
+        if (O) {
+            let d = this.p + O;
+            if (d >= I) {
+                d -= I;
             }
             const b = r[d];
-            for (let node = b.f; !b.P(node); node = node.getNext()) {
+            for (let node = b.e; !b.Y(node); node = node.getNext()) {
                 node.keepAlive();
             }
         }
-        const b = r[this.o];
-        for (let node = b.f; !b.P(node); node = node.getNext()) {
+        const b = r[this.p];
+        for (let node = b.e; !b.Y(node); node = node.getNext()) {
             node.timeout();
         }
     };
-    R;
+    a0;
+    O;
     I;
-    E;
-    o;
-    F;
-    S;
+    p;
+    J;
+    a1;
     r;
 }
 //# sourceMappingURL=TimeoutMonitor.js.map

package/lib/net/TypedPkgHub.js

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