@arcaelas/whatsapp 7.0.1 → 7.2.0

package/build/cjs/lib/message/index.d.ts

@@ -54,6 +54,8 @@ export default class Message {
         mime: string;
         caption: string;
         edited: boolean;
+        /** Momento en que se retiró para todos, o null si sigue vigente / When it was revoked for everyone, or null while it stands */
+        revoked_at?: number | null;
         multiple?: boolean;
         reactions?: {
             author: string;
@@ -96,6 +98,15 @@ export default class Message {
     get forwarded(): boolean;
     /** true si fue editado. / true when edited. */
     get edited(): boolean;
+    /**
+     * true si se retiró para todos. El documento no se borra: el mensaje sigue en su sitio
+     * para que la interfaz muestre «se eliminó este mensaje» en vez de un hueco.
+     * true when revoked for everyone. The document is not removed: the message stays in place
+     * so the interface can show "this message was deleted" instead of a gap.
+     */
+    get revoked(): boolean;
+    /** Fecha del retiro en ISO UTC, o null. / Revocation date as ISO UTC, or null. */
+    get revoked_at(): string | null;
     /** Fecha de creación en ISO UTC. / Creation date as ISO UTC. */
     get created_at(): string;
     /** Vencimiento del mensaje temporal en ISO UTC, o null. / Ephemeral expiration as ISO UTC, or null. */
@@ -106,7 +117,13 @@ export default class Message {
     get reason(): string | null;
     /** Nombre del negocio verificado que firma el mensaje, o null. / Verified business name signing the message, or null. */
     get business(): string | null;
-    /** true si es de una sola lectura (view-once). / true when view-once. */
+    /**
+     * true si es de una sola lectura (view-once). La marca vive en tres sitios según quién
+     * lo envió: la llave del sobre, el propio nodo del media (forma actual) o el wrapper
+     * heredado.
+     * true when view-once. The flag lives in three places depending on the sender: the key,
+     * the media node itself (current form) or the legacy wrapper.
+     */
     get once(): boolean;
     /** Contacto autor, desde el engine (ficha mínima si no está persistido). / Author contact, from the engine (minimal card when not persisted). */
     author(): Promise<InstanceType<WhatsApp['Contact']>>;
@@ -403,6 +420,8 @@ export declare function message(init: Init): {
             mime: string;
             caption: string;
             edited: boolean;
+            /** Momento en que se retiró para todos, o null si sigue vigente / When it was revoked for everyone, or null while it stands */
+            revoked_at?: number | null;
             multiple?: boolean;
             reactions?: {
                 author: string;
@@ -436,6 +455,15 @@ export declare function message(init: Init): {
         get forwarded(): boolean;
         /** true si fue editado. / true when edited. */
         get edited(): boolean;
+        /**
+         * true si se retiró para todos. El documento no se borra: el mensaje sigue en su sitio
+         * para que la interfaz muestre «se eliminó este mensaje» en vez de un hueco.
+         * true when revoked for everyone. The document is not removed: the message stays in place
+         * so the interface can show "this message was deleted" instead of a gap.
+         */
+        get revoked(): boolean;
+        /** Fecha del retiro en ISO UTC, o null. / Revocation date as ISO UTC, or null. */
+        get revoked_at(): string | null;
         /** Fecha de creación en ISO UTC. / Creation date as ISO UTC. */
         get created_at(): string;
         /** Vencimiento del mensaje temporal en ISO UTC, o null. / Ephemeral expiration as ISO UTC, or null. */
@@ -446,7 +474,13 @@ export declare function message(init: Init): {
         get reason(): string | null;
         /** Nombre del negocio verificado que firma el mensaje, o null. / Verified business name signing the message, or null. */
         get business(): string | null;
-        /** true si es de una sola lectura (view-once). / true when view-once. */
+        /**
+         * true si es de una sola lectura (view-once). La marca vive en tres sitios según quién
+         * lo envió: la llave del sobre, el propio nodo del media (forma actual) o el wrapper
+         * heredado.
+         * true when view-once. The flag lives in three places depending on the sender: the key,
+         * the media node itself (current form) or the legacy wrapper.
+         */
         get once(): boolean;
         /** Contacto autor, desde el engine (ficha mínima si no está persistido). / Author contact, from the engine (minimal card when not persisted). */
         author(): Promise<InstanceType<WhatsApp["Contact"]>>;

package/build/cjs/lib/message/index.js

@@ -23,6 +23,40 @@ const STATUS = ['error', 'pending', 'sent', 'delivered', 'read', 'played'];
 const unwrap = (msg) => msg.viewOnceMessage?.message ?? msg.viewOnceMessageV2?.message ?? msg.viewOnceMessageV2Extension?.message ?? msg.documentWithCaptionMessage?.message ?? msg;
 /** Bytes del proto (Uint8Array en runtime, base64 tras el engine) como Buffer. / Proto bytes (runtime Uint8Array, post-engine base64) as a Buffer. */
 const to_buffer = (value) => value instanceof Uint8Array && value.length ? Buffer.from(value) : typeof value === 'string' && value ? Buffer.from(value, 'base64') : null;
+/**
+ * Envío de vista única con el proto que WhatsApp entrega: se genera el contenido normal (media
+ * plano, sin wrapper), se marca `viewOnce` en el propio nodo del media y `isViewOnce` en la
+ * llave, y se transmite tal cual.
+ * View-once send with the proto WhatsApp actually delivers: the regular content is generated
+ * (flat media, no wrapper), `viewOnce` is flagged on the media node itself and `isViewOnce` on
+ * the key, and it is relayed as is.
+ *
+ * @param init - Sesión activa / Active session
+ * @param jid - Destino resuelto / Resolved target
+ * @param content - Contenido proto / Proto content
+ * @param quoted - Mensaje citado / Quoted message
+ * @returns Mensaje transmitido / Relayed message
+ */
+const once_of = async (init, jid, content, quoted) => {
+    const full = await (0, baileys_1.generateWAMessage)(jid, content, {
+        logger: init.socket.logger,
+        userJid: init.socket.user.id,
+        upload: init.socket.waUploadToServer,
+        ...(quoted && { quoted }),
+    });
+    // El media queda al nivel superior; sólo hay que marcarlo. / The media stays top level; it only needs flagging.
+    for (const node of Object.values(full.message ?? {}))
+        if (node && typeof node === 'object' && 'mimetype' in node)
+            node.viewOnce = true;
+    full.key.isViewOnce = true;
+    await init.socket.relayMessage(jid, full.message, { messageId: full.key.id });
+    // El relay no publica el mensaje: se emite el upsert que `sendMessage` haría, para que el
+    // resto de la sesión (eventos, cachés de los consumidores) lo vea como cualquier envío.
+    // The relay does not publish the message: the upsert `sendMessage` would emit is fired, so
+    // the rest of the session (events, consumer caches) sees it like any other send.
+    init.socket.ev.emit('messages.upsert', { messages: [full], type: 'append' });
+    return full;
+};
 /**
  * Envío base: resuelve el destino, cita si hay `mid`, marca view-once, persiste el documento
  * con su binario y retorna la instancia del tipo correcto. La cita viaja en las opciones del
@@ -36,7 +70,17 @@ const send = async (init, cid, content, binary, extra = {}, overrides) => {
     if (!jid)
         return null;
     const quoted = extra.mid ? (0, store_1.deserialize)(await init.engine.get(`/chat/${jid}/message/${extra.mid}`))?.raw : undefined;
-    const raw = await init.socket.sendMessage(jid, { ...content, ...(extra.once && { viewOnce: true }) }, { ...(quoted && { quoted }) });
+    // La vista única viaja como la manda WhatsApp: el media PLANO con `viewOnce` en su propio
+    // nodo y el sobre marcado con `isViewOnce`, sin envolverlo en `viewOnceMessage(V2)` —el
+    // wrapper que arma baileys con `viewOnce: true` queda en «enviado» y no se entrega.
+    // Comprobado contra el proto de un view-once entrante real.
+    // View-once travels the way WhatsApp sends it: the media FLAT with `viewOnce` on its own
+    // node and the key flagged `isViewOnce`, never wrapped in `viewOnceMessage(V2)` —the
+    // wrapper baileys builds from `viewOnce: true` stalls at "sent" and is never delivered.
+    // Checked against the proto of a real incoming view-once.
+    const raw = extra.once
+        ? await once_of(init, jid, content, quoted)
+        : await init.socket.sendMessage(jid, content, { ...(quoted && { quoted }) });
     if (!raw?.key?.id)
         return null;
     const sent = new Message(init, raw);
@@ -154,6 +198,15 @@ class Message {
     get forwarded() { return this._raw.forwarded; }
     /** true si fue editado. / true when edited. */
     get edited() { return this._raw.edited; }
+    /**
+     * true si se retiró para todos. El documento no se borra: el mensaje sigue en su sitio
+     * para que la interfaz muestre «se eliminó este mensaje» en vez de un hueco.
+     * true when revoked for everyone. The document is not removed: the message stays in place
+     * so the interface can show "this message was deleted" instead of a gap.
+     */
+    get revoked() { return this._raw.revoked_at != null; }
+    /** Fecha del retiro en ISO UTC, o null. / Revocation date as ISO UTC, or null. */
+    get revoked_at() { return this._raw.revoked_at != null ? new Date(this._raw.revoked_at).toISOString() : null; }
     /** Fecha de creación en ISO UTC. / Creation date as ISO UTC. */
     get created_at() { return new Date(this._raw.created_at).toISOString(); }
     /** Vencimiento del mensaje temporal en ISO UTC, o null. / Ephemeral expiration as ISO UTC, or null. */
@@ -172,10 +225,18 @@ class Message {
     }
     /** Nombre del negocio verificado que firma el mensaje, o null. / Verified business name signing the message, or null. */
     get business() { return this._raw.raw.verifiedBizName ?? null; }
-    /** true si es de una sola lectura (view-once). / true when view-once. */
+    /**
+     * true si es de una sola lectura (view-once). La marca vive en tres sitios según quién
+     * lo envió: la llave del sobre, el propio nodo del media (forma actual) o el wrapper
+     * heredado.
+     * true when view-once. The flag lives in three places depending on the sender: the key,
+     * the media node itself (current form) or the legacy wrapper.
+     */
     get once() {
         const msg = this._raw.raw.message;
-        return Boolean(msg?.viewOnceMessage ?? msg?.viewOnceMessageV2 ?? msg?.viewOnceMessageV2Extension);
+        const body = msg ? unwrap(msg) : {};
+        const media = body[(0, baileys_1.getContentType)(body)];
+        return Boolean(this._raw.raw.key?.isViewOnce ?? media?.viewOnce ?? msg?.viewOnceMessage ?? msg?.viewOnceMessageV2 ?? msg?.viewOnceMessageV2Extension);
     }
     /** Contacto autor, desde el engine (ficha mínima si no está persistido). / Author contact, from the engine (minimal card when not persisted). */
     async author() {
@@ -306,11 +367,19 @@ class Message {
      */
     async delete(all = false) {
         const doc = this._raw;
-        if (all)
+        // Retirar para todos deja el mensaje en su sitio, marcado; borrarlo solo para uno lo
+        // saca del historial local, que es lo que significa cada acción en WhatsApp.
+        // Revoking for everyone leaves the message in place, flagged; deleting it just for
+        // oneself drops it from the local history, which is what each action means on WhatsApp.
+        if (all) {
             await this._init.socket.sendMessage(doc.cid, { delete: { remoteJid: doc.cid, id: doc.id, fromMe: doc.me } });
-        else
+            doc.revoked_at = Date.now();
+            await this._init.engine.set(`/chat/${doc.cid}/message/${doc.id}`, (0, store_1.serialize)(doc), doc.created_at);
+        }
+        else {
             await this._init.socket.chatModify({ deleteForMe: { deleteMedia: false, key: { remoteJid: doc.cid, id: doc.id, fromMe: doc.me }, timestamp: Date.now() } }, doc.cid);
-        await this._init.engine.unset(`/chat/${doc.cid}/message/${doc.id}`);
+            await this._init.engine.unset(`/chat/${doc.cid}/message/${doc.id}`);
+        }
         return true;
     }
     /** Responde con texto. / Replies with text. */

package/build/cjs/lib/store/index.js

@@ -47,6 +47,15 @@ function deserialize(raw) {
         return null;
     }
 }
+/**
+ * Un mapeo que lleva a otro LID no traduce nada, y al ser truthy corta la cadena de respaldos
+ * de `jid_of` justo antes de llegar al mapping de baileys —el único que sí conoce el teléfono—.
+ * Descartarlo es lo que permite que la cadena siga buscando.
+ * A mapping leading to another LID translates nothing, and being truthy it cuts `jid_of`'s
+ * fallback chain right before reaching the baileys mapping —the only one that does know the
+ * phone—. Discarding it is what lets the chain keep looking.
+ */
+const phone_like = (value) => (value != null && !String(value).endsWith('@lid') ? String(value) : null);
 /**
  * JID canónico de un teléfono, JID o LID: los grupos y JIDs pasan tal cual, el LID se mapea
  * contra los índices `/lid` del engine (o contra baileys cuando hay socket) y el resto se
@@ -65,9 +74,9 @@ const jid_of = async (engine, uid, socket) => {
         return uid;
     const lid = uid.endsWith('@lid') ? (0, baileys_1.jidNormalizedUser)(uid) : '';
     const mapped = lid
-        ? deserialize(await engine.get(`/lid/${lid}`))
-            ?? deserialize(await engine.get(`/lid/${lid.split('@')[0]}_reverse`))
-            ?? await socket?.signalRepository?.lidMapping?.getPNForLID(lid).catch(() => null)
+        ? phone_like(deserialize(await engine.get(`/lid/${lid}`)))
+            ?? phone_like(deserialize(await engine.get(`/lid/${lid.split('@')[0]}_reverse`)))
+            ?? phone_like(await socket?.signalRepository?.lidMapping?.getPNForLID(lid).catch(() => null))
         : uid.replace(/\D/g, '');
     return mapped ? (String(mapped).includes('@') ? (0, baileys_1.jidNormalizedUser)(String(mapped)) : `${mapped}@s.whatsapp.net`) : null;
 };

package/build/cjs/lib/whatsapp/index.d.ts

@@ -21,6 +21,15 @@ interface Options {
     };
     /** Descargar el historial de mensajes al vincular; contactos, credenciales, LID mappings y tctokens se sincronizan siempre. / Download the message history on link; contacts, credentials, LID mappings and tctokens always sync. */
     sync?: boolean;
+    /**
+     * Nombre con el que esta sesión aparece en «Dispositivos vinculados» del teléfono. Cuando
+     * una cuenta tiene varias sesiones, es lo ÚNICO que permite distinguirlas para cerrar la
+     * correcta: sin él todas se ven iguales y no hay forma de saber cuál sobra.
+     * Name this session shows under the phone's «Linked devices». When an account holds several
+     * sessions it is the ONLY thing telling them apart to close the right one: without it they
+     * all look alike and there is no way to know which one is spare.
+     */
+    device?: string;
 }
 interface EventMap {
     connected: [WhatsApp];
@@ -63,10 +72,28 @@ export default class WhatsApp {
     off<E extends keyof EventMap>(event: E, handler: (...args: EventMap[E]) => void): this;
     connect(callback: (auth: string | Buffer) => void | Promise<void>): Promise<void>;
     /**
-     * Cierra la sesión: cancela el reintento pendiente y termina el socket.
-     * Closes the session: cancels the pending retry and ends the socket.
+     * Cierra la sesión de verdad: desvincula el dispositivo del teléfono y termina el socket.
+     * La promesa no resuelve hasta que todo eso ocurrió.
+     *
+     * Los dos flags modulan efectos secundarios, nunca si la sesión muere: `silent` sólo calla
+     * el evento `disconnected` local, y `destroy` decide si el engine se vacía o conserva
+     * chats, mensajes y contactos para estudiarlos después. Las credenciales se borran en los
+     * dos casos: el dispositivo ya no existe, así que reconectar con ellas sólo devolvería un
+     * `loggedOut`.
+     *
+     * Closes the session for real: unlinks the device from the phone and ends the socket. The
+     * promise does not settle until all of that happened.
+     *
+     * Both flags modulate side effects, never whether the session dies: `silent` only mutes the
+     * local `disconnected` event, and `destroy` decides whether the engine is wiped or keeps
+     * chats, messages and contacts for later study. Credentials go in both cases: the device no
+     * longer exists, so reconnecting with them would only return a `loggedOut`.
+     *
+     * @param options - `silent` calla el evento; `destroy` vacía el engine entero / `silent` mutes the event; `destroy` wipes the whole engine
      *
-     * @param options - `silent` calla el evento `disconnected`; `destroy` vacía el engine / `silent` mutes the `disconnected` event; `destroy` clears the engine
+     * @example
+     * await wa.disconnect();                     // desvincula y conserva el historial
+     * await wa.disconnect({ destroy: true });    // desvincula y no queda nada
      */
     disconnect(options?: {
         silent?: boolean;