@arcaelas/whatsapp 4.5.0 → 6.0.0

package/build/esm/lib/chat/index.js

@@ -3,62 +3,55 @@
  * @description Entidad Chat — conversaciones individuales y grupales.
  * Chat entity — individual and group conversations.
  */
+import { internals } from '../../lib/internal.js';
+import { Message } from '../../lib/message/index.js';
 import { deserialize, serialize } from '../../lib/store/index.js';
 /**
- * Duración usada cuando `chat.mute(true)` silencia "siempre".
- * Duration used when `chat.mute(true)` means "mute forever".
- */
-const MUTE_FOREVER_MS = 365 * 100 * 24 * 3_600 * 1_000;
-/**
- * Clase base del chat (forma pública, solo lectura).
- * Base Chat class (public shape, read-only).
+ * Clase base del chat: recibe el raw y deriva todo con getters.
+ * Base Chat class: receives the raw and derives everything via getters.
  */
 export class Chat {
-    constructor(raw) {
-        this._raw = raw;
+    /**
+     * @internal Documento crudo del chat. `id` es el identificador del engine (JID, LID o
+     * `@g.us`); `pinned` y `mute_end_time` son epoch ms.
+     * Raw chat document. `id` is the engine identifier (JID, LID or `@g.us`); `pinned` and
+     * `mute_end_time` are epoch ms.
+     */
+    constructor(_raw) {
+        this._raw = _raw;
     }
-    /** JID del chat. / Chat JID. */
+    /** Teléfono del contacto, o el identificador crudo en grupos y LIDs. / Contact phone, or the raw identifier for groups and LIDs. */
     get id() {
-        return this._raw.id;
+        return this._raw.id.endsWith('@s.whatsapp.net') ? this._raw.id.split('@')[0].split(':')[0] : this._raw.id;
     }
-    /** CID (alias). / CID (alias). */
-    get cid() {
-        return this._raw.id;
+    /** Nombre del grupo o del contacto. / Group or contact name. */
+    get name() {
+        return this._raw.name ?? this.id;
     }
-    /** Tipo: contact o group. / Type: contact or group. */
+    /** Tipo de conversación. / Conversation type. */
     get type() {
         return this._raw.id.endsWith('@g.us') ? 'group' : 'contact';
     }
-    /** Nombre del chat. / Chat name. */
-    get name() {
-        return this._raw.name ?? this._raw.display_name ?? this._raw.id.split('@')[0];
-    }
-    /** Descripción del grupo. / Group description. */
-    get content() {
-        return this._raw.description ?? '';
+    /** true si el chat está archivado. / true when the chat is archived. */
+    get archived() {
+        return this._raw.archived ?? false;
     }
-    /** Si está fijado. / Whether it's pinned. */
+    /** true si el chat está fijado. / true when the chat is pinned. */
     get pinned() {
         return this._raw.pinned != null;
     }
-    /** Si está archivado. / Whether it's archived. */
-    get archived() {
-        return this._raw.archived ?? false;
+    /** Mensajes sin leer del chat. / Chat's unread messages. */
+    get count() {
+        return this._raw.unread_count ?? 0;
     }
-    /** true si el chat está silenciado y el silencio aún no expira. / true if chat is muted and the mute has not expired. */
+    /** Fecha ISO UTC hasta la que el chat está silenciado, o null. / ISO UTC date until the chat stays muted, or null. */
     get muted() {
         const end = this._raw.mute_end_time;
-        return end != null && end > Date.now();
-    }
-    /** Si está leído. / Whether it's read. */
-    get read() {
-        return !this._raw.unread_count && !this._raw.marked_as_unread;
-    }
-    /** Si es solo lectura. / Whether it's read-only. */
-    get readonly() {
-        return this._raw.read_only ?? false;
+        return end != null && end > Date.now() ? new Date(end).toISOString() : null;
     }
 }
+/** Máximo de chats fijados que acepta WhatsApp; el cuarto se descarta en silencio. / Max pinned chats WhatsApp accepts; the fourth is silently dropped. */
+const MAX_PINNED = 3;
 /**
  * Factoría de Chat ligada al contexto WhatsApp.
  * Context-bound Chat factory.
@@ -67,243 +60,281 @@ export class Chat {
  */
 export function chat(wa) {
     /**
-     * Obtiene la key del último mensaje para operaciones de chatModify que la requieren.
-     * Fetches the last message key required by chatModify operations.
+     * Último mensaje del chat en el formato que exige `chatModify`.
+     * The chat's last message in the shape `chatModify` requires.
      */
     async function last_messages(cid) {
         const [raw] = await wa.engine.list(`/chat/${cid}/message`, 0, 1);
         const parsed = deserialize(raw ?? null);
         return parsed
-            ? [
-                {
-                    key: { remoteJid: cid, id: parsed.id, fromMe: parsed.me },
-                    messageTimestamp: Math.floor(parsed.created_at / 1000),
-                },
-            ]
+            ? [{ key: { remoteJid: cid, id: parsed.id, fromMe: parsed.me }, messageTimestamp: Math.floor(parsed.created_at / 1000) }]
             : [];
     }
-    return class _Chat extends Chat {
-        constructor() {
-            super(...arguments);
-            /** @internal Cache TTL (15s) de la promesa de participants del grupo. Evita round-trips a `groupMetadata` y deduplica llamadas concurrentes. */
-            this._members_cache = null;
-        }
-        /**
-         * Obtiene un chat por CID. Si no está persistido, lo crea a partir del contacto.
-         * Retrieves a chat by CID. If not persisted, creates it from the contact.
-         */
-        static async get(cid) {
-            let result = null;
-            const jid = await wa._resolve_jid(cid);
-            if (jid) {
-                const cached = deserialize(await wa.engine.get(`/chat/${jid}`));
-                if (cached) {
-                    result = new _Chat(cached);
-                }
-                else {
-                    const c = await wa.Contact.get(jid);
-                    if (c) {
-                        const raw = { id: jid, name: c.name };
-                        await wa.engine.set(`/chat/${jid}`, serialize(raw));
-                        result = new _Chat(raw);
-                    }
-                }
+    /**
+     * Cuenta los chats fijados distintos del indicado, cortando al llegar al máximo.
+     * Counts pinned chats other than the given one, stopping once the max is reached.
+     */
+    async function count_pinned(exclude) {
+        let total = 0;
+        for (let offset = 0; total < MAX_PINNED; offset += 200) {
+            const page = await wa.engine.list('/chat', offset, 200);
+            if (page.length === 0) {
+                break;
             }
-            return result;
-        }
-        /** Pagina los chats persistidos por mtime DESC. / Paginates persisted chats by mtime DESC. */
-        static async list(offset = 0, limit = 50) {
-            const chats = [];
-            for (const raw of await wa.engine.list('/chat', offset, limit)) {
+            for (const raw of page) {
                 const parsed = deserialize(raw);
-                if (parsed) {
-                    chats.push(new _Chat(parsed));
+                if (parsed && parsed.id !== exclude && parsed.pinned != null) {
+                    total++;
                 }
             }
-            return chats;
         }
-        /** Fija/desfija un chat por CID. / Pins or unpins a chat by CID. */
-        static async pin(cid, value) {
-            const c = await _Chat.get(cid);
-            return c ? c.pin(value) : false;
-        }
-        /** Archiva/desarchiva un chat por CID. / Archives or unarchives a chat by CID. */
-        static async archive(cid, value) {
-            const c = await _Chat.get(cid);
-            return c ? c.archive(value) : false;
+        return total;
+    }
+    /**
+     * Participantes del grupo memoizados 15s, para no repetir `groupMetadata` en cada página.
+     * Group participants memoized for 15s, avoiding a `groupMetadata` round-trip per page.
+     */
+    const groups_cache = new Map();
+    function group_meta(jid) {
+        if (!groups_cache.has(jid)) {
+            const socket = internals(wa).socket;
+            groups_cache.set(jid, socket ? socket.groupMetadata(jid).catch(() => ({ participants: [] })) : Promise.resolve({ participants: [] }));
+            setTimeout(() => groups_cache.delete(jid), 15_000);
         }
-        /** Silencia/des-silencia un chat por CID. / Mutes or unmutes a chat by CID. */
-        static async mute(cid, value) {
-            const c = await _Chat.get(cid);
-            return c ? c.mute(value) : false;
+        return groups_cache.get(jid);
+    }
+    /**
+     * Contacto desde el engine, o ficha mínima local cuando no está persistido (sin red).
+     * Contact from the engine, or a minimal local card when not persisted (no network).
+     */
+    async function load_contact(id) {
+        const cached = deserialize(await wa.engine.get(`/contact/${id}`));
+        return new wa.Contact(cached ?? { id });
+    }
+    return class _Chat extends Chat {
+        /**
+         * Participantes del chat: los integrantes en grupos, el contacto y yo en 1:1.
+         * Chat participants: members for groups, the contact and myself for 1:1.
+         *
+         * @param offset - Desplazamiento / Offset
+         * @param limit - Tamaño de página / Page size
+         * @returns Página de contactos / Contact page
+         */
+        async members(offset = 0, limit = 50) {
+            const ids = this.type === 'group'
+                ? (await group_meta(this._raw.id)).participants.map((participant) => participant.id)
+                : [this._raw.id, internals(wa).socket?.user?.id].filter((id) => Boolean(id));
+            return Promise.all(ids.slice(offset, offset + limit).map(load_contact));
         }
-        /** Vacía mensajes del chat (local). / Clears the chat's messages (local only). */
-        static async clear(cid) {
-            const c = await _Chat.get(cid);
-            return c ? c.clear() : false;
+        /**
+         * Descripción del chat: el asunto del grupo o, en un 1:1, la bio del contacto.
+         * Es asíncrono porque ninguno de los dos vive en el documento del chat.
+         * Chat description: the group's subject or, on a 1:1, the contact's bio. It is async
+         * because neither of them lives in the chat document.
+         *
+         * @returns Descripción, o cadena vacía si no hay / Description, or an empty string when absent
+         */
+        async content() {
+            if (this.type === 'group') {
+                return (await group_meta(this._raw.id)).desc ?? '';
+            }
+            return deserialize(await wa.engine.get(`/contact/${this._raw.id}`))?.status ?? '';
         }
-        /** Elimina el chat y sus mensajes. / Deletes the chat and its messages. */
-        static async delete(cid) {
-            const c = await _Chat.get(cid);
-            return c ? c.delete() : false;
+        /**
+         * Mensajes del chat paginados desde el más reciente.
+         * Chat messages paginated from the most recent one.
+         *
+         * @param offset - Desplazamiento / Offset
+         * @param limit - Tamaño de página / Page size
+         * @returns Página de mensajes / Message page
+         */
+        async messages(offset = 0, limit = 50) {
+            return Message.list(wa, this._raw.id, offset, limit);
         }
-        /** Re-hidrata metadata del chat desde el socket. / Re-hydrates chat metadata from the socket. */
-        async refresh() {
+        /**
+         * Activa o desactiva el indicador «escribiendo…».
+         * Toggles the "typing…" indicator.
+         *
+         * @param value - true activa, false vuelve a pausa / true enables, false returns to paused
+         * @returns true si el socket estaba disponible / true when the socket was available
+         */
+        async typing(value) {
             let ok = false;
-            if (wa._socket) {
-                if (this.type === 'group') {
-                    try {
-                        const meta = await wa._socket.groupMetadata(this.id);
-                        this._raw.name = meta.subject;
-                        this._raw.description = meta.desc ?? null;
-                        this._raw.participants = meta.participants.map((p) => ({
-                            id: p.id,
-                            admin: p.admin ?? null,
-                        }));
-                        this._raw.created_by = meta.owner ?? null;
-                        this._raw.created_at = meta.creation ?? null;
-                    }
-                    catch {
-                        /* group metadata may fail */
-                    }
-                }
-                else {
-                    const c = await wa.Contact.get(this.id);
-                    if (c) {
-                        await c.refresh();
-                        this._raw.name = c.name;
-                    }
-                }
-                await wa.engine.set(`/chat/${this.id}`, serialize(this._raw));
+            const socket = internals(wa).socket;
+            if (socket) {
+                await socket.sendPresenceUpdate(value ? 'composing' : 'paused', this._raw.id);
                 ok = true;
             }
-            return ok ? this : null;
+            return ok;
         }
-        /** Fija/desfija el chat. / Pins or unpins the chat. */
-        async pin(value) {
+        /**
+         * Activa o desactiva el indicador «grabando audio…».
+         * Toggles the "recording audio…" indicator.
+         *
+         * @param value - true activa, false vuelve a pausa / true enables, false returns to paused
+         * @returns true si el socket estaba disponible / true when the socket was available
+         */
+        async recording(value) {
             let ok = false;
-            if (wa._socket) {
-                await wa._socket.chatModify({ pin: value, lastMessages: await last_messages(this.id) }, this.id);
-                this._raw.pinned = value ? Date.now() : null;
-                await wa.engine.set(`/chat/${this.id}`, serialize(this._raw));
+            const socket = internals(wa).socket;
+            if (socket) {
+                await socket.sendPresenceUpdate(value ? 'recording' : 'paused', this._raw.id);
                 ok = true;
             }
             return ok;
         }
-        /** Archiva/desarchiva el chat. / Archives or unarchives the chat. */
+        /**
+         * Archiva o desarchiva el chat en la cuenta de WhatsApp.
+         * Archives or unarchives the chat on the WhatsApp account.
+         *
+         * @param value - true archiva, false desarchiva / true archives, false unarchives
+         * @returns true si la acción se envió / true when the action was sent
+         */
         async archive(value) {
             let ok = false;
-            if (wa._socket) {
-                await wa._socket.chatModify({ archive: value, lastMessages: await last_messages(this.id) }, this.id);
+            const socket = internals(wa).socket;
+            if (socket) {
+                await socket.chatModify({ archive: value, lastMessages: await last_messages(this._raw.id) }, this._raw.id);
                 this._raw.archived = value;
-                await wa.engine.set(`/chat/${this.id}`, serialize(this._raw));
+                await wa.engine.set(`/chat/${this._raw.id}`, serialize(this._raw));
                 ok = true;
             }
             return ok;
         }
-        /** Silencia/des-silencia el chat. / Mutes or unmutes the chat. */
-        async mute(value) {
+        /**
+         * Fija o desfija el chat en la cuenta de WhatsApp. WhatsApp acepta hasta 3 chats
+         * fijados y descarta el cuarto sin avisar, así que el límite se verifica antes.
+         * Pins or unpins the chat on the WhatsApp account. WhatsApp accepts up to 3 pinned
+         * chats and silently drops the fourth, so the limit is checked beforehand.
+         *
+         * @param value - true fija, false desfija / true pins, false unpins
+         * @returns false si el socket está caído o ya hay 3 chats fijados / false when the socket is down or 3 chats are already pinned
+         */
+        async pin(value) {
             let ok = false;
-            if (wa._socket) {
-                const mute_end = value === true ? Date.now() + MUTE_FOREVER_MS : null;
-                await wa._socket.chatModify({ mute: mute_end, lastMessages: await last_messages(this.id) }, this.id);
-                this._raw.mute_end_time = mute_end;
-                await wa.engine.set(`/chat/${this.id}`, serialize(this._raw));
-                ok = true;
+            const socket = internals(wa).socket;
+            if (socket) {
+                const allowed = value ? (await count_pinned(this._raw.id)) < MAX_PINNED : true;
+                if (allowed) {
+                    await socket.chatModify({ pin: value }, this._raw.id);
+                    this._raw.pinned = value ? Date.now() : null;
+                    await wa.engine.set(`/chat/${this._raw.id}`, serialize(this._raw));
+                    ok = true;
+                }
             }
             return ok;
         }
-        /** Toggle "Escribiendo...". / Toggles the "typing..." indicator. */
-        async typing(on) {
+        /**
+         * Silencia el chat hasta la fecha indicada. `false` o una fecha pasada lo des-silencian.
+         * Mutes the chat until the given date. `false` or a past date unmutes it.
+         *
+         * @param until - Fecha límite (ISO, epoch ms o Date) o false / Deadline (ISO, epoch ms or Date) or false
+         * @returns true si la acción se envió / true when the action was sent
+         */
+        async mute(until) {
             let ok = false;
-            if (wa._socket) {
-                await wa._socket.sendPresenceUpdate(on ? 'composing' : 'paused', this.id);
+            const socket = internals(wa).socket;
+            if (socket) {
+                const end = until === false ? 0 : new Date(until).getTime();
+                const muted = end > Date.now();
+                await socket.chatModify({ mute: muted ? end : null }, this._raw.id);
+                this._raw.mute_end_time = muted ? end : null;
+                await wa.engine.set(`/chat/${this._raw.id}`, serialize(this._raw));
                 ok = true;
             }
             return ok;
         }
-        /** Toggle "Grabando audio...". / Toggles the "recording audio..." indicator. */
-        async recording(on) {
+        /**
+         * Marca el chat completo como leído en la cuenta de WhatsApp.
+         * Marks the whole chat as read on the WhatsApp account.
+         *
+         * @returns true si la acción se envió / true when the action was sent
+         */
+        async seen() {
             let ok = false;
-            if (wa._socket) {
-                await wa._socket.sendPresenceUpdate(on ? 'recording' : 'paused', this.id);
+            const socket = internals(wa).socket;
+            if (socket) {
+                await socket.chatModify({ markRead: true, lastMessages: await last_messages(this._raw.id) }, this._raw.id);
+                this._raw.unread_count = 0;
+                await wa.engine.set(`/chat/${this._raw.id}`, serialize(this._raw));
                 ok = true;
             }
             return ok;
         }
-        /** Vacía mensajes del chat (engine local). / Clears chat messages (local engine). */
+        /**
+         * Vacía los mensajes del chat en la cuenta de WhatsApp y en el engine, conservando el chat.
+         * Clears the chat messages on the WhatsApp account and in the engine, keeping the chat.
+         *
+         * @returns true siempre; la limpieza local es idempotente / always true; local cleanup is idempotent
+         */
         async clear() {
-            await wa.engine.unset(`/chat/${this.id}/message`);
+            const socket = internals(wa).socket;
+            if (socket) {
+                await socket
+                    .chatModify({ clear: true, lastMessages: await last_messages(this._raw.id) }, this._raw.id)
+                    .catch(() => null);
+            }
+            await wa.engine.unset(`/chat/${this._raw.id}/message`);
             return true;
         }
-        /** Elimina el chat y sus mensajes (remoto + local). / Deletes the chat and its messages (remote + local). */
+        /**
+         * Elimina el chat y sus mensajes en la cuenta de WhatsApp y en el engine; en grupos
+         * abandona el grupo.
+         * Deletes the chat and its messages on the WhatsApp account and in the engine; for
+         * groups it leaves the group.
+         *
+         * @returns true siempre; la limpieza local es idempotente / always true; local cleanup is idempotent
+         */
         async delete() {
-            if (wa._socket) {
+            const socket = internals(wa).socket;
+            if (socket) {
                 if (this.type === 'group') {
-                    try {
-                        await wa._socket.groupLeave(this.id);
-                    }
-                    catch {
-                        /* may fail */
-                    }
+                    await socket.groupLeave(this._raw.id).catch(() => null);
                 }
                 else {
-                    try {
-                        await wa._socket.chatModify({ delete: true, lastMessages: [] }, this.id);
-                    }
-                    catch {
-                        /* may fail */
-                    }
+                    await socket
+                        .chatModify({ delete: true, lastMessages: await last_messages(this._raw.id) }, this._raw.id)
+                        .catch(() => null);
                 }
             }
-            await this.clear();
-            await wa.engine.unset(`/chat/${this.id}`);
+            await wa.engine.unset(`/chat/${this._raw.id}`);
             return true;
         }
         /**
-         * Participantes del chat paginados (incluyéndome en grupos). Para grupos,
-         * el `groupMetadata` se memoiza en la instancia con TTL de 15s para evitar
-         * round-trips repetidos al socket.
-         * Chat participants paginated (self included in groups). For groups,
-         * `groupMetadata` is memoized on the instance with a 15s TTL to avoid
-         * repeated socket round-trips.
+         * Carga un chat por teléfono, JID, LID o id de grupo: el persistido en el engine o,
+         * si todavía no existe, una instancia mínima lista para usar (no se persiste).
+         * Loads a chat by phone, JID, LID or group id: the engine-persisted one or, when it
+         * does not exist yet, a minimal ready-to-use instance (not persisted).
+         *
+         * @param cid - Teléfono, JID, LID o id de grupo / Phone, JID, LID or group id
+         * @returns Chat o null si el identificador es irresoluble / Chat or null when the identifier cannot be resolved
          */
-        async members(offset = 0, limit = 50) {
-            const result = [];
-            if (this.type !== 'group') {
-                if (offset === 0 && limit > 0) {
-                    const c = await wa.Contact.get(this.id);
-                    if (c) {
-                        result.push(c);
-                    }
-                }
-            }
-            else if (wa._socket) {
-                try {
-                    const socket = wa._socket;
-                    const participants = await (this._members_cache ??= (async () => {
-                        const meta = await socket.groupMetadata(this.id);
-                        setTimeout(() => { this._members_cache = null; }, 15_000);
-                        return meta.participants;
-                    })());
-                    const slice = participants.slice(offset, offset + limit);
-                    for (const p of slice) {
-                        const existing = await wa.Contact.get(p.id);
-                        if (existing) {
-                            result.push(existing);
-                        }
-                    }
-                }
-                catch {
-                    /* may fail */
-                }
+        static async get(cid) {
+            const digits = String(cid).replace(/\D+/g, '');
+            const jid = String(cid).includes('@')
+                ? await internals(wa).resolve_jid(String(cid))
+                : digits
+                    ? `${digits}@s.whatsapp.net`
+                    : null;
+            if (jid) {
+                const cached = deserialize(await wa.engine.get(`/chat/${jid}`));
+                return new _Chat(cached ?? { id: jid });
             }
-            return result;
+            return null;
         }
-        /** Mensajes del chat paginados por mtime DESC. / Chat messages paginated by mtime DESC. */
-        async messages(offset = 0, limit = 50) {
-            return wa.Message.list(this.id, offset, limit);
+        /**
+         * Pagina los chats persistidos, del más reciente al más antiguo.
+         * Paginates persisted chats, from the most recent to the oldest.
+         *
+         * @param offset - Desplazamiento / Offset
+         * @param limit - Tamaño de página / Page size
+         * @returns Página de chats / Chat page
+         */
+        static async list(offset = 0, limit = 50) {
+            return (await wa.engine.list('/chat', offset, limit))
+                .map((raw) => deserialize(raw))
+                .filter((parsed) => parsed !== null)
+                .map((parsed) => new _Chat(parsed));
         }
     };
 }
-//# sourceMappingURL=index.js.map