sonic-ws 1.0.0-beta.9 → 1.0.0-rc.0-patch

package/dist/ws/util/CodePointUtil.js

@@ -35,8 +35,10 @@ function overflowPow(num) {
     var _a;
     return (_a = OVERFLOW_POWS[num]) !== null && _a !== void 0 ? _a : (OVERFLOW_POWS[num] = Math.pow(exports.OVERFLOW, num));
 }
+for (var i = 0; i < 3; i++)
+    overflowPow(i);
 function processCharCodes(text) {
-    return text.split("").map(function (v) { return v.charCodeAt(0); });
+    return Array.from(text, function (char) { return char.charCodeAt(0); });
 }
 // this converts an encoded code point back to a signed number
 function fromSignedINT_C(point) {
@@ -61,12 +63,13 @@ function sectorSize(number) {
     // 0 would make -Infinity;
     if (number == 0)
         return 1;
+    number = Math.abs(number);
     // iterative system because it's faster than log
     var count = 1;
-    var num = exports.OVERFLOW;
+    var num = overflowPow(1);
     while (number >= num) {
         count++;
-        num *= exports.OVERFLOW;
+        num = overflowPow(count);
     }
     return count;
 }
@@ -78,24 +81,22 @@ function convertINT_D(number, chars) {
     // store the sign and work with the absolute value
     var negative = number < 0;
     number = Math.abs(number);
-    var string = "";
+    var result = [];
     // for each character except the last, extract the digit at that position
     // this is similar to how base conversion works: divide by base^position
     for (var i = 0; i < chars - 1; i++) {
-        var power = Math.pow(exports.OVERFLOW, chars - i - 1);
+        var power = overflowPow(chars - i - 1);
         var based = Math.floor(number / power);
-        string += String.fromCharCode(based);
+        result.push(based);
         // remove it from the number so it doesnt effect future iterations
         number -= based * power;
     }
     // the last digit is just the remainder
-    string += String.fromCharCode(number % exports.OVERFLOW);
+    result.push(number % exports.OVERFLOW);
     // if the number was negative, we offset each character to indicate the sign
     // we only offset non-zero digits to avoid collisions with the null character
-    var stringified = negative ? processCharCodes(string)
-        .map(function (part) { return String.fromCharCode(part > 0 ? part + exports.NEGATIVE_C : part); })
-        .join("")
-        : string;
+    var stringified = negative ? result.map(function (part) { return String.fromCharCode(part > 0 ? part + exports.NEGATIVE_C : part); }).join("")
+        : String.fromCharCode.apply(String, result);
     return stringified;
 }
 // decodes a string created by convertINT_D back into the original signed integer

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

@@ -10,9 +10,12 @@ export declare class PacketHolder {
     createPackets(packets: Packet[]): void;
     get(tag: string): number;
     getChar(tag: string): string;
+    getTag(key: string): string;
     getPacket(tag: string): Packet;
-    has(data: string): boolean;
+    has(key: string): boolean;
+    hasTag(tag: string): boolean;
     getKeys(): Record<string, number>;
+    getTags(): Record<number, string>;
     serialize(): string;
     static empty(): PacketHolder;
 }

package/dist/ws/util/PacketHolder.js

@@ -11,10 +11,6 @@ var PacketHolder = /** @class */ (function () {
         this.createPackets(packets);
     }
     PacketHolder.prototype.createKey = function (tag) {
-        if (tag.includes(",")) {
-            console.log("Tag \"".concat(tag, "\" is invalid; keys cannot contain commas."));
-            return;
-        }
         this.keys[tag] = this.key;
         this.tags[this.key] = tag;
         this.key++;
@@ -32,15 +28,24 @@ var PacketHolder = /** @class */ (function () {
     PacketHolder.prototype.getChar = function (tag) {
         return String.fromCharCode(this.get(tag));
     };
+    PacketHolder.prototype.getTag = function (key) {
+        return this.tags[key.charCodeAt(0)];
+    };
     PacketHolder.prototype.getPacket = function (tag) {
         return this.packetMap[tag];
     };
-    PacketHolder.prototype.has = function (data) {
-        return this.tags[data.charCodeAt(0)] != null;
+    PacketHolder.prototype.has = function (key) {
+        return key.charCodeAt(0) in this.tags;
+    };
+    PacketHolder.prototype.hasTag = function (tag) {
+        return tag in this.keys;
     };
     PacketHolder.prototype.getKeys = function () {
         return this.keys;
     };
+    PacketHolder.prototype.getTags = function () {
+        return this.tags;
+    };
     PacketHolder.prototype.serialize = function () {
         return this.packets.map(function (p) { return p.serialize(); }).join("");
     };

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

@@ -3,30 +3,68 @@ import { Packet } from "../packets/Packets";
 import { PacketType } from "../packets/PacketType";
 import { EnumPackage } from "../enums/EnumType";
 export declare function emitPacket(packets: PacketHolder, send: (data: string) => void, tag: string, values: any[]): void;
+export type ArguableType = PacketType | EnumPackage;
+/** Settings for single-typed packets */
+export type SinglePacketSettings = {
+    /** The tag of the packet; used for on(tag) and send(tag) */
+    tag: string;
+    /** The data type of the packet; defaults to PacketType.NONE */
+    type?: ArguableType;
+    /** The maximum amount of values that can be sent through this packet; defaults to 1 */
+    dataMax?: number;
+    /** The minimum amount of values that can be sent through this packet; defaults to the max */
+    dataMin?: number;
+    /** If the values should be kept in an array or spread along the listener; defaults to false */
+    dontSpread?: boolean;
+};
+/** Settings for multi-typed packets */
+export type MultiPacketSettings = {
+    /** The tag of the packet; used for on(tag) and send(tag) */
+    tag: string;
+    /** The data types of the packet */
+    types: ArguableType[];
+    /** The maximum amount of values that can be sent through each type of packet; defaults to 1 for each */
+    dataMaxes?: number[];
+    /** The minimum amount of values that can be sent through each type of packet; defaults to the max for each */
+    dataMins?: number[];
+    /** If the values should be kept in an array or spread along the listener; defaults to false */
+    dontSpread?: boolean;
+};
+/** Settings for single-typed enum packets */
+export type EnumPacketSettings = {
+    /** The tag of the packet; used for on(packetTag) and send(packetTag) */
+    packetTag: string;
+    /** The tag of the enum; used for WrapEnum(enumTag) */
+    enumTag: string;
+    /** The possible values of the enum */
+    values: any[];
+    /** The maximum amount of values that can be sent through this packet; defaults to 1 */
+    dataMax?: number;
+    /** The minimum amount of values that can be sent through this packet; defaults to the max */
+    dataMin?: number;
+    /** If the values should be kept in an array or spread along the listener; defaults to false */
+    dontSpread?: boolean;
+};
 /**
- * Creates a structure for a simple single-typed packet
- * @param tag The tag of the packet; for on(tag) and send(tag, ...)
- * @param type The packet type; defaults to none
- * @param dataCap The data cap (amount of values that can be sent); defaults to 1
- * @param dontSpread If true, the values will be kept in an array instead of spread
- * @returns The packet structure data
+ * Creates a structure for a simple single-typed packet.
+ * This packet can be sent and received with the specified tag, type, and data cap.
+ * @param settings The settings object containing `tag`, `type`, `dataMax`, `dataMin`, and `dontSpread`.
+ * @returns The constructed packet structure data.
+ * @throws {Error} If the `type` is invalid.
  */
-export declare function CreatePacket(tag: string, type?: (PacketType | EnumPackage), dataCap?: number, dontSpread?: boolean): Packet;
+export declare function CreatePacket(settings: SinglePacketSettings): Packet;
 /**
- * Creates a structure for an object (multi-typed) packet
- * @param tag The tag of the packet; for on(tag) and send(tag, ...)
- * @param types The types in the packet, in order
- * @param dataCaps The data cap (amount of values that can be sent) for each type, in order
- * @param dontSpread If true, the values will be kept in an array instead of spread
- * @returns The packet structure data
+ * Creates a structure for an object (multi-typed) packet.
+ * This packet allows multiple types and their associated data caps.
+ * @param settings The settings object containing `tag`, `types`, `dataMaxes`, `dataMins`, and `dontSpread`.
+ * @returns The constructed packet structure data.
+ * @throws {Error} If any type in `types` is invalid.
  */
-export declare function CreateObjPacket(tag: string, types: (PacketType | EnumPackage)[], dataCaps: number[], dontSpread?: boolean): Packet;
+export declare function CreateObjPacket(settings: MultiPacketSettings): Packet;
 /**
- * Creates and defines an enum packet. In an object, you can do DefineEnum() for the type
- * @param packetTag The tag of the packet; for on(tag) and send(tag, ...)
- * @param enumTag The tag of the enum; for send(tag, WrapEnum(enumTag, value))
- * @param strings The possible values of the enum
- * @param dataCap The data cap (amount of values that can be sent); defaults to 1
- * @returns The packet structure data
+ * Creates and defines an enum packet. This can be used to create an enum-based packet
+ * with a specific tag and possible values.
+ * @param settings The settings object containing `packetTag`, `enumTag`, `strings` (enum values), `dataMax`, `dataMin`, and `dontSpread`.
+ * @returns The constructed packet structure data.
  */
-export declare function CreateEnumPacket(packetTag: string, enumTag: string, strings: string[], dataCap?: number, dontSpread?: boolean): Packet;
+export declare function CreateEnumPacket(settings: EnumPacketSettings): Packet;

package/dist/ws/util/PacketUtils.js

@@ -14,62 +14,89 @@ function emitPacket(packets, send, tag, values) {
     if (code == CodePointUtil_1.NULL)
         throw new Error("Tag \"".concat(tag, "\" has not been created!"));
     var packet = packets.getPacket(tag);
-    if (values.length > packet.size)
-        throw new Error("Packet \"".concat(tag, "\" only allows ").concat(packet.size, " values!"));
-    send(code + packet.processSend(values));
+    if (values.length > packet.maxSize)
+        throw new Error("Packet \"".concat(tag, "\" only allows ").concat(packet.maxSize, " values!"));
+    if (values.length < packet.minSize)
+        throw new Error("Packet \"".concat(tag, "\" requires at least ").concat(packet.minSize, " values!"));
+    if (!packet.object) {
+        var found = values.find(function (v) { return typeof v == 'object' && v != null; });
+        if (found)
+            console.warn("Passing an array will result in undefined behavior (".concat(JSON.stringify(found), "). Spread the array with ...arr"));
+    }
+    send(code + (values.length > 0 ? packet.processSend(values) : ""));
 }
 function isValidType(type) {
     return (typeof type == 'number' && type in PacketType_1.PacketType) || type instanceof EnumType_1.EnumPackage;
 }
-function clampDataCap(dataCap) {
-    if (dataCap > CodePointUtil_1.MAX_C) {
+function clampDataMax(dataMax) {
+    if (dataMax > CodePointUtil_1.MAX_C) {
         console.warn("Only ".concat(CodePointUtil_1.MAX_C, " values can be sent in a single type! Use CreateObjPacket() if you want to send more."));
         return CodePointUtil_1.MAX_C;
     }
-    return dataCap;
+    return dataMax;
+}
+function clampDataMin(dataMin, dataMax) {
+    if (dataMin < 0) {
+        console.warn("Having a data minimum below 0 does not do anything!");
+        return 0;
+    }
+    // also catches >MAX_C
+    if (dataMin > dataMax) {
+        console.warn("Data minimum can not be higher than the data maximum!");
+        return dataMax;
+    }
+    return dataMin;
 }
 /**
- * Creates a structure for a simple single-typed packet
- * @param tag The tag of the packet; for on(tag) and send(tag, ...)
- * @param type The packet type; defaults to none
- * @param dataCap The data cap (amount of values that can be sent); defaults to 1
- * @param dontSpread If true, the values will be kept in an array instead of spread
- * @returns The packet structure data
+ * Creates a structure for a simple single-typed packet.
+ * This packet can be sent and received with the specified tag, type, and data cap.
+ * @param settings The settings object containing `tag`, `type`, `dataMax`, `dataMin`, and `dontSpread`.
+ * @returns The constructed packet structure data.
+ * @throws {Error} If the `type` is invalid.
  */
-function CreatePacket(tag, type, dataCap, dontSpread) {
-    if (type === void 0) { type = PacketType_1.PacketType.NONE; }
-    if (dataCap === void 0) { dataCap = 1; }
-    if (dontSpread === void 0) { dontSpread = false; }
-    if (!isValidType(type))
-        throw new Error("Invalid packet type: " + type);
-    return new Packets_1.Packet(tag, Packets_1.PacketSchema.single(type, clampDataCap(dataCap), dontSpread));
+function CreatePacket(settings) {
+    var tag = settings.tag, _a = settings.type, type = _a === void 0 ? PacketType_1.PacketType.NONE : _a, _b = settings.dataMax, dataMax = _b === void 0 ? 1 : _b, dataMin = settings.dataMin, _c = settings.dontSpread, dontSpread = _c === void 0 ? false : _c;
+    if (dataMin == undefined)
+        dataMin = type == PacketType_1.PacketType.NONE ? 0 : dataMax;
+    if (!isValidType(type)) {
+        throw new Error("Invalid packet type: ".concat(type));
+    }
+    return new Packets_1.Packet(tag, Packets_1.PacketSchema.single(type, clampDataMax(dataMax), clampDataMin(dataMin, dataMax), dontSpread), false);
 }
 /**
- * Creates a structure for an object (multi-typed) packet
- * @param tag The tag of the packet; for on(tag) and send(tag, ...)
- * @param types The types in the packet, in order
- * @param dataCaps The data cap (amount of values that can be sent) for each type, in order
- * @param dontSpread If true, the values will be kept in an array instead of spread
- * @returns The packet structure data
+ * Creates a structure for an object (multi-typed) packet.
+ * This packet allows multiple types and their associated data caps.
+ * @param settings The settings object containing `tag`, `types`, `dataMaxes`, `dataMins`, and `dontSpread`.
+ * @returns The constructed packet structure data.
+ * @throws {Error} If any type in `types` is invalid.
  */
-function CreateObjPacket(tag, types, dataCaps, dontSpread) {
-    if (dontSpread === void 0) { dontSpread = false; }
+function CreateObjPacket(settings) {
+    var tag = settings.tag, types = settings.types, dataMaxes = settings.dataMaxes, dataMins = settings.dataMins, _a = settings.dontSpread, dontSpread = _a === void 0 ? false : _a;
     var invalid = types.find(function (type) { return !isValidType(type); });
-    if (invalid)
-        throw new Error("Invalid packet type: " + invalid);
-    dataCaps = dataCaps.map(clampDataCap);
-    return new Packets_1.Packet(tag, Packets_1.PacketSchema.object(types, dataCaps, dontSpread));
+    if (invalid) {
+        throw new Error("Invalid packet type: ".concat(invalid));
+    }
+    if (dataMaxes == undefined)
+        dataMaxes = Array.from({ length: types.length }).map(function (_) { return 1; });
+    if (dataMins == undefined)
+        dataMins = Array.from({ length: types.length }).map(function (_, i) { return dataMaxes[i]; });
+    var clampedDataMaxes = dataMaxes.map(clampDataMax);
+    var clampedDataMins = dataMins.map(function (m, i) { return types[i] == PacketType_1.PacketType.NONE ? 0 : clampDataMin(m, clampedDataMaxes[i]); });
+    return new Packets_1.Packet(tag, Packets_1.PacketSchema.object(types, clampedDataMaxes, clampedDataMins, dontSpread), false);
 }
 /**
- * Creates and defines an enum packet. In an object, you can do DefineEnum() for the type
- * @param packetTag The tag of the packet; for on(tag) and send(tag, ...)
- * @param enumTag The tag of the enum; for send(tag, WrapEnum(enumTag, value))
- * @param strings The possible values of the enum
- * @param dataCap The data cap (amount of values that can be sent); defaults to 1
- * @returns The packet structure data
+ * Creates and defines an enum packet. This can be used to create an enum-based packet
+ * with a specific tag and possible values.
+ * @param settings The settings object containing `packetTag`, `enumTag`, `strings` (enum values), `dataMax`, `dataMin`, and `dontSpread`.
+ * @returns The constructed packet structure data.
  */
-function CreateEnumPacket(packetTag, enumTag, strings, dataCap, dontSpread) {
-    if (dataCap === void 0) { dataCap = 1; }
-    if (dontSpread === void 0) { dontSpread = false; }
-    return CreatePacket(packetTag, (0, EnumHandler_1.DefineEnum)(enumTag, strings), dataCap, dontSpread);
+function CreateEnumPacket(settings) {
+    var packetTag = settings.packetTag, enumTag = settings.enumTag, values = settings.values, _a = settings.dataMax, dataMax = _a === void 0 ? 1 : _a, _b = settings.dataMin, dataMin = _b === void 0 ? 0 : _b, _c = settings.dontSpread, dontSpread = _c === void 0 ? false : _c;
+    return CreatePacket({
+        tag: packetTag,
+        type: (0, EnumHandler_1.DefineEnum)(enumTag, values),
+        dataMax: dataMax,
+        dataMin: dataMin,
+        dontSpread: dontSpread
+    });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sonic-ws",
-  "version": "1.0.0-beta.9",
+  "version": "1.0.0-rc.0-patch",
   "description": "A bandwidth efficient websocket library",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",