@isaxn/bailyes 1.0.0 → 2.1.3

package/src/core/context.js

@@ -1,65 +1,117 @@
-import {
-  downloadContentFromMessage
-} from "@whiskeysockets/baileys";
-import fs from "fs";
-import path from "path";
-
-export class Context {
-  constructor(sock, msg) {
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const { getBaileys } = require("./baileys-loader.js");
+
+class Context {
+  constructor(sock, msg, { store = null } = {}) {
     this.sock = sock;
     this.msg = msg;
+    this.store = store;
 
     this.chat = msg.key.remoteJid;
-    this.sender =
-      msg.key.participant ||
-      msg.participant ||
-      msg.key.remoteJid;
+    this.sender = msg.key.participant || msg.participant || msg.key.remoteJid;
+    this.isGroup = Boolean(this.chat && this.chat.endsWith("@g.us"));
+    this.isLid = Boolean(this.sender && this.sender.endsWith("@lid"));
+    this.fromMe = Boolean(msg.key.fromMe);
 
-    this.isGroup = this.chat.endsWith("@g.us");
     this.message = msg.message;
 
     this.text =
       this.message?.conversation ||
       this.message?.extendedTextMessage?.text ||
+      this.message?.imageMessage?.caption ||
+      this.message?.videoMessage?.caption ||
       "";
+
+    this.command = null;
+    this.args = [];
+  }
+
+  get isImage() {
+    return Boolean(this.message?.imageMessage);
+  }
+
+  get isVideo() {
+    return Boolean(this.message?.videoMessage);
+  }
+
+  get isAudio() {
+    return Boolean(this.message?.audioMessage);
+  }
+
+  get isSticker() {
+    return Boolean(this.message?.stickerMessage);
+  }
+
+  get isDocument() {
+    return Boolean(this.message?.documentMessage);
   }
 
-  // ===== MEDIA =====
-  get isImage() { return !!this.message?.imageMessage; }
-  get isVideo() { return !!this.message?.videoMessage; }
-  get isAudio() { return !!this.message?.audioMessage; }
   get isVN() {
-    return this.isAudio && this.message.audioMessage?.ptt;
+    return this.isAudio && Boolean(this.message.audioMessage?.ptt);
+  }
+
+  getName(jid = this.sender) {
+    if (this.store) return this.store.getName(jid);
+    return String(jid || "").split("@")[0];
+  }
+
+  async getProfilePicture(jid = this.sender) {
+    if (!jid) return null;
+    try {
+      return await this.sock.profilePictureUrl(jid, "image");
+    } catch {
+      return null;
+    }
   }
 
   async downloadMedia(folder = "media") {
-    let type, msg;
+    const { downloadContentFromMessage } = await getBaileys();
+
+    let type;
+    let target;
 
-    if (this.isImage) type = "image", msg = this.message.imageMessage;
-    else if (this.isVideo) type = "video", msg = this.message.videoMessage;
-    else if (this.isAudio) type = "audio", msg = this.message.audioMessage;
-    else return null;
+    if (this.isImage) {
+      type = "image";
+      target = this.message.imageMessage;
+    } else if (this.isVideo) {
+      type = "video";
+      target = this.message.videoMessage;
+    } else if (this.isAudio) {
+      type = "audio";
+      target = this.message.audioMessage;
+    } else if (this.isSticker) {
+      type = "sticker";
+      target = this.message.stickerMessage;
+    } else if (this.isDocument) {
+      type = "document";
+      target = this.message.documentMessage;
+    } else {
+      return null;
+    }
 
-    const stream = await downloadContentFromMessage(msg, type);
-    const buffer = [];
+    const stream = await downloadContentFromMessage(target, type);
+    const chunks = [];
 
-    for await (const chunk of stream) buffer.push(chunk);
+    for await (const chunk of stream) chunks.push(chunk);
 
-    if (!fs.existsSync(folder)) fs.mkdirSync(folder);
+    if (!fs.existsSync(folder)) fs.mkdirSync(folder, { recursive: true });
 
-    const ext = type === "image" ? "jpg" : type === "video" ? "mp4" : "mp3";
+    const extensions = { image: "jpg", video: "mp4", audio: "mp3", sticker: "webp", document: "bin" };
+    const ext = extensions[type] || "bin";
     const filePath = path.join(folder, `${Date.now()}.${ext}`);
 
-    fs.writeFileSync(filePath, Buffer.concat(buffer));
+    fs.writeFileSync(filePath, Buffer.concat(chunks));
     return filePath;
   }
 
-  // ===== SEND =====
-  reply(text) {
-    return this.sock.sendMessage(this.chat, { text }, { quoted: this.msg });
+  reply(text, options = {}) {
+    return this.sock.sendMessage(this.chat, { text }, { quoted: this.msg, ...options });
   }
 
-  replyButtons(text, buttons, footer = "") {
+  replyButtons(text, buttons = [], footer = "", options = {}) {
     return this.sock.sendMessage(
       this.chat,
       {
@@ -72,7 +124,15 @@ export class Context {
         })),
         headerType: 1
       },
-      { quoted: this.msg }
+      { quoted: this.msg, ...options }
     );
   }
-}
+
+  react(emoji) {
+    return this.sock.sendMessage(this.chat, {
+      react: { text: emoji, key: this.msg.key }
+    });
+  }
+}
+
+module.exports = { Context };

package/src/core/events.js

@@ -1,15 +1,27 @@
-export class Events {
+"use strict";
+
+class Events {
   constructor() {
     this.events = {};
   }
 
   on(event, fn) {
     (this.events[event] ||= []).push(fn);
+    return this;
+  }
+
+  off(event, fn) {
+    if (!this.events[event]) return this;
+    this.events[event] = this.events[event].filter((listener) => listener !== fn);
+    return this;
   }
 
   emit(event, data) {
     for (const fn of this.events[event] || []) {
       fn(data);
     }
+    return this;
   }
-}
+}
+
+module.exports = { Events };

package/src/core/handler.js

@@ -1,40 +1,57 @@
-export class Handler {
-  constructor(prefix = ["!","."]) {
-    this.prefix = prefix;
+"use strict";
+
+class Handler {
+  constructor(prefix = ["!", "."]) {
+    this.prefix = Array.isArray(prefix) ? prefix : [prefix];
     this.commands = new Map();
     this.hears = [];
   }
 
   command(name, fn) {
-    this.commands.set(name, fn);
+    const names = Array.isArray(name) ? name : [name];
+    for (const n of names) this.commands.set(n, fn);
+    return this;
   }
 
   hear(pattern, fn) {
     this.hears.push({ pattern, fn });
+    return this;
+  }
+
+  matchPrefix(text) {
+    for (const p of this.prefix) {
+      if (text.startsWith(p)) return p;
+    }
+    return null;
   }
 
-  handle(ctx) {
-    const text = ctx.text.trim();
+  async handle(ctx) {
+    const text = (ctx.text || "").trim();
     if (!text) return;
 
-    for (const p of this.prefix) {
-      if (text.startsWith(p)) {
-        const [cmd, ...args] = text.slice(p.length).split(/\s+/);
-        if (this.commands.has(cmd)) {
-          ctx.command = cmd;
-          ctx.args = args;
-          return this.commands.get(cmd)(ctx);
-        }
+    const prefix = this.matchPrefix(text);
+
+    if (prefix !== null) {
+      const [cmd, ...args] = text.slice(prefix.length).trim().split(/\s+/);
+      const key = (cmd || "").toLowerCase();
+
+      if (this.commands.has(key)) {
+        ctx.command = key;
+        ctx.args = args;
+        ctx.text = args.join(" ");
+        return this.commands.get(key)(ctx);
       }
     }
 
     for (const h of this.hears) {
-      if (
-        typeof h.pattern === "string" && text === h.pattern ||
-        h.pattern instanceof RegExp && h.pattern.test(text)
-      ) {
+      const isString = typeof h.pattern === "string" && text === h.pattern;
+      const isRegex = h.pattern instanceof RegExp && h.pattern.test(text);
+
+      if (isString || isRegex) {
         return h.fn(ctx);
       }
     }
   }
-}
+}
+
+module.exports = { Handler };

package/src/core/store.js

@@ -0,0 +1,209 @@
+"use strict";
+
+const fs = require("fs");
+
+class Store {
+  constructor(options = {}) {
+    this.contacts = new Map();
+    this.chats = new Map();
+    this.groupMetadata = new Map();
+    this.messages = new Map();
+    this.maxMessagesPerChat = options.maxMessagesPerChat || 100;
+    this.file = options.file || null;
+    this.autosaveInterval = options.autosaveInterval ?? 30000;
+    this._timer = null;
+  }
+
+  bind(ev) {
+    if (this.file) this.readFromFile(this.file);
+
+    ev.on("contacts.upsert", (contacts) => {
+      for (const contact of contacts || []) this.upsertContact(contact);
+    });
+
+    ev.on("contacts.update", (updates) => {
+      for (const update of updates || []) this.upsertContact(update);
+    });
+
+    ev.on("chats.upsert", (chats) => {
+      for (const chat of chats || []) this.upsertChat(chat);
+    });
+
+    ev.on("chats.update", (updates) => {
+      for (const update of updates || []) this.upsertChat(update);
+    });
+
+    ev.on("chats.delete", (ids) => {
+      for (const id of ids || []) this.chats.delete(id);
+    });
+
+    ev.on("messages.upsert", (payload) => {
+      for (const msg of payload?.messages || []) this.upsertMessage(msg);
+    });
+
+    ev.on("messages.update", (updates) => {
+      for (const update of updates || []) this.patchMessage(update);
+    });
+
+    ev.on("messages.delete", (item) => {
+      if (Array.isArray(item?.keys)) {
+        for (const key of item.keys) {
+          this.messages.get(key.remoteJid)?.delete(key.id);
+        }
+        return;
+      }
+      if (item?.jid) this.messages.delete(item.jid);
+    });
+
+    ev.on("groups.update", (updates) => {
+      for (const update of updates || []) this.upsertGroupMetadata(update);
+    });
+
+    ev.on("group-participants.update", (data) => this.applyParticipantsUpdate(data));
+
+    if (this.file && this.autosaveInterval > 0) {
+      this._timer = setInterval(() => this.writeToFile(this.file), this.autosaveInterval);
+      if (this._timer.unref) this._timer.unref();
+    }
+
+    return this;
+  }
+
+  upsertContact(contact) {
+    if (!contact?.id) return;
+    const existing = this.contacts.get(contact.id) || { id: contact.id };
+    this.contacts.set(contact.id, { ...existing, ...contact });
+  }
+
+  upsertChat(chat) {
+    if (!chat?.id) return;
+    const existing = this.chats.get(chat.id) || { id: chat.id };
+    this.chats.set(chat.id, { ...existing, ...chat });
+  }
+
+  upsertGroupMetadata(meta) {
+    if (!meta?.id) return;
+    const existing = this.groupMetadata.get(meta.id) || { id: meta.id };
+    this.groupMetadata.set(meta.id, { ...existing, ...meta });
+  }
+
+  applyParticipantsUpdate({ id, participants, action } = {}) {
+    const meta = this.groupMetadata.get(id);
+    if (!meta || !Array.isArray(meta.participants) || !Array.isArray(participants)) return;
+
+    if (action === "add" || action === "promote" || action === "demote") {
+      for (const jid of participants) {
+        if (!meta.participants.some((p) => p.id === jid)) {
+          meta.participants.push({ id: jid });
+        }
+      }
+    }
+
+    if (action === "remove") {
+      meta.participants = meta.participants.filter((p) => !participants.includes(p.id));
+    }
+  }
+
+  upsertMessage(msg) {
+    const jid = msg?.key?.remoteJid;
+    const id = msg?.key?.id;
+    if (!jid || !id) return;
+
+    let bucket = this.messages.get(jid);
+    if (!bucket) {
+      bucket = new Map();
+      this.messages.set(jid, bucket);
+    }
+
+    bucket.set(id, msg);
+
+    while (bucket.size > this.maxMessagesPerChat) {
+      bucket.delete(bucket.keys().next().value);
+    }
+  }
+
+  patchMessage(update) {
+    const jid = update?.key?.remoteJid;
+    const id = update?.key?.id;
+    if (!jid || !id) return;
+
+    const bucket = this.messages.get(jid);
+    const existing = bucket?.get(id);
+    if (existing) bucket.set(id, { ...existing, ...update.update });
+  }
+
+  loadMessage(jid, id) {
+    return this.messages.get(jid)?.get(id) || null;
+  }
+
+  getContact(jid) {
+    return this.contacts.get(jid) || null;
+  }
+
+  getChat(jid) {
+    return this.chats.get(jid) || null;
+  }
+
+  getGroupMetadata(jid) {
+    return this.groupMetadata.get(jid) || null;
+  }
+
+  getName(jid) {
+    if (!jid) return "";
+    const contact = this.contacts.get(jid);
+    const fallback = String(jid).split("@")[0];
+    return contact?.name || contact?.notify || contact?.verifiedName || fallback;
+  }
+
+  toJSON() {
+    return {
+      contacts: Array.from(this.contacts.values()),
+      chats: Array.from(this.chats.values()),
+      groupMetadata: Array.from(this.groupMetadata.values()),
+      messages: Array.from(this.messages.entries()).map(([jid, bucket]) => [
+        jid,
+        Array.from(bucket.values())
+      ])
+    };
+  }
+
+  fromJSON(data) {
+    if (!data) return;
+
+    this.contacts = new Map((data.contacts || []).map((c) => [c.id, c]));
+    this.chats = new Map((data.chats || []).map((c) => [c.id, c]));
+    this.groupMetadata = new Map((data.groupMetadata || []).map((g) => [g.id, g]));
+    this.messages = new Map(
+      (data.messages || []).map(([jid, msgs]) => [
+        jid,
+        new Map(msgs.map((m) => [m.key.id, m]))
+      ])
+    );
+  }
+
+  writeToFile(file = this.file) {
+    if (!file) return;
+    try {
+      fs.writeFileSync(file, JSON.stringify(this.toJSON()));
+    } catch {
+      return;
+    }
+  }
+
+  readFromFile(file = this.file) {
+    if (!file || !fs.existsSync(file)) return;
+    try {
+      const raw = fs.readFileSync(file, "utf-8");
+      this.fromJSON(JSON.parse(raw));
+    } catch {
+      return;
+    }
+  }
+
+  stop() {
+    if (this._timer) clearInterval(this._timer);
+    if (this.file) this.writeToFile(this.file);
+  }
+}
+
+module.exports = { Store };

package/src/index.js

@@ -1,56 +1,134 @@
-//isanamd code dont delete
-export { WAClient } from "./core/client.js";
-import { Context } from "./core/context.js";
-import { Events } from "./core/events.js";
-import { Handler } from "./core/handler.js";
+/*
+@author : isank dev
+@linkch : https://whatsapp.com/channel/0029Vb8Fj4S1iUxiJPyKFh1U
+@note : informasi update nya lewat ch
+@tanggal : now
+*/
 
-const cooldown = new Map();
+"use strict";
 
-function canReply(jid, delay = 3000) {
-  const now = Date.now();
-  if (cooldown.has(jid) && now - cooldown.get(jid) < delay) {
-    return false;
-  }
-  cooldown.set(jid, now);
-  return true;
-}
+const { WAClient } = require("./core/client.js");
+const { Context } = require("./core/context.js");
+const { Events } = require("./core/events.js");
+const { Handler } = require("./core/handler.js");
+const { Store } = require("./core/store.js");
+const {
+  VERSION,
+  Button,
+  ButtonV2,
+  Carousel,
+  AIRich,
+  Toolkit,
+  bind,
+  sendLinkPreview,
+  sendLivePhoto,
+  sendLiveThumbnail,
+  bx
+} = require("./message/index.js");
 
-export class Bailyes {
+class Bailyes {
   constructor(options = {}) {
     this.auth = options.auth || "auth";
     this.prefix = options.prefix || ["!"];
-    this.client = new WAClient();
+    this.cooldown = options.cooldown ?? 0;
+
+    this.client = new WAClient(options);
     this.events = new Events();
     this.handler = new Handler(this.prefix);
+
+    this._cooldownMap = new Map();
+    this.sock = null;
+  }
+
+  get store() {
+    return this.client.store;
   }
 
-  
   on(event, fn) {
+    this.client.on(event, fn);
+    return this;
+  }
+
+  onFramework(event, fn) {
     this.events.on(event, fn);
+    return this;
   }
 
   command(name, fn) {
     this.handler.command(name, fn);
+    return this;
   }
 
   hear(pattern, fn) {
     this.handler.hear(pattern, fn);
+    return this;
+  }
+
+  _canReply(jid) {
+    if (!this.cooldown) return true;
+
+    const now = Date.now();
+    const last = this._cooldownMap.get(jid);
+
+    if (last && now - last < this.cooldown) return false;
+
+    this._cooldownMap.set(jid, now);
+    return true;
   }
 
   async start() {
-    const sock = await this.client.connect(this.auth);
+    this.client.on("messages.upsert", ({ messages, type }) => {
+      if (type !== "notify") return;
 
-    sock.ev.on("messages.upsert", ({ messages }) => {
       const msg = messages?.[0];
       if (!msg || !msg.message || msg.key.fromMe) return;
 
-      const ctx = new Context(sock, msg);
+      const ctx = new Context(this.sock, msg, { store: this.store });
 
-      if (!canReply(ctx.chat)) return;
+      if (!this._canReply(ctx.chat)) return;
 
       this.events.emit("message", ctx);
+      this.handler.handle(ctx).catch((error) => this.events.emit("error", error));
+    });
 
-      this.handler.handle(ctx);
+    this.client.on("open", (sock) => {
+      this.sock = sock;
+      bind(sock);
+      this.events.emit("ready", sock);
     });
+
+    this.client.on("qr", (qr) => this.events.emit("qr", qr));
+    this.client.on("pairing-code", (code) => this.events.emit("pairing-code", code));
+    this.client.on("close", (info) => this.events.emit("close", info));
+    this.client.on("logged-out", () => this.events.emit("logged-out"));
+
+    this.sock = await this.client.connect();
+    bind(this.sock);
+
+    return this.sock;
+  }
+
+  stop() {
+    this.client.stop();
   }
-}
+}
+
+module.exports = {
+  Bailyes,
+  WAClient,
+  Context,
+  Events,
+  Handler,
+  Store,
+  VERSION,
+  Button,
+  ButtonV2,
+  Carousel,
+  AIRich,
+  Toolkit,
+  bind,
+  sendLinkPreview,
+  sendLivePhoto,
+  sendLiveThumbnail,
+  bx
+};