@arcaelas/whatsapp 6.1.3 → 7.0.0

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

@@ -3,19 +3,17 @@
  * @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';
+import { deserialize, jid_of, serialize } from '../../lib/store/index.js';
 /**
- * Clase base del chat: recibe el raw y deriva todo con getters.
- * Base Chat class: receives the raw and derives everything via getters.
+ * Chat: recibe el raw y deriva todo con getters.
+ * Chat: receives the raw and derives everything via getters.
  */
-export class Chat {
+export default class Chat {
     /**
-     * @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.
+     * @internal Documento crudo. `id` es el identificador del engine (JID, LID o `@g.us`);
+     * `pinned`, `mute_end_time` y `activity` son epoch ms.
+     * Raw document. `id` is the engine identifier (JID, LID or `@g.us`); `pinned`,
+     * `mute_end_time` and `activity` are epoch ms.
      */
     constructor(_raw) {
         this._raw = _raw;
@@ -50,71 +48,50 @@ export class Chat {
         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.
+ * Chat ligado a la sesión viva: el socket y el engine llegan resueltos, así que sus métodos
+ * no vuelven a comprobarlos.
+ * Chat bound to the live session: socket and engine arrive resolved, so its methods do not
+ * check them again.
  *
- * @param wa - Instancia principal / Main WhatsApp instance
+ * @param init - Sesión activa: cliente, motor y socket / Active session: client, engine and socket
+ * @returns Clase `Chat` con acceso a la sesión / `Chat` class with session access
  */
-export function chat(wa) {
+export function chat(init) {
+    // WhatsApp acepta 3 chats fijados y descarta el cuarto sin avisar.
+    // WhatsApp accepts 3 pinned chats and silently drops the fourth.
+    const MAX_PINNED = 3;
     /**
-     * Último mensaje del chat en el formato que exige `chatModify`.
-     * The chat's last message in the shape `chatModify` requires.
+     * Último mensaje del chat, en las dos formas que hacen falta: la marca de actividad que
+     * ordena la lista y el `lastMessages` que exige `chatModify`.
+     * The chat's last message, in the two shapes needed: the activity stamp that orders the
+     * list and the `lastMessages` 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) }]
-            : [];
-    }
-    /**
-     * 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;
-            }
-            for (const raw of page) {
-                const parsed = deserialize(raw);
-                if (parsed && parsed.id !== exclude && parsed.pinned != null) {
-                    total++;
-                }
-            }
-        }
-        return total;
-    }
+    const tail = async (cid) => {
+        const doc = deserialize((await init.engine.list(`/chat/${cid}/message`, 0, 1))[0] ?? null);
+        return {
+            at: doc?.created_at ?? 0,
+            messages: doc ? [{ key: { remoteJid: cid, id: doc.id, fromMe: doc.me }, messageTimestamp: Math.floor(doc.created_at / 1_000) }] : [],
+        };
+    };
     /**
-     * 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.
+     * Metadatos del grupo memoizados 15s: `members` y `content` los piden por cada chat de
+     * una página y sin caché sería un round-trip por fila.
+     * Group metadata memoized for 15s: `members` and `content` ask for them on every chat of
+     * a page, and without a cache that is one round-trip per row.
      */
-    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);
+    const groups = new Map();
+    const meta = (jid) => {
+        if (!groups.has(jid)) {
+            groups.set(jid, init.socket.groupMetadata(jid).catch(() => ({ participants: [] })));
+            setTimeout(() => groups.delete(jid), 15_000);
         }
-        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 {
+        return groups.get(jid);
+    };
+    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.
+         * Participantes: los integrantes en grupos, el contacto y yo en 1:1.
+         * Participants: members for groups, the contact and myself for 1:1.
          *
          * @param offset - Desplazamiento / Offset
          * @param limit - Tamaño de página / Page size
@@ -122,219 +99,172 @@ export function chat(wa) {
          */
         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));
+                ? (await meta(this._raw.id)).participants.map((participant) => participant.id)
+                : [this._raw.id, init.socket.user?.id].filter((id) => Boolean(id));
+            return Promise.all(ids.slice(offset, offset + limit).map(async (id) => new init.wa.Contact(deserialize(await init.engine.get(`/contact/${id}`)) ?? { id })));
         }
         /**
-         * 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.
+         * Descripción: el asunto del grupo o, en un 1:1, la bio del contacto. Es asíncrono
+         * porque ninguna de las dos vive en el documento del 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
+         * @returns Descripción, o cadena vacía / Description, or an empty string
          */
         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 ?? '';
+            return this.type === 'group'
+                ? (await meta(this._raw.id)).desc ?? ''
+                : deserialize(await init.engine.get(`/contact/${this._raw.id}`))?.status ?? '';
         }
         /**
-         * Mensajes del chat paginados desde el más reciente.
-         * Chat messages paginated from the most recent one.
+         * Mensajes del chat, del más reciente al más antiguo.
+         * Chat messages, from the most recent to the oldest.
          *
          * @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);
+            return init.wa.Message.list(this._raw.id, offset, limit);
         }
         /**
-         * Activa o desactiva el indicador «escribiendo…».
-         * Toggles the "typing…" indicator.
+         * Publica el indicador «escribiendo…».
+         * Publishes 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
+         * @param value - true escribe, false vuelve a pausa / true types, false returns to paused
          */
         async typing(value) {
-            let ok = false;
-            const socket = internals(wa).socket;
-            if (socket) {
-                await socket.sendPresenceUpdate(value ? 'composing' : 'paused', this._raw.id);
-                ok = true;
-            }
-            return ok;
+            await init.socket.sendPresenceUpdate(value ? 'composing' : 'paused', this._raw.id);
+            return true;
         }
         /**
-         * Activa o desactiva el indicador «grabando audio…».
-         * Toggles the "recording audio…" indicator.
+         * Publica el indicador «grabando audio…».
+         * Publishes 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
+         * @param value - true graba, false vuelve a pausa / true records, false returns to paused
          */
         async recording(value) {
-            let ok = false;
-            const socket = internals(wa).socket;
-            if (socket) {
-                await socket.sendPresenceUpdate(value ? 'recording' : 'paused', this._raw.id);
-                ok = true;
-            }
-            return ok;
+            await init.socket.sendPresenceUpdate(value ? 'recording' : 'paused', this._raw.id);
+            return true;
         }
         /**
-         * Archiva o desarchiva el chat en la cuenta de WhatsApp.
-         * Archives or unarchives the chat on the WhatsApp account.
+         * Archiva o desarchiva el chat en la cuenta.
+         * Archives or unarchives the chat on the 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;
-            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._raw.id}`, serialize(this._raw));
-                ok = true;
-            }
-            return ok;
+            const last = await tail(this._raw.id);
+            await init.socket.chatModify({ archive: value, lastMessages: last.messages }, this._raw.id);
+            this._raw.archived = value;
+            // Archivar no es actividad: el chat conserva su posición en la lista.
+            // Archiving is not activity: the chat keeps its position in the list.
+            await init.engine.set(`/chat/${this._raw.id}`, serialize(this._raw), this._raw.activity ?? last.at);
+            return true;
         }
         /**
-         * 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.
+         * Fija o desfija el chat. Al fijar comprueba el límite, porque WhatsApp descarta el
+         * cuarto chat fijado sin avisar.
+         * Pins or unpins the chat. When pinning it checks the limit, since WhatsApp silently
+         * drops the fourth pinned chat.
          *
          * @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
+         * @returns false si ya hay 3 chats fijados / false when 3 chats are already pinned
          */
         async pin(value) {
-            let ok = false;
-            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;
+            let pinned = 0;
+            for (let offset = 0; value && pinned < MAX_PINNED; offset += 200) {
+                const page = await init.engine.list('/chat', offset, 200);
+                if (page.length === 0) {
+                    break;
                 }
+                pinned += page.filter((raw) => {
+                    const doc = deserialize(raw);
+                    return doc?.pinned != null && doc.id !== this._raw.id;
+                }).length;
+            }
+            if (pinned >= MAX_PINNED) {
+                return false;
             }
-            return ok;
+            await init.socket.chatModify({ pin: value }, this._raw.id);
+            this._raw.pinned = value ? Date.now() : null;
+            await init.engine.set(`/chat/${this._raw.id}`, serialize(this._raw), this._raw.activity ?? (await tail(this._raw.id)).at);
+            return true;
         }
         /**
-         * 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.
+         * Silencia el chat hasta la fecha indicada; `false` o una fecha pasada lo reactivan.
+         * 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
+         * @param until - Fecha límite (ISO, epoch ms o Date), o false / Deadline (ISO, epoch ms or Date), or false
          */
         async mute(until) {
-            let ok = false;
-            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;
+            const end = until === false ? 0 : new Date(until).getTime();
+            const muted = end > Date.now();
+            await init.socket.chatModify({ mute: muted ? end : null }, this._raw.id);
+            this._raw.mute_end_time = muted ? end : null;
+            await init.engine.set(`/chat/${this._raw.id}`, serialize(this._raw), this._raw.activity ?? (await tail(this._raw.id)).at);
+            return true;
         }
         /**
-         * 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
+         * Marca el chat completo como leído en la cuenta.
+         * Marks the whole chat as read on the account.
          */
         async seen() {
-            let ok = false;
-            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;
+            const last = await tail(this._raw.id);
+            await init.socket.chatModify({ markRead: true, lastMessages: last.messages }, this._raw.id);
+            this._raw.unread_count = 0;
+            await init.engine.set(`/chat/${this._raw.id}`, serialize(this._raw), this._raw.activity ?? last.at);
+            return true;
         }
         /**
-         * 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
+         * Vacía los mensajes del chat en la cuenta y en el engine, conservando el chat.
+         * Clears the chat messages on the account and in the engine, keeping the chat.
          */
         async clear() {
-            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`);
+            await init.socket.chatModify({ clear: true, lastMessages: (await tail(this._raw.id)).messages }, this._raw.id).catch(() => null);
+            await init.engine.unset(`/chat/${this._raw.id}/message`);
             return true;
         }
         /**
-         * 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
+         * Elimina el chat y sus mensajes en la cuenta y en el engine; en grupos, además sale
+         * del grupo.
+         * Deletes the chat and its messages on the account and in the engine; for groups it
+         * also leaves the group.
          */
         async delete() {
-            const socket = internals(wa).socket;
-            if (socket) {
-                if (this.type === 'group') {
-                    await socket.groupLeave(this._raw.id).catch(() => null);
-                }
-                else {
-                    await socket
-                        .chatModify({ delete: true, lastMessages: await last_messages(this._raw.id) }, this._raw.id)
-                        .catch(() => null);
-                }
-            }
-            await wa.engine.unset(`/chat/${this._raw.id}`);
+            await (this.type === 'group'
+                ? init.socket.groupLeave(this._raw.id)
+                : init.socket.chatModify({ delete: true, lastMessages: (await tail(this._raw.id)).messages }, this._raw.id)).catch(() => null);
+            await init.engine.unset(`/chat/${this._raw.id}`);
             return true;
         }
         /**
-         * 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).
+         * Chat por teléfono, JID, LID o id de grupo: el persistido o, si no existe todavía,
+         * una instancia mínima lista para usar que no se persiste.
+         * Chat by phone, JID, LID or group id: the persisted one or, when it does not exist
+         * yet, a minimal ready-to-use instance that is 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
+         * @returns Chat, o null si el identificador es irresoluble / Chat, or null when the identifier cannot be resolved
          */
         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 null;
+            const id = await jid_of(init.engine, String(cid), init.socket);
+            return id ? new this(deserialize(await init.engine.get(`/chat/${id}`)) ?? { id }) : null;
         }
         /**
-         * Pagina los chats persistidos, del más reciente al más antiguo.
-         * Paginates persisted chats, from the most recent to the oldest.
+         * Pagina los chats persistidos, del más activo al más antiguo.
+         * Paginates persisted chats, from the most active 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))
+            return (await init.engine.list('/chat', offset, limit))
                 .map((raw) => deserialize(raw))
-                .filter((parsed) => parsed !== null)
-                .map((parsed) => new _Chat(parsed));
+                .filter((doc) => doc !== null)
+                .map((doc) => new this(doc));
         }
-    };
+    }
+    return _Chat;
 }