justrun-ws 0.1.3 → 0.2.1

package/lib/net/TypedPkgHub.js

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

package/lib/net/hubPkgSerializer.js

@@ -1,12 +1,12 @@
 import { j, l, m } from '../common/varUintOps';
-export const makeNumTypePkgBuff = (pkgType, requestId, encoded) => {
+export const p = (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 s = (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.1.3",
+  "version": "0.2.1",
   "scripts": {
     "start": "webpack serve"
   },