sonic-ws 1.0.0-rc.7 → 1.0.0

package/README.md

@@ -7,17 +7,19 @@ SonicWS is an ultra-lightweight, high-performance WebSocket library focused on m
 Compression:
 - Lossless compression up to 70% or more (for example, 38kb -> 14kb)
 - Optimized bandwidth for many different types to fit special constraints
-- Automatic helpers to flatten nested arrays for maximum wire efficiency
+- Automatic helpers to flatten typed nested arrays for maximum wire efficiency (for example, [[1,2,3],[4,5,6]] to [[1,4],[2,5],[3,6]])
+- Uses raw binary bytes to transmit data as efficiently as possible while still using high level readable code
 
 Developer Friendly:
 - Predefined data types of various sized integers, decimals, strings, enums, etc. and RAW for any special cases
-- Keys are automatically indexed before transfer, improving readability (for example, send("pixel") and send("p") become identical)
+- 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
 
 Security:
-- Tamper-proof; any invalid packet instantly causes closure, and tampering is very likely to as well
-- Built-in ability for handshake packets, preventing constant if(!init) checks and null checks in every listener
+- Tamper-proof; any invalid packet instantly causes closure, and tampering becomes incredibly difficult
+- 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
 
 Performance & Scaling:
 - Can handle very large packets in microseconds
@@ -27,9 +29,11 @@ Performance & Scaling:
 
 Developer Experience:
 - Minimal boilerplate code due to listeners only receiving valid data
-- Enums can map to any primitive value, such as numbers, strings, null, etc. in 1 byte
+- Enums can map to any primitive value (e.g. number, string, boolean, null) and transmits in 1 byte
 - Timers and intervals for sockets that automatically clear upon closure
+- Many data types to maximize speed, clarity, bandwidth, and security
 - Debug tools for socket ids, byte size, data logging, etc. for troubleshooting
+- Very minimal learning curve, easy to work in
 - JSDoc's for understanding
 
 Whether you're making a real-time game, a dashboard, a distributed system, or anything else, SonicWS gets you safe, structured packets, fast.
@@ -51,11 +55,11 @@ Browser (Client):
 ```js
 const wss = new SonicWSServer({
     clientPackets: [
-        CreatePacket({tag: "pong", type: PacketType.INTS_D, dataMax: 1})
+        CreatePacket({tag: "pong", type: PacketType.VARINT, dataMax: 1})
     ],
     serverPackets: [
-        CreatePacket({tag: "ping", type: PacketType.INTS_D, dataMax: 1}),
-        CreateObjPacket({tag: "data", types: [PacketType.INTS_A, PacketTypes.STRING], dataMaxes: [2, 3]})
+        CreatePacket({tag: "ping", type: PacketType.VARINT, dataMax: 1}),
+        CreateObjPacket({tag: "data", types: [PacketType.BYTES, PacketTypes.STRINGS], dataMaxes: [2, 3]})
     ],
     websocketOptions: { port: 1234 }
 });
@@ -66,10 +70,10 @@ wss.on_connect((socket) => {
 
     socket.on("pong", (num) => {
         console.log("Ponged!", num);
-        socket.send("data", [Math.floor(Math.random() * 1000), Math.floor(Math.random() * 1000)], ["hello", "from", "server"]);
+        socket.send("data", [Math.floor(Math.random() * 26), Math.floor(Math.random() * 256)], ["hello", "from", "server"]);
     });
 
-    setInterval(() => {
+    socket.setInterval(() => {
         socket.send("ping", Date.now());
     }, 10000);
 
@@ -106,6 +110,10 @@ ws.on_close((event) => {
 
 Batch rate limit is off by 1
 
+Varint max is off by a bit
+
 ## PLANNED FEATURES
 
-More data checking and better error handling
+More data checking and better error handling
+
+Implement a better system for data min/max

package/dist/index.js

@@ -1,6 +1,6 @@
 "use strict";
 /*
- * Copyright 2025 Lily (cutelittlelily)
+ * Copyright 2025 Lily (liwybloc)
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.

package/dist/version.d.ts

@@ -1,4 +1,6 @@
 /** Current protocol version */
-export declare const VERSION = 8;
-/** Current protocol version as a character */
-export declare const VERSION_CHAR: string;
+export declare const VERSION = 9;
+/** Server data suffix */
+export declare const SERVER_SUFFIX = "SWS";
+/** Server data suffix in array */
+export declare const SERVER_SUFFIX_NUMS: number[];

package/dist/version.js

@@ -1,6 +1,6 @@
 "use strict";
 /*
- * Copyright 2025 Lily (cutelittlelily)
+ * Copyright 2025 Lily (liwybloc)
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -15,8 +15,11 @@
  * limitations under the License.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.VERSION_CHAR = exports.VERSION = void 0;
+exports.SERVER_SUFFIX_NUMS = exports.SERVER_SUFFIX = exports.VERSION = void 0;
+var StringUtil_1 = require("./ws/util/StringUtil");
 /** Current protocol version */
-exports.VERSION = 8;
-/** Current protocol version as a character */
-exports.VERSION_CHAR = String.fromCharCode(exports.VERSION);
+exports.VERSION = 9;
+/** Server data suffix */
+exports.SERVER_SUFFIX = "SWS";
+/** Server data suffix in array */
+exports.SERVER_SUFFIX_NUMS = (0, StringUtil_1.processCharCodes)(exports.SERVER_SUFFIX);

package/dist/ws/Connection.d.ts

@@ -0,0 +1,19 @@
+export interface Connection {
+    timers: Record<number, number>;
+    /** Sets an auto closing timer on the connection. Use connection.clearTimeout to prevent memory waste. */
+    setTimeout(call: () => void, time: number): number;
+    /** Sets an auto closing interval on the connection. Use connection.clearInterval to prevent memory waste. */
+    setInterval(call: () => void, time: number): number;
+    /** Safely clears a timer */
+    clearTimeout(index: number): void;
+    /** Safely clears an interval */
+    clearInterval(index: number): void;
+    /**
+     * Sends the uint8array through the connection
+     */
+    raw_send(data: Uint8Array): void;
+    /**
+     * Closes the connection
+     */
+    close(code?: number, reason?: string): void;
+}

package/dist/ws/Connection.js

@@ -0,0 +1,17 @@
+"use strict";
+/*
+ * Copyright 2025 Lily (liwybloc)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -1,12 +1,13 @@
 import { PacketHolder } from '../../util/packets/PacketHolder';
-export declare abstract class SonicWSCore {
+import { Connection } from '../../Connection';
+export declare abstract class SonicWSCore implements Connection {
     /** Raw 'ws' library connection / webjs WebSocket class */
     socket: WebSocket;
     protected listeners: {
-        message: Array<(data: string) => void>;
+        message: Array<(data: Uint8Array) => void>;
         close: Array<(event: CloseEvent) => void>;
         event: {
-            [key: string]: Array<(...data: any[]) => void>;
+            [key: number]: Array<(...data: any[]) => void>;
         };
     };
     protected preListen: {
@@ -16,12 +17,12 @@ export declare abstract class SonicWSCore {
     protected serverPackets: PacketHolder;
     private pastKeys;
     private readyListeners;
-    private keyHandler;
-    private sendQueue;
-    private timers;
     private batcher;
+    private bufferHandler;
     id: number;
-    constructor(ws: WebSocket);
+    timers: Record<number, number>;
+    constructor(ws: WebSocket, bufferHandler: (val: MessageEvent) => Promise<Uint8Array>);
+    private reading;
     private serverKeyHandler;
     private invalidPacket;
     private listenPacket;
@@ -31,11 +32,11 @@ export declare abstract class SonicWSCore {
      * Listens for all messages rawly
      * @param listener Callback for when data is received
      */
-    raw_onmessage(listener: (data: string) => void): void;
+    raw_onmessage(listener: (data: Uint8Array) => void): void;
     /**
      * Sends raw data
      */
-    raw_send(data: string): void;
+    raw_send(data: Uint8Array): void;
     /**
      * Sends a packet to the server
      * @param tag The tag of the packet
@@ -58,16 +59,33 @@ export declare abstract class SonicWSCore {
      * @param listener The callback with the values
      */
     on(tag: string, listener: (value: any[]) => void): void;
+    private setTimer;
     /**
      * Sets a timeout that will automatically end when the socket closes
      * @param call The function to call
      * @param time The time between now and the call (ms)
+     * @returns The timeout id to be used with socket.clearInterval(id)
      */
     setTimeout(call: () => void, time: number): number;
     /**
      * Sets an interval that will automatically end when the socket closes
      * @param call The function to call
      * @param time The time between calls (ms)
+     * @returns The interval id to be used with socket.clearInterval(id)
      */
     setInterval(call: () => void, time: number): number;
+    /**
+     * Clears a timeout
+     * @param id The timeout id
+     */
+    clearTimeout(id: number): void;
+    /**
+     * Clears an interval
+     * @param id The interval id
+     */
+    clearInterval(id: number): void;
+    /**
+     * Closes the connection
+     */
+    close(code?: number, reason?: string): void;
 }

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

@@ -1,6 +1,6 @@
 "use strict";
 /*
- * Copyright 2025 Lily (cutelittlelily)
+ * Copyright 2025 Lily (liwybloc)
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -14,26 +14,61 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SonicWSCore = void 0;
 var PacketHolder_1 = require("../../util/packets/PacketHolder");
-var CodePointUtil_1 = require("../../util/packets/CodePointUtil");
+var CompressionUtil_1 = require("../../util/packets/CompressionUtil");
 var PacketUtils_1 = require("../../util/packets/PacketUtils");
 var version_1 = require("../../../version");
 var Packets_1 = require("../../packets/Packets");
 var BatchHelper_1 = require("../../util/packets/BatchHelper");
-// throttle at 90% of rate limit to avoid spikes and kicks
-var THRESHOLD_MULT = 0.90;
+var BufferUtil_1 = require("../../util/BufferUtil");
 var SonicWSCore = /** @class */ (function () {
-    function SonicWSCore(ws) {
+    function SonicWSCore(ws, bufferHandler) {
         var _this = this;
         this.clientPackets = new PacketHolder_1.PacketHolder();
         this.serverPackets = new PacketHolder_1.PacketHolder();
         this.pastKeys = false;
         this.readyListeners = [];
-        this.sendQueue = [];
-        this.timers = [];
         this.id = -1;
+        this.timers = {};
+        this.reading = false;
         this.socket = ws;
         this.listeners = {
             message: [],
@@ -43,74 +78,107 @@ var SonicWSCore = /** @class */ (function () {
         this.preListen = {};
         this.batcher = new BatchHelper_1.BatchHelper();
         this.invalidPacket = this.invalidPacket.bind(this);
-        this.keyHandler = function (event) { return _this.serverKeyHandler(event); };
-        this.socket.addEventListener('message', this.keyHandler); // lambda to persist 'this'
+        this.serverKeyHandler = this.serverKeyHandler.bind(this);
+        this.messageHandler = this.messageHandler.bind(this);
+        this.socket.addEventListener('message', this.serverKeyHandler);
         this.socket.addEventListener('close', function (event) {
             _this.listeners.close.forEach(function (listener) { return listener(event); });
-            _this.timers.forEach(clearTimeout);
+            Object.values(_this.timers).forEach(clearTimeout);
         });
+        this.bufferHandler = bufferHandler;
     }
     SonicWSCore.prototype.serverKeyHandler = function (event) {
-        var _this = this;
-        var data = event.data.toString();
-        if (!data.startsWith("SWS")) {
-            this.socket.close(1000);
-            throw new Error("The server requested is not a Sonic WS server.");
-        }
-        var version = data.charCodeAt(3);
-        if (version != version_1.VERSION) {
-            this.socket.close(1000);
-            throw new Error("Version mismatch: ".concat(version > version_1.VERSION ? "client" : "server", " is outdated (server: ").concat(version, ", client: ").concat(version_1.VERSION, ")"));
-        }
-        var _a = data.substring(4).split(CodePointUtil_1.NULL), ckData = _a[0], skData = _a[1], uData = _a[2];
-        this.clientPackets.holdPackets(Packets_1.Packet.deserializeAll(ckData, true));
-        this.serverPackets.holdPackets(Packets_1.Packet.deserializeAll(skData, true));
-        this.batcher.registerSendPackets(this.clientPackets, this);
-        Object.keys(this.preListen).forEach(function (tag) { return _this.preListen[tag].forEach(function (listener) {
-            var key = _this.serverPackets.get(tag);
-            // print the error to console without halting execution
-            if (key == null)
-                return console.error(new Error("The server does not send the packet with tag \"".concat(tag, "\"!")));
-            _this.listen(tag, listener);
-        }); });
-        this.preListen = null; // clear
-        this.pastKeys = true;
-        this.readyListeners.forEach(function (l) { return l(); });
-        this.readyListeners = null; // clear
-        this.socket.removeEventListener('message', this.keyHandler);
-        this.socket.addEventListener('message', function (event) { return _this.messageHandler(event); }); // lambda to persist 'this'
-        this.keyHandler = null;
+        return __awaiter(this, void 0, void 0, function () {
+            var data, version, _a, off, ckLength, ckData, skData;
+            var _this = this;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        // stupid asynchronous bullshit
+                        if (this.reading)
+                            return [2 /*return*/, this.messageHandler(event)];
+                        this.reading = true;
+                        return [4 /*yield*/, this.bufferHandler(event)];
+                    case 1:
+                        data = _b.sent();
+                        if (data.length < 3 || (0, BufferUtil_1.as8String)(data.slice(0, 3)) != version_1.SERVER_SUFFIX) {
+                            this.socket.close(1000);
+                            throw new Error("The server requested is not a Sonic WS server.");
+                        }
+                        if (data.length == 3) {
+                            // todo: queue
+                            return [2 /*return*/];
+                        }
+                        version = data[3];
+                        if (version != version_1.VERSION) {
+                            this.socket.close(1000);
+                            throw new Error("Version mismatch: ".concat(version > version_1.VERSION ? "client" : "server", " is outdated (server: ").concat(version, ", client: ").concat(version_1.VERSION, ")"));
+                        }
+                        _a = (0, CompressionUtil_1.readVarInt)(data, 4, false), off = _a[0], ckLength = _a[1];
+                        ckData = data.slice(off, off + ckLength);
+                        this.clientPackets.holdPackets(Packets_1.Packet.deserializeAll(ckData, true));
+                        skData = data.slice(off + ckLength, data.length - 1);
+                        this.serverPackets.holdPackets(Packets_1.Packet.deserializeAll(skData, true));
+                        this.id = data[data.length - 1];
+                        this.batcher.registerSendPackets(this.clientPackets, this);
+                        Object.keys(this.preListen).forEach(function (tag) { return _this.preListen[tag].forEach(function (listener) {
+                            var key = _this.serverPackets.getKey(tag);
+                            // print the error to console without halting execution
+                            if (key == null)
+                                return console.error(new Error("The server does not send the packet with tag \"".concat(tag, "\"!")));
+                            _this.listen(tag, listener);
+                        }); });
+                        this.preListen = null; // clear
+                        this.pastKeys = true;
+                        this.readyListeners.forEach(function (l) { return l(); });
+                        this.readyListeners = null; // clear
+                        this.socket.removeEventListener('message', this.serverKeyHandler);
+                        this.socket.addEventListener('message', this.messageHandler);
+                        return [2 /*return*/];
+                }
+            });
+        });
     };
     SonicWSCore.prototype.invalidPacket = function (listened) {
         console.log(listened);
         throw new Error("An error occured with data from the server!! This is probably my fault.. make an issue at https://github.com/cutelittlelily/sonic-ws");
     };
     SonicWSCore.prototype.listenPacket = function (data, code) {
-        (0, PacketUtils_1.listenPacket)(data, this.listeners.event[code], this.invalidPacket);
+        var 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);
     };
     SonicWSCore.prototype.messageHandler = function (event) {
-        var _this = this;
-        var data = event.data.toString();
-        this.listeners.message.forEach(function (listener) { return listener(data); });
-        if (data.length < 1)
-            return;
-        var key = data.substring(0, 1);
-        var value = data.substring(1);
-        var code = key.charCodeAt(0);
-        if (code == null)
-            return;
-        var packet = this.serverPackets.getPacket(this.serverPackets.getTag(key));
-        if (packet.dataBatching == 0) {
-            this.listenPacket(packet.listen(value, null), code);
-            return;
-        }
-        var batchData = BatchHelper_1.BatchHelper.unravelBatch(packet, value, null);
-        if (typeof batchData == 'string')
-            return this.invalidPacket(batchData);
-        batchData.forEach(function (data) { return _this.listenPacket(data, code); });
+        return __awaiter(this, void 0, void 0, function () {
+            var data, key, value, packet, batchData;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.bufferHandler(event)];
+                    case 1:
+                        data = _a.sent();
+                        this.listeners.message.forEach(function (listener) { return listener(data); });
+                        if (data.length < 1)
+                            return [2 /*return*/];
+                        key = data[0];
+                        value = data.slice(1);
+                        packet = this.serverPackets.getPacket(this.serverPackets.getTag(key));
+                        if (packet.dataBatching == 0) {
+                            this.listenPacket(packet.listen(value, null), key);
+                            return [2 /*return*/];
+                        }
+                        batchData = BatchHelper_1.BatchHelper.unravelBatch(packet, value, null);
+                        if (typeof batchData == 'string')
+                            return [2 /*return*/, this.invalidPacket(batchData)];
+                        batchData.forEach(function (data) { return _this.listenPacket(data, key); });
+                        return [2 /*return*/];
+                }
+            });
+        });
     };
     SonicWSCore.prototype.listen = function (key, listener) {
-        var skey = this.serverPackets.get(key);
+        var skey = this.serverPackets.getKey(key);
         if (!skey) {
             console.log("Key is not available on server: " + key);
             return;
@@ -144,7 +212,7 @@ var SonicWSCore = /** @class */ (function () {
         }
         var _a = (0, PacketUtils_1.processPacket)(this.clientPackets, tag, values), code = _a[0], data = _a[1], packet = _a[2];
         if (packet.dataBatching == 0)
-            this.raw_send(code + data);
+            this.raw_send((0, BufferUtil_1.toPacketBuffer)(code, data));
         else
             this.batcher.batchPacket(code, data);
     };
@@ -179,26 +247,56 @@ var SonicWSCore = /** @class */ (function () {
         }
         this.listen(tag, listener);
     };
+    SonicWSCore.prototype.setTimer = function (id) {
+        this.timers[id] = id;
+    };
     /**
      * Sets a timeout that will automatically end when the socket closes
      * @param call The function to call
      * @param time The time between now and the call (ms)
+     * @returns The timeout id to be used with socket.clearInterval(id)
      */
     SonicWSCore.prototype.setTimeout = function (call, time) {
-        var timeout = setTimeout(call, time);
-        this.timers.push(timeout);
+        var _this = this;
+        var timeout = setTimeout(function () {
+            call();
+            _this.clearTimeout(timeout);
+        }, time);
+        this.setTimer(timeout);
         return timeout;
     };
     /**
      * Sets an interval that will automatically end when the socket closes
      * @param call The function to call
      * @param time The time between calls (ms)
+     * @returns The interval id to be used with socket.clearInterval(id)
      */
     SonicWSCore.prototype.setInterval = function (call, time) {
         var interval = setInterval(call, time);
-        this.timers.push(interval);
+        this.setTimer(interval);
         return interval;
     };
+    /**
+     * Clears a timeout
+     * @param id The timeout id
+     */
+    SonicWSCore.prototype.clearTimeout = function (id) {
+        clearTimeout(id);
+        delete this.timers[id];
+    };
+    /**
+     * Clears an interval
+     * @param id The interval id
+     */
+    SonicWSCore.prototype.clearInterval = function (id) {
+        this.clearTimeout(id);
+    };
+    /**
+     * Closes the connection
+     */
+    SonicWSCore.prototype.close = function (code, reason) {
+        this.socket.close(code, reason);
+    };
     return SonicWSCore;
 }());
 exports.SonicWSCore = SonicWSCore;

package/dist/ws/client/node/ClientNode.js

@@ -1,6 +1,6 @@
 "use strict";
 /*
- * Copyright 2025 Lily (cutelittlelily)
+ * Copyright 2025 Lily (liwybloc)
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -46,7 +46,7 @@ var SonicWS = /** @class */ (function (_super) {
      */
     function SonicWS(url, options) {
         var ws = new ws_1.default.WebSocket(url, options);
-        return _super.call(this, ws) || this;
+        return _super.call(this, ws, function (val) { return Promise.resolve(new Uint8Array(val.data)); }) || this;
     }
     return SonicWS;
 }(ClientCore_1.SonicWSCore));

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

@@ -1,8 +1,13 @@
+import { EnumPackage } from "../util/enums/EnumType";
 import { Packet } from "./Packets";
 import { PacketType } from "./PacketType";
-export declare const PacketValidityProcessors: Record<PacketType, (data: string, dataCap: number, dataMin: number, packet: Packet, index: number) => boolean>;
-export declare const PacketReceiveProcessors: Record<PacketType, (data: string, cap: number, packet: Packet, index: number) => "" | string | string[] | number | number[] | boolean[]>;
-export declare const PacketSendProcessors: Record<PacketType, (...data: any) => string>;
-export declare function createObjSendProcessor(types: PacketType[], packetDelimitSize: number): (data: any[]) => string;
-export declare function createObjReceiveProcessor(types: PacketType[], packetDelimitSize: number): (data: string, dataCaps: number[], packet: Packet) => any;
-export declare function createObjValidator(types: PacketType[], packetDelimitSize: number): (data: string, dataCaps: number[], dataMins: number[], packet: Packet) => boolean;
+export type PacketTypeValidator = (data: Uint8Array, index: number) => false | any;
+export type PacketReceiveProcessor = (data: Uint8Array, validationResult: any, index: number) => any;
+export type PacketSendProcessor = (...data: any) => number[];
+export declare function createValidator(type: PacketType, dataCap: number, dataMin: number, enumData: EnumPackage[]): 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): PacketSendProcessor;
+export declare function createObjSendProcessor(packet: Packet): PacketSendProcessor;
+export declare function createObjReceiveProcessor(packet: Packet): PacketReceiveProcessor;
+export declare function createObjValidator(packet: Packet): PacketTypeValidator;