ishumdz-bail 1.0.27 → 1.0.29

package/README.md

@@ -698,12 +698,15 @@ Action buttons (`url` / `copy` / `call`) never send a reply — nothing to handl
 ### Base Compatibility — cantarella / Case X Style Code (v1.0.27+)
 
 Code copied from other Baileys bases (cantarella-baileys, Case X Plugin YOUHU MD, etc.)
-runs without changes. Three shapes are accepted:
+runs without changes — and renders as a **horizontal one-line row** just like those
+bases. Three shapes are accepted:
 
-**1) Raw `buttonsMessage` classic menu card — even the risky mix.** A raw classic
-message that mixes `nativeFlowInfo` (single_select sheet) or `cta_*` buttons with
-plain buttons is **auto-upgraded to a native-flow interactive card**, so it can never
-render the "version doesn't support it" bubble:
+**1) Raw `buttonsMessage` classic menu card — mixed extras are flattened.** A raw
+classic message that mixes `nativeFlowInfo` (single_select sheet) or `cta_*` buttons
+with plain buttons **stays classic horizontal**: the header (location/image/video)
+is preserved, every extra becomes a plain button with its original `buttonId`, and
+its click arrives as a normal `buttonsResponseMessage` — so your bot can send the
+list sheet / URL action itself (e.g. a separate `nativeFlow: true` message):
 
 ```javascript
 // Case X / cantarella style — works as-is:
@@ -745,8 +748,60 @@ await sock.sendMessage(jid, { interactiveMessage: { buttons: [{ name: 'quick_rep
 
 **3) Plain raw `buttonsMessage`** (no native-flow extras) stays classic and gets the
 automatic invisible-PNG header when you omit one. Flow params are accepted as
-`paramsJson` or `buttonParamsJson`, and `single_select` / `cta_url` / `cta_copy` /
-`cta_call` / `quick_reply` names are preserved as-is.
+`paramsJson` or `buttonParamsJson`.
+
+> 💡 **Want the tap-to-open sheet too?** Send it as a second message when the button
+> is clicked (see `examples/menu-buttons.js` — the `allmenus` case). Mixing a sheet
+> into the same classic row is what produced the "doesn't support it" bubble; the
+> library keeps the row safe by flattening extras, and the two-message pattern gives
+> you both layouts.
+
+### One-Tap Horizontal Button → Automatic List Sheet — v1.0.28+
+
+`attachSheetAutoReply` does the two-message pattern **for you**: register it once,
+and when the user taps a horizontal button, the list sheet is sent automatically —
+no extra code in your `messages.upsert` handler:
+
+```javascript
+const { makeWASocket, attachSheetAutoReply } = require('ishumdz-bail')
+
+const sock = makeWASocket({ auth: state, ... })
+
+// register ONCE, right after creating the socket:
+attachSheetAutoReply(sock, {
+    // click id → full sheet (auto-sent, click never reaches your parser)
+    allmenus: {
+        text: '📂 *ALL MENUS* — tap a section 👇',
+        footer: 'ISHAN-X MD PRO',
+        buttonText: '📂 open menu',
+        sectionTitle: 'All Menus',
+        highlightLabel: '⭐ MAIN',
+        rows: [
+            { title: '📥 Download Menu', description: 'Downloader commands', rowId: '.downloadmenu' },
+            { title: '✨ AI Menu',       description: 'AI commands',         rowId: '.aimenu' },
+            { title: '🎮 Game Menu',     description: 'Fun & games',         rowId: '.gamemenu' }
+        ]
+    },
+    // shorthand: click id → rewrite into a normal command for your parser
+    support: '.owner'
+})
+
+// then your horizontal row stays 100% plain → guaranteed one-line render:
+await sock.sendMessage(jid, {
+    location: { degreesLatitude: 0, degreesLongitude: 0,
+                name: 'ISHAN-X MD PRO', address: '📂 Select Menu 👇' },
+    text: menuText, footer,
+    buttons: [
+        { buttonText: { displayText: '📂 allmenus' }, buttonId: 'allmenus', type: 1 },
+        { buttonText: { displayText: '👤 owner' },    buttonId: 'owner',    type: 1 },
+        { buttonText: { displayText: '⚡ ping' },      buttonId: 'ping',     type: 1 }
+    ]
+}, { quoted: msg })
+// user taps "allmenus" → sheet opens instantly; taps "owner" → your parser gets '.owner'
+```
+
+Also exported: `sendSheet(sock, jid, entry, quoted)` (send a sheet manually) and
+`decodeButtonClick(msg)` (the click bridge, shipped with the library).
 
 ---
 

package/lib/Pro/sheet-buttons.js

@@ -0,0 +1,179 @@
+/**
+ * sheet-buttons.js — one-tap horizontal button → automatic list sheet (v1.0.28+)
+ *
+ * Classic horizontal rows cannot carry a native-flow sheet inside the SAME
+ * message on current clients (that mix renders as "version doesn't support
+ * it"). The working pattern is TWO messages: the horizontal row, and — when
+ * the user clicks the menu button — a native-flow list sheet sent
+ * automatically. This module does the second half for you:
+ *
+ *   const { attachSheetAutoReply } = require('ishumdz-bail')
+ *
+ *   attachSheetAutoReply(sock, {
+ *       // click id → full sheet definition
+ *       allmenus: {
+ *           text: '📂 *ALL MENUS* — tap a section 👇',
+ *           footer: 'ISHAN-X MD PRO',
+ *           buttonText: '📂 open menu',
+ *           highlightLabel: '⭐ MAIN',
+ *           sectionTitle: 'All Menus',
+ *           rows: [
+ *               { title: '📥 Download Menu', description: 'Downloaders', rowId: '.downloadmenu' },
+ *               { title: '✨ AI Menu',       description: 'AI commands', rowId: '.aimenu' }
+ *           ]
+ *       },
+ *       // or a shorthand: rewrite the click into another command
+ *       support: '.owner'
+ *   })
+ *
+ * Now a horizontal row can stay 100% plain (guaranteed one-line render):
+ *
+ *   await sock.sendMessage(jid, {
+ *       location: { degreesLatitude: 0, degreesLongitude: 0,
+ *                   name: 'ISHAN-X MD PRO', address: '📂 Select Menu 👇' },
+ *       text: menuText, footer,
+ *       buttons: [
+ *           { buttonText: { displayText: '📂 allmenus' }, buttonId: 'allmenus', type: 1 },
+ *           { buttonText: { displayText: '👤 owner' },    buttonId: 'owner',    type: 1 }
+ *       ]
+ *   })
+ *
+ * User taps "allmenus" → the sheet opens instantly, and your own
+ * messages.upsert handler is NOT called for that click (consumed).
+ * A shorthand entry rewrites the click into the given command text and
+ * lets your normal command parser handle it.
+ */
+
+// Decode any button / sheet-row / list-row click into its id (same bridge
+// the examples use, now shipped with the library).
+export function decodeButtonClick(msg) {
+    // classic horizontal quick-reply buttons
+    const classic = msg?.message?.buttonsResponseMessage?.selectedButtonId
+    if (classic) return classic
+
+    // native flow (sheet rows / card quick replies)
+    const nf = msg?.message?.interactiveResponseMessage?.nativeFlowResponseMessage
+    if (nf?.paramsJson) {
+        try {
+            const p = JSON.parse(nf.paramsJson)
+            return p.id || p.selectedId || p.selected_row_id || null
+        } catch { /* ignore */ }
+    }
+
+    // classic listMessage rows
+    const list = msg?.message?.listResponseMessage?.singleSelectReply?.selectedRowId
+    if (list) return list
+
+    return null
+}
+
+const normalizeRows = (rows) => (rows || []).map(r => ({
+    title: r.title,
+    ...(r.description ? { description: r.description } : {}),
+    id: r.rowId ?? r.id ?? r.title
+}))
+
+const buildSections = (entry) => {
+    if (Array.isArray(entry.sections) && entry.sections.length) {
+        return entry.sections.map(s => ({
+            ...(s.title ? { title: s.title } : {}),
+            ...(s.highlight_label || s.highlightLabel ? { highlight_label: s.highlight_label || s.highlightLabel } : {}),
+            rows: normalizeRows(s.rows)
+        }))
+    }
+    return [{
+        title: entry.sectionTitle || entry.buttonText || 'Menu',
+        ...(entry.highlightLabel ? { highlight_label: entry.highlightLabel } : {}),
+        rows: normalizeRows(entry.rows)
+    }]
+}
+
+const normalizeHandlers = (handlers) => {
+    const sheets = {}
+    const commands = {}
+    for (const [id, val] of Object.entries(handlers || {})) {
+        if (typeof val === 'string') {
+            commands[id] = val
+        } else if (val && (Array.isArray(val.rows) || Array.isArray(val.sections))) {
+            sheets[id] = val
+        }
+    }
+    return { sheets, commands }
+}
+
+/**
+ * Manually send a native-flow list sheet (the tap-to-open menu).
+ * attachSheetAutoReply calls this for you on a matching click.
+ */
+export async function sendSheet(sock, jid, entry, quoted) {
+    const sections = buildSections(entry)
+    return sock.sendMessage(jid, {
+        text: entry.text || '📋 Select an option 👇',
+        ...(entry.footer ? { footer: entry.footer } : {}),
+        nativeFlow: true,
+        buttons: [{
+            buttonText: { displayText: entry.buttonText || '☰ menu' },
+            buttonId: entry.buttonId || 'sheet',
+            type: 1,
+            sections
+        }]
+    }, quoted ? { quoted } : {})
+}
+
+/**
+ * Register automatic sheet replies on a socket.
+ *
+ * @param {object} sock     the makeWASocket() instance
+ * @param {object} handlers map of clickId → sheet definition { text?, footer?,
+ *                          buttonText?, sectionTitle?, highlightLabel?, rows|sections }
+ *                          OR clickId → '.command' string shorthand
+ * @returns {Function} uninstall — restores the original sock.ev.on
+ */
+export function attachSheetAutoReply(sock, handlers) {
+    const { sheets, commands } = normalizeHandlers(handlers)
+
+    async function handleUpsert(payload) {
+        const { messages, type } = payload || {}
+        if (type !== 'notify' || !Array.isArray(messages)) return false
+        for (const msg of messages) {
+            if (!msg?.message || msg.key?.fromMe) continue
+            const clicked = decodeButtonClick(msg)
+            if (!clicked) continue
+
+            // 1) full sheet definition → send the sheet, consume the click
+            const entry = sheets[clicked]
+            if (entry) {
+                try {
+                    await sendSheet(sock, msg.key.remoteJid, { ...entry, buttonId: clicked }, msg)
+                } catch (e) {
+                    try { sock.logger?.error?.({ err: e }, 'sheet auto-reply failed') } catch { /* ignore */ }
+                }
+                return true
+            }
+
+            // 2) command shorthand → rewrite into normal command text for the parser
+            const cmd = commands[clicked]
+            if (cmd) {
+                msg.message = { conversation: cmd }
+                return false
+            }
+        }
+        return false
+    }
+
+    // Wrap the user's messages.upsert registration so the sheet fires first
+    // and consumed clicks never reach the bot's command parser.
+    const origOn = sock.ev.on.bind(sock.ev)
+    sock.ev.on = function (ev, handler) {
+        if (ev === 'messages.upsert') {
+            return origOn(ev, async (...args) => {
+                const consumed = await handleUpsert(args[0]).catch(() => false)
+                if (consumed) return true
+                return handler(...args)
+            })
+        }
+        return origOn(ev, handler)
+    }
+
+    return () => { sock.ev.on = origOn }
+}

package/lib/Utils/messages.js

@@ -699,56 +699,23 @@ export const generateWAMessageContent = async (message, options) => {
 		const rawExtras = (inputButtons || []).filter(b =>
 			b?.nativeFlowInfo?.name || Number(b?.type) === proto.Message.ButtonsMessage.Button.Type.NATIVE_FLOW)
 		if (rawExtras.length) {
-			const rawLoc = raw.locationMessage
-			const flowButtons = inputButtons.map(b => {
-				const name = b?.nativeFlowInfo?.name
-				if (name === 'single_select') {
-					let params = b.nativeFlowInfo.paramsJson
-					try { params = JSON.stringify(JSON.parse(params)) } catch { params = typeof params === 'string' ? params : '{}' }
-					return { name: 'single_select', buttonParamsJson: params }
-				}
-				if (name) {
-					return { name, buttonParamsJson: b.nativeFlowInfo.buttonParamsJson || b.nativeFlowInfo.paramsJson || '{}' }
-				}
-				return {
-					name: 'quick_reply',
-					buttonParamsJson: JSON.stringify({
-						display_text: b.buttonText?.displayText || '',
-						id: b.buttonId || b.buttonText?.displayText || ''
-					})
-				}
-			})
-			const interactiveMessage = {
-				nativeFlowMessage: { buttons: flowButtons, messageParamsJson: '', messageVersion: 1 }
-			};				const bodyText = raw.contentText || (raw.imageMessage?.caption ?? raw.videoMessage?.caption ?? '') || ''
-				if (bodyText) interactiveMessage.body = { text: bodyText };
-			if (raw.footerText) interactiveMessage.footer = { text: raw.footerText };
-			const header = { title: raw.text || (interactiveMessage.body.text ? String(interactiveMessage.body.text).split('\n')[0].slice(0, 42) : '') || 'Menu', subtitle: '', hasMediaAttachment: false };
-			if (rawLoc) {
-				header.locationMessage = {
-					degreesLatitude: rawLoc.degreesLatitude ?? 0,
-					degreesLongitude: rawLoc.degreesLongitude ?? 0,
-					name: rawLoc.name ?? null,
-					address: rawLoc.address ?? null,
-					...(rawLoc.jpegThumbnail ? { jpegThumbnail: rawLoc.jpegThumbnail } : {})
-				};
-				header.hasMediaAttachment = true;
-			} else if (raw.imageMessage) {
-				header.imageMessage = raw.imageMessage;
-				header.hasMediaAttachment = true;
-			} else if (raw.videoMessage) {
-				header.videoMessage = raw.videoMessage;
-				header.hasMediaAttachment = true;
-			} else if (raw.documentMessage) {
-				header.documentMessage = raw.documentMessage;
-				header.hasMediaAttachment = true;
-			}
-			if (header.title || header.hasMediaAttachment) interactiveMessage.header = header;
-			if (raw.contextInfo?.mentionedJid?.length) {
-				interactiveMessage.contextInfo = { mentionedJid: raw.contextInfo.mentionedJid };
-			}
-			m = { interactiveMessage };
-		} else {
+			// PATCH (1.0.28): a raw classic message that MIXES native-flow extras
+			// (single_select nativeFlowInfo, cta_* buttons) into a ButtonsMessage is
+			// the Case X / cantarella menu-card pattern — on current clients it
+			// renders as "version doesn't support it" (real-device evidence).
+			// Instead of upgrading to the vertical native-flow card, keep the
+			// HORIZONTAL classic layout: every extra becomes a plain RESPONSE
+			// button with its original buttonId, clicks arrive as
+			// buttonsResponseMessage, and the bot sends the list sheet / URL /
+			// copy action itself (e.g. a separate nativeFlow message). The header
+			// (location/image/video/document) is preserved untouched — that is the
+			// proven horizontal Case X / cantarella render.
+			raw.buttons = inputButtons.map(b => proto.Message.ButtonsMessage.Button.fromObject({
+				buttonId: b?.buttonId || b?.buttonText?.displayText || 'button',
+				buttonText: { displayText: b?.buttonText?.displayText || b?.displayText || 'Button' },
+				type: proto.Message.ButtonsMessage.Button.Type.RESPONSE
+			}))
+		}
 		if (!hasHeader) {
 			try {
 				const media = await prepareWAMessageMedia({ image: BUTTONS_INVISIBLE_PNG() }, options)
@@ -757,7 +724,6 @@ export const generateWAMessageContent = async (message, options) => {
 			} catch { /* upload failed — send as-is */ }
 		}
 		m = { buttonsMessage: raw };
-		}
 	}
 	else if ('buttons' in message && !!message.buttons) {
         // PATCH: `buttons` API — HORIZONTAL button row via classic ButtonsMessage

package/lib/index.js

@@ -2,6 +2,7 @@ import makeWASocket from './Socket/index.js';
 import chalk from "chalk";
 import { enableCallAutoAnswer, getActiveVoipClient, CallState } from './Caller/auto-answer.js';
 import { attachProMethods } from './Pro/index.js';
+import { attachSheetAutoReply, sendSheet, decodeButtonClick } from './Pro/sheet-buttons.js';
 import * as PollsPro from './Pro/polls.js';
 import * as NewsletterPro from './Pro/newsletter.js';
 import * as StatusPro from './Pro/status.js';
@@ -91,5 +92,8 @@ export const removeProfilePicture = ProfilePro.removeProfilePicture;
 export const rejectCall = ProfilePro.rejectCall;
 
 export { enableCallAutoAnswer, getActiveVoipClient, CallState, attachProMethods, makeWASocket };
+
+// One-tap horizontal button → automatic list sheet (v1.0.28+)
+export { attachSheetAutoReply, sendSheet, decodeButtonClick };
 export default makeWASocket;
 //# sourceMappingURL=index.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "ishumdz-bail",
-    "version": "1.0.27",
+    "version": "1.0.29",
     "description": "WhatsApp API Modification By Lovely",
     "keywords": [
         "whatsapp",