@mtkruto/node 0.1.138 → 0.1.140

package/esm/client/3_chat_list_manager.js

@@ -0,0 +1,353 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _ChatListManager_instances, _ChatListManager_c, _ChatListManager_sendChatUpdate, _ChatListManager_chats, _ChatListManager_archivedChats, _ChatListManager_chatsLoadedFromStorage, _ChatListManager_getChatList, _ChatListManager_loadChatsFromStorage, _ChatListManager_getLoadedChats, _ChatListManager_pinnedChats, _ChatListManager_pinnedArchiveChats, _ChatListManager_storageHadPinnedChats, _ChatListManager_pinnedChatsLoaded, _ChatListManager_loadPinnedChats, _ChatListManager_fetchPinnedChats, _ChatListManager_getPinnedChats, _ChatListManager_updateOrAddChat, _ChatListManager_removeChat, _ChatListManager_fetchChats;
+import { debug } from "../0_deps.js";
+import { toUnixTimestamp, UNREACHABLE } from "../1_utilities.js";
+import { peerToChatId, types } from "../2_tl.js";
+import { constructChat, constructChat3, constructChat4, getChatOrder } from "../3_types.js";
+import { getChatListId } from "./0_utilities.js";
+const d = debug("ChatListManager");
+export class ChatListManager {
+    constructor(c) {
+        _ChatListManager_instances.add(this);
+        _ChatListManager_c.set(this, void 0);
+        _ChatListManager_chats.set(this, new Map());
+        _ChatListManager_archivedChats.set(this, new Map());
+        _ChatListManager_chatsLoadedFromStorage.set(this, false);
+        _ChatListManager_pinnedChats.set(this, new Array());
+        _ChatListManager_pinnedArchiveChats.set(this, new Array());
+        _ChatListManager_storageHadPinnedChats.set(this, false);
+        _ChatListManager_pinnedChatsLoaded.set(this, false);
+        __classPrivateFieldSet(this, _ChatListManager_c, c, "f");
+    }
+    async reassignChatLastMessage(chatId, add = false, sendUpdate = true) {
+        try {
+            await __classPrivateFieldGet(this, _ChatListManager_c, "f").storage.assertUser("");
+        }
+        catch {
+            return () => Promise.resolve();
+        }
+        const [chat, listId] = this.getChatAnywhere(chatId);
+        if (!chat && !add) {
+            return () => Promise.resolve();
+        }
+        const message_ = await __classPrivateFieldGet(this, _ChatListManager_c, "f").storage.getLastMessage(chatId);
+        if (message_ != null) {
+            const message = await __classPrivateFieldGet(this, _ChatListManager_c, "f").messageManager.constructMessage(message_);
+            if (chat) {
+                chat.order = getChatOrder(message, chat.pinned);
+                chat.lastMessage = message;
+                await __classPrivateFieldGet(this, _ChatListManager_c, "f").storage.setChat(listId, chatId, chat.pinned, message.id, message.date);
+            }
+            else {
+                const pinnedChats = await __classPrivateFieldGet(this, _ChatListManager_instances, "m", _ChatListManager_getPinnedChats).call(this, listId);
+                const chat = await constructChat3(chatId, pinnedChats.indexOf(chatId), message, __classPrivateFieldGet(this, _ChatListManager_c, "f").getEntity);
+                if (chat == null) {
+                    UNREACHABLE();
+                }
+                __classPrivateFieldGet(this, _ChatListManager_chats, "f").set(chatId, chat);
+                await __classPrivateFieldGet(this, _ChatListManager_c, "f").storage.setChat(listId, chatId, chat.pinned, chat.lastMessage?.id ?? 0, chat.lastMessage?.date ?? new Date(0));
+            }
+            if (sendUpdate) {
+                return () => __classPrivateFieldGet(this, _ChatListManager_instances, "m", _ChatListManager_sendChatUpdate).call(this, chatId, !chat);
+            }
+            return () => Promise.resolve();
+        }
+        const message = await __classPrivateFieldGet(this, _ChatListManager_c, "f").messageManager.getHistory(chatId, { limit: 1 }).then((v) => v[0]);
+        if (message) {
+            if (chat) {
+                chat.order = getChatOrder(message, chat.pinned);
+                chat.lastMessage = message;
+                await __classPrivateFieldGet(this, _ChatListManager_c, "f").storage.setChat(listId, chatId, chat.pinned, message.id, message.date);
+            }
+            else {
+                const pinnedChats = await __classPrivateFieldGet(this, _ChatListManager_instances, "m", _ChatListManager_getPinnedChats).call(this, listId);
+                const chat = await constructChat3(chatId, pinnedChats.indexOf(chatId), message, __classPrivateFieldGet(this, _ChatListManager_c, "f").getEntity);
+                if (chat == null) {
+                    UNREACHABLE();
+                }
+                __classPrivateFieldGet(this, _ChatListManager_chats, "f").set(chatId, chat);
+            }
+            if (sendUpdate) {
+                return () => __classPrivateFieldGet(this, _ChatListManager_instances, "m", _ChatListManager_sendChatUpdate).call(this, chatId, !chat);
+            }
+            return () => Promise.resolve();
+        }
+        if (chat) {
+            chat.order = getChatOrder(undefined, chat.pinned);
+            chat.lastMessage = undefined;
+            if (sendUpdate) {
+                return () => __classPrivateFieldGet(this, _ChatListManager_instances, "m", _ChatListManager_sendChatUpdate).call(this, chatId, false);
+            }
+        }
+        return () => Promise.resolve();
+    }
+    tryGetChatId(username) {
+        username = username.toLowerCase();
+        for (const chat of __classPrivateFieldGet(this, _ChatListManager_chats, "f").values()) {
+            if ("username" in chat) {
+                if (chat.username === username || chat.also?.some((v) => v.toLowerCase() === username)) {
+                    return chat.id;
+                }
+            }
+        }
+        for (const chat of __classPrivateFieldGet(this, _ChatListManager_archivedChats, "f").values()) {
+            if ("username" in chat) {
+                if (chat.username === username || chat.also?.some((v) => v.toLowerCase() === username)) {
+                    return chat.id;
+                }
+            }
+        }
+        return null;
+    }
+    getChatAnywhere(chatId) {
+        let chat = __classPrivateFieldGet(this, _ChatListManager_chats, "f").get(chatId);
+        if (chat) {
+            return [chat, 0];
+        }
+        chat = __classPrivateFieldGet(this, _ChatListManager_archivedChats, "f").get(chatId);
+        if (chat) {
+            return [chat, 1];
+        }
+        return [undefined, -1];
+    }
+    async handelUpdateFolderPeers(update) {
+        for (const { peer, folder_id: listId } of update.folder_peers) {
+            const chatId = peerToChatId(peer);
+            const [chat, currentListId] = this.getChatAnywhere(chatId);
+            if (chat !== undefined && listId != currentListId) {
+                __classPrivateFieldGet(this, _ChatListManager_instances, "m", _ChatListManager_getChatList).call(this, currentListId).delete(chatId);
+                __classPrivateFieldGet(this, _ChatListManager_instances, "m", _ChatListManager_getChatList).call(this, listId).set(chatId, chat);
+                await __classPrivateFieldGet(this, _ChatListManager_instances, "m", _ChatListManager_sendChatUpdate).call(this, chatId, true);
+            }
+        }
+    }
+    async handleUpdatePinnedDialogs(update) {
+        const listId = update.folder_id ?? 0;
+        await __classPrivateFieldGet(this, _ChatListManager_instances, "m", _ChatListManager_fetchPinnedChats).call(this, update.folder_id);
+        const chats = __classPrivateFieldGet(this, _ChatListManager_instances, "m", _ChatListManager_getChatList).call(this, listId);
+        const pinnedChats = await __classPrivateFieldGet(this, _ChatListManager_instances, "m", _ChatListManager_getPinnedChats).call(this, listId);
+        for (const [i, chatId] of pinnedChats.entries()) {
+            const chat = chats.get(chatId);
+            if (chat !== undefined) {
+                chat.order = getChatOrder(chat.lastMessage, i);
+                chat.pinned = i;
+                await __classPrivateFieldGet(this, _ChatListManager_instances, "m", _ChatListManager_sendChatUpdate).call(this, chatId, false);
+            }
+        }
+        for (const chat of chats.values()) {
+            if (chat.pinned != -1 && pinnedChats.indexOf(chat.id) == -1) {
+                chat.order = getChatOrder(chat.lastMessage, -1);
+                chat.pinned = -1;
+                await __classPrivateFieldGet(this, _ChatListManager_instances, "m", _ChatListManager_sendChatUpdate).call(this, chat.id, false);
+            }
+        }
+        await __classPrivateFieldGet(this, _ChatListManager_c, "f").storage.setPinnedChats(listId, await __classPrivateFieldGet(this, _ChatListManager_instances, "m", _ChatListManager_getPinnedChats).call(this, listId));
+    }
+    async handleUpdateChannel(update) {
+        const peer = new types.PeerChannel(update);
+        const channel = await __classPrivateFieldGet(this, _ChatListManager_c, "f").getEntity(peer);
+        if (channel != null && "left" in channel && channel.left) {
+            await __classPrivateFieldGet(this, _ChatListManager_instances, "m", _ChatListManager_removeChat).call(this, peerToChatId(peer));
+        }
+        else if (channel instanceof types.ChannelForbidden) {
+            await __classPrivateFieldGet(this, _ChatListManager_instances, "m", _ChatListManager_removeChat).call(this, peerToChatId(peer));
+        }
+        else if (channel instanceof types.Channel) {
+            await __classPrivateFieldGet(this, _ChatListManager_instances, "m", _ChatListManager_updateOrAddChat).call(this, peerToChatId(peer));
+        }
+    }
+    async handleUpdateChat(update) {
+        const peer = new types.PeerChat(update);
+        const chat = await __classPrivateFieldGet(this, _ChatListManager_c, "f").getEntity(peer);
+        if (chat != null && "left" in chat && chat.left) {
+            await __classPrivateFieldGet(this, _ChatListManager_instances, "m", _ChatListManager_removeChat).call(this, peerToChatId(peer));
+        }
+        else if (chat instanceof types.ChatForbidden) {
+            await __classPrivateFieldGet(this, _ChatListManager_instances, "m", _ChatListManager_removeChat).call(this, peerToChatId(peer));
+        }
+        else if (chat instanceof types.Chat) {
+            await __classPrivateFieldGet(this, _ChatListManager_instances, "m", _ChatListManager_updateOrAddChat).call(this, peerToChatId(peer));
+        }
+    }
+    async handleUpdateUser(update) {
+        const peer = new types.PeerUser(update);
+        const chat = await __classPrivateFieldGet(this, _ChatListManager_c, "f").getEntity(peer);
+        if (chat != null) {
+            await __classPrivateFieldGet(this, _ChatListManager_instances, "m", _ChatListManager_updateOrAddChat).call(this, peerToChatId(peer));
+        }
+    }
+    async getChats(from = "main", after, limit = 100) {
+        await __classPrivateFieldGet(this, _ChatListManager_c, "f").storage.assertUser("getChats");
+        if (!__classPrivateFieldGet(this, _ChatListManager_chatsLoadedFromStorage, "f")) {
+            await __classPrivateFieldGet(this, _ChatListManager_instances, "m", _ChatListManager_loadChatsFromStorage).call(this);
+        }
+        if (after && !__classPrivateFieldGet(this, _ChatListManager_chats, "f").get(after.id)) {
+            throw new Error("Invalid after");
+        }
+        if (limit <= 0 || limit > 100) {
+            limit = 100;
+        }
+        const listId = getChatListId(from);
+        let chats = __classPrivateFieldGet(this, _ChatListManager_instances, "m", _ChatListManager_getLoadedChats).call(this, listId);
+        if (after) {
+            chats = chats
+                .filter((v) => v.order < after.order);
+        }
+        if (chats.length < limit) {
+            d("have only %d chats but %d more is needed", chats.length, limit - chats.length);
+            if (!await __classPrivateFieldGet(this, _ChatListManager_c, "f").storage.hasAllChats(listId)) {
+                await __classPrivateFieldGet(this, _ChatListManager_instances, "m", _ChatListManager_fetchChats).call(this, listId, limit, after);
+                return await this.getChats(from, after, limit);
+            }
+        }
+        chats = chats.slice(0, limit);
+        return chats;
+    }
+}
+_ChatListManager_c = new WeakMap(), _ChatListManager_chats = new WeakMap(), _ChatListManager_archivedChats = new WeakMap(), _ChatListManager_chatsLoadedFromStorage = new WeakMap(), _ChatListManager_pinnedChats = new WeakMap(), _ChatListManager_pinnedArchiveChats = new WeakMap(), _ChatListManager_storageHadPinnedChats = new WeakMap(), _ChatListManager_pinnedChatsLoaded = new WeakMap(), _ChatListManager_instances = new WeakSet(), _ChatListManager_sendChatUpdate = async function _ChatListManager_sendChatUpdate(chatId, added) {
+    try {
+        await __classPrivateFieldGet(this, _ChatListManager_c, "f").storage.assertUser("");
+    }
+    catch {
+        return;
+    }
+    const [chat] = this.getChatAnywhere(chatId);
+    const update = chat === undefined ? { deletedChat: { chatId } } : added ? { newChat: chat } : { editedChat: chat };
+    __classPrivateFieldGet(this, _ChatListManager_c, "f").handleUpdate(update);
+}, _ChatListManager_getChatList = function _ChatListManager_getChatList(listId) {
+    switch (listId) {
+        case 0:
+            return __classPrivateFieldGet(this, _ChatListManager_chats, "f");
+        case 1:
+            return __classPrivateFieldGet(this, _ChatListManager_archivedChats, "f");
+        default:
+            throw new Error("Invalid chat list: " + listId);
+    }
+}, _ChatListManager_loadChatsFromStorage = async function _ChatListManager_loadChatsFromStorage() {
+    const chats = await __classPrivateFieldGet(this, _ChatListManager_c, "f").storage.getChats(0);
+    const archivedChats = await __classPrivateFieldGet(this, _ChatListManager_c, "f").storage.getChats(1);
+    for (const { chatId, pinned, topMessageId } of chats) {
+        const chat = await constructChat4(chatId, pinned, topMessageId, __classPrivateFieldGet(this, _ChatListManager_c, "f").getEntity, __classPrivateFieldGet(this, _ChatListManager_c, "f").messageManager.getMessage.bind(__classPrivateFieldGet(this, _ChatListManager_c, "f").messageManager));
+        if (chat == null) {
+            continue;
+        }
+        __classPrivateFieldGet(this, _ChatListManager_chats, "f").set(chat.id, chat);
+    }
+    for (const { chatId, pinned, topMessageId } of archivedChats) {
+        const chat = await constructChat4(chatId, pinned, topMessageId, __classPrivateFieldGet(this, _ChatListManager_c, "f").getEntity, __classPrivateFieldGet(this, _ChatListManager_c, "f").messageManager.getMessage.bind(__classPrivateFieldGet(this, _ChatListManager_c, "f").messageManager));
+        if (chat == null) {
+            continue;
+        }
+        __classPrivateFieldGet(this, _ChatListManager_archivedChats, "f").set(chat.id, chat);
+    }
+    __classPrivateFieldSet(this, _ChatListManager_chatsLoadedFromStorage, true, "f");
+}, _ChatListManager_getLoadedChats = function _ChatListManager_getLoadedChats(listId) {
+    const chats_ = __classPrivateFieldGet(this, _ChatListManager_instances, "m", _ChatListManager_getChatList).call(this, listId);
+    const chats = new Array();
+    for (const chat of chats_.values()) {
+        chats.push(chat);
+    }
+    return chats
+        .sort((a, b) => b.id - a.id)
+        .sort((a, b) => b.order.localeCompare(a.order));
+}, _ChatListManager_loadPinnedChats = async function _ChatListManager_loadPinnedChats() {
+    const [pinnedChats, pinnedArchiveChats] = await Promise.all([__classPrivateFieldGet(this, _ChatListManager_c, "f").storage.getPinnedChats(0), __classPrivateFieldGet(this, _ChatListManager_c, "f").storage.getPinnedChats(1)]);
+    if (pinnedChats != null && pinnedArchiveChats != null) {
+        __classPrivateFieldSet(this, _ChatListManager_pinnedChats, pinnedChats, "f");
+        __classPrivateFieldSet(this, _ChatListManager_pinnedArchiveChats, pinnedArchiveChats, "f");
+        __classPrivateFieldSet(this, _ChatListManager_storageHadPinnedChats, true, "f");
+    }
+    __classPrivateFieldSet(this, _ChatListManager_pinnedChatsLoaded, true, "f");
+}, _ChatListManager_fetchPinnedChats = async function _ChatListManager_fetchPinnedChats(listId = null) {
+    if (listId == null || listId == 0) {
+        const dialogs = await __classPrivateFieldGet(this, _ChatListManager_c, "f").api.messages.getPinnedDialogs({ folder_id: 0 });
+        const pinnedChats = new Array();
+        for (const dialog of dialogs.dialogs) {
+            pinnedChats.push(peerToChatId(dialog.peer));
+        }
+        __classPrivateFieldSet(this, _ChatListManager_pinnedChats, pinnedChats, "f");
+        await __classPrivateFieldGet(this, _ChatListManager_c, "f").storage.setPinnedChats(0, __classPrivateFieldGet(this, _ChatListManager_pinnedChats, "f"));
+    }
+    if (listId == null || listId == 1) {
+        const dialogs = await __classPrivateFieldGet(this, _ChatListManager_c, "f").api.messages.getPinnedDialogs({ folder_id: 1 });
+        const pinnedArchiveChats = new Array();
+        for (const dialog of dialogs.dialogs) {
+            pinnedArchiveChats.push(peerToChatId(dialog.peer));
+        }
+        __classPrivateFieldSet(this, _ChatListManager_pinnedArchiveChats, pinnedArchiveChats, "f");
+        await __classPrivateFieldGet(this, _ChatListManager_c, "f").storage.setPinnedChats(1, __classPrivateFieldGet(this, _ChatListManager_pinnedArchiveChats, "f"));
+    }
+    if (listId != null && listId != 0 && listId != 1) {
+        UNREACHABLE();
+    }
+}, _ChatListManager_getPinnedChats = async function _ChatListManager_getPinnedChats(listId) {
+    if (!__classPrivateFieldGet(this, _ChatListManager_pinnedChatsLoaded, "f")) {
+        await __classPrivateFieldGet(this, _ChatListManager_instances, "m", _ChatListManager_loadPinnedChats).call(this);
+    }
+    if (!__classPrivateFieldGet(this, _ChatListManager_storageHadPinnedChats, "f")) {
+        await __classPrivateFieldGet(this, _ChatListManager_instances, "m", _ChatListManager_fetchPinnedChats).call(this);
+    }
+    switch (listId) {
+        case 0:
+            return __classPrivateFieldGet(this, _ChatListManager_pinnedChats, "f");
+        case 1:
+            return __classPrivateFieldGet(this, _ChatListManager_pinnedArchiveChats, "f");
+        default:
+            UNREACHABLE();
+    }
+}, _ChatListManager_updateOrAddChat = async function _ChatListManager_updateOrAddChat(chatId) {
+    const [chat, listId] = this.getChatAnywhere(chatId);
+    if (chat !== undefined) {
+        const newChat = await constructChat3(chatId, chat.pinned, chat.lastMessage, __classPrivateFieldGet(this, _ChatListManager_c, "f").getEntity);
+        if (newChat != null) {
+            __classPrivateFieldGet(this, _ChatListManager_instances, "m", _ChatListManager_getChatList).call(this, listId).set(chatId, newChat);
+            await __classPrivateFieldGet(this, _ChatListManager_instances, "m", _ChatListManager_sendChatUpdate).call(this, chatId, false);
+        }
+    }
+    else {
+        const chat = await constructChat4(chatId, -1, -1, __classPrivateFieldGet(this, _ChatListManager_c, "f").getEntity, __classPrivateFieldGet(this, _ChatListManager_c, "f").messageManager.getMessage.bind(__classPrivateFieldGet(this, _ChatListManager_c, "f").messageManager));
+        if (chat != null) {
+            __classPrivateFieldGet(this, _ChatListManager_instances, "m", _ChatListManager_getChatList).call(this, 0).set(chatId, chat);
+            await this.reassignChatLastMessage(chatId, false, false);
+            await __classPrivateFieldGet(this, _ChatListManager_instances, "m", _ChatListManager_sendChatUpdate).call(this, chatId, true);
+        }
+    }
+}, _ChatListManager_removeChat = async function _ChatListManager_removeChat(chatId) {
+    const [chat, listId] = this.getChatAnywhere(chatId);
+    if (chat !== undefined) {
+        __classPrivateFieldGet(this, _ChatListManager_instances, "m", _ChatListManager_getChatList).call(this, listId).delete(chatId);
+        await __classPrivateFieldGet(this, _ChatListManager_instances, "m", _ChatListManager_sendChatUpdate).call(this, chatId, false);
+    }
+}, _ChatListManager_fetchChats = async function _ChatListManager_fetchChats(listId, limit, after) {
+    const dialogs = await __classPrivateFieldGet(this, _ChatListManager_c, "f").api.messages.getDialogs({
+        limit,
+        offset_id: after?.lastMessage?.id ?? 0,
+        offset_date: after?.lastMessage?.date ? toUnixTimestamp(after.lastMessage.date) : 0,
+        offset_peer: after ? await __classPrivateFieldGet(this, _ChatListManager_c, "f").getInputPeer(after.id) : new types.InputPeerEmpty(),
+        hash: 0n,
+        folder_id: listId,
+    });
+    const pinnedChats = await __classPrivateFieldGet(this, _ChatListManager_instances, "m", _ChatListManager_getPinnedChats).call(this, listId);
+    if (!(dialogs instanceof types.messages.Dialogs) && !(dialogs instanceof types.messages.DialogsSlice)) {
+        UNREACHABLE();
+    }
+    if (dialogs.dialogs.length < limit) {
+        await __classPrivateFieldGet(this, _ChatListManager_c, "f").storage.setHasAllChats(listId, true);
+    }
+    const chats = __classPrivateFieldGet(this, _ChatListManager_instances, "m", _ChatListManager_getChatList).call(this, listId);
+    for (const dialog of dialogs.dialogs) {
+        const chat = await constructChat(dialog, dialogs, pinnedChats, __classPrivateFieldGet(this, _ChatListManager_c, "f").getEntity, __classPrivateFieldGet(this, _ChatListManager_c, "f").messageManager.getMessage.bind(__classPrivateFieldGet(this, _ChatListManager_c, "f").messageManager), __classPrivateFieldGet(this, _ChatListManager_c, "f").messageManager.getStickerSetName.bind(__classPrivateFieldGet(this, _ChatListManager_c, "f").messageManager));
+        chats.set(chat.id, chat);
+        await __classPrivateFieldGet(this, _ChatListManager_c, "f").storage.setChat(listId, chat.id, chat.pinned, chat.lastMessage?.id ?? 0, chat.lastMessage?.date ?? new Date(0));
+    }
+};

package/esm/client/3_reaction_manager.d.ts

@@ -0,0 +1,16 @@
+import { ID, Reaction } from "../3_types.js";
+import { AddReactionParams, SetReactionsParams } from "./0_params.js";
+import { C as C_ } from "./0_types.js";
+import { MessageManager } from "./2_message_manager.js";
+interface C extends C_ {
+    messageManager: MessageManager;
+}
+export declare class ReactionManager {
+    #private;
+    constructor(c: C);
+    setAvailableReactions(chatId: ID, availableReactions: "none" | "all" | Reaction[]): Promise<void>;
+    setReactions(chatId: number, messageId: number, reactions: Reaction[], params?: SetReactionsParams): Promise<void>;
+    addReaction(chatId: number, messageId: number, reaction: Reaction, params?: AddReactionParams): Promise<void>;
+    removeReaction(chatId: number, messageId: number, reaction: Reaction): Promise<void>;
+}
+export {};

package/esm/client/3_reaction_manager.js

@@ -0,0 +1,61 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _ReactionManager_instances, _ReactionManager_c, _ReactionManager_sendReaction;
+import { UNREACHABLE } from "../1_utilities.js";
+import { types } from "../2_tl.js";
+import { reactionEqual, reactionToTlObject } from "../3_types.js";
+export class ReactionManager {
+    constructor(c) {
+        _ReactionManager_instances.add(this);
+        _ReactionManager_c.set(this, void 0);
+        __classPrivateFieldSet(this, _ReactionManager_c, c, "f");
+    }
+    async setAvailableReactions(chatId, availableReactions) {
+        // TODO: sync with storage
+        await __classPrivateFieldGet(this, _ReactionManager_c, "f").api.messages.setChatAvailableReactions({
+            peer: await __classPrivateFieldGet(this, _ReactionManager_c, "f").getInputPeer(chatId),
+            available_reactions: availableReactions == "none" ? new types.ChatReactionsNone() : availableReactions == "all" ? new types.ChatReactionsAll() : Array.isArray(availableReactions) ? new types.ChatReactionsSome({ reactions: availableReactions.map((v) => v.type == "emoji" ? new types.ReactionEmoji({ emoticon: v.emoji }) : new types.ReactionCustomEmoji({ document_id: BigInt(v.id) })) }) : UNREACHABLE(),
+        });
+    }
+    async setReactions(chatId, messageId, reactions, params) {
+        await __classPrivateFieldGet(this, _ReactionManager_instances, "m", _ReactionManager_sendReaction).call(this, chatId, messageId, reactions, params);
+    }
+    async addReaction(chatId, messageId, reaction, params) {
+        const chosenReactions = await __classPrivateFieldGet(this, _ReactionManager_c, "f").messageManager.getMessage(chatId, messageId).then((v) => v?.reactions ?? []).then((v) => v.filter((v) => v.chosen));
+        for (const r of chosenReactions) {
+            if (reactionEqual(r.reaction, reaction)) {
+                return;
+            }
+        }
+        const reactions = [reaction, ...chosenReactions.map((v) => v.reaction)];
+        await this.setReactions(chatId, messageId, reactions, params);
+    }
+    async removeReaction(chatId, messageId, reaction) {
+        const chosenReactions = await __classPrivateFieldGet(this, _ReactionManager_c, "f").messageManager.getMessage(chatId, messageId).then((v) => v?.reactions ?? []).then((v) => v.filter((v) => v.chosen));
+        for (const r of chosenReactions) {
+            if (reactionEqual(r.reaction, reaction)) {
+                const reactions = chosenReactions.filter((v) => v != r).map((v) => v.reaction);
+                await this.setReactions(chatId, messageId, reactions);
+                break;
+            }
+        }
+    }
+}
+_ReactionManager_c = new WeakMap(), _ReactionManager_instances = new WeakSet(), _ReactionManager_sendReaction = async function _ReactionManager_sendReaction(chatId, messageId, reactions, params) {
+    await __classPrivateFieldGet(this, _ReactionManager_c, "f").api.messages.sendReaction({
+        peer: await __classPrivateFieldGet(this, _ReactionManager_c, "f").getInputPeer(chatId),
+        msg_id: messageId,
+        reaction: reactions.map((v) => reactionToTlObject(v)),
+        big: params?.big ? true : undefined,
+        add_to_recent: params?.addToRecents ? true : undefined,
+    });
+};