@vanzxysenpai/baileys 0.0.0-stage → 0.0.2

package/lib/Utils/tc-token-utils.js

@@ -0,0 +1,162 @@
+import { getBinaryNodeChild, getBinaryNodeChildren, isHostedLidUser, isHostedPnUser, isJidMetaAI, isLidUser, isPnUser, jidNormalizedUser } from '../WABinary/index.js';
+// Same phone-number pattern as WABinary's isJidBot, applied against the user
+// part so the check is invariant to @c.us ↔ @s.whatsapp.net normalization.
+const BOT_PHONE_REGEX = /^1313555\d{4}$|^131655500\d{2}$/;
+/**
+ * Mirrors WA Web's `Wid.isRegularUser()` (user ∧ ¬PSA ∧ ¬Bot). Used to gate tctoken
+ * storage against malformed notifications — WA Web filters server-side but we
+ * defend here for parity with `WAWebSetTcTokenChatAction.handleIncomingTcToken`.
+ * Works for both pre- and post-normalized JIDs (`@c.us` vs `@s.whatsapp.net`).
+ */
+function isRegularUser(jid) {
+    if (!jid)
+        return false;
+    const user = jid.split('@')[0] ?? '';
+    if (user === '0')
+        return false; // PSA
+    if (BOT_PHONE_REGEX.test(user))
+        return false; // Bot by phone pattern
+    if (isJidMetaAI(jid))
+        return false; // MetaAI (@bot server)
+    return !!(isPnUser(jid) || isLidUser(jid) || isHostedPnUser(jid) || isHostedLidUser(jid) || jid.endsWith('@c.us'));
+}
+const TC_TOKEN_BUCKET_DURATION = 604800; // 7 days
+const TC_TOKEN_NUM_BUCKETS = 4; // ~28-day rolling window
+/** Sentinel key under `tctoken` store holding a JSON array of tracked storage JIDs for cross-session pruning. */
+export const TC_TOKEN_INDEX_KEY = '__index';
+/** Read the persisted tctoken JID index and return its entries (never contains the sentinel key itself). */
+export async function readTcTokenIndex(keys) {
+    const data = await keys.get('tctoken', [TC_TOKEN_INDEX_KEY]);
+    const entry = data[TC_TOKEN_INDEX_KEY];
+    if (!entry?.token?.length)
+        return [];
+    try {
+        const parsed = JSON.parse(Buffer.from(entry.token).toString());
+        if (!Array.isArray(parsed))
+            return [];
+        return parsed.filter((j) => typeof j === 'string' && j.length > 0 && j !== TC_TOKEN_INDEX_KEY);
+    }
+    catch {
+        return [];
+    }
+}
+/** Build a SignalDataSet fragment that writes the merged index (persisted ∪ added) under the sentinel key. */
+export async function buildMergedTcTokenIndexWrite(keys, addedJids) {
+    const persisted = await readTcTokenIndex(keys);
+    const merged = new Set(persisted);
+    for (const jid of addedJids) {
+        if (jid && jid !== TC_TOKEN_INDEX_KEY)
+            merged.add(jid);
+    }
+    return {
+        [TC_TOKEN_INDEX_KEY]: { token: Buffer.from(JSON.stringify([...merged])) }
+    };
+}
+// WA Web has separate sender/receiver AB props for these but they're identical today
+export function isTcTokenExpired(timestamp) {
+    if (timestamp === null || timestamp === undefined)
+        return true;
+    const ts = typeof timestamp === 'string' ? parseInt(timestamp) : timestamp;
+    if (isNaN(ts))
+        return true;
+    const now = Math.floor(Date.now() / 1000);
+    const currentBucket = Math.floor(now / TC_TOKEN_BUCKET_DURATION);
+    const cutoffBucket = currentBucket - (TC_TOKEN_NUM_BUCKETS - 1);
+    const cutoffTimestamp = cutoffBucket * TC_TOKEN_BUCKET_DURATION;
+    return ts < cutoffTimestamp;
+}
+export function shouldSendNewTcToken(senderTimestamp) {
+    if (senderTimestamp === undefined)
+        return true;
+    const now = Math.floor(Date.now() / 1000);
+    const currentBucket = Math.floor(now / TC_TOKEN_BUCKET_DURATION);
+    const senderBucket = Math.floor(senderTimestamp / TC_TOKEN_BUCKET_DURATION);
+    return currentBucket > senderBucket;
+}
+/** Resolve JID to LID for tctoken storage (WA Web stores under LID) */
+export async function resolveTcTokenJid(jid, getLIDForPN) {
+    if (isLidUser(jid))
+        return jid;
+    const lid = await getLIDForPN(jid);
+    return lid ?? jid;
+}
+/** Resolve target JID for issuing privacy token based on AB prop 14303 */
+export async function resolveIssuanceJid(jid, issueToLid, getLIDForPN, getPNForLID) {
+    if (issueToLid) {
+        if (isLidUser(jid))
+            return jid;
+        const lid = await getLIDForPN(jid);
+        return lid ?? jid;
+    }
+    if (!isLidUser(jid))
+        return jid;
+    if (getPNForLID) {
+        const pn = await getPNForLID(jid);
+        return pn ?? jid;
+    }
+    return jid;
+}
+export async function buildTcTokenFromJid({ authState, jid, baseContent = [], getLIDForPN }) {
+    try {
+        const storageJid = await resolveTcTokenJid(jid, getLIDForPN);
+        const tcTokenData = await authState.keys.get('tctoken', [storageJid]);
+        const entry = tcTokenData?.[storageJid];
+        const tcTokenBuffer = entry?.token;
+        if (!tcTokenBuffer?.length || isTcTokenExpired(entry?.timestamp)) {
+            if (tcTokenBuffer) {
+                // Preserve senderTimestamp so shouldSendNewTcToken() keeps its dedupe state
+                // after we drop the unusable peer token. Only wipe the record entirely when
+                // there's nothing worth keeping.
+                const cleared = entry?.senderTimestamp !== undefined
+                    ? { token: Buffer.alloc(0), senderTimestamp: entry.senderTimestamp }
+                    : null;
+                await authState.keys.set({ tctoken: { [storageJid]: cleared } });
+            }
+            return baseContent.length > 0 ? baseContent : undefined;
+        }
+        baseContent.push({
+            tag: 'tctoken',
+            attrs: {},
+            content: tcTokenBuffer
+        });
+        return baseContent;
+    }
+    catch (error) {
+        return baseContent.length > 0 ? baseContent : undefined;
+    }
+}
+export async function storeTcTokensFromIqResult({ result, fallbackJid, keys, getLIDForPN, onNewJidStored }) {
+    const tokensNode = getBinaryNodeChild(result, 'tokens');
+    if (!tokensNode)
+        return;
+    const tokenNodes = getBinaryNodeChildren(tokensNode, 'token');
+    for (const tokenNode of tokenNodes) {
+        if (tokenNode.attrs.type !== 'trusted_contact' || !(tokenNode.content instanceof Uint8Array)) {
+            continue;
+        }
+        // In notifications tokenNode.attrs.jid is your own device JID, not the sender's
+        const rawJid = jidNormalizedUser(fallbackJid || tokenNode.attrs.jid);
+        if (!isRegularUser(rawJid))
+            continue;
+        const storageJid = await resolveTcTokenJid(rawJid, getLIDForPN);
+        const existingTcData = await keys.get('tctoken', [storageJid]);
+        const existingEntry = existingTcData[storageJid];
+        const existingTs = existingEntry?.timestamp ? Number(existingEntry.timestamp) : 0;
+        const incomingTs = tokenNode.attrs.t ? Number(tokenNode.attrs.t) : 0;
+        // timestamp-less tokens would be immediately expired
+        if (!incomingTs)
+            continue;
+        if (existingTs > 0 && existingTs > incomingTs)
+            continue;
+        await keys.set({
+            tctoken: {
+                [storageJid]: {
+                    ...existingEntry,
+                    token: Buffer.from(tokenNode.content),
+                    timestamp: tokenNode.attrs.t
+                }
+            }
+        });
+        onNewJidStored?.(storageJid);
+    }
+}

package/lib/Utils/templates.d.ts

@@ -0,0 +1,86 @@
+export class TemplateManager {
+    templates: Map<any, any>;
+    generateId(): string;
+    extractVariables(content: any): {
+        name: string;
+        defaultValue: string;
+        required: boolean;
+    }[];
+    create(options: any): {
+        id: any;
+        name: any;
+        content: any;
+        description: any;
+        category: any;
+        variables: {
+            name: string;
+            defaultValue: string;
+            required: boolean;
+        }[];
+        createdAt: Date;
+        updatedAt: Date;
+    };
+    get(id: any): any;
+    getByName(name: any): any;
+    getAll(): any[];
+    getByCategory(category: any): any[];
+    update(id: any, updates: any): any;
+    delete(id: any): boolean;
+    renderContent(content: any, data?: {}): any;
+    render(id: any, data?: {}): any;
+    validate(id: any, data: any): {
+        valid: boolean;
+        missing: any;
+    };
+    export(): string;
+    import(json: any, overwrite?: boolean): number;
+}
+export namespace PRESET_TEMPLATES {
+    namespace ORDER_CONFIRMATION {
+        let name: string;
+        let category: string;
+        let content: string;
+    }
+    namespace WELCOME {
+        let name_1: string;
+        export { name_1 as name };
+        let category_1: string;
+        export { category_1 as category };
+        let content_1: string;
+        export { content_1 as content };
+    }
+    namespace REMINDER {
+        let name_2: string;
+        export { name_2 as name };
+        let category_2: string;
+        export { category_2 as category };
+        let content_2: string;
+        export { content_2 as content };
+    }
+    namespace SUPPORT_TICKET {
+        let name_3: string;
+        export { name_3 as name };
+        let category_3: string;
+        export { category_3 as category };
+        let content_3: string;
+        export { content_3 as content };
+    }
+    namespace BIRTHDAY {
+        let name_4: string;
+        export { name_4 as name };
+        let category_4: string;
+        export { category_4 as category };
+        let content_4: string;
+        export { content_4 as content };
+    }
+    namespace INVOICE {
+        let name_5: string;
+        export { name_5 as name };
+        let category_5: string;
+        export { category_5 as category };
+        let content_5: string;
+        export { content_5 as content };
+    }
+}
+export function createTemplateManager(includePresets?: boolean): TemplateManager;
+export function renderTemplate(content: any, data?: {}): any;

package/lib/Utils/templates.js

@@ -0,0 +1,148 @@
+export class TemplateManager {
+    templates = new Map();
+    generateId() {
+        return `tpl_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+    }
+    extractVariables(content) {
+        const regex = /\{\{(\w+)(?::([^}]*))?\}\}/g;
+        const variables = [];
+        const seen = new Set();
+        let match;
+        while ((match = regex.exec(content)) !== null) {
+            const name = match[1];
+            if (!name || seen.has(name))
+                continue;
+            seen.add(name);
+            variables.push({ name, defaultValue: match[2], required: !match[2] });
+        }
+        return variables;
+    }
+    create(options) {
+        const template = {
+            id: options.id ?? this.generateId(),
+            name: options.name,
+            content: options.content,
+            description: options.description,
+            category: options.category,
+            variables: this.extractVariables(options.content),
+            createdAt: new Date(),
+            updatedAt: new Date()
+        };
+        this.templates.set(template.id, template);
+        return template;
+    }
+    get(id) {
+        return this.templates.get(id);
+    }
+    getByName(name) {
+        return Array.from(this.templates.values()).find((t) => t.name === name);
+    }
+    getAll() {
+        return Array.from(this.templates.values());
+    }
+    getByCategory(category) {
+        return Array.from(this.templates.values()).filter((t) => t.category === category);
+    }
+    update(id, updates) {
+        const template = this.templates.get(id);
+        if (!template)
+            return undefined;
+        if (updates.content)
+            updates.variables = this.extractVariables(updates.content);
+        const updated = { ...template, ...updates, updatedAt: new Date() };
+        this.templates.set(id, updated);
+        return updated;
+    }
+    delete(id) {
+        return this.templates.delete(id);
+    }
+    renderContent(content, data = {}) {
+        return content.replace(/\{\{(\w+)(?::([^}]*))?\}\}/g, (match, name, defaultValue) => {
+            const value = data[name];
+            if (value !== undefined && value !== null)
+                return String(value);
+            if (defaultValue !== undefined)
+                return defaultValue;
+            return match;
+        });
+    }
+    render(id, data = {}) {
+        const template = this.templates.get(id);
+        if (!template)
+            throw new Error(`Template not found: ${id}`);
+        return this.renderContent(template.content, data);
+    }
+    validate(id, data) {
+        const template = this.templates.get(id);
+        if (!template)
+            throw new Error(`Template not found: ${id}`);
+        const missing = template.variables.filter((v) => v.required && !(v.name in data)).map((v) => v.name);
+        return { valid: missing.length === 0, missing };
+    }
+    export() {
+        return JSON.stringify(Array.from(this.templates.values()), null, 2);
+    }
+    import(json, overwrite = false) {
+        const templates = JSON.parse(json);
+        let imported = 0;
+        for (const t of templates) {
+            if (!overwrite && this.templates.has(t.id))
+                continue;
+            this.templates.set(t.id, { ...t, createdAt: new Date(t.createdAt), updatedAt: new Date(t.updatedAt) });
+            imported++;
+        }
+        return imported;
+    }
+}
+/** Ready-made templates covering common bot scenarios (order, welcome, reminder, etc). */
+export const PRESET_TEMPLATES = {
+    ORDER_CONFIRMATION: {
+        name: 'Order Confirmation',
+        category: 'order',
+        content: `✅ *Order Confirmed!*\n\nOrder ID: #{{orderId}}\nCustomer: {{customerName}}\nDate: {{orderDate}}\n\n📦 *Items:*\n{{items}}\n\n💰 *Total: {{total}}*\n\nThank you! 🙏`
+    },
+    WELCOME: {
+        name: 'Welcome Message',
+        category: 'greeting',
+        content: `👋 *Welcome, {{name}}!*\n\nThank you for joining {{companyName:us}}!\nNeed help? Reply to this message!`
+    },
+    REMINDER: {
+        name: 'Reminder',
+        category: 'notification',
+        content: `⏰ *Reminder*\n\nHi {{name}},\n\n📋 {{subject}}\n📅 Date: {{date}}\n🕐 Time: {{time}}\n📍 Location: {{location:TBD}}`
+    },
+    SUPPORT_TICKET: {
+        name: 'Support Ticket',
+        category: 'support',
+        content: `🎫 *Support Ticket Created*\n\nTicket #: {{ticketId}}\nSubject: {{subject}}\n\nHi {{name}},\n\nWe received your request! Response time: {{responseTime:24 hours}} 🙏`
+    },
+    BIRTHDAY: {
+        name: 'Birthday Wishes',
+        category: 'greeting',
+        content: `🎂 *Happy Birthday, {{name}}!* 🎉\n\nWishing you a wonderful day!\n\n🎁 Use code: {{code}} for {{discount:10}}% off! 🥳`
+    },
+    INVOICE: {
+        name: 'Invoice',
+        category: 'invoice',
+        content: `🧾 *Invoice {{invoiceNumber}}*\n\nBilled to: {{customerName}}\nInvoice date: {{invoiceDate}}\nDue date: {{dueDate:on receipt}}\n\n📋 *Items:*\n{{items}}\n\nSubtotal: {{subtotal}}\n💰 *Total: {{total}}*\n\nThank you for your business! 🙏`
+    }
+};
+export const createTemplateManager = (includePresets = true) => {
+    const manager = new TemplateManager();
+    if (includePresets) {
+        for (const [key, template] of Object.entries(PRESET_TEMPLATES)) {
+            manager.create({ ...template, id: key.toLowerCase() });
+        }
+    }
+    return manager;
+};
+export const renderTemplate = (content, data = {}) => {
+    return content.replace(/\{\{(\w+)(?::([^}]*))?\}\}/g, (match, name, defaultValue) => {
+        const value = data[name];
+        if (value !== undefined && value !== null)
+            return String(value);
+        if (defaultValue !== undefined)
+            return defaultValue;
+        return match;
+    });
+};

package/lib/Utils/text-format.d.ts

@@ -0,0 +1,13 @@
+/** Default part size. WhatsApp accepts far more, but long single bubbles render and quote badly; 4000 is a safe chunk. */
+export const DEFAULT_TEXT_PART_LENGTH: 4000;
+export function splitText(text: any, maxLen?: number): string[];
+export function whatsappify(text: any): any;
+export function sendLongText(sock: any, jid: any, text: any, opts1?: { [key: string]: any; 
+    format?: boolean;
+    maxLen?: number;
+    delayMs?: number;
+}): Promise<{
+    ok: boolean;
+    ids: string[];
+    error?: unknown;
+}>;

package/lib/Utils/text-format.js

@@ -0,0 +1,81 @@
+// Vanz@Port (2.0.3) --- from xbibzlibrary/whatsbibz 1.4.0 (BibzWhats/send.js: splitText, whatsappify). See NOTICE.md.
+// Changed vs donor: whatsappify leaves fenced/inline code untouched (the donor rewrote `**x**` inside code blocks), splitText never cuts
+// an emoji/surrogate pair in half, and sendLongText does NOT retry a failed send (a retry after a partial relay can post duplicates).
+/** Default part size. WhatsApp accepts far more, but long single bubbles render and quote badly; 4000 is a safe chunk. */
+export const DEFAULT_TEXT_PART_LENGTH = 4000;
+/** Split long text into parts <= maxLen, preferring a newline, then a space, then a hard cut (never inside a surrogate pair). */
+export const splitText = (text, maxLen = DEFAULT_TEXT_PART_LENGTH) => {
+    const limit = Number.isFinite(maxLen) && maxLen >= 2 ? Math.floor(maxLen) : DEFAULT_TEXT_PART_LENGTH;
+    const out = [];
+    let rest = String(text ?? '');
+    while (rest.length > limit) {
+        let cut = rest.lastIndexOf('\n', limit);
+        if (cut < limit * 0.5) {
+            cut = rest.lastIndexOf(' ', limit);
+        }
+        if (cut < limit * 0.5) {
+            cut = limit;
+            const prev = rest.charCodeAt(cut - 1);
+            if (prev >= 0xd800 && prev <= 0xdbff) {
+                cut -= 1; // do not split a surrogate pair
+            }
+        }
+        out.push(rest.slice(0, cut).trim());
+        rest = rest.slice(cut).trim();
+    }
+    if (rest) {
+        out.push(rest);
+    }
+    return out.filter(Boolean);
+};
+/**
+ * Normalise ChatGPT-style markdown to WhatsApp formatting: **bold** / __bold__ -> *bold*, ~~strike~~ -> ~strike~,
+ * "# heading" -> "heading", [text](url) -> "text (url)". Fenced (```...```) and inline (`...`) code is left exactly as written.
+ */
+export const whatsappify = (text) => {
+    if (typeof text !== 'string' || !text) {
+        return text;
+    }
+    const stash = [];
+    const hold = (m) => `\u0000${stash.push(m) - 1}\u0000`;
+    let t = text.replace(/```[\s\S]*?```/g, hold).replace(/`[^`\n]+`/g, hold);
+    for (let i = 0; i < 3; i++) {
+        t = t.replace(/\*\*\*([^*\n]+)\*\*\*/g, '*$1*');
+        t = t.replace(/\*\*([^*\n]+)\*\*/g, '*$1*');
+        t = t.replace(/__([^_\n]+)__/g, '*$1*');
+    }
+    t = t.replace(/_{2,}([^_\n]+)_{2,}/g, '_$1_');
+    t = t.replace(/~~([^~\n]+)~~/g, '~$1~');
+    t = t.replace(/^\s{0,3}#{1,6}\s+/gm, '');
+    t = t.replace(/\[([^\]]+)\]\(([^)\s]+)\)/g, '$1 ($2)');
+    t = t.replace(/\*{3,}/g, '*').replace(/_{3,}/g, '_');
+    t = t.replace(/\u0000(\d+)\u0000/g, (_, i) => stash[Number(i)]);
+    return t.trim();
+};
+/**
+ * Send long text as several messages. Stops at the first failure (no automatic retry).
+ * @returns {Promise<{ ok: boolean, ids: string[], error?: unknown }>}
+ */
+export const sendLongText = async (sock, jid, text, { quoted, format = true, maxLen = DEFAULT_TEXT_PART_LENGTH, delayMs = 250 } = {}) => {
+    if (!sock || typeof sock.sendMessage !== 'function') {
+        throw new TypeError('sendLongText(sock, ...) requires a socket with sendMessage');
+    }
+    const body = format ? whatsappify(String(text ?? '')) : String(text ?? '');
+    const parts = splitText(body, maxLen);
+    const ids = [];
+    for (let i = 0; i < parts.length; i++) {
+        try {
+            const result = await sock.sendMessage(jid, { text: parts[i] }, quoted ? { quoted } : undefined);
+            if (result?.key?.id) {
+                ids.push(result.key.id);
+            }
+        }
+        catch (error) {
+            return { ok: false, ids, error };
+        }
+        if (delayMs > 0 && i < parts.length - 1) {
+            await new Promise((r) => setTimeout(r, delayMs));
+        }
+    }
+    return { ok: true, ids };
+};

package/lib/Utils/text-tools.d.ts

@@ -0,0 +1,3 @@
+export function parseMentions(text: any): string[];
+export function extractGroupInviteCode(link: any): string;
+export function joinGroupViaLink(sock: any, linkOrCode: any): Promise<any>;

package/lib/Utils/text-tools.js

@@ -0,0 +1,38 @@
+// Vanz@Port (2.0.3) --- from @japofc/baileys 2.4.1 (MIT, author JAPofc / J.AP), lib/Utils/text-tools.js. See NOTICE.md.
+// sendBroadcast is NOT ported (bulk-send helper; pacing/anti-spam policy belongs in the bot, not the library).
+// Fix vs donor: parseMentions ignored context, so an e-mail such as "foo@123456.com" yielded a bogus mention. A mention must
+// now start the string or follow whitespace/punctuation, and must not be followed by more word characters or a domain dot.
+const MENTION_RE = /(?<![\w.])@(\d{5,20})(?![\w]|\.\w)/g;
+const INVITE_RE = /(?:https?:\/\/)?chat\.whatsapp\.com\/(?:invite\/)?([0-9A-Za-z]{16,32})/;
+/** '@62812… halo @62813…' -> ['62812…@s.whatsapp.net', …] (de-duplicated, order of first appearance). */
+export const parseMentions = (text) => {
+    if (typeof text !== 'string' || !text) {
+        return [];
+    }
+    const seen = new Set();
+    const out = [];
+    for (const m of text.matchAll(MENTION_RE)) {
+        const jid = `${m[1]}@s.whatsapp.net`;
+        if (!seen.has(jid)) {
+            seen.add(jid);
+            out.push(jid);
+        }
+    }
+    return out;
+};
+/** Pull the invite code out of a chat.whatsapp.com link (or text containing one). Returns null when absent. */
+export const extractGroupInviteCode = (link) => {
+    if (typeof link !== 'string' || !link) {
+        return null;
+    }
+    const m = link.match(INVITE_RE);
+    return m ? m[1] : null;
+};
+/** Join a group from an invite link or bare code via sock.groupAcceptInvite. Throws when no code can be found. */
+export const joinGroupViaLink = async (sock, linkOrCode) => {
+    const code = extractGroupInviteCode(linkOrCode) ?? (/^[0-9A-Za-z]{16,32}$/.test(String(linkOrCode ?? '')) ? String(linkOrCode) : null);
+    if (!code) {
+        throw new Error(`joinGroupViaLink: no invite code found in ${JSON.stringify(linkOrCode)}`);
+    }
+    return sock.groupAcceptInvite(code);
+};

package/lib/Utils/ttl-cache.d.ts

@@ -0,0 +1,29 @@
+/* Elaina Baileys maintained distribution. Upstream notices and license are preserved in LICENSE and NOTICE.md. */
+export declare class TTLCache<T = any> {
+    constructor(options?: {
+        /** lifetime in seconds, the same unit node-cache used; 0 or omitted means no expiry */
+        stdTTL?: number;
+        /** ceiling on entries, the oldest is evicted once it is reached */
+        maxKeys?: number;
+        /** alias for maxKeys */
+        max?: number;
+        /** lifetime in milliseconds, takes precedence over stdTTL */
+        ttl?: number;
+    });
+    get(key: string | number): T | undefined;
+    set(key: string | number, value: T, ttl?: number): boolean;
+    has(key: string | number): boolean;
+    del(keys: string | number | Array<string | number>): number;
+    take(key: string | number): T | undefined;
+    mget(keys: Array<string | number>): Record<string, T>;
+    mset(list: Array<{ key: string | number; value?: T; val?: T; ttl?: number }>): boolean;
+    keys(): string[];
+    flushAll(): void;
+    getStats(): { hits: number; misses: number; keys: number; ksize: number; vsize: number };
+    close(): void;
+    on(): this;
+    off(): this;
+    removeAllListeners(): this;
+    readonly size: number;
+}
+export default TTLCache;

package/lib/Utils/ttl-cache.js

@@ -0,0 +1,123 @@
+// Ported into @vanzxysenpai/baileys 0.0.1 from @rexxhayanasi/elaina-baileys 1.4.7, MIT. See NOTICE.md.
+/* Elaina Baileys maintained distribution. Upstream notices and license are preserved in LICENSE and NOTICE.md. */
+import { LRUCache } from 'lru-cache';
+// DEFAULT_CACHE_MAX_KEYS is not exported by this package's Defaults; same value as Elaina's Defaults.
+const DEFAULT_CACHE_MAX_KEYS = 20_000;
+
+const asKey = (key) => (typeof key === 'string' ? key : String(key));
+
+const toMilliseconds = (seconds) => {
+    const value = Number(seconds);
+    return Number.isFinite(value) && value > 0 ? Math.round(value * 1000) : 0;
+};
+
+export class TTLCache {
+    #store;
+
+    #ttl;
+
+    #hits = 0;
+
+    #misses = 0;
+
+    constructor({ stdTTL = 0, maxKeys, max, ttl } = {}) {
+        this.#ttl = ttl !== undefined ? Number(ttl) || 0 : toMilliseconds(stdTTL);
+        const limit = Number(max ?? maxKeys);
+        this.#store = new LRUCache({
+            max: Number.isFinite(limit) && limit > 0 ? limit : DEFAULT_CACHE_MAX_KEYS,
+            ...(this.#ttl ? { ttl: this.#ttl } : {})
+        });
+    }
+
+    get(key) {
+        const value = this.#store.get(asKey(key));
+        if (value === undefined) {
+            this.#misses += 1;
+        }
+        else {
+            this.#hits += 1;
+        }
+        return value;
+    }
+
+    set(key, value, ttl) {
+        const override = toMilliseconds(ttl);
+        this.#store.set(asKey(key), value, override ? { ttl: override } : undefined);
+        return true;
+    }
+
+    has(key) {
+        return this.#store.has(asKey(key));
+    }
+
+    del(keys) {
+        const list = Array.isArray(keys) ? keys : [keys];
+        let removed = 0;
+        for (const key of list) {
+            if (this.#store.delete(asKey(key))) {
+                removed += 1;
+            }
+        }
+        return removed;
+    }
+
+    take(key) {
+        const value = this.get(key);
+        this.del(key);
+        return value;
+    }
+
+    mget(keys) {
+        const found = {};
+        for (const key of Array.isArray(keys) ? keys : [keys]) {
+            const value = this.get(key);
+            if (value !== undefined) {
+                found[key] = value;
+            }
+        }
+        return found;
+    }
+
+    mset(list) {
+        for (const item of list ?? []) {
+            this.set(item.key, item.value ?? item.val, item.ttl);
+        }
+        return true;
+    }
+
+    keys() {
+        return [...this.#store.keys()];
+    }
+
+    flushAll() {
+        this.#store.clear();
+        this.#hits = 0;
+        this.#misses = 0;
+    }
+
+    getStats() {
+        return { hits: this.#hits, misses: this.#misses, keys: this.#store.size, ksize: 0, vsize: 0 };
+    }
+
+    close() {
+        this.#store.clear();
+    }
+
+    on() {
+        return this;
+    }
+
+    off() {
+        return this;
+    }
+
+    removeAllListeners() {
+        return this;
+    }
+
+    get size() {
+        return this.#store.size;
+    }
+}
+
+export default TTLCache;