@mtcute/core 0.16.6 → 0.16.9

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

@@ -1,210 +0,0 @@
-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

@@ -1,475 +0,0 @@
-"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 {
-    client;
-    chat;
-    _inputPeer;
-    _chatId;
-    _started = false;
-    _lastMessage;
-    _lastReceivedMessage;
-    _queuedNewMessage = new deque_js_1.Deque();
-    _pendingNewMessages = new deque_js_1.Deque();
-    _lock = new async_lock_js_1.AsyncLock();
-    _pendingEditMessage = new Map();
-    _recentEdits = new deque_js_1.Deque(10);
-    _pendingRead = new Map();
-    constructor(client, chat) {
-        this.client = client;
-        this.chat = chat;
-        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