sonic-ws 1.2.0 → 1.2.1

package/README.md

@@ -23,7 +23,8 @@ Security:
 - Built-in ability for handshake packets, preventing repetitive initiation checks in listeners (for example, removes if(!init) everywhere)
 - Built-in rate limiting for packets; ability for global send & receive, alongside per-packet rate limiting
 - Built-in disabling & enabling of packets to prevent abuse
-- Prevents any race conditions; your callbacks will not be called until they finish.
+- Prevents any race conditions; your callbacks will not be called until the last one finishes. (Alongside async options!)
+- Prevents niche bugs found in other websocket libraries, such as functions calling after the socket already closed.
 
 Performance & Scaling:
 - Can handle very large packets in microseconds
@@ -119,4 +120,6 @@ Some weird error messages when invalid inputs are in like CreatePacket() and stu
 
 Better error handling
 
-Some middleware support
+Some middleware support
+
+Debug menus for client/server

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

@@ -166,8 +166,15 @@ class SonicWSCore {
         const key = data[0];
         const value = data.slice(1);
         const packet = this.serverPackets.getPacket(this.serverPackets.getTag(key));
+        if (packet.rereference && value.length == 0) {
+            if (packet.lastReceived[0] === undefined)
+                return this.invalidPacket("No previous value to rereference");
+            this.listenPacket(packet.lastReceived[0], key);
+            return;
+        }
         if (packet.dataBatching == 0) {
-            this.listenPacket(await packet.listen(value, null), key);
+            const res = packet.lastReceived[0] = await packet.listen(value, null);
+            this.listenPacket(res, key);
             return;
         }
         const batchData = await BatchHelper_1.BatchHelper.unravelBatch(packet, value, null);
@@ -205,7 +212,7 @@ class SonicWSCore {
      * @param values The values to send
      */
     async send(tag, ...values) {
-        const [code, data, packet] = await (0, PacketUtils_1.processPacket)(this.clientPackets, tag, values);
+        const [code, data, packet] = await (0, PacketUtils_1.processPacket)(this.clientPackets, tag, values, 0);
         if (packet.dataBatching == 0)
             this.raw_send((0, BufferUtil_1.toPacketBuffer)(code, data));
         else

package/dist/ws/packets/PacketProcessors.d.ts

@@ -4,10 +4,10 @@ import { PacketType } from "./PacketType";
 export type PacketTypeValidator = (data: Uint8Array, index: number) => Promise<[Uint8Array, false | any]>;
 export type PacketReceiveProcessor = (data: Uint8Array, validationResult: any, index: number) => any;
 export type PacketSendProcessor = (ident: string, ...data: any[]) => Promise<Uint8Array>;
-export declare function createValidator<T extends PacketType>(type: T, dataCap: number, dataMin: number, packet: Packet<T | T[]>, gzipCompression: boolean, rereference: boolean): PacketTypeValidator;
+export declare function createValidator<T extends PacketType>(type: T, dataCap: number, dataMin: number, packet: Packet<T | T[]>, gzipCompression: boolean): PacketTypeValidator;
 export declare function createReceiveProcessor(type: PacketType, enumData: EnumPackage[], cap: number): PacketReceiveProcessor;
 /** Creates a function that processes a packet type */
-export declare function createSendProcessor(type: PacketType, gzipCompression: boolean, rereference: boolean): PacketSendProcessor;
+export declare function createSendProcessor(type: PacketType, gzipCompression: boolean): PacketSendProcessor;
 export declare function createObjSendProcessor(packet: Packet<PacketType[]>): PacketSendProcessor;
 export declare function createObjReceiveProcessor(packet: Packet<PacketType[]>): PacketReceiveProcessor;
 export declare function createObjValidator(packet: Packet<PacketType[]>): PacketTypeValidator;

package/dist/ws/packets/PacketProcessors.js

@@ -52,7 +52,7 @@ function VARINT_VERIF(cap, min) {
     };
 }
 ;
-function createValidator(type, dataCap, dataMin, packet, gzipCompression, rereference) {
+function createValidator(type, dataCap, dataMin, packet, gzipCompression) {
     function genFunc() {
         switch (type) {
             case PacketType_1.PacketType.NONE: return (data) => data.length == 0;
@@ -149,29 +149,18 @@ function createValidator(type, dataCap, dataMin, packet, gzipCompression, rerefe
         }
     }
     const fn = genFunc();
-    let parsed = null;
     return gzipCompression
         ? async (data, index) => {
-            if (rereference && data.length == 0) {
-                if (parsed == null)
-                    return [data, false];
-                return parsed;
-            }
             try {
                 const dec = await (0, CompressionUtil_1.decompressGzip)(data);
-                return parsed = [dec, fn(dec, index)];
+                return [dec, fn(dec, index)];
             }
             catch {
                 return [data, false];
             }
         }
         : async (data, index) => {
-            if (rereference && data.length == 0) {
-                if (parsed == null)
-                    return [data, false];
-                return parsed;
-            }
-            return parsed = [data, fn(data, index)];
+            return [data, fn(data, index)];
         };
 }
 function createReceiveProcessor(type, enumData, cap) {
@@ -215,7 +204,7 @@ function createReceiveProcessor(type, enumData, cap) {
     }
 }
 /** Creates a function that processes a packet type */
-function createSendProcessor(type, gzipCompression, rereference) {
+function createSendProcessor(type, gzipCompression) {
     function genFunc() {
         switch (type) {
             case PacketType_1.PacketType.NONE: return () => [];
@@ -263,34 +252,19 @@ function createSendProcessor(type, gzipCompression, rereference) {
         }
     }
     const fn = genFunc();
-    let lastSent;
     if (!gzipCompression) {
         return async (_, data) => {
-            if (rereference) {
-                const jstr = JSON.stringify(data);
-                if (jstr == lastSent) {
-                    return CompressionUtil_1.EMPTY_UINT8;
-                }
-                lastSent = jstr;
-            }
             return new Uint8Array(fn(data));
         };
     }
     return async (ident, data) => {
-        if (rereference) {
-            const jstr = JSON.stringify(data);
-            if (jstr == lastSent) {
-                return CompressionUtil_1.EMPTY_UINT8;
-            }
-            lastSent = jstr;
-        }
         return (0, CompressionUtil_1.compressGzip)(new Uint8Array(fn(data)), ident);
     };
 }
 function createObjSendProcessor(packet) {
     const size = packet.type.length;
     // TODO: Add compression and add rereferences[]
-    const processors = packet.type.map(t => createSendProcessor(t, false, false));
+    const processors = packet.type.map(t => createSendProcessor(t, false));
     return async (ident, data) => {
         let result = [];
         for (let i = 0; i < size; i++) {
@@ -321,7 +295,7 @@ function createObjReceiveProcessor(packet) {
     };
 }
 function createObjValidator(packet) {
-    const validators = packet.type.map((t, i) => createValidator(t, packet.dataMax[i], packet.dataMin[i], packet, false, false));
+    const validators = packet.type.map((t, i) => createValidator(t, packet.dataMax[i], packet.dataMin[i], packet, false));
     return async (data) => {
         let index = 0, enums = 0, computedData = [];
         while (index < data.length) {

package/dist/ws/packets/Packets.d.ts

@@ -30,6 +30,8 @@ export declare class Packet<T extends (PacketType | readonly PacketType[])> {
     processSend: (data: any[]) => Promise<Uint8Array>;
     validate: (data: Uint8Array) => Promise<[Uint8Array, boolean]>;
     customValidator: ((socket: SonicWSConnection, ...values: any[]) => boolean) | null;
+    lastReceived: Record<number, any>;
+    lastSent: Record<number, any>;
     constructor(tag: string, schema: PacketSchema<T>, customValidator: ValidatorFunction, enabled: boolean, client: boolean);
     listen(value: Uint8Array, socket: SonicWSConnection | null): Promise<[processed: any, flatten: boolean] | string>;
     serialize(): number[];

package/dist/ws/packets/Packets.js

@@ -50,6 +50,8 @@ class Packet {
     processSend;
     validate;
     customValidator;
+    lastReceived = {};
+    lastSent = {};
     constructor(tag, schema, customValidator, enabled, client) {
         this.tag = tag;
         this.defaultEnabled = enabled;

package/dist/ws/server/SonicWSConnection.js

@@ -92,6 +92,7 @@ class SonicWSConnection {
         for (const tag of host.clientPackets.getTags()) {
             this.listeners[tag] = [];
             const pack = host.clientPackets.getPacket(tag);
+            pack.lastReceived[this.id] = undefined;
             this.enabledPackets[tag] = pack.defaultEnabled;
             this.asyncMap[tag] = pack.async;
             if (pack.async)
@@ -121,6 +122,9 @@ class SonicWSConnection {
                 if (shouldCall)
                     callback(true);
             }
+            for (const packet of host.clientPackets.getPackets()) {
+                delete packet.lastReceived[this.id];
+            }
         });
     }
     parseData(event) {
@@ -214,8 +218,14 @@ class SonicWSConnection {
             return;
         const [tag, value] = data;
         const packet = this.host.clientPackets.getPacket(tag);
+        if (packet.rereference && value.length == 0) {
+            if (packet.lastReceived[this.id] === undefined)
+                return this.invalidPacket("No previous value to rereference");
+            this.listenPacket(packet.lastReceived[this.id], tag);
+            return;
+        }
         if (packet.dataBatching == 0) {
-            const res = await packet.listen(value, this);
+            const res = packet.lastReceived[this.id] = await packet.listen(value, this);
             this.listenPacket(res, tag);
             return;
         }
@@ -282,7 +292,7 @@ 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.send_processed(...await (0, PacketUtils_1.processPacket)(this.host.serverPackets, tag, values, this.id));
     }
     /**
      * Broadcasts a packet to all other users connected

package/dist/ws/server/SonicWSServer.js

@@ -219,7 +219,7 @@ class SonicWSServer {
     async broadcastTagged(tag, packetTag, ...values) {
         if (!this.tagsInv.has(tag))
             return;
-        const data = await (0, PacketUtils_1.processPacket)(this.serverPackets, packetTag, values);
+        const data = await (0, PacketUtils_1.processPacket)(this.serverPackets, packetTag, values, -1);
         this.tagsInv.get(tag).forEach(conn => conn.send_processed(...data));
     }
     /**
@@ -229,7 +229,7 @@ class SonicWSServer {
      * @param values The values to send
      */
     async broadcastFiltered(tag, filter, ...values) {
-        const data = await (0, PacketUtils_1.processPacket)(this.serverPackets, tag, values);
+        const data = await (0, PacketUtils_1.processPacket)(this.serverPackets, tag, values, -1);
         this.connections.filter(filter).forEach(conn => conn.send_processed(...data));
     }
     /**

package/dist/ws/util/packets/PacketUtils.d.ts

@@ -9,7 +9,7 @@ import { EnumPackage } from "../enums/EnumType";
  * @param values The values
  * @returns The indexed code, the data, and the packet schema
  */
-export declare function processPacket(packets: PacketHolder, tag: string, values: any[]): Promise<[code: number, data: Uint8Array, packet: Packet<any>]>;
+export declare function processPacket(packets: PacketHolder, tag: string, values: any[], id: number): Promise<[code: number, data: Uint8Array, packet: Packet<any>]>;
 /**
  * Calls the listener for a packet with error callback
  * @param listened The listened data

package/dist/ws/util/packets/PacketUtils.js

@@ -26,6 +26,7 @@ exports.UnFlattenData = UnFlattenData;
 const Packets_1 = require("../../packets/Packets");
 const PacketType_1 = require("../../packets/PacketType");
 const EnumType_1 = require("../enums/EnumType");
+const CompressionUtil_1 = require("./CompressionUtil");
 /**
  * Processes and verifies values into a sendable format
  * @param packets Packet holder
@@ -33,7 +34,7 @@ const EnumType_1 = require("../enums/EnumType");
  * @param values The values
  * @returns The indexed code, the data, and the packet schema
  */
-async function processPacket(packets, tag, values) {
+async function processPacket(packets, tag, values, id) {
     const code = packets.getKey(tag);
     const packet = packets.getPacket(tag);
     if (packet.autoFlatten) {
@@ -68,7 +69,15 @@ async function processPacket(packets, tag, values) {
             }
         }
     }
-    return [code, values.length > 0 ? await packet.processSend(values) : new Uint8Array([]), packet];
+    const sendData = values.length > 0 ? await packet.processSend(values) : CompressionUtil_1.EMPTY_UINT8;
+    if (packet.rereference) {
+        if (id == -1)
+            throw new Error("Cannot broadcast a packet that is rereference-enabled");
+        if (packet.lastSent[id] == sendData)
+            return [code, CompressionUtil_1.EMPTY_UINT8, packet];
+        packet.lastSent[id] = sendData;
+    }
+    return [code, sendData, packet];
 }
 /**
  * Calls the listener for a packet with error callback

package/package.json

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