sonic-ws 1.0.0-rc.8 → 1.0.3

package/dist/ws/packets/Packets.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,46 +14,59 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PacketSchema = exports.Packet = void 0;
-var EnumHandler_1 = require("../util/enums/EnumHandler");
-var EnumType_1 = require("../util/enums/EnumType");
-var ArrayUtil_1 = require("../util/ArrayUtil");
-var CompressionUtil_1 = require("../util/packets/CompressionUtil");
-var PacketUtils_1 = require("../util/packets/PacketUtils");
-var PacketProcessors_1 = require("./PacketProcessors");
-var PacketType_1 = require("./PacketType");
-var Packet = /** @class */ (function () {
-    function Packet(tag, schema, customValidator, enabled, client) {
-        var _this = this;
+const EnumHandler_1 = require("../util/enums/EnumHandler");
+const EnumType_1 = require("../util/enums/EnumType");
+const CompressionUtil_1 = require("../util/packets/CompressionUtil");
+const PacketUtils_1 = require("../util/packets/PacketUtils");
+const PacketProcessors_1 = require("./PacketProcessors");
+const PacketType_1 = require("./PacketType");
+const BufferUtil_1 = require("../util/BufferUtil");
+const StringUtil_1 = require("../util/StringUtil");
+class Packet {
+    tag;
+    defaultEnabled;
+    maxSize;
+    minSize;
+    type;
+    enumData;
+    dataMax;
+    dataMin;
+    dataBatching;
+    maxBatchSize;
+    dontSpread;
+    autoFlatten;
+    rateLimit;
+    object;
+    client;
+    receiveProcessor;
+    sendProcessor;
+    validator;
+    processReceive;
+    processSend;
+    validate;
+    customValidator;
+    constructor(tag, schema, customValidator, enabled, client) {
         this.tag = tag;
         this.defaultEnabled = enabled;
+        this.client = client;
         this.enumData = schema.enumData;
         this.rateLimit = schema.rateLimit;
         this.dontSpread = schema.dontSpread;
         this.autoFlatten = schema.autoFlatten;
         this.dataBatching = schema.dataBatching;
         this.maxBatchSize = client ? Infinity : schema.maxBatchSize;
-        this.packetDelimitSize = schema.packetDelimitSize;
-        if (schema.object) {
+        this.object = schema.object;
+        if (this.object) {
             this.type = schema.types;
             this.dataMax = schema.dataMaxes;
             this.dataMin = schema.dataMins;
             this.maxSize = this.type.length;
             this.minSize = this.type.length;
-            this.object = true;
-            this.receiveProcessor = (0, PacketProcessors_1.createObjReceiveProcessor)(this.type, this.packetDelimitSize);
-            this.validifier = (0, PacketProcessors_1.createObjValidator)(this.type, this.packetDelimitSize);
-            this.sendProcessor = (0, PacketProcessors_1.createObjSendProcessor)(this.type, this.packetDelimitSize);
+            this.receiveProcessor = (0, PacketProcessors_1.createObjReceiveProcessor)(this);
+            this.validator = (0, PacketProcessors_1.createObjValidator)(this);
+            this.sendProcessor = (0, PacketProcessors_1.createObjSendProcessor)(this);
         }
         else {
             this.type = schema.type;
@@ -61,25 +74,25 @@ var Packet = /** @class */ (function () {
             this.dataMin = schema.dataMin;
             this.maxSize = this.dataMax;
             this.minSize = this.dataMin;
-            this.object = false;
-            this.receiveProcessor = PacketProcessors_1.PacketReceiveProcessors[this.type];
-            this.validifier = PacketProcessors_1.PacketValidityProcessors[this.type];
-            this.sendProcessor = PacketProcessors_1.PacketSendProcessors[this.type];
+            this.receiveProcessor = (0, PacketProcessors_1.createReceiveProcessor)(this.type, this.enumData, this.dataMax);
+            this.validator = (0, PacketProcessors_1.createValidator)(this.type, this.dataMax, this.dataMin, this);
+            this.sendProcessor = (0, PacketProcessors_1.createSendProcessor)(this.type);
         }
-        this.processReceive = function (data) { return _this.receiveProcessor(data, _this.dataMax, _this, 0); };
-        this.processSend = function (data) { return _this.sendProcessor(data); };
-        this.validate = client ? function () { return true; } : function (data) { return _this.validifier(data, _this.dataMax, _this.dataMin, _this, 0); };
+        this.processReceive = (data, validationResult) => this.receiveProcessor(data, validationResult, 0);
+        this.processSend = (data) => this.sendProcessor(data);
+        this.validate = (data) => this.validator(data, 0);
         this.customValidator = customValidator;
     }
-    Packet.prototype.listen = function (value, socket) {
+    listen(value, socket) {
         try {
-            if (!this.validate(value))
+            const validationResult = this.validate(value);
+            if (!this.client && validationResult == false)
                 return "Invalid packet";
-            var processed = this.processReceive(value);
-            var useableData = this.autoFlatten ? (0, PacketUtils_1.UnFlattenData)(processed) : processed;
+            const processed = this.processReceive(value, validationResult);
+            const useableData = this.autoFlatten ? (0, PacketUtils_1.UnFlattenData)(processed) : processed;
             if (this.customValidator != null) {
                 if (!this.dontSpread) {
-                    if (!this.customValidator.apply(this, __spreadArray([socket], useableData, false)))
+                    if (!this.customValidator(socket, ...useableData))
                         return "Didn't pass custom validator";
                 }
                 else {
@@ -93,146 +106,160 @@ var Packet = /** @class */ (function () {
             console.error("There was an error processing the packet! This is probably my fault... report at https://github.com/cutelittlelily/sonic-ws", err);
             return "Error: " + err;
         }
-    };
-    Packet.prototype.serializeINT_D = function (n) {
-        return String.fromCharCode.apply(String, (0, CompressionUtil_1.processCharCodes)((0, CompressionUtil_1.convertINT_D)(n, this.packetDelimitSize)).map(function (x) { return x + 1; }));
-    };
-    Packet.prototype.serialize = function () {
-        var _this = this;
-        // spread flag; ETX for "2", STX for "1", avoid NULL for delimiting
-        var spreadFlag = this.dontSpread ? CompressionUtil_1.ETX : CompressionUtil_1.STX;
-        // enum data, avoid null
-        var enumData = String.fromCharCode(this.enumData.length + 1) + this.enumData.map(function (x) { return x.serialize(); }).join("");
-        // data batching, also avoid null
-        var dataBatching = String.fromCharCode(this.dataBatching + 1) + String.fromCharCode(this.maxBatchSize + 1);
-        // rate limit, avoiding null again... ugh i should prob fix this with a map-
-        var rateLimit = String.fromCharCode(this.rateLimit + 1);
+    }
+    serialize() {
+        // shared values for both
+        const sharedData = [
+            this.tag.length, ...(0, StringUtil_1.processCharCodes)(this.tag),
+            this.dontSpread ? 1 : 0,
+            this.dataBatching,
+            this.enumData.length, ...this.enumData.map(x => x.serialize()).flat(),
+        ];
         // single-value packet (not an object schema)
         if (!this.object) {
-            return spreadFlag + dataBatching + rateLimit + enumData +
-                CompressionUtil_1.STX + // dummy byte flag for consistent deserialization; becomes -1 to indicate single
-                String.fromCharCode(this.dataMax + 1) + // the data max, offset by 1 for NULL
-                String.fromCharCode(this.dataMin + 1) + // the data min, offset by 1 for NULL
-                String.fromCharCode(this.type + 1) + // the type, offset by 1 for NULL
-                String.fromCharCode(this.tag.length + 1) + // tag length, offset by 1 for NULL
-                this.tag; // the tag
+            return [
+                ...sharedData, // shared
+                0, // dummy byte flag for consistent deserialization; becomes -1 to indicate single
+                ...(0, CompressionUtil_1.convertVarInt)(this.dataMax), // the data max
+                ...(0, CompressionUtil_1.convertVarInt)(this.dataMin), // the data min
+                this.type,
+            ];
         }
         // object packet
-        return spreadFlag + dataBatching + rateLimit + enumData +
-            String.fromCharCode(this.maxSize + 2) + // size, and +2 because of NULL and STX (STX is for single)
-            (this.autoFlatten ? CompressionUtil_1.ETX : CompressionUtil_1.STX) + // auto flatten flag
-            String.fromCharCode(this.packetDelimitSize + 1) + // packet delimit size, offset by 1 for NULL
-            this.dataMax.map(function (x) { return _this.serializeINT_D(x); }).join("") + // all data maxes, serialized
-            this.dataMin.map(function (x) { return _this.serializeINT_D(x); }).join("") + // all data mins, serialized
-            this.type.map(function (x) { return String.fromCharCode(x + 1); }).join("") + // all types, offset by 1 for NULL
-            String.fromCharCode(this.tag.length + 1) + // tag length, offset by 1 for NULL
-            this.tag; // the tag
-    };
-    Packet.processINT_Ds = function (area, packetDelimitSize) {
-        return (0, ArrayUtil_1.splitArray)((0, CompressionUtil_1.processCharCodes)(area), packetDelimitSize).map(function (x) { return (0, CompressionUtil_1.deconvertINT_DCodes)(x.map(function (y) { return y - 1; })); }); // subtract 1 to reverse
-    };
-    // i think i was high when i made these,
-    // probably ^^
-    Packet.deserialize = function (text, offset, client) {
-        var beginningOffset = offset;
-        var dontSpread = text[offset] == CompressionUtil_1.ETX;
-        var dataBatching = text.charCodeAt(++offset) - 1;
-        var maxBatchSize = text.charCodeAt(++offset) - 1;
-        var rateLimit = text.charCodeAt(++offset) - 1;
-        var enumLength = text.charCodeAt(++offset) - 1;
-        var enums = [];
-        for (var i = 0; i < enumLength; i++) {
-            var enumTagLength = text.charCodeAt(++offset) - 1;
-            var enumTag = text.slice(++offset, offset += enumTagLength);
-            offset--;
-            var valueCount = text.charCodeAt(++offset) - 1;
-            var values = [];
-            for (var j = 0; j < valueCount; j++) {
-                var valueLength = text.charCodeAt(++offset) - 1;
-                var valueType = text.charCodeAt(++offset) - 1;
-                var value = text.slice(++offset, offset += valueLength);
-                offset--;
+        return [
+            ...sharedData,
+            this.maxSize + 1, // size, and +1 because of 0 for single
+            this.autoFlatten ? 1 : 0, // auto flatten flag
+            ...this.dataMax.map(CompressionUtil_1.convertVarInt).flat(), // all data maxes, serialized
+            ...this.dataMin.map(CompressionUtil_1.convertVarInt).flat(), // all data mins, serialized
+            ...this.type, // all types, offset by 1 for NULL
+            this.tag.length, // tag length, offset by 1 for NULL
+        ];
+    }
+    static readVarInts(data, offset, size) {
+        const res = [];
+        for (let i = 0; i < size; i++) {
+            const [off, varint] = (0, CompressionUtil_1.readVarInt)(data, offset);
+            offset = off;
+            res.push(varint);
+        }
+        return [res, offset];
+    }
+    static deserialize(data, offset, client) {
+        const beginningOffset = offset;
+        // read length, go up 1
+        const tagLength = data[offset++];
+        // read tag as it's up 1, and add offset
+        const tag = (0, BufferUtil_1.as8String)(data.slice(offset, offset += tagLength));
+        // then read dont spread, go up 1
+        const dontSpread = data[offset++] == 1;
+        // read batching, up 1
+        const dataBatching = data[offset++];
+        // read enum length, up 1
+        const enumLength = data[offset++];
+        const enums = [];
+        for (let i = 0; i < enumLength; i++) {
+            // read tag length, go up 1
+            const enumTagLength = data[offset++];
+            // up 1 so read offset -> offset += tag length, to add tag length and skip over it
+            const enumTag = (0, BufferUtil_1.as8String)(data.slice(offset, offset += enumTagLength));
+            // read amount of values
+            const valueCount = data[offset++];
+            const values = [];
+            for (let j = 0; j < valueCount; j++) {
+                // read the length of the value, go up 1
+                const valueLength = data[offset++];
+                // then read the type of value, up 1
+                const valueType = data[offset++];
+                // now can just read the values, increase offset for later use
+                const value = (0, BufferUtil_1.as8String)(data.slice(offset, offset += valueLength));
+                // process it
                 values.push(EnumType_1.TYPE_CONVERSION_MAP[valueType](value));
             }
+            // define the enum with the values
             enums.push((0, EnumHandler_1.DefineEnum)(enumTag, values));
         }
-        var size = text.charCodeAt(++offset) - 2;
+        // read type count; prob should change sometime
+        const size = data[offset++] - 1;
         // objects
-        // the single packet is STX so STX - 2 = -1
+        // single packet is 0, 0 - 1 = -1
         if (size != -1) {
-            // ETX for true, STX for false
-            var autoFlatten = text[++offset] == CompressionUtil_1.ETX;
-            // delimiting size for huge packets
-            var packetDelimitSize = text.charCodeAt(++offset) - 1;
-            var areaSize = size * packetDelimitSize;
-            var dcStart = ++offset; // data maxes section start
-            var dcEnd = dcStart + areaSize; // data maxes section end
-            var dmStart = dcEnd; // data mins section start
-            var dmEnd = dmStart + areaSize; // data mins section end
-            var tStart = dmEnd; // types section start
-            var tEnd = tStart + size; // types section end
-            var tagStart_1 = tEnd + 1; // tag string starts after tag length byte
-            var dataMaxes = this.processINT_Ds(text.substring(dcStart, dcEnd), packetDelimitSize);
-            var dataMins = this.processINT_Ds(text.substring(dmStart, dmEnd), packetDelimitSize);
-            var types = (0, CompressionUtil_1.processCharCodes)(text.substring(tStart, tEnd)).map(function (x) { return x - 1; });
-            var index_1 = 0;
-            var finalTypes = types.map(function (x) { return x == PacketType_1.PacketType.ENUMS ? enums[index_1++] : x; }); // convert enums to their enum packages
-            var tagLength_1 = text.charCodeAt(tagStart_1 - 1) - 1; // tag length is right behind tag, subtracting 1 to reverse
-            var tag_1 = text.substring(tagStart_1, tagStart_1 + tagLength_1); // tag is tag length long. yeah
-            var schema_1 = PacketSchema.object(finalTypes, dataMaxes, dataMins, dontSpread, autoFlatten, packetDelimitSize, dataBatching, maxBatchSize, rateLimit);
+            // 1 for true, 0 for false
+            const autoFlatten = data[offset++] == 1;
+            // read var ints for the datamaxes
+            const [dataMaxes, o1] = this.readVarInts(data, offset, size);
+            offset = o1;
+            // read var ints for the datamins
+            const [dataMins, o2] = this.readVarInts(data, offset, size);
+            offset = o2;
+            // get types, skip past size since there'll be size of these
+            const types = Array.from(data.slice(offset, offset += size));
+            // convert any enums into their indexed form for best bandwidth
+            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);
             return [
-                new Packet(tag_1, schema_1, null, false, client),
-                (offset - beginningOffset) + 1 + areaSize + areaSize + size + tagLength_1,
+                new Packet(tag, schema, null, false, client),
+                // +1 to go next
+                (offset - beginningOffset) + 1,
             ];
         }
-        // single packet; subtracting 1 to revere.
-        var dataMax = text.charCodeAt(++offset) - 1;
-        var dataMin = text.charCodeAt(++offset) - 1;
-        var type = (text.charCodeAt(++offset) - 1);
-        var finalType = type == PacketType_1.PacketType.ENUMS ? enums[0] : type; // convert enum to enum package
-        var tagStart = ++offset;
-        var tagLength = text.charCodeAt(tagStart) - 1;
-        var tag = text.substring(tagStart + 1, tagStart + 1 + tagLength);
-        var schema = PacketSchema.single(finalType, dataMax, dataMin, dontSpread, dataBatching, maxBatchSize, rateLimit);
+        // single packet
+        // read varint for datamax
+        const [o1, dataMax] = (0, CompressionUtil_1.readVarInt)(data, offset);
+        offset = o1;
+        // read varint for datamin
+        const [o2, dataMin] = (0, CompressionUtil_1.readVarInt)(data, offset);
+        offset = o2;
+        // read type, no more so no +1
+        const type = data[offset];
+        // do enum stuff
+        const finalType = type == PacketType_1.PacketType.ENUMS ? enums[0] : type; // convert enum to enum package
+        console.log(tag, finalType, data, offset, data[offset]);
+        // make schema
+        const schema = PacketSchema.single(finalType, dataMax, dataMin, dontSpread, dataBatching, -1, -1);
         return [
             new Packet(tag, schema, null, false, client),
-            (offset - beginningOffset) + 1 + tagLength
+            // +1 to go next
+            (offset - beginningOffset) + 1,
         ];
-    };
-    Packet.deserializeAll = function (text, client) {
-        var arr = [];
-        var offset = 0;
-        while (offset < text.length) {
-            var _a = this.deserialize(text, offset, client), packet = _a[0], len = _a[1];
+    }
+    static deserializeAll(data, client) {
+        const arr = [];
+        let offset = 0;
+        while (offset < data.length) {
+            const [packet, len] = this.deserialize(data, offset, client);
             arr.push(packet);
             offset += len;
         }
         return arr;
-    };
-    return Packet;
-}());
+    }
+}
 exports.Packet = Packet;
-var PacketSchema = /** @class */ (function () {
-    function PacketSchema(object) {
-        this.types = [];
-        this.dataMaxes = [];
-        this.dataMins = [];
-        this.type = PacketType_1.PacketType.NONE;
-        this.dataMax = -1;
-        this.dataMin = -1;
-        this.packetDelimitSize = 1;
-        this.dataBatching = 0;
-        this.maxBatchSize = 10;
-        this.rateLimit = 0;
-        this.enumData = [];
-        this.dontSpread = false;
-        this.autoFlatten = false;
+class PacketSchema {
+    types = [];
+    dataMaxes = [];
+    dataMins = [];
+    type = PacketType_1.PacketType.NONE;
+    dataMax = -1;
+    dataMin = -1;
+    dataBatching = 0;
+    maxBatchSize = 10;
+    rateLimit = 0;
+    enumData = [];
+    dontSpread = false;
+    autoFlatten = false;
+    object;
+    constructor(object) {
         this.object = object;
     }
-    PacketSchema.single = function (type, dataMax, dataMin, dontSpread, dataBatching, maxBatchSize, rateLimit) {
-        var schema = new PacketSchema(false);
+    static single(type, dataMax, dataMin, dontSpread, dataBatching, maxBatchSize, rateLimit) {
+        const schema = new PacketSchema(false);
         if (typeof type == 'number') {
             schema.type = type;
+            if (type == PacketType_1.PacketType.NONE)
+                dataMax = dataMin = 0; // remove garbage data issues
         }
         else {
             schema.type = PacketType_1.PacketType.ENUMS;
@@ -245,12 +272,12 @@ var PacketSchema = /** @class */ (function () {
         schema.maxBatchSize = maxBatchSize;
         schema.rateLimit = rateLimit;
         return schema;
-    };
-    PacketSchema.object = function (types, dataMaxes, dataMins, dontSpread, autoFlatten, packetDelimitSize, dataBatching, maxBatchSize, rateLimit) {
+    }
+    static object(types, dataMaxes, dataMins, dontSpread, autoFlatten, dataBatching, maxBatchSize, rateLimit) {
         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!");
-        var schema = new PacketSchema(true);
-        types.forEach(function (type) {
+        const schema = new PacketSchema(true);
+        types.forEach(type => {
             if (typeof type == 'number') {
                 schema.types.push(type);
             }
@@ -263,12 +290,10 @@ var PacketSchema = /** @class */ (function () {
         schema.dataMins = dataMins;
         schema.dontSpread = dontSpread;
         schema.autoFlatten = autoFlatten;
-        schema.packetDelimitSize = packetDelimitSize;
         schema.dataBatching = dataBatching;
         schema.maxBatchSize = maxBatchSize;
         schema.rateLimit = rateLimit;
         return schema;
-    };
-    return PacketSchema;
-}());
+    }
+}
 exports.PacketSchema = PacketSchema;

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

@@ -1,13 +1,13 @@
 import * as WS from 'ws';
 import { SonicWSServer } from './SonicWSServer';
 import { Packet } from '../packets/Packets';
-export declare class SonicWSConnection {
+import { Connection } from '../Connection';
+export declare class SonicWSConnection implements Connection {
     /** Raw 'ws' library socket */
     socket: WS.WebSocket;
     private host;
     private listeners;
     private print;
-    private timers;
     private handshakePacket;
     private handshakeLambda;
     private messageLambda;
@@ -19,17 +19,13 @@ export declare class SonicWSConnection {
     handshakeComplete: boolean;
     /** 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;
-    /** The indexed character of the connection. Smaller data packet in strings. */
-    code: string;
+    _timers: Record<number, number>;
     constructor(socket: WS.WebSocket, host: SonicWSServer, id: number, handshakePacket: string | null, clientRateLimit: number, serverRateLimit: number);
     private parseData;
     private handshakeHandler;
     private invalidPacket;
     private listenPacket;
     private messageHandler;
-    private hideNewLines;
-    /** Sends raw data to the user; will likely fail validity checks if used externally */
-    raw_send(data: Uint8Array): void;
     /**
      * Enables a packet for the client.
      * @param tag The tag of the packet
@@ -82,20 +78,10 @@ export declare class SonicWSConnection {
      * Toggles printing all sent and received messages
      */
     togglePrint(): void;
-    /**
-     * Closes the socket
-     */
-    close(code?: number): void;
-    /**
-     * 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)
-     */
+    raw_send(data: Uint8Array): void;
+    close(code?: number, reason?: string): void;
     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)
-     */
     setInterval(call: () => void, time: number): number;
+    clearTimeout(id: number): void;
+    clearInterval(id: number): void;
 }