@areumtecnologia/wasockets 2.2.3 → 2.3.1

package/lib/Client/Builders/PollBuilder.js

@@ -0,0 +1,84 @@
+"use strict"
+
+Object.defineProperty(exports, "__esModule", { value: true })
+
+/**
+ * Fluent builder for WhatsApp Polls
+ */
+class PollBuilder {
+    constructor() {
+        this._name = ''
+        this._options = []
+        this._selectableCount = 1
+    }
+
+    /**
+     * Sets poll question / title
+     * @param {string} name
+     * @returns {this}
+     */
+    setName(name) {
+        this._name = name || ''
+        return this
+    }
+
+    /**
+     * Adds an option to the poll
+     * @param {string} option
+     * @returns {this}
+     */
+    addOption(option) {
+        if (option && typeof option === 'string') {
+            this._options.push(option.trim())
+        }
+        return this
+    }
+
+    /**
+     * Adds multiple options to the poll
+     * @param {Array<string>} options
+     * @returns {this}
+     */
+    addOptions(options) {
+        if (Array.isArray(options)) {
+            for (const opt of options) {
+                this.addOption(opt)
+            }
+        }
+        return this
+    }
+
+    /**
+     * Sets how many options can be selected (1 for single choice, > 1 for multiple choices)
+     * @param {number} count
+     * @returns {this}
+     */
+    setSelectableCount(count) {
+        this._selectableCount = Math.max(1, Number(count) || 1)
+        return this
+    }
+
+    /**
+     * Compiles poll into a payload for sendMessage()
+     * @returns {Object}
+     */
+    build() {
+        if (!this._name) {
+            throw new Error('PollBuilder requires a question name via setName().')
+        }
+        if (this._options.length < 2) {
+            throw new Error('PollBuilder requires at least 2 options.')
+        }
+
+        return {
+            poll: {
+                name: this._name,
+                values: this._options,
+                selectableCount: this._selectableCount
+            }
+        }
+    }
+}
+
+exports.PollBuilder = PollBuilder
+exports.default = PollBuilder

package/lib/Client/Builders/index.js

@@ -0,0 +1,21 @@
+"use strict"
+
+Object.defineProperty(exports, "__esModule", { value: true })
+
+const { InteractiveMessage } = require("./InteractiveMessage")
+const { QuickReplyButton, UrlButton, CopyCodeButton, CallButton, PixButton } = require("./Buttons")
+const { ListButton, ListSection, ListRow } = require("./Lists")
+const { PollBuilder } = require("./PollBuilder")
+const { EventBuilder } = require("./EventBuilder")
+
+exports.InteractiveMessage = InteractiveMessage
+exports.QuickReplyButton = QuickReplyButton
+exports.UrlButton = UrlButton
+exports.CopyCodeButton = CopyCodeButton
+exports.CallButton = CallButton
+exports.PixButton = PixButton
+exports.ListButton = ListButton
+exports.ListSection = ListSection
+exports.ListRow = ListRow
+exports.PollBuilder = PollBuilder
+exports.EventBuilder = EventBuilder

package/lib/Client/Constants.js

@@ -0,0 +1,54 @@
+"use strict"
+
+Object.defineProperty(exports, "__esModule", { value: true })
+
+/**
+ * High-level semantic event names for WaClient
+ */
+const Events = Object.freeze({
+    // Connection Lifecycle
+    STATUS_CHANGE: 'status.change',
+    QR_CODE: 'qr',
+    PAIRING_CODE: 'pairing.code',
+    CONNECTED: 'connected',
+    DISCONNECTED: 'disconnected',
+    LOGGED_OUT: 'logged.out',
+
+    // Messages
+    MESSAGE_RECEIVED: 'message.received',
+    MESSAGE_SENT: 'message.sent',
+    MESSAGE_UPDATE: 'message.update',
+    MESSAGE_DELETE: 'message.delete',
+
+    // Presence & Contacts
+    PRESENCE_UPDATE: 'presence.update',
+    CONTACTS_UPSERT: 'contacts.upsert',
+
+    // VoIP & Calls
+    CALL_INCOMING: 'call.incoming',
+    CALL_STATUS: 'call.status',
+
+    // Group & Community Events
+    GROUP_PARTICIPANTS_UPDATE: 'group.participants.update',
+
+    // Generic Error
+    ERROR: 'error'
+})
+
+/**
+ * Connection states for WaClient state machine
+ */
+const ConnectionStatus = Object.freeze({
+    IDLE: 'idle',
+    INITIALIZING: 'initializing',
+    CONNECTING: 'connecting',
+    QR_READY: 'qr_ready',
+    PAIRING_READY: 'pairing_ready',
+    CONNECTED: 'connected',
+    RECONNECTING: 'reconnecting',
+    LOGGED_OUT: 'logged_out',
+    DISCONNECTED: 'disconnected'
+})
+
+exports.Events = Events
+exports.ConnectionStatus = ConnectionStatus

package/lib/Client/Context/CallContext.js

@@ -0,0 +1,96 @@
+"use strict"
+
+Object.defineProperty(exports, "__esModule", { value: true })
+
+const { JidNormalizer } = require("../Normalizers/JidNormalizer")
+
+class CallContext {
+    /**
+     * @param {import('../WaClient').WaClient} client
+     * @param {Object} callData - Inbound call offer or active call metadata
+     * @param {Object} [activeCallInstance] - Low-level WebAssembly ActiveCall instance
+     */
+    constructor(client, callData, activeCallInstance = null) {
+        this.client = client
+        this.raw = callData || {}
+
+        this.id = this.raw.id || this.raw.callId || ''
+        this.from = this.raw.from || this.raw.chatId || ''
+        this.fromNumber = JidNormalizer.toPhoneNumber(this.from)
+        this.isVideo = Boolean(this.raw.isVideo)
+        this.status = this.raw.status || 'calling'
+        this.startTime = this.raw.date ? new Date(this.raw.date).getTime() : Date.now()
+        this.instance = activeCallInstance || null
+    }
+
+    _getSock() {
+        if (!this.client.sock) {
+            throw new Error('Socket is not connected.')
+        }
+        return this.client.sock
+    }
+
+    /**
+     * Atende a chamada recebida via WebAssembly VoIP
+     * @param {Object} [options={}]
+     */
+    async accept(options = {}) {
+        const sock = this._getSock()
+        if (!sock.acceptCall) {
+            throw new Error('VoIP stack is not initialized on the underlying socket.')
+        }
+
+        const callOptions = {
+            isVideo: this.isVideo,
+            ...options
+        }
+
+        const activeCall = await sock.acceptCall(this.id, this.from, callOptions)
+        this.instance = activeCall
+        this.status = 'connected'
+        return activeCall
+    }
+
+    /**
+     * Rejeita a chamada recebida
+     * @param {number|string} [reason=0]
+     */
+    async reject(reason = 0) {
+        const sock = this._getSock()
+        if (sock.rejectCall) {
+            await sock.rejectCall(this.id, this.from, reason)
+        }
+        this.status = 'rejected'
+    }
+
+    /**
+     * Encerra a chamada em andamento
+     */
+    async hangup() {
+        if (this.instance && typeof this.instance.terminate === 'function') {
+            await this.instance.terminate()
+        } else if (this.instance && typeof this.instance.end === 'function') {
+            await this.instance.end()
+        } else {
+            const sock = this._getSock()
+            if (sock.rejectCall) {
+                await sock.rejectCall(this.id, this.from, 0)
+            }
+        }
+        this.status = 'ended'
+    }
+
+    /**
+     * Transmite áudio na chamada conectada
+     * @param {string|Buffer} audioPathOrBuffer
+     */
+    async playAudio(audioPathOrBuffer) {
+        if (this.instance && typeof this.instance.playAudio === 'function') {
+            return this.instance.playAudio(audioPathOrBuffer)
+        }
+        throw new Error('No active audio stream or call is not connected yet.')
+    }
+}
+
+exports.CallContext = CallContext
+exports.default = CallContext

package/lib/Client/Context/MediaObject.js

@@ -0,0 +1,155 @@
+"use strict"
+
+Object.defineProperty(exports, "__esModule", { value: true })
+
+const { promises: fsPromises } = require("fs")
+const { dirname } = require("path")
+const { downloadContentFromMessage } = require("../../Utils/messages-media")
+
+class MediaObject {
+    /**
+     * @param {Object} mediaNode - Raw protobuf media node (imageMessage, videoMessage, etc.)
+     * @param {string} canonicalType - Canonical message type ('image', 'video', 'voice', 'audio', 'document', 'sticker')
+     */
+    constructor(mediaNode, canonicalType) {
+        this.mediaNode = mediaNode || {}
+        this.rawType = canonicalType || 'unknown'
+        this.mediaType = this._resolveMediaType(canonicalType)
+
+        this.mimetype = this.mediaNode.mimetype || this._defaultMimetype(this.mediaType)
+        this.fileLength = Number(this.mediaNode.fileLength || 0)
+        this.fileName = this.mediaNode.fileName || ''
+        this.seconds = Number(this.mediaNode.seconds || 0)
+        this.isVoice = Boolean(this.mediaNode.ptt)
+        this.isAnimated = Boolean(this.mediaNode.gifPlayback || this.mediaNode.isAnimated)
+        this.extension = this._inferExtension()
+
+        this._bufferCache = null
+    }
+
+    _resolveMediaType(type) {
+        if (type === 'voice' || type === 'audio') return 'audio'
+        if (type === 'gif' || type === 'video') return 'video'
+        if (type === 'image') return 'image'
+        if (type === 'sticker') return 'sticker'
+        if (type === 'document') return 'document'
+        return 'document'
+    }
+
+    _defaultMimetype(mediaType) {
+        switch (mediaType) {
+            case 'image': return 'image/jpeg'
+            case 'video': return 'video/mp4'
+            case 'audio': return 'audio/ogg; codecs=opus'
+            case 'sticker': return 'image/webp'
+            default: return 'application/octet-stream'
+        }
+    }
+
+    _inferExtension() {
+        if (this.fileName && this.fileName.includes('.')) {
+            const ext = this.fileName.split('.').pop()
+            if (ext) return ext.toLowerCase()
+        }
+        if (!this.mimetype) return 'bin'
+
+        const base = this.mimetype.split(';')[0].trim().toLowerCase()
+        const sub = base.split('/')[1] || 'bin'
+
+        if (sub === 'jpeg') return 'jpg'
+        if (sub.includes('ogg') || sub.includes('opus')) return 'ogg'
+        if (sub === 'pdf') return 'pdf'
+        if (sub === 'webp') return 'webp'
+        if (sub === 'mp4') return 'mp4'
+        if (sub === 'mpeg') return 'mp3'
+
+        return sub.replace(/[^a-z0-9]/gi, '') || 'bin'
+    }
+
+    /**
+     * Downloads media as a Node.js Readable stream
+     * @param {Object} [options={}]
+     * @returns {Promise<import('stream').Readable>}
+     */
+    async toStream(options = {}) {
+        if (!this.mediaNode.mediaKey && !this.mediaNode.directPath && !this.mediaNode.url) {
+            throw new Error('Media node does not contain valid decryption keys or download URL.')
+        }
+
+        return downloadContentFromMessage(this.mediaNode, this.mediaType, options)
+    }
+
+    /**
+     * Downloads media and returns decrypted Buffer (caches in memory)
+     * @param {Object} [options={}]
+     * @returns {Promise<Buffer>}
+     */
+    async toBuffer(options = {}) {
+        if (this._bufferCache) {
+            return this._bufferCache
+        }
+
+        const stream = await this.toStream(options)
+        const chunks = []
+
+        for await (const chunk of stream) {
+            chunks.push(chunk)
+        }
+
+        this._bufferCache = Buffer.concat(chunks)
+        return this._bufferCache
+    }
+
+    /**
+     * Saves the downloaded media directly to disk
+     * @param {string} destinationPath - Full or relative file path to save
+     * @param {Object} [options={}]
+     * @returns {Promise<string>} Saved destination path
+     */
+    async save(destinationPath, options = {}) {
+        const buffer = await this.toBuffer(options)
+        const dir = dirname(destinationPath)
+        await fsPromises.mkdir(dir, { recursive: true })
+        await fsPromises.writeFile(destinationPath, buffer)
+        return destinationPath
+    }
+
+    /**
+     * Returns Base64 encoded string of the media
+     * @param {Object} [options={}]
+     * @returns {Promise<string>}
+     */
+    async toBase64(options = {}) {
+        const buffer = await this.toBuffer(options)
+        return buffer.toString('base64')
+    }
+
+    /**
+     * Returns a Data URI string (e.g. data:image/jpeg;base64,...)
+     * @param {Object} [options={}]
+     * @returns {Promise<string>}
+     */
+    async toDataUri(options = {}) {
+        const base64 = await this.toBase64(options)
+        return `data:${this.mimetype};base64,${base64}`
+    }
+
+    /**
+     * Returns a Sharp instance for image processing (requires sharp installed)
+     * @param {Object} [options={}]
+     */
+    async toSharp(options = {}) {
+        let sharp
+        try {
+            sharp = require('sharp')
+        } catch {
+            throw new Error('The "sharp" package is required to use toSharp(). Run "npm install sharp" to add it.')
+        }
+
+        const buffer = await this.toBuffer(options)
+        return sharp(buffer)
+    }
+}
+
+exports.MediaObject = MediaObject
+exports.default = MediaObject

package/lib/Client/Context/MessageContext.js

@@ -0,0 +1,213 @@
+"use strict"
+
+Object.defineProperty(exports, "__esModule", { value: true })
+
+const { JidNormalizer } = require("../Normalizers/JidNormalizer")
+const { MessageNormalizer } = require("../Normalizers/MessageNormalizer")
+const { MediaObject } = require("./MediaObject")
+
+class MessageContext {
+    /**
+     * @param {import('../WaClient').WaClient} client
+     * @param {Object} rawMessage - proto.IWebMessageInfo
+     * @param {number} [depth=0] - Recursion depth guard for quoted messages
+     */
+    constructor(client, rawMessage, depth = 0) {
+        this.client = client
+        this.raw = rawMessage || {}
+
+        // 1. Detection of Edited Message (protocolMessage.editedMessage)
+        const editedMsg = rawMessage?.message?.protocolMessage?.editedMessage
+        this.isEdited = Boolean(editedMsg)
+
+        const effectiveKey = (this.isEdited && rawMessage.message.protocolMessage.key)
+            ? { ...rawMessage.key, ...rawMessage.message.protocolMessage.key }
+            : (rawMessage?.key || {})
+
+        const effectiveMessage = editedMsg || rawMessage?.message || null
+
+        // 2. Identity and Routing
+        this.id = effectiveKey.id || rawMessage?.key?.id || ''
+        this.chatId = effectiveKey.remoteJid || rawMessage?.key?.remoteJid || ''
+        this.fromMe = Boolean(effectiveKey.fromMe)
+        this.isFromMe = this.fromMe
+
+        this.isGroup = JidNormalizer.isGroup(this.chatId)
+        this.isChannel = JidNormalizer.isNewsletter(this.chatId)
+        this.isBroadcast = JidNormalizer.isBroadcast(this.chatId)
+
+        // Bot JID resolution
+        const sockUser = client?.sock?.user || {}
+        const clientJid = sockUser.id ? JidNormalizer.toJid(sockUser.id) : ''
+        const clientLid = sockUser.lid ? JidNormalizer.toJid(sockUser.lid) : ''
+
+        // Origin and Destination (from / to)
+        if (this.fromMe) {
+            this.from = clientJid || this.chatId
+            this.to = this.chatId
+            this.fromPushName = sockUser.name || sockUser.notify || 'Você'
+        } else {
+            this.from = this.isGroup
+                ? (effectiveKey.participant || rawMessage?.participant || this.chatId)
+                : this.chatId
+            this.to = clientJid || this.chatId
+            this.fromPushName = rawMessage?.pushName || JidNormalizer.toPhoneNumber(this.from) || 'Desconhecido'
+        }
+
+        this.sender = this.from
+        this.fromNumber = JidNormalizer.toPhoneNumber(this.from)
+        this.senderNumber = this.fromNumber
+        this.senderName = this.fromPushName
+
+        // Timestamps
+        const rawTs = Number(rawMessage?.messageTimestamp || Math.floor(Date.now() / 1000))
+        this.timestamp = new Date(rawTs > 10000000000 ? rawTs : rawTs * 1000)
+        this.editTimestamp = this.isEdited
+            ? new Date(Number(rawMessage.message.protocolMessage.timestampMs || Date.now()))
+            : null
+
+        // 3. Content Decoupling & Typed Parsers
+        this.type = MessageNormalizer.extractType(effectiveMessage)
+        this.body = MessageNormalizer.extractBody(effectiveMessage)
+        this.interactiveReply = MessageNormalizer.extractInteractiveReply(effectiveMessage)
+        this.contacts = MessageNormalizer.extractContacts(effectiveMessage)
+        this.location = MessageNormalizer.extractLocation(effectiveMessage)
+        this.reaction = MessageNormalizer.extractReaction(effectiveMessage)
+        this.poll = MessageNormalizer.extractPollCreation(effectiveMessage, rawMessage)
+
+        // 4. Media Normalization
+        this.mediaNode = MessageNormalizer.extractMediaNode(effectiveMessage)
+        this.hasMedia = Boolean(this.mediaNode)
+        this.media = this.hasMedia ? new MediaObject(this.mediaNode, this.type) : null
+        this.mediaDetails = MessageNormalizer.extractMediaDetails(effectiveMessage)
+
+        // 5. Context Info, Mentions & Forwarding
+        this.contextInfo = MessageNormalizer.extractContextInfo(effectiveMessage)
+        this.mentions = this.contextInfo?.mentionedJid || []
+        this.mentionedJids = this.mentions
+        this.isForwarded = Boolean(this.contextInfo?.isForwarded)
+        this.forwardingScore = Number(this.contextInfo?.forwardingScore || 0)
+
+        // Checks if the bot was directly mentioned (by PN or LID)
+        this.isMentioningMe = Boolean(
+            (clientJid && this.mentions.includes(clientJid)) ||
+            (clientLid && this.mentions.includes(clientLid))
+        )
+
+        // 6. Quoted Message Parsing (Recursion with depth limit 1)
+        this.isReply = Boolean(this.contextInfo?.quotedMessage)
+        this.quoted = null
+
+        if (this.isReply && this.contextInfo?.quotedMessage && depth === 0) {
+            const quotedParticipant = this.contextInfo.participant || this.chatId
+            const quotedRaw = {
+                key: {
+                    remoteJid: this.chatId,
+                    id: this.contextInfo.stanzaId,
+                    fromMe: clientJid && JidNormalizer.toJid(quotedParticipant) === clientJid,
+                    participant: quotedParticipant
+                },
+                message: this.contextInfo.quotedMessage,
+                pushName: this.contextInfo.pushName
+            }
+            try {
+                this.quoted = new MessageContext(this.client, quotedRaw, depth + 1)
+            } catch {
+                this.quoted = {
+                    id: this.contextInfo.stanzaId,
+                    sender: quotedParticipant,
+                    senderNumber: JidNormalizer.toPhoneNumber(quotedParticipant),
+                    type: MessageNormalizer.extractType(this.contextInfo.quotedMessage),
+                    body: MessageNormalizer.extractBody(this.contextInfo.quotedMessage),
+                    raw: this.contextInfo.quotedMessage
+                }
+            }
+        }
+    }
+
+    /**
+     * Responde citando esta mensagem automaticamente
+     * @param {string|Object} content - Texto ou payload de mensagem
+     * @param {Object} [options={}]
+     */
+    async reply(content, options = {}) {
+        const payload = typeof content === 'string' ? { text: content } : content
+        return this.client.sendMessage(this.chatId, payload, {
+            quoted: this.raw,
+            ...options
+        })
+    }
+
+    /**
+     * Reage à mensagem com um emoji (ou string vazia para remover)
+     * @param {string} emoji
+     */
+    async react(emoji) {
+        return this.client.sendMessage(this.chatId, {
+            react: {
+                text: emoji || '',
+                key: this.raw.key
+            }
+        })
+    }
+
+    /**
+     * Remove qualquer reação anteriormente atribuída a esta mensagem
+     */
+    async removeReaction() {
+        return this.react('')
+    }
+
+    /**
+     * Apaga esta mensagem para todos na conversa (revoke)
+     */
+    async delete() {
+        return this.client.sendMessage(this.chatId, {
+            delete: this.raw.key
+        })
+    }
+
+    /**
+     * Marca esta mensagem como lida (ticks azuis)
+     */
+    async markRead() {
+        if (!this.client?.sock?.readMessages) return
+        return this.client.sock.readMessages([this.raw.key])
+    }
+
+    /**
+     * Encaminha esta mensagem para outro destinatário
+     * @param {string} targetJid
+     * @param {Object} [options={}]
+     */
+    async forward(targetJid, options = {}) {
+        return this.client.sendMessage(
+            targetJid,
+            { forward: this.raw, ...options }
+        )
+    }
+
+    /**
+     * Fixa a mensagem no chat com duração configurável
+     * @param {number} [durationInSeconds=86400]
+     */
+    async pin(durationInSeconds = 86400) {
+        if (!this.client?.sock?.pinInChatMessage) {
+            throw new Error('Método pinInChatMessage indisponível no socket.')
+        }
+        return this.client.sock.pinInChatMessage(this.chatId, this.raw.key, 1, durationInSeconds)
+    }
+
+    /**
+     * Desafixa a mensagem do topo da conversa
+     */
+    async unpin() {
+        if (!this.client?.sock?.pinInChatMessage) {
+            throw new Error('Método pinInChatMessage indisponível no socket.')
+        }
+        return this.client.sock.pinInChatMessage(this.chatId, this.raw.key, 2)
+    }
+}
+
+exports.MessageContext = MessageContext
+exports.default = MessageContext