teleproto 1.214.0

package/events/Album.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AlbumEvent = exports.Album = void 0;
+const common_1 = require("./common");
+const tl_1 = require("../tl");
+const Logger_1 = require("../extensions/Logger");
+const _ALBUM_DELAY = 500; // 0.5 sec
+/**
+ * Occurs whenever an album (multiple grouped messages with media) arrive.
+ * @example
+ * ```ts
+ * // Albums are basically a list of messages. so event is a list
+ *   async function listenForAlbums(event: AlbumEvent) {
+ *       const messages = event.messages;
+ *       for (const message of messages){
+ *           console.log("Caption is",message.text);
+ *           console.log("Message id is",message.id);
+ *           console.log("Chat id is",message.chatId);
+ *       }
+ *   }
+ * // adds an event handler for new messages
+ * client.addEventHandler(listenForAlbums, new Album({}));
+ * ```
+ */
+class Album extends common_1.EventBuilder {
+    constructor(albumParams) {
+        let { chats, func, blacklistChats = false } = albumParams;
+        super({ chats, blacklistChats, func });
+    }
+    build(update, dispatch) {
+        if (!("message" in update && update.message instanceof tl_1.Api.Message)) {
+            return;
+        }
+        const groupedId = update.message.groupedId;
+        if (!groupedId) {
+            return;
+        }
+        const albums = this.client._ALBUMS;
+        const oldTimeout = albums.get(groupedId.toString());
+        let oldValues = [];
+        if (oldTimeout) {
+            clearTimeout(oldTimeout[0]);
+            oldValues.push(...oldTimeout[1]);
+        }
+        albums.set(groupedId.toString(), [
+            setTimeout(() => {
+                const values = albums.get(groupedId.toString());
+                albums.delete(groupedId.toString());
+                if (!values) {
+                    return;
+                }
+                const updates = values[1];
+                if (!updates) {
+                    return;
+                }
+                const messages = [];
+                for (const update of updates) {
+                    // there is probably an easier way
+                    if ("message" in update &&
+                        update.message instanceof tl_1.Api.Message) {
+                        messages.push(update.message);
+                    }
+                }
+                const event = new AlbumEvent(messages, values[1]);
+                event._setClient(this.client);
+                event._entities = messages[0]._entities;
+                dispatch(event);
+            }, _ALBUM_DELAY),
+            [...oldValues, update],
+        ]);
+    }
+}
+exports.Album = Album;
+class AlbumEvent extends common_1.EventCommon {
+    constructor(messages, originalUpdates) {
+        super({
+            msgId: messages[0].id,
+            chatPeer: messages[0].peerId,
+            broadcast: messages[0].post,
+        });
+        this.originalUpdates = originalUpdates;
+        this.messages = messages;
+    }
+    _setClient(client) {
+        super._setClient(client);
+        for (let i = 0; i < this.messages.length; i++) {
+            try {
+                // todo make sure this never fails
+                this.messages[i]._finishInit(client, this.originalUpdates[i]._entities || new Map(), undefined);
+            }
+            catch (e) {
+                client._log.error("Got error while trying to finish init message with id " +
+                    this.messages[i].id);
+                if (client._errorHandler) {
+                    client._errorHandler(e);
+                }
+                if (client._log.canSend(Logger_1.LogLevel.ERROR)) {
+                    console.error(e);
+                }
+            }
+        }
+    }
+}
+exports.AlbumEvent = AlbumEvent;

package/events/CallbackQuery.d.ts

@@ -0,0 +1,73 @@
+import { EntityLike } from "../define";
+import { EventBuilder, EventCommonSender } from "./common";
+import { Api } from "../tl";
+import { TelegramClient } from "..";
+import { EditMessageParams, SendMessageParams } from "../client/messages";
+export interface NewCallbackQueryInterface {
+    chats: EntityLike[];
+    func?: {
+        (event: CallbackQuery): boolean;
+    };
+    fromUsers: EntityLike[];
+    blacklistUsers: EntityLike[];
+    pattern?: RegExp;
+}
+export declare const NewCallbackQueryDefaults: NewCallbackQueryInterface;
+/**
+ * Occurs whenever you sign in as a bot and a user
+ * clicks one of the inline buttons on your messages.
+ * Note that the `chats` parameter will **not** work with normal
+ * IDs or peers if the clicked inline button comes from a "via bot"
+ * message. The `chats` parameter also supports checking against the
+ * `chat_instance` which should be used for inline callbacks.
+ *
+ * @example
+ * ```ts
+ * async function printQuery(event: NewCallbackQueryEvent) {
+ *     // TODO
+ * }
+ * ```
+ */
+export declare class CallbackQuery extends EventBuilder {
+    match?: RegExp;
+    private _noCheck;
+    constructor(inlineQueryParams?: Partial<NewCallbackQueryInterface>);
+    build(update: Api.TypeUpdate | Api.TypeUpdates, callback: undefined, selfId?: undefined): CallbackQueryEvent | undefined;
+    filter(event: CallbackQueryEvent): any;
+}
+export interface AnswerCallbackQueryParams {
+    message: string;
+    cacheTime: number;
+    url: string;
+    alert: boolean;
+}
+export declare class CallbackQueryEvent extends EventCommonSender {
+    /**
+     * The original {@link Api.UpdateBotCallbackQuery} or {@link Api.UpdateInlineBotCallbackQuery} object.
+     */
+    query: Api.UpdateBotCallbackQuery | Api.UpdateInlineBotCallbackQuery;
+    /**
+     * The regex match object returned from successfully matching the
+     * query `data` with the provided pattern in your event handler.
+     */
+    patternMatch: RegExpMatchArray | undefined;
+    private _message;
+    private _answered;
+    constructor(query: Api.UpdateBotCallbackQuery | Api.UpdateInlineBotCallbackQuery, peer: Api.TypePeer, msgId: number);
+    _setClient(client: TelegramClient): void;
+    get id(): import("big-integer").BigInteger;
+    get messageId(): number;
+    get data(): Api.bytes | undefined;
+    get chatInstance(): import("big-integer").BigInteger;
+    getMessage(): Promise<Api.Message>;
+    _refetchSender(): Promise<void>;
+    answer({ message, cacheTime, url, alert, }?: Partial<AnswerCallbackQueryParams>): Promise<boolean | undefined>;
+    get viaInline(): boolean;
+    respond(params?: SendMessageParams): Promise<void>;
+    reply(params?: SendMessageParams): Promise<void>;
+    edit(params: EditMessageParams): Promise<Api.Message>;
+    delete({ revoke }?: {
+        revoke: boolean;
+    }): Promise<Api.messages.AffectedMessages[] | undefined>;
+    get sender(): import("../define").Entity | undefined;
+}

package/events/CallbackQuery.js

@@ -0,0 +1,193 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CallbackQueryEvent = exports.CallbackQuery = exports.NewCallbackQueryDefaults = void 0;
+const common_1 = require("./common");
+const tl_1 = require("../tl");
+const Helpers_1 = require("../Helpers");
+const Utils_1 = require("../Utils");
+exports.NewCallbackQueryDefaults = {
+    chats: [],
+    fromUsers: [],
+    blacklistUsers: [],
+};
+/**
+ * Occurs whenever you sign in as a bot and a user
+ * clicks one of the inline buttons on your messages.
+ * Note that the `chats` parameter will **not** work with normal
+ * IDs or peers if the clicked inline button comes from a "via bot"
+ * message. The `chats` parameter also supports checking against the
+ * `chat_instance` which should be used for inline callbacks.
+ *
+ * @example
+ * ```ts
+ * async function printQuery(event: NewCallbackQueryEvent) {
+ *     // TODO
+ * }
+ * ```
+ */
+class CallbackQuery extends common_1.EventBuilder {
+    constructor(inlineQueryParams = {}) {
+        const { chats, func, pattern } = inlineQueryParams;
+        super({ chats, func, blacklistChats: false });
+        this.match = pattern;
+        this._noCheck = [this.chats, this.func, this.match].every((i) => i === null || i === undefined);
+    }
+    build(update, callback, selfId = undefined) {
+        if (update instanceof tl_1.Api.UpdateBotCallbackQuery) {
+            return new CallbackQueryEvent(update, update.peer, update.msgId);
+        }
+        else if (update instanceof tl_1.Api.UpdateInlineBotCallbackQuery) {
+            const b = (0, Helpers_1.toSignedLittleBuffer)(update.msgId.id, 8);
+            const msgId = b.readInt32LE(0);
+            const peerId = b.readInt32LE(4);
+            const peer = peerId < 0
+                ? new tl_1.Api.PeerChannel({ channelId: (0, Helpers_1.returnBigInt)(-peerId) })
+                : new tl_1.Api.PeerUser({ userId: (0, Helpers_1.returnBigInt)(peerId) });
+            return new CallbackQueryEvent(update, peer, msgId);
+        }
+    }
+    filter(event) {
+        if (this._noCheck)
+            return event;
+        if (this.chats) {
+            let inside = this.chats.includes(event.query.chatInstance.toString());
+            if (event.chatId) {
+                inside = inside || this.chats.includes(event.chatId.toString());
+            }
+            if (inside === this.blacklistChats) {
+                return;
+            }
+        }
+        if (this.match) {
+            const data = new TextDecoder().decode(event.query.data);
+            const result = this.match.exec(data);
+            this.match.lastIndex = 0;
+            if (result) {
+                event.patternMatch = result;
+            }
+            else {
+                return;
+            }
+        }
+        if (this.func) {
+            return this.func(event);
+        }
+        return true;
+    }
+}
+exports.CallbackQuery = CallbackQuery;
+class CallbackQueryEvent extends common_1.EventCommonSender {
+    constructor(query, peer, msgId) {
+        super({
+            msgId,
+            chatPeer: peer,
+            broadcast: false,
+        });
+        this.query = query;
+        this.patternMatch = undefined;
+        this._senderId = (0, Helpers_1.returnBigInt)(query.userId);
+        this._message = undefined;
+        this._answered = false;
+    }
+    _setClient(client) {
+        super._setClient(client);
+        const [sender, inputSender] = (0, Utils_1._getEntityPair)(this._senderId.toString(), this._entities, client._entityCache);
+        this._sender = sender;
+        this._inputSender = inputSender;
+    }
+    get id() {
+        return this.query.queryId;
+    }
+    get messageId() {
+        return this._messageId;
+    }
+    get data() {
+        return this.query.data;
+    }
+    get chatInstance() {
+        return this.query.chatInstance;
+    }
+    async getMessage() {
+        if (this._message) {
+            return this._message;
+        }
+        const chat = this.isChannel ? await this.getInputChat() : undefined;
+        const messages = await this._client.getMessages(chat, {
+            ids: this._messageId,
+        });
+        this._message = messages[0];
+        return this._message;
+    }
+    async _refetchSender() {
+        if (this._entities.has(this.senderId.toString())) {
+            this._sender = this._entities.get(this.senderId.toString());
+        }
+        if (!this._sender)
+            return;
+        this._inputSender = (0, Utils_1.getInputPeer)(this._chat);
+        if (!this._inputSender.hasOwnProperty("accessHash")) {
+            try {
+                this._inputSender = this._client._entityCache.get(this._senderId);
+            }
+            catch (e) {
+                const m = await this.getMessage();
+                if (m) {
+                    this._sender = m._sender;
+                    this._inputSender = m._inputSender;
+                }
+            }
+        }
+    }
+    async answer({ message, cacheTime, url, alert, } = {}) {
+        if (this._answered)
+            return;
+        return await this._client.invoke(new tl_1.Api.messages.SetBotCallbackAnswer({
+            queryId: this.query.queryId,
+            cacheTime,
+            alert,
+            message,
+            url,
+        })).then((res) => {
+            this._answered = true;
+            return res;
+        });
+    }
+    get viaInline() {
+        return this.query instanceof tl_1.Api.UpdateInlineBotCallbackQuery;
+    }
+    async respond(params = {}) {
+        await this.answer();
+        const inputChat = await this.getInputChat();
+        await this._client.sendMessage(inputChat, params);
+    }
+    async reply(params = {}) {
+        await this.answer();
+        params.replyTo = this.messageId;
+        const inputChat = await this.getInputChat();
+        await this._client.sendMessage(inputChat, params);
+    }
+    async edit(params) {
+        if (this.query.msgId instanceof tl_1.Api.InputBotInlineMessageID) {
+            return await this._client.editMessage(this.messageId, params).then(async (res) => {
+                await this.answer();
+                return res;
+            });
+        }
+        else {
+            const inputChat = await this.getInputChat();
+            return await this._client.editMessage(inputChat, params).then(async (res) => {
+                await this.answer();
+                return res;
+            });
+        }
+    }
+    async delete({ revoke } = { revoke: false }) {
+        if (this._client) {
+            return this._client.deleteMessages(await this.getInputChat(), [this.messageId], { revoke });
+        }
+    }
+    get sender() {
+        return this._sender;
+    }
+}
+exports.CallbackQueryEvent = CallbackQueryEvent;

package/events/DeletedMessage.d.ts

@@ -0,0 +1,45 @@
+import { EntityLike } from "../define";
+import { Api } from "../tl";
+import { EventBuilder, EventCommon, DefaultEventInterface } from "./common";
+/**
+ * Occurs whenever a message is deleted. Note that this event isn't 100%
+ * reliable, since Telegram doesn't always notify the clients that a message
+ * was deleted.
+ *
+ * @remarks
+ * Telegram **does not** send information about *where* a message
+ * was deleted if it occurs in private conversations with other users
+ * or in small group chats, because message IDs are *unique* and you
+ * can identify the chat with the message ID alone if you saved it
+ * previously.
+ *
+ * teleproto **does not** save information of where messages occur,
+ * so it cannot know in which chat a message was deleted (this will
+ * only work in channels, where the channel ID *is* present).
+ *
+ * This means that the `chats:` parameter will not work reliably,
+ * unless you intend on working with channels and super-groups only.
+ *
+ * @example
+ * ```ts
+ * async function deletedMessageEventPrint(event: DeletedMessageEvent) {
+ *
+ *   for (let index = 0; index < update.deletedIds.length; index++) {
+ *     const deletedMsgId = update.deletedIds[index];
+ *     console.log(`Message ${deletedMsgId} was deleted.`)
+ *   }
+ *
+ * }
+ * // adds an event handler for deleted messages
+ * client.addEventHandler(deletedMessageEventPrint, new DeletedMessage({}));
+ * ```
+ */
+export declare class DeletedMessage extends EventBuilder {
+    constructor(eventParams: DefaultEventInterface);
+    build(update: Api.TypeUpdate | Api.TypeUpdates, callback: undefined, selfId: bigInt.BigInteger): DeletedMessageEvent | undefined;
+}
+export declare class DeletedMessageEvent extends EventCommon {
+    deletedIds: number[];
+    peer?: EntityLike;
+    constructor(deletedIds: number[], peer?: EntityLike);
+}

package/events/DeletedMessage.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeletedMessageEvent = exports.DeletedMessage = void 0;
+const tl_1 = require("../tl");
+const common_1 = require("./common");
+/**
+ * Occurs whenever a message is deleted. Note that this event isn't 100%
+ * reliable, since Telegram doesn't always notify the clients that a message
+ * was deleted.
+ *
+ * @remarks
+ * Telegram **does not** send information about *where* a message
+ * was deleted if it occurs in private conversations with other users
+ * or in small group chats, because message IDs are *unique* and you
+ * can identify the chat with the message ID alone if you saved it
+ * previously.
+ *
+ * teleproto **does not** save information of where messages occur,
+ * so it cannot know in which chat a message was deleted (this will
+ * only work in channels, where the channel ID *is* present).
+ *
+ * This means that the `chats:` parameter will not work reliably,
+ * unless you intend on working with channels and super-groups only.
+ *
+ * @example
+ * ```ts
+ * async function deletedMessageEventPrint(event: DeletedMessageEvent) {
+ *
+ *   for (let index = 0; index < update.deletedIds.length; index++) {
+ *     const deletedMsgId = update.deletedIds[index];
+ *     console.log(`Message ${deletedMsgId} was deleted.`)
+ *   }
+ *
+ * }
+ * // adds an event handler for deleted messages
+ * client.addEventHandler(deletedMessageEventPrint, new DeletedMessage({}));
+ * ```
+ */
+class DeletedMessage extends common_1.EventBuilder {
+    constructor(eventParams) {
+        super(eventParams);
+    }
+    build(update, callback, selfId) {
+        if (update instanceof tl_1.Api.UpdateDeleteChannelMessages) {
+            return new DeletedMessageEvent(update.messages, new tl_1.Api.PeerChannel({ channelId: update.channelId }));
+        }
+        else if (update instanceof tl_1.Api.UpdateDeleteMessages) {
+            return new DeletedMessageEvent(update.messages);
+        }
+    }
+}
+exports.DeletedMessage = DeletedMessage;
+class DeletedMessageEvent extends common_1.EventCommon {
+    constructor(deletedIds, peer) {
+        super({
+            chatPeer: peer,
+            msgId: Array.isArray(deletedIds) ? deletedIds[0] : 0,
+        });
+        this.deletedIds = deletedIds;
+        this.peer = peer;
+    }
+}
+exports.DeletedMessageEvent = DeletedMessageEvent;

package/events/EditedMessage.d.ts

@@ -0,0 +1,30 @@
+import { Api } from "../tl";
+import { NewMessage, NewMessageEvent, NewMessageInterface } from "./NewMessage";
+export interface EditedMessageInterface extends NewMessageInterface {
+    func?: {
+        (event: EditedMessageEvent): boolean;
+    };
+}
+/**
+ * Occurs whenever a text message or a message with media was edited.
+ * @example
+ * ```ts
+ * async function editedEventPrint(event: EditedMessageEvent) {
+ *   const message = event.message as Api.Message;
+ *
+ *   console.log(`Message ${message.id} from channel ${message.chatId!.toString();} was edited at ${message.editDate}`)
+ * }
+ * // adds an event handler for edited messages
+ * client.addEventHandler(editedEventPrint, new EditedMessage({}));
+ * ```
+ */
+export declare class EditedMessage extends NewMessage {
+    func?: {
+        (event: EditedMessageEvent): boolean;
+    };
+    constructor(editedMessageParams: EditedMessageInterface);
+    build(update: Api.TypeUpdate | Api.TypeUpdates, callback: undefined, selfId: bigInt.BigInteger): EditedMessageEvent | undefined;
+}
+export declare class EditedMessageEvent extends NewMessageEvent {
+    constructor(message: Api.Message, originalUpdate: Api.TypeUpdate | Api.TypeUpdates);
+}

package/events/EditedMessage.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EditedMessageEvent = exports.EditedMessage = void 0;
+const tl_1 = require("../tl");
+const NewMessage_1 = require("./NewMessage");
+/**
+ * Occurs whenever a text message or a message with media was edited.
+ * @example
+ * ```ts
+ * async function editedEventPrint(event: EditedMessageEvent) {
+ *   const message = event.message as Api.Message;
+ *
+ *   console.log(`Message ${message.id} from channel ${message.chatId!.toString();} was edited at ${message.editDate}`)
+ * }
+ * // adds an event handler for edited messages
+ * client.addEventHandler(editedEventPrint, new EditedMessage({}));
+ * ```
+ */
+class EditedMessage extends NewMessage_1.NewMessage {
+    constructor(editedMessageParams) {
+        super(editedMessageParams);
+    }
+    build(update, callback, selfId) {
+        if (update instanceof tl_1.Api.UpdateEditChannelMessage ||
+            update instanceof tl_1.Api.UpdateEditMessage) {
+            if (!(update.message instanceof tl_1.Api.Message)) {
+                return undefined;
+            }
+            const event = new EditedMessageEvent(update.message, update);
+            this.addAttributes(event);
+            return event;
+        }
+    }
+}
+exports.EditedMessage = EditedMessage;
+class EditedMessageEvent extends NewMessage_1.NewMessageEvent {
+    constructor(message, originalUpdate) {
+        super(message, originalUpdate);
+    }
+}
+exports.EditedMessageEvent = EditedMessageEvent;

package/events/NewMessage.d.ts

@@ -0,0 +1,89 @@
+import { DefaultEventInterface, EventBuilder, EventCommon } from "./common";
+import type { Entity, EntityLike } from "../define";
+import type { TelegramClient } from "..";
+import { Api } from "../tl";
+import bigInt from "big-integer";
+export interface NewMessageInterface extends DefaultEventInterface {
+    func?: {
+        (event: NewMessageEvent): boolean;
+    };
+    /**
+     * If set to `true`, only **incoming** messages will be handled.
+     Mutually exclusive with ``outgoing`` (can only set one of either).
+     */
+    incoming?: boolean;
+    /**
+     * If set to `true`, only **outgoing** messages will be handled.
+     * Mutually exclusive with ``incoming`` (can only set one of either).
+     */
+    outgoing?: boolean;
+    /**
+     * Unlike `chats`, this parameter filters the *senders* of the
+     * message. That is, only messages *sent by these users* will be
+     * handled. Use `chats` if you want private messages with this/these
+     * users. `from_users` lets you filter by messages sent by *one or
+     * more* users across the desired chats (doesn't need a list).
+     */
+    fromUsers?: EntityLike[];
+    /**
+     * Whether forwarded messages should be handled or not. By default,
+     * both forwarded and normal messages are included. If it's `True`
+     * **only** forwards will be handled. If it's `False` only messages
+     * that are *not* forwards will be handled.
+     */
+    forwards?: boolean;
+    /**
+     *  If set, only messages matching this pattern will be handled.
+     */
+    pattern?: RegExp;
+}
+/**
+ * Occurs whenever a new text message or a message with media arrives.
+ * @example
+ * ```ts
+ * async function eventPrint(event: NewMessageEvent) {
+ * const message = event.message;
+ *
+ *   // Checks if it's a private message (from user or bot)
+ *   if (event.isPrivate){
+ *       // prints sender id
+ *       console.log(message.senderId);
+ *       // read message
+ *       if (message.text == "hello"){
+ *           const sender = await message.getSender();
+ *           console.log("sender is",sender);
+ *           await client.sendMessage(sender,{
+ *               message:`hi your id is ${message.senderId}`
+ *           });
+ *       }
+ *   }
+ * }
+ * // adds an event handler for new messages
+ * client.addEventHandler(eventPrint, new NewMessage({}));
+ * ```
+ */
+export declare class NewMessage extends EventBuilder {
+    func?: {
+        (event: NewMessageEvent): boolean;
+    };
+    incoming?: boolean;
+    outgoing?: boolean;
+    fromUsers?: EntityLike[];
+    forwards?: boolean;
+    pattern?: RegExp;
+    /** @hidden */
+    private readonly _noCheck;
+    constructor(newMessageParams?: NewMessageInterface);
+    _resolve(client: TelegramClient): Promise<void>;
+    build(update: Api.TypeUpdate | Api.TypeUpdates, callback: undefined, selfId: bigInt.BigInteger): NewMessageEvent | undefined;
+    filter(event: NewMessageEvent): EventCommon | import("./common").EventCommonSender | undefined;
+    addAttributes(update: any): void;
+}
+export declare class NewMessageEvent extends EventCommon {
+    message: Api.Message;
+    originalUpdate: (Api.TypeUpdate | Api.TypeUpdates) & {
+        _entities?: Map<number, Entity>;
+    };
+    constructor(message: Api.Message, originalUpdate: Api.TypeUpdate | Api.TypeUpdates);
+    _setClient(client: TelegramClient): void;
+}