@areumtecnologia/wasockets 2.2.3 → 2.3.1

package/lib/Client/Modules/GroupManager.js

@@ -0,0 +1,194 @@
+"use strict"
+
+Object.defineProperty(exports, "__esModule", { value: true })
+
+const { JidNormalizer } = require("../Normalizers/JidNormalizer")
+
+class GroupManager {
+    /**
+     * @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
+    }
+
+    /**
+     * Cria um novo grupo
+     * @param {string} subject - Nome do grupo
+     * @param {string[]} participants - Lista de telefones ou JIDs
+     */
+    async create(subject, participants = []) {
+        const sock = this._getSock()
+        const jids = participants.map(JidNormalizer.toJid)
+        return sock.groupCreate(subject, jids)
+    }
+
+    /**
+     * Retorna os metadados do grupo (usa cache em memória quando disponível)
+     * @param {string} groupJid
+     */
+    async getMetadata(groupJid) {
+        const sock = this._getSock()
+        const targetJid = JidNormalizer.toJid(groupJid)
+        return sock.groupMetadata(targetJid)
+    }
+
+    /**
+     * Adiciona participantes ao grupo
+     * @param {string} groupJid
+     * @param {string[]} participants
+     */
+    async addMembers(groupJid, participants = []) {
+        const sock = this._getSock()
+        const targetJid = JidNormalizer.toJid(groupJid)
+        const jids = participants.map(JidNormalizer.toJid)
+        return sock.groupParticipantsUpdate(targetJid, jids, 'add')
+    }
+
+    /**
+     * Remove participantes do grupo
+     * @param {string} groupJid
+     * @param {string[]} participants
+     */
+    async removeMembers(groupJid, participants = []) {
+        const sock = this._getSock()
+        const targetJid = JidNormalizer.toJid(groupJid)
+        const jids = participants.map(JidNormalizer.toJid)
+        return sock.groupParticipantsUpdate(targetJid, jids, 'remove')
+    }
+
+    /**
+     * Promove membros a administradores do grupo
+     * @param {string} groupJid
+     * @param {string[]} participants
+     */
+    async promote(groupJid, participants = []) {
+        const sock = this._getSock()
+        const targetJid = JidNormalizer.toJid(groupJid)
+        const jids = participants.map(JidNormalizer.toJid)
+        return sock.groupParticipantsUpdate(targetJid, jids, 'promote')
+    }
+
+    /**
+     * Rebaixa administradores a membros normais
+     * @param {string} groupJid
+     * @param {string[]} participants
+     */
+    async demote(groupJid, participants = []) {
+        const sock = this._getSock()
+        const targetJid = JidNormalizer.toJid(groupJid)
+        const jids = participants.map(JidNormalizer.toJid)
+        return sock.groupParticipantsUpdate(targetJid, jids, 'demote')
+    }
+
+    /**
+     * Obtém o código de convite do grupo
+     * @param {string} groupJid
+     * @returns {Promise<string>} Código de convite
+     */
+    async getInviteCode(groupJid) {
+        const sock = this._getSock()
+        const targetJid = JidNormalizer.toJid(groupJid)
+        return sock.groupInviteCode(targetJid)
+    }
+
+    /**
+     * Revoga o código de convite atual e gera um novo
+     * @param {string} groupJid
+     * @returns {Promise<string>} Novo código
+     */
+    async revokeInviteCode(groupJid) {
+        const sock = this._getSock()
+        const targetJid = JidNormalizer.toJid(groupJid)
+        return sock.groupRevokeInvite(targetJid)
+    }
+
+    /**
+     * Entra em um grupo através de um código de convite
+     * @param {string} inviteCode
+     * @returns {Promise<string>} JID do grupo
+     */
+    async joinWithCode(inviteCode) {
+        const sock = this._getSock()
+        const cleanCode = inviteCode.replace('https://chat.whatsapp.com/', '').trim()
+        return sock.groupAcceptInvite(cleanCode)
+    }
+
+    /**
+     * Altera o assunto/nome do grupo
+     * @param {string} groupJid
+     * @param {string} subject
+     */
+    async setSubject(groupJid, subject) {
+        const sock = this._getSock()
+        const targetJid = JidNormalizer.toJid(groupJid)
+        return sock.groupUpdateSubject(targetJid, subject)
+    }
+
+    /**
+     * Altera a descrição do grupo
+     * @param {string} groupJid
+     * @param {string} description
+     */
+    async setDescription(groupJid, description) {
+        const sock = this._getSock()
+        const targetJid = JidNormalizer.toJid(groupJid)
+        return sock.groupUpdateDescription(targetJid, description)
+    }
+
+    /**
+     * Define se apenas administradores podem enviar mensagens
+     * @param {string} groupJid
+     * @param {boolean} announceOnly
+     */
+    async setAnnounceOnly(groupJid, announceOnly = true) {
+        const sock = this._getSock()
+        const targetJid = JidNormalizer.toJid(groupJid)
+        return sock.groupSettingUpdate(targetJid, announceOnly ? 'announcement' : 'not_announcement')
+    }
+
+    /**
+     * Define se apenas administradores podem alterar as configurações do grupo
+     * @param {string} groupJid
+     * @param {boolean} locked
+     */
+    async setLocked(groupJid, locked = true) {
+        const sock = this._getSock()
+        const targetJid = JidNormalizer.toJid(groupJid)
+        return sock.groupSettingUpdate(targetJid, locked ? 'locked' : 'unlocked')
+    }
+
+    /**
+     * Menciona todos os membros do grupo em uma mensagem
+     * @param {string} groupJid
+     * @param {string|Object} textOrContent
+     * @param {Object} [options={}]
+     */
+    async mentionAll(groupJid, textOrContent, options = {}) {
+        const sock = this._getSock()
+        const targetJid = JidNormalizer.toJid(groupJid)
+        const content = typeof textOrContent === 'string' ? { text: textOrContent } : textOrContent
+
+        if (sock.groupSendMentionAll) {
+            return sock.groupSendMentionAll(targetJid, content, options)
+        }
+
+        // Fallback: busca participantes e anexa em mentions
+        const meta = await this.getMetadata(targetJid)
+        const participants = (meta.participants || []).map(p => p.id)
+        return this.client.sendMessage(targetJid, {
+            ...content,
+            mentions: participants
+        }, options)
+    }
+}
+
+exports.GroupManager = GroupManager
+exports.default = GroupManager

package/lib/Client/Modules/LabelManager.js

@@ -0,0 +1,123 @@
+"use strict"
+
+Object.defineProperty(exports, "__esModule", { value: true })
+
+const { JidNormalizer } = require("../Normalizers/JidNormalizer")
+
+class LabelManager {
+    /**
+     * @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
+    }
+
+    /**
+     * Cria uma nova etiqueta no WhatsApp Business
+     * @param {string} name - Nome da etiqueta
+     * @param {number} color - Índice numérico da cor (0 a 19)
+     * @param {number} [predefinedId=0]
+     */
+    async create(name, color = 0, predefinedId = 0) {
+        const sock = this._getSock()
+        if (!sock.createLabel) {
+            throw new Error('createLabel indisponível no socket.')
+        }
+        return sock.createLabel(name, color, predefinedId)
+    }
+
+    /**
+     * Atualiza dados de uma etiqueta existente
+     * @param {string} id
+     * @param {string} name
+     * @param {number} color
+     * @param {number} [predefinedId=0]
+     */
+    async update(id, name, color = 0, predefinedId = 0) {
+        const sock = this._getSock()
+        if (!sock.updateLabel) {
+            throw new Error('updateLabel indisponível no socket.')
+        }
+        return sock.updateLabel(id, name, color, predefinedId)
+    }
+
+    /**
+     * Remove uma etiqueta
+     * @param {string} id
+     */
+    async delete(id) {
+        const sock = this._getSock()
+        if (!sock.deleteLabel) {
+            throw new Error('deleteLabel indisponível no socket.')
+        }
+        return sock.deleteLabel(id)
+    }
+
+    /**
+     * Associa uma etiqueta a uma conversa
+     * @param {string} jid
+     * @param {string} labelId
+     */
+    async addChat(jid, labelId) {
+        const sock = this._getSock()
+        const targetJid = JidNormalizer.toJid(jid)
+        if (!sock.addChatLabel) {
+            throw new Error('addChatLabel indisponível no socket.')
+        }
+        return sock.addChatLabel(targetJid, labelId)
+    }
+
+    /**
+     * Remove uma etiqueta de uma conversa
+     * @param {string} jid
+     * @param {string} labelId
+     */
+    async removeChat(jid, labelId) {
+        const sock = this._getSock()
+        const targetJid = JidNormalizer.toJid(jid)
+        if (!sock.removeChatLabel) {
+            throw new Error('removeChatLabel indisponível no socket.')
+        }
+        return sock.removeChatLabel(targetJid, labelId)
+    }
+
+    /**
+     * Associa uma etiqueta a uma mensagem específica
+     * @param {string} jid
+     * @param {string} messageId
+     * @param {string} labelId
+     */
+    async addMessage(jid, messageId, labelId) {
+        const sock = this._getSock()
+        const targetJid = JidNormalizer.toJid(jid)
+        if (!sock.addMessageLabel) {
+            throw new Error('addMessageLabel indisponível no socket.')
+        }
+        return sock.addMessageLabel(targetJid, messageId, labelId)
+    }
+
+    /**
+     * Remove uma etiqueta de uma mensagem
+     * @param {string} jid
+     * @param {string} messageId
+     * @param {string} labelId
+     */
+    async removeMessage(jid, messageId, labelId) {
+        const sock = this._getSock()
+        const targetJid = JidNormalizer.toJid(jid)
+        if (!sock.removeMessageLabel) {
+            throw new Error('removeMessageLabel indisponível no socket.')
+        }
+        return sock.removeMessageLabel(targetJid, messageId, labelId)
+    }
+}
+
+exports.LabelManager = LabelManager
+exports.default = LabelManager

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