sonic-ws 1.1.1 → 1.2.1-wtf

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

@@ -15,7 +15,7 @@
  * limitations under the License.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.decompressBools = exports.compressBools = exports.varIntOverflowPow = exports.ONE_FOURTH = exports.ONE_EIGHT = exports.MAX_VARINT = exports.MAX_UVARINT = exports.MAX_VSECT_SIZE = exports.VARINT_OVERFLOW = exports.NEGATIVE_VARINT = exports.VARINT_CHAIN_FLAG = exports.UVARINT_OVERFLOW = exports.MAX_INT_D = exports.SHORT_OVERFLOW = exports.SHORT_CC_OVERFLOW = exports.NEGATIVE_SHORT = exports.MAX_SHORT = exports.BYTE_OVERFLOW = exports.NEGATIVE_BYTE = exports.MAX_BYTE = void 0;
+exports.decompressJSON = exports.compressJSON = exports.decompressBools = exports.compressBools = exports.varIntOverflowPow = exports.EMPTY_UINT8 = exports.ONE_FOURTH = exports.ONE_EIGHT = exports.MAX_VARINT = exports.MAX_UVARINT = exports.MAX_VSECT_SIZE = exports.VARINT_OVERFLOW = exports.NEGATIVE_VARINT = exports.VARINT_CHAIN_FLAG = exports.UVARINT_OVERFLOW = exports.MAX_INT_D = exports.SHORT_OVERFLOW = exports.SHORT_CC_OVERFLOW = exports.NEGATIVE_SHORT = exports.MAX_SHORT = exports.BYTE_OVERFLOW = exports.NEGATIVE_BYTE = exports.MAX_BYTE = void 0;
 exports.fromShort = fromShort;
 exports.toShort = toShort;
 exports.toByte = toByte;
@@ -36,6 +36,10 @@ exports.bytesToBits = bytesToBits;
 exports.bitsToBytes = bitsToBytes;
 exports.encodeHuffman = encodeHuffman;
 exports.decodeHuffman = decodeHuffman;
+exports.compressGzip = compressGzip;
+exports.decompressGzip = decompressGzip;
+exports.bytesToHex = bytesToHex;
+exports.hexToBytes = hexToBytes;
 const ArrayUtil_1 = require("../ArrayUtil");
 // this shit is so complex so i commented it...
 // the highest 8-bit
@@ -72,6 +76,7 @@ exports.MAX_VARINT = Math.floor(exports.MAX_UVARINT / 2);
 // constants
 exports.ONE_EIGHT = 1 / 8;
 exports.ONE_FOURTH = 1 / 4;
+exports.EMPTY_UINT8 = new Uint8Array([]);
 // precompute powers
 const VARINT_OVERFLOW_POWS = [];
 const varIntOverflowPow = (num) => VARINT_OVERFLOW_POWS[num] ??= exports.UVARINT_OVERFLOW ** num;
@@ -332,3 +337,199 @@ function decodeHuffman(bits) {
     return result;
 }
 ;
+const gzipError = "Your browser is too old to support compression. Please update!";
+async function compressGzip(data, ident = "") {
+    if (typeof CompressionStream === "undefined") {
+        if (typeof window !== "undefined")
+            window.alert(gzipError);
+        throw new Error(gzipError);
+    }
+    const stream = new Blob([data]).stream().pipeThrough(new CompressionStream("deflate-raw"));
+    const buffer = await new Response(stream).arrayBuffer();
+    if (data.length <= buffer.byteLength && ident != "") {
+        console.warn("WARN: Packet '" + ident + "' is small, and compressing it makes the size bigger!");
+    }
+    return new Uint8Array(buffer);
+}
+async function decompressGzip(data) {
+    if (typeof DecompressionStream === "undefined") {
+        if (typeof window !== "undefined")
+            window.alert(gzipError);
+        throw new Error(gzipError);
+    }
+    const stream = new Blob([data]).stream().pipeThrough(new DecompressionStream("deflate-raw"));
+    const buffer = await new Response(stream).arrayBuffer();
+    return new Uint8Array(buffer);
+}
+// BOOLEANS
+var JSONType;
+(function (JSONType) {
+    JSONType[JSONType["NULL"] = 0] = "NULL";
+    JSONType[JSONType["BOOL"] = 1] = "BOOL";
+    JSONType[JSONType["INT"] = 2] = "INT";
+    JSONType[JSONType["FLOAT"] = 3] = "FLOAT";
+    JSONType[JSONType["STRING"] = 4] = "STRING";
+    JSONType[JSONType["ARRAY"] = 5] = "ARRAY";
+    JSONType[JSONType["OBJECT"] = 6] = "OBJECT";
+})(JSONType || (JSONType = {}));
+const encodeString = (str) => {
+    const encoder = new TextEncoder();
+    const data = encoder.encode(str);
+    return [...convertVarInt(data.length), ...data];
+};
+const decodeString = (bytes, offset) => {
+    const [off, len] = readVarInt(bytes, offset);
+    const decoder = new TextDecoder();
+    return { value: decoder.decode(bytes.subarray(off, off + len)), length: off + len - offset };
+};
+// utility: pack 3-bit values into bytes
+const packTypeBits = (types) => {
+    let bits = '';
+    for (const t of types)
+        bits += t.toString(2).padStart(3, '0');
+    return bitsToBytes(bits);
+};
+// utility: unpack bytes into 3-bit type array
+const unpackTypeBits = (bytes, totalValues) => {
+    const bitStr = bytesToBits(bytes);
+    const types = [];
+    for (let i = 0; i < totalValues; i++) {
+        types.push(parseInt(bitStr.slice(i * 3, i * 3 + 3), 2));
+    }
+    return types;
+};
+// main compression
+const compressJSON = (value) => {
+    const bools = [];
+    const payload = [];
+    const typeList = [];
+    const encodeValue = (val) => {
+        if (val === null) {
+            typeList.push(JSONType.NULL);
+        }
+        else if (typeof val === 'boolean') {
+            typeList.push(JSONType.BOOL);
+            bools.push(val);
+        }
+        else if (Number.isInteger(val)) {
+            typeList.push(JSONType.INT);
+            payload.push(...convertVarInt(mapZigZag(val)));
+        }
+        else if (typeof val === 'number') {
+            typeList.push(JSONType.FLOAT);
+            payload.push(...convertFloat(val));
+        }
+        else if (typeof val === 'string') {
+            typeList.push(JSONType.STRING);
+            payload.push(...encodeString(val));
+        }
+        else if (Array.isArray(val)) {
+            typeList.push(JSONType.ARRAY);
+            payload.push(...convertVarInt(val.length));
+            for (const item of val)
+                encodeValue(item);
+        }
+        else if (typeof val === 'object') {
+            typeList.push(JSONType.OBJECT);
+            const keys = Object.keys(val);
+            payload.push(...convertVarInt(keys.length));
+            for (const key of keys) {
+                payload.push(...encodeString(key));
+                encodeValue(val[key]);
+            }
+        }
+        else {
+            throw new Error('Unsupported type');
+        }
+    };
+    encodeValue(value);
+    // boolean bitmap bytes
+    const boolBytes = bools.length
+        ? (0, ArrayUtil_1.splitArray)(bools, 8).map((slice) => (0, exports.compressBools)(slice))
+        : [];
+    // type map bytes (3-bit per value)
+    const typeBytes = packTypeBits(typeList);
+    // prepend lengths of boolBytes and typeBytes as varints
+    const header = [...convertVarInt(boolBytes.length), ...convertVarInt(typeBytes.length)];
+    return Uint8Array.from([...header, ...boolBytes.flat(), ...typeBytes, ...payload]);
+};
+exports.compressJSON = compressJSON;
+// decompression
+const decompressJSON = (bytes) => {
+    let offset = 0;
+    // read lengths
+    const [off1, boolByteLen] = readVarInt(bytes, offset);
+    offset = off1;
+    const [off2, typeByteLen] = readVarInt(bytes, offset);
+    offset = off2;
+    // boolean bitmap
+    const boolStream = [];
+    for (let i = 0; i < boolByteLen; i++) {
+        boolStream.push(...(0, exports.decompressBools)(bytes[offset++]));
+    }
+    let boolIndex = 0;
+    // type map
+    const typeBytes = bytes.subarray(offset, offset + typeByteLen);
+    offset += typeByteLen;
+    const typeList = unpackTypeBits(typeBytes, typeBytes.length * 8 / 3); // overestimate, will only use while decoding
+    let typeIndex = 0;
+    const decodeValue = (depth) => {
+        if (depth > 500)
+            throw new Error("JSON array too deep.");
+        const type = typeList[typeIndex++];
+        switch (type) {
+            case JSONType.NULL: return null;
+            case JSONType.BOOL: return boolStream[boolIndex++];
+            case JSONType.INT: {
+                const [off, n] = readVarInt(bytes, offset);
+                offset = off;
+                return demapZigZag(n);
+            }
+            case JSONType.FLOAT: {
+                const val = deconvertFloat(Array.from(bytes.subarray(offset, offset + 4)));
+                offset += 4;
+                return val;
+            }
+            case JSONType.STRING: {
+                const { value, length } = decodeString(bytes, offset);
+                offset += length;
+                return value;
+            }
+            case JSONType.ARRAY: {
+                const [off, len] = readVarInt(bytes, offset);
+                offset = off;
+                const arr = [];
+                for (let i = 0; i < len; i++)
+                    arr.push(decodeValue(depth + 1));
+                return arr;
+            }
+            case JSONType.OBJECT: {
+                const [off, numKeys] = readVarInt(bytes, offset);
+                offset = off;
+                const obj = {};
+                for (let i = 0; i < numKeys; i++) {
+                    const { value: key, length: keyLen } = decodeString(bytes, offset);
+                    offset += keyLen;
+                    obj[key] = decodeValue(depth + 1);
+                }
+                return obj;
+            }
+            default:
+                throw new Error(`Unknown type ${type}`);
+        }
+    };
+    return decodeValue(0);
+};
+exports.decompressJSON = decompressJSON;
+function bytesToHex(bytes) {
+    return Array.from(bytes, b => b.toString(16).padStart(2, '0')).join('');
+}
+;
+function hexToBytes(hex) {
+    const bytes = new Uint8Array(hex.length / 2);
+    for (let i = 0; i < hex.length; i += 2) {
+        bytes[i / 2] = parseInt(hex.substring(i, i + 2), 16);
+    }
+    return bytes;
+}
+;

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

@@ -33,7 +33,7 @@ export declare class PacketHolder {
     getKey(tag: string): number;
     /**
      * Returns the tag associated with a given character key
-     * @param key A 1-character string key
+     * @param key Key bytre
      */
     getTag(key: number): string;
     /**

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

@@ -71,7 +71,7 @@ class PacketHolder {
     }
     /**
      * Returns the tag associated with a given character key
-     * @param key A 1-character string key
+     * @param key Key bytre
      */
     getTag(key) {
         return this.tags[key];

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

@@ -9,7 +9,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[]): [code: number, data: Uint8Array, packet: Packet<any>];
+export declare function processPacket(packets: PacketHolder, tag: string, values: any[], id: number): Promise<[code: number, data: Uint8Array, packet: Packet<any>]>;
 /**
  * Calls the listener for a packet with error callback
  * @param listened The listened data
@@ -49,6 +49,8 @@ export type SharedPacketSettings = {
     validator?: ValidatorFunction;
     /** If this is true, other packets will be processed even if this one isn't finished; it'll still prevent it from calling twice before this finishes though. Defaults to false. */
     async?: boolean;
+    /** If this is true, the packet will be Gzip compressed. Defaults to false on all types but JSON. */
+    gzipCompression?: boolean;
 };
 /** Settings for single-typed packets */
 export type SinglePacketSettings = SharedPacketSettings & {
@@ -58,6 +60,8 @@ export type SinglePacketSettings = SharedPacketSettings & {
     dataMax?: number;
     /** The minimum amount of values that can be sent through this packet; defaults to the max */
     dataMin?: number;
+    /** If this is true, it will save the last received of this value, and if no data is sent, it'll re-use the previous value. This is not compatible with dataMin: 0. Defaults to false. */
+    rereference?: boolean;
 };
 /** Settings for multi-typed packets */
 export type MultiPacketSettings = SharedPacketSettings & {
@@ -79,6 +83,10 @@ export type EnumPacketSettings = SharedPacketSettings & {
     /** The minimum amount of values that can be sent through this packet; defaults to the max */
     dataMin?: number;
 };
+export type KeyEffectivePacketSettings = SharedPacketSettings & {
+    /** Amount of keys to consume in order to have differing values; defaults to 2. Must be 2+ */
+    count?: number;
+};
 /**
  * Creates a structure for a simple single-typed packet.
  * This packet can be sent and received with the specified tag, type, and data cap.
@@ -108,6 +116,7 @@ export declare function CreateObjPacket<T extends readonly ArguableType[], V ext
  * @returns The constructed packet structure data.
  */
 export declare function CreateEnumPacket(settings: EnumPacketSettings): Packet<PacketType.ENUMS>;
+export declare function CreateKeyEffective(settings: KeyEffectivePacketSettings): Packet<PacketType.KEY_EFFECTIVE>;
 /**
  * Flattens a 2-depth array for efficient wire transfer
  * Turns [[x,y,z],[x,y,z]...] to [[x,x...],[y,y...],[z,z...]]

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

@@ -20,11 +20,13 @@ exports.listenPacket = listenPacket;
 exports.CreatePacket = CreatePacket;
 exports.CreateObjPacket = CreateObjPacket;
 exports.CreateEnumPacket = CreateEnumPacket;
+exports.CreateKeyEffective = CreateKeyEffective;
 exports.FlattenData = FlattenData;
 exports.UnFlattenData = UnFlattenData;
 const Packets_1 = require("../../packets/Packets");
 const PacketType_1 = require("../../packets/PacketType");
 const EnumType_1 = require("../enums/EnumType");
+const CompressionUtil_1 = require("./CompressionUtil");
 /**
  * Processes and verifies values into a sendable format
  * @param packets Packet holder
@@ -32,7 +34,7 @@ const EnumType_1 = require("../enums/EnumType");
  * @param values The values
  * @returns The indexed code, the data, and the packet schema
  */
-function processPacket(packets, tag, values) {
+async function processPacket(packets, tag, values, id) {
     const code = packets.getKey(tag);
     const packet = packets.getPacket(tag);
     if (packet.autoFlatten) {
@@ -45,9 +47,11 @@ function processPacket(packets, tag, values) {
             throw new Error(`Packet "${tag}" requires at least ${packet.minSize} values!`);
     }
     if (!packet.object) {
-        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`);
+        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 {
         // also map non arrays to arrays to keep some code cleaner
@@ -65,7 +69,15 @@ function processPacket(packets, tag, values) {
             }
         }
     }
-    return [code, values.length > 0 ? packet.processSend(values) : new Uint8Array([]), packet];
+    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;
+    }
+    return [code, sendData, packet];
 }
 /**
  * Calls the listener for a packet with error callback
@@ -90,12 +102,13 @@ async function listenPacket(listened, listeners, errorCB) {
         }
     }
     catch (err) {
+        console.error(err);
         errorCB(err);
     }
 }
-/** Determines if a type is a valid packet type */
+/** Determines if a type is a invalid packet type */
 function isInvalidType(type) {
-    return !(typeof type == 'number' && type in PacketType_1.PacketType) && !(type instanceof EnumType_1.EnumPackage);
+    return (!(typeof type == 'number' && type in PacketType_1.PacketType) && !(type instanceof EnumType_1.EnumPackage)) || type == PacketType_1.PacketType.KEY_EFFECTIVE;
 }
 const MAX_DATA_MAX = 2048383;
 /** Clamps data max between 0 and MAX_DATA_MAX */
@@ -132,19 +145,21 @@ function clampDataMin(dataMin, dataMax) {
  * @throws {Error} If the `type` is invalid.
  */
 function CreatePacket(settings) {
-    let { tag, type = PacketType_1.PacketType.NONE, dataMax = 1, dataMin = 1, noDataRange = false, dontSpread = false, validator = null, dataBatching = 0, maxBatchSize = 10, rateLimit = 0, enabled = true, async = false } = settings;
+    let { tag, type = PacketType_1.PacketType.NONE, dataMax = 1, dataMin = 1, noDataRange = false, dontSpread = false, validator = null, dataBatching = 0, maxBatchSize = 10, rateLimit = 0, enabled = true, async = false, gzipCompression = type == PacketType_1.PacketType.JSON, rereference = false } = settings;
     if (!tag)
         throw new Error("Tag not selected!");
     if (noDataRange) {
-        dataMin = 0;
+        dataMin = rereference ? 1 : 0;
         dataMax = MAX_DATA_MAX;
     }
     else if (dataMin == undefined)
         dataMin = type == PacketType_1.PacketType.NONE ? 0 : dataMax;
+    if (rereference && dataMin == 0)
+        throw new Error("Rereference cannot be true if the dataMin is 0");
     if (isInvalidType(type)) {
         throw new Error(`Invalid packet type: ${type}`);
     }
-    const schema = Packets_1.PacketSchema.single(type, clampDataMax(dataMax), clampDataMin(dataMin, dataMax), dontSpread, dataBatching, maxBatchSize, rateLimit, async);
+    const schema = Packets_1.PacketSchema.single(type, clampDataMax(dataMax), clampDataMin(dataMin, dataMax), dontSpread, dataBatching, maxBatchSize, rateLimit, async, gzipCompression, rereference);
     return new Packets_1.Packet(tag, schema, validator, enabled, false);
 }
 /**
@@ -155,7 +170,7 @@ function CreatePacket(settings) {
  * @throws {Error} If any type in `types` is invalid.
  */
 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 } = 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)
@@ -181,7 +196,7 @@ function CreateObjPacket(settings) {
     }
     const clampedDataMaxes = dataMaxes.map(clampDataMax);
     const clampedDataMins = dataMins.map((m, i) => types[i] == PacketType_1.PacketType.NONE ? 0 : clampDataMin(m, clampedDataMaxes[i]));
-    const schema = Packets_1.PacketSchema.object(types, clampedDataMaxes, clampedDataMins, dontSpread, autoFlatten, dataBatching, maxBatchSize, rateLimit, async);
+    const schema = Packets_1.PacketSchema.object(types, clampedDataMaxes, clampedDataMins, dontSpread, autoFlatten, dataBatching, maxBatchSize, rateLimit, async, gzipCompression);
     return new Packets_1.Packet(tag, schema, validator, enabled, false);
 }
 /**
@@ -207,6 +222,14 @@ function CreateEnumPacket(settings) {
         async,
     });
 }
+function CreateKeyEffective(settings) {
+    const { tag, count = 2, validator = null, async = false } = settings;
+    if (!tag)
+        throw new Error("Tag not selected!");
+    if (count < 2)
+        throw new Error("Must have at least 2 key consumptions on key effective packet!");
+    throw new Error("Currently W.I.P.");
+}
 /**
  * Flattens a 2-depth array for efficient wire transfer
  * Turns [[x,y,z],[x,y,z]...] to [[x,x...],[y,y...],[z,z...]]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sonic-ws",
-  "version": "1.1.1",
+  "version": "1.2.1-wtf",
   "description": "Ultra-lightweight, high-performance, and bandwidth efficient websocket library",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -31,6 +31,7 @@
     "@types/node": "^24.2.1",
     "@types/ws": "^8.18.1",
     "cpy-cli": "^5.0.0",
+    "esbuild-loader": "^4.4.2",
     "form-data": "^4.0.4",
     "rimraf": "^6.0.1",
     "ts-loader": "^9.5.2",