@rennzsync/baileys 10.4.0 → 10.5.0

package/WAProto/index.js

@@ -100910,6 +100910,7 @@ export const proto = $root.proto = (() => {
              * @property {proto.Message.InteractiveMessage.IHeader|null} [header] InteractiveMessage header
              * @property {proto.Message.InteractiveMessage.IBody|null} [body] InteractiveMessage body
              * @property {proto.Message.InteractiveMessage.IFooter|null} [footer] InteractiveMessage footer
+             * @property {proto.Message.InteractiveMessage.IBloksWidget|null} [bloksWidget] InteractiveMessage bloksWidget
              * @property {proto.IContextInfo|null} [contextInfo] InteractiveMessage contextInfo
              * @property {proto.IUrlTrackingMap|null} [urlTrackingMap] InteractiveMessage urlTrackingMap
              * @property {proto.Message.InteractiveMessage.IShopMessage|null} [shopStorefrontMessage] InteractiveMessage shopStorefrontMessage
@@ -100957,6 +100958,14 @@ export const proto = $root.proto = (() => {
              */
             InteractiveMessage.prototype.footer = null;
 
+            /**
+             * InteractiveMessage bloksWidget.
+             * @member {proto.Message.InteractiveMessage.IBloksWidget|null|undefined} bloksWidget
+             * @memberof proto.Message.InteractiveMessage
+             * @instance
+             */
+            InteractiveMessage.prototype.bloksWidget = null;
+
             /**
              * InteractiveMessage contextInfo.
              * @member {proto.IContextInfo|null|undefined} contextInfo
@@ -101026,6 +101035,12 @@ export const proto = $root.proto = (() => {
                 set: $util.oneOfSetter($oneOfFields)
             });
 
+            // Virtual OneOf for proto3 optional field
+            Object.defineProperty(InteractiveMessage.prototype, "_bloksWidget", {
+                get: $util.oneOfGetter($oneOfFields = ["bloksWidget"]),
+                set: $util.oneOfSetter($oneOfFields)
+            });
+
             // Virtual OneOf for proto3 optional field
             Object.defineProperty(InteractiveMessage.prototype, "_contextInfo", {
                 get: $util.oneOfGetter($oneOfFields = ["contextInfo"]),
@@ -101091,6 +101106,8 @@ export const proto = $root.proto = (() => {
                     $root.proto.Message.InteractiveMessage.NativeFlowMessage.encode(message.nativeFlowMessage, writer.uint32(/* id 6, wireType 2 =*/50).fork(), q + 1).ldelim();
                 if (message.carouselMessage != null && Object.hasOwnProperty.call(message, "carouselMessage"))
                     $root.proto.Message.InteractiveMessage.CarouselMessage.encode(message.carouselMessage, writer.uint32(/* id 7, wireType 2 =*/58).fork(), q + 1).ldelim();
+                if (message.bloksWidget != null && Object.hasOwnProperty.call(message, "bloksWidget"))
+                    $root.proto.Message.InteractiveMessage.BloksWidget.encode(message.bloksWidget, writer.uint32(/* id 8, wireType 2 =*/66).fork(), q + 1).ldelim();
                 if (message.contextInfo != null && Object.hasOwnProperty.call(message, "contextInfo"))
                     $root.proto.ContextInfo.encode(message.contextInfo, writer.uint32(/* id 15, wireType 2 =*/122).fork(), q + 1).ldelim();
                 if (message.urlTrackingMap != null && Object.hasOwnProperty.call(message, "urlTrackingMap"))
@@ -101157,6 +101174,10 @@ export const proto = $root.proto = (() => {
                             message.footer = $root.proto.Message.InteractiveMessage.Footer.decode(reader, reader.uint32(), undefined, long + 1);
                             break;
                         }
+                    case 8: {
+                            message.bloksWidget = $root.proto.Message.InteractiveMessage.BloksWidget.decode(reader, reader.uint32(), undefined, long + 1);
+                            break;
+                        }
                     case 15: {
                             message.contextInfo = $root.proto.ContextInfo.decode(reader, reader.uint32(), undefined, long + 1);
                             break;
@@ -101250,6 +101271,14 @@ export const proto = $root.proto = (() => {
                             return "footer." + error;
                     }
                 }
+                if (message.bloksWidget != null && Object.hasOwnProperty.call(message, "bloksWidget")) {
+                    properties._bloksWidget = 1;
+                    {
+                        let error = $root.proto.Message.InteractiveMessage.BloksWidget.verify(message.bloksWidget, long + 1);
+                        if (error)
+                            return "bloksWidget." + error;
+                    }
+                }
                 if (message.contextInfo != null && Object.hasOwnProperty.call(message, "contextInfo")) {
                     properties._contextInfo = 1;
                     {
@@ -101340,6 +101369,11 @@ export const proto = $root.proto = (() => {
                         throw TypeError(".proto.Message.InteractiveMessage.footer: object expected");
                     message.footer = $root.proto.Message.InteractiveMessage.Footer.fromObject(object.footer, long + 1);
                 }
+                if (object.bloksWidget != null) {
+                    if (!$util.isObject(object.bloksWidget))
+                        throw TypeError(".proto.Message.InteractiveMessage.bloksWidget: object expected");
+                    message.bloksWidget = $root.proto.Message.InteractiveMessage.BloksWidget.fromObject(object.bloksWidget, long + 1);
+                }
                 if (object.contextInfo != null) {
                     if (!$util.isObject(object.contextInfo))
                         throw TypeError(".proto.Message.InteractiveMessage.contextInfo: object expected");
@@ -101425,6 +101459,11 @@ export const proto = $root.proto = (() => {
                     if (options.oneofs)
                         object.interactiveMessage = "carouselMessage";
                 }
+                if (message.bloksWidget != null && Object.hasOwnProperty.call(message, "bloksWidget")) {
+                    object.bloksWidget = $root.proto.Message.InteractiveMessage.BloksWidget.toObject(message.bloksWidget, options, q + 1);
+                    if (options.oneofs)
+                        object._bloksWidget = "bloksWidget";
+                }
                 if (message.contextInfo != null && Object.hasOwnProperty.call(message, "contextInfo")) {
                     object.contextInfo = $root.proto.ContextInfo.toObject(message.contextInfo, options, q + 1);
                     if (options.oneofs)
@@ -101464,6 +101503,360 @@ export const proto = $root.proto = (() => {
                 return typeUrlPrefix + "/proto.Message.InteractiveMessage";
             };
 
+            InteractiveMessage.BloksWidget = (function() {
+
+                /**
+                 * Properties of a BloksWidget.
+                 * @memberof proto.Message.InteractiveMessage
+                 * @interface IBloksWidget
+                 * @property {string|null} [uuid] BloksWidget uuid
+                 * @property {string|null} [data] BloksWidget data
+                 * @property {string|null} [type] BloksWidget type
+                 * @property {string|null} [fallback] BloksWidget fallback
+                 */
+
+                /**
+                 * Constructs a new BloksWidget.
+                 * @memberof proto.Message.InteractiveMessage
+                 * @classdesc Represents a BloksWidget.
+                 * @implements IBloksWidget
+                 * @constructor
+                 * @param {proto.Message.InteractiveMessage.IBloksWidget=} [properties] Properties to set
+                 */
+                function BloksWidget(properties) {
+                    if (properties)
+                        for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)
+                            if (properties[keys[i]] != null && keys[i] !== "__proto__")
+                                this[keys[i]] = properties[keys[i]];
+                }
+
+                /**
+                 * BloksWidget uuid.
+                 * @member {string|null|undefined} uuid
+                 * @memberof proto.Message.InteractiveMessage.BloksWidget
+                 * @instance
+                 */
+                BloksWidget.prototype.uuid = null;
+
+                /**
+                 * BloksWidget data.
+                 * @member {string|null|undefined} data
+                 * @memberof proto.Message.InteractiveMessage.BloksWidget
+                 * @instance
+                 */
+                BloksWidget.prototype.data = null;
+
+                /**
+                 * BloksWidget type.
+                 * @member {string|null|undefined} type
+                 * @memberof proto.Message.InteractiveMessage.BloksWidget
+                 * @instance
+                 */
+                BloksWidget.prototype.type = null;
+
+                /**
+                 * BloksWidget fallback.
+                 * @member {string|null|undefined} fallback
+                 * @memberof proto.Message.InteractiveMessage.BloksWidget
+                 * @instance
+                 */
+                BloksWidget.prototype.fallback = null;
+
+                // OneOf field names bound to virtual getters and setters
+                let $oneOfFields;
+
+                // Virtual OneOf for proto3 optional field
+                Object.defineProperty(BloksWidget.prototype, "_uuid", {
+                    get: $util.oneOfGetter($oneOfFields = ["uuid"]),
+                    set: $util.oneOfSetter($oneOfFields)
+                });
+
+                // Virtual OneOf for proto3 optional field
+                Object.defineProperty(BloksWidget.prototype, "_data", {
+                    get: $util.oneOfGetter($oneOfFields = ["data"]),
+                    set: $util.oneOfSetter($oneOfFields)
+                });
+
+                // Virtual OneOf for proto3 optional field
+                Object.defineProperty(BloksWidget.prototype, "_type", {
+                    get: $util.oneOfGetter($oneOfFields = ["type"]),
+                    set: $util.oneOfSetter($oneOfFields)
+                });
+
+                // Virtual OneOf for proto3 optional field
+                Object.defineProperty(BloksWidget.prototype, "_fallback", {
+                    get: $util.oneOfGetter($oneOfFields = ["fallback"]),
+                    set: $util.oneOfSetter($oneOfFields)
+                });
+
+                /**
+                 * Creates a new BloksWidget instance using the specified properties.
+                 * @function create
+                 * @memberof proto.Message.InteractiveMessage.BloksWidget
+                 * @static
+                 * @param {proto.Message.InteractiveMessage.IBloksWidget=} [properties] Properties to set
+                 * @returns {proto.Message.InteractiveMessage.BloksWidget} BloksWidget instance
+                 */
+                BloksWidget.create = function create(properties) {
+                    return new BloksWidget(properties);
+                };
+
+                /**
+                 * Encodes the specified BloksWidget message. Does not implicitly {@link proto.Message.InteractiveMessage.BloksWidget.verify|verify} messages.
+                 * @function encode
+                 * @memberof proto.Message.InteractiveMessage.BloksWidget
+                 * @static
+                 * @param {proto.Message.InteractiveMessage.IBloksWidget} message BloksWidget message or plain object to encode
+                 * @param {$protobuf.Writer} [writer] Writer to encode to
+                 * @returns {$protobuf.Writer} Writer
+                 */
+                BloksWidget.encode = function encode(message, writer, q) {
+                    if (!writer)
+                        writer = $Writer.create();
+                    if (q === undefined)
+                        q = 0;
+                    if (q > $util.recursionLimit)
+                        throw Error("max depth exceeded");
+                    if (message.uuid != null && Object.hasOwnProperty.call(message, "uuid"))
+                        writer.uint32(/* id 1, wireType 2 =*/10).string(message.uuid);
+                    if (message.data != null && Object.hasOwnProperty.call(message, "data"))
+                        writer.uint32(/* id 2, wireType 2 =*/18).string(message.data);
+                    if (message.type != null && Object.hasOwnProperty.call(message, "type"))
+                        writer.uint32(/* id 3, wireType 2 =*/26).string(message.type);
+                    if (message.fallback != null && Object.hasOwnProperty.call(message, "fallback"))
+                        writer.uint32(/* id 4, wireType 2 =*/34).string(message.fallback);
+                    return writer;
+                };
+
+                /**
+                 * Encodes the specified BloksWidget message, length delimited. Does not implicitly {@link proto.Message.InteractiveMessage.BloksWidget.verify|verify} messages.
+                 * @function encodeDelimited
+                 * @memberof proto.Message.InteractiveMessage.BloksWidget
+                 * @static
+                 * @param {proto.Message.InteractiveMessage.IBloksWidget} message BloksWidget message or plain object to encode
+                 * @param {$protobuf.Writer} [writer] Writer to encode to
+                 * @returns {$protobuf.Writer} Writer
+                 */
+                BloksWidget.encodeDelimited = function encodeDelimited(message, writer) {
+                    return this.encode(message, writer && writer.len ? writer.fork() : writer).ldelim();
+                };
+
+                /**
+                 * Decodes a BloksWidget message from the specified reader or buffer.
+                 * @function decode
+                 * @memberof proto.Message.InteractiveMessage.BloksWidget
+                 * @static
+                 * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+                 * @param {number} [length] Message length if known beforehand
+                 * @returns {proto.Message.InteractiveMessage.BloksWidget} BloksWidget
+                 * @throws {Error} If the payload is not a reader or valid buffer
+                 * @throws {$protobuf.util.ProtocolError} If required fields are missing
+                 */
+                BloksWidget.decode = function decode(reader, length, error, long) {
+                    if (!(reader instanceof $Reader))
+                        reader = $Reader.create(reader);
+                    if (long === undefined)
+                        long = 0;
+                    if (long > $Reader.recursionLimit)
+                        throw Error("maximum nesting depth exceeded");
+                    let end, message;
+                    if (length === undefined)
+                        end = reader.len;
+                    else {
+                        end = reader.pos + length;
+                        if (end > reader.len)
+                            throw RangeError("index out of range");
+                        length = reader.len;
+                        reader.len = end;
+                    }
+                    message = new $root.proto.Message.InteractiveMessage.BloksWidget();
+                    while (reader.pos < end) {
+                        let tag = reader.uint32();
+                        if (tag === error)
+                            break;
+                        switch (tag >>> 3) {
+                        case 1: {
+                                message.uuid = reader.string();
+                                break;
+                            }
+                        case 2: {
+                                message.data = reader.string();
+                                break;
+                            }
+                        case 3: {
+                                message.type = reader.string();
+                                break;
+                            }
+                        case 4: {
+                                message.fallback = reader.string();
+                                break;
+                            }
+                        default:
+                            reader.skipType(tag & 7, long);
+                            break;
+                        }
+                    }
+                    if (length !== undefined) {
+                        if (reader.pos !== end)
+                            throw RangeError("index out of range");
+                        reader.len = length;
+                    }
+                    return message;
+                };
+
+                /**
+                 * Decodes a BloksWidget message from the specified reader or buffer, length delimited.
+                 * @function decodeDelimited
+                 * @memberof proto.Message.InteractiveMessage.BloksWidget
+                 * @static
+                 * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+                 * @returns {proto.Message.InteractiveMessage.BloksWidget} BloksWidget
+                 * @throws {Error} If the payload is not a reader or valid buffer
+                 * @throws {$protobuf.util.ProtocolError} If required fields are missing
+                 */
+                BloksWidget.decodeDelimited = function decodeDelimited(reader) {
+                    if (!(reader instanceof $Reader))
+                        reader = new $Reader(reader);
+                    return this.decode(reader, reader.uint32());
+                };
+
+                /**
+                 * Verifies a BloksWidget message.
+                 * @function verify
+                 * @memberof proto.Message.InteractiveMessage.BloksWidget
+                 * @static
+                 * @param {Object.<string,*>} message Plain object to verify
+                 * @returns {string|null} `null` if valid, otherwise the reason why it is not
+                 */
+                BloksWidget.verify = function verify(message, long) {
+                    if (typeof message !== "object" || message === null)
+                        return "object expected";
+                    if (long === undefined)
+                        long = 0;
+                    if (long > $util.recursionLimit)
+                        return "maximum nesting depth exceeded";
+                    let properties = {};
+                    if (message.uuid != null && Object.hasOwnProperty.call(message, "uuid")) {
+                        properties._uuid = 1;
+                        if (!$util.isString(message.uuid))
+                            return "uuid: string expected";
+                    }
+                    if (message.data != null && Object.hasOwnProperty.call(message, "data")) {
+                        properties._data = 1;
+                        if (!$util.isString(message.data))
+                            return "data: string expected";
+                    }
+                    if (message.type != null && Object.hasOwnProperty.call(message, "type")) {
+                        properties._type = 1;
+                        if (!$util.isString(message.type))
+                            return "type: string expected";
+                    }
+                    if (message.fallback != null && Object.hasOwnProperty.call(message, "fallback")) {
+                        properties._fallback = 1;
+                        if (!$util.isString(message.fallback))
+                            return "fallback: string expected";
+                    }
+                    return null;
+                };
+
+                /**
+                 * Creates a BloksWidget message from a plain object. Also converts values to their respective internal types.
+                 * @function fromObject
+                 * @memberof proto.Message.InteractiveMessage.BloksWidget
+                 * @static
+                 * @param {Object.<string,*>} object Plain object
+                 * @returns {proto.Message.InteractiveMessage.BloksWidget} BloksWidget
+                 */
+                BloksWidget.fromObject = function fromObject(object, long) {
+                    if (object instanceof $root.proto.Message.InteractiveMessage.BloksWidget)
+                        return object;
+                    if (!$util.isObject(object))
+                        throw TypeError(".proto.Message.InteractiveMessage.BloksWidget: object expected");
+                    if (long === undefined)
+                        long = 0;
+                    if (long > $util.recursionLimit)
+                        throw Error("maximum nesting depth exceeded");
+                    let message = new $root.proto.Message.InteractiveMessage.BloksWidget();
+                    if (object.uuid != null)
+                        message.uuid = String(object.uuid);
+                    if (object.data != null)
+                        message.data = String(object.data);
+                    if (object.type != null)
+                        message.type = String(object.type);
+                    if (object.fallback != null)
+                        message.fallback = String(object.fallback);
+                    return message;
+                };
+
+                /**
+                 * Creates a plain object from a BloksWidget message. Also converts values to other types if specified.
+                 * @function toObject
+                 * @memberof proto.Message.InteractiveMessage.BloksWidget
+                 * @static
+                 * @param {proto.Message.InteractiveMessage.BloksWidget} message BloksWidget
+                 * @param {$protobuf.IConversionOptions} [options] Conversion options
+                 * @returns {Object.<string,*>} Plain object
+                 */
+                BloksWidget.toObject = function toObject(message, options, q) {
+                    if (!options)
+                        options = {};
+                    if (q === undefined)
+                        q = 0;
+                    if (q > $util.recursionLimit)
+                        throw Error("max depth exceeded");
+                    let object = {};
+                    if (message.uuid != null && Object.hasOwnProperty.call(message, "uuid")) {
+                        object.uuid = message.uuid;
+                        if (options.oneofs)
+                            object._uuid = "uuid";
+                    }
+                    if (message.data != null && Object.hasOwnProperty.call(message, "data")) {
+                        object.data = message.data;
+                        if (options.oneofs)
+                            object._data = "data";
+                    }
+                    if (message.type != null && Object.hasOwnProperty.call(message, "type")) {
+                        object.type = message.type;
+                        if (options.oneofs)
+                            object._type = "type";
+                    }
+                    if (message.fallback != null && Object.hasOwnProperty.call(message, "fallback")) {
+                        object.fallback = message.fallback;
+                        if (options.oneofs)
+                            object._fallback = "fallback";
+                    }
+                    return object;
+                };
+
+                /**
+                 * Converts this BloksWidget to JSON.
+                 * @function toJSON
+                 * @memberof proto.Message.InteractiveMessage.BloksWidget
+                 * @instance
+                 * @returns {Object.<string,*>} JSON object
+                 */
+                BloksWidget.prototype.toJSON = function toJSON() {
+                    return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+                };
+
+                /**
+                 * Gets the default type url for BloksWidget
+                 * @function getTypeUrl
+                 * @memberof proto.Message.InteractiveMessage.BloksWidget
+                 * @static
+                 * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
+                 * @returns {string} The default type url
+                 */
+                BloksWidget.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
+                    if (typeUrlPrefix === undefined) {
+                        typeUrlPrefix = "type.googleapis.com";
+                    }
+                    return typeUrlPrefix + "/proto.Message.InteractiveMessage.BloksWidget";
+                };
+
+                return BloksWidget;
+            })();
+
             InteractiveMessage.Body = (function() {
 
                 /**

package/lib/Socket/messages-send.js

@@ -2,9 +2,11 @@ import NodeCache from '@cacheable/node-cache';
 import { Boom } from '@hapi/boom';
 import { proto } from '../../WAProto/index.js';
 import { DEFAULT_CACHE_TTLS, WA_DEFAULT_EPHEMERAL } from '../Defaults/index.js';
-import { aggregateMessageKeysNotFromMe, assertMediaContent, assertMeId, bindWaitForEvent, decryptMediaRetryData, DEF_MEDIA_HOST, encodeNewsletterMessage, encodeSignedDeviceIdentity, encodeWAMessage, encryptMediaRetryRequest, extractDeviceJids, generateMessageIDV2, generateParticipantHashV2, generateWAMessage, getStatusCodeForMediaRetry, getUrlFromDirectPath, getWAUploadToServer, MessageRetryManager, normalizeMessageContent, parseAndInjectE2ESessions, unixTimestampSeconds } from '../Utils/index.js';
+import { aggregateMessageKeysNotFromMe, assertMediaContent, assertMeId, bindWaitForEvent, decryptMediaRetryData, DEF_MEDIA_HOST, encodeNewsletterMessage, encodeSignedDeviceIdentity, encodeWAMessage, encryptMediaRetryRequest, extractDeviceJids, generateMessageIDV2, generateParticipantHashV2, generateWAMessage, generateWAMessageFromContent, getStatusCodeForMediaRetry, getUrlFromDirectPath, getWAUploadToServer, MessageRetryManager, normalizeMessageContent, parseAndInjectE2ESessions, unixTimestampSeconds } from '../Utils/index.js';
 import { getUrlInfo } from '../Utils/link-preview.js';
 import { makeKeyedMutex, makeMutex } from '../Utils/make-mutex.js';
+import { buildRichMenuMessage } from '../Utils/rich-menu.js';
+import { sendA2UIWidget } from '../Utils/a2ui.js';
 import { getMessageReportingToken, shouldIncludeReportingToken } from '../Utils/reporting-utils.js';
 import { buildMergedTcTokenIndexWrite, isTcTokenExpired, resolveIssuanceJid, resolveTcTokenJid, shouldSendNewTcToken, storeTcTokensFromIqResult } from '../Utils/tc-token-utils.js';
 import { areJidsSameUser, getAdditionalNode, getBinaryNodeChild, getBinaryNodeChildren, isHostedLidUser, isHostedPnUser, isJidBot, isJidGroup, isJidMetaAI, isLidUser, isPnUser, jidDecode, jidEncode, jidNormalizedUser, PSA_WID, S_WHATSAPP_NET } from '../WABinary/index.js';
@@ -1098,6 +1100,16 @@ export const makeMessagesSocket = (config) => {
             ev.emit('messages.update', [{ key: message.key, update: { message: message.message } }]);
             return message;
         },
+        // Rich menu (tombol/kartu geser/header gambar/footer URL) — port dari @vansnowi/baileys
+        richMenu: async (jid, content = {}) => {
+            const waMsg = generateWAMessageFromContent(jid, buildRichMenuMessage(content), {
+                userJid: authState.creds.me.id
+            });
+            await relayMessage(jid, waMsg.message, { messageId: waMsg.key.id });
+            return waMsg;
+        },
+        // Widget A2UI (interactiveMessage.bloksWidget) — sock.sendA2UI(jid, { a2ui, bodyText, footer, buttons, ... })
+        sendA2UI: (jid, options = {}) => sendA2UIWidget({ relayMessage, user: authState.creds.me }, jid, options),
         sendMessage: async (jid, content, options = {}) => {
             const userJid = authState.creds.me.id;
             if (typeof content === 'object' &&