@mtkruto/node 0.1.139 → 0.1.141

package/esm/client/1_update_manager.js

@@ -0,0 +1,553 @@
+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 _UpdateManager_instances, _a, _UpdateManager_c, _UpdateManager_updateState, _UpdateManager_updateHandler, _UpdateManager_handleUpdateQueues, _UpdateManager_checkGap, _UpdateManager_checkChannelGap, _UpdateManager_channelUpdateQueues, _UpdateManager_processChannelPtsUpdateInner, _UpdateManager_queueUpdate, _UpdateManager_processChannelPtsUpdate, _UpdateManager_processPtsUpdateInner, _UpdateManager_ptsUpdateQueue, _UpdateManager_processPtsUpdate, _UpdateManager_processUpdatesQueue, _UpdateManager_processUpdates, _UpdateManager_setUpdateStateDate, _UpdateManager_setUpdatePts, _UpdateManager_getLocalState, _UpdateManager_recoverChannelUpdateGap, _UpdateManager_handleUpdatesSet, _UpdateManager_handleStoredUpdates, _UpdateManager_handleUpdate;
+import { debug } from "../0_deps.js";
+import { Queue, UNREACHABLE, ZERO_CHANNEL_ID } from "../1_utilities.js";
+import { as, functions, inputPeerToPeer, peerToChatId, types } from "../2_tl.js";
+import { CHANNEL_DIFFERENCE_LIMIT_BOT, CHANNEL_DIFFERENCE_LIMIT_USER } from "../4_constants.js";
+import { isChannelPtsUpdate, isPtsUpdate } from "./0_utilities.js";
+const d = debug("UpdateManager");
+const dGap = debug("UpdateManager/recoverUpdateGap");
+const dGapC = debug("UpdateManager/recoverChannelUpdateGap");
+export class UpdateManager {
+    constructor(c) {
+        _UpdateManager_instances.add(this);
+        _UpdateManager_c.set(this, void 0);
+        _UpdateManager_updateState.set(this, void 0);
+        _UpdateManager_updateHandler.set(this, void 0);
+        _UpdateManager_handleUpdateQueues.set(this, new Map());
+        _UpdateManager_channelUpdateQueues.set(this, new Map());
+        _UpdateManager_ptsUpdateQueue.set(this, new Queue("ptsUpdate"));
+        _UpdateManager_processUpdatesQueue.set(this, new Queue("UpdateManager/processUpdates"));
+        _UpdateManager_handleUpdatesSet.set(this, new Set());
+        __classPrivateFieldSet(this, _UpdateManager_c, c, "f");
+    }
+    async fetchState(source) {
+        const state = await __classPrivateFieldGet(this, _UpdateManager_c, "f").api.updates.getState();
+        __classPrivateFieldSet(this, _UpdateManager_updateState, state, "f");
+        d("state fetched [%s]", source);
+    }
+    async processChats(chats) {
+        for (const chat of chats) {
+            if (chat instanceof types.Channel && chat.access_hash) {
+                await __classPrivateFieldGet(this, _UpdateManager_c, "f").storage.setEntity(chat);
+                await __classPrivateFieldGet(this, _UpdateManager_c, "f").storage.setChannelAccessHash(chat.id, chat.access_hash);
+                if (chat.username) {
+                    await __classPrivateFieldGet(this, _UpdateManager_c, "f").storage.updateUsernames("channel", chat.id, [chat.username]);
+                }
+                if (chat.usernames) {
+                    await __classPrivateFieldGet(this, _UpdateManager_c, "f").storage.updateUsernames("channel", chat.id, chat.usernames.map((v) => v.username));
+                }
+            }
+            else if (chat instanceof types.Chat) {
+                await __classPrivateFieldGet(this, _UpdateManager_c, "f").storage.setEntity(chat);
+            }
+            else if (chat instanceof types.ChannelForbidden || chat instanceof types.ChatForbidden) {
+                await __classPrivateFieldGet(this, _UpdateManager_c, "f").storage.removeEntity(chat);
+            }
+        }
+    }
+    async processResult(result) {
+        if (result instanceof types.messages.Dialogs ||
+            result instanceof types.messages.DialogsSlice ||
+            result instanceof types.messages.Messages ||
+            result instanceof types.messages.MessagesSlice ||
+            result instanceof types.messages.ChannelMessages ||
+            result instanceof types.messages.ChatFull ||
+            result instanceof types.contacts.Found ||
+            result instanceof types.account.PrivacyRules ||
+            result instanceof types.contacts.ResolvedPeer ||
+            result instanceof types.channels.ChannelParticipants ||
+            result instanceof types.channels.ChannelParticipant ||
+            result instanceof types.messages.PeerDialogs ||
+            result instanceof types.contacts.TopPeers ||
+            result instanceof types.channels.AdminLogResults ||
+            result instanceof types.help.RecentMeUrls ||
+            result instanceof types.messages.InactiveChats ||
+            result instanceof types.help.PromoData ||
+            result instanceof types.messages.MessageViews ||
+            result instanceof types.messages.DiscussionMessage ||
+            result instanceof types.phone.GroupCall ||
+            result instanceof types.phone.GroupParticipants ||
+            result instanceof types.phone.JoinAsPeers ||
+            result instanceof types.messages.SponsoredMessages ||
+            result instanceof types.messages.SearchResultsCalendar ||
+            result instanceof types.channels.SendAsPeers ||
+            result instanceof types.users.UserFull ||
+            result instanceof types.messages.PeerSettings ||
+            result instanceof types.messages.MessageReactionsList ||
+            result instanceof types.messages.ForumTopics ||
+            result instanceof types.account.AutoSaveSettings ||
+            result instanceof types.chatlists.ExportedInvites ||
+            result instanceof types.chatlists.ChatlistInviteAlready ||
+            result instanceof types.chatlists.ChatlistInvite ||
+            result instanceof types.chatlists.ChatlistUpdates ||
+            result instanceof types.messages.Chats ||
+            result instanceof types.messages.ChatsSlice) {
+            await this.processChats(result.chats);
+            if ("users" in result) {
+                await this.processUsers(result.users);
+            }
+            if ("messages" in result) {
+                for (const message of result.messages) {
+                    if (message instanceof types.Message || message instanceof types.MessageService) {
+                        await __classPrivateFieldGet(this, _UpdateManager_c, "f").storage.setMessage(peerToChatId(message.peer_id), message.id, message);
+                    }
+                }
+            }
+        }
+        if (result instanceof types.messages.Messages) {
+            for (const message of result.messages) {
+                if (message instanceof types.Message || message instanceof types.MessageService) {
+                    await __classPrivateFieldGet(this, _UpdateManager_c, "f").storage.setMessage(peerToChatId(message.peer_id), message.id, message);
+                }
+            }
+        }
+    }
+    async processUsers(users) {
+        for (const user of users) {
+            if (user instanceof types.User && user.access_hash) {
+                await __classPrivateFieldGet(this, _UpdateManager_c, "f").storage.setEntity(user);
+                await __classPrivateFieldGet(this, _UpdateManager_c, "f").storage.setUserAccessHash(user.id, user.access_hash);
+                if (user.username) {
+                    await __classPrivateFieldGet(this, _UpdateManager_c, "f").storage.updateUsernames("user", user.id, [user.username]);
+                }
+                if (user.usernames) {
+                    await __classPrivateFieldGet(this, _UpdateManager_c, "f").storage.updateUsernames("user", user.id, user.usernames.map((v) => v.username));
+                }
+            }
+        }
+    }
+    getHandleUpdateQueue(boxId) {
+        let queue = __classPrivateFieldGet(this, _UpdateManager_handleUpdateQueues, "f").get(boxId);
+        if (queue !== undefined) {
+            return queue;
+        }
+        else {
+            queue = new Queue(`handleUpdate-${boxId}`);
+            return queue;
+        }
+    }
+    processUpdates(updates, checkGap, call = null, callback) {
+        __classPrivateFieldGet(this, _UpdateManager_processUpdatesQueue, "f").add(() => __classPrivateFieldGet(this, _UpdateManager_instances, "m", _UpdateManager_processUpdates).call(this, updates, checkGap, call).then(callback));
+    }
+    async recoverUpdateGap(source) {
+        dGap("recovering from update gap [%s]", source);
+        __classPrivateFieldGet(this, _UpdateManager_c, "f").setConnectionState("updating");
+        try {
+            let state = await __classPrivateFieldGet(this, _UpdateManager_instances, "m", _UpdateManager_getLocalState).call(this);
+            while (true) {
+                const difference = await __classPrivateFieldGet(this, _UpdateManager_c, "f").api.updates.getDifference({ pts: state.pts, date: state.date, qts: state.qts ?? 0 });
+                if (difference instanceof types.updates.Difference || difference instanceof types.updates.DifferenceSlice) {
+                    await this.processChats(difference.chats);
+                    await this.processUsers(difference.users);
+                    for (const message of difference.new_messages) {
+                        await __classPrivateFieldGet(this, _UpdateManager_instances, "m", _UpdateManager_processUpdates).call(this, new types.UpdateNewMessage({ message, pts: 0, pts_count: 0 }), false);
+                    }
+                    for (const update of difference.other_updates) {
+                        await __classPrivateFieldGet(this, _UpdateManager_instances, "m", _UpdateManager_processUpdates).call(this, update, false);
+                    }
+                    if (difference instanceof types.updates.Difference) {
+                        await __classPrivateFieldGet(this, _UpdateManager_c, "f").storage.setState(difference.state);
+                        dGap("recovered from update gap");
+                        break;
+                    }
+                    else if (difference instanceof types.updates.DifferenceSlice) {
+                        state = difference.intermediate_state;
+                    }
+                    else {
+                        UNREACHABLE();
+                    }
+                }
+                else if (difference instanceof types.updates.DifferenceTooLong) {
+                    await __classPrivateFieldGet(this, _UpdateManager_c, "f").storage.deleteMessages();
+                    await __classPrivateFieldGet(this, _UpdateManager_c, "f").storage.removeChats(0);
+                    await __classPrivateFieldGet(this, _UpdateManager_c, "f").storage.removeChats(1);
+                    state.pts = difference.pts;
+                    dGap("received differenceTooLong");
+                }
+                else if (difference instanceof types.updates.DifferenceEmpty) {
+                    await __classPrivateFieldGet(this, _UpdateManager_instances, "m", _UpdateManager_setUpdateStateDate).call(this, difference.date);
+                    dGap("there was no update gap");
+                    break;
+                }
+                else {
+                    UNREACHABLE();
+                }
+            }
+        }
+        finally {
+            __classPrivateFieldGet(this, _UpdateManager_c, "f").resetConnectionState();
+        }
+    }
+    setUpdateHandler(handler) {
+        __classPrivateFieldSet(this, _UpdateManager_updateHandler, handler, "f");
+    }
+}
+_a = UpdateManager, _UpdateManager_c = new WeakMap(), _UpdateManager_updateState = new WeakMap(), _UpdateManager_updateHandler = new WeakMap(), _UpdateManager_handleUpdateQueues = new WeakMap(), _UpdateManager_channelUpdateQueues = new WeakMap(), _UpdateManager_ptsUpdateQueue = new WeakMap(), _UpdateManager_processUpdatesQueue = new WeakMap(), _UpdateManager_handleUpdatesSet = new WeakMap(), _UpdateManager_instances = new WeakSet(), _UpdateManager_checkGap = async function _UpdateManager_checkGap(pts, ptsCount) {
+    const localState = await __classPrivateFieldGet(this, _UpdateManager_instances, "m", _UpdateManager_getLocalState).call(this);
+    if (localState.pts + ptsCount < pts) {
+        await this.recoverUpdateGap("processUpdates");
+    }
+}, _UpdateManager_checkChannelGap = async function _UpdateManager_checkChannelGap(channelId, pts, ptsCount) {
+    let localPts = await __classPrivateFieldGet(this, _UpdateManager_c, "f").storage.getChannelPts(channelId);
+    if (!localPts) {
+        localPts = pts - ptsCount;
+    }
+    if (localPts + ptsCount < pts) {
+        await __classPrivateFieldGet(this, _UpdateManager_instances, "m", _UpdateManager_recoverChannelUpdateGap).call(this, channelId, "processUpdates");
+    }
+}, _UpdateManager_processChannelPtsUpdateInner = async function _UpdateManager_processChannelPtsUpdateInner(update, checkGap) {
+    const channelId = update instanceof types.UpdateNewChannelMessage || update instanceof types.UpdateEditChannelMessage ? update.message.peer_id[as](types.PeerChannel).channel_id : update.channel_id;
+    if (update instanceof types.UpdateChannelTooLong) {
+        if (update.pts != undefined) {
+            await __classPrivateFieldGet(this, _UpdateManager_c, "f").storage.setChannelPts(channelId, update.pts);
+        }
+        await __classPrivateFieldGet(this, _UpdateManager_instances, "m", _UpdateManager_recoverChannelUpdateGap).call(this, channelId, "updateChannelTooLong");
+        return;
+    }
+    if (update.pts != 0) {
+        const ptsCount = update.pts_count;
+        if (checkGap) {
+            await __classPrivateFieldGet(this, _UpdateManager_instances, "m", _UpdateManager_checkChannelGap).call(this, channelId, update.pts, ptsCount);
+        }
+        let currentPts = await __classPrivateFieldGet(this, _UpdateManager_c, "f").storage.getChannelPts(channelId);
+        currentPts ??= update.pts - ptsCount;
+        if (currentPts + ptsCount > update.pts) {
+            return;
+        }
+    }
+    if (__classPrivateFieldGet(this, _UpdateManager_c, "f").guaranteeUpdateDelivery) {
+        await __classPrivateFieldGet(this, _UpdateManager_c, "f").storage.setUpdate(channelId, update);
+    }
+    if (update.pts != 0) {
+        await __classPrivateFieldGet(this, _UpdateManager_c, "f").storage.setChannelPts(channelId, update.pts);
+    }
+    __classPrivateFieldGet(this, _UpdateManager_instances, "m", _UpdateManager_queueUpdate).call(this, update, channelId, true);
+}, _UpdateManager_queueUpdate = function _UpdateManager_queueUpdate(update, boxId, pts) {
+    this.getHandleUpdateQueue(boxId).add(async () => {
+        if (__classPrivateFieldGet(this, _UpdateManager_c, "f").guaranteeUpdateDelivery && pts) {
+            await __classPrivateFieldGet(this, _UpdateManager_instances, "m", _UpdateManager_handleStoredUpdates).call(this, boxId);
+        }
+        else {
+            await __classPrivateFieldGet(this, _UpdateManager_instances, "m", _UpdateManager_handleUpdate).call(this, update);
+        }
+    });
+}, _UpdateManager_processChannelPtsUpdate = function _UpdateManager_processChannelPtsUpdate(update, checkGap) {
+    const channelId = update instanceof types.UpdateNewChannelMessage || update instanceof types.UpdateEditChannelMessage ? update.message.peer_id[as](types.PeerChannel).channel_id : update.channel_id;
+    let queue = __classPrivateFieldGet(this, _UpdateManager_channelUpdateQueues, "f").get(channelId);
+    if (queue == undefined) {
+        queue = new Queue(`channelUpdates-${channelId}`);
+        __classPrivateFieldGet(this, _UpdateManager_channelUpdateQueues, "f").set(channelId, queue);
+    }
+    queue.add(async () => {
+        await __classPrivateFieldGet(this, _UpdateManager_instances, "m", _UpdateManager_processChannelPtsUpdateInner).call(this, update, checkGap);
+    });
+}, _UpdateManager_processPtsUpdateInner = async function _UpdateManager_processPtsUpdateInner(update, checkGap) {
+    const localState = await __classPrivateFieldGet(this, _UpdateManager_instances, "m", _UpdateManager_getLocalState).call(this);
+    if (update.pts != 0) {
+        if (checkGap) {
+            await __classPrivateFieldGet(this, _UpdateManager_instances, "m", _UpdateManager_checkGap).call(this, update.pts, update.pts_count);
+        }
+        if (localState.pts + update.pts_count > update.pts) {
+            return;
+        }
+    }
+    if (__classPrivateFieldGet(this, _UpdateManager_c, "f").guaranteeUpdateDelivery) {
+        await __classPrivateFieldGet(this, _UpdateManager_c, "f").storage.setUpdate(_a.MAIN_BOX_ID, update);
+    }
+    if (update.pts != 0) {
+        await __classPrivateFieldGet(this, _UpdateManager_instances, "m", _UpdateManager_setUpdatePts).call(this, update.pts);
+    }
+    __classPrivateFieldGet(this, _UpdateManager_instances, "m", _UpdateManager_queueUpdate).call(this, update, 0n, true);
+}, _UpdateManager_processPtsUpdate = function _UpdateManager_processPtsUpdate(update, checkGap) {
+    __classPrivateFieldGet(this, _UpdateManager_ptsUpdateQueue, "f").add(async () => {
+        await __classPrivateFieldGet(this, _UpdateManager_instances, "m", _UpdateManager_processPtsUpdateInner).call(this, update, checkGap);
+    });
+}, _UpdateManager_processUpdates = async function _UpdateManager_processUpdates(updates_, checkGap, call = null) {
+    /// First, individual updates (Update[1]) are extracted from Updates.[2]
+    ///
+    /// If an updatesTooLong[3] was received, an update gap recovery is initiated and no further action will be taken.
+    ///
+    /// [1]: https://core.telegram.org/type/Update
+    /// [2]: https://core.telegram.org/type/Updates
+    /// [3]: https://core.telegram.org/constructor/updatesTooLong
+    let updates;
+    if (updates_ instanceof types.UpdatesCombined || updates_ instanceof types.Updates) {
+        updates = updates_.updates;
+        const seq = updates_.seq;
+        const seqStart = "seq_start" in updates_ ? updates_.seq_start : updates_.seq;
+        if (checkGap) {
+            if (seqStart == 0) {
+                checkGap = false;
+                d("seqStart=0");
+            }
+            else {
+                const localState = await __classPrivateFieldGet(this, _UpdateManager_instances, "m", _UpdateManager_getLocalState).call(this);
+                const localSeq = localState.seq;
+                if (localSeq + 1 == seqStart) {
+                    // The update sequence can be applied.
+                    localState.seq = seq;
+                    localState.date = updates_.date;
+                    await __classPrivateFieldGet(this, _UpdateManager_instances, "m", _UpdateManager_setUpdateStateDate).call(this, updates_.date);
+                    await __classPrivateFieldGet(this, _UpdateManager_c, "f").storage.setState(localState);
+                }
+                else if (localSeq + 1 > seqStart) {
+                    // The update sequence was already applied, and must be ignored.
+                    d("localSeq + 1 > seqStart");
+                    return;
+                }
+                else if (localSeq + 1 < seqStart) {
+                    // There's an updates gap that must be filled.
+                    await this.recoverUpdateGap("localSeq + 1 < seqStart");
+                }
+            }
+        }
+    }
+    else if (updates_ instanceof types.UpdateShort) {
+        updates = [updates_.update];
+    }
+    else if (updates_ instanceof types.UpdateShortMessage) {
+        updates = [
+            new types.UpdateNewMessage({
+                message: new types.Message({
+                    out: updates_.out,
+                    mentioned: updates_.mentioned,
+                    media_unread: updates_.media_unread,
+                    silent: updates_.silent,
+                    id: updates_.id,
+                    from_id: updates_.out ? new types.PeerUser({ user_id: await __classPrivateFieldGet(this, _UpdateManager_c, "f").getSelfId().then(BigInt) }) : new types.PeerUser({ user_id: updates_.user_id }),
+                    peer_id: new types.PeerUser({ user_id: updates_.user_id }),
+                    message: updates_.message,
+                    date: updates_.date,
+                    fwd_from: updates_.fwd_from,
+                    via_bot_id: updates_.via_bot_id,
+                    reply_to: updates_.reply_to,
+                    entities: updates_.entities,
+                    ttl_period: updates_.ttl_period,
+                }),
+                pts: updates_.pts,
+                pts_count: updates_.pts_count,
+            }),
+        ];
+    }
+    else if (updates_ instanceof types.UpdateShortChatMessage) {
+        updates = [
+            new types.UpdateNewMessage({
+                message: new types.Message({
+                    out: updates_.out,
+                    mentioned: updates_.mentioned,
+                    media_unread: updates_.media_unread,
+                    silent: updates_.silent,
+                    id: updates_.id,
+                    from_id: new types.PeerUser({ user_id: updates_.from_id }),
+                    peer_id: new types.PeerChat({ chat_id: updates_.chat_id }),
+                    fwd_from: updates_.fwd_from,
+                    via_bot_id: updates_.via_bot_id,
+                    reply_to: updates_.reply_to,
+                    date: updates_.date,
+                    message: updates_.message,
+                    entities: updates_.entities,
+                    ttl_period: updates_.ttl_period,
+                }),
+                pts: updates_.pts,
+                pts_count: updates_.pts_count,
+            }),
+        ];
+    }
+    else if (updates_ instanceof types.UpdateShortSentMessage) {
+        if (!(call instanceof functions.messages.sendMessage)) {
+            UNREACHABLE();
+        }
+        updates = [
+            new types.UpdateNewMessage({
+                message: new types.Message({
+                    out: updates_.out,
+                    silent: call.silent,
+                    id: updates_.id,
+                    from_id: new types.PeerUser({ user_id: await __classPrivateFieldGet(this, _UpdateManager_c, "f").getSelfId().then(BigInt) }),
+                    peer_id: inputPeerToPeer(call.peer),
+                    message: call.message,
+                    media: updates_.media,
+                    date: updates_.date,
+                    // reply_to: call.reply_to, // TODO?
+                    entities: updates_.entities,
+                    ttl_period: updates_.ttl_period,
+                }),
+                pts: updates_.pts,
+                pts_count: updates_.pts_count,
+            }),
+        ];
+    }
+    else if (updates_ instanceof types.UpdatesTooLong) {
+        await this.recoverUpdateGap("updatesTooLong");
+        return;
+    }
+    else if (updates_ instanceof types._Update) {
+        updates = [updates_];
+    }
+    else {
+        UNREACHABLE();
+    }
+    /// We process the updates when we are sure there is no gap.
+    if (updates_ instanceof types.Updates || updates_ instanceof types.UpdatesCombined) {
+        await this.processChats(updates_.chats);
+        await this.processUsers(updates_.users);
+        await __classPrivateFieldGet(this, _UpdateManager_instances, "m", _UpdateManager_setUpdateStateDate).call(this, updates_.date);
+    }
+    else if (updates_ instanceof types.UpdateShort ||
+        updates_ instanceof types.UpdateShortMessage ||
+        updates_ instanceof types.UpdateShortChatMessage ||
+        updates_ instanceof types.UpdateShortSentMessage) {
+        await __classPrivateFieldGet(this, _UpdateManager_instances, "m", _UpdateManager_setUpdateStateDate).call(this, updates_.date);
+    }
+    for (const update of updates) {
+        if (update instanceof types.UpdatePtsChanged) {
+            await this.fetchState("updatePtsChanged");
+            if (__classPrivateFieldGet(this, _UpdateManager_updateState, "f")) {
+                await __classPrivateFieldGet(this, _UpdateManager_c, "f").storage.setState(__classPrivateFieldGet(this, _UpdateManager_updateState, "f"));
+            }
+            else {
+                UNREACHABLE();
+            }
+        }
+        else if (isPtsUpdate(update)) {
+            __classPrivateFieldGet(this, _UpdateManager_instances, "m", _UpdateManager_processPtsUpdate).call(this, update, checkGap);
+        }
+        else if (isChannelPtsUpdate(update)) {
+            __classPrivateFieldGet(this, _UpdateManager_instances, "m", _UpdateManager_processChannelPtsUpdate).call(this, update, checkGap);
+        }
+        else {
+            __classPrivateFieldGet(this, _UpdateManager_instances, "m", _UpdateManager_queueUpdate).call(this, update, 0n, false);
+        }
+    }
+}, _UpdateManager_setUpdateStateDate = async function _UpdateManager_setUpdateStateDate(date) {
+    const localState = await __classPrivateFieldGet(this, _UpdateManager_instances, "m", _UpdateManager_getLocalState).call(this);
+    localState.date = date;
+    await __classPrivateFieldGet(this, _UpdateManager_c, "f").storage.setState(localState);
+}, _UpdateManager_setUpdatePts = async function _UpdateManager_setUpdatePts(pts) {
+    const localState = await __classPrivateFieldGet(this, _UpdateManager_instances, "m", _UpdateManager_getLocalState).call(this);
+    localState.pts = pts;
+    await __classPrivateFieldGet(this, _UpdateManager_c, "f").storage.setState(localState);
+}, _UpdateManager_getLocalState = async function _UpdateManager_getLocalState() {
+    let localState = await __classPrivateFieldGet(this, _UpdateManager_c, "f").storage.getState();
+    if (!localState) {
+        if (__classPrivateFieldGet(this, _UpdateManager_updateState, "f")) {
+            localState = __classPrivateFieldGet(this, _UpdateManager_updateState, "f");
+            await __classPrivateFieldGet(this, _UpdateManager_c, "f").storage.setState(localState);
+        }
+        else {
+            await this.fetchState("getLocalState");
+            if (__classPrivateFieldGet(this, _UpdateManager_updateState, "f")) {
+                localState = __classPrivateFieldGet(this, _UpdateManager_updateState, "f");
+                await __classPrivateFieldGet(this, _UpdateManager_c, "f").storage.setState(localState);
+            }
+            else {
+                UNREACHABLE();
+            }
+        }
+    }
+    return localState;
+}, _UpdateManager_recoverChannelUpdateGap = async function _UpdateManager_recoverChannelUpdateGap(channelId, source) {
+    dGapC("recovering channel update gap [%o, %s]", channelId, source);
+    const pts_ = await __classPrivateFieldGet(this, _UpdateManager_c, "f").storage.getChannelPts(channelId);
+    let pts = pts_ == null ? 1 : pts_;
+    while (true) {
+        const { access_hash } = await __classPrivateFieldGet(this, _UpdateManager_c, "f").getInputPeer(ZERO_CHANNEL_ID + -Number(channelId)).then((v) => v[as](types.InputPeerChannel));
+        const difference = await __classPrivateFieldGet(this, _UpdateManager_c, "f").api.updates.getChannelDifference({
+            pts,
+            channel: new types.InputChannel({ channel_id: channelId, access_hash }),
+            filter: new types.ChannelMessagesFilterEmpty(),
+            limit: await __classPrivateFieldGet(this, _UpdateManager_c, "f").storage.getAccountType() == "user" ? CHANNEL_DIFFERENCE_LIMIT_USER : CHANNEL_DIFFERENCE_LIMIT_BOT,
+        });
+        if (difference instanceof types.updates.ChannelDifference) {
+            await this.processChats(difference.chats);
+            await this.processUsers(difference.users);
+            for (const message of difference.new_messages) {
+                await __classPrivateFieldGet(this, _UpdateManager_instances, "m", _UpdateManager_processUpdates).call(this, new types.UpdateNewChannelMessage({ message, pts: 0, pts_count: 0 }), false);
+            }
+            for (const update of difference.other_updates) {
+                await __classPrivateFieldGet(this, _UpdateManager_instances, "m", _UpdateManager_processUpdates).call(this, update, false);
+            }
+            await __classPrivateFieldGet(this, _UpdateManager_c, "f").storage.setChannelPts(channelId, difference.pts);
+            dGapC("recovered from update gap [%o, %s]", channelId, source);
+            break;
+        }
+        else if (difference instanceof types.updates.ChannelDifferenceTooLong) {
+            // TODO: invalidate messages
+            dGapC("received channelDifferenceTooLong");
+            await this.processChats(difference.chats);
+            await this.processUsers(difference.users);
+            for (const message of difference.messages) {
+                await __classPrivateFieldGet(this, _UpdateManager_instances, "m", _UpdateManager_processUpdates).call(this, new types.UpdateNewChannelMessage({ message, pts: 0, pts_count: 0 }), false);
+            }
+            const pts_ = difference.dialog[as](types.Dialog).pts;
+            if (pts_ != undefined) {
+                pts = pts_;
+            }
+            else {
+                UNREACHABLE();
+            }
+            dGapC("processed channelDifferenceTooLong");
+        }
+        else if (difference instanceof types.updates.ChannelDifferenceEmpty) {
+            dGapC("there was no update gap");
+            break;
+        }
+    }
+}, _UpdateManager_handleStoredUpdates = async function _UpdateManager_handleStoredUpdates(boxId) {
+    if (__classPrivateFieldGet(this, _UpdateManager_handleUpdatesSet, "f").has(boxId)) {
+        return;
+    }
+    __classPrivateFieldGet(this, _UpdateManager_handleUpdatesSet, "f").add(boxId);
+    do {
+        const maybeUpdate = await __classPrivateFieldGet(this, _UpdateManager_c, "f").storage.getFirstUpdate(boxId);
+        if (maybeUpdate == null) {
+            break;
+        }
+        const [key, update] = maybeUpdate;
+        for (let i = 0; i < 100; ++i) {
+            try {
+                const handle = await __classPrivateFieldGet(this, _UpdateManager_instances, "m", _UpdateManager_handleUpdate).call(this, update);
+                handle: for (let i = 0; i < 2; ++i) {
+                    try {
+                        await handle();
+                        break handle;
+                    }
+                    catch {
+                        continue handle;
+                    }
+                }
+                break;
+            }
+            catch (err) {
+                d("#handleUpdate error: %o", err);
+            }
+        }
+        await __classPrivateFieldGet(this, _UpdateManager_c, "f").storage.set(key, null);
+    } while (true);
+    __classPrivateFieldGet(this, _UpdateManager_handleUpdatesSet, "f").delete(boxId);
+}, _UpdateManager_handleUpdate = async function _UpdateManager_handleUpdate(update) {
+    const handler = __classPrivateFieldGet(this, _UpdateManager_updateHandler, "f");
+    if (handler) {
+        return await handler(update);
+    }
+    else {
+        return () => Promise.resolve();
+    }
+};
+Object.defineProperty(UpdateManager, "MAIN_BOX_ID", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: 0n
+});

package/esm/client/2_message_manager.d.ts

@@ -0,0 +1,40 @@
+import { enums, types } from "../2_tl.js";
+import { FileSource, ID, Message } from "../3_types.js";
+import { DeleteMessagesParams, EditMessageParams, EditMessageReplyMarkupParams, ForwardMessagesParams, GetHistoryParams, PinMessageParams, SendAnimationParams, SendAudioParams, SendContactParams, SendDiceParams, SendDocumentParams, SendLocationParams, SendMessageParams, SendPhotoParams, SendPollParams, SendVenueParams, SendVideoNoteParams, SendVideoParams, SendVoiceParams } from "./0_params.js";
+import { C as C_ } from "./0_types.js";
+import { FileManager } from "./1_file_manager.js";
+interface C extends C_ {
+    fileManager: FileManager;
+}
+export declare class MessageManager {
+    #private;
+    constructor(c: C);
+    getMessages(chatId: ID, messageIds: number[]): Promise<Message[]>;
+    getMessageWithReply(chatId: ID, messageId: number): Promise<Message>;
+    getMessage(chatId: ID, messageId: number): Promise<Message>;
+    getStickerSetName(inputStickerSet: types.InputStickerSetID, hash?: number): Promise<string>;
+    constructMessage(message_: enums.Message, r?: boolean): Promise<Message>;
+    forwardMessages(from: ID, to: ID, messageIds: number[], params?: ForwardMessagesParams): Promise<Message[]>;
+    getHistory(chatId: ID, params?: GetHistoryParams): Promise<Message[]>;
+    sendMessage(chatId: ID, text: string, params?: SendMessageParams): Promise<import("../3_types.js").MessageText>;
+    sendVenue(chatId: ID, latitude: number, longitude: number, title: string, address: string, params?: SendVenueParams): Promise<import("../3_types.js").MessageVenue>;
+    sendContact(chatId: ID, firstName: string, number: string, params?: SendContactParams): Promise<import("../3_types.js").MessageContact>;
+    sendDice(chatId: ID, params?: SendDiceParams): Promise<import("../3_types.js").MessageDice>;
+    sendLocation(chatId: ID, latitude: number, longitude: number, params?: SendLocationParams): Promise<import("../3_types.js").MessageLocation>;
+    sendVideoNote(chatId: ID, audio: FileSource, params?: SendVideoNoteParams): Promise<import("../3_types.js").MessageVideoNote>;
+    sendAudio(chatId: ID, audio: FileSource, params?: SendAudioParams): Promise<import("../3_types.js").MessageAudio>;
+    sendVoice(chatId: ID, voice: FileSource, params?: SendVoiceParams): Promise<import("../3_types.js").MessageVoice>;
+    sendAnimation(chatId: ID, animation: FileSource, params?: SendAnimationParams): Promise<import("../3_types.js").MessageAnimation>;
+    sendVideo(chatId: ID, video: FileSource, params?: SendVideoParams): Promise<import("../3_types.js").MessageVideo>;
+    sendDocument(chatId: ID, document: FileSource, params?: SendDocumentParams): Promise<import("../3_types.js").MessageDocument>;
+    sendPhoto(chatId: ID, photo: FileSource, params?: SendPhotoParams): Promise<import("../3_types.js").MessagePhoto>;
+    sendPoll(chatId: ID, question: string, options: [string, string, ...string[]], params?: SendPollParams): Promise<import("../3_types.js").MessagePoll>;
+    editMessageReplyMarkup(chatId: ID, messageId: number, params?: EditMessageReplyMarkupParams): Promise<import("../3_types.js").MessageText | import("../3_types.js").MessagePhoto | import("../3_types.js").MessageDocument | import("../3_types.js").MessageVideo | import("../3_types.js").MessageSticker | import("../3_types.js").MessageAnimation | import("../3_types.js").MessageVoice | import("../3_types.js").MessageAudio | import("../3_types.js").MessageDice | import("../3_types.js").MessageVideoNote | import("../3_types.js").MessageContact | import("../3_types.js").MessageGame | import("../3_types.js").MessagePoll | import("../3_types.js").MessageVenue | import("../3_types.js").MessageLocation | import("../3_types.js").MessageNewChatMembers | import("../3_types.js").MessageLeftChatMember | import("../3_types.js").MessageNewChatTitle | import("../3_types.js").MessageNewChatPhoto | import("../3_types.js").MessageDeletedChatPhoto | import("../3_types.js").MessageGroupCreated | import("../3_types.js").MessageSupergroupCreated | import("../3_types.js").MessageChannelCreated | import("../3_types.js").MessageAutoDeleteTimerChanged | import("../3_types.js").MessageChatMigratedTo | import("../3_types.js").MessageChatMigratedFrom | import("../3_types.js").MessagePinnedMessage | import("../3_types.js").MessageUserShared | import("../3_types.js").MessageWriteAccessAllowed | import("../3_types.js").MessageForumTopicCreated | import("../3_types.js").MessageForumTopicEdited | import("../3_types.js").MessageForumTopicClosed | import("../3_types.js").MessageForumTopicReopened | import("../3_types.js").MessageVideoChatScheduled | import("../3_types.js").MessageVideoChatStarted | import("../3_types.js").MessageVideoChatEnded | import("../3_types.js").MessageGiveaway | import("../3_types.js").MessageUnsupported>;
+    editMessageText(chatId: ID, messageId: number, text: string, params?: EditMessageParams): Promise<import("../3_types.js").MessageText>;
+    deleteMessages(chatId: ID, messageIds: number[], params?: DeleteMessagesParams): Promise<void>;
+    deleteChatMemberMessages(chatId: ID, memberId: ID): Promise<void>;
+    pinMessage(chatId: ID, messageId: number, params?: PinMessageParams): Promise<void>;
+    unpinMessage(chatId: ID, messageId: number): Promise<void>;
+    unpinMessages(chatId: ID): Promise<void>;
+}
+export {};