chrxmaticc-framework 1.2.1 → 1.4.0

package/core/ChrxEmbedBuilder.js

@@ -0,0 +1,127 @@
+/**
+ * core/ChrxEmbedBuilder.js
+ * Simple and Advanced embed builder.
+ *
+ * Simple mode  → key/value syntax (title, desc, color)
+ * AdvancedEmbed → parses raw JSON or HTML-like string into a full embed
+ */
+
+const { EmbedBuilder } = require("discord.js");
+
+class ChrxEmbedBuilder {
+  /**
+   * Simple mode — just pass title, desc, color etc.
+   * @param {object} options
+   * @param {string} [options.title]
+   * @param {string} [options.desc]
+   * @param {string} [options.color]
+   * @param {string} [options.thumbnail]
+   * @param {string} [options.image]
+   * @param {string} [options.footer]
+   * @param {boolean} [options.timestamp]
+   * @param {object[]} [options.fields]  [{ name, value, inline? }]
+   */
+  static build(options = {}) {
+    const embed = new EmbedBuilder();
+
+    if (options.title)     embed.setTitle(options.title);
+    if (options.desc)      embed.setDescription(options.desc);
+    if (options.color)     embed.setColor(options.color);
+    if (options.thumbnail) embed.setThumbnail(options.thumbnail);
+    if (options.image)     embed.setImage(options.image);
+    if (options.footer)    embed.setFooter({ text: options.footer });
+    if (options.timestamp) embed.setTimestamp();
+    if (options.fields)    embed.addFields(options.fields);
+
+    return embed;
+  }
+
+  /**
+   * AdvancedEmbed — reads raw JSON string or HTML-like string and parses it.
+   * Supports both:
+   *   - JSON: { "title": "Hi", "desc": "ok bro", "color": "#5865F2", ... }
+   *   - HTML-like: <title>Hi</title><desc>ok bro</desc><color>#5865F2</color>
+   *
+   * @param {string|object} input  Raw JSON string, HTML-like string, or plain object
+   * @returns {EmbedBuilder}
+   */
+  static advanced(input) {
+    let data = {};
+
+    if (typeof input === "object") {
+      // Already a plain object
+      data = input;
+
+    } else if (typeof input === "string") {
+      // Try JSON first
+      try {
+        data = JSON.parse(input);
+      } catch {
+        // Fall back to HTML-like tag parser
+        data = ChrxEmbedBuilder._parseHTML(input);
+      }
+    }
+
+    return ChrxEmbedBuilder.build(data);
+  }
+
+  /**
+   * Parse HTML-like tag syntax into a plain object.
+   * Supports: <title> <desc> <color> <thumbnail> <image> <footer> <timestamp> <field>
+   *
+   * Example input:
+   * <title>Hello!</title>
+   * <desc>This is my embed</desc>
+   * <color>#5865F2</color>
+   * <field name="Field 1" value="Value 1" inline="true"/>
+   */
+  static _parseHTML(html) {
+    const data = {};
+
+    const extract = (tag) => {
+      const match = html.match(new RegExp(`<${tag}[^>]*>(.*?)<\\/${tag}>`, "si"));
+      return match ? match[1].trim() : null;
+    };
+
+    data.title     = extract("title")     || undefined;
+    data.desc      = extract("desc")      || extract("description") || undefined;
+    data.color     = extract("color")     || undefined;
+    data.thumbnail = extract("thumbnail") || undefined;
+    data.image     = extract("image")     || undefined;
+    data.footer    = extract("footer")    || undefined;
+    data.timestamp = html.includes("<timestamp") ? true : undefined;
+
+    // Parse <field name="x" value="y" inline="true"/> tags
+    const fieldRegex = /<field\s+name="([^"]+)"\s+value="([^"]+)"(?:\s+inline="(true|false)")?[^/]*\/>/gi;
+    const fields = [];
+    let fieldMatch;
+    while ((fieldMatch = fieldRegex.exec(html)) !== null) {
+      fields.push({
+        name: fieldMatch[1],
+        value: fieldMatch[2],
+        inline: fieldMatch[3] === "true",
+      });
+    }
+    if (fields.length > 0) data.fields = fields;
+
+    return data;
+  }
+}
+
+/**
+ * EmbedTrigger — fires a ChrxEmbedBuilder embed in a reply/send.
+ * Drop this anywhere in a ChrxCommandBuilder run() function.
+ *
+ * @param {import("discord.js").CommandInteraction} interaction
+ * @param {EmbedBuilder} embed
+ * @param {object} [options]
+ * @param {boolean} [options.ephemeral]
+ */
+async function EmbedTrigger(interaction, embed, options = {}) {
+  if (interaction.replied || interaction.deferred) {
+    return interaction.followUp({ embeds: [embed], ephemeral: options.ephemeral ?? false });
+  }
+  return interaction.reply({ embeds: [embed], ephemeral: options.ephemeral ?? false });
+}
+
+module.exports = { ChrxEmbedBuilder, EmbedTrigger };

package/core/ChrxModalBuilder.js

@@ -0,0 +1,151 @@
+/**
+ * core/ChrxModalBuilder.js
+ * Simple modal builder with built in validation and rate limiting.
+ */
+
+const {
+  ModalBuilder,
+  TextInputBuilder,
+  TextInputStyle,
+  ActionRowBuilder,
+} = require("discord.js");
+
+// ── Rate limiter ──────────────────────────────────────────────────────────
+// Tracks how many modals a user has triggered in the last minute
+const modalRateLimit = new Map(); // userId -> { count, resetAt }
+const RATE_LIMIT     = 50;        // max modals per minute per user
+
+function checkRateLimit(userId) {
+  const now  = Date.now();
+  const data = modalRateLimit.get(userId);
+
+  if (!data || now > data.resetAt) {
+    modalRateLimit.set(userId, { count: 1, resetAt: now + 60000 });
+    return true;
+  }
+
+  if (data.count >= RATE_LIMIT) return false;
+
+  data.count++;
+  return true;
+}
+
+// ── Type map ──────────────────────────────────────────────────────────────
+const STYLE_MAP = {
+  short:     TextInputStyle.Short,
+  paragraph: TextInputStyle.Paragraph,
+  long:      TextInputStyle.Paragraph, // alias
+};
+
+class ChrxModalBuilder {
+  /**
+   * @param {object} options
+   * @param {string}   options.name          Internal name (for reference)
+   * @param {string}   options.id            Modal custom ID
+   * @param {string}   options.title         Modal title (max 45 chars)
+   * @param {object[]} options.inputs        Input fields (max 5)
+   * @param {string}   options.inputs[].id       Input custom ID
+   * @param {string}   options.inputs[].label     Input label (max 100 chars)
+   * @param {string}   [options.inputs[].type]    "short" | "paragraph" (default: short)
+   * @param {boolean}  [options.inputs[].required] Required? (default: false)
+   * @param {string}   [options.inputs[].placeholder] Placeholder text
+   * @param {string}   [options.inputs[].value]   Pre-filled value
+   * @param {number}   [options.inputs[].minLength]
+   * @param {number}   [options.inputs[].maxLength]
+   */
+  constructor(options = {}) {
+    if (!options.id)     throw new Error("[ChrxModal] id is required.");
+    if (!options.title)  throw new Error("[ChrxModal] title is required.");
+    if (!options.inputs || options.inputs.length === 0) throw new Error("[ChrxModal] At least one input is required.");
+
+    // ── Validation ────────────────────────────────────────────────────────
+    if (options.title.length > 45) {
+      throw new Error(`[ChrxModal] Title exceeds 45 characters (got ${options.title.length}).`);
+    }
+    if (options.inputs.length > 5) {
+      throw new Error(`[ChrxModal] Maximum 5 inputs allowed (got ${options.inputs.length}).`);
+    }
+    for (const input of options.inputs) {
+      if (!input.id)    throw new Error("[ChrxModal] Every input must have an id.");
+      if (!input.label) throw new Error("[ChrxModal] Every input must have a label.");
+      if (input.label.length > 100) {
+        throw new Error(`[ChrxModal] Input label "${input.label}" exceeds 100 characters.`);
+      }
+    }
+
+    this._options = options;
+    this.name     = options.name ?? options.id;
+  }
+
+  /**
+   * Build and return the raw discord.js Modal.
+   * @returns {ModalBuilder}
+   */
+  build() {
+    const modal = new ModalBuilder()
+      .setCustomId(this._options.id)
+      .setTitle(this._options.title);
+
+    const rows = this._options.inputs.map((input) => {
+      const textInput = new TextInputBuilder()
+        .setCustomId(input.id)
+        .setLabel(input.label)
+        .setStyle(STYLE_MAP[input.type ?? "short"] ?? TextInputStyle.Short);
+
+      if (input.required)    textInput.setRequired(input.required);
+      if (input.placeholder) textInput.setPlaceholder(input.placeholder);
+      if (input.value)       textInput.setValue(input.value);
+      if (input.minLength)   textInput.setMinLength(input.minLength);
+      if (input.maxLength)   textInput.setMaxLength(input.maxLength);
+
+      return new ActionRowBuilder().addComponents(textInput);
+    });
+
+    modal.addComponents(...rows);
+    return modal;
+  }
+}
+
+/**
+ * ModalTrigger — shows a ChrxModalBuilder modal to the user.
+ * Handles rate limiting automatically.
+ *
+ * @param {import("discord.js").CommandInteraction} interaction
+ * @param {ChrxModalBuilder} modal
+ */
+async function ModalTrigger(interaction, modal) {
+  if (!checkRateLimit(interaction.user.id)) {
+    return interaction.reply({
+      content: "⏱ You're triggering too many modals! Slow down.",
+      ephemeral: true,
+    });
+  }
+
+  await interaction.showModal(modal.build());
+}
+
+/**
+ * onModalSubmit — listen for a modal submission by ID.
+ * @param {import("discord.js").Client} client
+ * @param {string} modalId
+ * @param {Function} handler  (interaction) => void
+ */
+function onModalSubmit(client, modalId, handler) {
+  client.on("interactionCreate", async (interaction) => {
+    if (!interaction.isModalSubmit()) return;
+    if (interaction.customId !== modalId) return;
+    try {
+      await handler(interaction);
+    } catch (err) {
+      console.error(`[ChrxModal] Error in modal "${modalId}":`, err);
+      const msg = { content: err.message || "❌ Something went wrong.", ephemeral: true };
+      if (interaction.replied || interaction.deferred) {
+        interaction.followUp(msg).catch(() => {});
+      } else {
+        interaction.reply(msg).catch(() => {});
+      }
+    }
+  });
+}
+
+module.exports = { ChrxModalBuilder, ModalTrigger, onModalSubmit };

package/core/ChrxReply.js

@@ -0,0 +1,236 @@
+/**
+ * core/ChrxReply.js
+ * Unified reply system — every Discord reply type simplified into clean triggers.
+ *
+ * Includes:
+ * - ChrxReply        → interaction.reply()
+ * - ChrxDeferReply   → interaction.deferReply()
+ * - ChrxEditReply    → interaction.editReply()
+ * - ChrxFollowUp     → interaction.followUp()
+ * - ChrxFetchReply   → interaction.fetchReply()
+ * - ChrxSilentReply  → ephemeral reply shortcut
+ * - ChrxAutoReply    → smart reply (detects state automatically)
+ * - ChrxThinkReply   → defer + slow handler + editReply
+ */
+
+// ── Helpers ───────────────────────────────────────────────────────────────
+
+/**
+ * Normalize input into a Discord reply payload.
+ * Accepts: string, EmbedBuilder, or plain payload object.
+ */
+function normalize(input, extra = {}) {
+  if (!input) return extra;
+
+  if (typeof input === "string") {
+    return { content: input, ...extra };
+  }
+
+  // EmbedBuilder instance
+  if (input?.data || input?.setTitle) {
+    return { embeds: [input], ...extra };
+  }
+
+  // Array of embeds
+  if (Array.isArray(input)) {
+    return { embeds: input, ...extra };
+  }
+
+  // Plain object payload — merge with extra
+  return { ...input, ...extra };
+}
+
+// ═════════════════════════════════════════════════════════════════════════════
+// ChrxReply — normal reply
+// ═════════════════════════════════════════════════════════════════════════════
+
+/**
+ * @param {import("discord.js").CommandInteraction} interaction
+ * @param {string|object|import("discord.js").EmbedBuilder} content
+ * @param {object} [options]
+ * @param {boolean} [options.ephemeral]
+ * @param {object[]} [options.components]
+ * @param {object[]} [options.files]
+ */
+async function ChrxReply(interaction, content, options = {}) {
+  try {
+    return await interaction.reply(normalize(content, options));
+  } catch (err) {
+    console.error("[ChrxReply] Error:", err.message);
+  }
+}
+
+// ═════════════════════════════════════════════════════════════════════════════
+// ChrxDeferReply — defer the interaction
+// ═════════════════════════════════════════════════════════════════════════════
+
+/**
+ * @param {import("discord.js").CommandInteraction} interaction
+ * @param {object} [options]
+ * @param {boolean} [options.ephemeral]
+ */
+async function ChrxDeferReply(interaction, options = {}) {
+  try {
+    if (interaction.deferred || interaction.replied) return;
+    return await interaction.deferReply({ ephemeral: options.ephemeral ?? false });
+  } catch (err) {
+    console.error("[ChrxDeferReply] Error:", err.message);
+  }
+}
+
+// ═════════════════════════════════════════════════════════════════════════════
+// ChrxEditReply — edit an existing reply
+// ═════════════════════════════════════════════════════════════════════════════
+
+/**
+ * @param {import("discord.js").CommandInteraction} interaction
+ * @param {string|object|import("discord.js").EmbedBuilder} content
+ * @param {object} [options]
+ */
+async function ChrxEditReply(interaction, content, options = {}) {
+  try {
+    // Auto defer if not already deferred or replied
+    if (!interaction.deferred && !interaction.replied) {
+      await interaction.deferReply({ ephemeral: options.ephemeral ?? false });
+    }
+    return await interaction.editReply(normalize(content, options));
+  } catch (err) {
+    console.error("[ChrxEditReply] Error:", err.message);
+  }
+}
+
+// ═════════════════════════════════════════════════════════════════════════════
+// ChrxFollowUp — follow up message
+// ═════════════════════════════════════════════════════════════════════════════
+
+/**
+ * @param {import("discord.js").CommandInteraction} interaction
+ * @param {string|object|import("discord.js").EmbedBuilder} content
+ * @param {object} [options]
+ * @param {boolean} [options.ephemeral]
+ */
+async function ChrxFollowUp(interaction, content, options = {}) {
+  try {
+    return await interaction.followUp(normalize(content, options));
+  } catch (err) {
+    console.error("[ChrxFollowUp] Error:", err.message);
+  }
+}
+
+// ═════════════════════════════════════════════════════════════════════════════
+// ChrxFetchReply — fetch the reply message object
+// ═════════════════════════════════════════════════════════════════════════════
+
+/**
+ * @param {import("discord.js").CommandInteraction} interaction
+ * @returns {Promise<import("discord.js").Message>}
+ */
+async function ChrxFetchReply(interaction) {
+  try {
+    return await interaction.fetchReply();
+  } catch (err) {
+    console.error("[ChrxFetchReply] Error:", err.message);
+    return null;
+  }
+}
+
+// ═════════════════════════════════════════════════════════════════════════════
+// ChrxSilentReply — ephemeral reply shortcut
+// ═════════════════════════════════════════════════════════════════════════════
+
+/**
+ * Always sends as ephemeral. No options needed.
+ * @param {import("discord.js").CommandInteraction} interaction
+ * @param {string|object|import("discord.js").EmbedBuilder} content
+ */
+async function ChrxSilentReply(interaction, content) {
+  try {
+    if (interaction.deferred || interaction.replied) {
+      return await interaction.followUp({ ...normalize(content), ephemeral: true });
+    }
+    return await interaction.reply({ ...normalize(content), ephemeral: true });
+  } catch (err) {
+    console.error("[ChrxSilentReply] Error:", err.message);
+  }
+}
+
+// ═════════════════════════════════════════════════════════════════════════════
+// ChrxAutoReply — smart reply, detects state automatically
+// Never throws "interaction already replied" — picks the right method every time
+// ═════════════════════════════════════════════════════════════════════════════
+
+/**
+ * @param {import("discord.js").CommandInteraction} interaction
+ * @param {string|object|import("discord.js").EmbedBuilder} content
+ * @param {object} [options]
+ * @param {boolean} [options.ephemeral]
+ */
+async function ChrxAutoReply(interaction, content, options = {}) {
+  try {
+    const payload = normalize(content, options);
+
+    if (interaction.replied) {
+      return await interaction.followUp(payload);
+    }
+
+    if (interaction.deferred) {
+      return await interaction.editReply(payload);
+    }
+
+    return await interaction.reply(payload);
+  } catch (err) {
+    console.error("[ChrxAutoReply] Error:", err.message);
+  }
+}
+
+// ═════════════════════════════════════════════════════════════════════════════
+// ChrxThinkReply — defer + slow async handler + auto editReply
+// Perfect for AI commands, database queries, anything slow
+// ═════════════════════════════════════════════════════════════════════════════
+
+/**
+ * @param {import("discord.js").CommandInteraction} interaction
+ * @param {Function} handler   Async function that returns the reply content
+ * @param {object}  [options]
+ * @param {boolean} [options.ephemeral]
+ * @param {string}  [options.errorMessage]  Custom error message on failure
+ *
+ * @example
+ * await ChrxThinkReply(interaction, async () => {
+ *   const result = await someSlowDatabaseCall();
+ *   return `Result: ${result}`;
+ * });
+ */
+async function ChrxThinkReply(interaction, handler, options = {}) {
+  try {
+    if (!interaction.deferred && !interaction.replied) {
+      await interaction.deferReply({ ephemeral: options.ephemeral ?? false });
+    }
+
+    const result = await handler();
+
+    if (!result) return;
+
+    return await interaction.editReply(normalize(result));
+  } catch (err) {
+    console.error("[ChrxThinkReply] Error:", err.message);
+    await interaction.editReply({
+      content: options.errorMessage || err.message || "❌ Something went wrong.",
+    }).catch(() => {});
+  }
+}
+
+// ═════════════════════════════════════════════════════════════════════════════
+// Exports
+// ═════════════════════════════════════════════════════════════════════════════
+
+module.exports = {
+  ChrxReply,
+  ChrxDeferReply,
+  ChrxEditReply,
+  ChrxFollowUp,
+  ChrxFetchReply,
+  ChrxSilentReply,
+  ChrxAutoReply,
+  ChrxThinkReply,
+};