highrise.bot 1.1.0 → 1.1.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "highrise.bot",
-  "version": "1.1.0",
+  "version": "1.1.1",
   "description": "Unofficial JavaScript SDK for the Highrise platform. Feature-complete WebSocket client with TypeScript support, built for production environments.",
   "keywords": [
     "highrise.bot",

package/src/classes/Actions/Awaiter.js

@@ -1,200 +1,88 @@
 class AwaitClass {
     constructor(ws) {
-        if (!ws) {
-            throw new Error('ws instance is required');
-        }
+        if (!ws) throw new Error('ws instance is required');
         this.ws = ws;
-        this._pendingAwaiters = new Map();
+        this._pendingAwaiters = {
+            chat: new Map(),
+            whisper: new Map(),
+            direct: new Map(),
+            tip: new Map(),
+            movement: new Map()
+        };
     }
 
     chat(filter = () => true, timeout = 30000, maxToCollect = 1, uniqueUsers = false) {
-        if (!this._validateParameters('chat', filter, timeout, maxToCollect)) {
-            return Promise.resolve([]);
-        }
-
         return this._createAwaiter('chat', filter, timeout, maxToCollect, uniqueUsers);
     }
 
     whisper(filter = () => true, timeout = 30000, maxToCollect = 1, uniqueUsers = false) {
-        if (!this._validateParameters('whisper', filter, timeout, maxToCollect)) {
-            return Promise.resolve([]);
-        }
-        
         return this._createAwaiter('whisper', filter, timeout, maxToCollect, uniqueUsers);
     }
 
     direct(filter = () => true, timeout = 30000, maxToCollect = 1, uniqueUsers = false) {
-        if (!this._validateParameters('direct', filter, timeout, maxToCollect)) {
-            return Promise.resolve([]);
-        }
         return this._createAwaiter('direct', filter, timeout, maxToCollect, uniqueUsers);
     }
 
     tip(filter = () => true, timeout = 30000, maxToCollect = 1, uniqueUsers = false) {
-        if (!this._validateParameters('tip', filter, timeout, maxToCollect)) {
-            return Promise.resolve([]);
-        }
         return this._createAwaiter('tip', filter, timeout, maxToCollect, uniqueUsers);
     }
 
     movement(filter = () => true, timeout = 30000, maxToCollect = 1, uniqueUsers = false) {
-        if (!this._validateParameters('movement', filter, timeout, maxToCollect)) {
-            return Promise.resolve([]);
-        }
         return this._createAwaiter('movement', filter, timeout, maxToCollect, uniqueUsers);
     }
 
-    _validateParameters(method, filter, timeout, maxToCollect) {
-        try {
-            if (typeof filter !== 'function') {
-                throw new TypeError(`Filter must be a function`);
-            }
-
-            if (typeof timeout !== 'number') {
-                throw new TypeError(`Timeout must be a number`);
-            }
-
-            if (timeout < 0) {
-                throw new RangeError(`Timeout cannot be negative`);
-            }
-
-            if (typeof maxToCollect !== 'number') {
-                throw new TypeError(`maxToCollect must be a number`);
-            }
-
-            if (!Number.isInteger(maxToCollect)) {
-                throw new TypeError(`maxToCollect must be an integer`);
-            }
-
-            if (maxToCollect < 1) {
-                throw new RangeError(`maxToCollect must be at least 1`);
-            }
-            
-            if (maxToCollect > 1000) {
-                throw new RangeError(`maxToCollect cannot exceed 1000`);
-            }
-
-            if (!this.ws.isConnected || !this.ws.isConnected()) {
-                throw new Error(`WebSocket is not connected to Highrise`);
-            }
-
-            return true;
-
-        } catch (error) {
-            if (error instanceof TypeError) {
-                this.ws._logger.error(`await.${method}`, `TypeError: ${error.message}`, { timeout, maxToCollect }, error);
-            } else if (error instanceof RangeError) {
-                this.ws._logger.error(`await.${method}`, `RangeError: ${error.message}`, { timeout, maxToCollect }, error);
-            } else {
-                this.ws._logger.error(`await.${method}`, error.message, { timeout, maxToCollect }, error);
-            }
-            return false;
+    _createAwaiter(eventType, filter, timeout, maxToCollect, uniqueUsers) {
+        if (typeof filter !== 'function' || typeof timeout !== 'number' || timeout < 0 || 
+            !Number.isInteger(maxToCollect) || maxToCollect < 1 || maxToCollect > 1000) {
+            return Promise.resolve([]);
         }
-    }
 
-    _createAwaiter(eventType, filter, timeout, maxToCollect, uniqueUsers = false) {
-        return new Promise((resolve, reject) => {
+        return new Promise((resolve) => {
             const awaiterId = Symbol('awaiter');
             const collected = [];
-            const seenUsers = new Set();
-            let timeoutId;
+            const seenUsers = uniqueUsers ? new Set() : null;
 
             const cleanup = () => {
                 clearTimeout(timeoutId);
-                this._pendingAwaiters.delete(awaiterId);
+                this._pendingAwaiters[eventType].delete(awaiterId);
             };
 
             const awaiter = {
-                eventType,
                 filter,
                 maxToCollect,
                 collected,
-                uniqueUsers,
                 seenUsers,
                 resolve: (results) => {
                     cleanup();
                     resolve(results);
-                },
-                reject: (error) => {
-                    cleanup();
-                    reject(error);
                 }
             };
 
-            this._pendingAwaiters.set(awaiterId, awaiter);
+            this._pendingAwaiters[eventType].set(awaiterId, awaiter);
 
-            if (timeout > 0) {
-                timeoutId = setTimeout(() => {
-                    awaiter.resolve(collected);
-                }, timeout);
-            }
+            const timeoutId = timeout > 0 ? setTimeout(() => awaiter.resolve(collected), timeout) : null;
         });
     }
 
     _processEvent(eventType, ...eventArgs) {
-        for (const [awaiterId, awaiter] of this._pendingAwaiters) {
-            if (awaiter.eventType === eventType) {
-                try {
-                    this._validateEventArguments(eventType, eventArgs);
+        const awaiters = this._pendingAwaiters[eventType];
+        if (!awaiters) return;
 
-                    if (awaiter.uniqueUsers && eventArgs[0]?.id) {
-                        if (awaiter.seenUsers.has(eventArgs[0].id)) {
-                            continue;
-                        }
-                        awaiter.seenUsers.add(eventArgs[0].id);
-                    }
-
-                    if (awaiter.filter(...eventArgs)) {
-                        awaiter.collected.push(eventArgs);
+        for (const awaiter of awaiters.values()) {
+            try {
+                if (awaiter.seenUsers && eventArgs[0]?.id) {
+                    if (awaiter.seenUsers.has(eventArgs[0].id)) continue;
+                    awaiter.seenUsers.add(eventArgs[0].id);
+                }
 
-                        if (awaiter.collected.length >= awaiter.maxToCollect) {
-                            awaiter.resolve(awaiter.collected);
-                        }
+                if (awaiter.filter(...eventArgs)) {
+                    awaiter.collected.push(eventArgs);
+                    if (awaiter.collected.length >= awaiter.maxToCollect) {
+                        awaiter.resolve(awaiter.collected);
                     }
-                } catch (error) {
-                    this.ws._logger.error(`await.${eventType}`, `Filter error: ${error.message}`)
                 }
-            }
-        }
-    }
-
-    _validateEventArguments(eventType, eventArgs) {
-        const validators = {
-            chat: (args) => {
-                if (args.length !== 2) throw new TypeError('Chat event requires 2 arguments (user, message)');
-                if (!args[0] || typeof args[0].id !== 'string') throw new TypeError('Invalid user object in chat event');
-                if (typeof args[1] !== 'string') throw new TypeError('Invalid message in chat event');
-            },
-            whisper: (args) => {
-                if (args.length !== 2) throw new TypeError('Whisper event requires 2 arguments (user, message)');
-                if (!args[0] || typeof args[0].id !== 'string') throw new TypeError('Invalid user object in whisper event');
-                if (typeof args[1] !== 'string') throw new TypeError('Invalid message in whisper event');
-            },
-            direct: (args) => {
-                if (args.length !== 3) throw new TypeError('Direct event requires 3 arguments (user, message, conversation)');
-                if (!args[0] || typeof args[0].id !== 'string') throw new TypeError('Invalid user object in direct event');
-                if (typeof args[1] !== 'string') throw new TypeError('Invalid message in direct event');
-                if (!args[2] || typeof args[2].id !== 'string') throw new TypeError('Invalid conversation object in direct event');
-            },
-            tip: (args) => {
-                if (args.length !== 3) throw new TypeError('Tip event requires 3 arguments (sender, receiver, currency)');
-                if (!args[0] || typeof args[0].id !== 'string') throw new TypeError('Invalid sender in tip event');
-                if (!args[1] || typeof args[1].id !== 'string') throw new TypeError('Invalid receiver in tip event');
-                if (!args[2] || typeof args[2].amount !== 'number') throw new TypeError('Invalid currency in tip event');
-            },
-            movement: (args) => {
-                if (args.length !== 3) throw new TypeError('Movement event requires 3 arguments (user, position, anchor)');
-                if (!args[0] || typeof args[0].id !== 'string') throw new TypeError('Invalid user object in movement event');
-                if (!args[1] || typeof args[1].x !== 'number') throw new TypeError('Invalid position in movement event');
-                if (args[2] !== null && (!args[2] || typeof args[2].entity_id !== 'string')) throw new TypeError('Invalid anchor in movement event');
-            }
-        };
-
-        if (validators[eventType]) {
-            try {
-                validators[eventType](eventArgs);
             } catch (error) {
-                this.ws._logger.error(`await.${eventType}`, error.message)
+                // Filter error - continue to next awaiter
             }
         }
     }

package/src/classes/Handlers/CommandHandler.js

@@ -288,11 +288,6 @@ class CommandHandler {
             return false
         }
 
-        if (typeof context.user.username !== 'string' || context.user.username.trim() === '') {
-            this.handlerError(`context.user.username must be a non-empty string.`)
-            return false
-        }
-
         return true
     }
 

package/src/classes/Managers/Networking/MessageHandler.js

@@ -17,6 +17,7 @@ class MessageHandler {
         setImmediate(() => {
             try {
                 const message = JSON.parse(data.toString());
+                
                 if (this.validateMessageStructure(message)) {
                     this._processMessage(message);
                 } else {

package/src/classes/Managers/RoleManager.js

@@ -37,7 +37,7 @@ class RolesManager {
             this._startWebApiSync();
             this._startAutoSave();
             this.initialized = true;
-            this.logger.success('RolesManager', '✅ Ready! Auto-syncing every 5 minutes.');
+            this.logger.success('RolesManager', 'Ready! Auto-syncing every 5 minutes.');
         } catch (error) {
             this.logger.error('RolesManager', 'Setup failed', error);
             this._createCustomRoles();

package/typings/index.d.ts

@@ -828,9 +828,11 @@ interface CooldownManagerStats {
  * Context passed to command handlers containing user and additional data
  */
 interface CommandContext {
-    user: User; // Using SDK's User type
+    user: User;
     args?: string[];
     message?: string;
+    conversation?: Conversation
+    /** Additional properties */
     [key: string]: any;
 }
 
@@ -3361,7 +3363,7 @@ declare class AwaitClass {
      * );
      * ```
      */
-    movement(filter?: MovementFilter, timeout?: number, maxToCollect?: number, uniqueUsers?: boolean): Promise<[User, Position, AnchorPosition | null][] | []>;
+    movement(filter?: MovementFilter, timeout?: number, maxToCollect?: number, uniqueUsers?: boolean): Promise<[User, Position | null, AnchorPosition | null][] | []>;
 }
 
 declare class WebApi {