-
- );
- }
-
- const theme = localStorage.getItem("theme") || "discord";
- if (message.content.substring(0, 7) === "\u0001ACTION") {
- return (
-
-
-
- {htmlContent}
-
-
-
- {formatTime(new Date(message.timestamp))}
-
-
- {showDate && (
-
- );
- }
- return (
-
-
-
- )}
-
- {formatDate(new Date(message.timestamp))}
-
-
-
-
-
-
-
- {avatarUrl ? (
- ![{message.userId.split("-")[0]}]({avatarUrl})
{
- // Fallback to initial if image fails to load
- e.currentTarget.style.display = "none";
- const parent = e.currentTarget.parentElement;
- if (parent) {
- parent.textContent = message.userId
- .charAt(0)
- .toUpperCase();
- }
- }}
- />
- ) : (
- message.userId.charAt(0).toUpperCase()
- )}
- {userStatus && (
-
-
-
- )}
-
- đĄ
-
-
-
-
- {userStatus}
-
-
-
-
-
- {formatTime(new Date(message.timestamp))}
-
-
-
- {message.userId === "system"
- ? "System"
- : (displayName || message.userId.split("-")[0]) +
- (displayName ? ` (${message.userId.split("-")[0]})` : "") +
- message.content.substring(7, message.content.length - 1)}
-
-
- {showDate && (
-
- );
-};
-
export const ChatArea: React.FC<{
onToggleChanList: () => void;
isChanListVisible: boolean;
@@ -588,7 +75,9 @@ export const ChatArea: React.FC<{
const [isEmojiSelectorOpen, setIsEmojiSelectorOpen] = useState(false);
const [isColorPickerOpen, setIsColorPickerOpen] = useState(false);
const [selectedColor, setSelectedColor] = useState
-
-
- )}
- {formatDate(new Date(message.timestamp))}
-
-
- {showHeader && (
-
- {
- if (message.userId !== "system") {
- onUsernameContextMenu(
- e,
- message.userId.split("-")[0],
- message.serverId,
- e.currentTarget,
- );
- }
- }}
- >
-
- )}
- {!showHeader && (
-
- {avatarUrl ? (
- {
- // Fallback to initial if image fails to load
- e.currentTarget.style.display = "none";
- const parent = e.currentTarget.parentElement;
- if (parent) {
- parent.textContent = message.userId
- .charAt(0)
- .toUpperCase();
- }
- }}
- />
- ) : (
- message.userId.charAt(0).toUpperCase()
- )}
- {userStatus && (
-
-
-
- )}
-
- đĄ
-
-
-
-
- {userStatus}
-
-
-
-
- )}
-
- {showHeader && (
-
- {/* Hover buttons */}
-
- {
- if (message.userId !== "system") {
- // Find the avatar element to position menu over it
- const messageElement = e.currentTarget.closest(".flex");
- const avatarElement =
- messageElement?.querySelector(".mr-4");
- onUsernameContextMenu(
- e,
- message.userId.split("-")[0],
- message.serverId,
- avatarElement,
- );
- }
- }}
- >
- {message.userId === "system"
- ? "System"
- : displayName || message.userId.split("-")[0]}
- {displayName && (
-
- {message.userId.split("-")[0]}
-
- )}
-
-
- {formatTime(new Date(message.timestamp))}
-
-
- )}
-
- {message.replyMessage && (
-
- {htmlContent}
-
-
- {/* Reactions positioned below message content */}
- {message.reactions && message.reactions.length > 0 && (
-
- â Replying to{" "}
-
- {
- // Find the avatar element to position menu over it
- const messageElement = e.currentTarget.closest(".flex");
- const avatarElement =
- messageElement?.querySelector(".mr-4");
- onUsernameContextMenu(
- e,
- message.replyMessage?.userId.split("-")[0] || "",
- message.serverId,
- avatarElement,
- );
- }}
- >
- {message.replyMessage?.userId.split("-")[0] || ""}
-
- :
- {" "}
-
- {mircToHtml(message.replyMessage.content)}
-
-
- )}
-
- {Object.entries(
- message.reactions.reduce(
- (
- acc: Record<
- string,
- {
- count: number;
- users: string[];
- currentUserReacted: boolean;
- }
- >,
- reaction: { emoji: string; userId: string },
- ) => {
- if (!acc[reaction.emoji]) {
- acc[reaction.emoji] = {
- count: 0,
- users: [],
- currentUserReacted: false,
- };
- }
- acc[reaction.emoji].count++;
- acc[reaction.emoji].users.push(reaction.userId);
- // Check if current user reacted with this emoji
- if (reaction.userId === currentUser?.username) {
- acc[reaction.emoji].currentUserReacted = true;
- }
- return acc;
- },
- {} as Record<
- string,
- {
- count: number;
- users: string[];
- currentUserReacted: boolean;
- }
- >,
- ),
- ).map(([emoji, data]) => (
-
- )}
- {
- // If current user has reacted, clicking removes the reaction
- if (
- (
- data as {
- count: number;
- users: string[];
- currentUserReacted: boolean;
- }
- ).currentUserReacted
- ) {
- onReactionUnreact(emoji, message);
- } else {
- // Otherwise, add the reaction
- onOpenReactionModal(message, {
- x: e.clientX,
- y: e.clientY,
- });
- }
- }}
- >
- {emoji}
-
- {
- (
- data as {
- count: number;
- users: string[];
- currentUserReacted: boolean;
- }
- ).count
- }
-
- {/* Show X button if current user reacted */}
- {(
- data as {
- count: number;
- users: string[];
- currentUserReacted: boolean;
- }
- ).currentUserReacted && (
-
- )}
-
- ))}
-
-
- {message.msgid && (
-
- )}
-
-
- setIsEmojiSelectorOpen(false)}
- />
- {isEmojiSelectorOpen && (
-
+
,
+ document.body,
+ )}
{isColorPickerOpen && (
+
+
+
+
+
+
+
+ {showDate && (
+
+ );
+};
diff --git a/src/components/message/DateSeparator.tsx b/src/components/message/DateSeparator.tsx
new file mode 100644
index 00000000..9d569794
--- /dev/null
+++ b/src/components/message/DateSeparator.tsx
@@ -0,0 +1,27 @@
+import type React from "react";
+
+interface DateSeparatorProps {
+ date: Date;
+ theme: string;
+}
+
+export const DateSeparator: React.FC
+
+
+ )}
+ {formatDate(new Date(message.timestamp))}
+
+
+ {
+ onUsernameContextMenu(
+ e,
+ username,
+ message.serverId,
+ e.currentTarget,
+ );
+ }}
+ isClickable={true}
+ />
+
+
+
+
+
+ {formatTime(new Date(message.timestamp))}
+
+
+
+ {message.userId === "system"
+ ? "System"
+ : (displayName || username) +
+ (displayName ? ` (${username})` : "") +
+ message.content.substring(7, message.content.length - 1)}
+
+
+
+
+ );
+};
diff --git a/src/components/message/MessageActions.tsx b/src/components/message/MessageActions.tsx
new file mode 100644
index 00000000..8d7ee8f2
--- /dev/null
+++ b/src/components/message/MessageActions.tsx
@@ -0,0 +1,34 @@
+import type React from "react";
+import { FaGrinAlt, FaReply } from "react-icons/fa";
+import type { MessageType } from "../../types";
+
+interface MessageActionsProps {
+ message: MessageType;
+ onReplyClick: () => void;
+ onReactClick: (buttonElement: Element) => void;
+}
+
+export const MessageActions: React.FC{formatDate(date)}
+
+
+
+ {message.msgid && (
+
+ )}
+
+ );
+};
diff --git a/src/components/message/MessageAvatar.tsx b/src/components/message/MessageAvatar.tsx
new file mode 100644
index 00000000..631e7538
--- /dev/null
+++ b/src/components/message/MessageAvatar.tsx
@@ -0,0 +1,72 @@
+import type React from "react";
+
+interface MessageAvatarProps {
+ userId: string;
+ avatarUrl?: string;
+ userStatus?: string;
+ theme: string;
+ showHeader: boolean;
+ onClick?: (e: React.MouseEvent) => void;
+ isClickable?: boolean;
+}
+
+export const MessageAvatar: React.FC
+
+
+ );
+ }
+
+ return (
+
+
+ );
+};
diff --git a/src/components/message/MessageHeader.tsx b/src/components/message/MessageHeader.tsx
new file mode 100644
index 00000000..51faab67
--- /dev/null
+++ b/src/components/message/MessageHeader.tsx
@@ -0,0 +1,52 @@
+import type React from "react";
+import { getColorStyle } from "../../lib/ircUtils";
+
+interface MessageHeaderProps {
+ userId: string;
+ displayName?: string;
+ userColor?: string;
+ timestamp: Date;
+ theme: string;
+ isClickable?: boolean;
+ onClick?: (e: React.MouseEvent) => void;
+}
+
+export const MessageHeader: React.FC
+ {avatarUrl ? (
+ {
+ // Fallback to initial if image fails to load
+ e.currentTarget.style.display = "none";
+ const parent = e.currentTarget.parentElement;
+ if (parent) {
+ parent.textContent = username.charAt(0).toUpperCase();
+ }
+ }}
+ />
+ ) : (
+ username.charAt(0).toUpperCase()
+ )}
+ {userStatus && (
+
+
+
+ )}
+
+ đĄ
+
+
+
+
+ {userStatus}
+
+
+
+ {isSystem ? "System" : displayName || username}
+ {displayName && (
+
+ {username}
+
+ )}
+
+
+ {formatTime(timestamp)}
+
+
+ );
+};
diff --git a/src/components/message/MessageItem.tsx b/src/components/message/MessageItem.tsx
new file mode 100644
index 00000000..85fb8a69
--- /dev/null
+++ b/src/components/message/MessageItem.tsx
@@ -0,0 +1,195 @@
+import type React from "react";
+import { mircToHtml } from "../../lib/ircUtils";
+import useStore from "../../store";
+import type { MessageType, User } from "../../types";
+import { EnhancedLinkWrapper } from "../ui/LinkWrapper";
+import {
+ ActionMessage,
+ DateSeparator,
+ MessageActions,
+ MessageAvatar,
+ MessageHeader,
+ MessageReactions,
+ MessageReply,
+ SystemMessage,
+} from "./index";
+
+interface MessageItemProps {
+ message: MessageType;
+ showDate: boolean;
+ showHeader: boolean;
+ setReplyTo: (msg: MessageType) => void;
+ onUsernameContextMenu: (
+ e: React.MouseEvent,
+ username: string,
+ serverId: string,
+ avatarElement?: Element | null,
+ ) => void;
+ onIrcLinkClick?: (url: string) => void;
+ onReactClick: (message: MessageType, buttonElement: Element) => void;
+ selectedServerId: string | null;
+ onReactionUnreact: (emoji: string, message: MessageType) => void;
+ onOpenReactionModal: (
+ message: MessageType,
+ position: { x: number; y: number },
+ ) => void;
+ onDirectReaction: (emoji: string, message: MessageType) => void;
+ users: User[];
+}
+
+export const MessageItem: React.FC
+ {showDate && (
+
+ );
+};
diff --git a/src/components/message/MessageReactions.tsx b/src/components/message/MessageReactions.tsx
new file mode 100644
index 00000000..a4f266f6
--- /dev/null
+++ b/src/components/message/MessageReactions.tsx
@@ -0,0 +1,82 @@
+import type React from "react";
+import type { MessageType } from "../../types";
+
+interface ReactionData {
+ count: number;
+ users: string[];
+ currentUserReacted: boolean;
+}
+
+interface MessageReactionsProps {
+ reactions: MessageType["reactions"];
+ currentUserUsername?: string;
+ onReactionClick: (emoji: string, currentUserReacted: boolean) => void;
+}
+
+export const MessageReactions: React.FC
+ setReplyTo(message)}
+ onReactClick={(buttonElement) => onReactClick(message, buttonElement)}
+ />
+
+
+ {showHeader && (
+
+
+
+ {message.replyMessage && (
+
+ {htmlContent}
+
+
+
+
+ {Object.entries(groupedReactions).map(([emoji, data]) => {
+ const reactionData = data as ReactionData;
+ return (
+
+ );
+};
diff --git a/src/components/message/MessageReply.tsx b/src/components/message/MessageReply.tsx
new file mode 100644
index 00000000..f02dd81f
--- /dev/null
+++ b/src/components/message/MessageReply.tsx
@@ -0,0 +1,37 @@
+import type React from "react";
+import { mircToHtml } from "../../lib/ircUtils";
+import type { MessageType } from "../../types";
+import { EnhancedLinkWrapper } from "../ui/LinkWrapper";
+
+interface MessageReplyProps {
+ replyMessage: MessageType;
+ theme: string;
+ onUsernameClick?: (e: React.MouseEvent) => void;
+ onIrcLinkClick?: (url: string) => void;
+}
+
+export const MessageReply: React.FC
+ onReactionClick(emoji, reactionData.currentUserReacted)
+ }
+ >
+ {emoji}
+ {reactionData.count}
+ {/* Show X button if current user reacted */}
+ {reactionData.currentUserReacted && (
+
+ )}
+
+ );
+ })}
+
+ â Replying to{" "}
+
+
+ {replyUsername}
+
+ :
+ {" "}
+
+ {mircToHtml(replyMessage.content)}
+
+
+ );
+};
diff --git a/src/components/message/SystemMessage.tsx b/src/components/message/SystemMessage.tsx
new file mode 100644
index 00000000..aad35bd9
--- /dev/null
+++ b/src/components/message/SystemMessage.tsx
@@ -0,0 +1,37 @@
+import type React from "react";
+import { mircToHtml } from "../../lib/ircUtils";
+import type { MessageType } from "../../types";
+import { EnhancedLinkWrapper } from "../ui/LinkWrapper";
+
+interface SystemMessageProps {
+ message: MessageType;
+ onIrcLinkClick?: (url: string) => void;
+}
+
+export const SystemMessage: React.FC
+
+ );
+};
diff --git a/src/components/message/index.ts b/src/components/message/index.ts
new file mode 100644
index 00000000..1b86cd7f
--- /dev/null
+++ b/src/components/message/index.ts
@@ -0,0 +1,8 @@
+export { ActionMessage } from "./ActionMessage";
+export { DateSeparator } from "./DateSeparator";
+export { MessageActions } from "./MessageActions";
+export { MessageAvatar } from "./MessageAvatar";
+export { MessageHeader } from "./MessageHeader";
+export { MessageReactions } from "./MessageReactions";
+export { MessageReply } from "./MessageReply";
+export { SystemMessage } from "./SystemMessage";
diff --git a/src/components/ui/ColorPicker.tsx b/src/components/ui/ColorPicker.tsx
index 4c3e0eb0..f8dda87e 100644
--- a/src/components/ui/ColorPicker.tsx
+++ b/src/components/ui/ColorPicker.tsx
@@ -1,13 +1,14 @@
import type React from "react";
import { FaTimes } from "react-icons/fa";
import { ircColors } from "../../lib/ircUtils";
+import type { FormattingType } from "../../lib/messageFormatter";
const ColorPicker: React.FC<{
- onSelect: (color: string, formatting: string[]) => void;
+ onSelect: (color: string, formatting: FormattingType[]) => void;
onClose: () => void;
selectedColor: string | null;
- selectedFormatting: string[];
- toggleFormatting: (format: string) => void;
+ selectedFormatting: FormattingType[];
+ toggleFormatting: (format: FormattingType) => void;
}> = ({
onSelect,
onClose,
diff --git a/src/components/ui/EmojiSelector.tsx b/src/components/ui/EmojiSelector.tsx
deleted file mode 100644
index a523e5b8..00000000
--- a/src/components/ui/EmojiSelector.tsx
+++ /dev/null
@@ -1,34 +0,0 @@
-import type React from "react";
-
-interface EmojiSelectorProps {
- onSelect: (emoji: string) => void;
- onClose: () => void;
-}
-
-const emojis = ["đ", "đ", "đ", "đ", "đ", "â¤ī¸", "đĨ", "đ", "đ¯", "đļ"];
-
-const EmojiSelector: React.FC
+
+
+ {htmlContent}
+
+
+
+ {formatTime(new Date(message.timestamp))}
+
+
-
- );
-};
-
-export default EmojiSelector;
diff --git a/src/components/ui/LinkWrapper.tsx b/src/components/ui/LinkWrapper.tsx
new file mode 100644
index 00000000..ad86d4cb
--- /dev/null
+++ b/src/components/ui/LinkWrapper.tsx
@@ -0,0 +1,85 @@
+import type React from "react";
+import { Children, cloneElement, Fragment, isValidElement } from "react";
+
+interface EnhancedLinkWrapperProps {
+ children: React.ReactNode;
+ onIrcLinkClick?: (url: string) => void;
+}
+
+export const EnhancedLinkWrapper: React.FC
- {emojis.map((emoji) => (
-
- ))}
-
-
-
-
- | undefined;
+ ready: BaseIRCEvent & { serverName: string; nickname: string };
+ NICK: EventWithTags & {
oldNick: string;
newNick: string;
};
- QUIT: { serverId: string; username: string; reason: string };
- JOIN: { serverId: string; username: string; channelName: string };
- PART: {
- serverId: string;
- username: string;
+ QUIT: BaseUserActionEvent & { reason: string };
+ JOIN: BaseUserActionEvent & { channelName: string };
+ PART: BaseUserActionEvent & {
channelName: string;
reason?: string;
};
- KICK: {
- serverId: string;
- mtags: Record | undefined;
+ KICK: EventWithTags & {
username: string;
channelName: string;
target: string;
reason: string;
};
- CHANMSG: {
- serverId: string;
- mtags: Record | undefined;
- sender: string;
+ CHANMSG: BaseMessageEvent & {
channelName: string;
- message: string;
- timestamp: Date;
- };
- USERMSG: {
- serverId: string;
- mtags: Record | undefined;
- sender: string;
- message: string;
- timestamp: Date;
};
- TAGMSG: {
- serverId: string;
- mtags: Record | undefined;
+ USERMSG: BaseMessageEvent;
+ TAGMSG: EventWithTags & {
sender: string;
channelName: string;
timestamp: Date;
};
- NAMES: { serverId: string; channelName: string; users: User[] };
- "CAP LS": { serverId: string; cliCaps: string };
- "CAP ACK": { serverId: string; cliCaps: string };
- ISUPPORT: { serverId: string; key: string; value: string };
- CAP_ACKNOWLEDGED: { serverId: string; key: string; capabilities: string };
- CAP_END: { serverId: string };
- AUTHENTICATE: { serverId: string; param: string };
- METADATA: {
- serverId: string;
- target: string;
- key: string;
- visibility: string;
- value: string;
- };
- METADATA_WHOIS: {
- serverId: string;
- target: string;
- key: string;
- visibility: string;
- value: string;
- };
- METADATA_KEYVALUE: {
- serverId: string;
- target: string;
- key: string;
- visibility: string;
- value: string;
- };
- METADATA_KEYNOTSET: { serverId: string; target: string; key: string };
- METADATA_SUBOK: { serverId: string; keys: string[] };
- METADATA_UNSUBOK: { serverId: string; keys: string[] };
- METADATA_SUBS: { serverId: string; keys: string[] };
- METADATA_SYNCLATER: { serverId: string; target: string; retryAfter?: number };
- BATCH_START: { serverId: string; batchId: string; type: string };
- BATCH_END: { serverId: string; batchId: string };
- METADATA_FAIL: {
- serverId: string;
+ NAMES: BaseIRCEvent & { channelName: string; users: User[] };
+ "CAP LS": BaseIRCEvent & { cliCaps: string };
+ "CAP ACK": BaseIRCEvent & { cliCaps: string };
+ ISUPPORT: BaseIRCEvent & { key: string; value: string };
+ CAP_ACKNOWLEDGED: BaseIRCEvent & { key: string; capabilities: string };
+ CAP_END: BaseIRCEvent;
+ AUTHENTICATE: BaseIRCEvent & { param: string };
+ METADATA: MetadataValueEvent;
+ METADATA_WHOIS: MetadataValueEvent;
+ METADATA_KEYVALUE: MetadataValueEvent;
+ METADATA_KEYNOTSET: BaseMetadataEvent;
+ METADATA_SUBOK: BaseIRCEvent & { keys: string[] };
+ METADATA_UNSUBOK: BaseIRCEvent & { keys: string[] };
+ METADATA_SUBS: BaseIRCEvent & { keys: string[] };
+ METADATA_SYNCLATER: BaseIRCEvent & { target: string; retryAfter?: number };
+ BATCH_START: BaseIRCEvent & { batchId: string; type: string };
+ BATCH_END: BaseIRCEvent & { batchId: string };
+ METADATA_FAIL: BaseIRCEvent & {
subcommand: string;
code: string;
target?: string;
diff --git a/src/lib/ircUrlParser.ts b/src/lib/ircUrlParser.ts
new file mode 100644
index 00000000..23560144
--- /dev/null
+++ b/src/lib/ircUrlParser.ts
@@ -0,0 +1,145 @@
+/**
+ * Utility functions for parsing IRC URLs (irc:// and ircs://)
+ * Supports extracting server details, channels, and connection parameters
+ */
+
+export interface ParsedIrcUrl {
+ host: string;
+ port: number;
+ scheme: "irc" | "ircs";
+ channels: string[];
+ nick?: string;
+ password?: string;
+}
+
+/**
+ * Parses an IRC URL and extracts connection details
+ *
+ * @param url - The IRC URL to parse (irc:// or ircs://)
+ * @param defaultNick - Default nickname to use if none specified in URL
+ * @returns Parsed IRC connection details
+ *
+ * @example
+ * ```typescript
+ * const parsed = parseIrcUrl('ircs://irc.libera.chat:6697/#channel1,channel2?nick=user&password=pass');
+ * // Returns: {
+ * // host: 'irc.libera.chat',
+ * // port: 6697,
+ * // scheme: 'ircs',
+ * // channels: ['#channel1', '#channel2'],
+ * // nick: 'user',
+ * // password: 'pass'
+ * // }
+ * ```
+ */
+export function parseIrcUrl(url: string, defaultNick = "user"): ParsedIrcUrl {
+ // Sanitize URL by removing trailing punctuation commonly found in chat text
+ const sanitizedUrl = url.trim().replace(/[),.;:]+$/, "");
+
+ const urlObj = new URL(sanitizedUrl);
+ const host = urlObj.hostname;
+ const scheme = urlObj.protocol.replace(":", "") as "irc" | "ircs";
+
+ // Determine port with sensible defaults
+ const port = urlObj.port
+ ? Number.parseInt(urlObj.port, 10)
+ : scheme === "ircs"
+ ? 443
+ : 8000;
+
+ // Parse channels from pathname (/chan1,chan2) or hash (#chan1,chan2)
+ const rawChannelStr =
+ urlObj.pathname.length > 1
+ ? urlObj.pathname.slice(1) // Remove leading /
+ : urlObj.hash.startsWith("#")
+ ? urlObj.hash.slice(1) // Remove leading #
+ : "";
+
+ const channels = rawChannelStr
+ .split(",")
+ .filter(Boolean)
+ .map((c) => decodeURIComponent(c))
+ .map((c) => normalizeChannelName(c));
+
+ // Extract connection parameters
+ const nick = urlObj.searchParams.get("nick") || defaultNick;
+ const password = urlObj.searchParams.get("password") || undefined;
+
+ return {
+ host,
+ port,
+ scheme,
+ channels,
+ nick,
+ password,
+ };
+}
+
+/**
+ * Normalizes a channel name by ensuring it has the correct prefix
+ * Adds '#' prefix if the channel doesn't start with a valid IRC channel prefix
+ *
+ * @param channelName - The channel name to normalize
+ * @returns Normalized channel name with proper prefix
+ */
+export function normalizeChannelName(channelName: string): string {
+ const validPrefixes = ["#", "&", "+", "!"];
+ const hasValidPrefix = validPrefixes.some((prefix) =>
+ channelName.startsWith(prefix),
+ );
+
+ return hasValidPrefix ? channelName : `#${channelName}`;
+}
+
+/**
+ * Validates if a URL is a valid IRC URL
+ *
+ * @param url - The URL to validate
+ * @returns true if the URL is a valid IRC URL
+ */
+export function isValidIrcUrl(url: string): boolean {
+ try {
+ const urlObj = new URL(url);
+ return (
+ ["irc:", "ircs:"].includes(urlObj.protocol) && urlObj.hostname !== ""
+ );
+ } catch {
+ return false;
+ }
+}
+
+/**
+ * Constructs an IRC URL from connection details
+ *
+ * @param details - The IRC connection details
+ * @returns Formatted IRC URL string
+ */
+export function constructIrcUrl(details: ParsedIrcUrl): string {
+ let url = `${details.scheme}://${details.host}:${details.port}`;
+
+ if (details.channels.length > 0) {
+ // Remove # prefixes from channels for clean URL construction
+ const cleanChannels = details.channels
+ .map((channel) =>
+ channel.startsWith("#") ? channel.substring(1) : channel,
+ )
+ .join(",");
+ url += `/${cleanChannels}`;
+ } else {
+ url += "/";
+ }
+
+ const params = new URLSearchParams();
+ if (details.nick) {
+ params.set("nick", details.nick);
+ }
+ if (details.password) {
+ params.set("password", details.password);
+ }
+
+ if (params.toString()) {
+ url += `?${params.toString()}`;
+ }
+
+ return url;
+}
diff --git a/src/lib/messageFormatter.ts b/src/lib/messageFormatter.ts
new file mode 100644
index 00000000..ef930f5f
--- /dev/null
+++ b/src/lib/messageFormatter.ts
@@ -0,0 +1,164 @@
+/**
+ * Utility functions for formatting IRC messages with colors and styling
+ * Handles IRC formatting codes for bold, italic, underline, etc.
+ */
+
+import { ircColors } from "./ircUtils";
+
+export type FormattingType =
+ | "bold"
+ | "italic"
+ | "underline"
+ | "strikethrough"
+ | "reverse"
+ | "monospace";
+
+export interface MessageFormatting {
+ color?: string;
+ formatting: FormattingType[];
+}
+
+/**
+ * IRC formatting control codes
+ */
+export const IRC_FORMATTING_CODES = {
+ bold: "\x02",
+ italic: "\x1D",
+ underline: "\x1F",
+ strikethrough: "\x1E",
+ reverse: "\x16",
+ monospace: "\x11",
+ color: "\x03",
+ reset: "\x0F",
+} as const;
+
+/**
+ * Gets the IRC color code for a given color name
+ *
+ * @param color - The color name or 'inherit' for no color
+ * @returns IRC color code string (e.g., '\x0301' for black)
+ *
+ * @example
+ * ```typescript
+ * getIrcColorCode('red') // Returns '\x0304'
+ * getIrcColorCode('inherit') // Returns ''
+ * ```
+ */
+export function getIrcColorCode(color: string): string {
+ if (color === "inherit") return "";
+
+ const index = ircColors.indexOf(color);
+ if (index === -1 || index === 99) return "";
+
+ // Format as two-digit number (e.g., 01, 02, 10)
+ const formattedIndex = index < 10 ? `0${index}` : `${index}`;
+ return `${IRC_FORMATTING_CODES.color}${formattedIndex}`;
+}
+
+/**
+ * Applies IRC formatting codes to text
+ *
+ * @param text - The text to format
+ * @param formatting - Array of formatting types to apply
+ * @returns Text wrapped with IRC formatting codes
+ *
+ * @example
+ * ```typescript
+ * applyIrcFormatting('Hello', ['bold', 'italic'])
+ * // Returns '\x02\x1DHello\x1D\x02'
+ * ```
+ */
+export function applyIrcFormatting(
+ text: string,
+ formatting: FormattingType[],
+): string {
+ let formattedText = text;
+
+ // Apply each formatting type
+ for (const format of formatting) {
+ const code = IRC_FORMATTING_CODES[format];
+ if (code) {
+ formattedText = `${code}${formattedText}${code}`;
+ }
+ }
+
+ return formattedText;
+}
+
+/**
+ * Formats a message with color and styling for IRC transmission
+ *
+ * @param text - The message text
+ * @param options - Formatting options (color and styling)
+ * @returns Formatted message ready for IRC transmission
+ *
+ * @example
+ * ```typescript
+ * formatMessageForIrc('Hello world', {
+ * color: 'red',
+ * formatting: ['bold', 'underline']
+ * })
+ * // Returns '\x0304\x02\x1FHello world\x1F\x02'
+ * ```
+ */
+export function formatMessageForIrc(
+ text: string,
+ options: MessageFormatting,
+): string {
+ const { color, formatting } = options;
+
+ // Apply formatting codes
+ let formattedText = applyIrcFormatting(text, formatting);
+
+ // Prepend color code if specified
+ const colorCode = color ? getIrcColorCode(color) : "";
+ if (colorCode) {
+ formattedText = `${colorCode}${formattedText}`;
+ }
+
+ return formattedText;
+}
+
+/**
+ * Gets CSS styles for preview based on formatting options
+ *
+ * @param options - Formatting options
+ * @returns CSS style object
+ */
+export function getPreviewStyles(
+ options: MessageFormatting,
+): React.CSSProperties {
+ const { color, formatting } = options;
+
+ return {
+ color: color && color !== "inherit" ? color : "inherit",
+ fontWeight: formatting.includes("bold") ? "bold" : "normal",
+ fontStyle: formatting.includes("italic") ? "italic" : "normal",
+ textDecoration: formatting.includes("underline")
+ ? "underline"
+ : formatting.includes("strikethrough")
+ ? "line-through"
+ : "none",
+ fontFamily: formatting.includes("monospace") ? "monospace" : "inherit",
+ };
+}
+
+/**
+ * Validates if a formatting type is supported
+ *
+ * @param format - The formatting type to validate
+ * @returns true if the formatting type is supported
+ */
+export function isValidFormattingType(
+ format: string,
+): format is FormattingType {
+ const validTypes: FormattingType[] = [
+ "bold",
+ "italic",
+ "underline",
+ "strikethrough",
+ "reverse",
+ "monospace",
+ ];
+ return validTypes.includes(format as FormattingType);
+}
diff --git a/src/types/index.ts b/src/types/index.ts
index 4c2e998d..49823181 100644
--- a/src/types/index.ts
+++ b/src/types/index.ts
@@ -76,6 +76,9 @@ export interface Message {
mentioned: string[];
}
+// Alias for backwards compatibility
+export type MessageType = Message;
+
export interface SocketResponse {
event: string;
data: unknown;
@@ -110,3 +113,37 @@ export type MessageTag = {
key: string;
value?: string;
};
+
+// Base event interface that all IRC events extend
+export interface BaseIRCEvent {
+ serverId: string;
+}
+
+// Events that include message tags
+export interface EventWithTags extends BaseIRCEvent {
+ mtags: Record | undefined;
+}
+
+// Base metadata event interface
+export interface BaseMetadataEvent extends BaseIRCEvent {
+ target: string;
+ key: string;
+}
+
+// Metadata event with visibility and value
+export interface MetadataValueEvent extends BaseMetadataEvent {
+ visibility: string;
+ value: string;
+}
+
+// Base message event interface
+export interface BaseMessageEvent extends EventWithTags {
+ sender: string;
+ message: string;
+ timestamp: Date;
+}
+
+// Base user action event interface
+export interface BaseUserActionEvent extends BaseIRCEvent {
+ username: string;
+}
diff --git a/tests/lib/ircUrlParser.test.ts b/tests/lib/ircUrlParser.test.ts
new file mode 100644
index 00000000..14906ef8
--- /dev/null
+++ b/tests/lib/ircUrlParser.test.ts
@@ -0,0 +1,287 @@
+import { describe, expect, it } from "vitest";
+import {
+ constructIrcUrl,
+ isValidIrcUrl,
+ normalizeChannelName,
+ type ParsedIrcUrl,
+ parseIrcUrl,
+} from "../../src/lib/ircUrlParser";
+
+describe("ircUrlParser", () => {
+ describe("parseIrcUrl", () => {
+ it("should parse basic IRC URL with default port", () => {
+ const result = parseIrcUrl("irc://irc.libera.chat/");
+
+ expect(result).toEqual({
+ host: "irc.libera.chat",
+ port: 8000,
+ scheme: "irc",
+ channels: [],
+ nick: "user",
+ password: undefined,
+ });
+ });
+
+ it("should parse IRCS URL with default port", () => {
+ const result = parseIrcUrl("ircs://irc.libera.chat/");
+
+ expect(result).toEqual({
+ host: "irc.libera.chat",
+ port: 443,
+ scheme: "ircs",
+ channels: [],
+ nick: "user",
+ password: undefined,
+ });
+ });
+
+ it("should parse URL with custom port", () => {
+ const result = parseIrcUrl("ircs://irc.libera.chat:6697/");
+
+ expect(result.port).toBe(6697);
+ });
+
+ it("should parse URL with single channel in pathname", () => {
+ const result = parseIrcUrl("irc://irc.libera.chat/channel1");
+
+ expect(result.channels).toEqual(["#channel1"]);
+ });
+
+ it("should parse URL with multiple channels in pathname", () => {
+ const result = parseIrcUrl(
+ "irc://irc.libera.chat/channel1,channel2,channel3",
+ );
+
+ expect(result.channels).toEqual(["#channel1", "#channel2", "#channel3"]);
+ });
+
+ it("should parse URL with channels in hash", () => {
+ const result = parseIrcUrl("irc://irc.libera.chat/#channel1,channel2");
+
+ expect(result.channels).toEqual(["#channel1", "#channel2"]);
+ });
+
+ it("should handle URL-encoded channel names", () => {
+ const result = parseIrcUrl("irc://irc.libera.chat/my%20channel");
+
+ expect(result.channels).toEqual(["#my channel"]);
+ });
+
+ it("should parse URL with nick parameter", () => {
+ const result = parseIrcUrl("irc://irc.libera.chat/?nick=testuser");
+
+ expect(result.nick).toBe("testuser");
+ });
+
+ it("should parse URL with password parameter", () => {
+ const result = parseIrcUrl("irc://irc.libera.chat/?password=secret123");
+
+ expect(result.password).toBe("secret123");
+ });
+
+ it("should parse complex URL with all parameters", () => {
+ const result = parseIrcUrl(
+ "ircs://irc.libera.chat:6697/channel1,channel2?nick=testuser&password=secret",
+ );
+
+ expect(result).toEqual({
+ host: "irc.libera.chat",
+ port: 6697,
+ scheme: "ircs",
+ channels: ["#channel1", "#channel2"],
+ nick: "testuser",
+ password: "secret",
+ });
+ });
+
+ it("should use custom default nick when provided", () => {
+ const result = parseIrcUrl("irc://irc.libera.chat/", "customnick");
+
+ expect(result.nick).toBe("customnick");
+ });
+
+ it("should override default nick with URL parameter", () => {
+ const result = parseIrcUrl(
+ "irc://irc.libera.chat/?nick=urlnick",
+ "defaultnick",
+ );
+
+ expect(result.nick).toBe("urlnick");
+ });
+
+ it("should sanitize URLs with trailing punctuation", () => {
+ const result = parseIrcUrl("irc://irc.libera.chat/channel1,channel2.");
+
+ expect(result.channels).toEqual(["#channel1", "#channel2"]);
+ });
+
+ it("should handle various trailing punctuation marks", () => {
+ const testCases = [
+ "irc://irc.libera.chat/test)",
+ "irc://irc.libera.chat/test,",
+ "irc://irc.libera.chat/test.",
+ "irc://irc.libera.chat/test;",
+ "irc://irc.libera.chat/test:",
+ "irc://irc.libera.chat/test).,;:",
+ ];
+
+ testCases.forEach((url) => {
+ const result = parseIrcUrl(url);
+ expect(result.channels).toEqual(["#test"]);
+ });
+ });
+
+ it("should handle channels with various prefixes", () => {
+ const result = parseIrcUrl(
+ "irc://irc.libera.chat/#chan1,&chan2,+chan3,!chan4",
+ );
+
+ expect(result.channels).toEqual(["#chan1", "&chan2", "+chan3", "!chan4"]);
+ });
+ });
+
+ describe("normalizeChannelName", () => {
+ it("should add # prefix to channel without prefix", () => {
+ expect(normalizeChannelName("channel")).toBe("#channel");
+ });
+
+ it("should preserve # prefix", () => {
+ expect(normalizeChannelName("#channel")).toBe("#channel");
+ });
+
+ it("should preserve & prefix", () => {
+ expect(normalizeChannelName("&channel")).toBe("&channel");
+ });
+
+ it("should preserve + prefix", () => {
+ expect(normalizeChannelName("+channel")).toBe("+channel");
+ });
+
+ it("should preserve ! prefix", () => {
+ expect(normalizeChannelName("!channel")).toBe("!channel");
+ });
+
+ it("should handle empty string", () => {
+ expect(normalizeChannelName("")).toBe("#");
+ });
+ });
+
+ describe("isValidIrcUrl", () => {
+ it("should return true for valid IRC URLs", () => {
+ expect(isValidIrcUrl("irc://irc.libera.chat/")).toBe(true);
+ expect(isValidIrcUrl("ircs://irc.libera.chat:6697/")).toBe(true);
+ });
+
+ it("should return false for non-IRC URLs", () => {
+ expect(isValidIrcUrl("http://example.com")).toBe(false);
+ expect(isValidIrcUrl("https://example.com")).toBe(false);
+ expect(isValidIrcUrl("ftp://example.com")).toBe(false);
+ });
+
+ it("should return false for invalid URLs", () => {
+ expect(isValidIrcUrl("not-a-url")).toBe(false);
+ expect(isValidIrcUrl("")).toBe(false);
+ expect(isValidIrcUrl("irc://")).toBe(false);
+ });
+ });
+
+ describe("constructIrcUrl", () => {
+ it("should construct basic IRC URL", () => {
+ const details: ParsedIrcUrl = {
+ host: "irc.libera.chat",
+ port: 8000,
+ scheme: "irc",
+ channels: [],
+ nick: "testuser",
+ };
+
+ const result = constructIrcUrl(details);
+ expect(result).toBe("irc://irc.libera.chat:8000/?nick=testuser");
+ });
+
+ it("should construct IRCS URL with channels", () => {
+ const details: ParsedIrcUrl = {
+ host: "irc.libera.chat",
+ port: 6697,
+ scheme: "ircs",
+ channels: ["#channel1", "#channel2"],
+ nick: "testuser",
+ password: "secret",
+ };
+
+ const result = constructIrcUrl(details);
+ expect(result).toBe(
+ "ircs://irc.libera.chat:6697/channel1,channel2?nick=testuser&password=secret",
+ );
+ });
+
+ it("should construct URL without optional parameters", () => {
+ const details: ParsedIrcUrl = {
+ host: "irc.libera.chat",
+ port: 443,
+ scheme: "ircs",
+ channels: ["#test"],
+ };
+
+ const result = constructIrcUrl(details);
+ expect(result).toBe("ircs://irc.libera.chat:443/test");
+ });
+ });
+
+ describe("round-trip compatibility", () => {
+ it("should parse and reconstruct URLs correctly", () => {
+ const testCases = [
+ {
+ url: "irc://irc.libera.chat:8000/",
+ expected: {
+ host: "irc.libera.chat",
+ port: 8000,
+ scheme: "irc" as const,
+ channels: [],
+ nick: "user",
+ },
+ },
+ {
+ url: "ircs://irc.libera.chat:6697/channel1,channel2?nick=testuser",
+ expected: {
+ host: "irc.libera.chat",
+ port: 6697,
+ scheme: "ircs" as const,
+ channels: ["#channel1", "#channel2"],
+ nick: "testuser",
+ },
+ },
+ {
+ url: "irc://irc.freenode.net/?nick=testuser",
+ expected: {
+ host: "irc.freenode.net",
+ port: 8000,
+ scheme: "irc" as const,
+ channels: [],
+ nick: "testuser",
+ },
+ },
+ ];
+
+ testCases.forEach(({ url, expected }) => {
+ const parsed = parseIrcUrl(url);
+
+ expect(parsed.host).toBe(expected.host);
+ expect(parsed.port).toBe(expected.port);
+ expect(parsed.scheme).toBe(expected.scheme);
+ expect(parsed.channels).toEqual(expected.channels);
+ expect(parsed.nick).toBe(expected.nick);
+
+ // Test reconstruction produces parseable URLs
+ const reconstructed = constructIrcUrl(parsed);
+ const reParsed = parseIrcUrl(reconstructed);
+
+ expect(reParsed.host).toBe(parsed.host);
+ expect(reParsed.port).toBe(parsed.port);
+ expect(reParsed.scheme).toBe(parsed.scheme);
+ expect(reParsed.channels).toEqual(parsed.channels);
+ expect(reParsed.nick).toBe(parsed.nick);
+ });
+ });
+ });
+});
diff --git a/tests/lib/messageFormatter.test.ts b/tests/lib/messageFormatter.test.ts
new file mode 100644
index 00000000..5ec149aa
--- /dev/null
+++ b/tests/lib/messageFormatter.test.ts
@@ -0,0 +1,311 @@
+import { describe, expect, it } from "vitest";
+import {
+ applyIrcFormatting,
+ type FormattingType,
+ formatMessageForIrc,
+ getIrcColorCode,
+ getPreviewStyles,
+ IRC_FORMATTING_CODES,
+ isValidFormattingType,
+ type MessageFormatting,
+} from "../../src/lib/messageFormatter";
+
+describe("messageFormatter", () => {
+ describe("getIrcColorCode", () => {
+ it("should return empty string for inherit color", () => {
+ expect(getIrcColorCode("inherit")).toBe("");
+ });
+
+ it("should return color code for valid colors", () => {
+ // Test with actual hex colors from ircColors array
+ expect(getIrcColorCode("#FFFFFF")).toBe("\x0300"); // White - index 0
+ expect(getIrcColorCode("#000000")).toBe("\x0301"); // Black - index 1
+ expect(getIrcColorCode("#FF0000")).toBe("\x0304"); // Red - index 4
+ });
+
+ it("should return empty string for invalid colors", () => {
+ expect(getIrcColorCode("invalidcolor")).toBe("");
+ expect(getIrcColorCode("")).toBe("");
+ });
+
+ it("should format single-digit indices with leading zero", () => {
+ // White is index 0, should be formatted as 00
+ const result = getIrcColorCode("#FFFFFF");
+ expect(result).toBe("\x0300");
+ expect(result.length).toBe(3); // \x03 + 2 digits
+ });
+ });
+
+ describe("applyIrcFormatting", () => {
+ it("should apply bold formatting", () => {
+ const result = applyIrcFormatting("test", ["bold"]);
+ expect(result).toBe("\x02test\x02");
+ });
+
+ it("should apply italic formatting", () => {
+ const result = applyIrcFormatting("test", ["italic"]);
+ expect(result).toBe("\x1Dtest\x1D");
+ });
+
+ it("should apply underline formatting", () => {
+ const result = applyIrcFormatting("test", ["underline"]);
+ expect(result).toBe("\x1Ftest\x1F");
+ });
+
+ it("should apply strikethrough formatting", () => {
+ const result = applyIrcFormatting("test", ["strikethrough"]);
+ expect(result).toBe("\x1Etest\x1E");
+ });
+
+ it("should apply reverse formatting", () => {
+ const result = applyIrcFormatting("test", ["reverse"]);
+ expect(result).toBe("\x16test\x16");
+ });
+
+ it("should apply monospace formatting", () => {
+ const result = applyIrcFormatting("test", ["monospace"]);
+ expect(result).toBe("\x11test\x11");
+ });
+
+ it("should apply multiple formatting types", () => {
+ const result = applyIrcFormatting("test", ["bold", "italic"]);
+ // Formatting is applied in array order, so bold first, then italic wraps it
+ expect(result).toBe("\x1D\x02test\x02\x1D");
+ });
+
+ it("should handle empty formatting array", () => {
+ const result = applyIrcFormatting("test", []);
+ expect(result).toBe("test");
+ });
+
+ it("should handle empty text", () => {
+ const result = applyIrcFormatting("", ["bold"]);
+ expect(result).toBe("\x02\x02");
+ });
+ });
+
+ describe("formatMessageForIrc", () => {
+ it("should format message with color only", () => {
+ const options: MessageFormatting = {
+ color: "#FF0000", // Red
+ formatting: [],
+ };
+ const result = formatMessageForIrc("hello", options);
+
+ // Should start with color code for red (index 4)
+ expect(result).toBe("\x0304hello");
+ });
+
+ it("should format message with formatting only", () => {
+ const options: MessageFormatting = {
+ formatting: ["bold", "italic"],
+ };
+ const result = formatMessageForIrc("hello", options);
+
+ expect(result).toBe("\x1D\x02hello\x02\x1D");
+ });
+
+ it("should format message with both color and formatting", () => {
+ const options: MessageFormatting = {
+ color: "#00007F", // Blue (Navy)
+ formatting: ["bold"],
+ };
+ const result = formatMessageForIrc("hello", options);
+
+ // Should have color code for blue (index 2) followed by formatted text
+ expect(result).toBe("\x0302\x02hello\x02");
+ });
+
+ it("should handle inherit color with formatting", () => {
+ const options: MessageFormatting = {
+ color: "inherit",
+ formatting: ["underline"],
+ };
+ const result = formatMessageForIrc("hello", options);
+
+ expect(result).toBe("\x1Fhello\x1F");
+ });
+
+ it("should handle no color with formatting", () => {
+ const options: MessageFormatting = {
+ formatting: ["italic"],
+ };
+ const result = formatMessageForIrc("hello", options);
+
+ expect(result).toBe("\x1Dhello\x1D");
+ });
+
+ it("should handle empty message", () => {
+ const options: MessageFormatting = {
+ color: "#FF0000", // Red
+ formatting: ["bold"],
+ };
+ const result = formatMessageForIrc("", options);
+
+ expect(result).toBe("\x0304\x02\x02");
+ });
+ });
+
+ describe("getPreviewStyles", () => {
+ it("should return styles for color only", () => {
+ const options: MessageFormatting = {
+ color: "red",
+ formatting: [],
+ };
+ const styles = getPreviewStyles(options);
+
+ expect(styles).toEqual({
+ color: "red",
+ fontWeight: "normal",
+ fontStyle: "normal",
+ textDecoration: "none",
+ fontFamily: "inherit",
+ });
+ });
+
+ it("should return styles for inherit color", () => {
+ const options: MessageFormatting = {
+ color: "inherit",
+ formatting: [],
+ };
+ const styles = getPreviewStyles(options);
+
+ expect(styles.color).toBe("inherit");
+ });
+
+ it("should return styles for bold formatting", () => {
+ const options: MessageFormatting = {
+ formatting: ["bold"],
+ };
+ const styles = getPreviewStyles(options);
+
+ expect(styles.fontWeight).toBe("bold");
+ });
+
+ it("should return styles for italic formatting", () => {
+ const options: MessageFormatting = {
+ formatting: ["italic"],
+ };
+ const styles = getPreviewStyles(options);
+
+ expect(styles.fontStyle).toBe("italic");
+ });
+
+ it("should return styles for underline formatting", () => {
+ const options: MessageFormatting = {
+ formatting: ["underline"],
+ };
+ const styles = getPreviewStyles(options);
+
+ expect(styles.textDecoration).toBe("underline");
+ });
+
+ it("should return styles for strikethrough formatting", () => {
+ const options: MessageFormatting = {
+ formatting: ["strikethrough"],
+ };
+ const styles = getPreviewStyles(options);
+
+ expect(styles.textDecoration).toBe("line-through");
+ });
+
+ it("should return styles for monospace formatting", () => {
+ const options: MessageFormatting = {
+ formatting: ["monospace"],
+ };
+ const styles = getPreviewStyles(options);
+
+ expect(styles.fontFamily).toBe("monospace");
+ });
+
+ it("should prioritize underline over strikethrough", () => {
+ const options: MessageFormatting = {
+ formatting: ["underline", "strikethrough"],
+ };
+ const styles = getPreviewStyles(options);
+
+ expect(styles.textDecoration).toBe("underline");
+ });
+
+ it("should handle multiple formatting types", () => {
+ const options: MessageFormatting = {
+ color: "blue",
+ formatting: ["bold", "italic", "monospace"],
+ };
+ const styles = getPreviewStyles(options);
+
+ expect(styles).toEqual({
+ color: "blue",
+ fontWeight: "bold",
+ fontStyle: "italic",
+ textDecoration: "none",
+ fontFamily: "monospace",
+ });
+ });
+ });
+
+ describe("isValidFormattingType", () => {
+ it("should return true for valid formatting types", () => {
+ const validTypes: FormattingType[] = [
+ "bold",
+ "italic",
+ "underline",
+ "strikethrough",
+ "reverse",
+ "monospace",
+ ];
+
+ validTypes.forEach((type) => {
+ expect(isValidFormattingType(type)).toBe(true);
+ });
+ });
+
+ it("should return false for invalid formatting types", () => {
+ const invalidTypes = ["invalid", "blink", "shadow", "", "BOLD", "Bold"];
+
+ invalidTypes.forEach((type) => {
+ expect(isValidFormattingType(type)).toBe(false);
+ });
+ });
+ });
+
+ describe("IRC_FORMATTING_CODES", () => {
+ it("should contain all expected formatting codes", () => {
+ expect(IRC_FORMATTING_CODES.bold).toBe("\x02");
+ expect(IRC_FORMATTING_CODES.italic).toBe("\x1D");
+ expect(IRC_FORMATTING_CODES.underline).toBe("\x1F");
+ expect(IRC_FORMATTING_CODES.strikethrough).toBe("\x1E");
+ expect(IRC_FORMATTING_CODES.reverse).toBe("\x16");
+ expect(IRC_FORMATTING_CODES.monospace).toBe("\x11");
+ expect(IRC_FORMATTING_CODES.color).toBe("\x03");
+ expect(IRC_FORMATTING_CODES.reset).toBe("\x0F");
+ });
+ });
+
+ describe("integration tests", () => {
+ it("should format complex message correctly", () => {
+ const options: MessageFormatting = {
+ color: "#FF0000", // Red
+ formatting: ["bold", "underline"],
+ };
+
+ const result = formatMessageForIrc("Hello World!", options);
+
+ // Should have color code + underline wrapping bold
+ expect(result).toBe("\x0304\x1F\x02Hello World!\x02\x1F");
+ });
+
+ it("should provide consistent preview styles for formatted message", () => {
+ const options: MessageFormatting = {
+ color: "#009300", // Green
+ formatting: ["bold", "italic"],
+ };
+
+ const styles = getPreviewStyles(options);
+
+ expect(styles.color).toBe("#009300");
+ expect(styles.fontWeight).toBe("bold");
+ expect(styles.fontStyle).toBe("italic");
+ });
+ });
+});
- {emojis.map((emoji) => (
-
- ))}
+ const handleBackdropClick = (e: React.MouseEvent) => {
+ if (e.target === e.currentTarget) {
+ onClose();
+ }
+ };
+
+ return createPortal(
+
,
+ document.body,
);
};
diff --git a/src/lib/ircClient.ts b/src/lib/ircClient.ts
index 183930b0..703e791d 100644
--- a/src/lib/ircClient.ts
+++ b/src/lib/ircClient.ts
@@ -1,5 +1,15 @@
import { v4 as uuidv4 } from "uuid";
-import type { Channel, Server, User } from "../types";
+import type {
+ BaseIRCEvent,
+ BaseMessageEvent,
+ BaseMetadataEvent,
+ BaseUserActionEvent,
+ Channel,
+ EventWithTags,
+ MetadataValueEvent,
+ Server,
+ User,
+} from "../types";
import {
parseIsupport,
parseMessageTags,
@@ -7,88 +17,50 @@ import {
} from "./ircUtils";
export interface EventMap {
- ready: { serverId: string; serverName: string; nickname: string };
- NICK: {
- serverId: string;
- mtags: Record
+
+
+
-
+
+
+
-