@xbibzlibrary/telebibz 0.4.4 → 3.0.1

package/lib/ratelimit.js

@@ -0,0 +1,61 @@
+// lib/ratelimit.js — auto-retry 429, throttler antre, dan batas laju per-user.
+'use strict';
+
+const dbg = require('debug')('telebibz:ratelimit');
+
+/** Transformer 429: hormati retry_after Telegram (maks maxRetry kali).
+ *  Pasang: bot.api.config.use(autoRetry()) */
+function autoRetry({ maxRetry = 5, baseDelayMs = 500 } = {}) {
+  return async (prev, method, payload) => {
+    let attempt = 0;
+    for (;;) {
+      try { return await prev(method, payload); }
+      catch (err) {
+        const ra = err && err.parameters && err.parameters.retry_after;
+        if (ra !== undefined && attempt < maxRetry) {
+          attempt++;
+          const wait = ra * 1000 + baseDelayMs * attempt;
+          dbg('429 pada %s — tidur %dms (attempt %d)', method, wait, attempt);
+          await new Promise((r) => setTimeout(r, wait));
+          continue;
+        }
+        throw err;
+      }
+    }
+  };
+}
+
+/** Transformer antrean: jaga maks `perSecond` panggilan API global.
+ *  Pasang: bot.api.config.use(throttler()) */
+function throttler({ perSecond = 28 } = {}) {
+  const interval = 1000 / perSecond;
+  let last = 0; let chain = Promise.resolve();
+  return (prev, method, payload) => {
+    chain = chain.then(async () => {
+      const wait = last + interval - Date.now();
+      if (wait > 0) await new Promise((r) => setTimeout(r, wait));
+      last = Date.now();
+      return prev(method, payload);
+    });
+    return chain;
+  };
+}
+
+/** Middleware anti-spam: maks `limit` update per user per `windowMs`. */
+function limiter({ windowMs = 2000, limit = 3, onExceeded } = {}) {
+  const bucket = new Map();
+  return async (ctx, next) => {
+    const key = ctx.from ? ctx.from.id : (ctx.chatId || '?');
+    const now = Date.now();
+    const arr = bucket.get(key) || [];
+    const alive = arr.filter((t) => now - t < windowMs);
+    if (alive.length >= limit) {
+      if (onExceeded) return onExceeded(ctx);
+      return; // diamkan spam
+    }
+    alive.push(now); bucket.set(key, alive);
+    return next();
+  };
+}
+
+module.exports = { autoRetry, throttler, limiter };

package/lib/runner.js

@@ -0,0 +1,45 @@
+// lib/runner.js — long polling tahan banting (retry 409 & jaringan, backoff halus).
+'use strict';
+
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+
+/**
+ * Loop getUpdates; memanggil handleUpdate per update.
+ *   stop() mengamaninya keluar loop dengan bersih.
+ * Perilaku:
+ *  - error jaringan (fetch gagal)      → retry 1 dtk
+ *  - 409 (instance lain masih polling) → log callback onConflict + retry 5 dtk
+ *  - error API lain                    → oper ke onFatal (default: berhenti bersih)
+ */
+async function pollLoop({ api, handleUpdate, allowedUpdates, dropPending, onConflict, onFatal, shouldStop, conflictDelay = 5000 }) {
+  let offset = 0;
+  if (dropPending) {
+    try {
+      const u = await api.callApi('getUpdates', { offset: -1, timeout: 0, allowed_updates: allowedUpdates });
+      if (u.length) offset = u[u.length - 1].update_id + 1;
+    } catch { /* abaikan — loop utama yang menangani */ }
+  }
+
+  while (!shouldStop()) {
+    let updates;
+    try {
+      updates = await api.callApi('getUpdates', { offset, timeout: 25, allowed_updates: allowedUpdates });
+      if (!Array.isArray(updates)) updates = [];
+    } catch (err) {
+      const code = err && (err.error_code || err.code);
+      if (shouldStop()) break;
+      if (code === 409) { if (onConflict) onConflict(err); await sleep(conflictDelay); continue; }
+      const fatal = code && code !== 429;
+      if (fatal) { if (onFatal) onFatal(err); break; }
+      await sleep(1000); continue; // koneksi putus / 429 → napas sebentar
+    }
+
+    for (const u of updates) {
+      if (shouldStop()) break;
+      offset = u.update_id + 1;
+      try { await handleUpdate(u); } catch { /* sudah ditangani error handler bot */ }
+    }
+  }
+}
+
+module.exports = { pollLoop };

package/lib/session.js

@@ -0,0 +1,36 @@
+// lib/session.js — sesi per-user-per-chat, tanpa konfigurasi.
+'use strict';
+
+/**
+ * session({ initial, getKey, storage })
+ *  - default getKey: from.id + chat.id (khas), fallback chat.id.
+ *  - default storage: Map di memori. Boleh kirim storage custom { read(key), write(key,val), delete(key) }.
+ */
+function session(opts = {}) {
+  const initial = opts.initial || (() => ({}));
+  const store = opts.storage || new Map();
+  const getKey = opts.getKey || ((ctx) => {
+    const from = ctx.from && ctx.from.id;
+    const chat = ctx.chat && ctx.chat.id;
+    if (from !== undefined && chat !== undefined) return `${from}:${chat}`;
+    return chat !== undefined ? String(chat) : undefined;
+  });
+
+  const read = (k) => (store.read ? store.read(k) : store.get(k));
+  const write = (k, v) => (store.write ? store.write(k, v) : store.set(k, v));
+  const del = (k) => (store.delete ? store.delete(k) : store.delete(k));
+
+  return async (ctx, next) => {
+    const key = getKey(ctx);
+    if (key === undefined) { ctx.session = {}; return next(); }
+    let s = await read(key);
+    if (s === undefined || s === null) { s = initial(); await write(key, s); }
+    // Proxy: properti __deleted di akhir → hapus dari store
+    ctx.session = new Proxy(s, {
+      get: (t, p) => t[p], set: (t, p, v) => { t[p] = v; return true; },
+    });
+    return next();
+  };
+}
+
+module.exports = { session };

package/lib/telebibz.js

@@ -0,0 +1,190 @@
+// lib/telebibz.js — kelas utama: 100% kode sendiri, 0 dependency.
+'use strict';
+
+const { makeApi } = require('./api');
+const { Context } = require('./context');
+const { Composer } = require('./composer');
+const { session } = require('./session');
+const { matchInlineQuery } = require('./inline-query');
+const { Menu, MenuContainer } = require('./menus');
+const { pollLoop } = require('./runner');
+const wizard = require('./wizard');
+const log = require('./logger');
+const { humanize } = require('./errors');
+const { broadcast } = require('./broadcast');
+
+const DEFAULT_UPDATES = [
+  'message', 'edited_message', 'callback_query', 'inline_query',
+  'my_chat_member', 'chat_member', 'message_reaction',
+  'business_connection', 'business_message', 'edited_business_message',
+];
+
+class TeleBibz {
+  /**
+   * new TeleBibz('123:ABC', {
+   *   allowedUpdates: [...], onError(err, ctx), silent, dropPending,
+   *   transport: (method, payload) => Promise<result>,   // ← suntik untuk test
+   *   session: {...opsi session}, apiRoot: 'https://api.telegram.org'
+   * })
+   */
+  constructor(token, opts = {}) {
+    if (!token || !/^\d+:[\w-]+$/.test(token)) {
+      throw new Error('TeleBibz: token tidak valid. Ambil dari @BotFather → /newbot.');
+    }
+    this.opts = opts;
+    this.token = token;
+    this.api = makeApi(token, opts.transport);
+    this.botInfo = undefined;
+
+    this._handlers = new Composer();        // composer publik (use/on/cmd/dll)
+    this._report = async (bare) => {
+      const err = bare && bare.error ? bare.error : bare;
+      const ctx = bare && bare.ctx;
+      if (typeof this.opts.onError === 'function') return this.opts.onError(err, ctx);
+      this.printError(err, ctx);
+    };
+
+    // Pohon eksekusi: session → wizard → user handlers (dilindungi boundary)
+    this._root = new Composer()
+      .use(session(opts.session || {}))
+      .use(wizard.middleware());
+    this._safe = this._root.errorBoundary(this._report);
+  }
+
+  /* ---------- shortcut publik ---------- */
+  use(...mw) { this._handlers.use(...mw); return this; }
+  cmd(names, ...mw) { this._handlers.command(names, ...mw); return this; }
+  hears(match, ...mw) {
+    this._handlers.hears(match instanceof RegExp || Array.isArray(match) ? match : new RegExp(`^${escapeRe(match)}$`, 'i'), ...mw);
+    return this;
+  }
+  action(trigs, ...mw) { this._handlers.callbackQuery(trigs, ...mw); return this; }
+
+  /** Mode inline: bot.inlineQuery(/kucing/, handler) atau bot.inlineQuery('*', h) */
+  branch(...a) { this._handlers.branch(...a); return this; }
+  filter(...a) { this._handlers.filter(...a); return this; }
+  drop(...a) { this._handlers.drop(...a); return this; }
+  route(...a) { this._handlers.route(...a); return this; }
+  lazy(...a) { this._handlers.lazy(...a); return this; }
+  fork(...a) { this._handlers.fork(...a); return this; }
+
+  inlineQuery(trigger, ...mw) { this._handlers.use(async (ctx, next) => (matchInlineQuery(trigger)(ctx) ? runChain(mw, ctx, next) : next())); return this; }
+
+  /** Shortcut shortcut: daftarkan daftar perintah ke tombol menu Telegram. */
+  setMyCommands(commands, extra = {}) { return this.api.setMyCommands(commands, extra); }
+  on(filter, ...mw) { this._handlers.on(filter, ...mw); return this; }
+  start(replies) {
+    const h = typeof replies === 'function' ? replies : async (ctx) => ctx.reply(replies);
+    return this.cmd('start', h);
+  }
+
+  /* ---------- wizard ---------- */
+  wizard(id, def, bindCommand = true) {
+    wizard.define(id, def);
+    if (bindCommand) this.cmd(id, (ctx) => wizard.start(ctx, id));
+    return this;
+  }
+  wizardStart(ctx, id) { return wizard.start(ctx, id); }
+  wizardActive(ctx) { return wizard.active(ctx); }
+
+  /* ---------- broadcast ---------- */
+  broadcast(ids, pesan, opts) { return broadcast(this.api, ids, pesan, opts); }
+
+  /* ---------- siklus hidup ---------- */
+
+  /** Ambil identitas bot (dipanggil otomatis oleh launch; panggil manual untuk webhook). */
+  async init() {
+    const me = await this.api.getMe();
+    this.botInfo = me;
+    return me;
+  }
+
+  /** Tangani SATU update mentah (webhook/serverless/test). */
+  async handleUpdate(update) {
+    if (this._wired !== true) this._wire();
+    const ctx = new Context(update, this.api, this.botInfo);
+    try { await this._root.run(ctx); }
+    catch (err) { await this._report({ error: err, ctx }); }
+  }
+
+  _wire() {
+    this._wired = true;
+    // Pasang handler publik SETELAH boundary agar semuanya terlindungi
+    this._root.use(this._handlers.middleware());
+  }
+
+  /** Nyalakan long polling (dengan retry 409 & backoff jaringan). */
+  async launch(launchOpts = {}) {
+    await this.init();
+    const me = this.botInfo;
+    if (!this.opts.silent) {
+      log.banner('🤖 TeleBibz ON', [
+        `bot      : @${me.username} (id ${me.id})`,
+        'mode     : long-polling',
+        `library  : telebibz ${require('../package.json').version} (0 dependency)`,
+        'brand    : //—Xbibz Official—//',
+      ]);
+      log.ok('menunggu update… (Ctrl+C untuk berhenti)');
+    }
+    this._stopping = false;
+    this._runPromise = pollLoop({
+      api: this.api,
+      handleUpdate: (u) => this.handleUpdate(u),
+      allowedUpdates: this.opts.allowedUpdates || DEFAULT_UPDATES,
+      dropPending: this.opts.dropPending || launchOpts.dropPending || false,
+      shouldStop: () => this._stopping,
+      conflictDelay: launchOpts.conflictDelay || 5000,
+      onConflict: () => { if (!this.opts.silent) log.warn('bot lain masih polling (409) — coba lagi 5 detik…'); },
+      onFatal: (err) => this._report({ error: err }),
+    });
+    // Ctrl+C → berhenti bersih
+    if (!this.opts.silent && !launchOpts.noSignalHandlers) {
+      const stop = () => { log.warn('mematikan…'); this.stop(); };
+      process.once('SIGINT', stop); process.once('SIGTERM', stop);
+    }
+    return this;
+  }
+
+  /** Berhenti polling (resolve runPromise). */
+  stop() { this._stopping = true; }
+  /** Promise loop polling — ditunggu utk graceful shutdown/test. */
+  get runPromise() { return this._runPromise; }
+
+  /**
+   * Handler webhook gaya Node/Express:
+   *   const server = bot.webhook();
+   *   http.createServer((req,res) => req.url==='/tg' ? server(req,res) : ...)
+   *   — framework mana pun: (req, res) pasangan Request/Response Node.
+   */
+  webhook() {
+    return async (req, res) => {
+      try {
+        const chunks = [];
+        for await (const c of req) chunks.push(Buffer.from(c));
+        const update = JSON.parse(Buffer.concat(chunks).toString('utf8'));
+        await this.handleUpdate(update);
+        res.statusCode = 200; res.setHeader('Content-Type', 'application/json'); res.end('{}');
+      } catch (e) { res.statusCode = 400; res.end('bad request'); }
+    };
+  }
+
+  /* ---------- error cantik ---------- */
+  printError(err, ctx) {
+    const h = humanize(err);
+    log.error(`Telegram error${h.code ? ` (${h.code})` : ''}: ${h.pesan}`);
+    if (h.method) log.error(`  saat memanggil : ${h.method}`);
+    const c = ctx && ctx.chat ? ctx.chat.id : '-';
+    if (c !== '-') log.error(`  di chat        : ${c}`);
+    if (h.saran) log.warn(`  💡 saran: ${h.saran}`);
+  }
+}
+
+function runChain(mws, ctx, next) {
+  let i = 0;
+  const step = () => (i < mws.length ? mws[i++](ctx, step) : next());
+  return step();
+}
+
+function escapeRe(s) { return String(s).replace(/[.*+?^${}()|[\]\\]/g, '\\$&'); }
+
+module.exports = { TeleBibz };

package/lib/wizard.js

@@ -0,0 +1,81 @@
+// lib/wizard.js — percakapan tanya-jawab berurutan (form) berbasis sesi.
+'use strict';
+
+const KEY = '__telebibz_wizard';
+
+/**
+ * Definisi wizard:
+ * {
+ *   steps: [
+ *     { key:'nama', ask:'Siapa namamu?' },
+ *     { key:'umur', ask:'Umur berapa?', parse: Number,
+ *       validate: (n) => (n>0 && n<120) ? null : 'Umur tidak masuk akal, ulangi:' },
+ *   ],
+ *   done: async (answers, ctx) => {},
+ *   cancelWords: ['batal', '/batal', 'cancel'],   // ops, default ada
+ *   onCancel: (ctx) => ctx.reply('Dibatalkan.'),  // ops
+ * }
+ */
+const wizards = new Map();
+
+function define(id, def) {
+  if (!def || !Array.isArray(def.steps) || !def.steps.length || typeof def.done !== 'function') {
+    throw new Error(`wizard "${id}" butuh steps[] dan done(answers, ctx)`);
+  }
+  const cancelWords = new Set((def.cancelWords || ['batal', '/batal', 'cancel']).map((s) => String(s).toLowerCase()));
+  wizards.set(id, { ...def, cancelWords });
+  return id;
+}
+
+function get(id) { return wizards.get(id); }
+
+/** Mulai wizard dari handler mana pun (command/action/dll). */
+async function start(ctx, id) {
+  const def = wizards.get(id);
+  if (!def) throw new Error(`wizard "${id}" belum didefinisikan`);
+  if (!ctx.session) throw new Error('telebibz: session belum aktif (lib internal)');
+  ctx.session[KEY] = { id, i: 0, ans: {} };
+  const s0 = def.steps[0];
+  return ctx.reply(typeof s0.ask === 'function' ? await s0.ask(ctx) : s0.ask, s0.opts || {});
+}
+
+/** Middleware global: memproses jawaban wizard yang sedang berjalan. */
+function middleware() {
+  return async (ctx, next) => {
+    const st = ctx.session && ctx.session[KEY];
+    if (!st) return next();
+    const def = wizards.get(st.id);
+    if (!def) { delete ctx.session[KEY]; return next(); }
+
+    const text = ctx.message && typeof ctx.message.text === 'string' ? ctx.message.text.trim() : null;
+    if (text === null) return; // pesan non-teks (foto/stiker) — diamkan, wizard menunggu
+
+    if (def.cancelWords.has(text.toLowerCase())) {
+      delete ctx.session[KEY];
+      if (def.onCancel) return def.onCancel(ctx);
+      return ctx.reply('✖️ Sesi dibatalkan.');
+    }
+
+    const step = def.steps[st.i];
+    let value = text;
+    if (step.parse) value = await step.parse(text, ctx);
+    if (step.validate) {
+      const errMsg = await step.validate(value, ctx);
+      if (errMsg) return ctx.reply(errMsg);
+    }
+    st.ans[step.key] = value;
+    st.i += 1;
+
+    if (st.i >= def.steps.length) {
+      delete ctx.session[KEY];
+      return def.done(st.ans, ctx);
+    }
+    const ns = def.steps[st.i];
+    return ctx.reply(typeof ns.ask === 'function' ? await ns.ask(ctx) : ns.ask, ns.opts || {});
+  };
+}
+
+/** True kalau user ini sedang di tengah wizard. */
+function active(ctx) { return Boolean(ctx.session && ctx.session[KEY]); }
+
+module.exports = { define, get, start, middleware, active, KEY };

package/package.json

@@ -1,114 +1,52 @@
 {
   "name": "@xbibzlibrary/telebibz",
-  "version": "0.4.4",
-  "description": "Telegram Bot framework for Node.js and TypeScript with a typed API client, routing, middleware, webhooks, keyboards, conversations, plugins, queues, and a polished terminal experience.",
-  "keywords": [
-    "telegram",
-    "telegram-bot",
-    "telegram-bot-api",
-    "telegram-bot-framework",
-    "nodejs",
-    "typescript",
-    "telegram-webhook",
-    "long-polling",
-    "conversation-wizard",
-    "inline-keyboard",
-    "telegram-mini-app",
-    "bot-framework"
-  ],
-  "type": "module",
-  "private": false,
-  "publishConfig": {
-    "access": "public",
-    "provenance": false
-  },
+  "version": "3.0.1",
+  "description": "Library Telegram Indonesia production-grade — set fitur penuh setara grammY: proxy-api segala metode, transformer, menus, inline query, media group, throttler & auto-retry, session swappable, webhook, polling tahan-409. //—Xbibz Official—//",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "type": "commonjs",
   "license": "MIT",
+  "author": "Xbibz Official",
   "repository": {
     "type": "git",
     "url": "https://github.com/XbibzOfficial777/telebibz.git"
   },
   "homepage": "https://github.com/XbibzOfficial777/telebibz#readme",
-  "bugs": {
-    "url": "https://github.com/XbibzOfficial777/telebibz/issues"
-  },
+  "keywords": [
+    "telegram",
+    "telegram-bot",
+    "bot",
+    "grammy",
+    "telegram-api",
+    "inline-keyboard",
+    "wizard",
+    "broadcast",
+    "indonesia",
+    "nodejs",
+    "zero-dependency",
+    "tanpa-dependency"
+  ],
   "engines": {
-    "node": ">=22"
+    "node": ">=18"
   },
-  "scripts": {
-    "generate": "node scripts/generate-api.mjs",
-    "update:telegram": "node scripts/fetch-telegram-api.mjs && npm run generate",
-    "build": "tsc -p tsconfig.json && tsc -p tsconfig.cjs.json && node scripts/create-cjs-package.mjs && node scripts/copy-telegram-types.mjs",
-    "typecheck": "tsc -p tsconfig.json --noEmit",
-    "lint": "tsc -p tsconfig.json --noEmit && eslint scripts/*.mjs bin/*.mjs --no-error-on-unmatched-pattern",
-    "test": "vitest run",
-    "test:watch": "vitest",
-    "test:integration": "vitest run tests/integration/**/*.test.ts",
-    "test:e2e": "vitest run tests/e2e",
-    "test:types": "tsc -p tests/tsconfig.json --noEmit",
-    "test:examples": "tsc -p examples/tsconfig.json --noEmit",
-    "benchmark": "tsx tests/benchmark.ts",
-    "package:check": "npm run build && npm pack --dry-run",
-    "security": "npm audit --audit-level=high --package-lock-only",
-    "release:check": "node scripts/release-check.mjs",
-    "doctor": "tsx src/cli.ts doctor",
-    "start": "tsx src/cli.ts start",
-    "dev": "tsx examples/minimal.ts",
-    "prepack": "npm run build",
-    "prepublishOnly": "npm run typecheck && npm run test:types && npm run test:examples && npm run lint && npm test && npm run build && npm run security && npm run release:check"
-  },
-  "bin": {
-    "telebibz": "./bin/telebibz.mjs"
+  "dependencies": {
+    "axios": "^1.20.0",
+    "mime-types": "^3.0.2",
+    "https-proxy-agent": "^9.1.0",
+    "debug": "^4.4.3"
   },
-  "exports": {
-    ".": {
-      "types": "./dist/src/index.d.ts",
-      "import": "./dist/src/index.js",
-      "require": "./dist-cjs/src/index.js"
-    },
-    "./api": {
-      "types": "./dist/src/api/index.d.ts",
-      "import": "./dist/src/api/index.js",
-      "require": "./dist-cjs/src/api/index.js"
-    },
-    "./keyboard": {
-      "types": "./dist/src/keyboard/index.d.ts",
-      "import": "./dist/src/keyboard/index.js",
-      "require": "./dist-cjs/src/keyboard/index.js"
-    },
-    "./testing": {
-      "types": "./dist/src/testing.d.ts",
-      "import": "./dist/src/testing.js",
-      "require": "./dist-cjs/src/testing.js"
-    }
+  "scripts": {
+    "test": "node test/all.test.js"
   },
   "files": [
-    "dist",
-    "dist-cjs",
-    "bin",
+    "index.js",
+    "index.d.ts",
+    "lib/",
+    "examples/",
+    "test/",
     "README.md",
-    "README.id.md",
-    "README.zh-CN.md",
     "LICENSE",
-    "CHANGELOG.md",
-    "SECURITY.md",
-    "CODE_OF_CONDUCT.md",
-    "CONTRIBUTING.md",
-    "CONTRIBUTION_RULES.md",
-    "GOVERNANCE.md",
-    "SUPPORT.md",
     "NOTICE.md",
-    "RELEASE_POLICY.md",
-    "RELEASE_AUTOMATION.md",
-    "SHOWCASE.md",
-    "assets",
-    "docs",
-    "examples"
-  ],
-  "devDependencies": {
-    "@types/node": "^22.10.0",
-    "eslint": "^9.17.0",
-    "tsx": "^4.19.2",
-    "typescript": "^5.7.2",
-    "vitest": "^4.1.11"
-  }
+    "CHANGELOG.md"
+  ]
 }