packet-events-js 1.0.0

package/src/utils/Logger.js

@@ -0,0 +1,207 @@
+export const LogLevel = Object.freeze({
+    TRACE: 0,
+    DEBUG: 1,
+    INFO: 2,
+    WARN: 3,
+    ERROR: 4,
+    FATAL: 5,
+    OFF: 6
+});
+
+const Colors = {
+    reset: '\x1b[0m',
+    bright: '\x1b[1m',
+    dim: '\x1b[2m',
+    
+    black: '\x1b[30m',
+    red: '\x1b[31m',
+    green: '\x1b[32m',
+    yellow: '\x1b[33m',
+    blue: '\x1b[34m',
+    magenta: '\x1b[35m',
+    cyan: '\x1b[36m',
+    white: '\x1b[37m',
+    
+    bgBlack: '\x1b[40m',
+    bgRed: '\x1b[41m',
+    bgGreen: '\x1b[42m',
+    bgYellow: '\x1b[43m',
+    bgBlue: '\x1b[44m',
+    bgMagenta: '\x1b[45m',
+    bgCyan: '\x1b[46m',
+    bgWhite: '\x1b[47m'
+};
+
+const LevelConfig = {
+    [LogLevel.TRACE]: { name: 'TRACE', color: Colors.dim + Colors.white },
+    [LogLevel.DEBUG]: { name: 'DEBUG', color: Colors.cyan },
+    [LogLevel.INFO]: { name: 'INFO ', color: Colors.green },
+    [LogLevel.WARN]: { name: 'WARN ', color: Colors.yellow },
+    [LogLevel.ERROR]: { name: 'ERROR', color: Colors.red },
+    [LogLevel.FATAL]: { name: 'FATAL', color: Colors.bright + Colors.red }
+};
+
+export class Logger {
+    static _loggers = new Map();
+    static _globalLevel = LogLevel.INFO;
+    static _useColors = true;
+    static _showTimestamp = true;
+    static _showLoggerName = true;
+
+    constructor(name) {
+        this.name = name;
+        this.level = null; 
+    }
+
+    static getLogger(name) {
+        if (!Logger._loggers.has(name)) {
+            Logger._loggers.set(name, new Logger(name));
+        }
+        return Logger._loggers.get(name);
+    }
+
+    static setGlobalLevel(level) {
+        Logger._globalLevel = level;
+    }
+
+    static setColorsEnabled(enabled) {
+        Logger._useColors = enabled;
+    }
+
+    static setTimestampEnabled(enabled) {
+        Logger._showTimestamp = enabled;
+    }
+
+    setLevel(level) {
+        this.level = level;
+        return this;
+    }
+
+    getEffectiveLevel() {
+        return this.level !== null ? this.level : Logger._globalLevel;
+    }
+
+    isEnabled(level) {
+        return level >= this.getEffectiveLevel();
+    }
+
+    _formatTimestamp() {
+        const now = new Date();
+        const pad = (n) => n.toString().padStart(2, '0');
+        return `${pad(now.getHours())}:${pad(now.getMinutes())}:${pad(now.getSeconds())}.${now.getMilliseconds().toString().padStart(3, '0')}`;
+    }
+
+    _format(level, message, args) {
+        const config = LevelConfig[level];
+        let output = '';
+
+        if (Logger._useColors) {
+            
+            if (Logger._showTimestamp) {
+                output += `${Colors.dim}[${this._formatTimestamp()}]${Colors.reset} `;
+            }
+            
+            output += `${config.color}[${config.name}]${Colors.reset}`;
+            
+            if (Logger._showLoggerName && this.name) {
+                output += ` ${Colors.magenta}[${this.name}]${Colors.reset}`;
+            }
+            
+            output += ` ${message}`;
+        } else {
+            
+            if (Logger._showTimestamp) {
+                output += `[${this._formatTimestamp()}] `;
+            }
+            
+            output += `[${config.name}]`;
+            
+            if (Logger._showLoggerName && this.name) {
+                output += ` [${this.name}]`;
+            }
+            
+            output += ` ${message}`;
+        }
+
+        if (args.length > 0) {
+            for (const arg of args) {
+                if (arg instanceof Error) {
+                    output += '\n' + arg.stack;
+                } else if (typeof arg === 'object') {
+                    output += '\n' + JSON.stringify(arg, null, 2);
+                } else {
+                    output += ' ' + arg;
+                }
+            }
+        }
+
+        return output;
+    }
+
+    log(level, message, ...args) {
+        if (!this.isEnabled(level)) return;
+
+        const output = this._format(level, message, args);
+
+        if (level >= LogLevel.ERROR) {
+            console.error(output);
+        } else if (level >= LogLevel.WARN) {
+            console.warn(output);
+        } else {
+            console.log(output);
+        }
+    }
+
+    trace(message, ...args) {
+        this.log(LogLevel.TRACE, message, ...args);
+    }
+
+    debug(message, ...args) {
+        this.log(LogLevel.DEBUG, message, ...args);
+    }
+
+    info(message, ...args) {
+        this.log(LogLevel.INFO, message, ...args);
+    }
+
+    warn(message, ...args) {
+        this.log(LogLevel.WARN, message, ...args);
+    }
+
+    error(message, ...args) {
+        this.log(LogLevel.ERROR, message, ...args);
+    }
+
+    fatal(message, ...args) {
+        this.log(LogLevel.FATAL, message, ...args);
+    }
+
+    child(suffix) {
+        return Logger.getLogger(`${this.name}.${suffix}`);
+    }
+
+    hexdump(label, data) {
+        if (!this.isEnabled(LogLevel.DEBUG)) return;
+
+        const lines = [];
+        const bytesPerLine = 16;
+
+        for (let i = 0; i < data.length; i += bytesPerLine) {
+            const slice = data.subarray(i, Math.min(i + bytesPerLine, data.length));
+            const hex = Array.from(slice)
+                .map(b => b.toString(16).padStart(2, '0'))
+                .join(' ');
+            const ascii = Array.from(slice)
+                .map(b => (b >= 32 && b <= 126) ? String.fromCharCode(b) : '.')
+                .join('');
+            
+            lines.push(`${i.toString(16).padStart(8, '0')}  ${hex.padEnd(48, ' ')} |${ascii}|`);
+        }
+
+        this.debug(`${label}:\n${lines.join('\n')}`);
+    }
+}
+
+export const logger = Logger.getLogger('PacketEvents');
+
+export default Logger;

package/src/utils/PacketBuffer.js

@@ -0,0 +1,389 @@
+import { encodeVarInt, decodeVarInt, encodeVarLong, decodeVarLong, getVarIntSize } from '../protocol/types/VarInt.js';
+import { UUID } from '../protocol/types/UUID.js';
+import { Position } from '../protocol/types/Position.js';
+import { NBTReader, NBTWriter, NBTCompound } from '../protocol/types/NBT.js';
+
+export class PacketBuffer {
+    
+    constructor(bufferOrSize) {
+        if (Buffer.isBuffer(bufferOrSize)) {
+            this.buffer = bufferOrSize;
+        } else if (typeof bufferOrSize === 'number') {
+            this.buffer = Buffer.alloc(bufferOrSize);
+        } else {
+            this.buffer = Buffer.alloc(0);
+        }
+        
+        this.readOffset = 0;
+        this.writeOffset = 0;
+        this._writeBuffers = [];
+    }
+
+    static writer() {
+        const pb = new PacketBuffer();
+        pb._mode = 'write';
+        return pb;
+    }
+
+    static reader(buffer) {
+        const pb = new PacketBuffer(buffer);
+        pb._mode = 'read';
+        return pb;
+    }
+
+    static wrap(buffer) {
+        return new PacketBuffer(buffer);
+    }
+
+    get readableBytes() {
+        return this.buffer.length - this.readOffset;
+    }
+
+    isReadable(count = 1) {
+        return this.readableBytes >= count;
+    }
+
+    resetReader() {
+        this.readOffset = 0;
+        return this;
+    }
+
+    skip(count) {
+        this.readOffset += count;
+        return this;
+    }
+
+    readBoolean() {
+        return this.buffer.readUInt8(this.readOffset++) !== 0;
+    }
+
+    readByte() {
+        return this.buffer.readInt8(this.readOffset++);
+    }
+
+    readUByte() {
+        return this.buffer.readUInt8(this.readOffset++);
+    }
+
+    readShort() {
+        const value = this.buffer.readInt16BE(this.readOffset);
+        this.readOffset += 2;
+        return value;
+    }
+
+    readUShort() {
+        const value = this.buffer.readUInt16BE(this.readOffset);
+        this.readOffset += 2;
+        return value;
+    }
+
+    readInt() {
+        const value = this.buffer.readInt32BE(this.readOffset);
+        this.readOffset += 4;
+        return value;
+    }
+
+    readUInt() {
+        const value = this.buffer.readUInt32BE(this.readOffset);
+        this.readOffset += 4;
+        return value;
+    }
+
+    readLong() {
+        const value = this.buffer.readBigInt64BE(this.readOffset);
+        this.readOffset += 8;
+        return value;
+    }
+
+    readULong() {
+        const value = this.buffer.readBigUInt64BE(this.readOffset);
+        this.readOffset += 8;
+        return value;
+    }
+
+    readFloat() {
+        const value = this.buffer.readFloatBE(this.readOffset);
+        this.readOffset += 4;
+        return value;
+    }
+
+    readDouble() {
+        const value = this.buffer.readDoubleBE(this.readOffset);
+        this.readOffset += 8;
+        return value;
+    }
+
+    readVarInt() {
+        const { value, bytesRead } = decodeVarInt(this.buffer, this.readOffset);
+        this.readOffset += bytesRead;
+        return value;
+    }
+
+    readVarLong() {
+        const { value, bytesRead } = decodeVarLong(this.buffer, this.readOffset);
+        this.readOffset += bytesRead;
+        return value;
+    }
+
+    readString(maxLength = 32767) {
+        const length = this.readVarInt();
+        
+        if (length > maxLength * 4) {
+            throw new Error(`String too long: ${length} > ${maxLength * 4}`);
+        }
+        
+        const value = this.buffer.toString('utf8', this.readOffset, this.readOffset + length);
+        this.readOffset += length;
+        
+        if (value.length > maxLength) {
+            throw new Error(`String too long: ${value.length} > ${maxLength}`);
+        }
+        
+        return value;
+    }
+
+    readIdentifier() {
+        return this.readString(32767);
+    }
+
+    readUUID() {
+        const uuid = UUID.fromBuffer(this.buffer, this.readOffset);
+        this.readOffset += 16;
+        return uuid;
+    }
+
+    readPosition() {
+        const position = Position.fromBuffer(this.buffer, this.readOffset);
+        this.readOffset += 8;
+        return position;
+    }
+
+    readNBT(named = true) {
+        const reader = new NBTReader(this.buffer, this.readOffset);
+        const compound = reader.read(named);
+        this.readOffset = reader.offset;
+        return compound;
+    }
+
+    readByteArray() {
+        const length = this.readVarInt();
+        const value = this.buffer.subarray(this.readOffset, this.readOffset + length);
+        this.readOffset += length;
+        return Buffer.from(value);
+    }
+
+    readBytes(length) {
+        const value = this.buffer.subarray(this.readOffset, this.readOffset + length);
+        this.readOffset += length;
+        return Buffer.from(value);
+    }
+
+    readRemainingBytes() {
+        const value = this.buffer.subarray(this.readOffset);
+        this.readOffset = this.buffer.length;
+        return Buffer.from(value);
+    }
+
+    readOptional(reader) {
+        const present = this.readBoolean();
+        return present ? reader.call(this) : null;
+    }
+
+    readArray(reader) {
+        const length = this.readVarInt();
+        const array = [];
+        
+        for (let i = 0; i < length; i++) {
+            array.push(reader.call(this));
+        }
+        
+        return array;
+    }
+
+    readAngle() {
+        return (this.readUByte() / 256) * 360;
+    }
+
+    readFixedPoint(intBits, fracBits) {
+        const raw = intBits + fracBits <= 32 ? this.readInt() : Number(this.readLong());
+        return raw / (1 << fracBits);
+    }
+
+    writeBoolean(value) {
+        const buf = Buffer.alloc(1);
+        buf.writeUInt8(value ? 1 : 0);
+        this._writeBuffers.push(buf);
+        return this;
+    }
+
+    writeByte(value) {
+        const buf = Buffer.alloc(1);
+        buf.writeInt8(value);
+        this._writeBuffers.push(buf);
+        return this;
+    }
+
+    writeUByte(value) {
+        const buf = Buffer.alloc(1);
+        buf.writeUInt8(value);
+        this._writeBuffers.push(buf);
+        return this;
+    }
+
+    writeShort(value) {
+        const buf = Buffer.alloc(2);
+        buf.writeInt16BE(value);
+        this._writeBuffers.push(buf);
+        return this;
+    }
+
+    writeUShort(value) {
+        const buf = Buffer.alloc(2);
+        buf.writeUInt16BE(value);
+        this._writeBuffers.push(buf);
+        return this;
+    }
+
+    writeInt(value) {
+        const buf = Buffer.alloc(4);
+        buf.writeInt32BE(value);
+        this._writeBuffers.push(buf);
+        return this;
+    }
+
+    writeUInt(value) {
+        const buf = Buffer.alloc(4);
+        buf.writeUInt32BE(value);
+        this._writeBuffers.push(buf);
+        return this;
+    }
+
+    writeLong(value) {
+        const buf = Buffer.alloc(8);
+        buf.writeBigInt64BE(BigInt(value));
+        this._writeBuffers.push(buf);
+        return this;
+    }
+
+    writeULong(value) {
+        const buf = Buffer.alloc(8);
+        buf.writeBigUInt64BE(BigInt(value));
+        this._writeBuffers.push(buf);
+        return this;
+    }
+
+    writeFloat(value) {
+        const buf = Buffer.alloc(4);
+        buf.writeFloatBE(value);
+        this._writeBuffers.push(buf);
+        return this;
+    }
+
+    writeDouble(value) {
+        const buf = Buffer.alloc(8);
+        buf.writeDoubleBE(value);
+        this._writeBuffers.push(buf);
+        return this;
+    }
+
+    writeVarInt(value) {
+        this._writeBuffers.push(encodeVarInt(value));
+        return this;
+    }
+
+    writeVarLong(value) {
+        this._writeBuffers.push(encodeVarLong(value));
+        return this;
+    }
+
+    writeString(value) {
+        const strBuf = Buffer.from(value, 'utf8');
+        this.writeVarInt(strBuf.length);
+        this._writeBuffers.push(strBuf);
+        return this;
+    }
+
+    writeIdentifier(value) {
+        return this.writeString(value);
+    }
+
+    writeUUID(uuid) {
+        this._writeBuffers.push(uuid.toBytes());
+        return this;
+    }
+
+    writePosition(position) {
+        this._writeBuffers.push(position.toBytes());
+        return this;
+    }
+
+    writeNBT(compound, named = true) {
+        const writer = new NBTWriter();
+        const nbtBuffer = writer.write(compound, named);
+        this._writeBuffers.push(nbtBuffer);
+        return this;
+    }
+
+    writeByteArray(value) {
+        this.writeVarInt(value.length);
+        this._writeBuffers.push(value);
+        return this;
+    }
+
+    writeBytes(value) {
+        this._writeBuffers.push(Buffer.from(value));
+        return this;
+    }
+
+    writeOptional(value, writer) {
+        if (value !== null && value !== undefined) {
+            this.writeBoolean(true);
+            writer.call(this, value);
+        } else {
+            this.writeBoolean(false);
+        }
+        return this;
+    }
+
+    writeArray(array, writer) {
+        this.writeVarInt(array.length);
+        
+        for (const item of array) {
+            writer.call(this, item);
+        }
+        
+        return this;
+    }
+
+    writeAngle(degrees) {
+        return this.writeUByte(Math.floor((degrees / 360) * 256) & 0xFF);
+    }
+
+    getBuffer() {
+        if (this._writeBuffers.length > 0) {
+            return Buffer.concat(this._writeBuffers);
+        }
+        return this.buffer;
+    }
+
+    get length() {
+        if (this._writeBuffers.length > 0) {
+            return this._writeBuffers.reduce((sum, buf) => sum + buf.length, 0);
+        }
+        return this.buffer.length;
+    }
+
+    clear() {
+        this._writeBuffers = [];
+        this.readOffset = 0;
+        return this;
+    }
+
+    copy() {
+        const pb = new PacketBuffer(Buffer.from(this.getBuffer()));
+        pb.readOffset = this.readOffset;
+        return pb;
+    }
+}
+
+export default PacketBuffer;