@areumtecnologia/wasockets 2.2.3 → 2.3.1

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

package/lib/Client/Normalizers/EventNormalizer.js

@@ -0,0 +1,99 @@
+"use strict"
+
+Object.defineProperty(exports, "__esModule", { value: true })
+
+const { Events } = require("../Constants")
+const { MessageContext } = require("../Context/MessageContext")
+const { CallContext } = require("../Context/CallContext")
+
+class EventNormalizer {
+    /**
+     * Binds low-level socket events and maps them to semantic WaClient events
+     * @param {import('../WaClient').WaClient} client
+     */
+    static bindSocketEvents(client) {
+        const sock = client.sock
+        if (!sock || !sock.ev) return
+
+        // 1. Message reception and outgoing events
+        sock.ev.on('messages.upsert', async ({ messages, type }) => {
+            if (!Array.isArray(messages)) return
+
+            for (const rawMsg of messages) {
+                // Ignore stub or protocol messages if completely empty
+                if (!rawMsg.message && !rawMsg.messageStubType) continue
+
+                // Handle protocol revoke messages explicitly
+                const isRevoke = rawMsg.message?.protocolMessage?.type === 0
+                if (isRevoke) {
+                    client.emit(Events.MESSAGE_DELETE, {
+                        keys: [rawMsg.message.protocolMessage.key || rawMsg.key]
+                    })
+                }
+
+                const ctx = new MessageContext(client, rawMsg)
+
+                if (ctx.isFromMe) {
+                    client.emit(Events.MESSAGE_SENT, ctx, rawMsg)
+                } else {
+                    client.emit(Events.MESSAGE_RECEIVED, ctx, rawMsg)
+                }
+
+                // If message is an edit, also notify on MESSAGE_UPDATE
+                if (ctx.isEdited) {
+                    client.emit(Events.MESSAGE_UPDATE, [{
+                        key: ctx.raw.key,
+                        update: { message: ctx.raw.message },
+                        ctx
+                    }])
+                }
+            }
+        })
+
+        // 2. Message updates (reactions, poll updates, edits, delivery/read receipts)
+        sock.ev.on('messages.update', (updates) => {
+            client.emit(Events.MESSAGE_UPDATE, updates)
+        })
+
+        // 3. Message deletion (revoke)
+        sock.ev.on('messages.delete', (item) => {
+            client.emit(Events.MESSAGE_DELETE, item)
+        })
+
+        // 4. Presence updates (typing, online, offline)
+        sock.ev.on('presence.update', (presence) => {
+            client.emit(Events.PRESENCE_UPDATE, presence)
+        })
+
+        // 5. Contacts upsert
+        sock.ev.on('contacts.upsert', (contacts) => {
+            client.emit(Events.CONTACTS_UPSERT, contacts)
+        })
+
+        // 6. Group participants updates (join, leave, promote, demote)
+        sock.ev.on('group-participants.update', (update) => {
+            client.emit(Events.GROUP_PARTICIPANTS_UPDATE, update)
+        })
+
+        // 7. VoIP incoming calls & status
+        sock.ev.on('call.received', (incomingCall) => {
+            const callCtx = new CallContext(client, incomingCall)
+            client.emit(Events.CALL_INCOMING, callCtx)
+        })
+
+        sock.ev.on('call', (calls) => {
+            client.emit(Events.CALL_STATUS, calls)
+            if (Array.isArray(calls)) {
+                for (const call of calls) {
+                    if (call.status === 'offer') {
+                        const callCtx = new CallContext(client, call)
+                        client.emit(Events.CALL_INCOMING, callCtx)
+                    }
+                }
+            }
+        })
+    }
+}
+
+exports.EventNormalizer = EventNormalizer
+exports.default = EventNormalizer

package/lib/Client/Normalizers/JidNormalizer.js

@@ -0,0 +1,96 @@
+"use strict"
+
+Object.defineProperty(exports, "__esModule", { value: true })
+
+class JidNormalizer {
+    /**
+     * Sanitizes and normalizes any phone number or JID string into a canonical JID,
+     * stripping device specifiers (e.g., ":1@s.whatsapp.net" -> "@s.whatsapp.net")
+     * @param {string} input - Phone number (e.g., "+55 (11) 99999-9999") or existing JID
+     * @returns {string} Normalized JID (e.g., "5511999999999@s.whatsapp.net")
+     */
+    static toJid(input) {
+        if (!input || typeof input !== 'string') return ''
+        const cleaned = input.trim()
+
+        if (cleaned.includes('@')) {
+            const [userPart, server] = cleaned.split('@')
+            const cleanUser = userPart.split(':')[0]
+            return `${cleanUser}@${server}`
+        }
+
+        const digits = cleaned.replace(/\D/g, '')
+        if (!digits) return ''
+
+        return `${digits}@s.whatsapp.net`
+    }
+
+    /**
+     * Extracts pure numeric phone number from a JID
+     * @param {string} jid - WhatsApp JID
+     * @returns {string} Extracted phone number or empty string
+     */
+    static toPhoneNumber(jid) {
+        if (!jid || typeof jid !== 'string') return ''
+        const base = jid.split('@')[0]
+        const withoutDevice = base.split(':')[0]
+        return withoutDevice.replace(/\D/g, '')
+    }
+
+    /**
+     * Checks if JID represents a WhatsApp Group
+     * @param {string} jid
+     * @returns {boolean}
+     */
+    static isGroup(jid) {
+        return typeof jid === 'string' && jid.endsWith('@g.us')
+    }
+
+    /**
+     * Checks if JID represents a WhatsApp Channel / Newsletter
+     * @param {string} jid
+     * @returns {boolean}
+     */
+    static isNewsletter(jid) {
+        return typeof jid === 'string' && jid.endsWith('@newsletter')
+    }
+
+    /**
+     * Checks if JID is an internal LID (Linked Identity)
+     * @param {string} jid
+     * @returns {boolean}
+     */
+    static isLid(jid) {
+        return typeof jid === 'string' && jid.endsWith('@lid')
+    }
+
+    /**
+     * Checks if JID is a regular user chat (Phone Number based)
+     * @param {string} jid
+     * @returns {boolean}
+     */
+    static isUser(jid) {
+        return typeof jid === 'string' && jid.endsWith('@s.whatsapp.net')
+    }
+
+    /**
+     * Checks if JID represents WhatsApp Status Broadcast
+     * @param {string} jid
+     * @returns {boolean}
+     */
+    static isStatusBroadcast(jid) {
+        return typeof jid === 'string' && jid === 'status@broadcast'
+    }
+
+    /**
+     * Checks if JID represents any Broadcast list
+     * @param {string} jid
+     * @returns {boolean}
+     */
+    static isBroadcast(jid) {
+        return typeof jid === 'string' && jid.endsWith('@broadcast')
+    }
+}
+
+exports.JidNormalizer = JidNormalizer
+exports.default = JidNormalizer