@mrlegendbot/baileys 1.2.3 → 1.2.5

package/lib/Utils/history.js

@@ -1,134 +1,142 @@
 import { pipeline } from 'stream/promises';
 import { promisify } from 'util';
 import { createInflate, inflate } from 'zlib';
-import { proto } from '../../WAProto/index.js';
+import { proto } from '../../WAProto/compiler.js';
 import { WAMessageStubType } from '../Types/index.js';
 import { isHostedLidUser, isHostedPnUser, isLidUser, isPnUser } from '../WABinary/index.js';
 import { toNumber } from './generics.js';
 import { normalizeMessageContent } from './messages.js';
 import { downloadContentFromMessage } from './messages-media.js';
 const inflatePromise = promisify(inflate);
-const extractPnFromMessages = (messages) => {
-    for (const msgItem of messages) {
-        const message = msgItem.message;
-        // Only extract from outgoing messages (fromMe: true) in 1:1 chats
-        // because userReceipt.userJid is the recipient's JID
-        if (!message?.key?.fromMe || !message.userReceipt?.length) {
-            continue;
-        }
-        const userJid = message.userReceipt[0]?.userJid;
-        if (userJid && (isPnUser(userJid) || isHostedPnUser(userJid))) {
-            return userJid;
-        }
+const extractPnFromMessages = messages => {
+  for (const msgItem of messages) {
+    const message = msgItem.message;
+    if (!message?.key?.fromMe || !message.userReceipt?.length) {
+      continue;
+    }
+    const userJid = message.userReceipt[0]?.userJid;
+    if (userJid && (isPnUser(userJid) || isHostedPnUser(userJid))) {
+      return userJid;
     }
-    return undefined;
+  }
+  return undefined;
 };
 export const downloadHistory = async (msg, options) => {
-    const stream = await downloadContentFromMessage(msg, 'md-msg-hist', { options });
-    // Pipe decrypted stream directly through zlib inflate
-    // This avoids allocating an intermediate buffer for the compressed data
-    const inflater = createInflate();
-    const chunks = [];
-    inflater.on('data', (chunk) => chunks.push(chunk));
-    await pipeline(stream, inflater);
-    const buffer = Buffer.concat(chunks);
-    const syncData = proto.HistorySync.decode(buffer);
-    return syncData;
+  const stream = await downloadContentFromMessage(msg, 'md-msg-hist', {
+    options
+  });
+  const inflater = createInflate();
+  const chunks = [];
+  inflater.on('data', chunk => chunks.push(chunk));
+  await pipeline(stream, inflater);
+  const buffer = Buffer.concat(chunks);
+  const syncData = proto.HistorySync.decode(buffer);
+  return syncData;
 };
 export const processHistoryMessage = (item, logger) => {
-    const messages = [];
-    const contacts = [];
-    const chats = [];
-    const lidPnMappings = [];
-    logger?.trace({ progress: item.progress }, 'processing history of type ' + item.syncType?.toString());
-    // Extract LID-PN mappings for all sync types
-    for (const m of item.phoneNumberToLidMappings || []) {
-        if (m.lidJid && m.pnJid) {
-            lidPnMappings.push({ lid: m.lidJid, pn: m.pnJid });
-        }
-    }
-    switch (item.syncType) {
-        case proto.HistorySync.HistorySyncType.INITIAL_BOOTSTRAP:
-        case proto.HistorySync.HistorySyncType.RECENT:
-        case proto.HistorySync.HistorySyncType.FULL:
-        case proto.HistorySync.HistorySyncType.ON_DEMAND:
-            for (const chat of item.conversations) {
-                contacts.push({
-                    id: chat.id,
-                    name: chat.displayName || chat.name || chat.username || undefined,
-                    username: chat.username || undefined,
-                    lid: chat.lidJid || chat.accountLid || undefined,
-                    phoneNumber: chat.pnJid || undefined
-                });
-                const chatId = chat.id;
-                const isLid = isLidUser(chatId) || isHostedLidUser(chatId);
-                const isPn = isPnUser(chatId) || isHostedPnUser(chatId);
-                if (isLid && chat.pnJid) {
-                    lidPnMappings.push({ lid: chatId, pn: chat.pnJid });
-                }
-                else if (isPn && chat.lidJid) {
-                    lidPnMappings.push({ lid: chat.lidJid, pn: chatId });
-                }
-                else if (isLid && !chat.pnJid) {
-                    // Fallback: extract PN from userReceipt in messages when pnJid is missing
-                    const pnFromReceipt = extractPnFromMessages(chat.messages || []);
-                    if (pnFromReceipt) {
-                        lidPnMappings.push({ lid: chatId, pn: pnFromReceipt });
-                    }
-                }
-                const msgs = chat.messages || [];
-                delete chat.messages;
-                for (const item of msgs) {
-                    const message = item.message;
-                    messages.push(message);
-                    if (!chat.messages?.length) {
-                        // keep only the most recent message in the chat array
-                        chat.messages = [{ message }];
-                    }
-                    if (!message.key.fromMe && !chat.lastMessageRecvTimestamp) {
-                        chat.lastMessageRecvTimestamp = toNumber(message.messageTimestamp);
-                    }
-                    if ((message.messageStubType === WAMessageStubType.BIZ_PRIVACY_MODE_TO_BSP ||
-                        message.messageStubType === WAMessageStubType.BIZ_PRIVACY_MODE_TO_FB) &&
-                        message.messageStubParameters?.[0]) {
-                        contacts.push({
-                            id: message.key.participant || message.key.remoteJid,
-                            verifiedName: message.messageStubParameters?.[0]
-                        });
-                    }
-                }
-                chats.push(chat);
-            }
-            break;
-        case proto.HistorySync.HistorySyncType.PUSH_NAME:
-            for (const c of item.pushnames) {
-                contacts.push({ id: c.id, notify: c.pushname });
-            }
-            break;
+  const messages = [];
+  const contacts = [];
+  const chats = [];
+  const lidPnMappings = [];
+  logger?.trace({
+    progress: item.progress
+  }, 'processing history of type ' + item.syncType?.toString());
+  for (const m of item.phoneNumberToLidMappings || []) {
+    if (m.lidJid && m.pnJid) {
+      lidPnMappings.push({
+        lid: m.lidJid,
+        pn: m.pnJid
+      });
     }
-    return {
-        chats,
-        contacts,
-        messages,
-        lidPnMappings,
-        pastParticipants: item.pastParticipants,
-        syncType: item.syncType,
-        progress: item.progress
-    };
+  }
+  switch (item.syncType) {
+    case proto.HistorySync.HistorySyncType.INITIAL_BOOTSTRAP:
+    case proto.HistorySync.HistorySyncType.RECENT:
+    case proto.HistorySync.HistorySyncType.FULL:
+    case proto.HistorySync.HistorySyncType.ON_DEMAND:
+      for (const chat of item.conversations) {
+        contacts.push({
+          id: chat.id,
+          name: chat.displayName || chat.name || chat.username || undefined,
+          username: chat.username || undefined,
+          lid: chat.lidJid || chat.accountLid || undefined,
+          phoneNumber: chat.pnJid || undefined
+        });
+        const chatId = chat.id;
+        const isLid = isLidUser(chatId) || isHostedLidUser(chatId);
+        const isPn = isPnUser(chatId) || isHostedPnUser(chatId);
+        if (isLid && chat.pnJid) {
+          lidPnMappings.push({
+            lid: chatId,
+            pn: chat.pnJid
+          });
+        } else if (isPn && chat.lidJid) {
+          lidPnMappings.push({
+            lid: chat.lidJid,
+            pn: chatId
+          });
+        } else if (isLid && !chat.pnJid) {
+          const pnFromReceipt = extractPnFromMessages(chat.messages || []);
+          if (pnFromReceipt) {
+            lidPnMappings.push({
+              lid: chatId,
+              pn: pnFromReceipt
+            });
+          }
+        }
+        const msgs = chat.messages || [];
+        delete chat.messages;
+        for (const item of msgs) {
+          const message = item.message;
+          messages.push(message);
+          if (!chat.messages?.length) {
+            chat.messages = [{
+              message
+            }];
+          }
+          if (!message.key.fromMe && !chat.lastMessageRecvTimestamp) {
+            chat.lastMessageRecvTimestamp = toNumber(message.messageTimestamp);
+          }
+          if ((message.messageStubType === WAMessageStubType.BIZ_PRIVACY_MODE_TO_BSP || message.messageStubType === WAMessageStubType.BIZ_PRIVACY_MODE_TO_FB) && message.messageStubParameters?.[0]) {
+            contacts.push({
+              id: message.key.participant || message.key.remoteJid,
+              verifiedName: message.messageStubParameters?.[0]
+            });
+          }
+        }
+        chats.push(chat);
+      }
+      break;
+    case proto.HistorySync.HistorySyncType.PUSH_NAME:
+      for (const c of item.pushnames) {
+        contacts.push({
+          id: c.id,
+          notify: c.pushname
+        });
+      }
+      break;
+  }
+  return {
+    chats,
+    contacts,
+    messages,
+    lidPnMappings,
+    pastParticipants: item.pastParticipants,
+    syncType: item.syncType,
+    progress: item.progress
+  };
 };
 export const downloadAndProcessHistorySyncNotification = async (msg, options, logger) => {
-    let historyMsg;
-    if (msg.initialHistBootstrapInlinePayload) {
-        historyMsg = proto.HistorySync.decode(await inflatePromise(msg.initialHistBootstrapInlinePayload));
-    }
-    else {
-        historyMsg = await downloadHistory(msg, options);
-    }
-    return processHistoryMessage(historyMsg, logger);
+  let historyMsg;
+  if (msg.initialHistBootstrapInlinePayload) {
+    historyMsg = proto.HistorySync.decode(await inflatePromise(msg.initialHistBootstrapInlinePayload));
+  } else {
+    historyMsg = await downloadHistory(msg, options);
+  }
+  return processHistoryMessage(historyMsg, logger);
 };
-export const getHistoryMsg = (message) => {
-    const normalizedContent = !!message ? normalizeMessageContent(message) : undefined;
-    const anyHistoryMsg = normalizedContent?.protocolMessage?.historySyncNotification;
-    return anyHistoryMsg;
+export const getHistoryMsg = message => {
+  const normalizedContent = !!message ? normalizeMessageContent(message) : undefined;
+  const anyHistoryMsg = normalizedContent?.protocolMessage?.historySyncNotification;
+  return anyHistoryMsg;
 };
-//# sourceMappingURL=history.js.map

package/lib/Utils/index.js

@@ -17,6 +17,5 @@ export * from './process-message.js';
 export * from './message-retry-manager.js';
 export * from './browser-utils.js';
 export * from './companion-reg-client-utils.js';
-export * from './identity-change-handler.js';
 export * from './stanza-ack.js';
-//# sourceMappingURL=index.js.map
+export * from './use-sqlite-auth-state.js';

package/lib/Utils/link-preview.js

@@ -1,85 +1,86 @@
 import { prepareWAMessageMedia } from './messages.js';
 import { extractImageThumb, getHttpStream } from './messages-media.js';
 const THUMBNAIL_WIDTH_PX = 192;
-/** Fetches an image and generates a thumbnail for it */
-const getCompressedJpegThumbnail = async (url, { thumbnailWidth, fetchOpts }) => {
-    const stream = await getHttpStream(url, fetchOpts);
-    const result = await extractImageThumb(stream, thumbnailWidth);
-    return result;
+const getCompressedJpegThumbnail = async (url, {
+  thumbnailWidth,
+  fetchOpts
+}) => {
+  const stream = await getHttpStream(url, fetchOpts);
+  const result = await extractImageThumb(stream, thumbnailWidth);
+  return result;
 };
-/**
- * Given a piece of text, checks for any URL present, generates link preview for the same and returns it
- * Return undefined if the fetch failed or no URL was found
- * @param text first matched URL in text
- * @returns the URL info required to generate link preview
- */
 export const getUrlInfo = async (text, opts = {
-    thumbnailWidth: THUMBNAIL_WIDTH_PX,
-    fetchOpts: { timeout: 3000 }
+  thumbnailWidth: THUMBNAIL_WIDTH_PX,
+  fetchOpts: {
+    timeout: 3000
+  }
 }) => {
-    try {
-        // retries
-        let retries = 0;
-        const maxRetry = 5;
-        const { getLinkPreview } = await import('link-preview-js');
-        let previewLink = text;
-        if (!text.startsWith('https://') && !text.startsWith('http://')) {
-            previewLink = 'https://' + previewLink;
+  try {
+    let retries = 0;
+    const maxRetry = 5;
+    const {
+      getLinkPreview
+    } = await import('link-preview-js');
+    let previewLink = text;
+    if (!text.startsWith('https://') && !text.startsWith('http://')) {
+      previewLink = 'https://' + previewLink;
+    }
+    const info = await getLinkPreview(previewLink, {
+      ...opts.fetchOpts,
+      followRedirects: 'follow',
+      handleRedirects: (baseURL, forwardedURL) => {
+        const urlObj = new URL(baseURL);
+        const forwardedURLObj = new URL(forwardedURL);
+        if (retries >= maxRetry) {
+          return false;
         }
-        const info = await getLinkPreview(previewLink, {
-            ...opts.fetchOpts,
-            followRedirects: 'follow',
-            handleRedirects: (baseURL, forwardedURL) => {
-                const urlObj = new URL(baseURL);
-                const forwardedURLObj = new URL(forwardedURL);
-                if (retries >= maxRetry) {
-                    return false;
-                }
-                if (forwardedURLObj.hostname === urlObj.hostname ||
-                    forwardedURLObj.hostname === 'www.' + urlObj.hostname ||
-                    'www.' + forwardedURLObj.hostname === urlObj.hostname) {
-                    retries += 1;
-                    return true;
-                }
-                else {
-                    return false;
-                }
-            },
-            headers: opts.fetchOpts?.headers
+        if (forwardedURLObj.hostname === urlObj.hostname || forwardedURLObj.hostname === 'www.' + urlObj.hostname || 'www.' + forwardedURLObj.hostname === urlObj.hostname) {
+          retries += 1;
+          return true;
+        } else {
+          return false;
+        }
+      },
+      headers: opts.fetchOpts?.headers
+    });
+    if (info && 'title' in info && info.title) {
+      const [image] = info.images;
+      const urlInfo = {
+        'canonical-url': info.url,
+        'matched-text': text,
+        title: info.title,
+        description: info.description,
+        originalThumbnailUrl: image
+      };
+      if (opts.uploadImage) {
+        const {
+          imageMessage
+        } = await prepareWAMessageMedia({
+          image: {
+            url: image
+          }
+        }, {
+          upload: opts.uploadImage,
+          mediaTypeOverride: 'thumbnail-link',
+          options: opts.fetchOpts
         });
-        if (info && 'title' in info && info.title) {
-            const [image] = info.images;
-            const urlInfo = {
-                'canonical-url': info.url,
-                'matched-text': text,
-                title: info.title,
-                description: info.description,
-                originalThumbnailUrl: image
-            };
-            if (opts.uploadImage) {
-                const { imageMessage } = await prepareWAMessageMedia({ image: { url: image } }, {
-                    upload: opts.uploadImage,
-                    mediaTypeOverride: 'thumbnail-link',
-                    options: opts.fetchOpts
-                });
-                urlInfo.jpegThumbnail = imageMessage?.jpegThumbnail ? Buffer.from(imageMessage.jpegThumbnail) : undefined;
-                urlInfo.highQualityThumbnail = imageMessage || undefined;
-            }
-            else {
-                try {
-                    urlInfo.jpegThumbnail = image ? (await getCompressedJpegThumbnail(image, opts)).buffer : undefined;
-                }
-                catch (error) {
-                    opts.logger?.debug({ err: error.stack, url: previewLink }, 'error in generating thumbnail');
-                }
-            }
-            return urlInfo;
+        urlInfo.jpegThumbnail = imageMessage?.jpegThumbnail ? Buffer.from(imageMessage.jpegThumbnail) : undefined;
+        urlInfo.highQualityThumbnail = imageMessage || undefined;
+      } else {
+        try {
+          urlInfo.jpegThumbnail = image ? (await getCompressedJpegThumbnail(image, opts)).buffer : undefined;
+        } catch (error) {
+          opts.logger?.debug({
+            err: error.stack,
+            url: previewLink
+          }, 'error in generating thumbnail');
         }
+      }
+      return urlInfo;
     }
-    catch (error) {
-        if (!error.message.includes('receive a valid')) {
-            throw error;
-        }
+  } catch (error) {
+    if (!error.message.includes('receive a valid')) {
+      throw error;
     }
+  }
 };
-//# sourceMappingURL=link-preview.js.map

package/lib/Utils/logger.js

@@ -1,3 +1,4 @@
 import P from 'pino';
-export default P({ timestamp: () => `,"time":"${new Date().toJSON()}"` });
-//# sourceMappingURL=logger.js.map
+export default P({
+  timestamp: () => `,"time":"${new Date().toJSON()}"`
+});

package/lib/Utils/lt-hash.js

@@ -1,8 +1,2 @@
 import { LTHashAntiTampering } from 'whatsapp-rust-bridge';
-/**
- * LT Hash is a summation based hash algorithm that maintains the integrity of a piece of data
- * over a series of mutations. You can add/remove mutations and it'll return a hash equal to
- * if the same series of mutations was made sequentially.
- */
 export const LT_HASH_ANTI_TAMPERING = new LTHashAntiTampering();
-//# sourceMappingURL=lt-hash.js.map

package/lib/Utils/make-mutex.js

@@ -1,33 +1,33 @@
 import { Mutex as AsyncMutex } from 'async-mutex';
 export const makeMutex = () => {
-    const mutex = new AsyncMutex();
-    return {
-        mutex(code) {
-            return mutex.runExclusive(code);
-        }
-    };
+  const mutex = new AsyncMutex();
+  return {
+    mutex(code) {
+      return mutex.runExclusive(code);
+    }
+  };
 };
 export const makeKeyedMutex = () => {
-    const map = new Map();
-    return {
-        async mutex(key, task) {
-            let entry = map.get(key);
-            if (!entry) {
-                entry = { mutex: new AsyncMutex(), refCount: 0 };
-                map.set(key, entry);
-            }
-            entry.refCount++;
-            try {
-                return await entry.mutex.runExclusive(task);
-            }
-            finally {
-                entry.refCount--;
-                // only delete it if this is still the current entry
-                if (entry.refCount === 0 && map.get(key) === entry) {
-                    map.delete(key);
-                }
-            }
+  const map = new Map();
+  return {
+    async mutex(key, task) {
+      let entry = map.get(key);
+      if (!entry) {
+        entry = {
+          mutex: new AsyncMutex(),
+          refCount: 0
+        };
+        map.set(key, entry);
+      }
+      entry.refCount++;
+      try {
+        return await entry.mutex.runExclusive(task);
+      } finally {
+        entry.refCount--;
+        if (entry.refCount === 0 && map.get(key) === entry) {
+          map.delete(key);
         }
-    };
+      }
+    }
+  };
 };
-//# sourceMappingURL=make-mutex.js.map