sonic-ws 1.1.0 → 1.1.1-patch

package/README.md

@@ -22,6 +22,7 @@ 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.
 
 Performance & Scaling:
 - Can handle very large packets in microseconds

package/dist/version.d.ts

@@ -1,5 +1,5 @@
 /** Current protocol version */
-export declare const VERSION = 14;
+export declare const VERSION = 15;
 /** 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 = 14;
+exports.VERSION = 15;
 /** Server data suffix */
 exports.SERVER_SUFFIX = "SWS";
 /** Server data suffix in array */

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

@@ -22,11 +22,17 @@ export declare abstract class SonicWSCore implements Connection {
     private bufferHandler;
     id: number;
     _timers: Record<number, [number, (closed: boolean) => void, boolean]>;
+    private asyncData;
+    private asyncMap;
     constructor(ws: WebSocket, bufferHandler: (val: MessageEvent) => Promise<Uint8Array>);
     private reading;
     private serverKeyHandler;
     private invalidPacket;
-    private listenPacket;
+    private listenLock;
+    private packetQueue;
+    listenPacket(data: string | [any[], boolean], code: number): void;
+    private isAsync;
+    private enqueuePacket;
     private messageHandler;
     protected listen(key: string, listener: (data: any[]) => void): void;
     /**

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

@@ -36,6 +36,8 @@ class SonicWSCore {
     bufferHandler;
     id = -1;
     _timers = {};
+    asyncData = {};
+    asyncMap = {};
     constructor(ws, bufferHandler) {
         this.socket = ws;
         this.listeners = {
@@ -84,6 +86,13 @@ class SonicWSCore {
         const skData = data.slice(valuesOff + ckLength, data.length);
         this.serverPackets.holdPackets(Packets_1.Packet.deserializeAll(skData, true));
         this.batcher.registerSendPackets(this.clientPackets, this);
+        for (const p of this.serverPackets.getPackets()) {
+            const key = this.serverPackets.getKey(p.tag);
+            this.asyncMap[key] = p.async;
+            if (p.async) {
+                this.asyncData[key] = [false, []];
+            }
+        }
         Object.keys(this.preListen).forEach(tag => this.preListen[tag].forEach(listener => {
             // print the error to console without halting execution
             if (!this.serverPackets.hasTag(tag))
@@ -101,11 +110,51 @@ class SonicWSCore {
         console.error(listened);
         throw new Error("An error occured with data from the server!! This is probably my fault.. make an issue at https://github.com/liwybloc/sonic-ws");
     }
+    listenLock = false;
+    packetQueue = [];
     listenPacket(data, code) {
         const listeners = this.listeners.event[code];
         if (!listeners)
-            return console.warn("Warn: No listener for packet " + this.serverPackets.getTag(code));
-        (0, PacketUtils_1.listenPacket)(data, listeners, this.invalidPacket);
+            return console.warn("Warn: No listener for packet " + code);
+        this.enqueuePacket(data, code, listeners);
+    }
+    isAsync(code) {
+        return this.asyncMap[code];
+    }
+    async enqueuePacket(data, code, listeners) {
+        const isAsync = this.isAsync(code);
+        let locked;
+        let packetQueue;
+        let asyncData;
+        if (isAsync) {
+            asyncData = this.asyncData[code];
+            locked = asyncData[0];
+            packetQueue = asyncData[1];
+        }
+        else {
+            locked = this.listenLock;
+            packetQueue = this.packetQueue;
+        }
+        if (locked) {
+            packetQueue.push([data, code]);
+            return;
+        }
+        if (isAsync)
+            asyncData[0] = true;
+        else
+            this.listenLock = true;
+        let currentData = data;
+        let currentCode = code;
+        while (true) {
+            await (0, PacketUtils_1.listenPacket)(currentData, listeners, this.invalidPacket);
+            if (packetQueue.length === 0)
+                break;
+            [currentData, currentCode] = packetQueue.shift();
+        }
+        if (isAsync)
+            asyncData[0] = false;
+        else
+            this.listenLock = false;
     }
     async messageHandler(event) {
         const data = await this.bufferHandler(event);

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

@@ -5,8 +5,9 @@ export type ValidatorFunction = ((socket: SonicWSConnection, values: any) => boo
 export type ConvertType<T> = T extends EnumPackage ? PacketType.ENUMS : T;
 type ImpactType<T extends (PacketType | readonly PacketType[]), K> = T extends PacketType[] ? K[] : K;
 export declare class Packet<T extends (PacketType | readonly PacketType[])> {
-    readonly tag: string;
     defaultEnabled: boolean;
+    readonly tag: string;
+    readonly async: boolean;
     readonly maxSize: number;
     readonly minSize: number;
     readonly type: T;
@@ -44,10 +45,11 @@ export declare class PacketSchema<T extends (PacketType | readonly PacketType[])
     enumData: EnumPackage[];
     dontSpread: boolean;
     autoFlatten: boolean;
+    async: boolean;
     object: boolean;
     constructor(object: boolean);
     testObject(): this is PacketSchema<PacketType[]>;
-    static single<T extends PacketType | EnumPackage>(type: T, dataMax: number, dataMin: number, dontSpread: boolean, dataBatching: number, maxBatchSize: number, rateLimit: number): PacketSchema<ConvertType<T>>;
-    static object<T extends readonly (PacketType | EnumPackage)[]>(types: T, dataMaxes: number[], dataMins: number[], dontSpread: boolean, autoFlatten: boolean, dataBatching: number, maxBatchSize: number, rateLimit: number): PacketSchema<ConvertType<T[number]>[]>;
+    static single<T extends PacketType | EnumPackage>(type: T, dataMax: number, dataMin: number, dontSpread: boolean, dataBatching: number, maxBatchSize: number, rateLimit: number, async: boolean): PacketSchema<ConvertType<T>>;
+    static object<T extends readonly (PacketType | EnumPackage)[]>(types: T, dataMaxes: number[], dataMins: number[], dontSpread: boolean, autoFlatten: boolean, dataBatching: number, maxBatchSize: number, rateLimit: number, async: boolean): PacketSchema<ConvertType<T[number]>[]>;
 }
 export {};

package/dist/ws/packets/Packets.js

@@ -25,8 +25,9 @@ const PacketType_1 = require("./PacketType");
 const BufferUtil_1 = require("../util/BufferUtil");
 const StringUtil_1 = require("../util/StringUtil");
 class Packet {
-    tag;
     defaultEnabled;
+    tag;
+    async;
     maxSize;
     minSize;
     type;
@@ -51,6 +52,7 @@ class Packet {
         this.tag = tag;
         this.defaultEnabled = enabled;
         this.client = client;
+        this.async = schema.async;
         this.enumData = schema.enumData;
         this.rateLimit = schema.rateLimit;
         this.dontSpread = schema.dontSpread;
@@ -119,6 +121,7 @@ class Packet {
         const sharedData = [
             this.tag.length, ...(0, StringUtil_1.processCharCodes)(this.tag),
             this.dontSpread ? 1 : 0,
+            this.async ? 1 : 0,
             this.dataBatching,
             this.enumData.length, ...this.enumData.map(x => x.serialize()).flat(),
         ];
@@ -160,6 +163,8 @@ class Packet {
         const tag = (0, BufferUtil_1.as8String)(data.slice(offset, offset += tagLength));
         // then read dont spread, go up 1
         const dontSpread = data[offset++] == 1;
+        // read async
+        const async = data[offset++] == 1;
         // read batching, up 1
         const dataBatching = data[offset++];
         // read enum length, up 1
@@ -205,7 +210,7 @@ class Packet {
             let index = 0;
             const finalTypes = types.map(x => x == PacketType_1.PacketType.ENUMS ? enums[index++] : x); // convert enums to their enum packages
             // make schema
-            const schema = PacketSchema.object(finalTypes, dataMaxes, dataMins, dontSpread, autoFlatten, dataBatching, -1, -1);
+            const schema = PacketSchema.object(finalTypes, dataMaxes, dataMins, dontSpread, autoFlatten, dataBatching, -1, -1, async);
             return [
                 new Packet(tag, schema, null, false, client),
                 // +1 to go next
@@ -224,7 +229,7 @@ class Packet {
         // do enum stuff
         const finalType = type == PacketType_1.PacketType.ENUMS ? enums[0] : type; // convert enum to enum package
         // make schema
-        const schema = PacketSchema.single(finalType, dataMax, dataMin, dontSpread, dataBatching, -1, -1);
+        const schema = PacketSchema.single(finalType, dataMax, dataMin, dontSpread, dataBatching, -1, -1, async);
         return [
             new Packet(tag, schema, null, false, client),
             // +1 to go next
@@ -253,6 +258,7 @@ class PacketSchema {
     enumData = [];
     dontSpread = false;
     autoFlatten = false;
+    async = false;
     object;
     constructor(object) {
         this.object = object;
@@ -260,7 +266,7 @@ class PacketSchema {
     testObject() {
         return this.object;
     }
-    static single(type, dataMax, dataMin, dontSpread, dataBatching, maxBatchSize, rateLimit) {
+    static single(type, dataMax, dataMin, dontSpread, dataBatching, maxBatchSize, rateLimit, async) {
         const schema = new PacketSchema(false);
         if (typeof type == 'number') {
             schema.type = type;
@@ -277,9 +283,10 @@ class PacketSchema {
         schema.dataBatching = dataBatching;
         schema.maxBatchSize = maxBatchSize;
         schema.rateLimit = rateLimit;
+        schema.async = async;
         return schema;
     }
-    static object(types, dataMaxes, dataMins, dontSpread, autoFlatten, dataBatching, maxBatchSize, rateLimit) {
+    static object(types, dataMaxes, dataMins, dontSpread, autoFlatten, dataBatching, maxBatchSize, rateLimit, async) {
         if (types.length != dataMaxes.length || types.length != dataMins.length)
             throw new Error("There is an inbalance between the amount of types, data maxes, and data mins!");
         const schema = new PacketSchema(true);
@@ -300,6 +307,7 @@ class PacketSchema {
         schema.dataBatching = dataBatching;
         schema.maxBatchSize = maxBatchSize;
         schema.rateLimit = rateLimit;
+        schema.async = async;
         return schema;
     }
 }

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

@@ -20,11 +20,16 @@ export declare class SonicWSConnection implements Connection {
     /** The index of the connection; unique for all connected, recycles old disconnected ids. Should be safe for INTS_C unless you have more than 27,647 connected at once. */
     id: number;
     _timers: Record<number, [number, (closed: boolean) => void, boolean]>;
+    private asyncMap;
+    private asyncData;
     private closed;
     constructor(socket: WS.WebSocket, host: SonicWSServer, id: number, handshakePacket: string | null, clientRateLimit: number, serverRateLimit: number);
     private parseData;
     private handshakeHandler;
     private invalidPacket;
+    private isAsync;
+    private listenLock;
+    private packetQueue;
     private listenPacket;
     private messageHandler;
     /**

package/dist/ws/server/SonicWSConnection.js

@@ -80,6 +80,8 @@ class SonicWSConnection {
     /** The index of the connection; unique for all connected, recycles old disconnected ids. Should be safe for INTS_C unless you have more than 27,647 connected at once. */
     id;
     _timers = {};
+    asyncMap = {};
+    asyncData = {};
     closed = false;
     constructor(socket, host, id, handshakePacket, clientRateLimit, serverRateLimit) {
         this.socket = socket;
@@ -87,9 +89,13 @@ class SonicWSConnection {
         this.id = id;
         this.handshakePacket = handshakePacket;
         this.listeners = {};
-        for (const key of host.clientPackets.getTags()) {
-            this.listeners[key] = [];
-            this.enabledPackets[key] = host.clientPackets.getPacket(key).defaultEnabled;
+        for (const tag of host.clientPackets.getTags()) {
+            this.listeners[tag] = [];
+            const pack = host.clientPackets.getPacket(tag);
+            this.enabledPackets[tag] = pack.defaultEnabled;
+            this.asyncMap[tag] = pack.async;
+            if (pack.async)
+                this.asyncData[tag] = [false, []];
         }
         this.setInterval = this.setInterval.bind(this);
         this.batcher = new BatchHelper_1.BatchHelper();
@@ -163,10 +169,45 @@ class SonicWSConnection {
         console.log("Closure cause", listened);
         this.socket.close(4003, listened);
     }
-    listenPacket(data, tag) {
+    isAsync(tag) {
+        return this.asyncMap[tag];
+    }
+    listenLock = false;
+    packetQueue = [];
+    async listenPacket(data, tag) {
         if (this.closed)
             return;
-        (0, PacketUtils_1.listenPacket)(data, this.listeners[tag], this.invalidPacket);
+        const isAsync = this.isAsync(tag);
+        let locked, packetQueue, asyncData;
+        if (isAsync) {
+            asyncData = this.asyncData[tag];
+            locked = asyncData[0];
+            packetQueue = asyncData[1];
+        }
+        else {
+            locked = this.listenLock;
+            packetQueue = this.packetQueue;
+        }
+        if (locked) {
+            packetQueue.push([data, tag]);
+            return;
+        }
+        if (isAsync)
+            asyncData[0] = true;
+        else
+            this.listenLock = true;
+        let currentData = data;
+        let currentTag = tag;
+        while (true) {
+            await (0, PacketUtils_1.listenPacket)(currentData, this.listeners[currentTag], this.invalidPacket);
+            if (packetQueue.length === 0)
+                break;
+            [currentData, currentTag] = packetQueue.shift();
+        }
+        if (isAsync)
+            asyncData[0] = false;
+        else
+            this.listenLock = false;
     }
     messageHandler(data) {
         if (data == null)

package/dist/ws/server/SonicWSServer.js

@@ -94,6 +94,11 @@ class SonicWSServer {
                 this.connections.splice(this.connections.indexOf(sonicConnection), 1);
                 delete this.connectionMap[sonicConnection.id];
                 this.availableIds.push(sonicConnection.id);
+                if (this.tags.has(sonicConnection)) {
+                    for (const tag of this.tags.get(sonicConnection))
+                        this.tagsInv.get(tag)?.delete(sonicConnection);
+                    this.tags.delete(sonicConnection);
+                }
             });
         });
         fetch('https://raw.githubusercontent.com/liwybloc/sonic-ws/refs/heads/main/release/version')

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

@@ -43,7 +43,6 @@ class PacketHolder {
         this.packetMap = {};
         if (!packets)
             return;
-        this.packets = packets;
         this.holdPackets(packets);
     }
     /** Assigns a new unique key to a tag */
@@ -57,6 +56,7 @@ class PacketHolder {
      * @param packets Array of packets to register
      */
     holdPackets(packets) {
+        this.packets = packets;
         for (const packet of packets)
             this.createKey(packet.tag), this.packetMap[packet.tag] = packet;
     }

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

@@ -16,7 +16,7 @@ export declare function processPacket(packets: PacketHolder, tag: string, values
  * @param listeners The listeners to run
  * @param errorCB The callback if something goes wrong
  */
-export declare function listenPacket(listened: string | [any[], boolean], listeners: ((...values: any) => void)[], errorCB: (data: string) => void): void;
+export declare function listenPacket(listened: string | [any[], boolean], listeners: ((...values: any) => void | Promise<void>)[], errorCB: (data: string) => void): Promise<void>;
 /** Valid packet type */
 export type ArguableType = PacketType | EnumPackage;
 /** Shared packet setting types */
@@ -47,6 +47,8 @@ export type SharedPacketSettings = {
     enabled?: boolean;
     /** A validation function that is called whenever data is received. Return true for success, return false to kick socket. */
     validator?: ValidatorFunction;
+    /** If this is true, other packets will be processed even if this one isn't finished; it'll still prevent it from calling twice before this finishes though. Defaults to false. */
+    async?: boolean;
 };
 /** Settings for single-typed packets */
 export type SinglePacketSettings = SharedPacketSettings & {

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

@@ -73,16 +73,21 @@ function processPacket(packets, tag, values) {
  * @param listeners The listeners to run
  * @param errorCB The callback if something goes wrong
  */
-function listenPacket(listened, listeners, errorCB) {
-    // if invalid then ignore it and call back
-    if (typeof listened == 'string')
+async function listenPacket(listened, listeners, errorCB) {
+    if (typeof listened === 'string')
         return errorCB(listened);
     const [processed, flatten] = listened;
     try {
-        if (flatten && Array.isArray(processed))
-            listeners.forEach(l => l(...processed));
-        else
-            listeners.forEach(l => l(processed));
+        if (flatten && Array.isArray(processed)) {
+            for (const l of listeners) {
+                await l(...processed);
+            }
+        }
+        else {
+            for (const l of listeners) {
+                await l(processed);
+            }
+        }
     }
     catch (err) {
         errorCB(err);
@@ -127,7 +132,7 @@ function clampDataMin(dataMin, dataMax) {
  * @throws {Error} If the `type` is invalid.
  */
 function CreatePacket(settings) {
-    let { tag, type = PacketType_1.PacketType.NONE, dataMax = 1, dataMin = 1, noDataRange = false, dontSpread = false, validator = null, dataBatching = 0, maxBatchSize = 10, rateLimit = 0, enabled = true, } = settings;
+    let { tag, type = PacketType_1.PacketType.NONE, dataMax = 1, dataMin = 1, noDataRange = false, dontSpread = false, validator = null, dataBatching = 0, maxBatchSize = 10, rateLimit = 0, enabled = true, async = false } = settings;
     if (!tag)
         throw new Error("Tag not selected!");
     if (noDataRange) {
@@ -139,7 +144,7 @@ function CreatePacket(settings) {
     if (isInvalidType(type)) {
         throw new Error(`Invalid packet type: ${type}`);
     }
-    const schema = Packets_1.PacketSchema.single(type, clampDataMax(dataMax), clampDataMin(dataMin, dataMax), dontSpread, dataBatching, maxBatchSize, rateLimit);
+    const schema = Packets_1.PacketSchema.single(type, clampDataMax(dataMax), clampDataMin(dataMin, dataMax), dontSpread, dataBatching, maxBatchSize, rateLimit, async);
     return new Packets_1.Packet(tag, schema, validator, enabled, false);
 }
 /**
@@ -150,7 +155,7 @@ function CreatePacket(settings) {
  * @throws {Error} If any type in `types` is invalid.
  */
 function CreateObjPacket(settings) {
-    let { tag, types = [], dataMaxes, dataMins, noDataRange = false, dontSpread = false, autoFlatten = false, validator = null, dataBatching = 0, maxBatchSize = 10, rateLimit = 0, enabled = true } = settings;
+    let { tag, types = [], dataMaxes, dataMins, noDataRange = false, dontSpread = false, autoFlatten = false, validator = null, dataBatching = 0, maxBatchSize = 10, rateLimit = 0, enabled = true, async = false } = settings;
     if (!tag)
         throw new Error("Tag not selected!");
     if (types.length == 0)
@@ -176,7 +181,7 @@ function CreateObjPacket(settings) {
     }
     const clampedDataMaxes = dataMaxes.map(clampDataMax);
     const clampedDataMins = dataMins.map((m, i) => types[i] == PacketType_1.PacketType.NONE ? 0 : clampDataMin(m, clampedDataMaxes[i]));
-    const schema = Packets_1.PacketSchema.object(types, clampedDataMaxes, clampedDataMins, dontSpread, autoFlatten, dataBatching, maxBatchSize, rateLimit);
+    const schema = Packets_1.PacketSchema.object(types, clampedDataMaxes, clampedDataMins, dontSpread, autoFlatten, dataBatching, maxBatchSize, rateLimit, async);
     return new Packets_1.Packet(tag, schema, validator, enabled, false);
 }
 /**
@@ -186,7 +191,7 @@ function CreateObjPacket(settings) {
  * @returns The constructed packet structure data.
  */
 function CreateEnumPacket(settings) {
-    const { tag, enumData, dataMax = 1, dataMin = 0, noDataRange = false, dontSpread = false, validator = null, dataBatching = 0, maxBatchSize = 10, rateLimit = 0, enabled = true } = settings;
+    const { tag, enumData, dataMax = 1, dataMin = 0, noDataRange = false, dontSpread = false, validator = null, dataBatching = 0, maxBatchSize = 10, rateLimit = 0, enabled = true, async = false } = settings;
     return CreatePacket({
         tag: tag,
         type: enumData,
@@ -199,6 +204,7 @@ function CreateEnumPacket(settings) {
         maxBatchSize,
         rateLimit,
         enabled,
+        async,
     });
 }
 /**

package/package.json

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