justrun-ws 0.1.2 → 0.2.0

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 = [];
-        if (e === 0) {
-            this.insert = i;
-            this.update = i;
-            this.remove = i;
+    constructor(f, h, g) {
+        this.R = f;
+        this.J = h;
+        this.D = g;
+        this.o = 0;
+        this.E = 0;
+        this.t = [];
+        if (f === 0) {
+            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.t.push(new c());
         }
     }
     insert(conn) {
-        if (!this.x) {
-            this.E = setInterval(this.M, this.D);
+        if (!this.E) {
+            this.S = setInterval(this.a2, this.R);
         }
-        this.x++;
-        this.o[this.j].C(conn);
+        this.E++;
+        this.t[this.o].Q(conn);
     }
     update(conn) {
         conn.remove();
-        this.o[this.j].C(conn);
+        this.t[this.o].Q(conn);
     }
     remove(conn) {
         conn.remove();
-        this.x--;
-        if (!this.x) {
-            clearInterval(this.E);
+        this.E--;
+        if (!this.E) {
+            clearInterval(this.S);
         }
     }
-    M = () => {
-        const { y, w, o } = this;
-        this.j++;
-        if (this.j === w) {
-            this.j = 0;
+    a2 = () => {
+        const { J, D, t } = this;
+        this.o++;
+        if (this.o === D) {
+            this.o = 0;
         }
-        if (y) {
-            let d = this.j + y;
-            if (d >= w) {
-                d -= w;
+        if (J) {
+            let d = this.o + J;
+            if (d >= D) {
+                d -= D;
             }
-            const a = o[d];
-            for (let node = a.g; !a.B(node); node = node.getNext()) {
+            const b = t[d];
+            for (let node = b.e; !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 = t[this.o];
+        for (let node = b.e; !b.P(node); node = node.getNext()) {
             node.timeout();
         }
     };
+    R;
+    J;
     D;
-    y;
-    w;
-    j;
-    x;
-    E;
     o;
+    E;
+    S;
+    t;
 }
 //# sourceMappingURL=TimeoutMonitor.js.map

package/lib/net/TypedPkgHub.js

@@ -1,94 +1,94 @@
-import { l, i } from '../common/utils';
+import { y, l } from '../common/utils';
 import { MonitorConn } from './TimeoutMonitor';
-export class TypedPkgHub {
-    constructor(s, m) {
-        const { responsePkgType, timeoutMonitor, makePkgBuff, parsePkgBuff } = m;
+export class t {
+    constructor(C, w) {
+        const { responsePkgType, timeoutMonitor, makePkgBuff, parsePkgBuff } = w;
         this.responsePkgType = responsePkgType;
         this.context = undefined;
-        this.onConnOpen = undefined;
-        this.onConnClose = undefined;
-        this.p = 0;
-        this.q = new Map();
-        this.c = new Map();
-        this.$ = new Map();
-        this.F = makePkgBuff;
-        this.G = parsePkgBuff;
-        this.u = s;
-        this.z = timeoutMonitor;
-        const o = this;
-        o.run = this.N;
-        const j = [];
-        this.F(responsePkgType, 0x200000, j);
-        this.H = {
+        this.F = undefined;
+        this.G = undefined;
+        this.u = 0;
+        this.v = new Map();
+        this.e = new Map();
+        this.L = new Map();
+        this.T = makePkgBuff;
+        this.U = parsePkgBuff;
+        this.A = C;
+        this.K = timeoutMonitor;
+        const Q = this;
+        Q.$ = this.a3;
+        const s = [];
+        this.T(responsePkgType, 0x200000, s);
+        this.V = {
             makePkgBuff: makePkgBuff,
             responsePkgType: responsePkgType,
-            j: l(j),
+            s: y(s),
         };
-        this.c.set(responsePkgType, o);
-        this.u.setConnWrapperMaker((a, isActive) => {
+        this.e.set(responsePkgType, Q);
+        this.A.N((b, q) => {
             do {
-                this.p++;
-            } while (this.q.has(this.p & 0x1fffff));
-            const conn = new k(this.H, a, this.p & 0x1fffff);
-            this.q.set(conn.id, conn);
-            this.z?.insert(conn);
-            const e = {
+                this.u++;
+            } while (this.v.has(this.u & 0x1fffff));
+            const conn = new x(this.V, b, this.u & 0x1fffff);
+            this.v.set(conn.id, conn);
+            this.K?.insert(conn);
+            const g = {
                 conn,
-                onPkgBuff: (buff) => this.O(conn, buff),
-                onClose: (err) => this.P(conn, err),
+                D: (buff) => this.a4(conn, buff),
+                n: (err) => this.a5(conn, err),
             };
-            this.onConnOpen?.(this, conn, !!isActive);
-            return e;
+            this.F?.(this, conn, !!q);
+            return g;
         });
     }
     responsePkgType;
     context;
-    onConnOpen;
-    onConnClose;
-    address() {
-        return this.u.address();
+    F;
+    G;
+    o() {
+        return this.A.o();
     }
-    getConn(connId) {
-        return this.q.get(connId);
+    Z(z) {
+        return this.v.get(z);
     }
-    connect(connStr) {
-        return this.u.connect(connStr);
+    c(d) {
+        return this.A.c(d);
     }
-    async connectLocal() {
+    async a0() {
         do {
-            this.p++;
-        } while (this.q.has(this.p & 0x1fffff));
-        const conn = new t(this.p & 0x1fffff, this);
-        this.q.set(conn.id, conn);
+            this.u++;
+        } while (this.v.has(this.u & 0x1fffff));
+        const conn = new a6(this.u & 0x1fffff, this);
+        this.v.set(conn.id, conn);
         return conn;
     }
-    async startServer(connStr) {
-        return this.u.startListen(connStr);
+    async a1(d) {
+        return this.A.O(d);
     }
-    async stopServer() {
-        return this.u.stopListen();
+    async a2() {
+        return this.A.P();
     }
-    sendMessageLocal(conn, message) {
+    a7(conn, message) {
         const pkgType = message.constructor.pkgType;
-        const handler = this.c.get(pkgType);
+        const handler = this.e.get(pkgType);
         if (handler) {
-            return handler?.runLocal(conn, message);
+            return handler?.r(conn, message);
         }
         throw new Error('Invalid package');
     }
-    sendRequestLocal(conn, request) {
+    a8(conn, request) {
         const pkgType = request.constructor.pkgType;
-        const handler = this.c.get(pkgType);
+        const handler = this.e.get(pkgType);
         if (handler) {
-            return handler?.runLocal(conn, request);
+            return handler?.r(conn, request);
         }
         throw new Error('Invalid package');
     }
     registerError(pkgType, wrapperCtor) {
         wrapperCtor.registerPkgType(pkgType);
-        this.$.set(pkgType, wrapperCtor);
-        const w = this.c.get(this.responsePkgType);
-        this.c.set(pkgType, w);
+        this.L.set(pkgType, wrapperCtor);
+        const a9 = this.e.get(this.responsePkgType);
+        this.e.set(pkgType, a9);
     }
     registerMessage(pkgType, wrapperCtor) {
         wrapperCtor.registerPkgType(pkgType);
@@ -99,197 +99,200 @@ export class TypedPkgHub {
     handleMessageWith(handler) {
         const pkgType = handler.pkgType;
         if (typeof pkgType !== typeof this.responsePkgType) {
-            throw new Error(`Wrapper ${handler.pkgName} has an incompatible pkgType ${typeof pkgType}`);
+            throw new Error(`Wrapper ${handler.m} has an incompatible pkgType ${typeof pkgType}`);
         }
-        if (this.c.has(pkgType)) {
-            throw new Error(`Wrapper ${handler.pkgName} is already handled by another handler`);
+        if (this.e.has(pkgType)) {
+            throw new Error(`Wrapper ${handler.m} is already handled by another handler`);
         }
-        this.c.set(pkgType, handler);
+        this.e.set(pkgType, handler);
         return handler;
     }
     handleRequestWith(handler) {
         const pkgType = handler.pkgType;
         if (typeof pkgType !== typeof this.responsePkgType) {
-            throw new Error(`Wrapper ${handler.pkgName} has an incompatible pkgType ${typeof pkgType}`);
+            throw new Error(`Wrapper ${handler.m} has an incompatible pkgType ${typeof pkgType}`);
         }
-        if (this.c.has(pkgType)) {
-            throw new Error(`Wrapper ${handler.pkgName} is already handled by another handler`);
+        if (this.e.has(pkgType)) {
+            throw new Error(`Wrapper ${handler.m} is already handled by another handler`);
         }
-        this.c.set(pkgType, handler);
+        this.e.set(pkgType, handler);
         return handler;
     }
-    removeHandler(handler) {
+    ak(handler) {
         const pkgType = handler.pkgType;
-        const x = this.c.get(pkgType);
-        if (x === handler) {
-            this.c.delete(pkgType);
+        const aa = this.e.get(pkgType);
+        if (aa === handler) {
+            this.e.delete(pkgType);
             return true;
         }
         return false;
     }
-    O(conn, buff) {
-        this.z?.update(conn);
-        const parseResult = this.G(buff);
-        const handler = this.c.get(parseResult.pkgType);
+    a4(conn, buff) {
+        this.K?.update(conn);
+        const a = this.U(buff);
+        const handler = this.e.get(a.pkgType);
         if (handler) {
-            handler.run(conn, parseResult);
+            handler.$(conn, a);
             return;
         }
         conn.close(new Error('Invalid package'));
     }
-    P(conn, err) {
-        const connId = conn.id;
-        this.q.delete(connId);
-        this.z?.remove(conn);
-        conn.onClose(err);
-        this.onConnClose?.(this, conn, conn.a.hadClosed(), err);
+    a5(conn, err) {
+        const z = conn.id;
+        this.v.delete(z);
+        this.K?.remove(conn);
+        conn.n(err);
+        this.G?.(this, conn, conn.b.J(), err);
     }
-    N(conn, parseResult) {
-        const { buff, pkgType, requestId, bodyOffset } = parseResult;
+    a3(conn, a) {
+        const { buff, pkgType, requestId, bodyOffset } = a;
         if (pkgType === this.responsePkgType) {
-            const b = buff.subarray(bodyOffset);
-            conn.I(requestId, b);
+            const h = buff.subarray(bodyOffset);
+            conn.W(requestId, h);
         }
         else {
-            const r = this.$.get(pkgType);
-            if (r) {
-                const b = buff.subarray(bodyOffset);
-                const y = new r(b, true);
-                conn.Q(requestId, y);
+            const S = this.L.get(pkgType);
+            if (S) {
+                const h = buff.subarray(bodyOffset);
+                const ab = new S(h, true);
+                conn.ac(requestId, ab);
             }
         }
     }
-    H;
-    p;
-    F;
-    G;
+    V;
     u;
-    q;
-    c;
-    $;
-    z;
+    T;
+    U;
+    A;
+    v;
+    e;
+    L;
+    K;
 }
-class k extends MonitorConn {
-    constructor(m, a, id) {
+class x extends MonitorConn {
+    constructor(w, b, id) {
         super();
         this.context = undefined;
         this.id = id;
-        this.a = a;
-        this.v = m;
-        this.h = undefined;
-        this.J = 0;
+        this.b = b;
+        this.B = w;
+        this.j = undefined;
+        this.X = 0;
     }
     context;
     id;
-    a;
+    b;
     get localAddress() {
-        return this.a.localAddress;
+        return this.b.localAddress;
     }
     get localPort() {
-        return this.a.localPort;
+        return this.b.localPort;
     }
     get remoteAddress() {
-        return this.a.remoteAddress;
+        return this.b.remoteAddress;
     }
     get remoteFamily() {
-        return this.a.remoteFamily;
+        return this.b.remoteFamily;
     }
     get remotePort() {
-        return this.a.remotePort;
+        return this.b.remotePort;
     }
     sendMessage(message) {
         const pkgType = message.constructor.pkgType;
         const encoded = [message.buff];
-        this.v.makePkgBuff(pkgType, 0, encoded);
-        return this.a.sendPkgBuffV(encoded);
+        this.B.makePkgBuff(pkgType, 0, encoded);
+        return this.b.p(encoded);
     }
     sendRequest(request) {
-        this.h = new Map();
-        this.sendRequest = this.K;
-        this.I = this.R;
-        this.onClose = this.S;
-        return this.K(request);
+        this.j = new Map();
+        this.sendRequest = this.Y;
+        this.W = this.ad;
+        this.n = this.ae;
+        return this.Y(request);
     }
     sendErrorResponse(error, requestId) {
         const pkgType = error.constructor.pkgType;
         const encoded = [error.buff];
-        this.v.makePkgBuff(pkgType, requestId, encoded);
-        return this.a.sendPkgBuffV(encoded);
+        this.B.makePkgBuff(pkgType, requestId, encoded);
+        return this.b.p(encoded);
     }
     sendResponse(request, requestId) {
         const encoded = [request.respBuff];
-        const { makePkgBuff, responsePkgType } = this.v;
+        const { makePkgBuff, responsePkgType } = this.B;
         makePkgBuff(responsePkgType, requestId, encoded);
-        return this.a.sendPkgBuffV(encoded);
+        return this.b.p(encoded);
     }
     async close(err) {
-        await this.a.close(err);
+        await this.b.close(err);
     }
-    I(requestId, L) {
+    W(requestId, al) {
         if (requestId === 0x200000 && this.context === undefined) {
             this.close(new Error('Authenticating timeout'));
         }
     }
-    Q(requestId, error) {
-        const d = this.h.get(requestId);
-        if (d) {
-            this.h.delete(requestId);
-            return d.g(error);
+    ac(requestId, error) {
+        const k = this.j.get(requestId);
+        if (k) {
+            this.j.delete(requestId);
+            return k.i(error);
         }
     }
     keepAlive() {
-        this.a.sendPkgBuff(this.v.j).catch(i);
+        this.b.I(this.B.s).catch(l);
     }
     timeout() {
         this.close(new Error('Connection timeout'));
     }
-    onClose(A) {
+    n(af) {
     }
-    async K(request) {
-        const requestId = (this.J++) & 0x1fffff;
-        const B = new Promise((f, g) => {
-            const C = { f, g };
-            this.h.set(requestId, C);
-        });
+    async Y(request) {
+        const requestId = (this.X++) & 0x1fffff;
         const pkgType = request.constructor.pkgType;
         const encoded = [request.buff];
-        this.v.makePkgBuff(pkgType, requestId, encoded);
-        this.a.sendPkgBuffV(encoded);
-        request.respBuff = await B;
-    }
-    R(requestId, b) {
-        const d = this.h.get(requestId);
-        if (d) {
-            this.h.delete(requestId);
-            d.f(b);
+        this.B.makePkgBuff(pkgType, requestId, encoded);
+        const ag = new Promise((f, i) => {
+            const ah = { f, i };
+            this.j.set(requestId, ah);
+            this.b.p(encoded).catch((err) => {
+                this.j.delete(requestId);
+                i(err);
+            });
+        });
+        request.respBuff = await ag;
+    }
+    ad(requestId, h) {
+        const k = this.j.get(requestId);
+        if (k) {
+            this.j.delete(requestId);
+            k.f(h);
             return;
         }
         if (requestId === 0x200000 && this.context === undefined) {
             this.close(new Error('Authenticating timeout'));
         }
     }
-    S(err) {
-        const n = this.h;
-        if (n.size > 0) {
+    ae(err) {
+        const H = this.j;
+        if (H.size > 0) {
             if (!err) {
                 err = new Error('Connection is closed');
             }
-            for (const [requestId, d] of n) {
-                n.delete(requestId);
-                d.g(err);
+            for (const [requestId, k] of H) {
+                H.delete(requestId);
+                k.i(err);
             }
         }
-        this.h = undefined;
+        this.j = undefined;
     }
-    v;
-    h;
-    J;
+    B;
+    j;
+    X;
 }
-class t {
-    constructor(id, D) {
+class a6 {
+    constructor(id, ai) {
         this.context = undefined;
         this.id = id;
-        this._ = D;
+        this.M = ai;
     }
     context;
     id;
@@ -301,19 +304,19 @@ class t {
         return 'Local';
     }
     async sendMessage(message) {
-        return this._.sendMessageLocal(this, message);
+        return this.M.a7(this, message);
     }
     async sendRequest(request) {
-        return this._.sendRequestLocal(this, request);
+        return this.M.a8(this, request);
     }
-    sendErrorResponse(M, E) {
+    sendErrorResponse(am, aj) {
         throw null;
     }
-    sendResponse(T, E) {
+    sendResponse(_request, aj) {
         throw null;
     }
-    async close(A) {
+    async close(af) {
     }
-    _;
+    M;
 }
 //# sourceMappingURL=TypedPkgHub.js.map

package/lib/net/hubPkgSerializer.js

@@ -1,14 +1,14 @@
 import { j, l, m } from '../common/varUintOps';
-export const makeNumTypePkgBuff = (pkgType, requestId, encoded) => {
+export const o = (pkgType, requestId, encoded) => {
     const i = [requestId, pkgType];
     const b = j(i);
     const a = new Uint8Array(b);
     m(i, a);
     encoded.push(a);
 };
-export const parseNumTypePkgBuff = (buff) => {
+export const p = (buff) => {
     const { h: [requestId, pkgType], k: bodyOffset } = l(2, buff);
-    const d = { buff, pkgType, requestId, bodyOffset };
-    return d;
+    const result = { buff, pkgType, requestId, bodyOffset };
+    return result;
 };
 //# sourceMappingURL=hubPkgSerializer.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "justrun-ws",
-  "version": "0.1.2",
+  "version": "0.2.0",
   "scripts": {
     "start": "webpack serve"
   },