@areumtecnologia/wasockets 2.2.3 → 2.3.0

package/lib/Client/Modules/MessageManager.js

@@ -0,0 +1,198 @@
+"use strict"
+
+Object.defineProperty(exports, "__esModule", { value: true })
+
+const { JidNormalizer } = require("../Normalizers/JidNormalizer")
+
+class MessageManager {
+    /**
+     * @param {import('../WaClient').WaClient} client
+     */
+    constructor(client) {
+        this.client = client
+    }
+
+    /**
+     * Envia mensagem de texto com suporte a menções
+     * @param {string} jid
+     * @param {string} text
+     * @param {Object} [options={}]
+     */
+    async sendText(jid, text, options = {}) {
+        const payload = {
+            text: text || '',
+            ...(options.mentions ? { mentions: options.mentions.map(JidNormalizer.toJid) } : {})
+        }
+        return this.client.sendMessage(jid, payload, options)
+    }
+
+    /**
+     * Envia arquivo de mídia (imagem, vídeo, áudio, documento ou figurinha)
+     * @param {string} jid
+     * @param {'image'|'video'|'audio'|'document'|'sticker'} type
+     * @param {string|Buffer|Object} content - Caminho, URL ou Buffer
+     * @param {Object} [options={}]
+     */
+    async sendMedia(jid, type, content, options = {}) {
+        const mediaPayload = typeof content === 'string' ? { url: content } : content
+        const payload = {
+            [type]: mediaPayload,
+            ...(options.caption ? { caption: options.caption } : {}),
+            ...(options.fileName ? { fileName: options.fileName } : {}),
+            ...(options.mimetype ? { mimetype: options.mimetype } : {}),
+            ...(options.viewOnce ? { viewOnce: true } : {})
+        }
+        return this.client.sendMessage(jid, payload, options)
+    }
+
+    /**
+     * Envia um álbum de fotos ou vídeos agrupados nativamente
+     * @param {string} jid
+     * @param {Array<Object>} items
+     * @param {Object} [options={}]
+     */
+    async sendAlbum(jid, items = [], options = {}) {
+        const targetJid = JidNormalizer.toJid(jid)
+        if (this.client.sock?.sendAlbumMessage) {
+            return this.client.sock.sendAlbumMessage(targetJid, items, options)
+        }
+        return this.client.sendMessage(targetJid, { album: items }, options)
+    }
+
+    /**
+     * Envia áudio simulando gravação de voz (PTT / Voice Note)
+     * @param {string} jid
+     * @param {string|Buffer|Object} audioSource
+     * @param {Object} [options={}]
+     */
+    async sendVoice(jid, audioSource, options = {}) {
+        const payload = {
+            audio: typeof audioSource === 'string' ? { url: audioSource } : audioSource,
+            mimetype: 'audio/mp4',
+            ptt: true,
+            ...(options.waveform ? { waveform: options.waveform } : {})
+        }
+        return this.client.sendMessage(jid, payload, options)
+    }
+
+    /**
+     * Envia um contato com cartão vCard
+     * @param {string} jid
+     * @param {string} name
+     * @param {string} phoneNumber
+     * @param {Object} [options={}]
+     */
+    async sendContact(jid, name, phoneNumber, options = {}) {
+        const cleanPhone = JidNormalizer.toPhoneNumber(phoneNumber)
+        const vcard = 'BEGIN:VCARD\n'
+            + 'VERSION:3.0\n'
+            + `FN:${name}\n`
+            + `ORG:${options.org || name};\n`
+            + `TEL;type=CELL;type=VOICE;waid=${cleanPhone}:+${cleanPhone}\n`
+            + 'END:VCARD'
+
+        const payload = {
+            contacts: {
+                displayName: name,
+                contacts: [{ vcard }]
+            }
+        }
+        return this.client.sendMessage(jid, payload, options)
+    }
+
+    /**
+     * Envia localização fixa ou ao vivo
+     * @param {string} jid
+     * @param {{ latitude: number, longitude: number, name?: string, address?: string, live?: boolean }} coords
+     * @param {Object} [options={}]
+     */
+    async sendLocation(jid, coords, options = {}) {
+        const payload = {
+            location: {
+                degreesLatitude: coords.latitude,
+                degreesLongitude: coords.longitude,
+                ...(coords.name ? { name: coords.name } : {}),
+                ...(coords.address ? { address: coords.address } : {})
+            },
+            ...(coords.live ? { live: true } : {})
+        }
+        return this.client.sendMessage(jid, payload, options)
+    }
+
+    /**
+     * Encaminha uma mensagem existente para outro destinatário
+     * @param {string} targetJid
+     * @param {Object} message - Objeto raw da mensagem
+     * @param {Object} [options={}]
+     */
+    async forward(targetJid, message, options = {}) {
+        return this.client.sendMessage(targetJid, { forward: message }, options)
+    }
+
+    /**
+     * Apaga uma mensagem para todos no chat
+     * @param {string} jid
+     * @param {Object} messageKey - { remoteJid, id, fromMe }
+     */
+    async delete(jid, messageKey) {
+        return this.client.sendMessage(jid, { delete: messageKey })
+    }
+
+    /**
+     * Edita uma mensagem de texto já enviada pelo próprio bot
+     * @param {string} jid
+     * @param {Object} messageKey
+     * @param {string} newText
+     */
+    async edit(jid, messageKey, newText) {
+        return this.client.sendMessage(jid, {
+            edit: messageKey,
+            text: newText
+        })
+    }
+
+    /**
+     * Fixa uma mensagem no topo da conversa
+     * @param {string} jid
+     * @param {Object} messageKey
+     * @param {number} [durationSeconds=86400]
+     */
+    async pin(jid, messageKey, durationSeconds = 86400) {
+        if (!this.client.sock?.pinInChatMessage) {
+            throw new Error('Método pinInChatMessage indisponível no socket.')
+        }
+        const targetJid = JidNormalizer.toJid(jid)
+        return this.client.sock.pinInChatMessage(targetJid, messageKey, 1, durationSeconds)
+    }
+
+    /**
+     * Desafixa mensagem do topo da conversa
+     * @param {string} jid
+     * @param {Object} messageKey
+     */
+    async unpin(jid, messageKey) {
+        if (!this.client.sock?.pinInChatMessage) {
+            throw new Error('Método pinInChatMessage indisponível no socket.')
+        }
+        const targetJid = JidNormalizer.toJid(jid)
+        return this.client.sock.pinInChatMessage(targetJid, messageKey, 2)
+    }
+
+    /**
+     * Reage com emoji a uma mensagem
+     * @param {string} jid
+     * @param {Object} messageKey
+     * @param {string} emoji
+     */
+    async react(jid, messageKey, emoji) {
+        return this.client.sendMessage(jid, {
+            react: {
+                text: emoji || '',
+                key: messageKey
+            }
+        })
+    }
+}
+
+exports.MessageManager = MessageManager
+exports.default = MessageManager

package/lib/Client/Modules/PresenceManager.js

@@ -0,0 +1,68 @@
+"use strict"
+
+Object.defineProperty(exports, "__esModule", { value: true })
+
+const { JidNormalizer } = require("../Normalizers/JidNormalizer")
+
+class PresenceManager {
+    /**
+     * @param {import('../WaClient').WaClient} client
+     */
+    constructor(client) {
+        this.client = client
+    }
+
+    _getSock() {
+        if (!this.client.sock) {
+            throw new Error('Socket is not connected.')
+        }
+        return this.client.sock
+    }
+
+    /**
+     * Inicia estado 'digitando' com retorno de objeto cancelador
+     * @param {string} jid
+     * @returns {{ stop: () => Promise<void> }}
+     */
+    startTyping(jid) {
+        return this.client.startTyping(jid)
+    }
+
+    /**
+     * Inicia simulação de gravação de áudio com cancelador
+     * @param {string} jid
+     * @returns {{ stop: () => Promise<void> }}
+     */
+    startRecording(jid) {
+        return this.client.startRecording(jid)
+    }
+
+    /**
+     * Define a presença da conta como online/disponível
+     */
+    async setOnline() {
+        const sock = this._getSock()
+        return sock.sendPresenceUpdate('available')
+    }
+
+    /**
+     * Define a presença da conta como offline/indisponível
+     */
+    async setOffline() {
+        const sock = this._getSock()
+        return sock.sendPresenceUpdate('unavailable')
+    }
+
+    /**
+     * Assina atualizações de presença em tempo real de um contato
+     * @param {string} jid
+     */
+    async subscribe(jid) {
+        const sock = this._getSock()
+        const targetJid = JidNormalizer.toJid(jid)
+        return sock.presenceSubscribe(targetJid)
+    }
+}
+
+exports.PresenceManager = PresenceManager
+exports.default = PresenceManager

package/lib/Client/Modules/PrivacyManager.js

@@ -0,0 +1,98 @@
+"use strict"
+
+Object.defineProperty(exports, "__esModule", { value: true })
+
+const { JidNormalizer } = require("../Normalizers/JidNormalizer")
+
+class PrivacyManager {
+    /**
+     * @param {import('../WaClient').WaClient} client
+     */
+    constructor(client) {
+        this.client = client
+    }
+
+    _getSock() {
+        if (!this.client.sock) {
+            throw new Error('Socket is not connected.')
+        }
+        return this.client.sock
+    }
+
+    /**
+     * Bloqueia um contato
+     * @param {string} jid
+     */
+    async block(jid) {
+        const sock = this._getSock()
+        const targetJid = JidNormalizer.toJid(jid)
+        return sock.updateBlockStatus(targetJid, 'block')
+    }
+
+    /**
+     * Desbloqueia um contato
+     * @param {string} jid
+     */
+    async unblock(jid) {
+        const sock = this._getSock()
+        const targetJid = JidNormalizer.toJid(jid)
+        return sock.updateBlockStatus(targetJid, 'unblock')
+    }
+
+    /**
+     * Retorna a lista de todos os JIDs bloqueados
+     * @returns {Promise<string[]>}
+     */
+    async getBlocklist() {
+        const sock = this._getSock()
+        return sock.fetchBlocklist()
+    }
+
+    /**
+     * Configura privacidade de Visto por Último
+     * @param {'all'|'contacts'|'contact_blacklist'|'none'} privacy
+     */
+    async setLastSeen(privacy) {
+        const sock = this._getSock()
+        return sock.updateLastSeenPrivacy(privacy)
+    }
+
+    /**
+     * Configura privacidade de Online
+     * @param {'all'|'match_last_seen'} privacy
+     */
+    async setOnline(privacy) {
+        const sock = this._getSock()
+        return sock.updateOnlinePrivacy(privacy)
+    }
+
+    /**
+     * Configura privacidade da Foto de Perfil
+     * @param {'all'|'contacts'|'contact_blacklist'|'none'} privacy
+     */
+    async setProfilePicture(privacy) {
+        const sock = this._getSock()
+        return sock.updateProfilePicturePrivacy(privacy)
+    }
+
+    /**
+     * Configura privacidade do Recado/Status
+     * @param {'all'|'contacts'|'contact_blacklist'|'none'} privacy
+     */
+    async setAbout(privacy) {
+        const sock = this._getSock()
+        return sock.updateStatusPrivacy(privacy)
+    }
+
+    /**
+     * Ativa ou desativa confirmações de leitura (ticks azuis)
+     * @param {boolean} enabled
+     */
+    async setReadReceipts(enabled) {
+        const sock = this._getSock()
+        return sock.updateReadReceiptsPrivacy(enabled ? 'all' : 'none')
+    }
+}
+
+exports.PrivacyManager = PrivacyManager
+exports.default = PrivacyManager

package/lib/Client/Modules/ProfileManager.js

@@ -0,0 +1,92 @@
+"use strict"
+
+Object.defineProperty(exports, "__esModule", { value: true })
+
+const { JidNormalizer } = require("../Normalizers/JidNormalizer")
+
+class ProfileManager {
+    /**
+     * @param {import('../WaClient').WaClient} client
+     */
+    constructor(client) {
+        this.client = client
+    }
+
+    _getSock() {
+        if (!this.client.sock) {
+            throw new Error('Socket is not connected.')
+        }
+        return this.client.sock
+    }
+
+    /**
+     * Atualiza o nome de exibição (pushName) do bot
+     * @param {string} name
+     */
+    async updateName(name) {
+        const sock = this._getSock()
+        return sock.updateProfileName(name)
+    }
+
+    /**
+     * Atualiza o recado / status de texto da conta
+     * @param {string} aboutText
+     */
+    async updateAbout(aboutText) {
+        const sock = this._getSock()
+        return sock.updateProfileStatus(aboutText)
+    }
+
+    /**
+     * Obtém o recado de um contato ou da própria conta
+     * @param {string} [jid]
+     */
+    async getAbout(jid) {
+        const sock = this._getSock()
+        const targetJid = jid ? JidNormalizer.toJid(jid) : sock.user?.id
+        return sock.fetchStatus(targetJid)
+    }
+
+    /**
+     * Atualiza a foto de perfil da conta ou de um grupo
+     * @param {string} jidOrSelf - 'me' ou JID
+     * @param {string|Buffer|Object} imageSource
+     */
+    async updatePicture(jidOrSelf, imageSource) {
+        const sock = this._getSock()
+        const isSelf = !jidOrSelf || jidOrSelf === 'me'
+        const targetJid = isSelf ? sock.user?.id : JidNormalizer.toJid(jidOrSelf)
+        const content = typeof imageSource === 'string' ? { url: imageSource } : imageSource
+        return sock.updateProfilePicture(targetJid, content)
+    }
+
+    /**
+     * Remove a foto de perfil
+     * @param {string} [jidOrSelf]
+     */
+    async removePicture(jidOrSelf) {
+        const sock = this._getSock()
+        const isSelf = !jidOrSelf || jidOrSelf === 'me'
+        const targetJid = isSelf ? sock.user?.id : JidNormalizer.toJid(jidOrSelf)
+        return sock.removeProfilePicture(targetJid)
+    }
+
+    /**
+     * Obtém a URL da foto de perfil
+     * @param {string} jid
+     * @param {boolean} [highRes=true] - Se true, busca imagem em alta resolução
+     * @returns {Promise<string|null>}
+     */
+    async getPictureUrl(jid, highRes = true) {
+        const sock = this._getSock()
+        const targetJid = JidNormalizer.toJid(jid)
+        try {
+            return await sock.profilePictureUrl(targetJid, highRes ? 'image' : 'preview')
+        } catch {
+            return null
+        }
+    }
+}
+
+exports.ProfileManager = ProfileManager
+exports.default = ProfileManager

package/lib/Client/Modules/UserManager.js

@@ -0,0 +1,92 @@
+"use strict"
+
+Object.defineProperty(exports, "__esModule", { value: true })
+
+const { JidNormalizer } = require("../Normalizers/JidNormalizer")
+
+class UserManager {
+    /**
+     * @param {import('../WaClient').WaClient} client
+     */
+    constructor(client) {
+        this.client = client
+    }
+
+    _getSock() {
+        if (!this.client.sock) {
+            throw new Error('Socket is not connected.')
+        }
+        return this.client.sock
+    }
+
+    /**
+     * Verifica se um número ou JID existe no WhatsApp
+     * @param {string} phoneOrJid
+     * @returns {Promise<{ exists: boolean, jid: string } | null>}
+     */
+    async isOnWhatsApp(phoneOrJid) {
+        return this.client.isOnWhatsApp(phoneOrJid)
+    }
+
+    /**
+     * Resolve um JID de forma transparente para PN ou LID
+     * @param {string} jidOrPhone
+     * @param {boolean} [fetchIfMissing=false]
+     * @returns {Promise<string>} JID canônico resolvido
+     */
+    async resolveJid(jidOrPhone, fetchIfMissing = false) {
+        const sock = this._getSock()
+        if (sock.resolveJid) {
+            return sock.resolveJid(jidOrPhone, fetchIfMissing)
+        }
+        return JidNormalizer.toJid(jidOrPhone)
+    }
+
+    /**
+     * Converte um identificador LID (@lid) para o número de telefone (@s.whatsapp.net)
+     * @param {string} lidJid
+     * @param {boolean} [fetchIfMissing=false]
+     * @returns {Promise<string|null>} Telefone no formato JID
+     */
+    async getPnForLid(lidJid, fetchIfMissing = false) {
+        const sock = this._getSock()
+        if (sock.toPn) {
+            return sock.toPn(lidJid, fetchIfMissing)
+        }
+        return null
+    }
+
+    /**
+     * Converte um telefone (@s.whatsapp.net) para seu LID (@lid) correspondente
+     * @param {string} pnJid
+     * @param {boolean} [fetchIfMissing=false]
+     * @returns {Promise<string|null>} LID no formato JID
+     */
+    async getLidForPn(pnJid, fetchIfMissing = false) {
+        const sock = this._getSock()
+        if (sock.toLid) {
+            return sock.toLid(pnJid, fetchIfMissing)
+        }
+        return null
+    }
+
+    /**
+     * Obtém o perfil comercial de uma conta WhatsApp Business
+     * @param {string} jid
+     */
+    async getBusinessProfile(jid) {
+        const sock = this._getSock()
+        const targetJid = JidNormalizer.toJid(jid)
+        if (!sock.getBusinessProfile) {
+            return null
+        }
+        try {
+            return await sock.getBusinessProfile(targetJid)
+        } catch {
+            return null
+        }
+    }
+}
+
+exports.UserManager = UserManager
+exports.default = UserManager

package/lib/Client/Modules/VoipManager.js

@@ -0,0 +1,117 @@
+"use strict"
+
+Object.defineProperty(exports, "__esModule", { value: true })
+
+const { JidNormalizer } = require("../Normalizers/JidNormalizer")
+const { CallContext } = require("../Context/CallContext")
+
+class VoipManager {
+    /**
+     * @param {import('../WaClient').WaClient} client
+     */
+    constructor(client) {
+        this.client = client
+    }
+
+    _getSock() {
+        if (!this.client.sock) {
+            throw new Error('Socket is not connected.')
+        }
+        return this.client.sock
+    }
+
+    /**
+     * Realiza uma chamada de voz WhatsApp via WebAssembly
+     * @param {string} phoneNumber - Telefone ou JID de destino
+     * @param {Object} [options={}]
+     * @returns {Promise<CallContext>}
+     */
+    async call(phoneNumber, options = {}) {
+        const sock = this._getSock()
+        if (!sock.call) {
+            throw new Error('VoIP engine is not enabled in this WaSockets build.')
+        }
+        const cleanNumber = JidNormalizer.toPhoneNumber(phoneNumber) || phoneNumber
+        const activeCall = await sock.call(cleanNumber, { ...options, isVideo: false })
+        return new CallContext(this.client, {
+            id: activeCall.callId,
+            from: cleanNumber,
+            isVideo: false,
+            status: 'calling'
+        }, activeCall)
+    }
+
+    /**
+     * Realiza uma chamada de vídeo WhatsApp
+     * @param {string} phoneNumber
+     * @param {Object} [options={}]
+     * @returns {Promise<CallContext>}
+     */
+    async callVideo(phoneNumber, options = {}) {
+        const sock = this._getSock()
+        if (!sock.callVideo && !sock.call) {
+            throw new Error('VoIP engine is not enabled in this WaSockets build.')
+        }
+        const cleanNumber = JidNormalizer.toPhoneNumber(phoneNumber) || phoneNumber
+        const fn = sock.callVideo ? sock.callVideo.bind(sock) : (num, opts) => sock.call(num, { ...opts, isVideo: true })
+        const activeCall = await fn(cleanNumber, options)
+        return new CallContext(this.client, {
+            id: activeCall.callId,
+            from: cleanNumber,
+            isVideo: true,
+            status: 'calling'
+        }, activeCall)
+    }
+
+    /**
+     * Retorna a chamada ativa no momento ou null
+     * @returns {CallContext|null}
+     */
+    get activeCall() {
+        const sock = this.client.sock
+        const rawCall = sock?.activeCall
+        if (!rawCall) return null
+
+        return new CallContext(this.client, {
+            id: rawCall.callId,
+            from: rawCall.target,
+            isVideo: Boolean(rawCall.isVideo),
+            status: rawCall.state || 'active'
+        }, rawCall.instance || rawCall)
+    }
+
+    /**
+     * Limpa o estado da chamada ativa atual
+     */
+    clearActiveCall() {
+        const sock = this.client.sock
+        if (sock?.clearActiveCall) {
+            sock.clearActiveCall()
+        }
+    }
+
+    /**
+     * Atende uma chamada recebida diretamente pelo ID
+     * @param {string} callId
+     * @param {string} from
+     * @param {Object} [options={}]
+     */
+    async acceptCall(callId, from, options = {}) {
+        const ctx = new CallContext(this.client, { id: callId, from, isVideo: options.isVideo })
+        return ctx.accept(options)
+    }
+
+    /**
+     * Rejeita uma chamada recebida
+     * @param {string} callId
+     * @param {string} from
+     * @param {number|string} [reason=0]
+     */
+    async rejectCall(callId, from, reason = 0) {
+        const ctx = new CallContext(this.client, { id: callId, from })
+        return ctx.reject(reason)
+    }
+}
+
+exports.VoipManager = VoipManager
+exports.default = VoipManager

package/lib/Client/Modules/index.js

@@ -0,0 +1,29 @@
+"use strict"
+
+Object.defineProperty(exports, "__esModule", { value: true })
+
+const { MessageManager } = require("./MessageManager")
+const { GroupManager } = require("./GroupManager")
+const { ChannelManager } = require("./ChannelManager")
+const { PresenceManager } = require("./PresenceManager")
+const { ProfileManager } = require("./ProfileManager")
+const { PrivacyManager } = require("./PrivacyManager")
+const { UserManager } = require("./UserManager")
+const { ChatManager } = require("./ChatManager")
+const { VoipManager } = require("./VoipManager")
+const { BusinessManager } = require("./BusinessManager")
+const { CommunityManager } = require("./CommunityManager")
+const { LabelManager } = require("./LabelManager")
+
+exports.MessageManager = MessageManager
+exports.GroupManager = GroupManager
+exports.ChannelManager = ChannelManager
+exports.PresenceManager = PresenceManager
+exports.ProfileManager = ProfileManager
+exports.PrivacyManager = PrivacyManager
+exports.UserManager = UserManager
+exports.ChatManager = ChatManager
+exports.VoipManager = VoipManager
+exports.BusinessManager = BusinessManager
+exports.CommunityManager = CommunityManager
+exports.LabelManager = LabelManager