Minecraft-protocol-1.20.4-chat-parser/main/chatparser.js

const lang = require("./en_us.json"); // translate message
const regex = /^(.+):\s*\/(.+)$/;

function parseCommand(message) {
    const match = message.match(regex);
    if (match) {
        const username = match[1];
        const command = match[2];
        return { username, command };
    } else {
        return undefined;
    }
}

function inject(bot) {
bot.on('systemChat', (packet) => {
  // console.log(packet)
  const jsonmsg = JSON.parse(packet.formattedMessage);
  const msg = parseMinecraftMessage(packet.formattedMessage);
  const nocolormsg = parseMinecraftMessageNoColor(packet.formattedMessage);
  const cspy = parseCommand(nocolormsg)
  if (cspy) bot.emit('custom_Commandspy', msg);
  if (jsonmsg === undefined) { // idk, but work
    if (msg !== undefined) bot.emit('custom_systemChat', msg, nocolormsg, undefined);
  } else {
	if (msg !== undefined) bot.emit('custom_systemChat', msg, nocolormsg, jsonmsg);
  }
});

bot.on('playerChat', (packet) => {
  let msg, vmsg;
  // console.log(packet)
  // other
  const uuid = packet.sender ? packet.sender : undefined;
  const plainMessage = packet.plainMessage ? packet.plainMessage : undefined;
  // Color
  const SenderName = packet.senderName ? parseMinecraftMessage(packet.senderName) : undefined;
  const TargetName = packet.targetName ? parseMinecraftMessage(packet.targetName) : undefined;
  const formattedMessage = packet.formattedMessage ? parseMinecraftMessage(packet.formattedMessage) : undefined;
  const unsignedContent = packet.unsignedContent ? parseMinecraftMessage(packet.unsignedContent) : undefined;
  // No Color
  const NoColorSenderName = packet.senderName ? parseMinecraftMessageNoColor(packet.senderName) : undefined;
  const NoColorTargetName = packet.targetName ? parseMinecraftMessageNoColor(packet.targetName) : undefined;
  const NoColorformattedMessage = packet.formattedMessage ? parseMinecraftMessageNoColor(packet.formattedMessage) : undefined;
  const NoColorunsignedContent = packet.unsignedContent ? parseMinecraftMessageNoColor(packet.unsignedContent) : undefined;
  switch (packet.type) {
	case 1: // /me text
	  msg = `* ${SenderName} ${formattedMessage}`;
	  nocolorplayermsg = `* ${NoColorSenderName} ${NoColorformattedMessage}`;
	  break;
    case 2: // someone /tell you text
      msg = `${SenderName} whispers to you: ${plainMessage ? plainMessage : formattedMessage}`;
	  nocolorplayermsg = `${NoColorSenderName} whispers to you: ${plainMessage ? plainMessage : NoColorformattedMessage}`;	
      break;
	case 3: // you /tell someone text
	  msg = `You whisper to ${TargetName}: ${plainMessage ? plainMessage : formattedMessage}`;
	  nocolorplayermsg = `You whisper to ${NoColorTargetName}: ${plainMessage ? plainMessage : NoColorformattedMessage}`;
	  break;
    case 4: // player chat
	  // /sudo and vanish send formattedMessage message
	  // normal unsignedContent
	  vmsg = formattedMessage;
	  nocolormsg = NoColorformattedMessage
	  msg = unsignedContent;
	  nocolorplayermsg = NoColorunsignedContent
      break;
    case 5: // /say text
      msg = `[${SenderName}] ${plainMessage ? plainMessage : formattedMessage}`;
	  nocolorplayermsg = `[${NoColorSenderName}] ${plainMessage ? plainMessage : NoColorformattedMessage}`;
      break;
    case 6: // /minecraft:teammsg text
      msg = `${TargetName} <${SenderName}> ${plainMessage}`;
	  nocolorplayermsg = `${NoColorTargetName} <${NoColorSenderName}> ${plainMessage}`;
      break;
    default:
      console.log(`Unknown player_chat packet. Type: ${packet.type}`);
	  console.log(packet)
      break;
  }
  if (msg !== undefined) bot.emit('custom_playerChat', msg, uuid, plainMessage, SenderName, TargetName, formattedMessage, unsignedContent, NoColorSenderName, NoColorTargetName, NoColorformattedMessage, NoColorunsignedContent, nocolorplayermsg, packet.type);
  if (vmsg !== undefined) bot.emit('custom_systemChat', vmsg, nocolormsg, "");
});

const ansiColorCodes = {
  '§0': '\x1B[30m', '§1': '\x1B[34m', '§2': '\x1B[32m', '§3': '\x1B[36m', 
  '§4': '\x1B[31m', '§5': '\x1B[35m', '§6': '\x1B[33m', '§7': '\x1B[37m', 
  '§8': '\x1B[90m', '§9': '\x1B[94m', '§a': '\x1B[92m', '§b': '\x1B[96m', 
  '§c': '\x1B[91m', '§d': '\x1B[95m', '§e': '\x1B[93m', '§f': '\x1B[97m', 
  'black': '\x1B[30m', 'dark_blue': '\x1B[34m', 'dark_green': '\x1B[32m', 
  'dark_aqua': '\x1B[36m', 'dark_red': '\x1B[31m', 'dark_purple': '\x1B[35m', 
  'gold': '\x1B[33m', 'gray': '\x1B[37m', 'dark_gray': '\x1B[90m', 'blue': '\x1B[94m', 
  'green': '\x1B[92m', 'aqua': '\x1B[96m', 'red': '\x1B[91m', 'light_purple': '\x1B[95m', 
  'yellow': '\x1B[93m', 'white': '\x1B[97m'
};

const ansiFormatCodes = {
  '§l': '\x1B[1m',  '§o': '\x1B[3m',  '§n': '\x1B[4m',  '§m': '\x1B[9m', '§k': '\x1B[5m',  '§r': '\x1B[0m',
  'bold': '\x1B[1m', 'italic': '\x1B[3m', 'underlined': '\x1B[4m', 'strikethrough': '\x1B[9m', 'obfuscated': '\x1B[5m', 'reset': '\x1B[0m',
};

function parseMinecraftMessage(component) {
  let jsonComponent;
  try {
	jsonComponent = JSON.parse(component);
  } catch (e) {
	console.error("Invalid JSON format:", component);
	return '';
  }

  function extractText(comp) {
    let text = '';
	if (comp.text && typeof comp.text === 'string' || typeof comp.text === 'number' && comp.text !== undefined && comp.text !== null) {
      text += comp.text;
    }
    if (comp[""] && typeof comp[""] === 'string' || typeof comp[""] === 'number' && comp[""] !== undefined && comp[""] !== null) {
      text += comp[""];
    }
	if (comp && typeof comp === 'string' || typeof comp === 'number' && comp !== undefined && comp !== null) {
	  return comp;
    }

    if (comp.extra) {
      comp.extra.forEach(subComp => {
        text += formatfunction(comp, extractText(subComp));
	  });
	}    
	
	if (comp.translate) {
	  let translateString = lang[comp.translate] || comp.translate;
		if (comp.with) {
			const withArgs = comp.with.map(arg => extractText(arg));
			withArgs.forEach((arg, index) => {
			  if (arg.length > 2048) return translateString = ''; // anti tellraw translate crash
			  translateString = translateString.replace('%s', formatfunction(comp, arg));
			  const placeholder = new RegExp(`%${index + 1}\\$s`, 'g'); // create tellraw translate crash
			  translateString = translateString.replace(placeholder, formatfunction(comp, arg));
			  });
		}	  
	  text += formatfunction(comp, translateString);
	}
	
	text = parseMinecraftColor(comp.color) + parseMinecraftFormat(comp) + text + ansiFormatCodes['reset'];
    return text;
  }
  
  return extractText(jsonComponent) + ansiFormatCodes['reset'];
  
}


function formatfunction(comp, text) {
	if (text === undefined) return '';
	return text = parseMinecraftColor(comp.color) + parseMinecraftFormat(comp) + text + parseMinecraftColor(comp.color) + parseMinecraftFormat(comp);
}

function parseMinecraftColor(color) {
  if (color && ansiColorCodes[color] && !color.startsWith('#')) {
    return ansiColorCodes[color];
  } else if (color && color.startsWith('#')) {
    const hexRegex = /#?([a-fA-F\d]{2})([a-fA-F\d]{2})([a-fA-F\d]{2})/;
    const hexCodes = hexRegex.exec(color);
    if (hexCodes) {
      const red = parseInt(hexCodes[1], 16);
      const green = parseInt(hexCodes[2], 16);
      const blue = parseInt(hexCodes[3], 16);
      const ansiColor = `\u001b[38;2;${red};${green};${blue}m`;
      return ansiColor;
    }
  } else {
    return '';
  }
}

function parseMinecraftFormat(format) {
  let result = '';
  if (format.bold && format.bold === 1) result += ansiFormatCodes['bold'];
  if (format.italic && format.italic === 1) result += ansiFormatCodes['italic'];
  if (format.underlined && format.underlined === 1) result += ansiFormatCodes['underlined'];
  if (format.strikethrough && format.strikethrough === 1) result += ansiFormatCodes['strikethrough'];
  if (format.obfuscated && format.obfuscated === 1) result += ansiFormatCodes['obfuscated'];
  return result;
}


function parseMinecraftMessageNoColor(component) {
  let jsonComponent;
  try {
	jsonComponent = JSON.parse(component);
  } catch (e) {
    console.error("Invalid JSON format:", component);
  }

  function extractText(comp) {
    let text = '';

	if (comp.text && typeof comp.text === 'string' || typeof comp.text === 'number' && comp.text !== undefined && comp.text !== null) {
      text += comp.text;
    }
    if (comp[""] && typeof comp[""] === 'string' || typeof comp[""] === 'number' && comp[""] !== undefined && comp[""] !== null) {
      text += comp[""];
    }
	if (comp && typeof comp === 'string' || typeof comp === 'number' && comp !== undefined && comp !== null) {
	  return comp;
    }
    if (comp.extra) {
      comp.extra.forEach(subComp => {
        text += extractText(subComp);
      });
    }
	if (comp.translate) {
	  let translateString = lang[comp.translate] || comp.translate;
	  if (comp.with) {
		const withArgs = comp.with.map(arg => extractText(arg));
		withArgs.forEach((arg, index) => {
		  if (arg.length > 10000) return translateString = ''; // anti tellraw translate crash
		  translateString = translateString.replace('%s', arg); 
		  const placeholder = new RegExp(`%${index + 1}\\$s`, 'g'); // create tellraw translate crash
		  translateString = translateString.replace(placeholder, arg);

		});
	  }
	  text += translateString;
	}

    return text;
  }
  msgText = extractText(jsonComponent)
  // msgText = msgText.replace('§', '&')
  return msgText;
}

function kickparser(component) {
	if (component === undefined) return component;
    function kickparserText(comp) {
        let text = '';
        
        if (typeof comp === 'string') {
            text += comp;
        }
		if (typeof comp.value === 'string') {
            text += comp.value;
        }
        if (comp.with) {
            text += kickparserText(comp.with);
        }
		
        if (comp.value) {
            [comp.value].forEach(subComp => {
				if (typeof subComp === 'string') text += subComp;
                text += kickparserText(subComp);
            });
		}
		
		// how did i write this???
        if (comp.translate) {
            let translateString = lang[comp.translate.value] || comp.translate.value;

            if (typeof translateString === 'string') {
                if (comp.with) {
                    const withArray = Array.isArray(comp.with.value) ? comp.with.value : [comp.with.value];
					let formattedString = translateString;
					const replacements = [];

					withArray.forEach((replacementText) => {
						if (replacementText.value) {
							const items = Array.isArray(replacementText.value) ? replacementText.value : [replacementText.value];
                                    
							items.forEach((item) => {
							const itemText = kickparserText(item);
							if (itemText) replacements.push(itemText);
							if (item.with && item.with.value) {
								const nestedValues = Array.isArray(item.with.value) ? item.with.value : [item.with.value];
								nestedValues.forEach(nestedItem => {
									const nestedText = kickparserText(nestedItem);
									if (nestedText) replacements.push(nestedText);
								});
							}
							});
						}
					});

					let replacementIndex = 0;
					formattedString = formattedString.replace(/%s/g, () => {
						return replacementIndex < replacements.length ? replacements[replacementIndex++] : '%s';
					});
					text += formattedString;
				} else {
					text += kickparserText(translateString);
				}
			
			} else {
				throw new Error(`Translation not found for key: ${comp.translate.value}`);
			}
		}
            
        

        return text;
    }
    
    let result = '';  // Initialize result to an empty string
    
    [component].forEach((comp) => {
        if (comp.reason) {  // Check if reason is defined
            result += kickparserText(comp.reason);
        }
    });
    
    return result
}


bot.parsekickmsg = (component) => {
	return kickparser(component);
};



}

module.exports = { inject };