sonic-ws 1.2.2 → 1.3.0-min

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

@@ -361,7 +361,7 @@ async function decompressGzip(data) {
     const buffer = await new Response(stream).arrayBuffer();
     return new Uint8Array(buffer);
 }
-// BOOLEANS
+// json (why did i say booleans idk)
 var JSONType;
 (function (JSONType) {
     JSONType[JSONType["NULL"] = 0] = "NULL";

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

@@ -0,0 +1,2 @@
+export declare function setHashFunc(use64Bit: boolean): void;
+export declare function hashValue(value: any): bigint | number;

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

@@ -0,0 +1,122 @@
+"use strict";
+/*
+ * Copyright 2026 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 });
+exports.setHashFunc = setHashFunc;
+exports.hashValue = hashValue;
+const HASH_INIT_64 = 14695981039346656037n;
+const HASH_PRIME_64 = 1099511628211n;
+const MASK_64 = (1n << 64n) - 1n;
+const hashValue64 = (value) => {
+    let hash = HASH_INIT_64;
+    const walk = (v) => {
+        if (v === null) {
+            hash ^= 0n;
+            hash = (hash * HASH_PRIME_64) & MASK_64;
+            return;
+        }
+        const t = typeof v;
+        if (t === "number") {
+            hash ^= BigInt(Math.trunc(v));
+            hash = (hash * HASH_PRIME_64) & MASK_64;
+            return;
+        }
+        if (t === "string") {
+            for (let i = 0; i < v.length; i++) {
+                hash ^= BigInt(v.charCodeAt(i));
+                hash = (hash * HASH_PRIME_64) & MASK_64;
+            }
+            return;
+        }
+        if (t === "boolean") {
+            hash ^= v ? 1n : 0n;
+            hash = (hash * HASH_PRIME_64) & MASK_64;
+            return;
+        }
+        if (Array.isArray(v)) {
+            for (let i = 0; i < v.length; i++) {
+                walk(v[i]);
+            }
+            return;
+        }
+        if (t === "object") {
+            const keys = Object.keys(v).sort();
+            for (let i = 0; i < keys.length; i++) {
+                const k = keys[i];
+                for (let j = 0; j < k.length; j++) {
+                    hash ^= BigInt(k.charCodeAt(j));
+                    hash = (hash * HASH_PRIME_64) & MASK_64;
+                }
+                walk(v[k]);
+            }
+        }
+    };
+    walk(value);
+    return hash;
+};
+const HASH_INIT = 2166136261;
+const hashValue32 = (value) => {
+    let hash = HASH_INIT;
+    const walk = (v) => {
+        if (v === null) {
+            hash ^= 0;
+            return;
+        }
+        const t = typeof v;
+        if (t === "number") {
+            hash ^= v | 0;
+            hash += (hash << 1) + (hash << 4) + (hash << 7) + (hash << 8) + (hash << 24);
+            return;
+        }
+        if (t === "string") {
+            for (let i = 0; i < v.length; i++) {
+                hash ^= v.charCodeAt(i);
+                hash += (hash << 1) + (hash << 4) + (hash << 7) + (hash << 8) + (hash << 24);
+            }
+            return;
+        }
+        if (t === "boolean") {
+            hash ^= v ? 1 : 0;
+            return;
+        }
+        if (Array.isArray(v)) {
+            for (let i = 0; i < v.length; i++) {
+                walk(v[i]);
+            }
+            return;
+        }
+        if (t === "object") {
+            const keys = Object.keys(v).sort();
+            for (let i = 0; i < keys.length; i++) {
+                const k = keys[i];
+                for (let j = 0; j < k.length; j++) {
+                    hash ^= k.charCodeAt(j);
+                    hash += (hash << 1) + (hash << 4) + (hash << 7) + (hash << 8) + (hash << 24);
+                }
+                walk(v[k]);
+            }
+        }
+    };
+    walk(value);
+    return hash >>> 0;
+};
+let hashFunc = hashValue64;
+function setHashFunc(use64Bit) {
+    hashFunc = use64Bit ? hashValue64 : hashValue32;
+}
+function hashValue(value) {
+    return hashFunc(value);
+}

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

@@ -35,7 +35,7 @@ export declare class PacketHolder {
      * Returns the tag associated with a given character key
      * @param key Key bytre
      */
-    getTag(key: number): string;
+    getTag(key: number): string | undefined;
     /**
      * Returns the packet instance associated with a tag
      * @param tag The packet tag
@@ -45,7 +45,7 @@ export declare class PacketHolder {
      * Checks if a given character key exists
      * @param key A string index
      */
-    hasKey(key: number): boolean;
+    hasKey(key: number): key is keyof typeof this.tags;
     /**
      * Checks if a tag has been assigned a key
      * @param tag The packet tag

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

@@ -74,6 +74,8 @@ class PacketHolder {
      * @param key Key bytre
      */
     getTag(key) {
+        if (!(key in this.tags))
+            return undefined;
         return this.tags[key];
     }
     /**

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

@@ -2,6 +2,8 @@ import { PacketHolder } from "./PacketHolder";
 import { ConvertType, Packet, ValidatorFunction } from "../../packets/Packets";
 import { PacketType } from "../../packets/PacketType";
 import { EnumPackage } from "../enums/EnumType";
+import { SendQueue } from "../../PacketProcessor";
+export type ProcessedPacket = [code: number, data: Uint8Array, packet: Packet<any>];
 /**
  * Processes and verifies values into a sendable format
  * @param packets Packet holder
@@ -9,7 +11,7 @@ import { EnumPackage } from "../enums/EnumType";
  * @param values The values
  * @returns The indexed code, the data, and the packet schema
  */
-export declare function processPacket(packets: PacketHolder, tag: string, values: any[], id: number): Promise<[code: number, data: Uint8Array, packet: Packet<any>]>;
+export declare function processPacket(packets: PacketHolder, tag: string, values: any[], sendQueue: SendQueue, id: number, force?: boolean): Promise<ProcessedPacket>;
 /**
  * Calls the listener for a packet with error callback
  * @param listened The listened data
@@ -95,7 +97,7 @@ export type KeyEffectivePacketSettings = SharedPacketSettings & {
  * @throws {Error} If the `type` is invalid.
  */
 export declare function CreatePacket<T extends ArguableType>(settings: SinglePacketSettings & {
-    type: T;
+    type?: T;
 }): Packet<ConvertType<T>>;
 /**
  * Creates a structure for an object (multi-typed) packet.

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

@@ -27,6 +27,7 @@ const Packets_1 = require("../../packets/Packets");
 const PacketType_1 = require("../../packets/PacketType");
 const EnumType_1 = require("../enums/EnumType");
 const CompressionUtil_1 = require("./CompressionUtil");
+const HashUtil_1 = require("./HashUtil");
 /**
  * Processes and verifies values into a sendable format
  * @param packets Packet holder
@@ -34,50 +35,68 @@ const CompressionUtil_1 = require("./CompressionUtil");
  * @param values The values
  * @returns The indexed code, the data, and the packet schema
  */
-async function processPacket(packets, tag, values, id) {
+async function processPacket(packets, tag, values, sendQueue, id, force = false) {
     const code = packets.getKey(tag);
     const packet = packets.getPacket(tag);
-    if (packet.autoFlatten) {
-        values = FlattenData(values[0]);
-    }
-    else {
-        if (values.length > packet.maxSize)
-            throw new Error(`Packet "${tag}" only allows ${packet.maxSize} values!`);
-        if (values.length < packet.minSize)
-            throw new Error(`Packet "${tag}" requires at least ${packet.minSize} values!`);
-    }
-    if (!packet.object) {
-        if (packet.type != PacketType_1.PacketType.JSON) {
-            const found = values.find(v => typeof v == 'object' && v != null);
-            if (found)
-                console.warn(`Passing an array will result in undefined behavior (${JSON.stringify(found)}). Spread the array with ...arr`);
+    return handleQueue(sendQueue, packets, id, tag, values, force, async () => {
+        if (packet.rereference) {
+            if (id === -1)
+                throw new Error("Cannot send a re-referenced packet from the server-wide sender!");
+            const serialized = (0, HashUtil_1.hashValue)(values);
+            if (packet.lastSent[id] === serialized) {
+                return [code, CompressionUtil_1.EMPTY_UINT8, packet];
+            }
+            packet.lastSent[id] = serialized;
         }
-    }
-    else {
-        // also map non arrays to arrays to keep some code cleaner
-        values = values.map(x => !Array.isArray(x) ? [x] : x);
-        // something is weird with this
-        if (!packet.autoFlatten) {
-            const dataMins = packet.dataMin;
-            const dataMaxes = packet.dataMax;
-            for (let i = 0; i < dataMins.length; i++) {
-                // these will be the same length
-                if (values[i].length < dataMins[i])
-                    throw new Error(`Section ${i + 1} of packet "${tag}" requires at least ${dataMins[i]} values!`);
-                if (values[i].length > dataMaxes[i])
-                    throw new Error(`Section ${i + 1} of packet "${tag}" only allows ${dataMaxes[i]} values!`);
+        if (packet.autoFlatten) {
+            values = FlattenData(values[0]);
+        }
+        else {
+            if (values.length > packet.maxSize)
+                throw new Error(`Packet "${tag}" only allows ${packet.maxSize} values!`);
+            if (values.length < packet.minSize)
+                throw new Error(`Packet "${tag}" requires at least ${packet.minSize} values!`);
+        }
+        if (!packet.object) {
+            if (packet.type !== PacketType_1.PacketType.JSON) {
+                const found = values.find(v => typeof v === 'object' && v != null);
+                if (found)
+                    console.warn(`Passing an array will result in undefined behavior (${JSON.stringify(found)}). Spread the array with ...arr`);
+            }
+        }
+        else {
+            values = values.map(x => !Array.isArray(x) ? [x] : x);
+            if (!packet.autoFlatten) {
+                const dataMins = packet.dataMin;
+                const dataMaxes = packet.dataMax;
+                for (let i = 0; i < dataMins.length; i++) {
+                    if (values[i].length < dataMins[i])
+                        throw new Error(`Section ${i + 1} of packet "${tag}" requires at least ${dataMins[i]} values!`);
+                    if (values[i].length > dataMaxes[i])
+                        throw new Error(`Section ${i + 1} of packet "${tag}" only allows ${dataMaxes[i]} values!`);
+                }
             }
         }
+        const sendData = values.length > 0 ? await packet.processSend(values) : CompressionUtil_1.EMPTY_UINT8;
+        return [code, sendData, packet];
+    });
+}
+async function handleQueue(sendQueue, packets, id, tag, values, force, fn) {
+    if (sendQueue[0] && !force) {
+        return new Promise((resolve) => sendQueue[1].push([resolve, tag, values]));
     }
-    const sendData = values.length > 0 ? await packet.processSend(values) : CompressionUtil_1.EMPTY_UINT8;
-    if (packet.rereference) {
-        if (id == -1)
-            throw new Error("Cannot broadcast a packet that is rereference-enabled");
-        if (packet.lastSent[id] == sendData)
-            return [code, CompressionUtil_1.EMPTY_UINT8, packet];
-        packet.lastSent[id] = sendData;
+    sendQueue[0] = true;
+    const result = await fn();
+    if (sendQueue[1].length > 0) {
+        const [resolve, nextTag, nextValues] = sendQueue[1].shift();
+        queueMicrotask(async () => {
+            resolve(await processPacket(packets, nextTag, nextValues, sendQueue, id, true));
+        });
+    }
+    else {
+        sendQueue[0] = false;
     }
-    return [code, sendData, packet];
+    return result;
 }
 /**
  * Calls the listener for a packet with error callback
@@ -173,7 +192,7 @@ function CreateObjPacket(settings) {
     let { tag, types = [], dataMaxes, dataMins, noDataRange = false, dontSpread = false, autoFlatten = false, validator = null, dataBatching = 0, maxBatchSize = 10, rateLimit = 0, enabled = true, async = false, gzipCompression = types && types.includes(PacketType_1.PacketType.JSON) } = settings;
     if (!tag)
         throw new Error("Tag not selected!");
-    if (types.length == 0)
+    if (!types || types.length == 0)
         throw new Error("Types is set to 0 length");
     for (const type of types) {
         if (!isInvalidType(type))

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

@@ -16,6 +16,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RateHandler = void 0;
+const Connection_1 = require("../../Connection");
 class RateHandler {
     rates = {};
     limits = {};
@@ -50,7 +51,7 @@ class RateHandler {
     }
     trigger(tag) {
         if (tag in this.rates && ++this.rates[tag] > this.limits[tag]) {
-            this.socket.close(4000);
+            this.socket.close(Connection_1.CloseCodes.RATELIMIT);
             return true;
         }
         return false;

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "sonic-ws",
-  "version": "1.2.2",
+  "version": "1.3.0-min",
   "description": "Ultra-lightweight, high-performance, and bandwidth efficient websocket library",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "scripts": {
     "webpack": "webpack --mode production",
-    "build_web": "rimraf ./html && tsc --moduleResolution nodenext --module nodenext --target ES6 --outdir ./html src/ws/client/browser/ClientBrowser.ts && npm run webpack",
+    "build_web": "rimraf ./html && tsc --moduleResolution nodenext --module nodenext --outDir ./html src/ws/client/browser/ClientBrowser.ts && npm run webpack",
     "build_node": "rimraf ./dist && tsc -d",
     "build": "npm run build_node && npm run build_web",
     "test_web": "npm run build && node test-site/server.mjs",
@@ -24,8 +24,7 @@
   "author": "lily",
   "license": "Apache-2.0",
   "dependencies": {
-    "ws": "^8.18.2",
-    "zstd-codec": "^0.1.5"
+    "ws": "^8.18.2"
   },
   "devDependencies": {
     "@types/node": "^24.2.1",