packet-events-js 1.0.0

package/src/protocol/types/TextComponent.js

@@ -0,0 +1,355 @@
+export const ChatColor = Object.freeze({
+    BLACK: 'black',
+    DARK_BLUE: 'dark_blue',
+    DARK_GREEN: 'dark_green',
+    DARK_AQUA: 'dark_aqua',
+    DARK_RED: 'dark_red',
+    DARK_PURPLE: 'dark_purple',
+    GOLD: 'gold',
+    GRAY: 'gray',
+    DARK_GRAY: 'dark_gray',
+    BLUE: 'blue',
+    GREEN: 'green',
+    AQUA: 'aqua',
+    RED: 'red',
+    LIGHT_PURPLE: 'light_purple',
+    YELLOW: 'yellow',
+    WHITE: 'white',
+
+    hex: (hex) => hex.startsWith('#') ? hex : `#${hex}`
+});
+
+export const ChatFormat = Object.freeze({
+    BOLD: 'bold',
+    ITALIC: 'italic',
+    UNDERLINED: 'underlined',
+    STRIKETHROUGH: 'strikethrough',
+    OBFUSCATED: 'obfuscated'
+});
+
+export const ClickAction = Object.freeze({
+    OPEN_URL: 'open_url',
+    RUN_COMMAND: 'run_command',
+    SUGGEST_COMMAND: 'suggest_command',
+    CHANGE_PAGE: 'change_page',
+    COPY_TO_CLIPBOARD: 'copy_to_clipboard'
+});
+
+export const HoverAction = Object.freeze({
+    SHOW_TEXT: 'show_text',
+    SHOW_ITEM: 'show_item',
+    SHOW_ENTITY: 'show_entity'
+});
+
+export class TextComponent {
+    constructor(text = '') {
+        this._data = {};
+        
+        if (text) {
+            this._data.text = text;
+        }
+    }
+
+    static text(text) {
+        return new TextComponent(text);
+    }
+
+    static translatable(key, ...args) {
+        const component = new TextComponent();
+        component._data.translate = key;
+        
+        if (args.length > 0) {
+            component._data.with = args.map(arg => 
+                arg instanceof TextComponent ? arg.toJSON() : { text: String(arg) }
+            );
+        }
+        
+        return component;
+    }
+
+    static keybind(keybind) {
+        const component = new TextComponent();
+        component._data.keybind = keybind;
+        return component;
+    }
+
+    static score(name, objective, value) {
+        const component = new TextComponent();
+        component._data.score = { name, objective };
+        
+        if (value !== undefined) {
+            component._data.score.value = value;
+        }
+        
+        return component;
+    }
+
+    static selector(selector, separator) {
+        const component = new TextComponent();
+        component._data.selector = selector;
+        
+        if (separator) {
+            component._data.separator = separator.toJSON();
+        }
+        
+        return component;
+    }
+
+    static nbt(nbt, interpret = false, separator) {
+        const component = new TextComponent();
+        component._data.nbt = nbt;
+        component._data.interpret = interpret;
+        
+        if (separator) {
+            component._data.separator = separator.toJSON();
+        }
+        
+        return component;
+    }
+
+    block(coords) {
+        this._data.block = coords;
+        return this;
+    }
+
+    entity(selector) {
+        this._data.entity = selector;
+        return this;
+    }
+
+    storage(storage) {
+        this._data.storage = storage;
+        return this;
+    }
+
+    color(color) {
+        this._data.color = color;
+        return this;
+    }
+
+    bold(value = true) {
+        this._data.bold = value;
+        return this;
+    }
+
+    italic(value = true) {
+        this._data.italic = value;
+        return this;
+    }
+
+    underlined(value = true) {
+        this._data.underlined = value;
+        return this;
+    }
+
+    strikethrough(value = true) {
+        this._data.strikethrough = value;
+        return this;
+    }
+
+    obfuscated(value = true) {
+        this._data.obfuscated = value;
+        return this;
+    }
+
+    font(font) {
+        this._data.font = font;
+        return this;
+    }
+
+    insertion(insertion) {
+        this._data.insertion = insertion;
+        return this;
+    }
+
+    clickEvent(action, value) {
+        this._data.clickEvent = { action, value };
+        return this;
+    }
+
+    openUrl(url) {
+        return this.clickEvent(ClickAction.OPEN_URL, url);
+    }
+
+    runCommand(command) {
+        return this.clickEvent(ClickAction.RUN_COMMAND, command);
+    }
+
+    suggestCommand(command) {
+        return this.clickEvent(ClickAction.SUGGEST_COMMAND, command);
+    }
+
+    copyToClipboard(text) {
+        return this.clickEvent(ClickAction.COPY_TO_CLIPBOARD, text);
+    }
+
+    hoverEvent(action, contents) {
+        this._data.hoverEvent = { action, contents };
+        return this;
+    }
+
+    showText(text) {
+        const contents = text instanceof TextComponent ? text.toJSON() : { text: String(text) };
+        return this.hoverEvent(HoverAction.SHOW_TEXT, contents);
+    }
+
+    showItem(id, count = 1, tag) {
+        const contents = { id, count };
+        if (tag) contents.tag = tag;
+        return this.hoverEvent(HoverAction.SHOW_ITEM, contents);
+    }
+
+    showEntity(type, id, name) {
+        const contents = { type, id };
+        if (name) {
+            contents.name = name instanceof TextComponent ? name.toJSON() : { text: String(name) };
+        }
+        return this.hoverEvent(HoverAction.SHOW_ENTITY, contents);
+    }
+
+    append(...children) {
+        if (!this._data.extra) {
+            this._data.extra = [];
+        }
+        
+        for (const child of children) {
+            if (child instanceof TextComponent) {
+                this._data.extra.push(child.toJSON());
+            } else {
+                this._data.extra.push({ text: String(child) });
+            }
+        }
+        
+        return this;
+    }
+
+    toJSON() {
+        return { ...this._data };
+    }
+
+    toString() {
+        return JSON.stringify(this._data);
+    }
+
+    toPlainText() {
+        let text = this._data.text || '';
+        
+        if (this._data.extra) {
+            for (const extra of this._data.extra) {
+                if (typeof extra === 'string') {
+                    text += extra;
+                } else if (extra.text) {
+                    text += extra.text;
+                }
+            }
+        }
+        
+        return text;
+    }
+
+    static fromJSON(json) {
+        if (typeof json === 'string') {
+            json = JSON.parse(json);
+        }
+        
+        const component = new TextComponent();
+        component._data = { ...json };
+        return component;
+    }
+
+    static fromLegacy(legacy) {
+        const colorMap = {
+            '0': 'black', '1': 'dark_blue', '2': 'dark_green', '3': 'dark_aqua',
+            '4': 'dark_red', '5': 'dark_purple', '6': 'gold', '7': 'gray',
+            '8': 'dark_gray', '9': 'blue', 'a': 'green', 'b': 'aqua',
+            'c': 'red', 'd': 'light_purple', 'e': 'yellow', 'f': 'white'
+        };
+        
+        const formatMap = {
+            'k': 'obfuscated', 'l': 'bold', 'm': 'strikethrough',
+            'n': 'underlined', 'o': 'italic', 'r': 'reset'
+        };
+        
+        const root = TextComponent.text('');
+        let current = TextComponent.text('');
+        let buffer = '';
+        
+        for (let i = 0; i < legacy.length; i++) {
+            if (legacy[i] === '§' && i + 1 < legacy.length) {
+                const code = legacy[i + 1].toLowerCase();
+                
+                if (buffer) {
+                    current._data.text = buffer;
+                    root.append(current);
+                    buffer = '';
+                }
+                
+                if (colorMap[code]) {
+                    current = TextComponent.text('').color(colorMap[code]);
+                } else if (formatMap[code]) {
+                    if (code === 'r') {
+                        current = TextComponent.text('');
+                    } else {
+                        current = TextComponent.text('')[formatMap[code]]();
+                    }
+                }
+                
+                i++;
+            } else {
+                buffer += legacy[i];
+            }
+        }
+        
+        if (buffer) {
+            current._data.text = buffer;
+            root.append(current);
+        }
+        
+        return root;
+    }
+}
+
+export class ComponentBuilder {
+    constructor() {
+        this.components = [];
+    }
+
+    append(component) {
+        if (typeof component === 'string') {
+            component = TextComponent.text(component);
+        }
+        this.components.push(component);
+        return this;
+    }
+
+    newLine() {
+        return this.append('\n');
+    }
+
+    build() {
+        if (this.components.length === 0) {
+            return TextComponent.text('');
+        }
+        
+        if (this.components.length === 1) {
+            return this.components[0];
+        }
+        
+        const root = TextComponent.text('');
+        root.append(...this.components);
+        return root;
+    }
+
+    static create() {
+        return new ComponentBuilder();
+    }
+}
+
+export default {
+    ChatColor,
+    ChatFormat,
+    ClickAction,
+    HoverAction,
+    TextComponent,
+    ComponentBuilder
+};

package/src/protocol/types/UUID.js

@@ -0,0 +1,105 @@
+import * as crypto from 'crypto';
+
+export class UUID {
+    
+    constructor(mostSigBits, leastSigBits) {
+        this.mostSigBits = BigInt(mostSigBits);
+        this.leastSigBits = BigInt(leastSigBits);
+    }
+
+    static fromString(str) {
+        
+        const hex = str.replace(/-/g, '');
+        
+        if (hex.length !== 32) {
+            throw new Error('Invalid UUID string length');
+        }
+        
+        const mostSigBits = BigInt('0x' + hex.substring(0, 16));
+        const leastSigBits = BigInt('0x' + hex.substring(16, 32));
+        
+        return new UUID(mostSigBits, leastSigBits);
+    }
+
+    static randomUUID() {
+        const bytes = crypto.randomBytes(16);
+
+        bytes[6] = (bytes[6] & 0x0f) | 0x40;
+        
+        bytes[8] = (bytes[8] & 0x3f) | 0x80;
+        
+        const mostSigBits = bytes.readBigUInt64BE(0);
+        const leastSigBits = bytes.readBigUInt64BE(8);
+        
+        return new UUID(mostSigBits, leastSigBits);
+    }
+
+    static fromBuffer(buffer, offset = 0) {
+        const mostSigBits = buffer.readBigUInt64BE(offset);
+        const leastSigBits = buffer.readBigUInt64BE(offset + 8);
+        return new UUID(mostSigBits, leastSigBits);
+    }
+
+    static fromBytes(bytes) {
+        return UUID.fromBuffer(Buffer.isBuffer(bytes) ? bytes : Buffer.from(bytes));
+    }
+
+    static offlinePlayerUUID(username) {
+        const hash = crypto.createHash('md5').update(`OfflinePlayer:${username}`).digest();
+
+        hash[6] = (hash[6] & 0x0f) | 0x30;
+        
+        hash[8] = (hash[8] & 0x3f) | 0x80;
+        
+        return UUID.fromBuffer(hash);
+    }
+
+    toBuffer(buffer, offset = 0) {
+        buffer.writeBigUInt64BE(this.mostSigBits, offset);
+        buffer.writeBigUInt64BE(this.leastSigBits, offset + 8);
+    }
+
+    toBytes() {
+        const buffer = Buffer.alloc(16);
+        this.toBuffer(buffer);
+        return buffer;
+    }
+
+    toString(withDashes = true) {
+        const mostHex = this.mostSigBits.toString(16).padStart(16, '0');
+        const leastHex = this.leastSigBits.toString(16).padStart(16, '0');
+        
+        const hex = mostHex + leastHex;
+        
+        if (withDashes) {
+            return [
+                hex.substring(0, 8),
+                hex.substring(8, 12),
+                hex.substring(12, 16),
+                hex.substring(16, 20),
+                hex.substring(20, 32)
+            ].join('-');
+        }
+        
+        return hex;
+    }
+
+    equals(other) {
+        if (!(other instanceof UUID)) return false;
+        return this.mostSigBits === other.mostSigBits && 
+               this.leastSigBits === other.leastSigBits;
+    }
+
+    get version() {
+        return Number((this.mostSigBits >> 12n) & 0xFn);
+    }
+
+    get variant() {
+        const variantBits = Number((this.leastSigBits >> 62n) & 0x3n);
+        if ((variantBits & 0x2) === 0) return 0; 
+        if ((variantBits & 0x1) === 0) return 2; 
+        return variantBits;
+    }
+}
+
+export default UUID;

package/src/protocol/types/VarInt.js

@@ -0,0 +1,144 @@
+const SEGMENT_BITS = 0x7F;
+const CONTINUE_BIT = 0x80;
+
+export function encodeVarInt(value) {
+    const bytes = [];
+
+    if (value < 0) {
+        value = value >>> 0; 
+    }
+    
+    do {
+        let byte = value & SEGMENT_BITS;
+        value >>>= 7;
+        
+        if (value !== 0) {
+            byte |= CONTINUE_BIT;
+        }
+        
+        bytes.push(byte);
+    } while (value !== 0);
+    
+    return Buffer.from(bytes);
+}
+
+export function decodeVarInt(buffer, offset = 0) {
+    let value = 0;
+    let position = 0;
+    let bytesRead = 0;
+    
+    while (true) {
+        if (offset + bytesRead >= buffer.length) {
+            throw new Error('VarInt buffer underflow');
+        }
+        
+        const byte = buffer[offset + bytesRead];
+        value |= (byte & SEGMENT_BITS) << position;
+        bytesRead++;
+        
+        if ((byte & CONTINUE_BIT) === 0) {
+            break;
+        }
+        
+        position += 7;
+        
+        if (position >= 32) {
+            throw new Error('VarInt is too big');
+        }
+    }
+
+    if (value > 0x7FFFFFFF) {
+        value = value - 0x100000000;
+    }
+    
+    return { value, bytesRead };
+}
+
+export function getVarIntSize(value) {
+    if (value < 0) value = value >>> 0;
+    
+    if (value < 0x80) return 1;
+    if (value < 0x4000) return 2;
+    if (value < 0x200000) return 3;
+    if (value < 0x10000000) return 4;
+    return 5;
+}
+
+export function encodeVarLong(value) {
+    const bytes = [];
+    let bigValue = BigInt(value);
+
+    if (bigValue < 0n) {
+        bigValue = bigValue & 0xFFFFFFFFFFFFFFFFn;
+    }
+    
+    do {
+        let byte = Number(bigValue & 0x7Fn);
+        bigValue >>= 7n;
+        
+        if (bigValue !== 0n) {
+            byte |= CONTINUE_BIT;
+        }
+        
+        bytes.push(byte);
+    } while (bigValue !== 0n);
+    
+    return Buffer.from(bytes);
+}
+
+export function decodeVarLong(buffer, offset = 0) {
+    let value = 0n;
+    let position = 0n;
+    let bytesRead = 0;
+    
+    while (true) {
+        if (offset + bytesRead >= buffer.length) {
+            throw new Error('VarLong buffer underflow');
+        }
+        
+        const byte = buffer[offset + bytesRead];
+        value |= BigInt(byte & SEGMENT_BITS) << position;
+        bytesRead++;
+        
+        if ((byte & CONTINUE_BIT) === 0) {
+            break;
+        }
+        
+        position += 7n;
+        
+        if (position >= 64n) {
+            throw new Error('VarLong is too big');
+        }
+    }
+
+    if (value > 0x7FFFFFFFFFFFFFFFn) {
+        value = value - 0x10000000000000000n;
+    }
+    
+    return { value, bytesRead };
+}
+
+export function getVarLongSize(value) {
+    let bigValue = BigInt(value);
+    if (bigValue < 0n) bigValue = bigValue & 0xFFFFFFFFFFFFFFFFn;
+    
+    if (bigValue < 0x80n) return 1;
+    if (bigValue < 0x4000n) return 2;
+    if (bigValue < 0x200000n) return 3;
+    if (bigValue < 0x10000000n) return 4;
+    if (bigValue < 0x800000000n) return 5;
+    if (bigValue < 0x40000000000n) return 6;
+    if (bigValue < 0x2000000000000n) return 7;
+    if (bigValue < 0x100000000000000n) return 8;
+    if (bigValue < 0x8000000000000000n) return 9;
+    return 10;
+}
+
+export default {
+    encodeVarInt,
+    decodeVarInt,
+    getVarIntSize,
+    encodeVarLong,
+    decodeVarLong,
+    getVarLongSize
+};

package/src/protocol/types/index.js

@@ -0,0 +1,5 @@
+export * from './VarInt.js';
+export * from './UUID.js';
+export * from './Position.js';
+export * from './NBT.js';
+export * from './TextComponent.js';