@vanzxy/baileys 2.0.0

package/lib/Socket/username.js

@@ -0,0 +1,153 @@
+import { USyncQuery, USyncUser } from '../WAUSync/index.js';
+import { makeCommunitiesSocket } from './communities.js';
+import { executeWMexQuery } from './mex.js';
+
+// Vanz@Port (from @queenanya/baileys, originally @innovatorssoft/baileys) ---
+// WhatsApp Username socket layer: check, set, pin, find, and recommend usernames.
+// Query IDs below are captured from live WA Web sessions and may rotate with
+// WA updates — re-capture via the proto-extract tool if a call starts failing
+// with an "unexpected response structure" Boom.
+export const USERNAME_QUERY_IDS = {
+    CHECK: '26124072630599520', // UsernameCheck
+    CHECK_MULTI: '27134626522840290', // UsernameCheckMulti
+    SET: '27108705368767936', // UsernameSet
+    GET: '32618050064506056', // UsernameGet
+    GET_RECOMMENDATIONS: '26077456248616956', // UsernameGetRecommendationsQuery
+    PIN_SET: '25529696019976770' // UsernamePinSet
+};
+
+export const USERNAME_CHECK_RESULT = {
+    SUCCESS: 'SUCCESS',
+    INVALID: 'INVALID'
+};
+
+export const USERNAME_SOURCE = {
+    FB: 'FB',
+    IG: 'IG',
+    USER_INPUT: 'USER_INPUT',
+    SUGGESTION: 'SUGGESTION'
+};
+
+export const makeUsernameSocket = (config) => {
+    const sock = makeCommunitiesSocket(config);
+    const { query, generateMessageTag, executeUSyncQuery } = sock;
+
+    /** Internal helper — wraps executeWMexQuery with this socket's query/tag */
+    const mexQuery = (variables, queryId, dataPath) => executeWMexQuery(variables, queryId, dataPath, query, generateMessageTag);
+
+    // 1. Check username availability
+    const checkUsername = async (username, includeSuggestions = true) => {
+        if (!USERNAME_QUERY_IDS.CHECK) {
+            throw new Error('Username CHECK query_id not configured — capture a live WA session to obtain it');
+        }
+        const data = await mexQuery({ username, include_suggestions: includeSuggestions }, USERNAME_QUERY_IDS.CHECK, 'xwa2_username_check');
+        if (data?.result === USERNAME_CHECK_RESULT.SUCCESS) {
+            return { available: true, username };
+        }
+        return {
+            available: false,
+            username,
+            suggestions: data?.suggestions ?? [],
+            rejectionReasons: data?.rejection_reasons ?? [],
+            suggestionsEligible: data?.suggestions_eligible ?? true
+        };
+    };
+
+    // 2. Check multiple usernames at once
+    const checkUsernameMulti = async (usernames) => {
+        if (!USERNAME_QUERY_IDS.CHECK_MULTI) {
+            throw new Error('Username CHECK_MULTI query_id not configured');
+        }
+        return mexQuery({ usernames }, USERNAME_QUERY_IDS.CHECK_MULTI, 'xwa2_username_check_multi');
+    };
+
+    // 3. Set username
+    const setUsername = async (username, options = {}) => {
+        if (!USERNAME_QUERY_IDS.SET) {
+            throw new Error('Username SET query_id not configured — capture a live WA session to obtain it');
+        }
+        const { source = USERNAME_SOURCE.USER_INPUT, sessionId, pin } = options;
+        const variables = {
+            username,
+            reserved: false,
+            source,
+            ...(sessionId ? { session_id: sessionId } : {}),
+            ...(pin ? { pin } : {})
+        };
+        return mexQuery(variables, USERNAME_QUERY_IDS.SET, 'xwa2_username_set');
+    };
+
+    // 4. Delete / unset username
+    const deleteUsername = async () => {
+        if (!USERNAME_QUERY_IDS.SET) {
+            throw new Error('Username SET query_id not configured — capture a live WA session to obtain it');
+        }
+        return mexQuery({ username: null }, USERNAME_QUERY_IDS.SET, 'xwa2_username_delete');
+    };
+
+    // 5. Get own username
+    const getMyUsername = async () => {
+        if (!USERNAME_QUERY_IDS.GET) {
+            throw new Error('Username GET query_id not configured — capture a live WA session to obtain it');
+        }
+        const data = await mexQuery({}, USERNAME_QUERY_IDS.GET, 'xwa2_username_get');
+        return data?.username ?? null;
+    };
+
+    // 6. Pin/unpin username (requires PIN)
+    const setUsernamePin = async (pin) => {
+        if (!USERNAME_QUERY_IDS.PIN_SET) {
+            throw new Error('Username PIN_SET query_id not configured — capture a live WA session to obtain it');
+        }
+        return mexQuery({ pin }, USERNAME_QUERY_IDS.PIN_SET, 'xwa2_username_pin_set');
+    };
+
+    // 7. Find user by username (USync)
+    const findUserByUsername = async (username, pin) => {
+        const usyncQuery = new USyncQuery().withContactProtocol();
+        const user = new USyncUser().withUsername(username);
+        if (pin) user.withUsernameKey(pin);
+        usyncQuery.withUser(user);
+        const result = await executeUSyncQuery(usyncQuery);
+        if (!result?.list?.length) return null;
+        const entry = result.list[0];
+        if (!entry) return null;
+        return {
+            jid: entry.id,
+            contact: Boolean(entry.contact)
+        };
+    };
+
+    // 8. Fetch usernames of known contacts (USync)
+    const fetchContactUsernames = async (...jids) => {
+        const usyncQuery = new USyncQuery().withUsernameProtocol();
+        for (const jid of jids) {
+            usyncQuery.withUser(new USyncUser().withId(jid));
+        }
+        const result = await executeUSyncQuery(usyncQuery);
+        return result?.list ?? [];
+    };
+
+    // 9. Get username recommendations
+    const getUsernameRecommendations = async (source = null) => {
+        const variables = {};
+        if (source) variables.source = source;
+        return mexQuery(variables, USERNAME_QUERY_IDS.GET_RECOMMENDATIONS, 'xwa2_username_get_recommendations');
+    };
+
+    return {
+        ...sock,
+        checkUsername,
+        checkUsernameMulti,
+        setUsername,
+        deleteUsername,
+        getMyUsername,
+        setUsernamePin,
+        findUserByUsername,
+        fetchContactUsernames,
+        getUsernameRecommendations,
+        USERNAME_QUERY_IDS,
+        USERNAME_CHECK_RESULT,
+        USERNAME_SOURCE
+    };
+};

package/lib/Store/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./make-in-memory-store.js";
+export * from "./make-ordered-dictionary.js";
+export * from "./object-repository.js";

package/lib/Store/index.js

@@ -0,0 +1,4 @@
+export * from './make-in-memory-store.js';
+export * from './make-ordered-dictionary.js';
+export * from './object-repository.js';
+//# sourceMappingURL=index.js.map

package/lib/Store/make-in-memory-store.d.ts

@@ -0,0 +1,62 @@
+export function waChatKey(pin: any): {
+    key: (c: any) => string;
+    compare: (k1: any, k2: any) => any;
+};
+export function waMessageID(m: any): any;
+export namespace waLabelAssociationKey {
+    function key(la: any): any;
+    function compare(k1: any, k2: any): any;
+}
+export function makeInMemoryStore(config?: {}): {
+    chats: any;
+    contacts: {};
+    messages: {};
+    groupMetadata: {};
+    state: {
+        connection: string;
+    };
+    presences: {};
+    labels: ObjectRepository;
+    labelAssociations: any;
+    bind: (ev: any) => void;
+    /** loads messages from the store, if not found -- uses the legacy connection */
+    loadMessages: (jid: any, count: any, cursor: any) => Promise<any>;
+    /**
+     * Get all available labels for profile
+     *
+     * Keep in mind that the list is formed from predefined tags and tags
+     * that were "caught" during their editing.
+     */
+    getLabels: () => ObjectRepository;
+    /**
+     * Get labels for chat
+     *
+     * @returns Label IDs
+     **/
+    getChatLabels: (chatId: any) => any;
+    /**
+     * Get labels for message
+     *
+     * @returns Label IDs
+     **/
+    getMessageLabels: (messageId: any) => any;
+    loadMessage: (jid: any, id: any) => Promise<any>;
+    mostRecentMessage: (jid: any) => Promise<any>;
+    fetchImageUrl: (jid: any, sock: any) => Promise<any>;
+    fetchGroupMetadata: (jid: any, sock: any) => Promise<any>;
+    fetchMessageReceipts: ({ remoteJid, id }: {
+        remoteJid: any;
+        id: any;
+    }) => Promise<any>;
+    toJSON: () => {
+        chats: any;
+        contacts: {};
+        messages: {};
+        labels: ObjectRepository;
+        labelAssociations: any;
+    };
+    fromJSON: (json: any) => void;
+    writeToFile: (path: any) => void;
+    readFromFile: (path: any) => void;
+};
+import { ObjectRepository } from './object-repository.js';

package/lib/Store/make-in-memory-store.js

@@ -0,0 +1,429 @@
+/**
+ * Lia@Note 03-02-26 [WIP]
+ * Manually converted to ESM and modified by me
+ * Originally based on @whiskeysockets/baileys v6.7.16
+ * Minor adjustments for compatibility with baileys v7 (⁠つ⁠≧⁠▽⁠≦⁠)⁠つ
+ */
+import keyedDB from '@adiwajshing/keyed-db';
+import { writeFileSync, readFileSync, existsSync } from 'fs';
+import { WAProto } from '../Types/index.js';
+import { LabelAssociationType } from '../Types/LabelAssociation.js';
+import { DEFAULT_CONNECTION_CONFIG } from '../Defaults/index.js';
+import { md5, toNumber, updateMessageWithReceipt, updateMessageWithReaction } from '../Utils/index.js';
+import { jidDecode, jidNormalizedUser } from '../WABinary/index.js';
+import { makeOrderedDictionary } from './make-ordered-dictionary.js';
+import { ObjectRepository } from './object-repository.js';
+export const waChatKey = (pin) => ({
+    key: (c) => (pin ? (c.pinned ? '1' : '0') : '') + (c.archived ? '0' : '1') + (c.conversationTimestamp ? c.conversationTimestamp.toString(16).padStart(8, '0') : '') + c.id,
+    compare: (k1, k2) => k2.localeCompare(k1)
+});
+export const waMessageID = (m) => m.key.id || '';
+export const waLabelAssociationKey = {
+    key: (la) => (la.type === LabelAssociationType.Chat ? la.chatId + la.labelId : la.chatId + la.messageId + la.labelId),
+    compare: (k1, k2) => k2.localeCompare(k1)
+};
+const makeMessagesDictionary = () => makeOrderedDictionary(waMessageID);
+export const makeInMemoryStore = (config = {}) => {
+    const socket = config.socket;
+    const chatKey = config.chatKey || waChatKey(true);
+    const labelAssociationKey = config.labelAssociationKey || waLabelAssociationKey;
+    const logger = config.logger || DEFAULT_CONNECTION_CONFIG.logger.child({ stream: 'in-mem-store' });
+    const KeyedDB = keyedDB?.default ?? keyedDB; // Lia@Note 03-02-26 --- Handle CJS ↔ ESM default export differences ⊂⁠(⁠･⁠ω⁠･⁠*⁠⊂⁠)
+    const chats = new KeyedDB(chatKey, c => c.id);
+    const messages = {};
+    const contacts = {};
+    const groupMetadata = {};
+    const presences = {};
+    const state = { connection: 'close' };
+    const labels = new ObjectRepository();
+    const labelAssociations = new KeyedDB(labelAssociationKey, labelAssociationKey.key);
+    const assertMessageList = (jid) => {
+        if (!messages[jid]) {
+            messages[jid] = makeMessagesDictionary();
+        }
+        return messages[jid];
+    };
+    const contactsUpsert = (newContacts) => {
+        const oldContacts = new Set(Object.keys(contacts));
+        for (const contact of newContacts) {
+            oldContacts.delete(contact.id);
+            contacts[contact.id] = Object.assign(contacts[contact.id] || {}, contact);
+        }
+        return oldContacts;
+    };
+    const labelsUpsert = (newLabels) => {
+        for (const label of newLabels) {
+            labels.upsertById(label.id, label);
+        }
+    };
+    /**
+     * binds to a BaileysEventEmitter.
+     * It listens to all events and constructs a state that you can query accurate data from.
+     * Eg. can use the store to fetch chats, contacts, messages etc.
+     * @param ev typically the event emitter from the socket connection
+     */
+    const bind = (ev) => {
+        ev.on('connection.update', update => {
+            Object.assign(state, update);
+        });
+        ev.on('messaging-history.set', ({ chats: newChats, contacts: newContacts, messages: newMessages, isLatest, syncType }) => {
+            if (syncType === WAProto.HistorySync.HistorySyncType.ON_DEMAND) {
+                // Vanz@Fix (bug 38): was early-returning without saving anything.
+                // ON_DEMAND is used when loading older messages (e.g. scroll-up / .q search).
+                // We should at minimum merge the messages into the store.
+                for (const msg of newMessages) {
+                    const jid = msg.key.remoteJidAlt || msg.key.remoteJid;
+                    const list = assertMessageList(jid);
+                    list.upsert(msg, 'prepend');
+                }
+                logger.debug({ messages: newMessages.length }, 'synced ON_DEMAND messages');
+                return;
+            }
+            if (isLatest) {
+                chats.clear();
+                for (const id in messages) {
+                    delete messages[id];
+                }
+            }
+            const chatsAdded = chats.insertIfAbsent(...newChats).length;
+            logger.debug({ chatsAdded }, 'synced chats');
+            const oldContacts = contactsUpsert(newContacts);
+            if (isLatest) {
+                for (const jid of oldContacts) {
+                    delete contacts[jid];
+                }
+            }
+            logger.debug({ deletedContacts: isLatest ? oldContacts.size : 0, newContacts }, 'synced contacts');
+            for (const msg of newMessages) {
+                const jid = msg.key.remoteJidAlt || msg.key.remoteJid;
+                const list = assertMessageList(jid);
+                list.upsert(msg, 'prepend');
+            }
+            logger.debug({ messages: newMessages.length }, 'synced messages');
+        });
+        ev.on('contacts.upsert', contacts => {
+            contactsUpsert(contacts);
+        });
+        ev.on('contacts.update', async (updates) => {
+            var _a;
+            for (const update of updates) {
+                let contact;
+                if (contacts[update.id]) {
+                    contact = contacts[update.id];
+                }
+                else {
+                    const contactHashes = await Promise.all(Object.keys(contacts).map(async (contactId) => {
+                        const { user } = jidDecode(contactId);
+                        return [contactId, (await md5(Buffer.from(user + 'WA_ADD_NOTIF', 'utf8'))).toString('base64').slice(0, 3)];
+                    }));
+                    contact = contacts[((_a = contactHashes.find(([, b]) => b === update.id)) === null || _a === void 0 ? void 0 : _a[0]) || '']; // find contact by attrs.hash, when user is not saved as a contact
+                }
+                if (contact) {
+                    if (update.imgUrl === 'changed') {
+                        contact.imgUrl = socket ? await (socket === null || socket === void 0 ? void 0 : socket.profilePictureUrl(contact.id)) : undefined;
+                    }
+                    else if (update.imgUrl === 'removed') {
+                        delete contact.imgUrl;
+                    }
+                }
+                else {
+                    return logger.debug({ update }, 'got update for non-existant contact');
+                }
+                Object.assign(contacts[contact.id], contact);
+            }
+        });
+        ev.on('chats.upsert', newChats => {
+            chats.upsert(...newChats);
+        });
+        ev.on('chats.update', updates => {
+            for (let update of updates) {
+                const result = chats.update(update.id, chat => {
+                    if (update.unreadCount > 0) {
+                        update = { ...update };
+                        update.unreadCount = (chat.unreadCount || 0) + update.unreadCount;
+                    }
+                    Object.assign(chat, update);
+                });
+                if (!result) {
+                    logger.debug({ update }, 'got update for non-existant chat');
+                }
+            }
+        });
+        ev.on('labels.edit', (label) => {
+            if (label.deleted) {
+                return labels.deleteById(label.id);
+            }
+            // WhatsApp can store only up to 20 labels
+            if (labels.count() < 20) {
+                return labels.upsertById(label.id, label);
+            }
+            logger.error('Labels count exceed');
+        });
+        ev.on('labels.association', ({ type, association }) => {
+            switch (type) {
+                case 'add':
+                    labelAssociations.upsert(association);
+                    break;
+                case 'remove':
+                    labelAssociations.delete(association);
+                    break;
+                default:
+                    console.error(`unknown operation type [${type}]`);
+            }
+        });
+        ev.on('presence.update', ({ id, presences: update }) => {
+            presences[id] = presences[id] || {};
+            Object.assign(presences[id], update);
+        });
+        ev.on('chats.delete', deletions => {
+            for (const item of deletions) {
+                if (chats.get(item)) {
+                    chats.deleteById(item);
+                }
+            }
+        });
+        ev.on('messages.upsert', ({ messages: newMessages, type }) => {
+            switch (type) {
+                case 'append':
+                case 'notify':
+                    for (const msg of newMessages) {
+                        const jid = jidNormalizedUser(msg.key.remoteJidAlt || msg.key.remoteJid);
+                        const list = assertMessageList(jid);
+                        list.upsert(msg, 'append');
+                        if (type === 'notify' && !chats.get(jid)) {
+                            ev.emit('chats.upsert', [
+                                {
+                                    id: jid,
+                                    conversationTimestamp: toNumber(msg.messageTimestamp),
+                                    unreadCount: 1
+                                }
+                            ]);
+                        }
+                    }
+                    break;
+            }
+        });
+        ev.on('messages.update', updates => {
+            var _a;
+            for (const { update, key } of updates) {
+                const list = assertMessageList(jidNormalizedUser(key.remoteJid));
+                if (update === null || update === void 0 ? void 0 : update.status) {
+                    const listStatus = (_a = list.get(key.id)) === null || _a === void 0 ? void 0 : _a.status;
+                    if (listStatus && (update === null || update === void 0 ? void 0 : update.status) <= listStatus) {
+                        logger.debug({ update, storedStatus: listStatus }, 'status stored newer then update');
+                        delete update.status;
+                        logger.debug({ update }, 'new update object');
+                    }
+                }
+                const result = list.updateAssign(key.id, update);
+                if (!result) {
+                    logger.debug({ update }, 'got update for non-existent message');
+                }
+            }
+        });
+        ev.on('messages.delete', item => {
+            if ('all' in item) {
+                const list = messages[item.jid];
+                list === null || list === void 0 ? void 0 : list.clear();
+            }
+            else {
+                const jid = item.keys[0].remoteJidAlt || item.keys[0].remoteJid;
+                const list = messages[jid];
+                if (list) {
+                    const idSet = new Set(item.keys.map(k => k.id));
+                    list.filter(m => !idSet.has(m.key.id));
+                }
+            }
+        });
+        ev.on('groups.update', updates => {
+            for (const update of updates) {
+                const id = update.id;
+                if (groupMetadata[id]) {
+                    Object.assign(groupMetadata[id], update);
+                }
+                else {
+                    logger.debug({ update }, 'got update for non-existant group metadata');
+                }
+            }
+        });
+        ev.on('group-participants.update', ({ id, participants, action }) => {
+            const metadata = groupMetadata[id];
+            if (metadata) {
+                switch (action) {
+                    case 'add':
+                        metadata.participants.push(...participants.map(participant => ({ id: participant.id, phoneNumber: participant.phoneNumber, admin: participant.admin })));
+                        break;
+                    case 'demote':
+                    case 'promote':
+                        for (const participant of metadata.participants) {
+                            for (const participantData of participants) {
+                                if (participantData.id === participant.id || participantData.phoneNumber === participant.phoneNumber) {
+                                    participant.admin = action === 'promote' && 'admin';
+                                }
+                            }
+                        }
+                        break;
+                    case 'remove':
+                        const removeSet = new Set();
+                        for (const p of participants) {
+                            if (p.id)
+                                removeSet.add(p.id);
+                            if (p.phoneNumber)
+                                removeSet.add(p.phoneNumber);
+                        }
+                        metadata.participants = metadata.participants.reduce((acc, p) => {
+                            if (!removeSet.has(p.id) && !removeSet.has(p.phoneNumber))
+                                acc.push(p);
+                            return acc;
+                        }, []);
+                        break;
+                }
+            }
+        });
+        ev.on('message-receipt.update', updates => {
+            for (const { key, receipt } of updates) {
+                const obj = messages[key.remoteJidAlt || key.remoteJid];
+                const msg = obj === null || obj === void 0 ? void 0 : obj.get(key.id);
+                if (msg) {
+                    updateMessageWithReceipt(msg, receipt);
+                }
+            }
+        });
+        ev.on('messages.reaction', (reactions) => {
+            for (const { key, reaction } of reactions) {
+                const obj = messages[key.remoteJidAlt || key.remoteJid];
+                const msg = obj === null || obj === void 0 ? void 0 : obj.get(key.id);
+                if (msg) {
+                    updateMessageWithReaction(msg, reaction);
+                }
+            }
+        });
+    };
+    const toJSON = () => ({
+        chats,
+        contacts,
+        messages,
+        labels,
+        labelAssociations
+    });
+    const fromJSON = (json) => {
+        chats.upsert(...json.chats);
+        labelAssociations.upsert(...json.labelAssociations || []);
+        contactsUpsert(Object.values(json.contacts));
+        labelsUpsert(Object.values(json.labels || {}));
+        for (const jid in json.messages) {
+            const list = assertMessageList(jid);
+            for (const msg of json.messages[jid]) {
+                list.upsert(WAProto.WebMessageInfo.fromObject(msg), 'append');
+            }
+        }
+    };
+    return {
+        chats,
+        contacts,
+        messages,
+        groupMetadata,
+        state,
+        presences,
+        labels,
+        labelAssociations,
+        bind,
+        /** loads messages from the store, if not found -- uses the legacy connection */
+        loadMessages: async (jid, count, cursor) => {
+            const list = assertMessageList(jid);
+            const mode = !cursor || 'before' in cursor ? 'before' : 'after';
+            const cursorKey = !!cursor ? ('before' in cursor ? cursor.before : cursor.after) : undefined;
+            const cursorValue = cursorKey ? list.get(cursorKey.id) : undefined;
+            let messages;
+            if (list && mode === 'before' && (!cursorKey || cursorValue)) {
+                if (cursorValue) {
+                    const msgIdx = list.array.findIndex(m => m.key.id === (cursorKey === null || cursorKey === void 0 ? void 0 : cursorKey.id));
+                    messages = list.array.slice(0, msgIdx);
+                }
+                else {
+                    messages = list.array;
+                }
+                const diff = count - messages.length;
+                if (diff < 0) {
+                    messages = messages.slice(-count); // get the last X messages
+                }
+            }
+            else {
+                messages = [];
+            }
+            return messages;
+        },
+        /**
+         * Get all available labels for profile
+         *
+         * Keep in mind that the list is formed from predefined tags and tags
+         * that were "caught" during their editing.
+         */
+        getLabels: () => {
+            return labels;
+        },
+        /**
+         * Get labels for chat
+         *
+         * @returns Label IDs
+         **/
+        getChatLabels: (chatId) => {
+            return labelAssociations.filter((la) => la.chatId === chatId).all();
+        },
+        /**
+         * Get labels for message
+         *
+         * @returns Label IDs
+         **/
+        getMessageLabels: (messageId) => {
+            const associations = labelAssociations
+                .filter((la) => la.messageId === messageId)
+                .all();
+            return associations.map(({ labelId }) => labelId);
+        },
+        loadMessage: async (jid, id) => { var _a; return (_a = messages[jid]) === null || _a === void 0 ? void 0 : _a.get(id); },
+        mostRecentMessage: async (jid) => {
+            var _a;
+            const message = (_a = messages[jid]) === null || _a === void 0 ? void 0 : _a.array.slice(-1)[0];
+            return message;
+        },
+        fetchImageUrl: async (jid, sock) => {
+            const contact = contacts[jid];
+            if (!contact) {
+                return sock === null || sock === void 0 ? void 0 : sock.profilePictureUrl(jid);
+            }
+            if (typeof contact.imgUrl === 'undefined') {
+                contact.imgUrl = await (sock === null || sock === void 0 ? void 0 : sock.profilePictureUrl(jid));
+            }
+            return contact.imgUrl;
+        },
+        fetchGroupMetadata: async (jid, sock) => {
+            if (!groupMetadata[jid]) {
+                const metadata = await (sock === null || sock === void 0 ? void 0 : sock.groupMetadata(jid));
+                if (metadata) {
+                    groupMetadata[jid] = metadata;
+                }
+            }
+            return groupMetadata[jid];
+        },
+        fetchMessageReceipts: async ({ remoteJid, id }) => {
+            const list = messages[remoteJid];
+            const msg = list === null || list === void 0 ? void 0 : list.get(id);
+            return msg === null || msg === void 0 ? void 0 : msg.userReceipt;
+        },
+        toJSON,
+        fromJSON,
+        writeToFile: (path) => {
+            writeFileSync(path, JSON.stringify(toJSON()));
+        },
+        readFromFile: (path) => {
+            if (existsSync(path)) {
+                logger.debug({ path }, 'reading from file');
+                const jsonStr = readFileSync(path, { encoding: 'utf-8' });
+                const json = JSON.parse(jsonStr);
+                fromJSON(json);
+            }
+        }
+    };
+};
+//# sourceMappingURL=make-in-memory-store.js.map

package/lib/Store/make-ordered-dictionary.d.ts

@@ -0,0 +1,12 @@
+export function makeOrderedDictionary(idGetter: any): {
+    array: any[];
+    get: (id: any) => any;
+    upsert: (item: any, mode: any) => void;
+    update: (item: any) => boolean;
+    remove: (item: any) => boolean;
+    updateAssign: (id: any, update: any) => boolean;
+    clear: () => void;
+    filter: (contain: any) => void;
+    toJSON: () => any[];
+    fromJSON: (newItems: any) => void;
+};