sonic-ws 1.1.1 → 1.2.1-wtf

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

@@ -7,7 +7,6 @@ type ImpactType<T extends (PacketType | readonly PacketType[]), K> = T extends P
 export declare class Packet<T extends (PacketType | readonly PacketType[])> {
     defaultEnabled: boolean;
     readonly tag: string;
-    readonly async: boolean;
     readonly maxSize: number;
     readonly minSize: number;
     readonly type: T;
@@ -19,17 +18,22 @@ export declare class Packet<T extends (PacketType | readonly PacketType[])> {
     readonly dontSpread: boolean;
     readonly autoFlatten: boolean;
     readonly rateLimit: number;
+    readonly async: boolean;
+    readonly rereference: boolean;
+    readonly gzipCompression: boolean;
     readonly object: boolean;
     readonly client: boolean;
     private receiveProcessor;
     private sendProcessor;
     private validator;
     processReceive: (data: Uint8Array, validationResult: any) => any;
-    processSend: (data: any[]) => Uint8Array;
-    validate: (data: Uint8Array) => boolean;
+    processSend: (data: any[]) => Promise<Uint8Array>;
+    validate: (data: Uint8Array) => Promise<[Uint8Array, boolean]>;
     customValidator: ((socket: SonicWSConnection, ...values: any[]) => boolean) | null;
+    lastReceived: Record<number, any>;
+    lastSent: Record<number, any>;
     constructor(tag: string, schema: PacketSchema<T>, customValidator: ValidatorFunction, enabled: boolean, client: boolean);
-    listen(value: Uint8Array, socket: SonicWSConnection | null): [processed: any, flatten: boolean] | string;
+    listen(value: Uint8Array, socket: SonicWSConnection | null): Promise<[processed: any, flatten: boolean] | string>;
     serialize(): number[];
     private static readVarInts;
     static deserialize(data: Uint8Array, offset: number, client: boolean): [packet: Packet<any>, offset: number];
@@ -46,10 +50,12 @@ export declare class PacketSchema<T extends (PacketType | readonly PacketType[])
     dontSpread: boolean;
     autoFlatten: boolean;
     async: boolean;
+    rereference: boolean;
+    gzipCompression: 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, 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]>[]>;
+    static single<T extends PacketType | EnumPackage>(type: T, dataMax: number, dataMin: number, dontSpread: boolean, dataBatching: number, maxBatchSize: number, rateLimit: number, async: boolean, gzipCompression: boolean, rereference: 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, gzipCompression: boolean): PacketSchema<ConvertType<T[number]>[]>;
 }
 export {};

package/dist/ws/packets/Packets.js

@@ -27,7 +27,6 @@ const StringUtil_1 = require("../util/StringUtil");
 class Packet {
     defaultEnabled;
     tag;
-    async;
     maxSize;
     minSize;
     type;
@@ -39,6 +38,9 @@ class Packet {
     dontSpread;
     autoFlatten;
     rateLimit;
+    async;
+    rereference;
+    gzipCompression;
     object;
     client;
     receiveProcessor;
@@ -48,6 +50,8 @@ class Packet {
     processSend;
     validate;
     customValidator;
+    lastReceived = {};
+    lastSent = {};
     constructor(tag, schema, customValidator, enabled, client) {
         this.tag = tag;
         this.defaultEnabled = enabled;
@@ -57,8 +61,10 @@ class Packet {
         this.rateLimit = schema.rateLimit;
         this.dontSpread = schema.dontSpread;
         this.autoFlatten = schema.autoFlatten;
+        this.rereference = schema.rereference;
         this.dataBatching = schema.dataBatching;
         this.maxBatchSize = client ? Infinity : schema.maxBatchSize;
+        this.gzipCompression = schema.gzipCompression;
         this.object = schema.object;
         if (schema.testObject()) {
             this.type = schema.type;
@@ -70,8 +76,8 @@ class Packet {
             this.minSize = this.type.length;
             // trst me bro..
             this.receiveProcessor = (0, PacketProcessors_1.createObjReceiveProcessor)(this);
-            this.validator = (0, PacketProcessors_1.createObjValidator)(this);
             this.sendProcessor = (0, PacketProcessors_1.createObjSendProcessor)(this);
+            this.validator = (0, PacketProcessors_1.createObjValidator)(this);
         }
         else {
             this.type = schema.type;
@@ -82,22 +88,22 @@ class Packet {
             // @ts-expect-error
             this.receiveProcessor = (0, PacketProcessors_1.createReceiveProcessor)(this.type, this.enumData, this.dataMax);
             // @ts-expect-error
-            this.validator = (0, PacketProcessors_1.createValidator)(this.type, this.dataMax, this.dataMin, this);
+            this.sendProcessor = (0, PacketProcessors_1.createSendProcessor)(this.type, this.gzipCompression, this.rereference);
             // @ts-expect-error
-            this.sendProcessor = (0, PacketProcessors_1.createSendProcessor)(this.type);
+            this.validator = (0, PacketProcessors_1.createValidator)(this.type, this.dataMax, this.dataMin, this, this.gzipCompression, this.rereference);
         }
         this.processReceive = (data, validationResult) => this.receiveProcessor(data, validationResult, 0);
-        this.processSend = (data) => new Uint8Array(this.sendProcessor(data));
+        this.processSend = async (data) => new Uint8Array(await this.sendProcessor(tag, data));
         this.validate = (data) => this.validator(data, 0);
         this.customValidator = customValidator;
     }
-    listen(value, socket) {
+    async listen(value, socket) {
         try {
-            const validationResult = this.validate(value);
+            const [dcData, validationResult] = await this.validate(value);
             // holy shit i used === to fix another bug
             if (!this.client && validationResult === false)
                 return "Invalid packet";
-            const processed = this.processReceive(value, validationResult);
+            const processed = this.processReceive(dcData, validationResult);
             const useableData = this.autoFlatten ? (0, PacketUtils_1.UnFlattenData)(processed) : processed;
             if (this.customValidator != null) {
                 if (!this.dontSpread) {
@@ -120,8 +126,7 @@ class Packet {
         // shared values for both
         const sharedData = [
             this.tag.length, ...(0, StringUtil_1.processCharCodes)(this.tag),
-            this.dontSpread ? 1 : 0,
-            this.async ? 1 : 0,
+            (0, CompressionUtil_1.compressBools)([this.dontSpread, this.async, this.object, this.autoFlatten, this.gzipCompression, this.rereference]),
             this.dataBatching,
             this.enumData.length, ...this.enumData.map(x => x.serialize()).flat(),
         ];
@@ -129,7 +134,6 @@ class Packet {
         if (!this.object) {
             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,
@@ -138,12 +142,10 @@ class Packet {
         // object packet
         return [
             ...sharedData,
-            this.maxSize + 1, // size, and +1 because of 0 for single
-            this.autoFlatten ? 1 : 0, // auto flatten flag
+            this.maxSize, // size
             ...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
+            ...this.type, // all types
         ];
     }
     static readVarInts(data, offset, size) {
@@ -161,10 +163,8 @@ class Packet {
         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 async
-        const async = data[offset++] == 1;
+        // then read dontSpread and async
+        const [dontSpread, async, isObject, autoFlatten, gzipCompression, rereference] = (0, CompressionUtil_1.decompressBools)(data[offset++]);
         // read batching, up 1
         const dataBatching = data[offset++];
         // read enum length, up 1
@@ -191,13 +191,10 @@ class Packet {
             // define the enum with the values
             enums.push((0, EnumHandler_1.DefineEnum)(enumTag, values));
         }
-        // read type count; prob should change sometime
-        const size = data[offset++] - 1;
         // objects
-        // single packet is 0, 0 - 1 = -1
-        if (size != -1) {
-            // 1 for true, 0 for false
-            const autoFlatten = data[offset++] == 1;
+        if (isObject) {
+            // read size
+            const size = data[offset++];
             // read var ints for the datamaxes
             const [dataMaxes, o1] = this.readVarInts(data, offset, size);
             offset = o1;
@@ -210,11 +207,11 @@ 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, async);
+            const schema = PacketSchema.object(finalTypes, dataMaxes, dataMins, dontSpread, autoFlatten, dataBatching, -1, -1, async, gzipCompression);
             return [
                 new Packet(tag, schema, null, false, client),
                 // +1 to go next
-                (offset - beginningOffset) + 1,
+                (offset - beginningOffset),
             ];
         }
         // single packet
@@ -224,16 +221,15 @@ class Packet {
         // 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];
+        // read type
+        const type = data[offset++];
         // 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, async);
+        const schema = PacketSchema.single(finalType, dataMax, dataMin, dontSpread, dataBatching, -1, -1, async, gzipCompression, rereference);
         return [
             new Packet(tag, schema, null, false, client),
-            // +1 to go next
-            (offset - beginningOffset) + 1,
+            (offset - beginningOffset),
         ];
     }
     static deserializeAll(data, client) {
@@ -259,6 +255,8 @@ class PacketSchema {
     dontSpread = false;
     autoFlatten = false;
     async = false;
+    rereference = false;
+    gzipCompression = false;
     object;
     constructor(object) {
         this.object = object;
@@ -266,7 +264,7 @@ class PacketSchema {
     testObject() {
         return this.object;
     }
-    static single(type, dataMax, dataMin, dontSpread, dataBatching, maxBatchSize, rateLimit, async) {
+    static single(type, dataMax, dataMin, dontSpread, dataBatching, maxBatchSize, rateLimit, async, gzipCompression, rereference) {
         const schema = new PacketSchema(false);
         if (typeof type == 'number') {
             schema.type = type;
@@ -277,16 +275,18 @@ class PacketSchema {
             schema.type = PacketType_1.PacketType.ENUMS;
             schema.enumData = [type];
         }
-        schema.dataMax = dataMax;
+        schema.async = async;
         schema.dataMin = dataMin;
+        schema.dataMax = dataMax;
+        schema.rateLimit = rateLimit;
         schema.dontSpread = dontSpread;
+        schema.rereference = rereference;
         schema.dataBatching = dataBatching;
         schema.maxBatchSize = maxBatchSize;
-        schema.rateLimit = rateLimit;
-        schema.async = async;
+        schema.gzipCompression = gzipCompression;
         return schema;
     }
-    static object(types, dataMaxes, dataMins, dontSpread, autoFlatten, dataBatching, maxBatchSize, rateLimit, async) {
+    static object(types, dataMaxes, dataMins, dontSpread, autoFlatten, dataBatching, maxBatchSize, rateLimit, async, gzipCompression) {
         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,14 +300,15 @@ class PacketSchema {
                 schema.enumData.push(type);
             }
         });
-        schema.dataMax = dataMaxes;
+        schema.async = async;
         schema.dataMin = dataMins;
+        schema.dataMax = dataMaxes;
+        schema.rateLimit = rateLimit;
         schema.dontSpread = dontSpread;
         schema.autoFlatten = autoFlatten;
         schema.dataBatching = dataBatching;
         schema.maxBatchSize = maxBatchSize;
-        schema.rateLimit = rateLimit;
-        schema.async = async;
+        schema.gzipCompression = gzipCompression;
         return schema;
     }
 }

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

@@ -67,7 +67,7 @@ export declare class SonicWSConnection implements Connection {
      * @param tag The tag to send
      * @param values The values to send
      */
-    send(tag: string, ...values: any[]): void;
+    send(tag: string, ...values: any[]): Promise<void>;
     /**
      * Broadcasts a packet to all other users connected
      * @param tag The tag to send

package/dist/ws/server/SonicWSConnection.js

@@ -92,6 +92,7 @@ class SonicWSConnection {
         for (const tag of host.clientPackets.getTags()) {
             this.listeners[tag] = [];
             const pack = host.clientPackets.getPacket(tag);
+            pack.lastReceived[this.id] = undefined;
             this.enabledPackets[tag] = pack.defaultEnabled;
             this.asyncMap[tag] = pack.async;
             if (pack.async)
@@ -121,6 +122,9 @@ class SonicWSConnection {
                 if (shouldCall)
                     callback(true);
             }
+            for (const packet of host.clientPackets.getPackets()) {
+                delete packet.lastReceived[this.id];
+            }
         });
     }
     parseData(event) {
@@ -209,17 +213,23 @@ class SonicWSConnection {
         else
             this.listenLock = false;
     }
-    messageHandler(data) {
+    async messageHandler(data) {
         if (data == null)
             return;
         const [tag, value] = data;
         const packet = this.host.clientPackets.getPacket(tag);
+        if (packet.rereference && value.length == 0) {
+            if (packet.lastReceived[this.id] === undefined)
+                return this.invalidPacket("No previous value to rereference");
+            this.listenPacket(packet.lastReceived[this.id], tag);
+            return;
+        }
         if (packet.dataBatching == 0) {
-            const res = packet.listen(value, this);
+            const res = packet.lastReceived[this.id] = await packet.listen(value, this);
             this.listenPacket(res, tag);
             return;
         }
-        const batchData = BatchHelper_1.BatchHelper.unravelBatch(packet, value, this);
+        const batchData = await BatchHelper_1.BatchHelper.unravelBatch(packet, value, this);
         if (typeof batchData == 'string')
             return this.invalidPacket(batchData);
         for (const data of batchData) {
@@ -281,8 +291,8 @@ class SonicWSConnection {
      * @param tag The tag to send
      * @param values The values to send
      */
-    send(tag, ...values) {
-        this.send_processed(...(0, PacketUtils_1.processPacket)(this.host.serverPackets, tag, values));
+    async send(tag, ...values) {
+        this.send_processed(...await (0, PacketUtils_1.processPacket)(this.host.serverPackets, tag, values, this.id));
     }
     /**
      * Broadcasts a packet to all other users connected

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

@@ -13,6 +13,8 @@ export type SonicServerOptions = {
     readonly serverPackets?: PacketTypings;
     /** Default WS Options */
     readonly websocketOptions?: WS.ServerOptions;
+    /** If it should check for updates; defaults to true. */
+    readonly checkForUpdates?: boolean;
 };
 export type PacketTypings = readonly Packet<PacketType | readonly PacketType[]>[];
 export declare class SonicWSServer {
@@ -98,14 +100,14 @@ export declare class SonicWSServer {
      * @param packetTag Packet tag to send
      * @param values Values to send
      */
-    broadcastTagged(tag: string, packetTag: string, ...values: any): void;
+    broadcastTagged(tag: string, packetTag: string, ...values: any): Promise<void>;
     /**
      * Broadcasts a packet to all users connected, but with a filter
      * @param tag The tag to send
      * @param filter The filter for who to send to
      * @param values The values to send
      */
-    broadcastFiltered(tag: string, filter: (socket: SonicWSConnection) => boolean, ...values: any): void;
+    broadcastFiltered(tag: string, filter: (socket: SonicWSConnection) => boolean, ...values: any): Promise<void>;
     /**
      * Broadcasts a packet to all users connected
      * @param tag The tag to send

package/dist/ws/server/SonicWSServer.js

@@ -83,10 +83,11 @@ class SonicWSServer {
         const s_serverPackets = this.serverPackets.serialize();
         const serverData = [...version_1.SERVER_SUFFIX_NUMS, version_1.VERSION];
         const keyData = [...(0, CompressionUtil_1.convertVarInt)(s_clientPackets.length), ...s_clientPackets, ...s_serverPackets];
-        this.wss.on('connection', (socket) => {
+        this.wss.on('connection', async (socket) => {
             const sonicConnection = new SonicWSConnection_1.SonicWSConnection(socket, this, this.generateSocketID(), this.handshakePacket, this.clientRateLimit, this.serverRateLimit);
             // send tags to the client so it doesn't have to hard code them in
-            socket.send(new Uint8Array([...serverData, ...(0, CompressionUtil_1.convertVarInt)(sonicConnection.id), ...keyData]));
+            const data = new Uint8Array([...(0, CompressionUtil_1.convertVarInt)(sonicConnection.id), ...keyData]);
+            socket.send([...serverData, ...await (0, CompressionUtil_1.compressGzip)(data)]);
             this.connections.push(sonicConnection);
             this.connectionMap[sonicConnection.id] = sonicConnection;
             this.connectListeners.forEach(l => l(sonicConnection));
@@ -101,17 +102,19 @@ class SonicWSServer {
                 }
             });
         });
-        fetch('https://raw.githubusercontent.com/liwybloc/sonic-ws/refs/heads/main/release/version')
-            .then((res) => res.text())
-            .then((ver) => {
-            if (parseInt(ver) != version_1.VERSION) {
-                console.warn(`SonicWS is currently running outdated! (current: ${version_1.VERSION}, latest: ${ver}) Update with "npm update sonic-ws"`);
-            }
-        })
-            .catch((err) => {
-            console.error(err);
-            console.warn(`Could not check SonicWS version.`);
-        });
+        if (settings.checkForUpdates ?? true) {
+            fetch('https://raw.githubusercontent.com/liwybloc/sonic-ws/refs/heads/main/release/version')
+                .then((res) => res.text())
+                .then((ver) => {
+                if (parseInt(ver) > version_1.VERSION) {
+                    console.warn(`SonicWS is currently running outdated! (current: ${version_1.VERSION}, latest: ${ver}) Update with "npm update sonic-ws"`);
+                }
+            })
+                .catch((err) => {
+                console.error(err);
+                console.warn(`Could not check SonicWS version.`);
+            });
+        }
     }
     generateSocketID() {
         if (this.availableIds.length == 0)
@@ -213,10 +216,10 @@ class SonicWSServer {
      * @param packetTag Packet tag to send
      * @param values Values to send
      */
-    broadcastTagged(tag, packetTag, ...values) {
+    async broadcastTagged(tag, packetTag, ...values) {
         if (!this.tagsInv.has(tag))
             return;
-        const data = (0, PacketUtils_1.processPacket)(this.serverPackets, packetTag, values);
+        const data = await (0, PacketUtils_1.processPacket)(this.serverPackets, packetTag, values, -1);
         this.tagsInv.get(tag).forEach(conn => conn.send_processed(...data));
     }
     /**
@@ -225,8 +228,8 @@ class SonicWSServer {
      * @param filter The filter for who to send to
      * @param values The values to send
      */
-    broadcastFiltered(tag, filter, ...values) {
-        const data = (0, PacketUtils_1.processPacket)(this.serverPackets, tag, values);
+    async broadcastFiltered(tag, filter, ...values) {
+        const data = await (0, PacketUtils_1.processPacket)(this.serverPackets, tag, values, -1);
         this.connections.filter(filter).forEach(conn => conn.send_processed(...data));
     }
     /**

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

@@ -11,5 +11,5 @@ export declare class BatchHelper {
     private initiateBatch;
     private startBatch;
     batchPacket(code: number, data: Uint8Array): void;
-    static unravelBatch(packet: Packet<any>, data: Uint8Array, socket: SonicWSConnection | null): any[] | string;
+    static unravelBatch(packet: Packet<any>, data: Uint8Array, socket: SonicWSConnection | null): Promise<any[] | string>;
 }

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

@@ -51,7 +51,7 @@ class BatchHelper {
         if (!this.batchTimeouts[code])
             this.startBatch(code);
     }
-    static unravelBatch(packet, data, socket) {
+    static async unravelBatch(packet, data, socket) {
         const result = [];
         for (let i = 0; i < data.length;) {
             // must be >0 for it to apply
@@ -66,7 +66,7 @@ class BatchHelper {
             // read sector
             const sect = data.slice(i, i += varint);
             // call the packets listeners
-            const listen = packet.listen(sect, socket);
+            const listen = await packet.listen(sect, socket);
             // if invalid, return that
             if (typeof listen == 'string')
                 return "Batched packet: " + listen;

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

@@ -15,6 +15,7 @@ export declare const MAX_UVARINT: number;
 export declare const MAX_VARINT: number;
 export declare const ONE_EIGHT: number;
 export declare const ONE_FOURTH: number;
+export declare const EMPTY_UINT8: Uint8Array<ArrayBuffer>;
 export declare const varIntOverflowPow: (num: number) => number;
 export type SHORT_BITS = [high: number, low: number];
 export declare function fromShort(short: SHORT_BITS): number;
@@ -39,3 +40,9 @@ export declare function bytesToBits(bytes: ArrayLike<number>): string;
 export declare function bitsToBytes(bitString: string): Uint8Array;
 export declare function encodeHuffman(text: string): Uint8Array;
 export declare function decodeHuffman(bits: string): string;
+export declare function compressGzip(data: Uint8Array<ArrayBuffer>, ident?: string): Promise<Uint8Array>;
+export declare function decompressGzip(data: Uint8Array): Promise<Uint8Array>;
+export declare const compressJSON: (value: any) => Uint8Array<ArrayBuffer>;
+export declare const decompressJSON: (bytes: Uint8Array) => any;
+export declare function bytesToHex(bytes: Uint8Array): string;
+export declare function hexToBytes(hex: string): Uint8Array<ArrayBuffer>;