@isaxn/bailyes 1.0.0 → 2.1.3

package/src/message/quick.js

@@ -0,0 +1,117 @@
+/*
+@author : isank dev
+@linkch : https://whatsapp.com/channel/0029Vb8Fj4S1iUxiJPyKFh1U
+@note : informasi update nya lewat ch
+@tanggal : now
+*/
+
+"use strict";
+
+const { Button } = require("./button.js");
+const { ButtonV2 } = require("./button-v2.js");
+const { Carousel } = require("./carousel.js");
+const { AIRich } = require("./ai-rich.js");
+const { sendLinkPreview } = require("./link-preview.js");
+const { sendLivePhoto } = require("./live-photo.js");
+const { sendLiveThumbnail } = require("./live-thumbnail.js");
+
+async function button(client, jid, { title, body = "", footer = "", thumbnail, buttons = [], contextInfo = {}, options = {} } = {}) {
+  if (!Array.isArray(buttons) || !buttons.length) {
+    throw new Error("buttons must be a non-empty array of { text, id }");
+  }
+
+  const builder = new ButtonV2(client).setBody(body).setFooter(footer).setContextInfo(contextInfo);
+
+  if (title) builder.setTitle(title);
+  if (thumbnail) builder.setThumbnail(thumbnail);
+
+  for (const item of buttons) {
+    builder.addButton(item.text ?? item.displayText ?? "", item.id ?? item.buttonId);
+  }
+
+  return builder.send(jid, options);
+}
+
+async function list(client, jid, { title = "", body = "", footer = "", sections = [], contextInfo = {}, options = {} } = {}) {
+  if (!Array.isArray(sections) || !sections.length) {
+    throw new Error("sections must be a non-empty array");
+  }
+
+  const builder = new Button(client)
+    .setTitle(title)
+    .setBody(body)
+    .setFooter(footer)
+    .setContextInfo(contextInfo)
+    .addSelection(title || "Menu");
+
+  for (const section of sections) {
+    builder.makeSection(section.title ?? "", section.highlight ?? "");
+
+    for (const row of section.rows || []) {
+      builder.makeRow(row.header ?? "", row.title ?? "", row.description ?? "", row.id ?? "");
+    }
+  }
+
+  return builder.send(jid, options);
+}
+
+async function card(client, jid, { body = "", footer = "", cards = [], contextInfo = {}, options = {} } = {}) {
+  if (!Array.isArray(cards) || cards.length < 2) {
+    throw new Error("cards must have at least 2 items, use bx.button for a single card");
+  }
+
+  const buttonKinds = {
+    url: (b, item) => b.addUrl(item.text, item.value, item.webview ?? false),
+    call: (b, item) => b.addCall(item.text, item.value),
+    copy: (b, item) => b.addCopy(item.text, item.value),
+    reply: (b, item) => b.addReply(item.text, item.value ?? item.id ?? "")
+  };
+
+  const built = await Promise.all(
+    cards.map(async (item) => {
+      const single = new Button(client)
+        .setTitle(item.title ?? "")
+        .setSubtitle(item.subtitle ?? "")
+        .setBody(item.body ?? "")
+        .setFooter(item.footer ?? footer);
+
+      if (item.image) single.setImage(item.image);
+      if (item.video) single.setVideo(item.video);
+
+      for (const btn of item.buttons || []) {
+        (buttonKinds[btn.type] ?? buttonKinds.reply)(single, btn);
+      }
+
+      return single.toCard();
+    })
+  );
+
+  return new Carousel(client).setBody(body).setFooter(footer).setContextInfo(contextInfo).addCard(built).send(jid, options);
+}
+
+async function rich(client, jid, { title = "", text, code, table, tip, options = {} } = {}) {
+  const builder = new AIRich(client).setTitle(title);
+
+  if (text) builder.addText(text);
+  if (code) builder.addCode(code.language ?? "javascript", code.content ?? "");
+  if (table) builder.addTable(table);
+  if (tip) builder.addTip(tip);
+
+  return builder.send(jid, options);
+}
+
+async function linkPreview(client, jid, options = {}) {
+  return sendLinkPreview(client, jid, options);
+}
+
+const bx = {
+  button,
+  list,
+  card,
+  rich,
+  linkPreview,
+  livePhoto: sendLivePhoto,
+  liveThumbnail: sendLiveThumbnail
+};
+
+module.exports = { bx };

package/src/message/table.js

@@ -0,0 +1,39 @@
+"use strict";
+
+const { extractIE } = require("./inline-entities.js");
+
+function toTableMetadata(arr, { hyperlink = true, citation = true, latex = true } = {}) {
+  if (!Array.isArray(arr) || !arr.every((row) => Array.isArray(row) && row.every((cell) => typeof cell === "string"))) {
+    throw new TypeError("Table must be a nested array of strings");
+  }
+
+  const [header, ...rows] = arr;
+  const maxLen = Math.max(header.length, ...rows.map((r) => r.length));
+  const normalize = (r) => [...r, ...Array(maxLen - r.length).fill("")];
+
+  const unified_rows = [{ is_header: true, cells: normalize(header) }, ...rows.map((r) => ({ is_header: false, cells: normalize(r) }))].map(
+    (row) => {
+      const markdown_cells = row.cells.map((cell) => {
+        const extracted = extractIE(cell, { hyperlink, citation, latex });
+        return {
+          text: extracted.text,
+          ...(extracted.inline_entities.length ? { inline_entities: extracted.inline_entities } : {})
+        };
+      });
+
+      return {
+        ...row,
+        ...(markdown_cells.some((c) => c.inline_entities?.length) ? { markdown_cells } : {})
+      };
+    }
+  );
+
+  const rowsMeta = unified_rows.map((r) => ({
+    items: r.cells,
+    ...(r.is_header ? { isHeading: true } : {})
+  }));
+
+  return { title: "", rows: rowsMeta, unified_rows };
+}
+
+module.exports = { toTableMetadata };

package/src/message/tokenizer.js

@@ -0,0 +1,207 @@
+"use strict";
+
+const KEYWORDS = {
+  javascript: new Set([
+    "break", "case", "catch", "continue", "debugger", "delete", "do", "else", "finally", "for",
+    "function", "if", "in", "instanceof", "new", "return", "switch", "this", "throw", "try",
+    "typeof", "var", "void", "while", "with", "true", "false", "null", "undefined", "class",
+    "const", "let", "super", "extends", "export", "import", "yield", "static", "constructor",
+    "async", "await", "get", "set"
+  ]),
+  typescript: new Set([
+    "abstract", "any", "as", "asserts", "bigint", "boolean", "declare", "enum", "implements",
+    "infer", "interface", "is", "keyof", "module", "namespace", "never", "readonly", "require",
+    "number", "object", "override", "private", "protected", "public", "satisfies", "string",
+    "symbol", "type", "unknown", "using", "from", "break", "case", "catch", "continue", "do",
+    "else", "finally", "for", "function", "if", "new", "return", "switch", "this", "throw",
+    "try", "var", "void", "while", "class", "const", "let", "extends", "import", "export",
+    "async", "await"
+  ]),
+  python: new Set([
+    "False", "None", "True", "and", "as", "assert", "async", "await", "break", "class",
+    "continue", "def", "del", "elif", "else", "except", "finally", "for", "from", "global",
+    "if", "import", "in", "is", "lambda", "nonlocal", "not", "or", "pass", "raise", "return",
+    "try", "while", "with", "yield"
+  ]),
+  java: new Set([
+    "abstract", "assert", "boolean", "break", "byte", "case", "catch", "char", "class", "const",
+    "continue", "default", "do", "double", "else", "enum", "extends", "final", "finally",
+    "float", "for", "goto", "if", "implements", "import", "instanceof", "int", "interface",
+    "long", "native", "new", "package", "private", "protected", "public", "return", "short",
+    "static", "strictfp", "super", "switch", "synchronized", "this", "throw", "throws",
+    "transient", "try", "void", "volatile", "while"
+  ]),
+  golang: new Set([
+    "break", "case", "chan", "const", "continue", "default", "defer", "else", "fallthrough",
+    "for", "func", "go", "goto", "if", "import", "interface", "map", "package", "range",
+    "return", "select", "struct", "switch", "type", "var"
+  ]),
+  c: new Set([
+    "auto", "break", "case", "char", "const", "continue", "default", "do", "double", "else",
+    "enum", "extern", "float", "for", "goto", "if", "int", "long", "register", "return",
+    "short", "signed", "sizeof", "static", "struct", "switch", "typedef", "union", "unsigned",
+    "void", "volatile", "while"
+  ]),
+  cpp: new Set([
+    "alignas", "alignof", "and", "auto", "bool", "break", "case", "catch", "class", "const",
+    "constexpr", "continue", "delete", "do", "double", "else", "enum", "explicit", "export",
+    "extern", "false", "float", "for", "friend", "if", "inline", "int", "long", "mutable",
+    "namespace", "new", "noexcept", "nullptr", "operator", "private", "protected", "public",
+    "return", "short", "signed", "sizeof", "static", "struct", "switch", "template", "this",
+    "throw", "true", "try", "typedef", "typename", "union", "unsigned", "using", "virtual",
+    "void", "while"
+  ]),
+  php: new Set([
+    "abstract", "and", "array", "as", "break", "callable", "case", "catch", "class", "clone",
+    "const", "continue", "declare", "default", "do", "echo", "else", "elseif", "empty",
+    "enddeclare", "endfor", "endforeach", "endif", "endswitch", "endwhile", "extends", "final",
+    "finally", "fn", "for", "foreach", "function", "global", "goto", "if", "implements",
+    "include", "include_once", "instanceof", "interface", "match", "namespace", "new", "null",
+    "or", "private", "protected", "public", "require", "require_once", "return", "static",
+    "switch", "throw", "trait", "try", "use", "var", "while", "yield"
+  ]),
+  rust: new Set([
+    "as", "break", "const", "continue", "crate", "else", "enum", "extern", "false", "fn",
+    "for", "if", "impl", "in", "let", "loop", "match", "mod", "move", "mut", "pub", "ref",
+    "return", "self", "Self", "static", "struct", "super", "trait", "true", "type", "unsafe",
+    "use", "where", "while"
+  ]),
+  html: new Set([
+    "html", "head", "body", "div", "span", "p", "a", "img", "video", "audio", "script",
+    "style", "link", "meta", "form", "input", "button", "table", "tr", "td", "th", "ul",
+    "ol", "li", "section", "article", "header", "footer", "nav", "main"
+  ]),
+  bash: new Set([
+    "if", "then", "else", "elif", "fi", "for", "while", "do", "done", "case", "esac",
+    "function", "in", "select", "until", "break", "continue", "return", "export", "readonly",
+    "local", "declare"
+  ]),
+  markdown: new Set(["#", "##", "###", "####", "#####", "######"])
+};
+
+const TYPE_MAP = {
+  0: "DEFAULT",
+  1: "KEYWORD",
+  2: "METHOD",
+  3: "STR",
+  4: "NUMBER",
+  5: "COMMENT"
+};
+
+function isIdentifierChar(char, lang) {
+  if (lang === "css") return /[a-zA-Z0-9_$-]/.test(char);
+  if (lang === "html") return /[a-zA-Z0-9_$:-]/.test(char);
+  return /[a-zA-Z0-9_$]/.test(char);
+}
+
+function tokenize(code, lang = "javascript") {
+  const normalizedLang = (lang || "").toLowerCase();
+
+  if (!lang || normalizedLang === "txt" || normalizedLang === "text" || normalizedLang === "plaintext") {
+    return {
+      codeBlock: [{ codeContent: code, highlightType: 0 }],
+      unified_codeBlock: [{ content: code, type: "DEFAULT" }]
+    };
+  }
+
+  const keywords = KEYWORDS[normalizedLang] || new Set();
+  const tokens = [];
+
+  let i = 0;
+
+  const push = (content, type) => {
+    if (!content) return;
+
+    const last = tokens[tokens.length - 1];
+
+    if (last && last.highlightType === type) {
+      last.codeContent += content;
+    } else {
+      tokens.push({ codeContent: content, highlightType: type });
+    }
+  };
+
+  while (i < code.length) {
+    const c = code[i];
+
+    if (/\s/.test(c)) {
+      const s = i;
+      while (i < code.length && /\s/.test(code[i])) i++;
+      push(code.slice(s, i), 0);
+      continue;
+    }
+
+    if ((c === "/" && code[i + 1] === "/") || (c === "#" && ["python", "bash"].includes(normalizedLang))) {
+      const s = i;
+      while (i < code.length && code[i] !== "\n") i++;
+      push(code.slice(s, i), 5);
+      continue;
+    }
+
+    if (c === '"' || c === "'" || c === "`") {
+      const s = i;
+      const quote = c;
+      i++;
+
+      while (i < code.length) {
+        if (code[i] === "\\" && i + 1 < code.length) {
+          i += 2;
+        } else if (code[i] === quote) {
+          i++;
+          break;
+        } else {
+          i++;
+        }
+      }
+
+      push(code.slice(s, i), 3);
+      continue;
+    }
+
+    if (/[0-9]/.test(c)) {
+      const s = i;
+      while (i < code.length && /[0-9._]/.test(code[i])) i++;
+      push(code.slice(s, i), 4);
+      continue;
+    }
+
+    if (/[a-zA-Z_$]/.test(c)) {
+      const s = i;
+      while (i < code.length && isIdentifierChar(code[i], normalizedLang)) i++;
+
+      const word = code.slice(s, i);
+      let type = 0;
+
+      if (keywords.has(word)) {
+        type = 1;
+      } else if (normalizedLang === "css") {
+        let j = i;
+        while (j < code.length && /\s/.test(code[j])) j++;
+        if (code[j] === ":") type = 1;
+      } else if (normalizedLang === "html") {
+        let p = s - 1;
+        while (p >= 0 && /\s/.test(code[p])) p--;
+        if (code[p] === "<" || (code[p] === "/" && code[p - 1] === "<")) type = 1;
+      }
+
+      if (type === 0) {
+        let j = i;
+        while (j < code.length && /\s/.test(code[j])) j++;
+        if (code[j] === "(") type = 2;
+      }
+
+      push(word, type);
+      continue;
+    }
+
+    push(c, 0);
+    i++;
+  }
+
+  return {
+    codeBlock: tokens,
+    unified_codeBlock: tokens.map((t) => ({ content: t.codeContent, type: TYPE_MAP[t.highlightType] }))
+  };
+}
+
+module.exports = { tokenize };

package/src/message/toolkit.js

@@ -0,0 +1,233 @@
+"use strict";
+
+const sharp = require("sharp");
+const ffmpeg = require("fluent-ffmpeg");
+const { PassThrough, Readable } = require("stream");
+const { getBaileys } = require("../core/baileys-loader.js");
+const { extractIE, waitAllPromises } = require("./inline-entities.js");
+
+class Toolkit {
+  static extractIE(text, options = {}) {
+    return extractIE(text, options);
+  }
+
+  static async waitAllPromises(input) {
+    return waitAllPromises(input);
+  }
+
+  static async resize(buffer, x, y, fit = "cover") {
+    return sharp(buffer)
+      .resize(x, y, {
+        fit,
+        position: "center",
+        background: { r: 0, g: 0, b: 0, alpha: 0 }
+      })
+      .png()
+      .toBuffer();
+  }
+
+  static async fetchBuffer(url, options = {}, { silent = true } = {}) {
+    try {
+      const response = await fetch(url, options);
+      if (!response.ok) throw new Error(`HTTP ${response.status}`);
+      return Buffer.from(await response.arrayBuffer());
+    } catch (error) {
+      if (silent) return Buffer.alloc(0);
+      throw error;
+    }
+  }
+
+  static async toUrl(client, mediaPath, mediaType = "document") {
+    if (!mediaPath) throw new Error("Url or buffer needed");
+
+    const { prepareWAMessageMedia } = await getBaileys();
+
+    const media = await prepareWAMessageMedia(
+      { [mediaType]: Buffer.isBuffer(mediaPath) ? mediaPath : { url: mediaPath } },
+      { upload: client.waUploadToServer, jid: "@newsletter" }
+    );
+
+    return Object.values(media)[0]?.url;
+  }
+
+  static async resolveMedia(
+    client,
+    media,
+    mediaType = "image",
+    { resolveUrl = false, resolveWAUrl = false, result = "url", resize = false, width = 300, height = 300 } = {}
+  ) {
+    const isUrl = (str) => /^https?:\/\/.+/i.test(str);
+    const isWAUrl = (str) => /^https?:\/\/[^/]*\.whatsapp\.net\//i.test(str);
+
+    if (Array.isArray(media)) {
+      return Promise.all(
+        media.map((item) =>
+          Toolkit.resolveMedia(client, item, mediaType, { resolveUrl, resolveWAUrl, result, resize, width, height })
+        )
+      );
+    }
+
+    const originalIsBuffer = Buffer.isBuffer(media);
+
+    if (typeof media === "string" && isUrl(media)) {
+      const shouldFetch = (isWAUrl(media) && resolveWAUrl) || (!isWAUrl(media) && resolveUrl) || result !== "url";
+
+      if (shouldFetch) {
+        media = await Toolkit.fetchBuffer(media, {}, { silent: true });
+      } else {
+        return media;
+      }
+    }
+
+    if (typeof media === "string" && !isUrl(media)) {
+      media = Buffer.from(media, "base64");
+    }
+
+    if (!Buffer.isBuffer(media) || !media.length) {
+      return undefined;
+    }
+
+    if (resize && Buffer.isBuffer(media)) {
+      media = await Toolkit.resize(media, width, height);
+    }
+
+    if (result === "buffer") return media;
+    if (result === "base64") return media.toString("base64");
+
+    return Toolkit.toUrl(client, media, mediaType);
+  }
+
+  static getMp4Duration(buffer, { silent = true } = {}) {
+    try {
+      if (!Buffer.isBuffer(buffer) || buffer.length < 8) {
+        if (silent) return 0;
+        throw new Error("Invalid buffer");
+      }
+
+      let offset = 0;
+
+      while (offset < buffer.length - 8) {
+        const size = buffer.readUInt32BE(offset);
+
+        if (size < 8 || offset + size > buffer.length) {
+          if (silent) return 0;
+          throw new Error("Invalid atom size");
+        }
+
+        const type = buffer.toString("ascii", offset + 4, offset + 8);
+
+        if (type === "moov") {
+          let moovOffset = offset + 8;
+          const moovEnd = offset + size;
+
+          while (moovOffset < moovEnd - 8) {
+            const childSize = buffer.readUInt32BE(moovOffset);
+
+            if (childSize < 8 || moovOffset + childSize > moovEnd) {
+              if (silent) return 0;
+              throw new Error("Invalid child atom size");
+            }
+
+            const childType = buffer.toString("ascii", moovOffset + 4, moovOffset + 8);
+
+            if (childType === "mvhd") {
+              const version = buffer.readUInt8(moovOffset + 8);
+
+              if (version === 0) {
+                const timescale = buffer.readUInt32BE(moovOffset + 20);
+                const duration = buffer.readUInt32BE(moovOffset + 24);
+
+                if (!timescale) {
+                  if (silent) return 0;
+                  throw new Error("Invalid timescale");
+                }
+
+                return duration / timescale;
+              }
+
+              if (version === 1) {
+                const timescale = buffer.readUInt32BE(moovOffset + 32);
+                const duration = Number(buffer.readBigUInt64BE(moovOffset + 36));
+
+                if (!timescale) {
+                  if (silent) return 0;
+                  throw new Error("Invalid timescale");
+                }
+
+                return duration / timescale;
+              }
+            }
+
+            moovOffset += childSize;
+          }
+        }
+
+        offset += size;
+      }
+
+      if (silent) return 0;
+      throw new Error("No mvhd found");
+    } catch (error) {
+      if (silent) return 0;
+      throw error;
+    }
+  }
+
+  static getMp4Preview(
+    videoBuffer,
+    { time, result = "buffer", resize = true, width = 300, height = 300, silent = true } = {}
+  ) {
+    return new Promise((resolve, reject) => {
+      const fail = (error) => {
+        if (silent) return resolve(result === "base64" ? "" : Buffer.alloc(0));
+        return reject(error);
+      };
+
+      try {
+        if (!Buffer.isBuffer(videoBuffer) || !videoBuffer.length) {
+          return fail(new Error("videoBuffer is invalid or empty"));
+        }
+
+        const inputStream = new Readable({ read() {} });
+        inputStream.push(videoBuffer);
+        inputStream.push(null);
+
+        const outputStream = new PassThrough();
+        const chunks = [];
+
+        outputStream.on("data", (chunk) => chunks.push(chunk));
+
+        outputStream.on("end", async () => {
+          try {
+            let output = Buffer.concat(chunks);
+
+            if (!output.length) {
+              return fail(new Error("Empty output, check the video format or timestamp"));
+            }
+
+            if (resize) {
+              output = await Toolkit.resize(output, width, height);
+            }
+
+            return resolve(result === "base64" ? output.toString("base64") : output);
+          } catch (error) {
+            return fail(error);
+          }
+        });
+
+        outputStream.on("error", fail);
+
+        const seekTime = time ?? Math.min(Toolkit.getMp4Duration(videoBuffer) * 0.2, 10);
+
+        ffmpeg(inputStream)
+          .outputOptions([`-ss ${seekTime}`, "-vframes 1", "-vcodec png", "-f image2pipe"])
+          .on("error", (error) => fail(new Error(`ffmpeg error: ${error.message}`)))
+          .pipe(outputStream, { end: true });
+      } catch (error) {
+        return fail(error);
+      }
+    });
+  }
+}
+
+module.exports = { Toolkit };

package/dist/core/client.cjs

@@ -1,65 +0,0 @@
-"use strict";
-
-const makeWASocket = require("@whiskeysockets/baileys").default;
-const {
-  useMultiFileAuthState,
-  DisconnectReason,
-  fetchLatestBaileysVersion
-} = require("@whiskeysockets/baileys");
-
-const qrcode = require("qrcode-terminal");
-const pino = require("pino");
-
-class WAClient {
-  async connect(authFolder = "./auth") {
-    const { state, saveCreds } =
-      await useMultiFileAuthState(authFolder);
-
-    const { version } =
-      await fetchLatestBaileysVersion();
-
-    const sock = makeWASocket({
-      version,
-      auth: state,
-      printQRInTerminal: false,
-      logger: pino({ level: "silent" }),
-      browser: ["Bailyes", "Chrome", "1.0.0"]
-    });
-    sock.ev.on("creds.update", saveCreds);
-
-    sock.ev.on("connection.update", (update) => {
-      const { connection, lastDisconnect, qr } = update;
-
-      if (qr) {
-        console.clear();
-        console.log("📱 Scan QR Code:\n");
-        qrcode.generate(qr, { small: true });
-      }
-
-      if (connection === "open") {
-        console.log("✅ WhatsApp Connected");
-      }
-
-      if (connection === "close") {
-        const code =
-          lastDisconnect?.error?.output?.statusCode;
-
-        if (code !== DisconnectReason.loggedOut) {
-          setTimeout(() => {
-            this.connect(authFolder);
-          }, 3000);
-        } else {
-          console.log(
-            "❌ Logged out. Delete auth folder to re-login."
-          );
-        }
-      }
-    });
-
-    return sock;
-  }
-}
-
-module.exports = {
-  WAClient
-};

package/dist/index.cjs

@@ -1,6 +0,0 @@
-//cjs
-"use strict";
-const { WAClient } = require("./core/client.cjs");
-module.exports = {
-  WAClient
-};