sonic-ws 1.2.1-wtf → 1.2.2-why

package/README.md

@@ -16,6 +16,7 @@ Developer Friendly:
 - Keys are automatically indexed before transfer, improving readability and efficiency (for example, send("pixel") and send("p") use the same bandwidth)
 - Data is validated and supports custom validation, ensuring only valid, safe, and untampered packets ever call your listeners
 - Edge cases are heavily tested with heavy data ranges; supports code points fully up to the max of 0x10FFFF
+- Debug tools to view all packets
 
 Security:
 - Tamper-proof; any invalid packet instantly causes closure, and tampering becomes incredibly difficult

package/dist/version.d.ts

@@ -1,5 +1,5 @@
 /** Current protocol version */
-export declare const VERSION = 17;
+export declare const VERSION = 18;
 /** Server data suffix */
 export declare const SERVER_SUFFIX = "SWS";
 /** Server data suffix in array */

package/dist/version.js

@@ -18,7 +18,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.SERVER_SUFFIX_NUMS = exports.SERVER_SUFFIX = exports.VERSION = void 0;
 const StringUtil_1 = require("./ws/util/StringUtil");
 /** Current protocol version */
-exports.VERSION = 17;
+exports.VERSION = 18;
 /** Server data suffix */
 exports.SERVER_SUFFIX = "SWS";
 /** Server data suffix in array */

package/dist/ws/Connection.d.ts

@@ -1,3 +1,11 @@
+export interface BasicMiddleware {
+    init?(conn: Connection): void;
+    onReceive_pre(tag: string, data: Uint8Array): boolean | void;
+    onSend_pre(tag: string, values: any[]): boolean | void;
+    onReceive_post(tag: string, values: any[]): boolean | void;
+    onSend_post(tag: string, data: Uint8Array): boolean | void;
+    onStatusChange(status: number): void;
+}
 /**
  * Holds shared connection values. Lets helper functions work on client and server.
  */
@@ -42,4 +50,8 @@ export interface Connection {
      * Closes the connection
      */
     close(code?: number, reason?: string): void;
+    /**
+     * Adds a basic middleware which can interact with packets
+     */
+    addBasicMiddleware(middleware: BasicMiddleware): void;
 }

package/dist/ws/Connection.js

@@ -15,3 +15,4 @@
  * limitations under the License.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+;

package/dist/ws/client/core/ClientCore.d.ts

@@ -1,5 +1,5 @@
 import { PacketHolder } from '../../util/packets/PacketHolder';
-import { Connection } from '../../Connection';
+import { BasicMiddleware, Connection } from '../../Connection';
 export declare abstract class SonicWSCore implements Connection {
     /** Raw 'ws' library connection / webjs WebSocket class */
     socket: WebSocket;
@@ -24,6 +24,7 @@ export declare abstract class SonicWSCore implements Connection {
     _timers: Record<number, [number, (closed: boolean) => void, boolean]>;
     private asyncData;
     private asyncMap;
+    private _state;
     constructor(ws: WebSocket, bufferHandler: (val: MessageEvent) => Promise<Uint8Array>);
     private reading;
     private readQueue;
@@ -31,9 +32,12 @@ export declare abstract class SonicWSCore implements Connection {
     private invalidPacket;
     private listenLock;
     private packetQueue;
-    listenPacket(data: string | [any[], boolean], code: number): void;
+    listenPacket(data: string | [any[], boolean], code: number): Promise<void>;
     private isAsync;
     private enqueuePacket;
+    private basicMiddlewares;
+    addBasicMiddleware(middleware: BasicMiddleware): void;
+    private callMiddleware;
     private messageHandler;
     protected listen(key: string, listener: (data: any[]) => void): void;
     /**

package/dist/ws/client/core/ClientCore.js

@@ -38,6 +38,7 @@ class SonicWSCore {
     _timers = {};
     asyncData = {};
     asyncMap = {};
+    _state = WebSocket.OPEN;
     constructor(ws, bufferHandler) {
         this.socket = ws;
         this.listeners = {
@@ -52,7 +53,9 @@ class SonicWSCore {
         this.serverKeyHandler = this.serverKeyHandler.bind(this);
         this.messageHandler = this.messageHandler.bind(this);
         this.socket.addEventListener('message', this.serverKeyHandler);
-        this.socket.addEventListener('close', (event) => {
+        this.socket.addEventListener('open', () => this.callMiddleware('onStatusChange', WebSocket.OPEN));
+        this.socket.addEventListener('close', event => {
+            this.callMiddleware('onStatusChange', WebSocket.CLOSED);
             this.listeners.close.forEach(listener => listener(event));
             for (const [id, callback, shouldCall] of Object.values(this._timers)) {
                 this.clearTimeout(id);
@@ -115,7 +118,9 @@ class SonicWSCore {
     }
     listenLock = false;
     packetQueue = [];
-    listenPacket(data, code) {
+    async listenPacket(data, code) {
+        if (await this.callMiddleware('onReceive_post', this.serverPackets.getTag(code), typeof data == 'string' ? [data] : data[0]))
+            return;
         const listeners = this.listeners.event[code];
         if (!listeners)
             return console.warn("Warn: No listener for packet " + code);
@@ -158,6 +163,35 @@ class SonicWSCore {
         else
             this.listenLock = false;
     }
+    basicMiddlewares = [];
+    addBasicMiddleware(middleware) {
+        this.basicMiddlewares.push(middleware);
+        const m = middleware;
+        try {
+            if (typeof m.init === 'function')
+                m.init(this);
+        }
+        catch (e) {
+            console.warn('Middleware init threw an error:', e);
+        }
+    }
+    async callMiddleware(method, ...values) {
+        let cancelled = false;
+        for (const middleware of this.basicMiddlewares) {
+            const fn = middleware[method];
+            if (!fn)
+                continue;
+            try {
+                if (await fn(...values)) {
+                    cancelled = true;
+                }
+            }
+            catch (e) {
+                console.warn(`Middleware ${String(method)} threw an error:`, e);
+            }
+        }
+        return cancelled;
+    }
     async messageHandler(event) {
         const data = await this.bufferHandler(event);
         this.listeners.message.forEach(listener => listener(data));
@@ -166,6 +200,8 @@ class SonicWSCore {
         const key = data[0];
         const value = data.slice(1);
         const packet = this.serverPackets.getPacket(this.serverPackets.getTag(key));
+        if (await this.callMiddleware('onReceive_pre', packet.tag, data))
+            return;
         if (packet.rereference && value.length == 0) {
             if (packet.lastReceived[0] === undefined)
                 return this.invalidPacket("No previous value to rereference");
@@ -212,7 +248,11 @@ class SonicWSCore {
      * @param values The values to send
      */
     async send(tag, ...values) {
+        if (await this.callMiddleware('onSend_pre', tag, values))
+            return;
         const [code, data, packet] = await (0, PacketUtils_1.processPacket)(this.clientPackets, tag, values, 0);
+        if (await this.callMiddleware('onSend_post', tag, data))
+            return;
         if (packet.dataBatching == 0)
             this.raw_send((0, BufferUtil_1.toPacketBuffer)(code, data));
         else

package/dist/ws/server/SonicWSConnection.d.ts

@@ -1,7 +1,7 @@
 import * as WS from 'ws';
 import { SonicWSServer } from './SonicWSServer';
 import { Packet } from '../packets/Packets';
-import { Connection } from '../Connection';
+import { BasicMiddleware, Connection } from '../Connection';
 export declare class SonicWSConnection implements Connection {
     /** Raw 'ws' library socket */
     socket: WS.WebSocket;
@@ -23,6 +23,7 @@ export declare class SonicWSConnection implements Connection {
     private asyncMap;
     private asyncData;
     private closed;
+    private _state;
     constructor(socket: WS.WebSocket, host: SonicWSServer, id: number, handshakePacket: string | null, clientRateLimit: number, serverRateLimit: number);
     private parseData;
     private handshakeHandler;
@@ -32,6 +33,9 @@ export declare class SonicWSConnection implements Connection {
     private packetQueue;
     private listenPacket;
     private messageHandler;
+    private basicMiddlewares;
+    addBasicMiddleware(middleware: BasicMiddleware): void;
+    private callMiddleware;
     /**
      * Enables a packet for the client.
      * @param tag The tag of the packet

package/dist/ws/server/SonicWSConnection.js

@@ -83,6 +83,7 @@ class SonicWSConnection {
     asyncMap = {};
     asyncData = {};
     closed = false;
+    _state = WebSocket.OPEN;
     constructor(socket, host, id, handshakePacket, clientRateLimit, serverRateLimit) {
         this.socket = socket;
         this.host = host;
@@ -115,7 +116,9 @@ class SonicWSConnection {
             this.handshakeLambda = (data) => this.handshakeHandler(data);
             this.socket.addEventListener('message', this.handshakeLambda);
         }
+        this.socket.on('open', () => this.callMiddleware('onStatusChange', WebSocket.OPEN));
         this.socket.on('close', () => {
+            this.callMiddleware('onStatusChange', WebSocket.CLOSED);
             this.closed = true;
             for (const [id, callback, shouldCall] of Object.values(this._timers)) {
                 this.clearTimeout(id);
@@ -181,6 +184,8 @@ class SonicWSConnection {
     async listenPacket(data, tag) {
         if (this.closed)
             return;
+        if (await this.callMiddleware('onReceive_post', tag, typeof data == 'string' ? [data] : data[0]))
+            return;
         const isAsync = this.isAsync(tag);
         let locked, packetQueue, asyncData;
         if (isAsync) {
@@ -218,6 +223,8 @@ class SonicWSConnection {
             return;
         const [tag, value] = data;
         const packet = this.host.clientPackets.getPacket(tag);
+        if (await this.callMiddleware('onReceive_pre', packet.tag, value))
+            return;
         if (packet.rereference && value.length == 0) {
             if (packet.lastReceived[this.id] === undefined)
                 return this.invalidPacket("No previous value to rereference");
@@ -236,6 +243,35 @@ class SonicWSConnection {
             this.listenPacket(data, tag);
         }
     }
+    basicMiddlewares = [];
+    addBasicMiddleware(middleware) {
+        this.basicMiddlewares.push(middleware);
+        const m = middleware;
+        try {
+            if (typeof m.init === 'function')
+                m.init(this);
+        }
+        catch (e) {
+            console.warn('Middleware init threw an error:', e);
+        }
+    }
+    async callMiddleware(method, ...values) {
+        let cancelled = false;
+        for (const middleware of this.basicMiddlewares) {
+            const fn = middleware[method];
+            if (!fn)
+                continue;
+            try {
+                if (!await fn(...values)) {
+                    cancelled = true;
+                }
+            }
+            catch (e) {
+                console.warn(`Middleware ${String(method)} threw an error:`, e);
+            }
+        }
+        return cancelled;
+    }
     /**
      * Enables a packet for the client.
      * @param tag The tag of the packet
@@ -292,7 +328,12 @@ class SonicWSConnection {
      * @param values The values to send
      */
     async send(tag, ...values) {
-        this.send_processed(...await (0, PacketUtils_1.processPacket)(this.host.serverPackets, tag, values, this.id));
+        if (await this.callMiddleware('onSend_pre', tag, values))
+            return;
+        const [code, data, packet] = await (0, PacketUtils_1.processPacket)(this.host.serverPackets, tag, values, this.id);
+        if (await this.callMiddleware('onSend_post', tag, data))
+            return;
+        this.send_processed(code, data, packet);
     }
     /**
      * Broadcasts a packet to all other users connected

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sonic-ws",
-  "version": "1.2.1-wtf",
+  "version": "1.2.2-why",
   "description": "Ultra-lightweight, high-performance, and bandwidth efficient websocket library",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",