@mtcute/core 0.5.0 → 0.7.0

package/cjs/highlevel/types/calls/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../src/highlevel/types/calls/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,sDAAmC","sourcesContent":["export * from './discard-reason.js'\n"]}

package/cjs/highlevel/types/conversation.d.ts

@@ -0,0 +1,210 @@
+import { tl } from '@mtcute/tl';
+import { MaybePromise } from '../../types/utils.js';
+import { ITelegramClient } from '../client.types.js';
+import { sendMedia } from '../methods/messages/send-media.js';
+import { sendMediaGroup } from '../methods/messages/send-media-group.js';
+import { sendText } from '../methods/messages/send-text.js';
+import type { Message } from './messages/message.js';
+import type { InputPeerLike } from './peers/index.js';
+import type { ParsedUpdate } from './updates/index.js';
+import { ParametersSkip2 } from './utils.js';
+/**
+ * Represents a conversation inside some chat.
+ *
+ * A conversation keeps track of any messages sent or edited
+ * since it was started and until it was stopped,
+ * and allows waiting for events in it.
+ *
+ * If you need a conversation across multiple chats,
+ * you should use multiple {@link Conversation} objects
+ * and synchronize them manually.
+ */
+export declare class Conversation {
+    readonly client: ITelegramClient;
+    readonly chat: InputPeerLike;
+    private _inputPeer;
+    private _chatId;
+    private _started;
+    private _lastMessage;
+    private _lastReceivedMessage;
+    private _queuedNewMessage;
+    private _pendingNewMessages;
+    private _lock;
+    private _pendingEditMessage;
+    private _recentEdits;
+    private _pendingRead;
+    constructor(client: ITelegramClient, chat: InputPeerLike);
+    private static _getState;
+    /**
+     * Pass the update to the conversation manager and all registered
+     * conversations on this client.
+     *
+     * @returns `true` if the update was handled by some conversation
+     */
+    static handleUpdate(client: ITelegramClient, update: ParsedUpdate): boolean;
+    /**
+     * Get the input peer that this conversation is with
+     */
+    get inputPeer(): tl.TypeInputPeer;
+    /**
+     * ID of the very last message in this conversation.
+     */
+    get lastMessage(): number;
+    /**
+     * ID of the last incoming message in this conversation.
+     *
+     * Note that before any messages were received since the {@link start}
+     * of the conversation, this will equal to {@link lastMessage}
+     */
+    get lastReceivedMessage(): number;
+    /**
+     * Start the conversation
+     */
+    start(): Promise<void>;
+    /**
+     * Stop the conversation
+     */
+    stop(): void;
+    private _recordMessage;
+    /**
+     * Send a text message to this conversation.
+     *
+     * Wrapper over {@link sendText}
+     */
+    sendText(...params: ParametersSkip2<typeof sendText>): ReturnType<typeof sendText>;
+    /**
+     * Send a media to this conversation.
+     *
+     * Wrapper over {@link sendMedia}
+     */
+    sendMedia(...params: ParametersSkip2<typeof sendMedia>): ReturnType<typeof sendMedia>;
+    /**
+     * Send a media group to this conversation.
+     *
+     * Wrapper over {@link sendMediaGroup}
+     */
+    sendMediaGroup(...params: ParametersSkip2<typeof sendMediaGroup>): ReturnType<typeof sendMediaGroup>;
+    /**
+     * Mark the conversation as read up to a certain point.
+     *
+     * By default, reads until the last message.
+     * You can pass `message=null` to read the entire conversation,
+     * or pass message ID to read up until that ID.
+     */
+    markRead({ message, clearMentions, }?: {
+        message?: number | null;
+        clearMentions?: boolean;
+    }): Promise<void>;
+    /**
+     * Helper method that calls {@link start},
+     * the provided function and then {@link stop}.
+     *
+     * It is preferred that you use this function rather than
+     * manually starting and stopping the conversation.
+     *
+     * If you don't stop the conversation when you're done,
+     * it *will* lead to memory leaks.
+     *
+     * @param handler
+     */
+    with<T>(handler: () => MaybePromise<T>): Promise<T>;
+    /**
+     * Wait for a new message in the conversation
+     *
+     * @param filter  Filter for the handler. You can use any filter you can use for dispatcher
+     * @param [timeout=15000]  Timeout for the handler in ms. Pass `null` to disable.
+     *   When the timeout is reached, `MtTimeoutError` is thrown.
+     */
+    waitForNewMessage(filter?: (msg: Message) => MaybePromise<boolean>, timeout?: number | null): Promise<Message>;
+    /**
+     * Wait for a response for the given message
+     * (def. the last one) in the conversation.
+     *
+     * A message is considered to be a response if
+     * it was sent after the given one.
+     *
+     * @param filter  Filter for the handler. You can use any filter you can use for dispatcher
+     * @param params
+     */
+    waitForResponse(filter?: (msg: Message) => MaybePromise<boolean>, params?: {
+        /**
+         * Message for which to wait for response for.
+         *
+         * @default  last sent/received message
+         */
+        message?: number;
+        /**
+         * Timeout for the handler in ms. Pass `null` to disable.
+         *
+         * When the timeout is reached, `TimeoutError` is thrown.
+         *
+         * @default  `15000` (15 sec)
+         */
+        timeout?: number | null;
+    }): Promise<Message>;
+    /**
+     * Wait for the reply for the given message'
+     * (def. the last one) in the conversation.
+     *
+     * @param filter  Filter for the handler. You can use any filter you can use for dispatcher
+     * @param params
+     */
+    waitForReply(filter?: (msg: Message) => MaybePromise<boolean>, params?: {
+        /**
+         * Message for which to wait for reply for.
+         *
+         * @default  last sent/received message
+         */
+        message?: number;
+        /**
+         * Timeout for the handler in ms. Pass `null` to disable.
+         *
+         * When the timeout is reached, `TimeoutError` is thrown.
+         *
+         * @default  `15000` (15 sec)
+         */
+        timeout?: number | null;
+    }): Promise<Message>;
+    /**
+     * Wait for a message to be edited in the conversation.
+     * By defaults wait for the last message sent by the other party
+     * (at the moment) to be edited.
+     *
+     * Returns the edited message.
+     *
+     * @param filter  Filter for the handler. You can use any filter you can use for dispatcher
+     * @param params
+     */
+    waitForEdit(filter?: (msg: Message) => MaybePromise<boolean>, params?: {
+        /**
+         * Message for which to wait for reply for.
+         *
+         * @default  last received message
+         */
+        message?: number;
+        /**
+         * Timeout for the handler in ms. Pass `null` to disable.
+         *
+         * When the timeout is reached, `TimeoutError` is thrown.
+         *
+         * @default  `15000` (15 sec)
+         */
+        timeout?: number | null;
+    }): Promise<Message>;
+    /**
+     * Wait for the message to be read by the other party.
+     *
+     * Note that reading the message doesn't mean the response was sent,
+     * and if the response was sent, it doesn't mean that the message was read.
+     *
+     * @param message  Message for which to wait for read for. Defaults to last message.
+     * @param timeout  Timeout for the handler in ms, def. 15 sec. Pass `null` to disable.
+     *   When the timeout is reached, `TimeoutError` is thrown.
+     */
+    waitForRead(message?: number, timeout?: number | null): Promise<void>;
+    private _onNewMessage;
+    private _onEditMessage;
+    private _onHistoryRead;
+    private _processPendingNewMessages;
+    private _processRecentEdits;
+}

package/cjs/highlevel/types/conversation.js

@@ -0,0 +1,469 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Conversation = void 0;
+const errors_js_1 = require("../../types/errors.js");
+const async_lock_js_1 = require("../../utils/async-lock.js");
+const controllable_promise_js_1 = require("../../utils/controllable-promise.js");
+const deque_js_1 = require("../../utils/deque.js");
+const peer_utils_js_1 = require("../../utils/peer-utils.js");
+const get_peer_dialogs_js_1 = require("../methods/dialogs/get-peer-dialogs.js");
+const read_history_js_1 = require("../methods/messages/read-history.js");
+const send_media_js_1 = require("../methods/messages/send-media.js");
+const send_media_group_js_1 = require("../methods/messages/send-media-group.js");
+const send_text_js_1 = require("../methods/messages/send-text.js");
+const resolve_peer_js_1 = require("../methods/users/resolve-peer.js");
+const CONVERSATION_SYMBOL = Symbol('conversation');
+/**
+ * Represents a conversation inside some chat.
+ *
+ * A conversation keeps track of any messages sent or edited
+ * since it was started and until it was stopped,
+ * and allows waiting for events in it.
+ *
+ * If you need a conversation across multiple chats,
+ * you should use multiple {@link Conversation} objects
+ * and synchronize them manually.
+ */
+class Conversation {
+    constructor(client, chat) {
+        this.client = client;
+        this.chat = chat;
+        this._started = false;
+        this._queuedNewMessage = new deque_js_1.Deque();
+        this._pendingNewMessages = new deque_js_1.Deque();
+        this._lock = new async_lock_js_1.AsyncLock();
+        this._pendingEditMessage = new Map();
+        this._recentEdits = new deque_js_1.Deque(10);
+        this._pendingRead = new Map();
+        if (!(CONVERSATION_SYMBOL in client)) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            client[CONVERSATION_SYMBOL] = {
+                pendingConversations: new Map(),
+                hasConversations: false,
+            };
+        }
+    }
+    static _getState(client) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        return client[CONVERSATION_SYMBOL];
+    }
+    /**
+     * Pass the update to the conversation manager and all registered
+     * conversations on this client.
+     *
+     * @returns `true` if the update was handled by some conversation
+     */
+    static handleUpdate(client, update) {
+        const state = Conversation._getState(client);
+        if (!state?.hasConversations)
+            return false;
+        let chatId;
+        switch (update.name) {
+            case 'new_message':
+            case 'edit_message':
+                chatId = (0, peer_utils_js_1.getMarkedPeerId)(update.data.raw.peerId);
+                break;
+            case 'history_read':
+                chatId = update.data.chatId;
+                break;
+            default:
+                return false;
+        }
+        const conv = state.pendingConversations.get(chatId);
+        if (!conv)
+            return false;
+        for (const c of conv) {
+            switch (update.name) {
+                case 'new_message':
+                    c._onNewMessage(update.data);
+                    return true;
+                case 'edit_message':
+                    c._onEditMessage(update.data);
+                    return true;
+                case 'history_read':
+                    c._onHistoryRead(update.data);
+                    return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Get the input peer that this conversation is with
+     */
+    get inputPeer() {
+        if (!this._started) {
+            throw new errors_js_1.MtArgumentError("Conversation hasn't started yet");
+        }
+        return this._inputPeer;
+    }
+    /**
+     * ID of the very last message in this conversation.
+     */
+    get lastMessage() {
+        if (!this._started) {
+            throw new errors_js_1.MtArgumentError("Conversation hasn't started yet");
+        }
+        return this._lastMessage;
+    }
+    /**
+     * ID of the last incoming message in this conversation.
+     *
+     * Note that before any messages were received since the {@link start}
+     * of the conversation, this will equal to {@link lastMessage}
+     */
+    get lastReceivedMessage() {
+        if (!this._started) {
+            throw new errors_js_1.MtArgumentError("Conversation hasn't started yet");
+        }
+        return this._lastReceivedMessage;
+    }
+    /**
+     * Start the conversation
+     */
+    async start() {
+        if (this._started)
+            return;
+        this._started = true;
+        this._inputPeer = await (0, resolve_peer_js_1.resolvePeer)(this.client, this.chat);
+        this._chatId = (0, peer_utils_js_1.getMarkedPeerId)(this._inputPeer);
+        const [dialog] = await (0, get_peer_dialogs_js_1.getPeerDialogs)(this.client, this._inputPeer);
+        const lastMessage = dialog.lastMessage;
+        if (lastMessage) {
+            this._lastMessage = this._lastReceivedMessage = lastMessage.id;
+        }
+        else {
+            this._lastMessage = this._lastReceivedMessage = 0;
+        }
+        const state = Conversation._getState(this.client);
+        if (!state.pendingConversations.has(this._chatId)) {
+            state.pendingConversations.set(this._chatId, []);
+        }
+        state.pendingConversations.get(this._chatId).push(this);
+        state.hasConversations = true;
+    }
+    /**
+     * Stop the conversation
+     */
+    stop() {
+        if (!this._started)
+            return;
+        const state = Conversation._getState(this.client);
+        const pending = state.pendingConversations.get(this._chatId);
+        const pendingIdx = pending?.indexOf(this) ?? -1;
+        if (pendingIdx > -1) {
+            // just in case
+            pending.splice(pendingIdx, 1);
+        }
+        if (pending && !pending.length) {
+            state.pendingConversations.delete(this._chatId);
+        }
+        state.hasConversations = Boolean(state.pendingConversations.size);
+        // reset pending status
+        this._queuedNewMessage.clear();
+        this._pendingNewMessages.clear();
+        this._pendingEditMessage.clear();
+        this._recentEdits.clear();
+        this._pendingRead.clear();
+        this._started = false;
+    }
+    _recordMessage(msg, incoming = false) {
+        this._lastMessage = msg.id;
+        if (incoming)
+            this._lastReceivedMessage = msg.id;
+        return msg;
+    }
+    /**
+     * Send a text message to this conversation.
+     *
+     * Wrapper over {@link sendText}
+     */
+    async sendText(...params) {
+        if (!this._started) {
+            throw new errors_js_1.MtArgumentError("Conversation hasn't started yet");
+        }
+        return this._recordMessage(await (0, send_text_js_1.sendText)(this.client, this._inputPeer, ...params));
+    }
+    /**
+     * Send a media to this conversation.
+     *
+     * Wrapper over {@link sendMedia}
+     */
+    async sendMedia(...params) {
+        if (!this._started) {
+            throw new errors_js_1.MtArgumentError("Conversation hasn't started yet");
+        }
+        return this._recordMessage(await (0, send_media_js_1.sendMedia)(this.client, this._inputPeer, ...params));
+    }
+    /**
+     * Send a media group to this conversation.
+     *
+     * Wrapper over {@link sendMediaGroup}
+     */
+    async sendMediaGroup(...params) {
+        if (!this._started) {
+            throw new errors_js_1.MtArgumentError("Conversation hasn't started yet");
+        }
+        const msgs = await (0, send_media_group_js_1.sendMediaGroup)(this.client, this._inputPeer, ...params);
+        this._recordMessage(msgs[msgs.length - 1]);
+        return msgs;
+    }
+    /**
+     * Mark the conversation as read up to a certain point.
+     *
+     * By default, reads until the last message.
+     * You can pass `message=null` to read the entire conversation,
+     * or pass message ID to read up until that ID.
+     */
+    markRead({ message, clearMentions = true, } = {}) {
+        if (!this._started) {
+            throw new errors_js_1.MtArgumentError("Conversation hasn't started yet");
+        }
+        if (message === null) {
+            message = 0;
+        }
+        else if (message === undefined) {
+            message = this._lastMessage ?? 0;
+        }
+        return (0, read_history_js_1.readHistory)(this.client, this._inputPeer, { maxId: message, clearMentions });
+    }
+    /**
+     * Helper method that calls {@link start},
+     * the provided function and then {@link stop}.
+     *
+     * It is preferred that you use this function rather than
+     * manually starting and stopping the conversation.
+     *
+     * If you don't stop the conversation when you're done,
+     * it *will* lead to memory leaks.
+     *
+     * @param handler
+     */
+    async with(handler) {
+        await this.start();
+        let err;
+        let res;
+        try {
+            res = await handler();
+        }
+        catch (e) {
+            err = e;
+        }
+        this.stop();
+        // eslint-disable-next-line @typescript-eslint/no-throw-literal
+        if (err)
+            throw err;
+        return res;
+    }
+    /**
+     * Wait for a new message in the conversation
+     *
+     * @param filter  Filter for the handler. You can use any filter you can use for dispatcher
+     * @param [timeout=15000]  Timeout for the handler in ms. Pass `null` to disable.
+     *   When the timeout is reached, `MtTimeoutError` is thrown.
+     */
+    waitForNewMessage(filter, timeout = 15000) {
+        if (!this._started) {
+            throw new errors_js_1.MtArgumentError("Conversation hasn't started yet");
+        }
+        const promise = (0, controllable_promise_js_1.createControllablePromise)();
+        let timer = undefined;
+        if (timeout !== null) {
+            timer = setTimeout(() => {
+                promise.reject(new errors_js_1.MtTimeoutError(timeout));
+                this._queuedNewMessage.removeBy((it) => it.promise === promise);
+            }, timeout);
+        }
+        this._queuedNewMessage.pushBack({
+            promise,
+            check: filter,
+            timeout: timer,
+        });
+        this._processPendingNewMessages();
+        return promise;
+    }
+    /**
+     * Wait for a response for the given message
+     * (def. the last one) in the conversation.
+     *
+     * A message is considered to be a response if
+     * it was sent after the given one.
+     *
+     * @param filter  Filter for the handler. You can use any filter you can use for dispatcher
+     * @param params
+     */
+    waitForResponse(filter, params) {
+        const msgId = params?.message ?? this._lastMessage ?? 0;
+        const pred = filter ?
+            (msg) => (msg.id > msgId ? filter(msg) : false) :
+            (msg) => msg.id > msgId;
+        return this.waitForNewMessage(pred, params?.timeout);
+    }
+    /**
+     * Wait for the reply for the given message'
+     * (def. the last one) in the conversation.
+     *
+     * @param filter  Filter for the handler. You can use any filter you can use for dispatcher
+     * @param params
+     */
+    waitForReply(filter, params) {
+        const msgId = params?.message ?? this._lastMessage;
+        if (!msgId) {
+            throw new errors_js_1.MtArgumentError('Provide message for which to wait for reply for');
+        }
+        const pred = filter ?
+            (msg) => (msg.replyToMessage?.id === msgId ? filter(msg) : false) :
+            (msg) => msg.replyToMessage?.id === msgId;
+        return this.waitForNewMessage(pred, params?.timeout);
+    }
+    /**
+     * Wait for a message to be edited in the conversation.
+     * By defaults wait for the last message sent by the other party
+     * (at the moment) to be edited.
+     *
+     * Returns the edited message.
+     *
+     * @param filter  Filter for the handler. You can use any filter you can use for dispatcher
+     * @param params
+     */
+    async waitForEdit(filter, params) {
+        if (!this._started) {
+            throw new errors_js_1.MtArgumentError("Conversation hasn't started yet");
+        }
+        const msgId = params?.message ?? this._lastReceivedMessage;
+        if (!msgId) {
+            throw new errors_js_1.MtArgumentError('Provide message for which to wait for edit for');
+        }
+        const promise = (0, controllable_promise_js_1.createControllablePromise)();
+        let timer = undefined;
+        const timeout = params?.timeout;
+        if (timeout) {
+            timer = setTimeout(() => {
+                promise.reject(new errors_js_1.MtTimeoutError(timeout));
+                this._pendingEditMessage.delete(msgId);
+            }, timeout);
+        }
+        this._pendingEditMessage.set(msgId, {
+            promise,
+            check: filter,
+            timeout: timer,
+        });
+        this._processRecentEdits();
+        return promise;
+    }
+    /**
+     * Wait for the message to be read by the other party.
+     *
+     * Note that reading the message doesn't mean the response was sent,
+     * and if the response was sent, it doesn't mean that the message was read.
+     *
+     * @param message  Message for which to wait for read for. Defaults to last message.
+     * @param timeout  Timeout for the handler in ms, def. 15 sec. Pass `null` to disable.
+     *   When the timeout is reached, `TimeoutError` is thrown.
+     */
+    async waitForRead(message, timeout = 15000) {
+        if (!this._started) {
+            throw new errors_js_1.MtArgumentError("Conversation hasn't started yet");
+        }
+        const msgId = message ?? this._lastMessage;
+        if (!msgId) {
+            throw new errors_js_1.MtArgumentError('Provide message for which to wait for read for');
+        }
+        // check if the message is already read
+        const [dialog] = await (0, get_peer_dialogs_js_1.getPeerDialogs)(this.client, this._inputPeer);
+        if (dialog.lastRead >= msgId)
+            return;
+        const promise = (0, controllable_promise_js_1.createControllablePromise)();
+        let timer = undefined;
+        if (timeout !== null) {
+            timer = setTimeout(() => {
+                promise.reject(new errors_js_1.MtTimeoutError(timeout));
+                this._pendingRead.delete(msgId);
+            }, timeout);
+        }
+        this._pendingRead.set(msgId, {
+            promise,
+            timeout: timer,
+        });
+        return promise;
+    }
+    _onNewMessage(msg) {
+        if (msg.chat.id !== this._chatId)
+            return;
+        if (!this._queuedNewMessage.length) {
+            this._pendingNewMessages.pushBack(msg);
+            return;
+        }
+        const it = this._queuedNewMessage.peekFront();
+        // order does matter for new messages
+        void this._lock.acquire().then(async () => {
+            try {
+                if (!it.check || (await it.check(msg))) {
+                    if (it.timeout)
+                        clearTimeout(it.timeout);
+                    it.promise.resolve(msg);
+                    this._queuedNewMessage.popFront();
+                }
+            }
+            catch (e) {
+                this.client.emitError(e);
+            }
+            this._lastMessage = this._lastReceivedMessage = msg.id;
+            // this func will *never* error, so no need to use .then
+            this._lock.release();
+        });
+    }
+    _onEditMessage(msg, fromRecent = false) {
+        if (msg.chat.id !== this._chatId)
+            return;
+        const it = this._pendingEditMessage.get(msg.id);
+        if (!it) {
+            if (!fromRecent) {
+                this._recentEdits.pushBack(msg);
+            }
+            return;
+        }
+        (async () => {
+            if (!it.check || (await it.check(msg))) {
+                if (it.timeout)
+                    clearTimeout(it.timeout);
+                it.promise.resolve(msg);
+                this._pendingEditMessage.delete(msg.id);
+            }
+        })().catch((e) => {
+            this.client.emitError(e);
+        });
+    }
+    _onHistoryRead(upd) {
+        if (upd.chatId !== this._chatId)
+            return;
+        const lastRead = upd.maxReadId;
+        for (const msgId of this._pendingRead.keys()) {
+            if (msgId <= lastRead) {
+                const it = this._pendingRead.get(msgId);
+                if (it.timeout)
+                    clearTimeout(it.timeout);
+                it.promise.resolve();
+                this._pendingRead.delete(msgId);
+            }
+        }
+    }
+    _processPendingNewMessages() {
+        if (!this._pendingNewMessages.length)
+            return;
+        let it;
+        while ((it = this._pendingNewMessages.popFront())) {
+            this._onNewMessage(it);
+        }
+    }
+    _processRecentEdits() {
+        if (!this._recentEdits.length)
+            return;
+        const iter = this._recentEdits.iter();
+        let it;
+        while (!(it = iter.next()).done) {
+            this._onEditMessage(it.value, true);
+        }
+    }
+}
+exports.Conversation = Conversation;
+//# sourceMappingURL=conversation.js.map