cassidy-styler

export { default as FontSystem } from "./font"; import { fonts, FontTypes } from "./font"; const line = "━"; /** * Formats a title string by extracting and rearranging emojis and non-emoji characters based on a pattern. * * @param {string} str - The input string containing emojis and text. * @param {string} [pattern] - The format pattern where `{word}` represents non-emoji text and `{emojis}` represents extracted emojis. * @returns {string} - The formatted title string. */ export function forceTitleFormat(str: string, pattern?: string): string { pattern ??= `{word} ${UNIRedux.charm} {emojis}`; const emojiRegex = /\p{Emoji}/gu; let emojis = [...str].filter((char) => emojiRegex.test(char)).join(""); let nonEmojis = [...str] .filter((char) => !emojiRegex.test(char)) .join("") .trim() .replaceAll("|", ""); const res = pattern .replaceAll("{word}", nonEmojis) .replaceAll("{emojis}", emojis); return res; } interface FormatOptions { title: string; content: string; titleFont?: FontTypes; contentFont?: FontTypes; titlePattern?: string; noFormat?: boolean; lineLength?: number; } /** * Formats title and content text. */ export function format( title: string, content: string, contentFont?: FontTypes ): string; /** * Formats title and content text with optional font styles and title patterns. */ export function format({ title, content, contentFont, titleFont, titlePattern, noFormat, lineLength, }: FormatOptions): string; /** * Formats title and content text with optional font styles and title patterns. */ export function format( arg1: string | FormatOptions, arg2?: string, arg3?: FontTypes | undefined ): string { let options: FormatOptions; if (typeof arg1 === "string" && typeof arg2 === "string") { options = { title: arg1, content: arg2, contentFont: arg3 }; } else if (typeof arg1 === "object" && arg1 !== null) { options = arg1; } else { throw new Error("Invalid arguments"); } options.titleFont ??= "bold"; options.contentFont ??= "fancy"; options.titlePattern ??= undefined; options.noFormat ??= false; options.lineLength ??= 15; return `${fonts[options.titleFont]( !options.noFormat ? forceTitleFormat(options.title, options.titlePattern) : options.title )}\n${line.repeat(options.lineLength)}\n${fonts[options.contentFont]( autoBold(options.content) )}`; } /** * A collection of special Unicode characters and symbols. * Provides commonly used characters like line separators, trademarks, mathematical symbols, and more. */ export class UNIRedux { /** Special invisible space character */ static specialSpace = "ᅠ"; /** Standard line repeated 1 time */ static singleLine = line; /** Burger menu icon */ static burger: "☰" = "☰"; /** Standard line repeated 15 times */ static standardLine = line.repeat(15); /** Section sign */ static section: "§" = "§"; /** Pilcrow sign */ static paragraph: "¶" = "¶"; /** Registered trademark sign */ static registered: "®" = "®"; /** Trademark sign */ static trademark: "™" = "™"; /** Copyright sign */ static copyright: "©" = "©"; /** Degree sign */ static degree: "°" = "°"; /** Micro sign */ static micro: "µ" = "µ"; /** Bullet point */ static bullet: "•" = "•"; /** En dash */ static enDash: "–" = "–"; /** Em dash */ static emDash: "—" = "—"; /** Prime symbol */ static prime: "′" = "′"; /** Double prime symbol */ static doublePrime: "″" = "″"; /** Dagger symbol */ static daggers: "†" = "†"; /** Double dagger symbol */ static doubleDagger: "‡" = "‡"; /** Ellipsis */ static ellipsis: "…" = "…"; /** Infinity symbol */ static infinity: "∞" = "∞"; /** Generic currency sign */ static currency: "¤" = "¤"; /** Yen sign */ static yen: "¥" = "¥"; /** Euro sign */ static euro: "€" = "€"; /** Pound sign */ static pound: "£" = "£"; /** Plus-minus sign */ static plusMinus: "±" = "±"; /** Approximately equal sign */ static approximately: "≈" = "≈"; /** Not equal to sign */ static notEqual: "≠" = "≠"; /** Less than or equal to sign */ static lessThanOrEqual: "≤" = "≤"; /** Greater than or equal to sign */ static greaterThanOrEqual: "≥" = "≥"; /** Summation sign */ static summation: "∑" = "∑"; /** Integral sign */ static integral: "∫" = "∫"; /** Square root sign */ static squareRoot: "√" = "√"; /** Partial differential sign */ static partialDifferential: "∂" = "∂"; /** Angle symbol */ static angle: "∠" = "∠"; /** Degree Fahrenheit sign */ static degreeFahrenheit: "℉" = "℉"; /** Degree Celsius sign */ static degreeCelsius: "℃" = "℃"; /** Floral Heart symbol */ static floralHeart: "❧" = "❧"; /** Star Flower symbol */ static starFlower: "✻" = "✻"; /** Heavy Star symbol */ static heavyStar: "★" = "★"; /** Sparkle symbol */ static sparkle: "✦" = "✦"; /** Asterisk symbol */ static asterisk: "✱" = "✱"; /** Heavy Check Mark */ static heavyCheckMark: "✔" = "✔"; /** Heavy Ballot X */ static heavyBallotX: "✖" = "✖"; /** Heart symbol */ static heart: "♥" = "♥"; /** Diamond symbol */ static diamond: "♦" = "♦"; /** Club symbol */ static club: "♣" = "♣"; /** Spade symbol */ static spade: "♠" = "♠"; /** Musical Note symbol */ static musicalNote: "♪" = "♪"; /** Double Musical Note symbol */ static doubleMusicalNote: "♫" = "♫"; /** Snowflake symbol */ static snowflake: "❄" = "❄"; /** Sparkle Star symbol */ static sparkleStar: "✨" = "✨"; /** Anchor symbol */ static anchor: "⚓" = "⚓"; /** Umbrella symbol */ static umbrella: "☔" = "☔"; /** Hourglass symbol */ static hourglass: "⌛" = "⌛"; /** Hourglass Not Done symbol */ static hourglassNotDone: "⏳" = "⏳"; /** Charm symbol */ static charm: "✦" = "✦"; /** Disc symbol */ static disc: "⦿" = "⦿"; /** Arrow symbol */ static arrow: "➤" = "➤"; /** Arrow (Black and White) symbol */ static arrowBW: "➣" = "➣"; /** Arrow from Top symbol */ static arrowFromT: "➥" = "➥"; /** Arrow from Bottom symbol */ static arrowFromB: "➦" = "➦"; /** Restart symbol */ static restart: "⟳" = "⟳"; /** Arrow Outline symbol */ static arrowOutline: "➩" = "➩"; } /** * Abbreviates a number using K (thousand), M (million), B (billion), etc. * * @param {number|string} value - The number to abbreviate. * @param {number} [places=2] - The number of decimal places to round to. * @param {boolean} [isFull=false] - If true, returns the full name instead of letter notation (e.g., "Thousand" instead of "K"). * @returns {string} - The abbreviated number. */ export function abbreviateNumber( value: number | string, places = 2, isFull = false ): string { let num = Number(value); if (isNaN(num)) return "Invalid input"; if (num < 1000) { return num.toFixed(places).replace(/\.?0+$/, ""); } const suffixes = ["", "K", "M", "B", "T", "P", "E"]; const fullSuffixes = [ "", "Thousand", "Million", "Billion", "Trillion", "Quadrillion", "Quintillion", ]; const magnitude = Math.floor(Math.log10(num) / 3); if (magnitude === 0) { return num % 1 === 0 ? num.toString() : num.toFixed(places).replace(/\.?0+$/, ""); } const abbreviatedValue = num / Math.pow(1000, magnitude); const suffix = isFull ? fullSuffixes[magnitude] : suffixes[magnitude]; if (abbreviatedValue % 1 === 0) { return `${Math.round(abbreviatedValue)}${isFull ? ` ${suffix}` : suffix}`; } const formattedValue = abbreviatedValue.toFixed(places).replace(/\.?0+$/, ""); return `${formattedValue}${isFull ? ` ${suffix}` : suffix}`; } /** * Transforms the input text by applying bold and bold-italic formatting. * * The function looks for text wrapped in `***` and `**` and replaces them with * bold-italic and bold formatting respectively. * * @param text - The input text to be transformed. * @returns The transformed text with bold and bold-italic formatting applied. */ export function autoBold(text: string) { text = String(text); text = text.replace(/\*\*\*(.*?)\*\*\*/g, (_: string, text: string) => fonts.bold_italic(text) ); text = text.replace(/\*\*(.*?)\*\*/g, (_: string, text: string) => fonts.bold(text) ); return text; } /** * Replaces custom font tags in the given text with corresponding font styles. * * The function looks for patterns in the format `[font=fontName]text[:font=fontName]` * and replaces them with the corresponding font styles if the font names match. * * @param text - The input text containing custom font tags. * @returns The text with font tags replaced by corresponding font styles. */ export function fontTag(text: string) { text = String(text); text = text.replace( /\[font=(.*?)\]\s*(.*?)\s*\[:font=(.*?)\]/g, (_, font, text, font2) => font === font2 ? fonts[font as FontTypes](text) : text ); return text; } type StrictMessageForm = { body?: string; attachment?: ReadableStream | ReadableStream[] | any | any[]; mentions?: Mention[]; location?: { latitude: number; longitude: number; current: boolean }; }; type MessageForm = string | StrictMessageForm; type FCAID = string | number; type Mention = { tag: string; id: FCAID; fromIndex: number; }; interface LiaIOQueue { form: MessageForm; senderID?: FCAID; replyTo?: FCAID | undefined; style?: FormatOptions; resolve?: (value: any) => any; reject?: (reason?: any) => any; event?: any; api?: any; } /** * @lianecagara * Class representing the LiaIOLite/Box for handling message input/output operations. * This class is responsible for sending, replying, and receiving messages, * as well as managing message reactions and handling events related to messages. * * @class Box */ export class Box { #api: any = null; #event: any = null; public style: FormatOptions | undefined; /** * Creates an instance of the LiaIO class to manage message interactions. * * @param {API} api - The API instance for interacting with the messaging service. * @param {FCAMessageReplyEvent | any} event - The event that triggered the interaction. * @memberof Box */ constructor(api: any, event: any, style?: FormatOptions) { this.#api = api; this.#event = event; this.style = style; } static queue: LiaIOQueue[] = []; /** * Sends an output message, which can be a reply or a new message. * * @param params - The parameters for sending the message. * @param params.form - The form of the message to be sent. * @param params.senderID - The ID of the sender (optional). * @param params.replyTo - The ID of the message being replied to (optional). * @param style * @returns A promise resolving to the sent message event. * @memberof Box */ async out(param0: { form: MessageForm; senderID?: FCAID; replyTo?: FCAID; style?: FormatOptions; }): Promise<any> { const { form: oform, senderID = this.#event.threadID, replyTo = undefined, style = null, } = param0; const form = normalizeMessageForm(oform) as StrictMessageForm; let exMents: Mention[] = []; if (typeof form.body === "string") { const ments = form.body.match(/@\[(.*?)=(.*?)\]/g); if (Array.isArray(ments)) { for (const ment of ments) { const [tag, uid] = ment.slice(2, -1).split("="); form.body = form.body.replace(ment, `@${tag}`); exMents.push({ id: uid, tag, fromIndex: form.body.indexOf(`@${tag}`), }); } } } let styler: FormatOptions | undefined = this.style; if (style) { styler = style; } if (styler && form.body && styler !== undefined && styler.title) { const combined: FormatOptions = { ...styler, content: form.body, }; form.body = format(combined); } return new Promise(async (resolve, reject) => { form.mentions = [...exMents, ...(form.mentions ?? [])]; for (const key in form) { if ( form[key as keyof StrictMessageForm] === null || form[key as keyof StrictMessageForm] === undefined ) { delete form[key as keyof StrictMessageForm]; } if (!form.mentions || form.mentions.length < 1) { delete form.mentions; } } console.log(`Form to send:`, form, senderID, replyTo); /** * @type {LiaIOQueue} */ const queueItem: LiaIOQueue = { ...param0, senderID, replyTo, style: styler, form, resolve, reject, api: this.#api, event: this.#event, }; Box.queue.push(queueItem); if (Box.queue.length === 1) { Box._processQueue(); } }); } static async _processQueue() { console.log(`Processing Queue..`); while (this.queue.length > 0) { const currentTask = this.queue[0]; console.log( `Current Queue task (total ${this.queue.length}):`, currentTask.form ); if (this.queue.length > 1) { await new Promise((resolve) => setTimeout(resolve, 500)); } try { console.log(`Sending form...`, currentTask.form); const { api, form: oform, reject, resolve, replyTo, senderID, } = currentTask; const form = normalizeMessageForm(oform); api.sendMessage( form, senderID, (err: any, info: any) => { if (err && reject) { reject(err); } else if (resolve) { console.log(`Form sent:`, form, senderID, replyTo); resolve(info); } }, replyTo ?? undefined ); } catch (error) { currentTask.reject?.(error); } this.queue.shift(); console.log(`Moving to next queue`); } } /** * Sends a reply to a message, optionally targeting a specific reply. * * @param form - The form of the reply message to be sent. * @param replyTo - The ID of the message being replied to (optional). * @returns A promise resolving to the message reply event. * @memberof Box * @example * await liaIO.reply("Hello, world!"); */ reply( form: MessageForm, replyTo: FCAID = this.#event.messageID ): Promise<any> { return this.out({ form, replyTo, }); } /** * Sends a message to a destination, optionally specifying the destination ID. * * @param form - The form of the message to be sent. * @param senderID - The ID of the destination to send the message to (optional). * @memberof Box * @example * await liaIO.send("Hello, world!"); */ send( form: MessageForm, senderID: FCAID = this.#event.threadID ): Promise<any> { return this.out({ form, senderID, }); } /** * An easy way to handle errors. * * @param error - Error to be sent. */ error(error: Error | Record<string, any>): Promise<any> { const errString = error instanceof Error ? String(error.stack) : JSON.stringify(error, null, 2); console.error(error); return this.reply(errString); } /** * Adds a reaction to a message, optionally targeting a specific message to react to. * * @param emoji - The reaction to be added (e.g., "like", "love"). * @param reactTo - The ID of the message to react to (optional). * @returns A promise resolving to the sent reaction event. * @memberof Box */ reaction( emoji: string, reactTo: FCAID = this.#event.messageID ): Promise<any> { return new Promise((resolve, reject) => { this.#api.setMessageReaction(emoji, reactTo, (err: any) => { if (err) { return reject(err); } return resolve(true); }); }); } clone(): Box { return new Box(this.#api, this.#event, this.style); } styled(style: FormatOptions) { return new Box(this.#api, this.#event, style); } } function normalizeMessageForm(form: MessageForm): StrictMessageForm { let r: Record<string, any> = {}; if (form && r) { if (typeof form === "object") { r = form; } if (typeof form === "string") { r = { body: form, }; } if (!Array.isArray(r.attachment) && r.attachment) { r.attachment = [r.attachment]; } return r; } else { return { body: undefined, }; } } export const LiaIOLite = Box;