sonic-ws 1.0.0-rc.7 → 1.0.0

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

@@ -1,35 +1,37 @@
 import { EnumPackage } from "../util/enums/EnumType";
 import { SonicWSConnection } from "../server/SonicWSConnection";
 import { PacketType } from "./PacketType";
+export type ValidatorFunction = ((socket: SonicWSConnection, values: any[]) => boolean) | null;
 export declare class Packet {
     tag: string;
+    defaultEnabled: boolean;
     maxSize: number;
     minSize: number;
     type: PacketType | PacketType[];
     enumData: EnumPackage[];
     dataMax: number | number[];
     dataMin: number | number[];
-    packetDelimitSize: number;
     dataBatching: number;
     maxBatchSize: number;
     dontSpread: boolean;
     autoFlatten: boolean;
     rateLimit: number;
     object: boolean;
+    client: boolean;
     private receiveProcessor;
     private sendProcessor;
-    private validifier;
-    processReceive: (data: string) => any;
-    processSend: (data: any[]) => string;
-    validate: (data: string) => boolean;
+    private validator;
+    processReceive: (data: Uint8Array, validationResult: any) => any;
+    processSend: (data: any[]) => number[];
+    validate: (data: Uint8Array) => boolean;
     customValidator: ((socket: SonicWSConnection, ...values: any[]) => boolean) | null;
-    constructor(tag: string, schema: PacketSchema, customValidator: ((socket: SonicWSConnection, values: any[]) => boolean) | null, client: boolean);
-    listen(value: string, socket: SonicWSConnection | null): [processed: any, flatten: boolean] | string;
-    private serializeINT_D;
-    serialize(): string;
-    private static processINT_Ds;
-    static deserialize(text: string, offset: number, client: boolean): [packet: Packet, offset: number];
-    static deserializeAll(text: string, client: boolean): Packet[];
+    constructor(tag: string, schema: PacketSchema, customValidator: ValidatorFunction, enabled: boolean, client: boolean);
+    listen(value: Uint8Array, socket: SonicWSConnection | null): [processed: any, flatten: boolean] | string;
+    private serializeNumber;
+    serialize(): number[];
+    private static readVarInts;
+    static deserialize(data: Uint8Array, offset: number, client: boolean): [packet: Packet, offset: number];
+    static deserializeAll(data: Uint8Array, client: boolean): Packet[];
 }
 export declare class PacketSchema {
     types: PacketType[];
@@ -38,7 +40,6 @@ export declare class PacketSchema {
     type: PacketType;
     dataMax: number;
     dataMin: number;
-    packetDelimitSize: number;
     dataBatching: number;
     maxBatchSize: number;
     rateLimit: number;
@@ -48,5 +49,5 @@ export declare class PacketSchema {
     object: boolean;
     constructor(object: boolean);
     static single(type: PacketType | EnumPackage, dataMax: number, dataMin: number, dontSpread: boolean, dataBatching: number, maxBatchSize: number, rateLimit: number): PacketSchema;
-    static object(types: (PacketType | EnumPackage)[], dataMaxes: number[], dataMins: number[], dontSpread: boolean, autoFlatten: boolean, packetDelimitSize: number, dataBatching: number, maxBatchSize: number, rateLimit: number): PacketSchema;
+    static object(types: (PacketType | EnumPackage)[], dataMaxes: number[], dataMins: number[], dontSpread: boolean, autoFlatten: boolean, dataBatching: number, maxBatchSize: number, rateLimit: number): PacketSchema;
 }

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.
@@ -27,32 +27,34 @@ 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 CodePointUtil_1 = require("../util/packets/CodePointUtil");
+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 BufferUtil_1 = require("../util/BufferUtil");
+var StringUtil_1 = require("../util/StringUtil");
 var Packet = /** @class */ (function () {
-    function Packet(tag, schema, customValidator, client) {
+    function Packet(tag, schema, customValidator, enabled, client) {
         var _this = this;
         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;
@@ -60,21 +62,22 @@ 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.enumData);
+            this.sendProcessor = (0, PacketProcessors_1.createSendProcessor)(this.type);
         }
-        this.processReceive = function (data) { return _this.receiveProcessor(data, _this.dataMax, _this, 0); };
+        this.processReceive = function (data, validationResult) { return _this.receiveProcessor(data, validationResult, 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.validate = function (data) { return _this.validator(data, 0); };
         this.customValidator = customValidator;
+        this.serializeNumber = this.serializeNumber.bind(this);
     }
     Packet.prototype.listen = function (value, socket) {
         try {
-            if (!this.validate(value))
+            var validationResult = this.validate(value);
+            if (!this.client && validationResult == false)
                 return "Invalid packet";
-            var processed = this.processReceive(value);
+            var processed = this.processReceive(value, validationResult);
             var useableData = this.autoFlatten ? (0, PacketUtils_1.UnFlattenData)(processed) : processed;
             if (this.customValidator != null) {
                 if (!this.dontSpread) {
@@ -93,114 +96,129 @@ var Packet = /** @class */ (function () {
             return "Error: " + err;
         }
     };
-    Packet.prototype.serializeINT_D = function (n) {
-        return String.fromCharCode.apply(String, (0, CodePointUtil_1.processCharCodes)((0, CodePointUtil_1.convertINT_D)(n, this.packetDelimitSize)).map(function (x) { return x + 1; }));
+    Packet.prototype.serializeNumber = function (n) {
+        return (0, CompressionUtil_1.convertVarInt)(n, false);
     };
     Packet.prototype.serialize = function () {
-        var _this = this;
-        // spread flag; ETX for "2", STX for "1", avoid NULL for delimiting
-        var spreadFlag = this.dontSpread ? CodePointUtil_1.ETX : CodePointUtil_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);
+        // shared values for both
+        var sharedData = __spreadArray(__spreadArray(__spreadArray([
+            this.tag.length
+        ], (0, StringUtil_1.processCharCodes)(this.tag), true), [
+            this.dontSpread ? 1 : 0,
+            this.dataBatching, this.maxBatchSize,
+            this.enumData.length
+        ], false), this.enumData.map(function (x) { return x.serialize(); }).flat(), true);
         // single-value packet (not an object schema)
         if (!this.object) {
-            return spreadFlag + dataBatching + rateLimit + enumData +
-                CodePointUtil_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 __spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray([], sharedData, true), [
+                0
+            ], false), this.serializeNumber(this.dataMax), true), this.serializeNumber(this.dataMin), true), [
+                this.type,
+            ], false);
         }
         // 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 ? CodePointUtil_1.ETX : CodePointUtil_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
+        return __spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray([], sharedData, true), [
+            this.maxSize + 1, // size, and +1 because of 0 for single
+            this.autoFlatten ? 1 : 0
+        ], false), this.dataMax.map(this.serializeNumber).flat(), true), this.dataMin.map(this.serializeNumber).flat(), true), this.type, true), [
+            this.tag.length, // tag length, offset by 1 for NULL
+        ], false);
     };
-    Packet.processINT_Ds = function (area, packetDelimitSize) {
-        return (0, ArrayUtil_1.splitArray)((0, CodePointUtil_1.processCharCodes)(area), packetDelimitSize).map(function (x) { return (0, CodePointUtil_1.deconvertINT_DCodes)(x.map(function (y) { return y - 1; })); }); // subtract 1 to reverse
+    Packet.readVarInts = function (data, offset, size) {
+        var res = [];
+        for (var i = 0; i < size; i++) {
+            var _a = (0, CompressionUtil_1.readVarInt)(data, offset, false), off = _a[0], varint = _a[1];
+            offset = off;
+            res.push(varint);
+        }
+        return [res, offset];
     };
-    // i think i was high when i made these,
-    // probably ^^
-    Packet.deserialize = function (text, offset, client) {
+    Packet.deserialize = function (data, offset, client) {
         var beginningOffset = offset;
-        var dontSpread = text[offset] == CodePointUtil_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;
+        // read length, go up 1
+        var tagLength = data[offset++];
+        // read tag as it's up 1, and add offset
+        var tag = (0, BufferUtil_1.as8String)(data.slice(offset, offset += tagLength));
+        // then read dont spread, go up 1
+        var dontSpread = data[offset++] == 1;
+        // read batching, up 1
+        var dataBatching = data[offset++];
+        // read max batch size, up 1; can prob remove? idk
+        var maxBatchSize = data[offset++];
+        // read enum length, up 1
+        var enumLength = data[offset++];
         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;
+            // read tag length, go up 1
+            var enumTagLength = data[offset++];
+            // up 1 so read offset -> offset += tag length, to add tag length and skip over it
+            var enumTag = (0, BufferUtil_1.as8String)(data.slice(offset, offset += enumTagLength));
+            // read amount of values
+            var valueCount = data[offset++];
             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--;
+                // read the length of the value, go up 1
+                var valueLength = data[offset++];
+                // then read the type of value, up 1
+                var valueType = data[offset++];
+                // now can just read the values, increase offset for later use
+                var 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
+        var 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] == CodePointUtil_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, CodePointUtil_1.processCharCodes)(text.substring(tStart, tEnd)).map(function (x) { return x - 1; });
+            // 1 for true, 0 for false
+            var autoFlatten = data[offset++] == 1;
+            // read var ints for the datamaxes
+            var _a = this.readVarInts(data, offset, size), dataMaxes = _a[0], o1_1 = _a[1];
+            offset = o1_1;
+            // read var ints for the datamins
+            var _b = this.readVarInts(data, offset, size), dataMins = _b[0], o2_1 = _b[1];
+            offset = o2_1;
+            // get types, skip past size since there'll be size of these
+            var types = Array.from(data.slice(offset, offset += size));
+            // convert any enums into their indexed form for best bandwidth
             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
+            // make schema
+            var schema_1 = PacketSchema.object(finalTypes, dataMaxes, dataMins, dontSpread, autoFlatten, dataBatching, maxBatchSize, -1);
             return [
-                new Packet(tag_1, PacketSchema.object(finalTypes, dataMaxes, dataMins, dontSpread, autoFlatten, packetDelimitSize, dataBatching, maxBatchSize, rateLimit), null, client),
-                (offset - beginningOffset) + 1 + areaSize + areaSize + size + tagLength_1,
+                new Packet(tag, schema_1, 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);
+        // single packet
+        // read varint for datamax
+        var _c = (0, CompressionUtil_1.readVarInt)(data, offset, false), o1 = _c[0], dataMax = _c[1];
+        offset = o1;
+        // read varint for datamin
+        var _d = (0, CompressionUtil_1.readVarInt)(data, offset, false), o2 = _d[0], dataMin = _d[1];
+        offset = o2;
+        // read type, no more so no +1
+        var type = data[offset];
+        // do enum stuff
         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);
+        // make schema
+        var schema = PacketSchema.single(finalType, dataMax, dataMin, dontSpread, dataBatching, maxBatchSize, -1);
         return [
-            new Packet(tag, PacketSchema.single(finalType, dataMax, dataMin, dontSpread, dataBatching, maxBatchSize, rateLimit), null, client),
-            (offset - beginningOffset) + 1 + tagLength
+            new Packet(tag, schema, null, false, client),
+            // +1 to go next
+            (offset - beginningOffset) + 1,
         ];
     };
-    Packet.deserializeAll = function (text, client) {
+    Packet.deserializeAll = function (data, client) {
         var arr = [];
         var offset = 0;
-        while (offset < text.length) {
-            var _a = this.deserialize(text, offset, client), packet = _a[0], len = _a[1];
+        while (offset < data.length) {
+            var _a = this.deserialize(data, offset, client), packet = _a[0], len = _a[1];
             arr.push(packet);
             offset += len;
         }
@@ -217,7 +235,6 @@ var PacketSchema = /** @class */ (function () {
         this.type = PacketType_1.PacketType.NONE;
         this.dataMax = -1;
         this.dataMin = -1;
-        this.packetDelimitSize = 1;
         this.dataBatching = 0;
         this.maxBatchSize = 10;
         this.rateLimit = 0;
@@ -230,6 +247,8 @@ var PacketSchema = /** @class */ (function () {
         var 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;
@@ -243,7 +262,7 @@ var PacketSchema = /** @class */ (function () {
         schema.rateLimit = rateLimit;
         return schema;
     };
-    PacketSchema.object = function (types, dataMaxes, dataMins, dontSpread, autoFlatten, packetDelimitSize, dataBatching, maxBatchSize, rateLimit) {
+    PacketSchema.object = function (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);
@@ -260,7 +279,6 @@ 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;

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

@@ -1,25 +1,25 @@
 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;
     private handshakedMessageLambda;
     private batcher;
     private rater;
+    private enabledPackets;
     /** If the packet handshake has been completed; `wss.requireHandshake(packet)` */
     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;
@@ -28,7 +28,17 @@ export declare class SonicWSConnection {
     private messageHandler;
     private hideNewLines;
     /** Sends raw data to the user; will likely fail validity checks if used externally */
-    raw_send(data: string): void;
+    raw_send(data: Uint8Array): void;
+    /**
+     * Enables a packet for the client.
+     * @param tag The tag of the packet
+     */
+    enablePacket(tag: string): void;
+    /**
+     * Disables a packet for the client.
+     * @param tag The tag of the packet
+     */
+    disablePacket(tag: string): void;
     /**
      * Checks if the connection is closed
      * @returns If it's closed or not
@@ -48,7 +58,7 @@ export declare class SonicWSConnection {
     /**
      * For internal use.
      */
-    send_processed(code: string, data: string, packet: Packet): void;
+    send_processed(code: number, data: number[], packet: Packet): void;
     /**
      * Sends a packet with the tag and values
      * @param tag The tag to send
@@ -72,19 +82,31 @@ export declare class SonicWSConnection {
      */
     togglePrint(): void;
     /**
-     * Closes the socket
+     * Closes the connection
      */
-    close(code?: number): void;
+    close(code?: number, reason?: string): 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)
+     * @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;
 }