@badzz88/baileys 8.5.4 → 8.5.6

package/src/Utils/history.js

@@ -0,0 +1,232 @@
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
+exports.getHistoryMsg =
+    exports.downloadAndProcessHistorySyncNotification =
+        exports.processHistoryMessage =
+            exports.downloadHistory =
+                void 0;
+const util_1 = require('util');
+const zlib_1 = require('zlib');
+const index_js_1 = require('../../WAProto/index.js');
+const Types_1 = require('../Types');
+const WABinary_1 = require('../WABinary');
+const generics_1 = require('./generics');
+const messages_1 = require('./messages');
+const messages_media_1 = require('./messages-media');
+const inflatePromise = (0, util_1.promisify)(zlib_1.inflate);
+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 && ((0, WABinary_1.isPnUser)(userJid) || (0, WABinary_1.isHostedPnUser)(userJid))) {
+            return userJid;
+        }
+    }
+    return undefined;
+};
+const downloadHistory = async (msg, options) => {
+    const stream = await (0, messages_media_1.downloadContentFromMessage)(msg, 'md-msg-hist', { options });
+    const bufferArray = [];
+    for await (const chunk of stream) {
+        bufferArray.push(chunk);
+    }
+    let buffer = Buffer.concat(bufferArray);
+    buffer = await inflatePromise(buffer);
+    const syncData = index_js_1.proto.HistorySync.decode(buffer);
+    return syncData;
+};
+exports.downloadHistory = downloadHistory;
+const processHistoryMessage = (item, logger) => {
+    const messages = [];
+    const contacts = [];
+    const chats = [];
+    const lidPnMappings = [];
+    const callLogRecords = [];
+    const pastParticipants = [];
+    const recentStickers = [];
+    let globalSettings = undefined;
+    let statusV3Messages = undefined;
+    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 });
+        }
+    }
+    for (const c of item.inlineContacts || []) {
+        if (c.lidJid && c.pnJid) {
+            lidPnMappings.push({ lid: c.lidJid, pn: c.pnJid });
+        }
+        if (c.pnJid) {
+            contacts.push({
+                id: c.pnJid,
+                name: c.fullName || c.firstName || c.username || undefined,
+                notify: c.pushname || undefined,
+                username: c.username || undefined,
+                shortName: c.shortName || undefined,
+                verifiedName: c.verifiedBizName || undefined,
+                businessName: c.verifiedBizName || undefined,
+                lid: c.lidJid || undefined
+            });
+        }
+    }
+    for (const rec of item.callLogRecords || []) {
+        callLogRecords.push({
+            ...rec,
+            callType: rec.callType,
+            duration: rec.duration ? (0, generics_1.toNumber)(rec.duration) : undefined,
+            isVideo: rec.isVideo,
+            callInitiator: rec.callInitiatorJid,
+            callEndReason: rec.callResult,
+            timestamp: rec.startTime ? (0, generics_1.toNumber)(rec.startTime) : undefined
+        });
+    }
+    const stickerKeys = new Set();
+    for (const s of item.recentStickers || []) {
+        const stickerKey = s.fileSha256 ? Buffer.from(s.fileSha256).toString('base64') : undefined;
+        if (!stickerKey || !stickerKeys.has(stickerKey)) {
+            if (stickerKey)
+                stickerKeys.add(stickerKey);
+            recentStickers.push(s);
+        }
+    }
+    switch (item.syncType) {
+        case index_js_1.proto.HistorySync.HistorySyncType.INITIAL_BOOTSTRAP:
+        case index_js_1.proto.HistorySync.HistorySyncType.RECENT:
+        case index_js_1.proto.HistorySync.HistorySyncType.FULL:
+        case index_js_1.proto.HistorySync.HistorySyncType.ON_DEMAND:
+            if (item.globalSettings) {
+                const gs = item.globalSettings;
+                globalSettings = {
+                    ...gs,
+                    autoDownloadSettings: {
+                        photos: gs.autoDownloadPhotos,
+                        audio: gs.autoDownloadAudio,
+                        documents: gs.autoDownloadDocuments,
+                        videos: gs.autoDownloadVideos
+                    },
+                    disappearingMode: gs.disappearingMode
+                        ? {
+                            duration: gs.disappearingMode.duration
+                                ? (0, generics_1.toNumber)(gs.disappearingMode.duration)
+                                : undefined,
+                            isDefaultDisappearingMode: gs.disappearingMode.isDefaultDisappearingMode ?? false
+                        }
+                        : undefined,
+                    archiveChats: gs.archiveChats,
+                    wallpaper: gs.wallpaper,
+                    mediaEncryptionBackupEnabled: gs.mediaEncryptionBackupEnabled,
+                    lightWeightContactsEnabled: gs.lightWeightContactsEnabled,
+                    privacySettings: gs.privacy
+                        ? {
+                            readReceipts: gs.privacy.readreceipts,
+                            lastSeen: gs.privacy.lastseen,
+                            status: gs.privacy.status,
+                            profile: gs.privacy.profile,
+                            groupsAddPrivacy: gs.privacy.groupadd,
+                            callPrivacy: gs.privacy.calladd
+                        }
+                        : undefined
+                };
+            }
+            if (item.statusV3Messages?.length) {
+                const now = Math.floor(Date.now() / 1000);
+                statusV3Messages = item.statusV3Messages.filter(s => {
+                    const ts = s.message?.messageTimestamp;
+                    if (!ts)
+                        return true;
+                    const timestamp = (0, generics_1.toNumber)(ts);
+                    return timestamp + 24 * 60 * 60 > now;
+                });
+            }
+            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 = (0, WABinary_1.isLidUser)(chatId) || (0, WABinary_1.isHostedLidUser)(chatId);
+                const isPn = (0, WABinary_1.isPnUser)(chatId) || (0, WABinary_1.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 = (0, generics_1.toNumber)(message.messageTimestamp);
+                    }
+                    if ((message.messageStubType === Types_1.WAMessageStubType.BIZ_PRIVACY_MODE_TO_BSP ||
+                        message.messageStubType === Types_1.WAMessageStubType.BIZ_PRIVACY_MODE_TO_FB) &&
+                        message.messageStubParameters?.[0]) {
+                        contacts.push({
+                            id: message.key.participant || message.key.remoteJid,
+                            verifiedName: message.messageStubParameters?.[0]
+                        });
+                    }
+                }
+                if (chat.id && (0, WABinary_1.isJidGroup)(chat.id)) {
+                }
+                chats.push({ ...chat });
+            }
+            for (const pp of item.pastParticipants || []) {
+                pastParticipants.push(pp);
+            }
+            break;
+        case index_js_1.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,
+        syncType: item.syncType,
+        progress: item.progress,
+        globalSettings,
+        callLogRecords,
+        recentStickers,
+        pastParticipants,
+        statusV3Messages
+    };
+};
+exports.processHistoryMessage = processHistoryMessage;
+const downloadAndProcessHistorySyncNotification = async (msg, options, logger) => {
+    let historyMsg;
+    if (msg.initialHistBootstrapInlinePayload) {
+        historyMsg = index_js_1.proto.HistorySync.decode(await inflatePromise(msg.initialHistBootstrapInlinePayload));
+    }
+    else {
+        historyMsg = await (0, exports.downloadHistory)(msg, options);
+    }
+    return (0, exports.processHistoryMessage)(historyMsg, logger);
+};
+exports.downloadAndProcessHistorySyncNotification = downloadAndProcessHistorySyncNotification;
+const getHistoryMsg = message => {
+    const normalizedContent = !!message ? (0, messages_1.normalizeMessageContent)(message) : undefined;
+    const anyHistoryMsg = normalizedContent?.protocolMessage?.historySyncNotification;
+    return anyHistoryMsg;
+};
+exports.getHistoryMsg = getHistoryMsg;

package/src/Utils/identity-change-handler.js

@@ -0,0 +1,52 @@
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
+exports.handleIdentityChange = handleIdentityChange;
+const WABinary_1 = require('../WABinary');
+const generics_1 = require('./generics');
+async function handleIdentityChange(node, ctx) {
+    const from = node.attrs.from;
+    if (!from) {
+        return { action: 'invalid_notification' };
+    }
+    const identityNode = (0, WABinary_1.getBinaryNodeChild)(node, 'identity');
+    if (!identityNode) {
+        return { action: 'no_identity_node' };
+    }
+    ctx.logger.info({ jid: from }, 'identity changed');
+    const decoded = (0, WABinary_1.jidDecode)(from);
+    if (decoded?.device && decoded.device !== 0) {
+        ctx.logger.debug({ jid: from, device: decoded.device }, 'ignoring identity change from companion device');
+        return { action: 'skipped_companion_device', device: decoded.device };
+    }
+    const isSelfPrimary = ctx.meId &&
+        ((0, WABinary_1.areJidsSameUser)(from, ctx.meId) || (ctx.meLid && (0, WABinary_1.areJidsSameUser)(from, ctx.meLid)));
+    if (isSelfPrimary) {
+        ctx.logger.info({ jid: from }, 'self primary identity changed');
+        return { action: 'skipped_self_primary' };
+    }
+    if (ctx.debounceCache.get(from)) {
+        ctx.logger.debug({ jid: from }, 'skipping identity assert (debounced)');
+        return { action: 'debounced' };
+    }
+    ctx.debounceCache.set(from, true);
+    const isOfflineNotification = !(0, generics_1.isStringNullOrEmpty)(node.attrs.offline);
+    const hasExistingSession = await ctx.validateSession(from);
+    if (!hasExistingSession.exists) {
+        ctx.logger.debug({ jid: from }, 'no old session, skipping session refresh');
+        return { action: 'skipped_no_session' };
+    }
+    ctx.logger.debug({ jid: from }, 'old session exists, will refresh session');
+    if (isOfflineNotification) {
+        ctx.logger.debug({ jid: from }, 'skipping session refresh during offline processing');
+        return { action: 'skipped_offline' };
+    }
+    ctx.onBeforeSessionRefresh?.(from);
+    try {
+        await ctx.assertSessions([from], true);
+        return { action: 'session_refreshed' };
+    }
+    catch (error) {
+        ctx.logger.warn({ error, jid: from }, 'failed to assert sessions after identity change');
+        return { action: 'session_refresh_failed', error };
+    }
+}

package/src/Utils/index.js

@@ -0,0 +1,58 @@
+'use strict';
+var __createBinding = (this && this.__createBinding) ||
+    (Object.create
+        ? function (o, m, k, k2) {
+            if (k2 === undefined)
+                k2 = k;
+            var desc = Object.getOwnPropertyDescriptor(m, k);
+            if (!desc || ('get' in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+                desc = {
+                    enumerable: true,
+                    get: function () {
+                        return m[k];
+                    }
+                };
+            }
+            Object.defineProperty(o, k2, desc);
+        }
+        : function (o, m, k, k2) {
+            if (k2 === undefined)
+                k2 = k;
+            o[k2] = m[k];
+        });
+var __exportStar = (this && this.__exportStar) ||
+    function (m, exports) {
+        for (var p in m)
+            if (p !== 'default' && !Object.prototype.hasOwnProperty.call(exports, p))
+                __createBinding(exports, m, p);
+    };
+Object.defineProperty(exports, '__esModule', { value: true });
+__exportStar(require('./generics'), exports);
+__exportStar(require('./decode-wa-message'), exports);
+__exportStar(require('./messages'), exports);
+__exportStar(require('./messages-media'), exports);
+__exportStar(require('./validate-connection'), exports);
+__exportStar(require('./crypto'), exports);
+__exportStar(require('./signal'), exports);
+__exportStar(require('./noise-handler'), exports);
+__exportStar(require('./history'), exports);
+__exportStar(require('./chat-utils'), exports);
+__exportStar(require('./lt-hash'), exports);
+__exportStar(require('./auth-utils'), exports);
+__exportStar(require('./use-multi-file-auth-state'), exports);
+__exportStar(require('./link-preview'), exports);
+__exportStar(require('./event-buffer'), exports);
+__exportStar(require('./process-message'), exports);
+__exportStar(require('./message-retry-manager'), exports);
+__exportStar(require('./browser-utils'), exports);
+__exportStar(require('./identity-change-handler'), exports);
+__exportStar(require('./stanza-ack'), exports);
+__exportStar(require('./message-composer'), exports);
+__exportStar(require('./group-history'), exports);
+__exportStar(require('./consumer-application'), exports);
+__exportStar(require('./voip-rekey'), exports);
+__exportStar(require('./companion-reg-client-utils'), exports);
+__exportStar(require('./view-once-cache'), exports);
+__exportStar(require('./sticker'), exports);
+__exportStar(require('./command-loader'), exports);
+__exportStar(require('./session-pool'), exports);

package/src/Utils/jid-display-normalization.js

@@ -0,0 +1,195 @@
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
+exports.normalizeMessageForDisplayJids = void 0;
+exports.normalizeMentionedJidsForSend = void 0;
+const WABinary_1 = require('../WABinary');
+const createLidPnDebug = logger => {
+    const enabled = process.env.LID_PN_DEBUG === '1' || process.env.LID_PN_DEBUG === 'true';
+    return (phase, payload) => {
+        if (!enabled) {
+            return;
+        }
+        logger?.debug({ ...payload, phase }, 'lid->pn normalization trace');
+    };
+};
+const fallbackPnFromLidJid = jid => {
+    const decoded = (0, WABinary_1.jidDecode)(jid);
+    const rawUser = decoded?.user || (typeof jid === 'string' ? jid.split('@')[0] : '');
+    const user = rawUser.split(':')[0];
+    if (!user) {
+        return jid;
+    }
+    return `${user}@s.whatsapp.net`;
+};
+const toDisplayPnJid = jid => {
+    if (!jid || typeof jid !== 'string') {
+        return jid;
+    }
+    const decoded = (0, WABinary_1.jidDecode)(jid);
+    if (!decoded?.user) {
+        return jid;
+    }
+    if (!(0, WABinary_1.isPnUser)(jid) && !(0, WABinary_1.isHostedPnUser)(jid)) {
+        return jid;
+    }
+    const user = decoded.user.split(':')[0];
+    if (!user) {
+        return jid;
+    }
+    const server = decoded.server === 'hosted' ? 'hosted' : 's.whatsapp.net';
+    return `${user}@${server}`;
+};
+const buildLidPnHints = key => {
+    const hints = new Map();
+    if (!key) {
+        return hints;
+    }
+    const addHint = (lid, pn) => {
+        if (!(0, WABinary_1.isLidUser)(lid) && !(0, WABinary_1.isHostedLidUser)(lid)) {
+            return;
+        }
+        if (!(0, WABinary_1.isPnUser)(pn) && !(0, WABinary_1.isHostedPnUser)(pn)) {
+            return;
+        }
+        hints.set(lid, pn);
+        const lidDecoded = (0, WABinary_1.jidDecode)(lid);
+        const pnDecoded = (0, WABinary_1.jidDecode)(pn);
+        if (lidDecoded?.user && pnDecoded?.user) {
+            hints.set(`${lidDecoded.user}@lid`, `${pnDecoded.user}@s.whatsapp.net`);
+        }
+    };
+    addHint(key.participant, key.participantAlt);
+    addHint(key.remoteJid, key.remoteJidAlt);
+    addHint(key.participantAlt, key.participant);
+    addHint(key.remoteJidAlt, key.remoteJid);
+    return hints;
+};
+const mergeGroupDataHints = (hints, groupData, debug) => {
+    if (!groupData?.participants?.length) {
+        return;
+    }
+    debug?.('groupData-size', { participants: groupData.participants.length });
+    for (const participant of groupData.participants) {
+        const lidCandidate = participant?.lid;
+        const idCandidate = participant?.id;
+        const pnCandidate = participant?.phoneNumber;
+        const lid = ((0, WABinary_1.isLidUser)(lidCandidate) || (0, WABinary_1.isHostedLidUser)(lidCandidate)
+            ? lidCandidate
+            : undefined) ||
+            ((0, WABinary_1.isLidUser)(idCandidate) || (0, WABinary_1.isHostedLidUser)(idCandidate) ? idCandidate : undefined);
+        const pn = ((0, WABinary_1.isPnUser)(pnCandidate) || (0, WABinary_1.isHostedPnUser)(pnCandidate)
+            ? pnCandidate
+            : undefined) ||
+            ((0, WABinary_1.isPnUser)(idCandidate) || (0, WABinary_1.isHostedPnUser)(idCandidate) ? idCandidate : undefined);
+        if (!lid || !pn) {
+            continue;
+        }
+        if (((0, WABinary_1.isLidUser)(lid) || (0, WABinary_1.isHostedLidUser)(lid)) &&
+            ((0, WABinary_1.isPnUser)(pn) || (0, WABinary_1.isHostedPnUser)(pn))) {
+            const displayPn = toDisplayPnJid(pn);
+            hints.set(lid, displayPn);
+            const lidDecoded = (0, WABinary_1.jidDecode)(lid);
+            if (lidDecoded?.user) {
+                hints.set(`${lidDecoded.user}@lid`, displayPn);
+            }
+            debug?.('group-hint', { lid, pn: displayPn });
+        }
+    }
+};
+const normalizeToPnJid = async (jid, hints, signalRepository, debug) => {
+    if (!jid || typeof jid !== 'string') {
+        return jid;
+    }
+    if (!(0, WABinary_1.isLidUser)(jid) && !(0, WABinary_1.isHostedLidUser)(jid)) {
+        return jid;
+    }
+    debug?.('input', { lid: jid });
+    const hinted = hints.get(jid);
+    if (hinted) {
+        const normalized = toDisplayPnJid(hinted);
+        debug?.('hint-exact', { lid: jid, hinted, normalized });
+        return normalized;
+    }
+    const decoded = (0, WABinary_1.jidDecode)(jid);
+    if (decoded?.user) {
+        const userHint = hints.get(`${decoded.user}@lid`);
+        if (userHint) {
+            const normalized = toDisplayPnJid(userHint);
+            debug?.('hint-user', { lid: jid, userHint, normalized });
+            return normalized;
+        }
+    }
+    const mapped = await signalRepository?.lidMapping?.getPNForLID?.(jid);
+    if (mapped) {
+        const normalized = toDisplayPnJid(mapped);
+        debug?.('mapping', { lid: jid, mapped, normalized });
+        return normalized;
+    }
+    const fallback = fallbackPnFromLidJid(jid);
+    debug?.('fallback', { lid: jid, fallback });
+    return fallback;
+};
+const normalizeMentionedJidsToPn = async (node, hints, signalRepository, debug) => {
+    if (!node || typeof node !== 'object') {
+        return;
+    }
+    if (Array.isArray(node)) {
+        for (const item of node) {
+            await normalizeMentionedJidsToPn(item, hints, signalRepository, debug);
+        }
+        return;
+    }
+    if (Array.isArray(node.mentionedJid)) {
+        const before = [...node.mentionedJid];
+        node.mentionedJid = await Promise.all(node.mentionedJid.map(jid => normalizeToPnJid(jid, hints, signalRepository, debug)));
+        debug?.('mentions', { before, after: node.mentionedJid });
+    }
+    if (typeof node.participant === 'string') {
+        const before = node.participant;
+        node.participant = await normalizeToPnJid(node.participant, hints, signalRepository, debug);
+        if (before !== node.participant) {
+            debug?.('participant-field', { before, after: node.participant });
+        }
+    }
+    if (typeof node.remoteJid === 'string') {
+        const before = node.remoteJid;
+        node.remoteJid = await normalizeToPnJid(node.remoteJid, hints, signalRepository, debug);
+        if (before !== node.remoteJid) {
+            debug?.('remoteJid-field', { before, after: node.remoteJid });
+        }
+    }
+    for (const value of Object.values(node)) {
+        if (value && typeof value === 'object') {
+            await normalizeMentionedJidsToPn(value, hints, signalRepository, debug);
+        }
+    }
+};
+const normalizeMentionedJidsForSend = async (mentions, groupData, signalRepository, logger) => {
+    if (!Array.isArray(mentions)) {
+        return mentions;
+    }
+    const debug = createLidPnDebug(logger);
+    const hints = new Map();
+    mergeGroupDataHints(hints, groupData, debug);
+    const normalized = await Promise.all(mentions.map(jid => normalizeToPnJid(jid, hints, signalRepository, debug)));
+    debug('send-mentions-result', { before: mentions, after: normalized });
+    return normalized;
+};
+const normalizeMessageForDisplayJids = async (messageInfo, signalRepository, logger, groupData) => {
+    if (!messageInfo?.key) {
+        return messageInfo;
+    }
+    const debug = createLidPnDebug(logger);
+    const hints = buildLidPnHints(messageInfo.key);
+    mergeGroupDataHints(hints, groupData, debug);
+    const beforeKey = { ...messageInfo.key };
+    messageInfo.key.participant = await normalizeToPnJid(messageInfo.key.participant, hints, signalRepository, debug);
+    messageInfo.key.participantAlt = await normalizeToPnJid(messageInfo.key.participantAlt, hints, signalRepository, debug);
+    messageInfo.key.remoteJid = await normalizeToPnJid(messageInfo.key.remoteJid, hints, signalRepository, debug);
+    messageInfo.key.remoteJidAlt = await normalizeToPnJid(messageInfo.key.remoteJidAlt, hints, signalRepository, debug);
+    await normalizeMentionedJidsToPn(messageInfo.message, hints, signalRepository, debug);
+    debug('display-key-result', { before: beforeKey, after: messageInfo.key });
+    return messageInfo;
+};
+exports.normalizeMessageForDisplayJids = normalizeMessageForDisplayJids;
+exports.normalizeMentionedJidsForSend = normalizeMentionedJidsForSend;

package/src/Utils/link-preview.js

@@ -0,0 +1,135 @@
+'use strict';
+var __createBinding = (this && this.__createBinding) ||
+    (Object.create
+        ? function (o, m, k, k2) {
+            if (k2 === undefined)
+                k2 = k;
+            var desc = Object.getOwnPropertyDescriptor(m, k);
+            if (!desc || ('get' in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+                desc = {
+                    enumerable: true,
+                    get: function () {
+                        return m[k];
+                    }
+                };
+            }
+            Object.defineProperty(o, k2, desc);
+        }
+        : function (o, m, k, k2) {
+            if (k2 === undefined)
+                k2 = k;
+            o[k2] = m[k];
+        });
+var __setModuleDefault = (this && this.__setModuleDefault) ||
+    (Object.create
+        ? function (o, v) {
+            Object.defineProperty(o, 'default', { enumerable: true, value: v });
+        }
+        : function (o, v) {
+            o['default'] = v;
+        });
+var __importStar = (this && this.__importStar) ||
+    (function () {
+        var ownKeys = function (o) {
+            ownKeys =
+                Object.getOwnPropertyNames ||
+                    function (o) {
+                        var ar = [];
+                        for (var k in o)
+                            if (Object.prototype.hasOwnProperty.call(o, k))
+                                ar[ar.length] = k;
+                        return ar;
+                    };
+            return ownKeys(o);
+        };
+        return function (mod) {
+            if (mod && mod.__esModule)
+                return mod;
+            var result = {};
+            if (mod != null)
+                for (var k = ownKeys(mod), i = 0; i < k.length; i++)
+                    if (k[i] !== 'default')
+                        __createBinding(result, mod, k[i]);
+            __setModuleDefault(result, mod);
+            return result;
+        };
+    })();
+Object.defineProperty(exports, '__esModule', { value: true });
+exports.getUrlInfo = void 0;
+const messages_1 = require('./messages');
+const messages_media_1 = require('./messages-media');
+const THUMBNAIL_WIDTH_PX = 192;
+const getCompressedJpegThumbnail = async (url, { thumbnailWidth, fetchOpts }) => {
+    const stream = await (0, messages_media_1.getHttpStream)(url, fetchOpts);
+    const result = await (0, messages_media_1.extractImageThumb)(stream, thumbnailWidth);
+    return result;
+};
+const getUrlInfo = async (text, opts = {
+    thumbnailWidth: THUMBNAIL_WIDTH_PX,
+    fetchOpts: { timeout: 3000 }
+}) => {
+    try {
+        const retries = 0;
+        const maxRetry = 5;
+        const { getLinkPreview } = await Promise.resolve().then(() => __importStar(require('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;
+                }
+                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 (0, messages_1.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;
+        }
+    }
+    catch (error) {
+        if (!error.message.includes('receive a valid')) {
+            throw error;
+        }
+    }
+};
+exports.getUrlInfo = getUrlInfo;

package/src/Utils/logger.js

@@ -0,0 +1,8 @@
+'use strict';
+var __importDefault = (this && this.__importDefault) ||
+    function (mod) {
+        return mod && mod.__esModule ? mod : { default: mod };
+    };
+Object.defineProperty(exports, '__esModule', { value: true });
+const pino_1 = __importDefault(require('pino'));
+exports.default = (0, pino_1.default)({ timestamp: () => `,"time":"${new Date().toJSON()}"` });