vantiv.io 1.0.0

package/src/utils/ConvertSvgToPng.js

@@ -0,0 +1,51 @@
+const sharp = require('sharp');
+const fs = require('fs').promises;
+
+async function convertAvatarToPNG(encodedSVG, outputPath = 'avatar.png', options = {}) {
+    try {
+        const {
+            density = 1800,
+            quality = 100,
+            compressionLevel = 0
+        } = options;
+
+        function decodeAvatarSVG(encodedSVG) {
+            return encodedSVG
+                .replace(/\\u003C/g, '<')
+                .replace(/\\u003E/g, '>')
+                .replace(/\\u0026/g, '&')
+                .replace(/\\u0027/g, "'")
+                .replace(/\\u0022/g, '"');
+        }
+
+        const decodedSVG = decodeAvatarSVG(encodedSVG);
+
+        const pngBuffer = await sharp(Buffer.from(decodedSVG), {
+            density: density
+        })
+        .png({
+            quality: quality,
+            compressionLevel: compressionLevel,
+            adaptiveFiltering: false,
+            force: true
+        })
+        .toBuffer();
+
+        await fs.writeFile(outputPath, pngBuffer);
+
+        const metadata = await sharp(pngBuffer).metadata();
+        console.log(`✅ Lossless PNG: ${metadata.width}x${metadata.height}px @ ${density}DPI`);
+
+        return {
+            success: true,
+            width: metadata.width,
+            height: metadata.height,
+            size: pngBuffer.length / 1024 / 1024
+        };
+
+    } catch (error) {
+        throw error;
+    }
+}
+
+module.exports = convertAvatarToPNG;

package/src/utils/ModelPool.js

@@ -0,0 +1,160 @@
+class ModelPool {
+    constructor() {
+        this._pools = new Map();
+        this._parsers = new Map();
+        this._stats = {
+            created: 0,
+            reused: 0,
+            peakSize: 0,
+            batchReleased: 0
+        };
+    }
+
+    registerModel(type, parser) {
+        if (typeof parser !== 'function') {
+            throw new Error(`Parser for type '${type}' must be a function`);
+        }
+        this._parsers.set(type, parser);
+        if (!this._pools.has(type)) {
+            this._pools.set(type, []);
+        }
+    }
+
+    get(type, ...args) {
+        if (!this._parsers.has(type)) {
+            throw new Error(`Model type '${type}' not registered. Call registerModel() first.`);
+        }
+
+        const pool = this._getPool(type);
+        const parser = this._parsers.get(type);
+        
+        let model;
+        if (pool.length > 0) {
+            model = pool.pop();
+            this._stats.reused++;
+            Object.assign(model, parser(...args));
+        } else {
+            model = parser(...args);
+            this._stats.created++;
+        }
+
+        return model;
+    }
+
+    release(type, model) {
+        if (!model) return;
+
+        const pool = this._getPool(type);
+        pool.push(model);
+        this._stats.peakSize = Math.max(this._stats.peakSize, pool.length);
+    }
+
+    releaseBatch(type, models) {
+        if (!models || !Array.isArray(models) || models.length === 0) return;
+
+        const pool = this._getPool(type);
+        const validModels = models.filter(model => model != null);
+        
+        if (validModels.length > 0) {
+            pool.push(...validModels);
+            this._stats.batchReleased += validModels.length;
+            this._stats.peakSize = Math.max(this._stats.peakSize, pool.length);
+        }
+    }
+
+    releaseMultiple(modelMap) {
+        if (!modelMap || typeof modelMap !== 'object') return;
+
+        let totalReleased = 0;
+        
+        for (const [type, models] of Object.entries(modelMap)) {
+            if (Array.isArray(models)) {
+                const pool = this._getPool(type);
+                const validModels = models.filter(model => model != null);
+                
+                if (validModels.length > 0) {
+                    pool.push(...validModels);
+                    totalReleased += validModels.length;
+                    this._stats.peakSize = Math.max(this._stats.peakSize, pool.length);
+                }
+            }
+        }
+        
+        this._stats.batchReleased += totalReleased;
+    }
+
+    getBatch(type, count, ...args) {
+        if (count <= 0) return [];
+        
+        const models = new Array(count);
+        for (let i = 0; i < count; i++) {
+            models[i] = this.get(type, ...args);
+        }
+        return models;
+    }
+
+    hasType(type) {
+        return this._parsers.has(type);
+    }
+
+    getRegisteredTypes() {
+        return Array.from(this._parsers.keys());
+    }
+
+    getStats() {
+        const poolSizes = {};
+        for (const [type, pool] of this._pools) {
+            poolSizes[type] = pool.length;
+        }
+
+        return {
+            ...this._stats,
+            poolSizes,
+            registeredTypes: this.getRegisteredTypes(),
+            totalOperations: this._stats.created + this._stats.reused + this._stats.batchReleased
+        };
+    }
+
+    clear(type = null) {
+        if (type) {
+            this._pools.get(type)?.splice(0);
+        } else {
+            for (const pool of this._pools.values()) {
+                pool.splice(0);
+            }
+
+            this._stats.created = 0;
+            this._stats.reused = 0;
+            this._stats.peakSize = 0;
+            this._stats.batchReleased = 0;
+        }
+    }
+
+    getPoolSize(type) {
+        return this._pools.get(type)?.length || 0;
+    }
+
+    preWarm(type, count) {
+        if (count <= 0) return;
+        
+        const pool = this._getPool(type);
+        const parser = this._parsers.get(type);
+        
+        for (let i = 0; i < count; i++) {
+            const model = parser();
+            pool.push(model);
+            this._stats.created++;
+        }
+        
+        this._stats.peakSize = Math.max(this._stats.peakSize, pool.length);
+    }
+
+    _getPool(type) {
+        if (!this._pools.has(type)) {
+            this._pools.set(type, []);
+        }
+        return this._pools.get(type);
+    }
+}
+
+module.exports = ModelPool;

package/src/utils/Models.js

@@ -0,0 +1,128 @@
+class User {
+    constructor(data = {}) {
+        this.username = data.user.username || ''
+        this.id = data.user.id || ''
+    }
+}
+
+class Position {
+    constructor(data = {}) {
+        this.x = data.position.x || 0
+        this.y = data.position.y || 0
+        this.z = data.position.z || 0
+        this.facing = data.position.facing || ''
+    }
+}
+
+class Tip {
+    constructor(data = {}) {
+        this.sender = {
+            id: data.sender.id,
+            username: data.sender.username
+        }
+
+        this.receiver = {
+            id: data.receiver.id,
+            username: data.receiver.username
+        }
+
+        this.item = {
+            type: data.item.type || '',
+            amount: data.item.amount || 0
+        }
+    }
+}
+
+class AnchorPosition {
+    constructor(data = {}) {
+        this.entity_id = data.position.entity_id || ''
+        this.anchor_ix = data.position.anchor_ix || 0
+    }
+}
+
+class Message {
+    constructor(data = {}) {
+        this.user = {
+            id: data.user?.id || '',
+            username: data.user?.username || ''
+        };
+        this.message = data.message || ''
+    }
+}
+
+class Direct {
+    constructor(data = {}) {
+        this.user = {
+            id: data.user_id || '',
+            username: null
+        },
+
+        this.message = data.message
+        this.conversation = {
+            id: data.conversation_id || "",
+            is_new_conversation: data.is_new_conversation
+        }
+    }
+}
+
+class SessionMetadata {
+    constructor(data = {}) {
+        this.bot_id = data.user_id || ''
+        this.room = {
+            owner_id: data.room_info.owner_id || '',
+            room_name: data.room_info.room_name || ''
+        };
+        this.metadata = {
+            connection_id: data.connection_id || '',
+            rate_limits: data.rate_limits || {}
+        };
+    }
+}
+
+class RoomModerate {
+    constructor(data = {}) {
+        this.moderator = {
+            id: data.moderatorId || '',
+            username: data.moderator_username || null
+        }
+
+        this.target = {
+            id: data.targetUserId || '',
+            username: data.target_username || null
+        }
+
+        this.action = {
+            type: data.moderationType || '',
+            duration: data.duration  || null
+        }
+    }
+}
+
+class HiddenChannel {
+    constructor(data = {}) {
+        this.sender_id = data.sender_id
+        this.message = data.msg
+        this.tags = data.tags
+    }
+}
+
+class Voice {
+    constructor(data = {}) {
+        this.users = data.users.map(([user, status]) => ({ user, status }));
+        this.seconds_left = data.seconds_left
+        this.ended = false
+    }
+}
+
+module.exports = {
+    Tip,
+    User,
+    Voice,
+    Direct,
+    Message,
+    Position,
+    RoomModerate,
+    HiddenChannel,
+    AnchorPosition,
+    SessionMetadata,
+}

package/src/utils/versionCheck.js

@@ -0,0 +1,27 @@
+const colors = require('colors');
+
+async function checkVersion(logger) {
+    try {
+        const packageJson = require('../../package.json');
+        const currentVersion = packageJson.version;
+        const packageName = packageJson.name;
+
+        const response = await fetch(`https://registry.npmjs.org/${packageName}/latest`);
+        const data = await response.json();
+        const latestVersion = data.version;
+
+        if (latestVersion === currentVersion) {
+            logger.success('versionCheck', `Using latest version: ${colors.green(`v${currentVersion}`)}`);
+            return;
+        }
+
+        logger.warn('versionCheck', 
+            `${colors.yellow('Update available:')} ${colors.red(`v${currentVersion}`)} → ${colors.green(`v${latestVersion}`)} | ${colors.cyan(`npm install ${packageName}@latest`)}`
+        );
+
+    } catch (error) {
+        logger.debug('versionCheck', 'Version check failed', { error: error.message });
+    }
+}
+
+module.exports = { checkVersion };

package/src/validators/ConfigValidator.js

@@ -0,0 +1,205 @@
+class ConfigValidator {
+    static validateHighriseOptions(options = {}) {
+        const errors = [];
+        const warnings = [];
+        const validated = { ...options };
+        
+        if (validated.Events !== undefined) {
+            if (!Array.isArray(validated.Events)) {
+                errors.push('Events must be an array');
+            } else if (validated.Events.length === 0) {
+                errors.push('At least one event type must be specified');
+            }
+        }
+        
+        if (validated.LoggerOptions !== undefined) {
+            if (typeof validated.LoggerOptions !== 'object' || validated.LoggerOptions === null) {
+                errors.push('LoggerOptions must be an object');
+            } else {
+                const loggerResult = this.validateLoggerOptions(validated.LoggerOptions);
+                if (!loggerResult.success) {
+                    errors.push(...loggerResult.errors);
+                } else {
+                    validated.LoggerOptions = loggerResult.validatedConfig;
+                }
+            }
+        }
+        
+        if (validated.autoReconnect !== undefined) {
+            if (typeof validated.autoReconnect !== 'boolean') {
+                errors.push('autoReconnect must be a boolean');
+            }
+        }
+        
+        if (validated.reconnectDelay !== undefined) {
+            if (typeof validated.reconnectDelay !== 'number') {
+                errors.push('reconnectDelay must be a number');
+            } else if (validated.reconnectDelay < 1000) {
+                warnings.push('reconnectDelay below 1000ms may cause rate limiting');
+                validated.reconnectDelay = Math.max(500, validated.reconnectDelay);
+            } else if (validated.reconnectDelay > 300000) {
+                warnings.push('reconnectDelay above 300000ms (5 minutes) may impact user experience');
+                validated.reconnectDelay = Math.min(validated.reconnectDelay, 600000);
+            }
+            
+            validated.reconnectDelay = Math.round(validated.reconnectDelay);
+        }
+        
+        return {
+            success: errors.length === 0,
+            errors,
+            warnings,
+            validatedConfig: validated
+        };
+    }
+    
+    static validateLoggerOptions(loggerOptions = {}) {
+        const errors = [];
+        const warnings = [];
+        const validated = { ...loggerOptions };
+        
+        const booleanFields = ['showTimestamp', 'showMethodName', 'colors'];
+        booleanFields.forEach(field => {
+            if (validated[field] !== undefined) {
+                if (typeof validated[field] !== 'boolean') {
+                    // Try to convert string booleans
+                    if (typeof validated[field] === 'string') {
+                        if (validated[field].toLowerCase() === 'true') {
+                            validated[field] = true;
+                            warnings.push(`LoggerOptions.${field} was converted from string to boolean`);
+                        } else if (validated[field].toLowerCase() === 'false') {
+                            validated[field] = false;
+                            warnings.push(`LoggerOptions.${field} was converted from string to boolean`);
+                        } else {
+                            errors.push(`LoggerOptions.${field} must be a boolean`);
+                        }
+                    } else {
+                        errors.push(`LoggerOptions.${field} must be a boolean`);
+                    }
+                }
+            }
+        });
+        
+        return {
+            success: errors.length === 0,
+            errors,
+            warnings,
+            validatedConfig: validated
+        };
+    }
+    
+    static validateSenderConfig(config = {}) {
+        const errors = [];
+        const warnings = [];
+        const validated = { ...config };
+        
+        if (validated.defaultTimeout !== undefined) {
+            const timeout = parseInt(validated.defaultTimeout);
+            if (isNaN(timeout)) {
+                errors.push('defaultTimeout must be a number');
+            } else if (timeout < 100) {
+                errors.push('defaultTimeout must be at least 100ms');
+            } else if (timeout > 60000) {
+                warnings.push('defaultTimeout above 60000ms may cause slow response detection');
+                validated.defaultTimeout = Math.min(timeout, 120000);
+            } else {
+                validated.defaultTimeout = timeout;
+            }
+        }
+        
+        if (validated.maxRetries !== undefined) {
+            const retries = parseInt(validated.maxRetries);
+            if (isNaN(retries)) {
+                errors.push('maxRetries must be a number');
+            } else if (retries < 0) {
+                errors.push('maxRetries cannot be negative');
+            } else if (retries > 10) {
+                warnings.push('maxRetries above 10 may cause excessive network traffic');
+                validated.maxRetries = Math.min(retries, 15);
+            } else {
+                validated.maxRetries = retries;
+            }
+        }
+        
+        if (validated.retryDelay !== undefined) {
+            const delay = parseInt(validated.retryDelay);
+            if (isNaN(delay)) {
+                errors.push('retryDelay must be a number');
+            } else if (delay < 10) {
+                warnings.push('retryDelay below 10ms may not allow proper error recovery');
+                validated.retryDelay = Math.max(delay, 5);
+            } else if (delay > 30000) {
+                warnings.push('retryDelay above 30000ms may impact user experience');
+                validated.retryDelay = Math.min(delay, 60000);
+            } else {
+                validated.retryDelay = delay;
+            }
+        }
+        
+        return {
+            success: errors.length === 0,
+            errors,
+            warnings,
+            validatedConfig: validated
+        };
+    }
+    
+    static validateEvents(events) {
+        const errors = [];
+        const validEvents = [
+            'SessionMetadata', 'ChatEvent', 'WhisperEvent', 'UserMovedEvent',
+            'UserJoinedEvent', 'UserLeftEvent', 'MessageEvent', 'TipReactionEvent', 
+            'RoomModeratedEvent', 'ChannelEvent'
+        ];
+        
+        if (!Array.isArray(events)) {
+            errors.push('Events must be an array');
+            return { success: false, errors, validEvents };
+        }
+        
+        if (events.length === 0) {
+            errors.push('At least one event type must be specified');
+        }
+        
+        const invalidEvents = events.filter(event => !validEvents.includes(event));
+        if (invalidEvents.length > 0) {
+            errors.push(`Invalid event types: ${invalidEvents.join(', ')}`);
+        }
+        
+        const duplicateEvents = events.filter((event, index) => events.indexOf(event) !== index);
+        if (duplicateEvents.length > 0) {
+            warnings.push(`Duplicate event types: ${duplicateEvents.join(', ')}`);
+        }
+        
+        return {
+            success: errors.length === 0,
+            errors,
+            warnings: duplicateEvents.length > 0 ? [`Duplicate event types: ${duplicateEvents.join(', ')}`] : [],
+            validEvents,
+            validatedEvents: [...new Set(events)]
+        };
+    }
+    
+    static validateCredentials(token, roomId) {
+        const errors = [];
+        
+        if (!token || typeof token !== 'string') {
+            errors.push('Token must be a non-empty string');
+        } else if (token.length !== 64) {
+            errors.push('Token must be exactly 64 characters long');
+        }
+        
+        if (!roomId || typeof roomId !== 'string') {
+            errors.push('Room ID must be a non-empty string');
+        } else if (roomId.length !== 24) {
+            errors.push('Room ID must be exactly 24 characters long');
+        }
+        
+        return {
+            success: errors.length === 0,
+            errors
+        };
+    }
+}
+
+module.exports = { ConfigValidator };

package/src/validators/ConnectionValidator.js

@@ -0,0 +1,65 @@
+class ConnectionValidator {
+    static validateCredentials(token, roomId) {
+        const errors = [];
+        
+        if (!token || typeof token !== 'string') {
+            errors.push('Token must be a non-empty string');
+        } else if (token.length !== 64) {
+            errors.push(`Token must be exactly 64 characters (got ${token.length})`);
+        }
+        
+        if (!roomId || typeof roomId !== 'string') {
+            errors.push('Room ID must be a non-empty string');
+        } else if (roomId.length !== 24) {
+            errors.push(`Room ID must be exactly 24 characters (got ${roomId.length})`);
+        }
+        
+        if (errors.length > 0) {
+            throw new Error(`Connection validation failed: ${errors.join('; ')}`);
+        }
+    }
+    
+    static validateEvents(events) {
+        if (!Array.isArray(events)) {
+            throw new Error('Events must be an array');
+        }
+        
+        if (events.length === 0) {
+            throw new Error('At least one event type must be specified');
+        }
+        
+        const validEvents = [
+            'SessionMetadata', 'ChatEvent', 'WhisperEvent', 
+            'UserMovedEvent', 'UserJoinedEvent', 'UserLeftEvent',
+            'MessageEvent', 'TipReactionEvent', 'RoomModeratedEvent',
+            'ChannelEvent'
+        ];
+        
+        const invalidEvents = events.filter(event => !validEvents.includes(event));
+        if (invalidEvents.length > 0) {
+            throw new Error(`Invalid event types: ${invalidEvents.join(', ')}`);
+        }
+        
+        return [...new Set(events)];
+    }
+    
+    static validateOptions(options) {
+        const validated = { ...options };
+        
+        if (validated.autoReconnect !== undefined && typeof validated.autoReconnect !== 'boolean') {
+            throw new TypeError('autoReconnect must be a boolean');
+        }
+        
+        if (validated.reconnectDelay !== undefined) {
+            const delay = parseInt(validated.reconnectDelay);
+            if (isNaN(delay) || delay < 1000) {
+                throw new TypeError('reconnectDelay must be a number >= 1000');
+            }
+            validated.reconnectDelay = Math.min(delay, 300000);
+        }
+        
+        return validated;
+    }
+}
+
+module.exports = ConnectionValidator;