@tryty/easydc-js 0.0.0-stage → 1.1.0

package/src/parser.js

@@ -0,0 +1,168 @@
+'use strict';
+const { ParseError } = require('./errors');
+
+// Karakter yang bisa di-escape dengan backslash: \$ \[ \] \; \\
+const ESCAPABLE = '$[];\\';
+const IDENT = /[A-Za-z][A-Za-z0-9_]*/y;
+const BLOCK = new Set(['if', 'elseif', 'else', 'endif']);
+
+function lineCol(root, pos) {
+  let line = 1;
+  let col = 1;
+  for (let i = 0; i < pos && i < root.length; i++) {
+    if (root[i] === '\n') { line++; col = 1; } else col++;
+  }
+  return { line, col };
+}
+
+function fail(message, pos, state) {
+  return new ParseError(message, lineCol(state.root, pos));
+}
+
+/** Cari "]" penutup yang cocok untuk "[" di indeks `open` (menghormati escape & nesting). */
+function findClose(src, open) {
+  let depth = 0;
+  for (let i = open; i < src.length; i++) {
+    const c = src[i];
+    if (c === '\\') { i++; continue; }
+    if (c === '[') depth++;
+    else if (c === ']') {
+      depth--;
+      if (depth === 0) return i;
+    }
+  }
+  return -1;
+}
+
+/** Pecah isi kurung dengan ";" level-0 lalu parse tiap argumen. */
+function splitArgs(inner, base, state) {
+  if (inner === '') return [];
+  const ranges = [];
+  let depth = 0;
+  let start = 0;
+  for (let i = 0; i < inner.length; i++) {
+    const c = inner[i];
+    if (c === '\\') { i++; continue; }
+    if (c === '[') depth++;
+    else if (c === ']') depth--;
+    else if (c === ';' && depth === 0) { ranges.push([start, i]); start = i + 1; }
+  }
+  ranges.push([start, inner.length]);
+  return ranges.map(([s, e]) => structure(parseFlat(inner.slice(s, e), base + s, state), state));
+}
+
+function describeArity(def) {
+  if (def.min === def.max) return `tepat ${def.min}`;
+  if (def.max === Infinity) return `minimal ${def.min}`;
+  return `${def.min}-${def.max}`;
+}
+
+/** Tahap 1: teks + pemanggilan fungsi (belum ada struktur $if). */
+function parseFlat(src, base, state) {
+  const nodes = [];
+  let text = '';
+  const flush = () => {
+    if (text) { nodes.push({ type: 'text', value: text }); text = ''; }
+  };
+  let i = 0;
+  while (i < src.length) {
+    const ch = src[i];
+    if (ch === '\\' && i + 1 < src.length && ESCAPABLE.includes(src[i + 1])) {
+      text += src[i + 1];
+      i += 2;
+      continue;
+    }
+    if (ch !== '$') { text += ch; i++; continue; }
+
+    IDENT.lastIndex = i + 1;
+    const m = IDENT.exec(src);
+    if (!m) { text += '$'; i++; continue; } // "$5", "$" sendirian = teks biasa
+
+    const ident = m[0];
+    let len = 0;
+    for (let l = ident.length; l >= 1; l--) {
+      if (state.registry.has(ident.slice(0, l).toLowerCase())) { len = l; break; }
+    }
+    if (!len) {
+      throw fail(`Fungsi $${ident} tidak dikenal (kalau maksudnya teks biasa, tulis \\$${ident})`, base + i, state);
+    }
+    const def = state.registry.get(ident.slice(0, len).toLowerCase());
+    let j = i + 1 + len;
+    let args = null;
+    if (src[j] === '[' && def.brackets !== 'none') {
+      const close = findClose(src, j);
+      if (close === -1) throw fail(`Tanda ] penutup untuk ${def.display} tidak ditemukan`, base + i, state);
+      args = splitArgs(src.slice(j + 1, close), base + j + 1, state);
+      j = close + 1;
+    }
+    if (def.brackets === 'required' && args === null) {
+      throw fail(`${def.display} wajib memakai tanda kurung, contoh: ${def.display}[...]`, base + i, state);
+    }
+    const n = args ? args.length : 0;
+    if (n < def.min || n > def.max) {
+      throw fail(`${def.display} membutuhkan ${describeArity(def)} argumen, tetapi diberi ${n}`, base + i, state);
+    }
+    flush();
+    nodes.push({ type: 'fn', name: def.name, def, args, pos: base + i });
+    if (BLOCK.has(def.name)) {
+      if (src[j] === '\r' && src[j + 1] === '\n') j += 2;
+      else if (src[j] === '\n') j += 1;
+    }
+    i = j;
+  }
+  flush();
+  return nodes;
+}
+
+/** Tahap 2: ubah $if/$elseif/$else/$endif menjadi node blok. */
+function structure(nodes, state) {
+  const root = { kind: 'root', body: [] };
+  const stack = [root];
+  const top = () => stack[stack.length - 1];
+
+  for (const node of nodes) {
+    if (node.type !== 'fn' || !BLOCK.has(node.def.name)) { top().body.push(node); continue; }
+    const name = node.def.name;
+    if (name === 'if') {
+      const frame = { kind: 'if', pos: node.pos, branches: [], body: null, sawElse: false };
+      const branch = { cond: node.args[0], body: [] };
+      frame.branches.push(branch);
+      frame.body = branch.body;
+      stack.push(frame);
+      continue;
+    }
+    const frame = top();
+    if (frame.kind !== 'if') throw fail(`${node.def.display} tanpa $if di depannya`, node.pos, state);
+    if (name === 'elseif') {
+      if (frame.sawElse) throw fail('$elseif tidak boleh setelah $else', node.pos, state);
+      const branch = { cond: node.args[0], body: [] };
+      frame.branches.push(branch);
+      frame.body = branch.body;
+    } else if (name === 'else') {
+      if (frame.sawElse) throw fail('$else tidak boleh dipakai dua kali dalam satu $if', node.pos, state);
+      frame.sawElse = true;
+      const branch = { cond: null, body: [] };
+      frame.branches.push(branch);
+      frame.body = branch.body;
+    } else {
+      stack.pop();
+      top().body.push({ type: 'if', branches: frame.branches, pos: frame.pos });
+    }
+  }
+  if (stack.length > 1) {
+    throw fail('$if tidak ditutup, tambahkan $endif', top().pos, state);
+  }
+  return root.body;
+}
+
+/**
+ * Parse kode menjadi AST. `registry` = Map(namaLowercase -> definisi fungsi).
+ * Melempar ParseError (dengan baris/kolom) bila ada kesalahan.
+ */
+function parse(code, registry) {
+  const src = String(code ?? '');
+  const state = { root: src, registry };
+  return structure(parseFlat(src, 0, state), state);
+}
+
+module.exports = { parse };

package/src/util.js

@@ -0,0 +1,188 @@
+'use strict';
+const { BotError } = require('./errors');
+
+const UNITS = { ms: 1, s: 1000, m: 60000, h: 3600000, d: 86400000, w: 604800000 };
+
+/** "10s", "5m", "1h30m", "1500" (ms) -> milidetik. */
+function parseTime(input) {
+  const s = String(input ?? '').trim().toLowerCase().replace(/\s+/g, '');
+  if (!s) throw new BotError('Waktu kosong (contoh: 10s, 5m, 1h30m)');
+  if (/^\d+$/.test(s)) return Number(s);
+  const re = /(\d+(?:\.\d+)?)(ms|s|m|h|d|w)/y;
+  let total = 0;
+  let idx = 0;
+  while (idx < s.length) {
+    re.lastIndex = idx;
+    const m = re.exec(s);
+    if (!m) throw new BotError(`Format waktu salah: "${input}" (contoh: 10s, 5m, 1h30m)`);
+    total += Number(m[1]) * UNITS[m[2]];
+    idx = re.lastIndex;
+  }
+  return Math.round(total);
+}
+
+/** ms -> "1d 2h 3m 4s". */
+function formatDuration(ms) {
+  let s = Math.floor(Math.max(0, Number(ms) || 0) / 1000);
+  const d = Math.floor(s / 86400);
+  s -= d * 86400;
+  const h = Math.floor(s / 3600);
+  s -= h * 3600;
+  const m = Math.floor(s / 60);
+  s -= m * 60;
+  const parts = [];
+  if (d) parts.push(`${d}d`);
+  if (h) parts.push(`${h}h`);
+  if (m) parts.push(`${m}m`);
+  if (s || !parts.length) parts.push(`${s}s`);
+  return parts.join(' ');
+}
+
+/** Format angka hasil hitungan tanpa noise floating point. */
+function formatNumber(n) {
+  if (!Number.isFinite(n)) throw new BotError('Hasil hitungan bukan angka yang valid');
+  if (Number.isInteger(n)) return String(n);
+  return String(parseFloat(n.toPrecision(12)));
+}
+
+/** Kalkulator aman (tanpa eval). Mendukung + - * / % ^ ( ) dan fungsi umum. */
+function safeMath(expr) {
+  const src = String(expr ?? '').toLowerCase().replace(/\s+/g, '').replace(/\*\*/g, '^');
+  if (!src) throw new BotError('Ekspresi matematika kosong');
+  const FUNCS = {
+    sqrt: Math.sqrt, abs: Math.abs, round: Math.round, floor: Math.floor, ceil: Math.ceil,
+    trunc: Math.trunc, sign: Math.sign, log: Math.log, log10: Math.log10, min: Math.min,
+    max: Math.max, pow: Math.pow,
+  };
+  const CONSTS = { pi: Math.PI, e: Math.E };
+  let i = 0;
+
+  const fail = (msg) => { throw new BotError(`${msg} pada "${expr}"`); };
+  const peek = () => src[i];
+
+  function parseExpr() {
+    let v = parseTerm();
+    while (peek() === '+' || peek() === '-') {
+      const op = src[i++];
+      const r = parseTerm();
+      v = op === '+' ? v + r : v - r;
+    }
+    return v;
+  }
+  function parseTerm() {
+    let v = parseUnary();
+    while (peek() === '*' || peek() === '/' || peek() === '%') {
+      const op = src[i++];
+      const r = parseUnary();
+      if (op === '*') v *= r;
+      else {
+        if (r === 0) throw new BotError('Pembagian dengan nol');
+        v = op === '/' ? v / r : v % r;
+      }
+    }
+    return v;
+  }
+  function parseUnary() {
+    if (peek() === '-') { i++; return -parseUnary(); }
+    if (peek() === '+') { i++; return parseUnary(); }
+    return parsePow();
+  }
+  function parsePow() {
+    const base = parsePrimary();
+    if (peek() === '^') {
+      i++;
+      return Math.pow(base, parseUnary());
+    }
+    return base;
+  }
+  function parsePrimary() {
+    if (peek() === '(') {
+      i++;
+      const v = parseExpr();
+      if (peek() !== ')') fail('Kurung tutup ")" hilang');
+      i++;
+      return v;
+    }
+    const numRe = /\d+(?:\.\d+)?|\.\d+/y;
+    numRe.lastIndex = i;
+    const nm = numRe.exec(src);
+    if (nm) { i = numRe.lastIndex; return Number(nm[0]); }
+    const idRe = /[a-z_][a-z0-9_]*/y;
+    idRe.lastIndex = i;
+    const im = idRe.exec(src);
+    if (im) {
+      i = idRe.lastIndex;
+      const name = im[0];
+      if (peek() === '(') {
+        if (!Object.hasOwn(FUNCS, name)) fail(`Fungsi "${name}" tidak dikenal`);
+        i++;
+        const args = [];
+        if (peek() !== ')') {
+          args.push(parseExpr());
+          while (peek() === ',') { i++; args.push(parseExpr()); }
+        }
+        if (peek() !== ')') fail('Kurung tutup ")" hilang');
+        i++;
+        return FUNCS[name](...args);
+      }
+      if (Object.hasOwn(CONSTS, name)) return CONSTS[name];
+      fail(`"${name}" tidak dikenal`);
+    }
+    return fail(i >= src.length ? 'Ekspresi tidak lengkap' : `Karakter "${src[i]}" tidak valid`);
+  }
+
+  const result = parseExpr();
+  if (i < src.length) fail(`Karakter "${src[i]}" tidak valid`);
+  return result;
+}
+
+/** Pecah teks panjang jadi potongan <= limit (Discord: 2000). */
+function splitMessage(text, limit = 2000) {
+  const s = String(text ?? '');
+  if (!s.trim()) return [];
+  if (s.length <= limit) return [s];
+  const chunks = [];
+  let current = '';
+  const push = () => { if (current) { chunks.push(current); current = ''; } };
+  for (const line of s.split('\n')) {
+    let rest = line;
+    while (rest.length > limit) {
+      push();
+      chunks.push(rest.slice(0, limit));
+      rest = rest.slice(limit);
+    }
+    const candidate = current ? `${current}\n${rest}` : rest;
+    if (candidate.length > limit) { push(); current = rest; } else current = candidate;
+  }
+  push();
+  return chunks;
+}
+
+/** Format tanggal sederhana: token YYYY MM DD HH mm ss pada zona waktu tertentu. */
+function formatDate(ms, format, timeZone) {
+  let parts;
+  try {
+    parts = new Intl.DateTimeFormat('en-CA', {
+      timeZone, year: 'numeric', month: '2-digit', day: '2-digit',
+      hour: '2-digit', minute: '2-digit', second: '2-digit', hourCycle: 'h23',
+    }).formatToParts(new Date(ms));
+  } catch (e) {
+    throw new BotError(`Zona waktu "${timeZone}" tidak valid atau tanggal salah`, { cause: e });
+  }
+  const map = {};
+  for (const p of parts) map[p.type] = p.value;
+  const tokens = { YYYY: map.year, MM: map.month, DD: map.day, HH: map.hour, mm: map.minute, ss: map.second };
+  return String(format).replace(/YYYY|MM|DD|HH|mm|ss/g, (t) => tokens[t]);
+}
+
+/** 1234567 -> "1.234.567" (pemisah bisa diganti). */
+function numberSeparator(value, sep = ',') {
+  const s = String(value).trim();
+  if (!/^-?\d+(\.\d+)?$/.test(s)) throw new BotError(`"${s}" bukan angka`);
+  const neg = s.startsWith('-');
+  const [int, dec] = s.replace('-', '').split('.');
+  const grouped = int.replace(/\B(?=(\d{3})+(?!\d))/g, sep);
+  return `${neg ? '-' : ''}${grouped}${dec ? `.${dec}` : ''}`;
+}
+
+module.exports = { parseTime, formatDuration, formatNumber, safeMath, splitMessage, formatDate, numberSeparator };