packet-events-js 1.0.0

package/src/protocol/ProtocolVersion.js

@@ -0,0 +1,141 @@
+export class ProtocolVersion {
+    static _versions = new Map();
+    static _byProtocolId = new Map();
+
+    constructor(name, protocolId, isSnapshot = false) {
+        this.name = name;
+        this.protocolId = protocolId;
+        this.isSnapshot = isSnapshot;
+
+        ProtocolVersion._versions.set(name, this);
+        ProtocolVersion._byProtocolId.set(protocolId, this);
+    }
+
+    static getByName(name) {
+        return ProtocolVersion._versions.get(name);
+    }
+
+    static getByProtocolId(protocolId) {
+        return ProtocolVersion._byProtocolId.get(protocolId);
+    }
+
+    static getAllVersions() {
+        return Array.from(ProtocolVersion._versions.values());
+    }
+
+    static getLatest() {
+        return ProtocolVersion.V1_21_11;
+    }
+
+    isNewerThan(other) {
+        return this.protocolId > other.protocolId;
+    }
+
+    isOlderThan(other) {
+        return this.protocolId < other.protocolId;
+    }
+
+    isBetween(min, max) {
+        return this.protocolId >= min.protocolId && this.protocolId <= max.protocolId;
+    }
+
+    equals(other) {
+        if (!(other instanceof ProtocolVersion)) return false;
+        return this.protocolId === other.protocolId;
+    }
+
+    toString() {
+        return this.name;
+    }
+
+    toJSON() {
+        return {
+            name: this.name,
+            protocolId: this.protocolId,
+            isSnapshot: this.isSnapshot
+        };
+    }
+
+    static V1_21_11 = new ProtocolVersion('1.21.11', 770);
+    static V1_21_10 = new ProtocolVersion('1.21.10', 770);
+    static V1_21_9 = new ProtocolVersion('1.21.9', 770);
+    static V1_21_8 = new ProtocolVersion('1.21.8', 770);
+    static V1_21_7 = new ProtocolVersion('1.21.7', 770);
+    static V1_21_6 = new ProtocolVersion('1.21.6', 770);
+    static V1_21_5 = new ProtocolVersion('1.21.5', 770);
+    static V1_21_4 = new ProtocolVersion('1.21.4', 769);
+    static V1_21_3 = new ProtocolVersion('1.21.3', 768);
+    static V1_21_2 = new ProtocolVersion('1.21.2', 768);
+    static V1_21_1 = new ProtocolVersion('1.21.1', 767);
+    static V1_21 = new ProtocolVersion('1.21', 767);
+
+    static V1_20_6 = new ProtocolVersion('1.20.6', 766);
+    static V1_20_5 = new ProtocolVersion('1.20.5', 766);
+    static V1_20_4 = new ProtocolVersion('1.20.4', 765);
+    static V1_20_3 = new ProtocolVersion('1.20.3', 765);
+    static V1_20_2 = new ProtocolVersion('1.20.2', 764);
+    static V1_20_1 = new ProtocolVersion('1.20.1', 763);
+    static V1_20 = new ProtocolVersion('1.20', 763);
+
+    static V1_19_4 = new ProtocolVersion('1.19.4', 762);
+    static V1_19_3 = new ProtocolVersion('1.19.3', 761);
+    static V1_19_2 = new ProtocolVersion('1.19.2', 760);
+    static V1_19_1 = new ProtocolVersion('1.19.1', 760);
+    static V1_19 = new ProtocolVersion('1.19', 759);
+
+    static V1_18_2 = new ProtocolVersion('1.18.2', 758);
+    static V1_18_1 = new ProtocolVersion('1.18.1', 757);
+    static V1_18 = new ProtocolVersion('1.18', 757);
+
+    static V1_17_1 = new ProtocolVersion('1.17.1', 756);
+    static V1_17 = new ProtocolVersion('1.17', 755);
+
+    static V1_16_5 = new ProtocolVersion('1.16.5', 754);
+    static V1_16_4 = new ProtocolVersion('1.16.4', 754);
+    static V1_16_3 = new ProtocolVersion('1.16.3', 753);
+    static V1_16_2 = new ProtocolVersion('1.16.2', 751);
+    static V1_16_1 = new ProtocolVersion('1.16.1', 736);
+    static V1_16 = new ProtocolVersion('1.16', 735);
+
+    static V1_15_2 = new ProtocolVersion('1.15.2', 578);
+    static V1_15_1 = new ProtocolVersion('1.15.1', 575);
+    static V1_15 = new ProtocolVersion('1.15', 573);
+
+    static V1_14_4 = new ProtocolVersion('1.14.4', 498);
+    static V1_14_3 = new ProtocolVersion('1.14.3', 490);
+    static V1_14_2 = new ProtocolVersion('1.14.2', 485);
+    static V1_14_1 = new ProtocolVersion('1.14.1', 480);
+    static V1_14 = new ProtocolVersion('1.14', 477);
+
+    static V1_13_2 = new ProtocolVersion('1.13.2', 404);
+    static V1_13_1 = new ProtocolVersion('1.13.1', 401);
+    static V1_13 = new ProtocolVersion('1.13', 393);
+
+    static V1_12_2 = new ProtocolVersion('1.12.2', 340);
+    static V1_12_1 = new ProtocolVersion('1.12.1', 338);
+    static V1_12 = new ProtocolVersion('1.12', 335);
+
+    static V1_11_2 = new ProtocolVersion('1.11.2', 316);
+    static V1_11_1 = new ProtocolVersion('1.11.1', 316);
+    static V1_11 = new ProtocolVersion('1.11', 315);
+
+    static V1_10_2 = new ProtocolVersion('1.10.2', 210);
+    static V1_10_1 = new ProtocolVersion('1.10.1', 210);
+    static V1_10 = new ProtocolVersion('1.10', 210);
+
+    static V1_9_4 = new ProtocolVersion('1.9.4', 110);
+    static V1_9_3 = new ProtocolVersion('1.9.3', 110);
+    static V1_9_2 = new ProtocolVersion('1.9.2', 109);
+    static V1_9_1 = new ProtocolVersion('1.9.1', 108);
+    static V1_9 = new ProtocolVersion('1.9', 107);
+
+    static V1_8_9 = new ProtocolVersion('1.8.9', 47);
+    static V1_8_8 = new ProtocolVersion('1.8.8', 47);
+    static V1_8 = new ProtocolVersion('1.8', 47);
+
+    static V1_7_10 = new ProtocolVersion('1.7.10', 5);
+    static V1_7_6 = new ProtocolVersion('1.7.6', 5);
+    static V1_7_2 = new ProtocolVersion('1.7.2', 4);
+}
+
+export default ProtocolVersion;

package/src/protocol/packets/Packet.js

@@ -0,0 +1,119 @@
+import { PacketBuffer } from '../../utils/PacketBuffer.js';
+
+export class Packet {
+    
+    static get packetId() {
+        throw new Error('Packet class must implement static packetId getter');
+    }
+
+    static get packetName() {
+        return this.name;
+    }
+
+    constructor() {
+        this._timestamp = Date.now();
+    }
+
+    get packetId() {
+        return this.constructor.packetId;
+    }
+
+    get packetName() {
+        return this.constructor.packetName;
+    }
+
+    get timestamp() {
+        return this._timestamp;
+    }
+
+    read(buffer, context) {
+        throw new Error(`${this.packetName}.read() must be implemented`);
+    }
+
+    write(buffer, context) {
+        throw new Error(`${this.packetName}.write() must be implemented`);
+    }
+
+    encode(context = {}) {
+        const buffer = PacketBuffer.writer();
+        buffer.writeVarInt(this.packetId);
+        this.write(buffer, context);
+        return buffer.getBuffer();
+    }
+
+    static decode(data, context = {}) {
+        const packet = new this();
+        const buffer = PacketBuffer.reader(data);
+        packet.read(buffer, context);
+        return packet;
+    }
+
+    toJSON() {
+        const json = {
+            packetId: this.packetId,
+            packetName: this.packetName,
+            timestamp: this._timestamp
+        };
+
+        for (const key of Object.keys(this)) {
+            if (!key.startsWith('_')) {
+                json[key] = this[key];
+            }
+        }
+
+        return json;
+    }
+
+    toString() {
+        return `${this.packetName}(0x${this.packetId.toString(16).padStart(2, '0')})`;
+    }
+
+    clone() {
+        const PacketClass = this.constructor;
+        const packet = new PacketClass();
+        
+        for (const key of Object.keys(this)) {
+            const value = this[key];
+            
+            if (value === null || value === undefined) {
+                packet[key] = value;
+            } else if (Buffer.isBuffer(value)) {
+                packet[key] = Buffer.from(value);
+            } else if (Array.isArray(value)) {
+                packet[key] = [...value];
+            } else if (typeof value === 'object' && value.clone) {
+                packet[key] = value.clone();
+            } else if (typeof value === 'object') {
+                packet[key] = { ...value };
+            } else {
+                packet[key] = value;
+            }
+        }
+        
+        return packet;
+    }
+}
+
+export function PacketInfo(metadata) {
+    return function(PacketClass) {
+        PacketClass._metadata = metadata;
+        
+        if (metadata.id !== undefined) {
+            Object.defineProperty(PacketClass, 'packetId', {
+                get: () => metadata.id,
+                configurable: true
+            });
+        }
+        
+        if (metadata.name) {
+            Object.defineProperty(PacketClass, 'packetName', {
+                get: () => metadata.name,
+                configurable: true
+            });
+        }
+        
+        return PacketClass;
+    };
+}
+
+export default Packet;

package/src/protocol/packets/PacketRegistry.js

@@ -0,0 +1,145 @@
+import { ConnectionState } from '../ConnectionState.js';
+import { PacketDirection } from '../PacketDirection.js';
+import { Logger } from '../../utils/Logger.js';
+
+const logger = Logger.getLogger('PacketRegistry');
+
+export class PacketRegistry {
+    constructor() {
+        
+        this._registry = new Map();
+
+        this._classToInfo = new Map();
+
+        for (const state of Object.values(ConnectionState)) {
+            const stateMap = new Map();
+            stateMap.set(PacketDirection.SERVERBOUND, new Map());
+            stateMap.set(PacketDirection.CLIENTBOUND, new Map());
+            this._registry.set(state.name, stateMap);
+        }
+    }
+
+    register({ packetClass, state, direction, packetId, name }) {
+        const stateName = typeof state === 'object' ? state.name : state;
+        
+        if (!this._registry.has(stateName)) {
+            throw new Error(`Unknown state: ${stateName}`);
+        }
+
+        const stateMap = this._registry.get(stateName);
+        const directionMap = stateMap.get(direction);
+
+        if (!directionMap) {
+            throw new Error(`Unknown direction: ${direction}`);
+        }
+
+        if (directionMap.has(packetId)) {
+            logger.warn(`Overwriting packet registration for ${stateName}/${direction}/0x${packetId.toString(16)}`);
+        }
+
+        directionMap.set(packetId, packetClass);
+
+        this._classToInfo.set(packetClass, {
+            state: stateName,
+            direction,
+            packetId,
+            name: name || packetClass.packetName || packetClass.name
+        });
+
+        logger.trace(`Registered packet: ${packetClass.name} (${stateName}/${direction}/0x${packetId.toString(16)})`);
+    }
+
+    registerAll(packets) {
+        for (const packet of packets) {
+            this.register(packet);
+        }
+    }
+
+    getPacketClass(state, direction, packetId) {
+        const stateName = typeof state === 'object' ? state.name : state;
+        
+        const stateMap = this._registry.get(stateName);
+        if (!stateMap) return undefined;
+
+        const directionMap = stateMap.get(direction);
+        if (!directionMap) return undefined;
+
+        return directionMap.get(packetId);
+    }
+
+    getPacketInfo(packetClass) {
+        return this._classToInfo.get(packetClass);
+    }
+
+    createPacket(state, direction, packetId, data, context = {}) {
+        const PacketClass = this.getPacketClass(state, direction, packetId);
+
+        if (!PacketClass) {
+            return null;
+        }
+
+        try {
+            return PacketClass.decode(data, context);
+        } catch (error) {
+            logger.error(`Failed to decode packet 0x${packetId.toString(16)}:`, error);
+            return null;
+        }
+    }
+
+    hasPacket(state, direction, packetId) {
+        return this.getPacketClass(state, direction, packetId) !== undefined;
+    }
+
+    getPackets(state, direction) {
+        const stateName = typeof state === 'object' ? state.name : state;
+        const stateMap = this._registry.get(stateName);
+        
+        if (!stateMap) return new Map();
+        
+        return stateMap.get(direction) || new Map();
+    }
+
+    getAllPacketClasses() {
+        return Array.from(this._classToInfo.keys());
+    }
+
+    clear() {
+        for (const stateMap of this._registry.values()) {
+            for (const directionMap of stateMap.values()) {
+                directionMap.clear();
+            }
+        }
+        this._classToInfo.clear();
+    }
+
+    getStats() {
+        const stats = {
+            total: 0,
+            byState: {},
+            byDirection: {
+                [PacketDirection.SERVERBOUND]: 0,
+                [PacketDirection.CLIENTBOUND]: 0
+            }
+        };
+
+        for (const [stateName, stateMap] of this._registry) {
+            stats.byState[stateName] = {
+                [PacketDirection.SERVERBOUND]: 0,
+                [PacketDirection.CLIENTBOUND]: 0
+            };
+
+            for (const [direction, directionMap] of stateMap) {
+                const count = directionMap.size;
+                stats.byState[stateName][direction] = count;
+                stats.byDirection[direction] += count;
+                stats.total += count;
+            }
+        }
+
+        return stats;
+    }
+}
+
+export const defaultRegistry = new PacketRegistry();
+
+export default PacketRegistry;

package/src/protocol/packets/handshake/HandshakePacket.js

@@ -0,0 +1,44 @@
+import { Packet } from '../Packet.js';
+
+export class HandshakePacket extends Packet {
+    static get packetId() { return 0x00; }
+    static get packetName() { return 'Handshake'; }
+
+    constructor() {
+        super();
+
+        this.protocolVersion = 0;
+
+        this.serverAddress = '';
+
+        this.serverPort = 25565;
+
+        this.nextState = 1;
+    }
+
+    read(buffer, context) {
+        this.protocolVersion = buffer.readVarInt();
+        this.serverAddress = buffer.readString(255);
+        this.serverPort = buffer.readUShort();
+        this.nextState = buffer.readVarInt();
+    }
+
+    write(buffer, context) {
+        buffer.writeVarInt(this.protocolVersion);
+        buffer.writeString(this.serverAddress);
+        buffer.writeUShort(this.serverPort);
+        buffer.writeVarInt(this.nextState);
+    }
+
+    toJSON() {
+        return {
+            ...super.toJSON(),
+            protocolVersion: this.protocolVersion,
+            serverAddress: this.serverAddress,
+            serverPort: this.serverPort,
+            nextState: this.nextState
+        };
+    }
+}
+
+export default HandshakePacket;