sonic-ws 1.0.0-rc.8 → 1.0.3

package/dist/ws/client/core/ClientCore.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.
@@ -14,62 +14,29 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
-    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (g && (g = 0, op[0] && (_ = 0)), _) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SonicWSCore = void 0;
-var PacketHolder_1 = require("../../util/packets/PacketHolder");
-var CompressionUtil_1 = require("../../util/packets/CompressionUtil");
-var PacketUtils_1 = require("../../util/packets/PacketUtils");
-var version_1 = require("../../../version");
-var Packets_1 = require("../../packets/Packets");
-var BatchHelper_1 = require("../../util/packets/BatchHelper");
-var BufferUtil_1 = require("../../util/BufferUtil");
-// throttle at 90% of rate limit to avoid spikes and kicks
-var THRESHOLD_MULT = 0.90;
-var SonicWSCore = /** @class */ (function () {
-    function SonicWSCore(ws, bufferHandler) {
-        var _this = this;
-        this.clientPackets = new PacketHolder_1.PacketHolder();
-        this.serverPackets = new PacketHolder_1.PacketHolder();
-        this.pastKeys = false;
-        this.readyListeners = [];
-        this.timers = [];
-        this.id = -1;
+const PacketHolder_1 = require("../../util/packets/PacketHolder");
+const CompressionUtil_1 = require("../../util/packets/CompressionUtil");
+const PacketUtils_1 = require("../../util/packets/PacketUtils");
+const version_1 = require("../../../version");
+const Packets_1 = require("../../packets/Packets");
+const BatchHelper_1 = require("../../util/packets/BatchHelper");
+const BufferUtil_1 = require("../../util/BufferUtil");
+class SonicWSCore {
+    /** Raw 'ws' library connection / webjs WebSocket class */
+    socket;
+    listeners;
+    preListen;
+    clientPackets = new PacketHolder_1.PacketHolder();
+    serverPackets = new PacketHolder_1.PacketHolder();
+    pastKeys = false;
+    readyListeners = [];
+    batcher;
+    bufferHandler;
+    id = -1;
+    _timers = {};
+    constructor(ws, bufferHandler) {
         this.socket = ws;
         this.listeners = {
             message: [],
@@ -79,144 +46,131 @@ var SonicWSCore = /** @class */ (function () {
         this.preListen = {};
         this.batcher = new BatchHelper_1.BatchHelper();
         this.invalidPacket = this.invalidPacket.bind(this);
-        this.keyHandler = function (event) { return _this.serverKeyHandler(event); };
-        this.socket.addEventListener('message', this.keyHandler); // lambda to persist 'this'
-        this.socket.addEventListener('close', function (event) {
-            _this.listeners.close.forEach(function (listener) { return listener(event); });
-            _this.timers.forEach(clearTimeout);
+        this.serverKeyHandler = this.serverKeyHandler.bind(this);
+        this.messageHandler = this.messageHandler.bind(this);
+        this.socket.addEventListener('message', this.serverKeyHandler);
+        this.socket.addEventListener('close', (event) => {
+            this.listeners.close.forEach(listener => listener(event));
+            Object.values(this._timers).forEach(clearTimeout);
         });
         this.bufferHandler = bufferHandler;
     }
-    SonicWSCore.prototype.serverKeyHandler = function (event) {
-        var _this = this;
-        var data = event.data.toString();
-        if (!data.startsWith("SWS")) {
+    reading = false;
+    async serverKeyHandler(event) {
+        // stupid asynchronous bullshit
+        if (this.reading)
+            return this.messageHandler(event);
+        this.reading = true;
+        const data = await this.bufferHandler(event);
+        if (data.length < 3 || (0, BufferUtil_1.as8String)(data.slice(0, 3)) != version_1.SERVER_SUFFIX) {
             this.socket.close(1000);
             throw new Error("The server requested is not a Sonic WS server.");
         }
-        var version = data.charCodeAt(3);
+        const version = data[3];
         if (version != version_1.VERSION) {
             this.socket.close(1000);
-            throw new Error("Version mismatch: ".concat(version > version_1.VERSION ? "client" : "server", " is outdated (server: ").concat(version, ", client: ").concat(version_1.VERSION, ")"));
+            throw new Error(`Version mismatch: ${version > version_1.VERSION ? "client" : "server"} is outdated (server: ${version}, client: ${version_1.VERSION})`);
         }
-        var _a = data.substring(4).split(CompressionUtil_1.NULL), ckData = _a[0], skData = _a[1], uData = _a[2];
+        const [ckOff, id] = (0, CompressionUtil_1.readVarInt)(data, 4);
+        this.id = id;
+        const [valuesOff, ckLength] = (0, CompressionUtil_1.readVarInt)(data, ckOff);
+        const ckData = data.slice(valuesOff, valuesOff + ckLength);
         this.clientPackets.holdPackets(Packets_1.Packet.deserializeAll(ckData, true));
+        const skData = data.slice(valuesOff + ckLength, data.length);
         this.serverPackets.holdPackets(Packets_1.Packet.deserializeAll(skData, true));
         this.batcher.registerSendPackets(this.clientPackets, this);
-        Object.keys(this.preListen).forEach(function (tag) { return _this.preListen[tag].forEach(function (listener) {
-            var key = _this.serverPackets.getKey(tag);
+        Object.keys(this.preListen).forEach(tag => this.preListen[tag].forEach(listener => {
             // print the error to console without halting execution
-            if (key == null)
-                return console.error(new Error("The server does not send the packet with tag \"".concat(tag, "\"!")));
-            _this.listen(tag, listener);
-        }); });
+            if (!this.serverPackets.hasTag(tag))
+                return console.error(new Error(`The server does not send the packet with tag "${tag}"!`));
+            this.listen(tag, listener);
+        }));
         this.preListen = null; // clear
         this.pastKeys = true;
-        this.readyListeners.forEach(function (l) { return l(); });
+        this.readyListeners.forEach(l => l());
         this.readyListeners = null; // clear
-        this.socket.removeEventListener('message', this.keyHandler);
-        this.socket.addEventListener('message', function (event) { return _this.messageHandler(event); }); // lambda to persist 'this'
-        this.keyHandler = null;
-    };
-    SonicWSCore.prototype.invalidPacket = function (listened) {
+        this.socket.removeEventListener('message', this.serverKeyHandler);
+        this.socket.addEventListener('message', this.messageHandler);
+    }
+    invalidPacket(listened) {
         console.log(listened);
         throw new Error("An error occured with data from the server!! This is probably my fault.. make an issue at https://github.com/cutelittlelily/sonic-ws");
-    };
-    SonicWSCore.prototype.listenPacket = function (data, code) {
-        (0, PacketUtils_1.listenPacket)(data, this.listeners.event[code], this.invalidPacket);
-    };
-    SonicWSCore.prototype.messageHandler = function (event) {
-        return __awaiter(this, void 0, void 0, function () {
-            var data, key, value, packet, batchData;
-            var _this = this;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.bufferHandler(event)];
-                    case 1:
-                        data = _a.sent();
-                        this.listeners.message.forEach(function (listener) { return listener(data); });
-                        if (data.length < 1)
-                            return [2 /*return*/];
-                        key = data[0];
-                        value = data.slice(1);
-                        if (key == null)
-                            return [2 /*return*/];
-                        packet = this.serverPackets.getPacket(this.serverPackets.getTag(key));
-                        if (packet.dataBatching == 0) {
-                            this.listenPacket(packet.listen(value, null), key);
-                            return [2 /*return*/];
-                        }
-                        batchData = BatchHelper_1.BatchHelper.unravelBatch(packet, value, null);
-                        if (typeof batchData == 'string')
-                            return [2 /*return*/, this.invalidPacket(batchData)];
-                        batchData.forEach(function (data) { return _this.listenPacket(data, key); });
-                        return [2 /*return*/];
-                }
-            });
-        });
-    };
-    SonicWSCore.prototype.listen = function (key, listener) {
-        var skey = this.serverPackets.getKey(key);
-        if (!skey) {
+    }
+    listenPacket(data, code) {
+        const listeners = this.listeners.event[code];
+        if (!listeners)
+            return console.warn("Warn: No listener for packet " + this.serverPackets.getTag(code));
+        (0, PacketUtils_1.listenPacket)(data, listeners, this.invalidPacket);
+    }
+    async messageHandler(event) {
+        const data = await this.bufferHandler(event);
+        this.listeners.message.forEach(listener => listener(data));
+        if (data.length < 1)
+            return;
+        const key = data[0];
+        const value = data.slice(1);
+        const packet = this.serverPackets.getPacket(this.serverPackets.getTag(key));
+        if (packet.dataBatching == 0) {
+            this.listenPacket(packet.listen(value, null), key);
+            return;
+        }
+        const batchData = BatchHelper_1.BatchHelper.unravelBatch(packet, value, null);
+        if (typeof batchData == 'string')
+            return this.invalidPacket(batchData);
+        batchData.forEach(data => this.listenPacket(data, key));
+    }
+    listen(key, listener) {
+        const skey = this.serverPackets.getKey(key);
+        if (skey == null) {
             console.log("Key is not available on server: " + key);
             return;
         }
         if (!this.listeners.event[skey])
             this.listeners.event[skey] = [];
         this.listeners.event[skey].push(listener);
-    };
+    }
     /**
      * Listens for all messages rawly
      * @param listener Callback for when data is received
      */
-    SonicWSCore.prototype.raw_onmessage = function (listener) {
+    raw_onmessage(listener) {
         this.listeners.message.push(listener);
-    };
-    /**
-     * Sends raw data
-     */
-    SonicWSCore.prototype.raw_send = function (data) {
-        this.socket.send(data);
-    };
+    }
     /**
      * Sends a packet to the server
      * @param tag The tag of the packet
      * @param values The values to send
      */
-    SonicWSCore.prototype.send = function (tag) {
-        var values = [];
-        for (var _i = 1; _i < arguments.length; _i++) {
-            values[_i - 1] = arguments[_i];
-        }
-        var _a = (0, PacketUtils_1.processPacket)(this.clientPackets, tag, values), code = _a[0], data = _a[1], packet = _a[2];
+    send(tag, ...values) {
+        const [code, data, packet] = (0, PacketUtils_1.processPacket)(this.clientPackets, tag, values);
         if (packet.dataBatching == 0)
             this.raw_send((0, BufferUtil_1.toPacketBuffer)(code, data));
         else
-            this.batcher.batchPacket(packet, code, data);
-    };
+            this.batcher.batchPacket(code, data);
+    }
     /**
      * Listens for when the client connects
      * @param listener Callback on connection
      */
-    SonicWSCore.prototype.on_ready = function (listener) {
+    on_ready(listener) {
         if (this.pastKeys)
             listener();
         else
             this.readyListeners.push(listener);
-    };
+    }
     /**
      * Listens for when the client closes
      * @param listener Callback on close with close event
      */
-    SonicWSCore.prototype.on_close = function (listener) {
+    on_close(listener) {
         this.listeners.close.push(listener);
-    };
+    }
     /**
      * Listens to a packet from the server
      * @param tag The tag to listen for
      * @param listener The callback with the values
      */
-    SonicWSCore.prototype.on = function (tag, listener) {
+    on(tag, listener) {
         if (this.socket.readyState !== WebSocket.OPEN) {
             if (!this.preListen[tag])
                 this.preListen[tag] = [];
@@ -224,27 +178,36 @@ var SonicWSCore = /** @class */ (function () {
             return;
         }
         this.listen(tag, listener);
-    };
-    /**
-     * 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)
-     */
-    SonicWSCore.prototype.setTimeout = function (call, time) {
-        var timeout = setTimeout(call, time);
-        this.timers.push(timeout);
+    }
+    /* JSDocs in Connection.ts class */
+    raw_send(data) {
+        this.socket.send(data);
+    }
+    setTimeout(call, time) {
+        const timeout = setTimeout(() => {
+            call();
+            this.clearTimeout(timeout);
+        }, time);
+        this.setTimer(timeout);
         return timeout;
-    };
-    /**
-     * Sets an interval that will automatically end when the socket closes
-     * @param call The function to call
-     * @param time The time between calls (ms)
-     */
-    SonicWSCore.prototype.setInterval = function (call, time) {
-        var interval = setInterval(call, time);
-        this.timers.push(interval);
+    }
+    setInterval(call, time) {
+        const interval = setInterval(call, time);
+        this.setTimer(interval);
         return interval;
-    };
-    return SonicWSCore;
-}());
+    }
+    setTimer(id) {
+        this._timers[id] = id;
+    }
+    clearTimeout(id) {
+        clearTimeout(id);
+        delete this._timers[id];
+    }
+    clearInterval(id) {
+        this.clearTimeout(id);
+    }
+    close(code, reason) {
+        this.socket.close(code, reason);
+    }
+}
 exports.SonicWSCore = SonicWSCore;

package/dist/ws/client/node/ClientNode.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.
@@ -14,40 +14,23 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        if (typeof b !== "function" && b !== null)
-            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SonicWS = void 0;
-var ws_1 = __importDefault(require("ws"));
-var ClientCore_1 = require("../core/ClientCore");
+const ws_1 = __importDefault(require("ws"));
+const ClientCore_1 = require("../core/ClientCore");
 /** Class to connect to a SonicWS server */
-var SonicWS = /** @class */ (function (_super) {
-    __extends(SonicWS, _super);
+class SonicWS extends ClientCore_1.SonicWSCore {
     /**
      * Creates a connection to the url
      * @param url The url to connect to
      * @param options The websocket options
      */
-    function SonicWS(url, options) {
-        var ws = new ws_1.default.WebSocket(url, options);
-        return _super.call(this, ws, function (val) { return Promise.resolve(new Uint8Array(val.data)); }) || this;
+    constructor(url, options) {
+        const ws = new ws_1.default.WebSocket(url, options);
+        super(ws, (val) => Promise.resolve(new Uint8Array(val.data)));
     }
-    return SonicWS;
-}(ClientCore_1.SonicWSCore));
+}
 exports.SonicWS = SonicWS;

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

@@ -1,9 +1,13 @@
-import { EnumValue } from "../util/enums/EnumType";
+import { EnumPackage } from "../util/enums/EnumType";
 import { Packet } from "./Packets";
 import { PacketType } from "./PacketType";
-export declare const PacketValidityProcessors: Record<PacketType, (data: Uint8Array, dataCap: number, dataMin: number, packet: Packet, index: number) => boolean>;
-export declare const PacketReceiveProcessors: Record<PacketType, (data: Uint8Array, cap: number, packet: Packet, index: number) => Uint8Array | string | number | number[] | string[] | EnumValue[]>;
-export declare const PacketSendProcessors: Record<PacketType, (...data: any) => number[]>;
-export declare function createObjSendProcessor(types: PacketType[], packetDelimitSize: number): (data: any[]) => number[];
-export declare function createObjReceiveProcessor(types: PacketType[], packetDelimitSize: number): (data: Uint8Array, dataCaps: number[], packet: Packet) => any;
-export declare function createObjValidator(types: PacketType[], packetDelimitSize: number): (data: Uint8Array, dataCaps: number[], dataMins: number[], packet: Packet) => boolean;
+export type PacketTypeValidator = (data: Uint8Array, index: number) => false | any;
+export type PacketReceiveProcessor = (data: Uint8Array, validationResult: any, index: number) => any;
+export type PacketSendProcessor = (...data: any) => number[];
+export declare function createValidator(type: PacketType, dataCap: number, dataMin: number, packet: Packet): PacketTypeValidator;
+export declare function createReceiveProcessor(type: PacketType, enumData: EnumPackage[], cap: number): PacketReceiveProcessor;
+/** Creates a function that processes a packet type */
+export declare function createSendProcessor(type: PacketType): PacketSendProcessor;
+export declare function createObjSendProcessor(packet: Packet): PacketSendProcessor;
+export declare function createObjReceiveProcessor(packet: Packet): PacketReceiveProcessor;
+export declare function createObjValidator(packet: Packet): PacketTypeValidator;