@pontalabs/baileys 1.0.11 → 1.1.0

package/lib/Utils/messages.js

@@ -16,6 +16,48 @@ const generics_1 = require("./generics")
 const messages_media_1 = require("./messages-media")
 const rich_message_utils_1 = require("./rich-message-utils")
 
+// --- shim kompatibilitas tambahan dari @pontalabs 1.1.9 (untuk richMessage/buttonsMessage) ---
+const Jimp = require("jimp")
+const { proto } = WAProto_1
+const { getStream, toBuffer } = messages_media_1
+const { promises } = fs_1
+const hasNonNullishProperty = (message, key) =>
+    typeof message === "object" &&
+    message !== null &&
+    key in message &&
+    message[key] !== null &&
+    message[key] !== undefined
+async function processLocationThumbnail(input, options = {}) {
+    const {
+        maxWidth = 300,
+        maxHeight = 300,
+        quality = 80
+    } = options
+
+    let buffer
+
+    if (
+        typeof input === "string" &&
+        (input.startsWith("http://") || input.startsWith("https://"))
+    ) {
+        const { stream } = await getStream({ url: input })
+        buffer = await toBuffer(stream)
+    } else if (typeof input === "string") {
+        buffer = await promises.readFile(input)
+    } else if (Buffer.isBuffer(input)) {
+        buffer = input
+    } else {
+        throw new Error("thumbnail must be URL, path or Buffer")
+    }
+
+    const image = await Jimp.read(buffer)
+
+    image.scaleToFit(maxWidth, maxHeight)
+
+    return await image.quality(quality).getBufferAsync(Jimp.MIME_JPEG)
+}
+// --- akhir shim ---
+
 const MIMETYPE_MAP = {
     image: 'image/jpeg',
     video: 'video/mp4',
@@ -1434,6 +1476,450 @@ const generateWAMessageContent = async (message, options) => {
         m = {
             interactiveMessage
         }
+    } else if (hasNonNullishProperty(message, "buttonsMessage")) {
+    const btnMsg = { ...message.buttonsMessage };
+    if (btnMsg.locationMessage?.jpegThumbnail && !Buffer.isBuffer(btnMsg.locationMessage.jpegThumbnail)) {
+        btnMsg.locationMessage.jpegThumbnail = await processLocationThumbnail(btnMsg.locationMessage.jpegThumbnail);
+    }
+    m = { buttonsMessage: btnMsg };
+    } else if (hasNonNullishProperty(message, "richMessage")) {
+    const { randomUUID } = require('crypto');
+    const rich = message.richMessage;
+    const submessages = [];
+    const sections = [];
+    const richResponseSources = [];
+
+    const extractIE = (text) => {
+        let ie = [], result = '', last = 0, citation_index = 1, hyperlink_index = 0, latex_index = 0, stack = [];
+        for (let i = 0; i < text.length; i++) {
+            if (text[i] == '[' && text[i - 1] != '\\') {
+                stack.push(i);
+            } else if (text[i] == ']' && (text[i + 1] == '(' || text[i + 1] == '<')) {
+                let start = stack.pop();
+                if (start == null) continue;
+                let open = text[i + 1], close = open == '(' ? ')' : '>', type = open == '(' ? 'link' : 'latex', end = i + 2, depth = 1;
+                while (end < text.length && depth) {
+                    if (text[end] == open && text[end - 1] != '\\') depth++;
+                    else if (text[end] == close && text[end - 1] != '\\') depth--;
+                    end++;
+                }
+                if (depth) continue;
+                let raw = text.slice(start + 1, i).trim(), url = text.slice(i + 2, end - 1).trim(), key, tag, data;
+                if (type == 'latex') {
+                    let [txt = '', width = null, height = null, font_height = null, padding = null] = raw.split('|');
+                    key = `LATEX_${latex_index++}`;
+                    tag = `{{${key}}}${txt || 'image'}{{/${key}}}`;
+                    data = { type: 'latex', ie: { key, text: txt, url, width, height, font_height, padding } };
+                } else if (raw) {
+                    key = `HLINK_${hyperlink_index++}`;
+                    tag = `{{${key}}}${url}{{/${key}}}`;
+                    data = { type: 'hyperlink', ie: { key, text: raw, url } };
+                } else {
+                    key = `CITE_${citation_index - 1}`;
+                    tag = `{{${key}}}${url}{{/${key}}}`;
+                    data = { type: 'citation', ie: { reference_id: citation_index++, key, text: '', url } };
+                }
+                result += text.slice(last, start) + tag;
+                last = end;
+                ie.push(data);
+                i = end - 1;
+            }
+        }
+        result += text.slice(last);
+        return { text: result, ie };
+    };
+
+    const tokenizer = (code, lang = 'javascript') => {
+        const keywordsMap = {
+            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'])
+        };
+        const TYPE_MAP = { 0:'DEFAULT', 1:'KEYWORD', 2:'METHOD', 3:'STR', 4:'NUMBER', 5:'COMMENT' };
+        const keywords = keywordsMap[lang] || 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)) { let s = i; while (i < code.length && /\s/.test(code[i])) i++; push(code.slice(s, i), 0); continue; }
+            if (c === '/' && code[i + 1] === '/') { let s = i; i += 2; while (i < code.length && code[i] !== '\n') i++; push(code.slice(s, i), 5); continue; }
+            if (c === '"' || c === "'" || c === '`') { let s = i; const q = c; i++; while (i < code.length) { if (code[i] === '\\' && i + 1 < code.length) i += 2; else if (code[i] === q) { i++; break; } else i++; } push(code.slice(s, i), 3); continue; }
+            if (/[0-9]/.test(c)) { let 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)) { let s = i; while (i < code.length && /[a-zA-Z0-9_$]/.test(code[i])) i++; const word = code.slice(s, i); let type = 0; if (keywords.has(word)) type = 1; else { 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] })) };
+    };
+
+    const toTableMetadata = (arr) => {
+        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) }))];
+        const rowsMeta = unified_rows.map(r => ({ items: r.cells, ...(r.is_header ? { isHeading: true } : {}) }));
+        return { title: '', rows: rowsMeta, unified_rows };
+    };
+
+    if (rich.text) {
+        const parsed = typeof rich.text === 'string' ? extractIE(rich.text) : rich.text;
+        const text = parsed.text || parsed;
+        const inline_entities = parsed.ie ? parsed.ie.map(({ type, ie }) => {
+            if (type === 'hyperlink') return { key: ie.key, metadata: { display_name: ie.text, is_trusted: true, url: ie.url, __typename: 'GenAIInlineLinkItem' } };
+            if (type === 'citation') return { key: ie.key, metadata: { reference_id: ie.reference_id, reference_url: ie.url, reference_title: ie.url, reference_display_name: ie.url, sources: [], __typename: 'GenAISearchCitationItem' } };
+            if (type === 'latex') return { key: ie.key, metadata: { latex_expression: ie.text || '', latex_image: { url: ie.url, width: Number(ie.width) || 100, height: Number(ie.height) || 100 }, font_height: Number(ie.font_height) || 83.33, padding: Number(ie.padding) || 15, __typename: 'GenAILatexItem' } };
+            return null;
+        }).filter(Boolean) : [];
+        submessages.push({ messageType: 2, messageText: text });
+        sections.push({
+            view_model: {
+                primitive: { text, inline_entities, __typename: 'GenAIMarkdownTextUXPrimitive' },
+                __typename: 'GenAISingleLayoutViewModel'
+            }
+        });
+    }
+
+    if (rich.code) {
+        const { language, code } = rich.code;
+        const tok = tokenizer(code, language);
+        submessages.push({ messageType: 5, codeMetadata: { codeLanguage: language, codeBlocks: tok.codeBlock } });
+        sections.push({
+            view_model: {
+                primitive: { language, code_blocks: tok.unified_codeBlock, __typename: 'GenAICodeUXPrimitive' },
+                __typename: 'GenAISingleLayoutViewModel'
+            }
+        });
+    }
+
+    if (rich.table) {
+        const meta = toTableMetadata(rich.table);
+        submessages.push({ messageType: 4, tableMetadata: { title: meta.title, rows: meta.rows } });
+        sections.push({
+            view_model: {
+                primitive: { rows: meta.unified_rows, __typename: 'GenATableUXPrimitive' },
+                __typename: 'GenAISingleLayoutViewModel'
+            }
+        });
+    }
+
+    if (rich.images) {
+        const urls = Array.isArray(rich.images) ? rich.images : [rich.images];
+        submessages.push({
+            messageType: 1,
+            gridImageMetadata: {
+                gridImageUrl: { imagePreviewUrl: urls[0] },
+                imageUrls: urls.map(url => ({ imagePreviewUrl: url, imageHighResUrl: url, sourceUrl: 'https://www.levvicode.cloud/' }))
+            }
+        });
+        urls.forEach(url => {
+            sections.push({
+                view_model: {
+                    primitive: { media: { url, mime_type: 'image/jpeg' }, imagine_type: 3, status: { status: 'READY' }, __typename: 'GenAIImaginePrimitive' },
+                    __typename: 'GenAISingleLayoutViewModel'
+                }
+            });
+        });
+    }
+
+    if (rich.video) {
+        submessages.push({ messageType: 2, messageText: '[ CANNOT_LOAD_VIDEO - Ponta ]' });
+        sections.push({
+            view_model: {
+                primitive: {
+                    media: { url: rich.video, mime_type: 'video/mp4', duration: 10 },
+                    imagine_type: 'ANIMATE',
+                    status: { status: 'READY' },
+                    __typename: 'GenAIImaginePrimitive'
+                },
+                __typename: 'GenAISingleLayoutViewModel'
+            }
+        });
+    }
+
+    if (rich.productSingle) {
+        submessages.push({ messageType: 2, messageText: '[ CANNOT_LOAD_PRODUCT - Ponta ]' });
+        sections.push({
+            view_model: {
+                primitive: { ...rich.productSingle, __typename: 'GenAIProductItemCardPrimitive' },
+                __typename: 'GenAISingleLayoutViewModel'
+            }
+        });
+    }
+
+    if (rich.productMultiple) {
+        submessages.push({ messageType: 2, messageText: '[ CANNOT_LOAD_PRODUCT - Ponta ]' });
+        sections.push({
+            view_model: {
+                primitives: rich.productMultiple.map(p => ({ ...p, __typename: 'GenAIProductItemCardPrimitive' })),
+                __typename: 'GenAIHScrollLayoutViewModel'
+            }
+        });
+    }
+
+    if (rich.product && !rich.productSingle && !rich.productMultiple) {
+        submessages.push({ messageType: 2, messageText: '[ CANNOT_LOAD_PRODUCT - Ponta ]' });
+        if (Array.isArray(rich.product)) {
+            sections.push({
+                view_model: {
+                    primitives: rich.product.map(p => ({ ...p, __typename: 'GenAIProductItemCardPrimitive' })),
+                    __typename: 'GenAIHScrollLayoutViewModel'
+                }
+            });
+        } else {
+            sections.push({
+                view_model: {
+                    primitive: { ...rich.product, __typename: 'GenAIProductItemCardPrimitive' },
+                    __typename: 'GenAISingleLayoutViewModel'
+                }
+            });
+        }
+    }
+
+    if (rich.post) {
+        submessages.push({ messageType: 2, messageText: '[ CANNOT_LOAD_POST - Ponta ]' });
+        if (Array.isArray(rich.post)) {
+            sections.push({
+                view_model: {
+                    primitives: rich.post.map(p => ({ ...p, __typename: 'GenAIPostPrimitive' })),
+                    __typename: 'GenAIHScrollLayoutViewModel'
+                }
+            });
+        } else {
+            sections.push({
+                view_model: {
+                    primitive: { ...rich.post, __typename: 'GenAIPostPrimitive' },
+                    __typename: 'GenAISingleLayoutViewModel'
+                }
+            });
+        }
+    }
+
+    if (rich.reels) {
+        const items = Array.isArray(rich.reels) ? rich.reels : [rich.reels];
+        submessages.push({
+            messageType: 9,
+            contentItemsMetadata: {
+                contentType: 1,
+                itemsMetadata: items.map(i => ({
+                    reelItem: { title: i.title, profileIconUrl: i.profileIconUrl, thumbnailUrl: i.thumbnailUrl, videoUrl: i.videoUrl }
+                }))
+            }
+        });
+        sections.push({
+            view_model: {
+                primitives: items.map(i => ({
+                    reels_url: i.videoUrl,
+                    thumbnail_url: i.thumbnailUrl,
+                    creator: i.title,
+                    avatar_url: i.profileIconUrl,
+                    reels_title: i.reels_title || '',
+                    likes_count: i.likes_count || 0,
+                    shares_count: i.shares_count || 0,
+                    view_count: i.view_count || 0,
+                    reel_source: i.reel_source || 'IG',
+                    is_verified: i.is_verified || false,
+                    __typename: 'GenAIReelPrimitive'
+                })),
+                __typename: 'GenAIHScrollLayoutViewModel'
+            }
+        });
+        items.forEach((i, idx) => richResponseSources.push({
+            provider: 'Ponta',
+            thumbnailCDNURL: i.thumbnailUrl,
+            sourceProviderURL: i.videoUrl,
+            sourceQuery: '',
+            faviconCDNURL: i.profileIconUrl,
+            citationNumber: idx + 1,
+            sourceTitle: i.title
+        }));
+    }
+
+    if (rich.sources) {
+        const sourceArr = Array.isArray(rich.sources) ? rich.sources : [rich.sources];
+        sections.push({
+            view_model: {
+                primitive: {
+                    sources: sourceArr.map(s => typeof s === 'object' ? s : {
+                        source_type: 'THIRD_PARTY',
+                        source_display_name: s[2] || '',
+                        source_subtitle: 'AI',
+                        source_url: s[1] || '',
+                        favicon: { url: s[0] || '', mime_type: 'image/jpeg', width: 16, height: 16 }
+                    }),
+                    __typename: 'GenAISearchResultPrimitive'
+                },
+                __typename: 'GenAISingleLayoutViewModel'
+            }
+        });
+    }
+
+    if (rich.tip) {
+        submessages.push({ messageType: 2, messageText: rich.tip });
+        sections.push({
+            view_model: {
+                primitive: { text: rich.tip, __typename: 'GenAIMetadataTextPrimitive' },
+                __typename: 'GenAISingleLayoutViewModel'
+            }
+        });
+    }
+
+    if (rich.suggestions) {
+        sections.push({
+            view_model: {
+                primitives: rich.suggestions.map(s => ({
+                    prompt_text: s,
+                    prompt_type: 'SUGGESTED_PROMPT',
+                    __typename: 'GenAIFollowUpSuggestionPillPrimitive'
+                })),
+                __typename: 'GenAIActionRowLayoutViewModel'
+            }
+        });
+    }
+
+    if (rich.footer) {
+        sections.push({
+            view_model: {
+                primitive: { text: rich.footer, __typename: 'GenAIMetadataTextPrimitive' },
+                __typename: 'GenAISingleLayoutViewModel'
+            }
+        });
+    }
+
+    const unifiedData = { response_id: randomUUID(), sections };
+
+    m = {
+        messageContextInfo: {
+            deviceListMetadata: {},
+            deviceListMetadataVersion: 2,
+            botMetadata: {
+                messageDisclaimerText: rich.title || '',
+                richResponseSourcesMetadata: { sources: richResponseSources }
+            }
+        },
+        botForwardedMessage: {
+            message: {
+                richResponseMessage: {
+                    messageType: 1,
+                    submessages,
+                    unifiedResponse: {
+                        data: Buffer.from(JSON.stringify(unifiedData)).toString('base64')
+                    },
+                    contextInfo: {
+                        forwardingScore: 1,
+                        isForwarded: true,
+                        forwardedAiBotMessageInfo: { botJid: '0@bot' },
+                        forwardOrigin: 4
+                    }
+                }
+            }
+        }
+    };
+}
+
+
+
+ else {
+    m = await prepareWAMessageMedia(message, options);
+}    
+    
+    if (hasNonNullishProperty(message, "buttonReply")) {
+        switch (message.type) {
+            case "list":
+                m.listResponseMessage = {
+                    title: message.buttonReply.title,
+                    description: message.buttonReply.description,
+                    singleSelectReply: { selectedRowId: message.buttonReply.rowId },
+                    lisType: proto.Message.ListResponseMessage.ListType.SINGLE_SELECT,
+                };
+                break;
+            case "template":
+                m.templateButtonReplyMessage = {
+                    selectedDisplayText: message.buttonReply.displayText,
+                    selectedId: message.buttonReply.id,
+                    selectedIndex: message.buttonReply.index,
+                };
+                break;
+            case "plain":
+                m.buttonsResponseMessage = {
+                    selectedButtonId: message.buttonReply.id,
+                    selectedDisplayText: message.buttonReply.displayText,
+                    type: proto.Message.ButtonsResponseMessage.Type.DISPLAY_TEXT,
+                };
+                break;
+            case "interactive":
+                m.interactiveResponseMessage = {
+                    body: {
+                        text: message.buttonReply.displayText,
+                        format: proto.Message.InteractiveResponseMessage.Body.Format.EXTENSIONS_1,
+                    },
+                    nativeFlowResponseMessage: {
+                        name: message.buttonReply.nativeFlows.name,
+                        paramsJson: message.buttonReply.nativeFlows.paramsJson,
+                        version: message.buttonReply.nativeFlows.version,
+                    },
+                };
+                break;
+        }
+    } else if (hasNonNullishProperty(message, "templateButtons")) {
+        const hydratedTemplate = { hydratedButtons: message.templateButtons };
+        if (hasNonNullishProperty(message, "text")) {
+            hydratedTemplate.hydratedContentText = message.text;
+        } else {
+            if (hasNonNullishProperty(message, "caption")) {
+                hydratedTemplate.hydratedContentText = message.caption;
+            }
+            Object.assign(msg, m);
+        }
+        if (hasNonNullishProperty(message, "footer")) {
+            hydratedTemplate.hydratedFooterText = message.footer;
+        }
+        m = { templateMessage: { hydratedTemplate: hydratedTemplate } };
+    } else if (hasNonNullishProperty(message, "interactiveButtons")) {
+        const interactiveMessage = {
+            nativeFlowMessage: { buttons: message.interactiveButtons },
+        };
+        if (hasNonNullishProperty(message, "text")) {
+            interactiveMessage.body = { text: message.text };
+        }
+        if (hasNonNullishProperty(message, "title")) {
+            interactiveMessage.header = {
+                title: message.title,
+                subtitle: null,
+                hasMediaAttachment: false,
+            };
+            if (hasNonNullishProperty(message, "subtitle")) {
+                interactiveMessage.header.subtitle = message.subtitle;
+            }
+        } else {
+            if (hasNonNullishProperty(message, "caption")) {
+                interactiveMessage.body = { text: message.caption };
+                interactiveMessage.header = {
+                    title: null,
+                    subtitle: null,
+                    hasMediaAttachment: false,
+                    ...Object.assign(interactiveMessage, m),
+                };
+                if (hasNonNullishProperty(message, "title")) {
+                    interactiveMessage.header.title = message.title;
+                }
+                if (hasNonNullishProperty(message, "subtitle")) {
+                    interactiveMessage.header.subtitle = message.subtitle;
+                }
+                if (hasNonNullishProperty(message, "hasMediaAttachment")) {
+                    interactiveMessage.header.hasMediaAttachment = Boolean(
+                        message.hasMediaAttachment
+                    );
+                }
+            }
+        }
+        if (hasNonNullishProperty(message, "footer")) {
+            interactiveMessage.footer = { text: message.footer };
+        }
+        m = { interactiveMessage: interactiveMessage };
+    } else if (hasNonNullishProperty(message, "shop")) {
     }
 
     if ('ephemeral' in message && !!message.ephemeral) {
@@ -1735,6 +2221,34 @@ function getAggregateVotesInPollMessage({
     return Object.values(voteHashMap)
 }
 
+// --- tambahan dari @pontalabs 1.1.9: dukungan Event RSVP response ---
+const updateMessageWithEventResponse = (msg, update) => {
+    const authorID = generics_1.getKeyAuthor(update.eventResponseMessageKey)
+    const responses = (msg.eventResponses || []).filter(
+        (r) => generics_1.getKeyAuthor(r.eventResponseMessageKey) !== authorID
+    )
+    responses.push(update)
+    msg.eventResponses = responses
+}
+function getAggregateResponsesInEventMessage({ eventResponses }, meLid) {
+    const responseTypes = ["GOING", "NOT_GOING", "MAYBE"]
+    const responseMap = {}
+    for (const type of responseTypes) {
+        responseMap[type] = { response: type, responders: [] }
+    }
+    for (const update of eventResponses) {
+        const { response } = update.response || 0
+        const responseType = proto.Message.EventResponseMessage.EventResponseType[response]
+        if (responseType !== "UNKNOWN" && responseMap[responseType]) {
+            responseMap[responseType].responders.push(
+                generics_1.getKeyAuthor(update.eventResponseMessageKey, meLid)
+            )
+        }
+    }
+    return Object.values(responseMap)
+}
+// --- akhir tambahan ---
+
 const aggregateMessageKeysNotFromMe = (keys) => {
     const keyMap = {}
 
@@ -1867,9 +2381,12 @@ module.exports = {
     updateMessageWithReceipt,
     updateMessageWithReaction,
     updateMessageWithPollUpdate,
+    updateMessageWithEventResponse,
     getAggregateVotesInPollMessage,
+    getAggregateResponsesInEventMessage,
     aggregateMessageKeysNotFromMe,
     downloadMediaMessage,
     assertMediaContent,
-    patchMessageForMdIfRequired
+    patchMessageForMdIfRequired,
+    hasNonNullishProperty
 }