@tryty/easydc-js 0.0.0-stage → 1.1.0

package/src/context.js

@@ -0,0 +1,218 @@
+'use strict';
+const { BotError } = require('./errors');
+const { splitMessage } = require('./util');
+
+const EPHEMERAL = 64; // MessageFlags.Ephemeral
+
+/**
+ * Konteks satu eksekusi kode. Diberikan ke setiap fungsi `$...` sebagai argumen pertama.
+ * Fungsi custom (bot.addFunction) juga menerima objek ini.
+ */
+class Context {
+  constructor(bot, init = {}) {
+    this.bot = bot;
+    this.client = bot.client;
+    this.kind = 'message'; // 'message' | 'slash' | 'component' | 'event'
+    this.eventName = null;
+    this.message = null;
+    this.interaction = null;
+    this.guild = null;
+    this.channel = null;
+    this.member = null;
+    this.user = null;
+    this.args = [];
+    this.rawArgs = '';
+    this.command = null;
+    this.options = new Map();
+    this.values = [];
+    this.customId = null;
+    this.reaction = null;
+    this.mentionSkipId = null;
+    this.fields = new Map(); // nilai input modal yang dikirim
+    this.target = null; // { id, name, content? } untuk context menu & event
+    this.focused = null; // { name, value, type } untuk autocomplete
+    Object.assign(this, init);
+
+    // state yang diisi oleh fungsi
+    this.temp = new Map();
+    this.embeds = [];
+    this.rows = [];
+    this.files = [];
+    this.poll = null;
+    this.modal = null;
+    this.choices = [];
+    this.ephemeral = false;
+    this.update = false;
+    this.useReply = false;
+    this.deleteCommand = false;
+    this.deleteIn = null;
+    this.sent = [];
+  }
+
+  // --- helper untuk fungsi ---------------------------------------------------
+  static cleanId(v) {
+    return String(v ?? '').trim().replace(/^<(?:@!?|@&|#)(\d+)>$/, '$1');
+  }
+
+  requireGuild() {
+    if (!this.guild) throw new BotError('Fungsi ini hanya bisa dipakai di dalam server (bukan DM)');
+    return this.guild;
+  }
+
+  async fetchUser(id) {
+    if (id === undefined || id === null || id === '') {
+      if (!this.user) throw new BotError('Tidak ada user pada konteks ini');
+      return this.user;
+    }
+    const clean = Context.cleanId(id);
+    const users = this.client.users;
+    const cached = users.cache.get(clean);
+    if (cached) return cached;
+    try {
+      return await users.fetch(clean);
+    } catch (e) {
+      throw new BotError(`User "${clean}" tidak ditemukan`, { cause: e });
+    }
+  }
+
+  async tryMember(id) {
+    if (!this.guild) return null;
+    if (id === undefined || id === null || id === '') return this.member ?? null;
+    const clean = Context.cleanId(id);
+    const cached = this.guild.members.cache.get(clean);
+    if (cached) return cached;
+    try {
+      return await this.guild.members.fetch(clean);
+    } catch {
+      return null;
+    }
+  }
+
+  async fetchMember(id) {
+    this.requireGuild();
+    const m = await this.tryMember(id);
+    if (!m) throw new BotError(`Member "${Context.cleanId(id) || '(kamu)'}" tidak ditemukan di server ini`);
+    return m;
+  }
+
+  mentionedUsers() {
+    const col = this.message?.mentions?.users;
+    const list = col && typeof col.values === 'function' ? [...col.values()] : [];
+    return this.mentionSkipId ? list.filter((u) => u.id !== this.mentionSkipId) : list;
+  }
+
+  currentEmbed() {
+    if (!this.embeds.length) this.embeds.push({});
+    return this.embeds[this.embeds.length - 1];
+  }
+
+  newEmbed() {
+    if (this.embeds.length >= 10) throw new BotError('Maksimal 10 embed per pesan');
+    if (this.embeds.length && !Object.keys(this.embeds[this.embeds.length - 1]).length) return;
+    this.embeds.push({});
+  }
+
+  // --- mengirim jawaban --------------------------------------------------------
+  _buildComponents() {
+    const out = [];
+    for (const row of this.rows) {
+      if (!row.components.length) continue;
+      if (row.kind === 'select' && row.components[0].type === 3) {
+        const menu = row.components[0];
+        if (!menu.options.length) {
+          throw new BotError(`Select menu "${menu.custom_id}" belum punya opsi (pakai $addSelectOption)`);
+        }
+        if (menu.max_values !== undefined && menu.max_values > menu.options.length) {
+          throw new BotError(`Select menu "${menu.custom_id}": max (${menu.max_values}) melebihi jumlah opsi (${menu.options.length})`);
+        }
+        if (menu.min_values !== undefined && menu.max_values !== undefined && menu.min_values > menu.max_values) {
+          throw new BotError(`Select menu "${menu.custom_id}": min lebih besar dari max`);
+        }
+      }
+      out.push({ type: 1, components: row.components });
+    }
+    return out;
+  }
+
+  async _send(payload, first) {
+    const it = this.interaction;
+    if (it) {
+      const withFlags = this.ephemeral ? { ...payload, flags: EPHEMERAL } : payload;
+      if (this.update && first && typeof it.update === 'function') return it.update(payload);
+      if (it.deferred && !it.replied) return it.editReply(payload);
+      if (it.replied || it.deferred) return it.followUp(withFlags);
+      return it.reply(withFlags);
+    }
+    if (this.kind === 'message' && this.useReply && this.message && typeof this.message.reply === 'function') {
+      return this.message.reply({ ...payload, failIfNotExists: false });
+    }
+    if (!this.channel) return null;
+    return this.channel.send(payload);
+  }
+
+  /** Kirim hasil: teks (dipecah bila > 2000 karakter) + embed + tombol. */
+  async _showModal() {
+    const it = this.interaction;
+    if (!it || typeof it.showModal !== 'function') {
+      throw new BotError('Modal hanya bisa dipakai dari slash command, tombol, atau select menu');
+    }
+    if (it.deferred || it.replied) {
+      throw new BotError('Modal harus jadi respons pertama (jangan pakai $defer atau kirim pesan sebelum modal)');
+    }
+    const m = this.modal;
+    if (!m.components.length) throw new BotError('Modal belum punya input (pakai $addTextInput)');
+    await it.showModal({ custom_id: m.custom_id, title: m.title, components: m.components });
+  }
+
+  async respond(text) {
+    if (this.modal) return this._showModal();
+    const chunks = splitMessage(text);
+    const embeds = this.embeds.filter((e) => Object.keys(e).length > 0);
+    const components = this._buildComponents();
+    const hasExtra = this.files.length > 0 || this.poll !== null;
+    if (!chunks.length && !embeds.length && !components.length && !hasExtra) return;
+    if (!chunks.length && !embeds.length && !hasExtra) {
+      throw new BotError('Tombol/select menu butuh teks atau embed di pesan yang sama');
+    }
+    if (!chunks.length) chunks.push(undefined);
+    for (let i = 0; i < chunks.length; i++) {
+      const last = i === chunks.length - 1;
+      const payload = { allowedMentions: this.bot.options.allowedMentions };
+      if (chunks[i]) payload.content = chunks[i];
+      if (last && embeds.length) payload.embeds = embeds;
+      if (last && components.length) payload.components = components;
+      if (last && this.files.length) payload.files = this.files;
+      if (last && this.poll) payload.poll = this.poll;
+      const sent = await this._send(payload, i === 0);
+      this.sent.push(sent);
+    }
+  }
+
+  /** Kirim teks polos saja (dipakai untuk pesan $stop/$onlyIf/error). */
+  async sendPlain(text) {
+    const chunks = splitMessage(text);
+    for (let i = 0; i < chunks.length; i++) {
+      await this._send({ content: chunks[i], allowedMentions: this.bot.options.allowedMentions }, i === 0);
+    }
+  }
+
+  /** Pekerjaan setelah pesan terkirim: $deleteIn dan $deleteCommand. */
+  async finish() {
+    const swallow = () => {};
+    if (this.deleteIn !== null) {
+      const ms = this.deleteIn;
+      if (this.interaction) {
+        setTimeout(() => this.interaction.deleteReply?.().catch(swallow), ms);
+      } else {
+        for (const m of this.sent) {
+          if (m && typeof m.delete === 'function') setTimeout(() => m.delete().catch(swallow), ms);
+        }
+      }
+    }
+    if (this.deleteCommand && this.message && typeof this.message.delete === 'function') {
+      await this.message.delete().catch(swallow);
+    }
+  }
+}
+
+module.exports = { Context };

package/src/database.js

@@ -0,0 +1,73 @@
+'use strict';
+const fs = require('node:fs');
+const path = require('node:path');
+
+/**
+ * Database key-value sederhana (disimpan sebagai file JSON).
+ * - `memory: true` -> hanya di RAM (hilang saat bot mati).
+ * - Penulisan ditunda sebentar lalu ditulis atomik (file sementara + rename).
+ * - File rusak tidak dihapus: dipindah ke *.corrupt-<waktu> lalu mulai kosong.
+ */
+class Database {
+  constructor({ path: file = './easydc-data.json', memory = false, saveDelay = 200 } = {}) {
+    this.file = memory ? null : path.resolve(file);
+    this.saveDelay = saveDelay;
+    this.data = new Map();
+    this._timer = null;
+    if (this.file) this._load();
+  }
+
+  _load() {
+    fs.mkdirSync(path.dirname(this.file), { recursive: true });
+    if (!fs.existsSync(this.file)) return;
+    const raw = fs.readFileSync(this.file, 'utf8');
+    if (!raw.trim()) return;
+    try {
+      const obj = JSON.parse(raw);
+      if (obj === null || typeof obj !== 'object' || Array.isArray(obj)) throw new Error('isi file bukan object');
+      for (const [k, v] of Object.entries(obj)) this.data.set(k, v);
+    } catch (e) {
+      const backup = `${this.file}.corrupt-${Date.now()}`;
+      fs.renameSync(this.file, backup);
+      console.warn(`[easydc] File database rusak (${e.message}). Disalin ke ${backup}, memulai database kosong.`);
+    }
+  }
+
+  get(key) { return this.data.get(key); }
+  has(key) { return this.data.has(key); }
+
+  set(key, value) {
+    this.data.set(key, value);
+    this._schedule();
+  }
+
+  delete(key) {
+    const existed = this.data.delete(key);
+    this._schedule();
+    return existed;
+  }
+
+  keys(prefix = '') {
+    return [...this.data.keys()].filter((k) => k.startsWith(prefix));
+  }
+
+  _schedule() {
+    if (!this.file || this._timer) return;
+    this._timer = setTimeout(() => {
+      this._timer = null;
+      try { this.flush(); } catch (e) { console.error('[easydc] Gagal menyimpan database:', e.message); }
+    }, this.saveDelay);
+    if (this._timer.unref) this._timer.unref();
+  }
+
+  /** Tulis ke disk sekarang juga (sinkron). */
+  flush() {
+    if (!this.file) return;
+    if (this._timer) { clearTimeout(this._timer); this._timer = null; }
+    const tmp = `${this.file}.tmp`;
+    fs.writeFileSync(tmp, JSON.stringify(Object.fromEntries(this.data)));
+    fs.renameSync(tmp, this.file);
+  }
+}
+
+module.exports = { Database };

package/src/errors.js

@@ -0,0 +1,38 @@
+'use strict';
+
+/** Error umum milik package ini. */
+class BotError extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = 'EasyDCError';
+  }
+}
+
+/** Error saat membaca kode `$fungsi[...]` (ada posisi baris/kolom). */
+class ParseError extends BotError {
+  constructor(message, { line, col } = {}) {
+    super(line ? `${message} (baris ${line}, kolom ${col})` : message);
+    this.name = 'EasyDCParseError';
+    this.line = line;
+    this.col = col;
+  }
+}
+
+/** Dikumpulkan dari semua command yang kodenya salah (dilempar sebelum bot login). */
+class ValidationError extends BotError {
+  constructor(problems) {
+    super(`Ditemukan ${problems.length} masalah pada kode:\n - ${problems.join('\n - ')}`);
+    this.name = 'EasyDCValidationError';
+    this.problems = problems;
+  }
+}
+
+/** Sinyal internal untuk menghentikan eksekusi ($stop, $onlyIf, $cooldown, ...). */
+class Stop extends Error {
+  constructor(message = '') {
+    super(message);
+    this.name = 'EasyDCStop';
+  }
+}
+
+module.exports = { BotError, ParseError, ValidationError, Stop };

package/src/functions/actions.js

@@ -0,0 +1,103 @@
+'use strict';
+const { BotError } = require('../errors');
+const { parseTime, splitMessage } = require('../util');
+const { f, has, cleanId, num, fetchChannel: getChannel } = require('./helpers');
+
+const MAX_TIMEOUT = 28 * 24 * 60 * 60 * 1000;
+
+// PERHATIAN: fungsi di file ini melakukan aksi memakai izin BOT, bukan izin pengirim.
+// Selalu lindungi command dengan $onlyPerms[...] / $onlyAdmin / $onlyOwner.
+module.exports = [
+  f('sendMessage', { b: 'required', min: 2, max: 2, s: '[channelID;teks]', d: 'Kirim pesan ke channel lain' },
+    async (ctx, [id, text]) => {
+      const ch = await getChannel(ctx, id);
+      if (typeof ch.send !== 'function') throw new BotError('Channel itu bukan channel teks');
+      for (const chunk of splitMessage(text)) {
+        await ch.send({ content: chunk, allowedMentions: ctx.bot.options.allowedMentions });
+      }
+      return '';
+    }),
+  f('sendDM', { b: 'required', min: 2, max: 2, s: '[userID;teks]', d: 'Kirim DM ke user' },
+    async (ctx, [id, text]) => {
+      const user = await ctx.fetchUser(id);
+      try {
+        for (const chunk of splitMessage(text)) {
+          await user.send({ content: chunk, allowedMentions: ctx.bot.options.allowedMentions });
+        }
+      } catch (e) {
+        throw new BotError('Tidak bisa mengirim DM (kemungkinan DM user tertutup)', { cause: e });
+      }
+      return '';
+    }),
+  f('react', { b: 'required', min: 1, s: '[emoji1;emoji2;...]', d: 'Beri reaksi pada pesan perintah' },
+    async (ctx, emojis) => {
+      if (!ctx.message || typeof ctx.message.react !== 'function') throw new BotError('$react hanya bisa dipakai pada command pesan');
+      for (const e of emojis) await ctx.message.react(e.trim());
+      return '';
+    }),
+  f('ban', { b: 'required', min: 1, max: 3, s: '[userID;alasan?;hariHapusPesan?]', d: 'Ban user (hapus pesan 0-7 hari)' },
+    async (ctx, [id, reason, days]) => {
+      const guild = ctx.requireGuild();
+      const d = has(days) ? num(days, 'hari', { min: 0, max: 7, int: true }) : 0;
+      await guild.members.ban(cleanId(id), { reason: has(reason) ? reason : undefined, deleteMessageSeconds: d * 86400 });
+      return '';
+    }),
+  f('kick', { b: 'required', min: 1, max: 2, s: '[userID;alasan?]', d: 'Kick member' },
+    async (ctx, [id, reason]) => {
+      const m = await ctx.fetchMember(id);
+      await m.kick(has(reason) ? reason : undefined);
+      return '';
+    }),
+  f('timeout', { b: 'required', min: 2, max: 3, s: '[userID;waktu;alasan?]', d: 'Timeout member (maks 28 hari)' },
+    async (ctx, [id, time, reason]) => {
+      const ms = parseTime(time);
+      if (ms < 1000 || ms > MAX_TIMEOUT) throw new BotError('Durasi timeout harus antara 1 detik dan 28 hari');
+      const m = await ctx.fetchMember(id);
+      await m.timeout(ms, has(reason) ? reason : undefined);
+      return '';
+    }),
+  f('untimeout', { b: 'required', min: 1, max: 2, s: '[userID;alasan?]', d: 'Cabut timeout member' },
+    async (ctx, [id, reason]) => {
+      const m = await ctx.fetchMember(id);
+      await m.timeout(null, has(reason) ? reason : undefined);
+      return '';
+    }),
+  f('addRole', { b: 'required', min: 2, max: 3, s: '[userID;roleID;alasan?]', d: 'Beri role' },
+    async (ctx, [id, roleId, reason]) => {
+      const guild = ctx.requireGuild();
+      const rid = cleanId(roleId);
+      if (!guild.roles.cache.get(rid)) throw new BotError(`Role "${rid}" tidak ditemukan`);
+      const m = await ctx.fetchMember(id);
+      await m.roles.add(rid, has(reason) ? reason : undefined);
+      return '';
+    }),
+  f('removeRole', { b: 'required', min: 2, max: 3, s: '[userID;roleID;alasan?]', d: 'Cabut role' },
+    async (ctx, [id, roleId, reason]) => {
+      const guild = ctx.requireGuild();
+      const rid = cleanId(roleId);
+      if (!guild.roles.cache.get(rid)) throw new BotError(`Role "${rid}" tidak ditemukan`);
+      const m = await ctx.fetchMember(id);
+      await m.roles.remove(rid, has(reason) ? reason : undefined);
+      return '';
+    }),
+  f('setNickname', { b: 'required', min: 2, max: 2, s: '[userID;nickname]', d: 'Ubah nickname (kosongkan untuk reset)' },
+    async (ctx, [id, nick]) => {
+      const m = await ctx.fetchMember(id);
+      await m.setNickname(nick.trim() === '' ? null : nick);
+      return '';
+    }),
+  f('clear', { b: 'required', min: 1, max: 1, s: '[jumlah]', d: 'Hapus 1-100 pesan terakhir (maks umur 14 hari). Mengembalikan jumlah terhapus' },
+    async (ctx, [n]) => {
+      const amount = num(n, 'jumlah', { min: 1, max: 100, int: true });
+      if (!ctx.channel || typeof ctx.channel.bulkDelete !== 'function') throw new BotError('$clear hanya bisa dipakai di channel teks server');
+      const deleted = await ctx.channel.bulkDelete(amount, true);
+      return String(deleted.size ?? 0);
+    }),
+  f('slowmode', { b: 'required', min: 1, max: 1, s: '[detik]', d: 'Atur slowmode channel (0 = mati, maks 21600)' },
+    async (ctx, [n]) => {
+      const secs = num(n, 'detik', { min: 0, max: 21600, int: true });
+      if (!ctx.channel || typeof ctx.channel.setRateLimitPerUser !== 'function') throw new BotError('$slowmode hanya bisa dipakai di channel teks server');
+      await ctx.channel.setRateLimitPerUser(secs);
+      return '';
+    }),
+];

package/src/functions/components.js

@@ -0,0 +1,108 @@
+'use strict';
+const { BotError } = require('../errors');
+const { f, has, truthy, num, url, limit } = require('./helpers');
+
+const STYLES = { primary: 1, secondary: 2, success: 3, danger: 4, link: 5 };
+
+function parseEmoji(v) {
+  const m = /^<(a?):(\w+):(\d+)>$/.exec(v.trim());
+  return m ? { id: m[3], name: m[2], animated: m[1] === 'a' } : { name: v.trim() };
+}
+
+function newRow(ctx, kind) {
+  if (ctx.rows.length >= 5) throw new BotError('Maksimal 5 baris tombol/select per pesan');
+  const row = { kind, components: [] };
+  ctx.rows.push(row);
+  return row;
+}
+
+/** Pakai baris terakhir bila masih kosong, kalau tidak buat baris baru. */
+function freshRow(ctx, kind) {
+  const last = ctx.rows[ctx.rows.length - 1];
+  if (last && last.components.length === 0) { last.kind = kind; return last; }
+  return newRow(ctx, kind);
+}
+
+function buttonRow(ctx) {
+  const last = ctx.rows[ctx.rows.length - 1];
+  if (last && last.kind === 'buttons' && last.components.length < 5) return last;
+  return newRow(ctx, 'buttons');
+}
+
+const CHANNEL_TYPES = { text: 0, voice: 2, category: 4, announcement: 5, stage: 13, forum: 15 };
+
+function entitySelect(name, type, label, extra) {
+  return f(name, {
+    b: 'required', min: 1, max: extra ? 5 : 4,
+    s: `[customID;placeholder?;min?;max?${extra ? ';tipe?' : ''}]`,
+    d: `Select menu pilih ${label} (nilai terpilih lewat $interactionValues)${extra ? '. Tipe: text voice category announcement stage forum, pisah koma' : ''}`,
+  }, (ctx, [id, placeholder, min, max, types]) => {
+    if (!id.trim()) throw new BotError('customID select menu tidak boleh kosong');
+    const menu = { type, custom_id: limit('customID', id.trim(), 100) };
+    if (has(placeholder)) menu.placeholder = limit('placeholder', placeholder, 150);
+    if (has(min)) menu.min_values = num(min, 'min', { min: 0, max: 25, int: true });
+    if (has(max)) menu.max_values = num(max, 'max', { min: 1, max: 25, int: true });
+    if (menu.min_values !== undefined && menu.max_values !== undefined && menu.min_values > menu.max_values) {
+      throw new BotError('min tidak boleh lebih besar dari max');
+    }
+    if (extra && has(types)) {
+      menu.channel_types = types.split(',').map((t) => t.trim().toLowerCase()).filter(Boolean).map((t) => {
+        if (!Object.hasOwn(CHANNEL_TYPES, t)) throw new BotError(`Tipe channel "${t}" tidak valid (${Object.keys(CHANNEL_TYPES).join(', ')})`);
+        return CHANNEL_TYPES[t];
+      });
+    }
+    freshRow(ctx, 'select').components.push(menu);
+    return '';
+  });
+}
+
+module.exports = [
+  entitySelect('addUserSelect', 5, 'user', false),
+  entitySelect('addRoleSelect', 6, 'role', false),
+  entitySelect('addMentionableSelect', 7, 'user atau role', false),
+  entitySelect('addChannelSelect', 8, 'channel', true),
+  f('newRow', { b: 'none', d: 'Mulai baris tombol baru (otomatis tiap 5 tombol)' },
+    (ctx) => { freshRow(ctx, 'buttons'); return ''; }),
+  f('addButton', { b: 'required', min: 3, max: 5, s: '[label;gaya;customID/URL;nonaktif?;emoji?]', d: 'Tambah tombol. Gaya: primary secondary success danger link' },
+    (ctx, [label, style, target, disabled, emoji]) => {
+      const key = style.trim().toLowerCase();
+      if (!Object.hasOwn(STYLES, key)) throw new BotError(`Gaya tombol "${style}" tidak valid (primary, secondary, success, danger, link)`);
+      if (!label.trim() && !has(emoji)) throw new BotError('Tombol butuh label atau emoji');
+      const btn = { type: 2, style: STYLES[key] };
+      if (label.trim()) btn.label = limit('label tombol', label.trim(), 80);
+      if (key === 'link') btn.url = url(target, 'URL tombol');
+      else {
+        if (!target.trim()) throw new BotError('customID tombol tidak boleh kosong');
+        btn.custom_id = limit('customID', target.trim(), 100);
+      }
+      if (has(disabled) && truthy(disabled)) btn.disabled = true;
+      if (has(emoji)) btn.emoji = parseEmoji(emoji);
+      buttonRow(ctx).components.push(btn);
+      return '';
+    }),
+  f('addSelectMenu', { b: 'required', min: 1, max: 4, s: '[customID;placeholder?;min?;max?]', d: 'Buat select menu (lanjutkan dengan $addSelectOption)' },
+    (ctx, [id, placeholder, min, max]) => {
+      if (!id.trim()) throw new BotError('customID select menu tidak boleh kosong');
+      const menu = { type: 3, custom_id: limit('customID', id.trim(), 100), options: [] };
+      if (has(placeholder)) menu.placeholder = limit('placeholder', placeholder, 150);
+      if (has(min)) menu.min_values = num(min, 'min', { min: 0, max: 25, int: true });
+      if (has(max)) menu.max_values = num(max, 'max', { min: 1, max: 25, int: true });
+      freshRow(ctx, 'select').components.push(menu);
+      return '';
+    }),
+  f('addSelectOption', { b: 'required', min: 2, max: 5, s: '[label;nilai;deskripsi?;emoji?;default?]', d: 'Tambah opsi ke select menu terakhir (maks 25)' },
+    (ctx, [label, value, description, emoji, def]) => {
+      const row = ctx.rows[ctx.rows.length - 1];
+      if (!row || row.kind !== 'select') throw new BotError('Pakai $addSelectMenu dulu sebelum $addSelectOption');
+      const menu = row.components[0];
+      if (menu.type !== 3) throw new BotError('$addSelectOption hanya untuk select menu teks ($addSelectMenu)');
+      if (menu.options.length >= 25) throw new BotError('Maksimal 25 opsi per select menu');
+      if (!label.trim() || !value.trim()) throw new BotError('Label dan nilai opsi tidak boleh kosong');
+      const opt = { label: limit('label opsi', label.trim(), 100), value: limit('nilai opsi', value.trim(), 100) };
+      if (has(description)) opt.description = limit('deskripsi opsi', description, 100);
+      if (has(emoji)) opt.emoji = parseEmoji(emoji);
+      if (has(def) && truthy(def)) opt.default = true;
+      menu.options.push(opt);
+      return '';
+    }),
+];