@japofc/baileys 2.1.0

package/lib/Builders/ButtonV2.d.ts

@@ -0,0 +1,28 @@
+import type { BaseBuilder, RowBuilder } from './shared.js';
+
+export interface ButtonV2BuildOptions {
+    /** Default true — some clients need it to render legacy buttonsMessage. */
+    viewOnce?: boolean;
+    [key: string]: any;
+}
+
+/** Legacy `buttonsMessage` builder (quick-reply buttons + location-fallback header). */
+export class ButtonV2 extends BaseBuilder {
+    constructor(client: any);
+    /** Add a simple quick-reply button. buttonId defaults to a random uuid. */
+    addButton(displayText?: string, buttonId?: string): this;
+    /** Push a raw pre-built button object. */
+    addRawButton(obj: Record<string, any>): this;
+    /** Header thumbnail (fallback location-header image). */
+    setThumbnail(path: string | Buffer): this;
+    /** Raw pre-built header media object. */
+    setMedia(obj: Record<string, any>): this;
+    /** Alias for addButton(). */
+    button(displayText?: string, buttonId?: string): this;
+    /** Group buttons via a RowBuilder callback. */
+    row(cb: (row: RowBuilder) => void): this;
+    /** Build the WAMessage without sending. */
+    build(jid: string, options?: ButtonV2BuildOptions): Promise<any>;
+    /** Build and send. Requires at least one button. */
+    send(jid: string, options?: Record<string, any>): Promise<any>;
+}

package/lib/Builders/ButtonV2.js

@@ -0,0 +1,144 @@
+import { BaseBuilder, Toolkit, RowBuilder, generateWAMessageFromContent, prepareWAMessageMedia, generateMessageIDV2, crypto } from './shared.js';
+class ButtonV2 extends BaseBuilder {
+	#client;
+
+	/** @param {import('../../WAProto/index.js').WASocket} client Active Baileys socket. */
+	constructor(client) {
+		super();
+		if (!client) {
+			throw new Error('Socket is required');
+		}
+
+		this.#client = client;
+		this._image;
+		this._data;
+		this._buttons = [];
+	}
+
+	/** Add a simple quick-reply button. @param {string} displayText Label. @param {string} [buttonId] Defaults to a random uuid. */
+	addButton(displayText = '', buttonId = crypto.randomUUID()) {
+		if (!displayText) throw new TypeError('addButton(displayText) requires a non-empty label');
+		this._buttons.push({
+			buttonId,
+			buttonText: { displayText },
+			type: 1,
+		});
+		return this;
+	}
+
+	/** Push a raw pre-built button object, bypassing the `addButton()` shorthand. */
+	addRawButton(obj) {
+		if (typeof obj !== 'object' || obj === null || Array.isArray(obj)) {
+			throw new TypeError('Buttons must be a plain object');
+		}
+
+		this._buttons.push(obj);
+		return this;
+	}
+
+	/** Set the header thumbnail (used as a fallback location-header image when no `setMedia()` header is given). */
+	setThumbnail(path) {
+		if (!path) throw new Error('Url or buffer needed');
+		this._image = path;
+		return this;
+	}
+
+	/** Set a raw pre-built header media object for the buttons message. */
+	setMedia(obj) {
+		if (typeof obj !== 'object' || obj === null || Array.isArray(obj)) {
+			throw new TypeError('Media must be a plain object');
+		}
+
+		this._data = obj;
+		return this;
+	}
+
+	/** Alias for addButton() — shorthand parity with RowBuilder#button(). */
+	button(displayText, buttonId) {
+		return this.addButton(displayText, buttonId);
+	}
+
+	/**
+	 * JAP@Add 29-08-26 --- Fluent row helper ported from the RowBuilder class (already
+	 * present but previously unwired into ButtonV2). Lets callers group buttons via a
+	 * callback instead of chaining addButton() calls one at a time.
+	 * @param {(row: RowBuilder) => void} cb
+	 */
+	row(cb) {
+		const r = new RowBuilder();
+		cb(r);
+		r.buttons.forEach((b) => this._buttons.push(b));
+		return this;
+	}
+
+	// JAP@Fix 22-08-26 (v4.7) --- _thumbnail was computed unconditionally (fetch + resize) even
+	// when setMedia() is used, in which case the location-fallback header (the only place
+	// _thumbnail is used) never runs at all — wasted network/CPU work on every build() call.
+	// Now only computed when it'll actually be used. Also: `viewOnce` was hardcoded true with no
+	// way to opt out (kept as the default — some clients need it to render legacy buttonsMessage
+	// at all — but it's now a `{ viewOnce = true }` option instead of a hardcoded literal).
+	/** @returns {Promise<Record<string, any>>} The generated WAMessage (without sending). @param {boolean} [viewOnce] Default true — some clients require this for legacy buttonsMessage to render; pass false to send it as a normal (non-disappearing) message. */
+	async build(jid, { viewOnce = true, ...options } = {}) {
+		const _thumbnail = !this._data && this._image ? await Toolkit.resize(Buffer.isBuffer(this._image) ? this._image : await Toolkit.fetchBuffer(this._image, {}, { silent: true }), 300, 300) : null;
+		const msg = generateWAMessageFromContent(
+			jid,
+			{
+				...this._extraPayload,
+				buttonsMessage: {
+					contentText: this._body,
+					footerText: this._footer,
+					...(this._data
+						? this._data
+						: {
+								headerType: 6,
+								locationMessage: {
+									degreesLatitude: 0,
+									degreesLongitude: 0,
+									name: this._title,
+									address: this._subtitle,
+									jpegThumbnail: _thumbnail,
+								},
+							}),
+					viewOnce,
+					contextInfo: this._contextInfo,
+					buttons: [...this._buttons],
+				},
+			},
+			{ ...options }
+		);
+		return msg;
+	}
+
+	/** Build and send this buttons message. @param {string} jid Destination chat/group jid. */
+	async send(jid, { ...options } = {}) {
+		if (this._buttons.length < 1) throw new Error('ButtonV2 requires at least one button');
+		const msg = await this.build(jid, options);
+
+		await this.#client.relayMessage(msg.key.remoteJid, msg.message, {
+			messageId: msg.key.id,
+			additionalNodes: [
+				{
+					tag: 'biz',
+					attrs: {},
+					content: [
+						{
+							tag: 'interactive',
+							attrs: { type: 'native_flow', v: '1' },
+							content: [{ tag: 'native_flow', attrs: { v: '9', name: 'mixed' } }],
+						},
+					],
+				},
+			],
+			...options,
+		});
+		return msg;
+	}
+}
+
+/**
+ * Legacy `templateMessage` / `hydratedFourRowTemplate` builder — WA's Generation-1
+ * button protocol (predates the nativeFlow format that Button/ButtonV2 use).
+ * Capped at 3 buttons (quickReply/url/call only), no interactive list/flow support.
+ * Ported from MessageBuilderV4.7.
+ */
+export { ButtonV2 };

package/lib/Builders/ButtonV3.d.ts

@@ -0,0 +1,25 @@
+import type { BaseBuilder } from './shared.js';
+
+/**
+ * Legacy `templateMessage` / `hydratedFourRowTemplate` builder — WA's Generation-1
+ * button protocol (predates the nativeFlow format Button/ButtonV2 use). Capped at
+ * 3 buttons (quickReply/url/call only), no interactive list/flow support.
+ */
+export class ButtonV3 extends BaseBuilder {
+    constructor(client: any);
+    /** Load an existing templateMessage (e.g. from a fetched/quoted message) for editing. */
+    loadFrom(msg: Record<string, any>): this;
+    setImage(path: string | Buffer, options?: Record<string, any>): this;
+    setVideo(path: string | Buffer, options?: Record<string, any>): this;
+    setDocument(path: string | Buffer, options?: Record<string, any>): this;
+    setMedia(obj: Record<string, any>): this;
+    clearButtons(): this;
+    /** Max 3 buttons — throws past the limit. */
+    addButton(hydratedButton: Record<string, any>): this;
+    addReply(display_text?: string, id?: string): this;
+    addUrl(display_text?: string, url?: string, options?: Record<string, any>): this;
+    addCall(display_text?: string, phone_number?: string): this;
+    toTemplate(): Promise<Record<string, any>>;
+    build(jid: string, options?: Record<string, any>): Promise<Record<string, any>>;
+    send(jid: string, options?: Record<string, any>): Promise<any>;
+}

package/lib/Builders/ButtonV3.js

@@ -0,0 +1,184 @@
+import { BaseBuilder, generateWAMessageFromContent, prepareWAMessageMedia, generateMessageIDV2, crypto } from './shared.js';
+class ButtonV3 extends BaseBuilder {
+	#client;
+
+	/** @param {import('../../WAProto/index.js').WASocket} client Active Baileys socket. */
+	constructor(client) {
+		super();
+		if (!client) {
+			throw new Error('Socket is required');
+		}
+
+		this.#client = client;
+		this._data;
+		this._mediaHeaderType = null;
+		this._buttons = [];
+	}
+
+	/** Load an existing templateMessage (e.g. from a fetched/quoted message) for editing. */
+	loadFrom(msg) {
+		if (!msg) throw new Error('templateMessage needed');
+		if (!msg.templateMessage) throw new Error('templateMessage not found');
+
+		const { templateMessage, ...extraPayload } = msg;
+		const hft = templateMessage.hydratedFourRowTemplate || {};
+
+		this._title = hft.hydratedTitleText || '';
+		this._body = hft.hydratedContentText || '';
+		this._footer = hft.hydratedFooterText || '';
+		this._contextInfo = templateMessage.contextInfo || {};
+		this._extraPayload = extraPayload;
+
+		this._buttons = Array.isArray(hft.hydratedButtons)
+			? hft.hydratedButtons.map((button) => ({ ...button }))
+			: [];
+
+		if (hft.imageMessage) {
+			this._data = { imageMessage: hft.imageMessage };
+			this._mediaHeaderType = 'imageMessage';
+		} else if (hft.videoMessage) {
+			this._data = { videoMessage: hft.videoMessage };
+			this._mediaHeaderType = 'videoMessage';
+		} else if (hft.documentMessage) {
+			this._data = { documentMessage: hft.documentMessage };
+			this._mediaHeaderType = 'documentMessage';
+		} else if (hft.locationMessage) {
+			this._data = { locationMessage: hft.locationMessage };
+			this._mediaHeaderType = 'locationMessage';
+		} else {
+			this._data = undefined;
+			this._mediaHeaderType = null;
+		}
+
+		return this;
+	}
+
+	setImage(path, options = {}) {
+		if (!path) throw new Error('Url or buffer needed');
+		this._data = Buffer.isBuffer(path)
+			? { image: path, ...options }
+			: { image: { url: path }, ...options };
+		this._mediaHeaderType = 'imageMessage';
+		return this;
+	}
+
+	setVideo(path, options = {}) {
+		if (!path) throw new Error('Url or buffer needed');
+		this._data = Buffer.isBuffer(path)
+			? { video: path, ...options }
+			: { video: { url: path }, ...options };
+		this._mediaHeaderType = 'videoMessage';
+		return this;
+	}
+
+	setDocument(path, options = {}) {
+		if (!path) throw new Error('Url or buffer needed');
+		this._data = Buffer.isBuffer(path)
+			? { document: path, ...options }
+			: { document: { url: path }, ...options };
+		this._mediaHeaderType = 'documentMessage';
+		return this;
+	}
+
+	setMedia(obj) {
+		if (typeof obj !== 'object' || obj === null || Array.isArray(obj)) {
+			throw new TypeError('Media must be a plain object');
+		}
+		this._data = obj;
+		this._mediaHeaderType = null; // caller is expected to pass an already-resolved shape
+		return this;
+	}
+
+	clearButtons() {
+		this._buttons = [];
+		return this;
+	}
+
+	addButton(hydratedButton) {
+		if (this._buttons.length >= 3) {
+			throw new Error('ButtonV3 (TemplateMessage) supports a maximum of 3 buttons');
+		}
+		this._buttons.push({ index: this._buttons.length + 1, ...hydratedButton });
+		return this;
+	}
+
+	addReply(display_text = '', id = '') {
+		return this.addButton({
+			quickReplyButton: { displayText: display_text, id },
+		});
+	}
+
+	addUrl(display_text = '', url = '', options = {}) {
+		return this.addButton({
+			urlButton: { displayText: display_text, url, ...options },
+		});
+	}
+
+	addCall(display_text = '', phone_number = '') {
+		return this.addButton({
+			callButton: { displayText: display_text, phoneNumber: phone_number },
+		});
+	}
+
+	async toTemplate() {
+		let mediaFields = {};
+
+		if (this._data) {
+			const alreadyResolved =
+				this._data.imageMessage || this._data.videoMessage ||
+				this._data.documentMessage || this._data.locationMessage;
+
+			mediaFields = alreadyResolved
+				? this._data
+				: await prepareWAMessageMedia(this._data, {
+						upload: this.#client.waUploadToServer,
+					}).catch((e) => {
+						if (String(e).includes('Invalid media type')) return this._data;
+						throw e;
+					});
+		} else if (this._title) {
+			mediaFields = { hydratedTitleText: this._title };
+		}
+
+		return {
+			hydratedContentText: this._body,
+			hydratedFooterText: this._footer,
+			hydratedButtons: this._buttons,
+			...mediaFields,
+		};
+	}
+
+	async build(jid, { messageId, ...options } = {}) {
+		const hydratedFourRowTemplate = await this.toTemplate();
+
+		return generateWAMessageFromContent(
+			jid,
+			{
+				...this._extraPayload,
+				templateMessage: {
+					hydratedFourRowTemplate,
+					contextInfo: this._contextInfo,
+				},
+			},
+			{ messageId: messageId || generateMessageIDV2(), ...options },
+		);
+	}
+
+	async send(jid, { messageId, additionalNodes = [], ...options } = {}) {
+		if (this._buttons.length < 1)
+			throw new Error('ButtonV3 requires at least one button');
+		const msg = await this.build(jid, { messageId, ...options });
+
+		// TemplateMessage predates the nativeFlow protocol and does not need the
+		// "biz"/"native_flow" additionalNodes hack that Button/ButtonV2 use.
+		await this.#client.relayMessage(msg.key.remoteJid, msg.message, {
+			messageId: msg.key.id,
+			additionalNodes,
+			...options,
+		});
+		return msg;
+	}
+}
+
+/** Carousel of interactive cards (each with its own header media + optional buttons), scrollable horizontally in-chat. */
+export { ButtonV3 };

package/lib/Builders/Carousel.d.ts

@@ -0,0 +1,22 @@
+import type { BaseBuilder } from './shared.js';
+
+/** One carousel card — typically built via `new Button(client).setImage(…).addUrl(…).toCard()`. */
+export interface CarouselCard {
+    header: {
+        hasMediaAttachment: boolean;
+        [key: string]: any;
+    };
+    [key: string]: any;
+}
+
+/** Chainable carousel builder (max 10 cards — enforced, WA truncates beyond that). */
+export class Carousel extends BaseBuilder {
+    static MAX_CARDS: number;
+    constructor(client: any);
+    /** Add one card, or an array of cards. Each must carry header media. */
+    addCard(card: CarouselCard | CarouselCard[]): this;
+    /** Build the WAMessage without sending. */
+    build(jid: string, options?: Record<string, any>): any;
+    /** Build and send. Requires at least one card. */
+    send(jid: string, options?: Record<string, any>): Promise<any>;
+}

package/lib/Builders/Carousel.js

@@ -0,0 +1,111 @@
+import { BaseBuilder, generateWAMessageFromContent, prepareWAMessageMedia, generateMessageIDV2, crypto } from './shared.js';
+class Carousel extends BaseBuilder {
+	#client;
+
+	// JAP@Add 22-08-26 (v4.7) --- WhatsApp caps carousels at 10 cards; anything beyond
+	// that is silently truncated client-side, so failing fast here is more useful than
+	// shipping a carousel that quietly loses cards.
+	static MAX_CARDS = 10;
+
+	/** @param {import('../../WAProto/index.js').WASocket} client Active Baileys socket. */
+	constructor(client) {
+		super();
+		if (!client) {
+			throw new Error('Socket is required');
+		}
+
+		this.#client = client;
+		this._cards = [];
+	}
+
+	/**
+	 * Add one card, or an array of cards, to the carousel.
+	 * @param {Record<string, any>|Record<string, any>[]} card A card (or array of cards) with `header.hasMediaAttachment: true`
+	 *   — typically built via `new Button(client).setImage(...).addUrl(...).toCard()`.
+	 */
+	addCard(card) {
+		const cards = Array.isArray(card) ? card : [card];
+		const baseIndex = this._cards.length;
+
+		for (const [index, c] of cards.entries()) {
+			if (!c?.header?.hasMediaAttachment) {
+				throw new Error(`Card [${baseIndex + index}] must include an image or video in header`);
+			}
+		}
+
+		if (this._cards.length + cards.length > Carousel.MAX_CARDS) {
+			throw new Error(`Carousel supports at most ${Carousel.MAX_CARDS} cards (got ${this._cards.length + cards.length})`);
+		}
+
+		this._cards.push(...cards);
+		return this;
+	}
+
+	/** @returns {Record<string, any>} The generated WAMessage (without sending). */
+	build(jid, { ...options } = {}) {
+		return generateWAMessageFromContent(
+			jid,
+			{
+				...this._extraPayload,
+				interactiveMessage: {
+					header: {
+						hasMediaAttachment: false,
+					},
+					body: { text: this._body },
+					footer: { text: this._footer },
+					contextInfo: this._contextInfo,
+					carouselMessage: {
+						cards: this._cards,
+					},
+				},
+			},
+			{ ...options }
+		);
+	}
+
+	/** Build and send this carousel. @param {string} jid Destination chat/group jid. */
+	async send(jid, { ...options } = {}) {
+		if (this._cards.length === 0) throw new Error('Carousel requires at least one card (use addCard())');
+
+		const msg = this.build(jid, options);
+
+		await this.#client.relayMessage(msg.key.remoteJid, msg.message, {
+			messageId: msg.key.id,
+			additionalNodes: [
+				{
+					tag: 'biz',
+					attrs: {},
+					content: [
+						{
+							tag: 'interactive',
+							attrs: { type: 'native_flow', v: '1' },
+							content: [{ tag: 'native_flow', attrs: { v: '9', name: 'mixed' } }],
+						},
+					],
+				},
+			],
+			...options,
+		});
+		return msg;
+	}
+}
+
+/**
+ * JAP@Add (v4.8) --- Chainable poll builder, wrapping the socket's own well-tested
+ * `sendMessage({ poll })` path (see messages.js) instead of hand-building
+ * pollCreationMessageV3/V5 over relayMessage. Two things from the traffic you sent were
+ * deliberately NOT implemented here because they can't be built with confidence:
+ *   1. Per-option poll images (`values: [{ name, image }]`) — the proto this fork ships
+ *      only has a plain `optionName` string per option; an image-poll option isn't a named
+ *      field anywhere in it. The one place an image-poll concept even appears
+ *      (`pollCreationOptionImageMessage`) is typed as an opaque `FutureProofMessage` (a
+ *      forward-compat envelope with no documented inner layout) — there's no field list to
+ *      target, so adding "support" for it would just be silently dropping the image and
+ *      guessing at a shape. Flagging instead of faking it.
+ *   2. Quiz-mode `correctAnswer.optionHash` built by hand — the one working example you
+ *      captured had a 65-character hex string where a sha256 digest should be 64, and this
+ *      builder's target `sendMessage({poll})` path (pollCreationMessageV5) already computes
+ *      quiz mode correctly from a plain `correctAnswer` string, so `setQuiz()` below defers to
+ *      that existing, already-tested logic rather than reimplementing the hash.
+ */
+export { Carousel };

package/lib/Builders/JapBaileys.d.ts

@@ -0,0 +1,34 @@
+import type { AIRich } from './AIRich.js';
+import type { Button } from './Button.js';
+import type { ButtonV2 } from './ButtonV2.js';
+import type { ButtonV3 } from './ButtonV3.js';
+import type { Carousel } from './Carousel.js';
+import type { Poll } from './Poll.js';
+import type { A2UI } from './A2UI.js';
+
+/**
+ * JapBaileys — unified builder hub. Every builder stays in its own
+ * class/file; this is a single entry point to instantiate them.
+ */
+export class JapBaileys {
+    constructor(client: any);
+    client: any;
+    airich(): AIRich;
+    japAI(): AIRich;
+    aiJap(): AIRich;
+    leafRich(): AIRich;
+    japRich(): AIRich;
+    richJap(): AIRich;
+    button(): Button;
+    buttonV2(): ButtonV2;
+    buttonV3(): ButtonV3;
+    carousel(): Carousel;
+    poll(): Poll;
+    a2ui(): A2UI;
+    /** PascalCase aliases. */
+    AIRich(): AIRich;
+    Button(): Button;
+    Carousel(): Carousel;
+    Poll(): Poll;
+    A2UI(): A2UI;
+}

package/lib/Builders/JapBaileys.js

@@ -0,0 +1,108 @@
+import { AIRich } from './AIRich.js'
+import { Button } from './Button.js'
+import { ButtonV2 } from './ButtonV2.js'
+import { ButtonV3 } from './ButtonV3.js'
+import { Carousel } from './Carousel.js'
+import { Poll } from './Poll.js'
+import { A2UI } from './A2UI.js'
+
+/**
+ * JapBaileys — unified builder hub.
+ *
+ * Semua builder tetap berada di class/file masing-masing.
+ * Class ini hanya menyediakan satu pintu masuk.
+ */
+class JapBaileys {
+  constructor(client) {
+    if (!client) {
+      throw new TypeError(
+        'JapBaileys(client) requires an active Baileys socket/client'
+      )
+    }
+
+    this.client = client
+  }
+
+  // ===== AIRICH =====
+
+  airich() {
+    return new AIRich(this.client)
+  }
+
+  japAI() {
+    return new AIRich(this.client)
+  }
+
+  aiJap() {
+    return new AIRich(this.client)
+  }
+
+  leafRich() {
+    return new AIRich(this.client)
+  }
+
+  japRich() {
+    return new AIRich(this.client)
+  }
+
+  richJap() {
+    return new AIRich(this.client)
+  }
+
+  // ===== BUTTON =====
+
+  button() {
+    return new Button(this.client)
+  }
+
+  buttonV2() {
+    return new ButtonV2(this.client)
+  }
+
+  buttonV3() {
+    return new ButtonV3(this.client)
+  }
+
+  // ===== CAROUSEL =====
+
+  carousel() {
+    return new Carousel(this.client)
+  }
+
+  // ===== POLL =====
+
+  poll() {
+    return new Poll(this.client)
+  }
+
+  // ===== A2UI / BLOKS =====
+
+  a2ui() {
+    return new A2UI()
+  }
+
+  /**
+   * Alias PascalCase untuk developer yang suka naming class.
+   */
+  AIRich() {
+    return this.airich()
+  }
+
+  Button() {
+    return this.button()
+  }
+
+  Carousel() {
+    return this.carousel()
+  }
+
+  Poll() {
+    return this.poll()
+  }
+
+  A2UI() {
+    return this.a2ui()
+  }
+}
+
+export { JapBaileys }

package/lib/Builders/Poll.d.ts

@@ -0,0 +1,25 @@
+import type { BaseBuilder } from './shared.js';
+
+/**
+ * Chainable poll builder wrapping the socket's own `sendMessage({ poll })` path.
+ * Per-option images and hand-built quiz hashes are deliberately NOT supported
+ * (see the .js docblock) — quiz mode defers to the socket's tested logic.
+ */
+export class Poll extends BaseBuilder {
+    constructor(client: any);
+    setName(name: string): this;
+    addOption(name: string): this;
+    addOptions(names: string[]): this;
+    setSelectable(count: number): this;
+    setMultiSelect(canSelectMultiple?: boolean): this;
+    setHideVoter(hide?: boolean): this;
+    setCanAddOption(allow?: boolean): this;
+    setAnnouncementGroup(isAnnouncement?: boolean): this;
+    setEndDate(date: Date | string | number): this;
+    /** Quiz mode — must match one of the added options exactly. */
+    setQuiz(correctOptionName: string): this;
+    /** Requires a name + at least 2 options. */
+    build(): { poll: Record<string, any> };
+    /** Build and send via the socket's `sendMessage()`. */
+    send(jid: string, options?: Record<string, any>): Promise<any>;
+}