teleproto 1.214.0

package/events/NewMessage.js

@@ -0,0 +1,182 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NewMessageEvent = exports.NewMessage = void 0;
+const common_1 = require("./common");
+const tl_1 = require("../tl");
+const Logger_1 = require("../extensions/Logger");
+/**
+ * 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({}));
+ * ```
+ */
+class NewMessage extends common_1.EventBuilder {
+    constructor(newMessageParams = {}) {
+        let { chats, func, incoming, outgoing, fromUsers, forwards, pattern, blacklistChats = false, } = newMessageParams;
+        if (incoming && outgoing) {
+            incoming = outgoing = undefined;
+        }
+        else if (incoming != undefined && outgoing == undefined) {
+            outgoing = !incoming;
+        }
+        else if (outgoing != undefined && incoming == undefined) {
+            incoming = !outgoing;
+        }
+        else if (outgoing == false && incoming == false) {
+            throw new Error("Don't create an event handler if you don't want neither incoming nor outgoing!");
+        }
+        super({ chats, blacklistChats, func });
+        this.incoming = incoming;
+        this.outgoing = outgoing;
+        this.fromUsers = fromUsers;
+        this.forwards = forwards;
+        this.pattern = pattern;
+        this._noCheck = [
+            incoming,
+            outgoing,
+            chats,
+            pattern,
+            fromUsers,
+            forwards,
+            func,
+        ].every((v) => v == undefined);
+    }
+    async _resolve(client) {
+        await super._resolve(client);
+        this.fromUsers = await (0, common_1._intoIdSet)(client, this.fromUsers);
+    }
+    build(update, callback, selfId) {
+        if (update instanceof tl_1.Api.UpdateNewMessage ||
+            update instanceof tl_1.Api.UpdateNewChannelMessage) {
+            if (!(update.message instanceof tl_1.Api.Message)) {
+                return undefined;
+            }
+            const event = new NewMessageEvent(update.message, update);
+            this.addAttributes(event);
+            return event;
+        }
+        else if (update instanceof tl_1.Api.UpdateShortMessage) {
+            return new NewMessageEvent(new tl_1.Api.Message({
+                out: update.out,
+                mentioned: update.mentioned,
+                mediaUnread: update.mediaUnread,
+                silent: update.silent,
+                id: update.id,
+                peerId: new tl_1.Api.PeerUser({ userId: update.userId }),
+                fromId: new tl_1.Api.PeerUser({
+                    userId: update.out ? selfId : update.userId,
+                }),
+                message: update.message,
+                date: update.date,
+                fwdFrom: update.fwdFrom,
+                viaBotId: update.viaBotId,
+                replyTo: update.replyTo,
+                entities: update.entities,
+                ttlPeriod: update.ttlPeriod,
+            }), update);
+        }
+        else if (update instanceof tl_1.Api.UpdateShortChatMessage) {
+            return new NewMessageEvent(new tl_1.Api.Message({
+                out: update.out,
+                mentioned: update.mentioned,
+                mediaUnread: update.mediaUnread,
+                silent: update.silent,
+                id: update.id,
+                peerId: new tl_1.Api.PeerChat({ chatId: update.chatId }),
+                fromId: new tl_1.Api.PeerUser({
+                    userId: update.out ? selfId : update.fromId,
+                }),
+                message: update.message,
+                date: update.date,
+                fwdFrom: update.fwdFrom,
+                viaBotId: update.viaBotId,
+                replyTo: update.replyTo,
+                entities: update.entities,
+                ttlPeriod: update.ttlPeriod,
+            }), update);
+        }
+    }
+    filter(event) {
+        var _a;
+        if (this._noCheck) {
+            return event;
+        }
+        if (this.incoming && event.message.out) {
+            return;
+        }
+        if (this.outgoing && !event.message.out) {
+            return;
+        }
+        if (this.forwards != undefined) {
+            if (this.forwards != !!event.message.fwdFrom) {
+                return;
+            }
+        }
+        if (this.fromUsers != undefined) {
+            if (!event.message.senderId ||
+                !this.fromUsers.includes(event.message.senderId.toString())) {
+                return;
+            }
+        }
+        if (this.pattern) {
+            const match = (_a = event.message.message) === null || _a === void 0 ? void 0 : _a.match(this.pattern);
+            if (!match) {
+                return;
+            }
+            event.message.patternMatch = match;
+        }
+        return super.filter(event);
+    }
+    addAttributes(update) {
+        //update.patternMatch =
+    }
+}
+exports.NewMessage = NewMessage;
+class NewMessageEvent extends common_1.EventCommon {
+    constructor(message, originalUpdate) {
+        super({
+            msgId: message.id,
+            chatPeer: message.peerId,
+            broadcast: message.post,
+        });
+        this.originalUpdate = originalUpdate;
+        this.message = message;
+    }
+    _setClient(client) {
+        super._setClient(client);
+        const m = this.message;
+        try {
+            // todo make sure this never fails
+            m._finishInit(client, this.originalUpdate._entities || new Map(), undefined);
+        }
+        catch (e) {
+            client._log.error("Got error while trying to finish init message with id " + m.id);
+            if (client._errorHandler) {
+                client._errorHandler(e);
+            }
+            if (client._log.canSend(Logger_1.LogLevel.ERROR)) {
+                console.error(e);
+            }
+        }
+    }
+}
+exports.NewMessageEvent = NewMessageEvent;

package/events/Raw.d.ts

@@ -0,0 +1,29 @@
+import { EventBuilder, EventCommon } from "./common";
+import type { TelegramClient } from "..";
+import { Api } from "../tl";
+export interface RawInterface {
+    /**
+     * The types that the {@link Api.TypeUpdate} instance must be.
+     * Equivalent to ``if (update instanceof type) return update``.
+     */
+    types?: Function[];
+    func?: CallableFunction;
+}
+/**
+ * The RAW updates that telegram sends. these are {@link Api.TypeUpdate} objects.
+ * The are useful to handle custom events that you need like user typing or games.
+ * @example
+ * ```ts
+ * client.addEventHandler((update) => {
+ *   console.log("Received new Update");
+ *   console.log(update);
+ * });
+ * ```
+ */
+export declare class Raw extends EventBuilder {
+    private readonly types?;
+    constructor(params: RawInterface);
+    resolve(client: TelegramClient): Promise<void>;
+    build(update: Api.TypeUpdate): Api.TypeUpdate;
+    filter(event: EventCommon): EventCommon | import("./common").EventCommonSender | undefined;
+}

package/events/Raw.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Raw = void 0;
+const common_1 = require("./common");
+/**
+ * The RAW updates that telegram sends. these are {@link Api.TypeUpdate} objects.
+ * The are useful to handle custom events that you need like user typing or games.
+ * @example
+ * ```ts
+ * client.addEventHandler((update) => {
+ *   console.log("Received new Update");
+ *   console.log(update);
+ * });
+ * ```
+ */
+class Raw extends common_1.EventBuilder {
+    constructor(params) {
+        super({ func: params.func });
+        this.types = params.types;
+    }
+    async resolve(client) {
+        this.resolved = true;
+    }
+    build(update) {
+        return update;
+    }
+    filter(event) {
+        if (this.types) {
+            let correct = false;
+            for (const type of this.types) {
+                if (event instanceof type) {
+                    correct = true;
+                    break;
+                }
+            }
+            if (!correct) {
+                return;
+            }
+        }
+        return super.filter(event);
+    }
+}
+exports.Raw = Raw;

package/events/common.d.ts

@@ -0,0 +1,66 @@
+import { Api } from "../tl";
+import type { Entity, EntityLike } from "../define";
+import { ChatGetter } from "../tl/custom";
+import type { TelegramClient } from "..";
+import { SenderGetter } from "../tl/custom/senderGetter";
+import bigInt from "big-integer";
+/** @hidden */
+export declare function _intoIdSet(client: TelegramClient, chats: EntityLike[] | EntityLike | undefined): Promise<string[] | undefined>;
+export interface DefaultEventInterface {
+    /**
+     * May be one or more entities (username/peer/etc.), preferably IDs.<br/>
+     * By default, only matching chats will be handled.
+     */
+    chats?: EntityLike[];
+    /**
+     * Whether to treat the chats as a blacklist instead of as a whitelist (default).<br/>
+     * This means that every chat will be handled *except* those specified in ``chats``<br/>
+     * which will be ignored if ``blacklistChats:true``.
+     */
+    blacklistChats?: boolean;
+    /**
+     * A callable function that should accept the event as input
+     * parameter, and return a value indicating whether the event
+     * should be dispatched or not (any truthy value will do, it
+     * does not need to be a `bool`). It works like a custom filter:
+     */
+    func?: CallableFunction;
+}
+/**
+ * The common event builder, with builtin support to filter per chat.<br/>
+ * All events inherit this.
+ */
+export declare class EventBuilder {
+    chats?: string[];
+    blacklistChats: boolean;
+    resolved: boolean;
+    func?: CallableFunction;
+    client?: TelegramClient;
+    constructor(eventParams: DefaultEventInterface);
+    build(update: Api.TypeUpdate, callback?: CallableFunction, selfId?: bigInt.BigInteger): any;
+    resolve(client: TelegramClient): Promise<void>;
+    _resolve(client: TelegramClient): Promise<void>;
+    filter(event: EventCommon | EventCommonSender): undefined | EventCommon | EventCommonSender;
+}
+interface EventCommonInterface {
+    chatPeer?: EntityLike;
+    msgId?: number;
+    broadcast?: boolean;
+}
+export declare class EventCommon extends ChatGetter {
+    _eventName: string;
+    _entities: Map<string, Entity>;
+    _messageId?: number;
+    constructor({ chatPeer, msgId, broadcast, }: EventCommonInterface);
+    _setClient(client: TelegramClient): void;
+    get client(): TelegramClient | undefined;
+}
+export declare class EventCommonSender extends SenderGetter {
+    _eventName: string;
+    _entities: Map<string, Entity>;
+    _messageId?: number;
+    constructor({ chatPeer, msgId, broadcast, }: EventCommonInterface);
+    _setClient(client: TelegramClient): void;
+    get client(): TelegramClient | undefined;
+}
+export {};

package/events/common.js

@@ -0,0 +1,141 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventCommonSender = exports.EventCommon = exports.EventBuilder = void 0;
+exports._intoIdSet = _intoIdSet;
+const tl_1 = require("../tl");
+const custom_1 = require("../tl/custom");
+const Helpers_1 = require("../Helpers");
+const __1 = require("..");
+const senderGetter_1 = require("../tl/custom/senderGetter");
+const big_integer_1 = __importDefault(require("big-integer"));
+const Utils_1 = require("../Utils");
+/** @hidden */
+async function _intoIdSet(client, chats) {
+    if (chats == undefined) {
+        return undefined;
+    }
+    if (!(0, Helpers_1.isArrayLike)(chats)) {
+        chats = [chats];
+    }
+    const result = new Set();
+    for (let chat of chats) {
+        if (typeof chat == "number" ||
+            typeof chat == "bigint" ||
+            (typeof chat == "string" && (0, Utils_1.parseID)(chat)) ||
+            big_integer_1.default.isInstance(chat)) {
+            chat = (0, Helpers_1.returnBigInt)(chat);
+            if (chat.lesser(0)) {
+                result.add(chat.toString());
+            }
+            else {
+                result.add(__1.utils.getPeerId(new tl_1.Api.PeerUser({
+                    userId: chat,
+                })));
+                result.add(__1.utils.getPeerId(new tl_1.Api.PeerChat({
+                    chatId: chat,
+                })));
+                result.add(__1.utils.getPeerId(new tl_1.Api.PeerChannel({
+                    channelId: chat,
+                })));
+            }
+        }
+        else if (typeof chat == "object" &&
+            chat.SUBCLASS_OF_ID == 0x2d45687) {
+            result.add(__1.utils.getPeerId(chat));
+        }
+        else {
+            chat = await client.getInputEntity(chat);
+            if (chat instanceof tl_1.Api.InputPeerSelf) {
+                chat = await client.getMe(true);
+            }
+            result.add(__1.utils.getPeerId(chat));
+        }
+    }
+    return Array.from(result);
+}
+/**
+ * The common event builder, with builtin support to filter per chat.<br/>
+ * All events inherit this.
+ */
+class EventBuilder {
+    constructor(eventParams) {
+        var _a;
+        this.chats = (_a = eventParams.chats) === null || _a === void 0 ? void 0 : _a.map((x) => x.toString());
+        this.blacklistChats = eventParams.blacklistChats || false;
+        this.resolved = false;
+        this.func = eventParams.func;
+    }
+    build(update, callback, selfId) {
+        if (update)
+            return update;
+    }
+    async resolve(client) {
+        if (this.resolved) {
+            return;
+        }
+        await this._resolve(client);
+        this.resolved = true;
+    }
+    async _resolve(client) {
+        this.chats = await _intoIdSet(client, this.chats);
+    }
+    filter(event) {
+        if (!this.resolved) {
+            return;
+        }
+        if (this.chats != undefined) {
+            if (event.chatId == undefined) {
+                return;
+            }
+            const inside = this.chats.includes(event.chatId.toString());
+            if (inside == this.blacklistChats) {
+                // If this chat matches but it's a blacklist ignore.
+                // If it doesn't match but it's a whitelist ignore.
+                return;
+            }
+        }
+        if (this.func && !this.func(event)) {
+            return;
+        }
+        return event;
+    }
+}
+exports.EventBuilder = EventBuilder;
+class EventCommon extends custom_1.ChatGetter {
+    constructor({ chatPeer = undefined, msgId = undefined, broadcast = undefined, }) {
+        super();
+        this._eventName = "Event";
+        custom_1.ChatGetter.initChatClass(this, { chatPeer, broadcast });
+        this._entities = new Map();
+        this._client = undefined;
+        this._messageId = msgId;
+    }
+    _setClient(client) {
+        this._client = client;
+    }
+    get client() {
+        return this._client;
+    }
+}
+exports.EventCommon = EventCommon;
+class EventCommonSender extends senderGetter_1.SenderGetter {
+    constructor({ chatPeer = undefined, msgId = undefined, broadcast = undefined, }) {
+        super();
+        this._eventName = "Event";
+        custom_1.ChatGetter.initChatClass(this, { chatPeer, broadcast });
+        senderGetter_1.SenderGetter.initChatClass(this, { chatPeer, broadcast });
+        this._entities = new Map();
+        this._client = undefined;
+        this._messageId = msgId;
+    }
+    _setClient(client) {
+        this._client = client;
+    }
+    get client() {
+        return this._client;
+    }
+}
+exports.EventCommonSender = EventCommonSender;

package/events/index.d.ts

@@ -0,0 +1,2 @@
+export { Raw } from "./Raw";
+export { NewMessage, NewMessageEvent } from "./NewMessage";

package/events/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NewMessageEvent = exports.NewMessage = exports.Raw = void 0;
+var Raw_1 = require("./Raw");
+Object.defineProperty(exports, "Raw", { enumerable: true, get: function () { return Raw_1.Raw; } });
+var NewMessage_1 = require("./NewMessage");
+Object.defineProperty(exports, "NewMessage", { enumerable: true, get: function () { return NewMessage_1.NewMessage; } });
+Object.defineProperty(exports, "NewMessageEvent", { enumerable: true, get: function () { return NewMessage_1.NewMessageEvent; } });

package/extensions/AsyncQueue.d.ts

@@ -0,0 +1,10 @@
+export declare class AsyncQueue {
+    _queue: any[];
+    private canGet;
+    private resolveGet;
+    private canPush;
+    private resolvePush;
+    constructor();
+    push(value: any): Promise<void>;
+    pop(): Promise<any>;
+}

package/extensions/AsyncQueue.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AsyncQueue = void 0;
+class AsyncQueue {
+    constructor() {
+        this._queue = [];
+        this.canPush = true;
+        this.resolvePush = (value) => { };
+        this.resolveGet = (value) => { };
+        this.canGet = new Promise((resolve) => {
+            this.resolveGet = resolve;
+        });
+    }
+    async push(value) {
+        await this.canPush;
+        this._queue.push(value);
+        this.resolveGet(true);
+        this.canPush = new Promise((resolve) => {
+            this.resolvePush = resolve;
+        });
+    }
+    async pop() {
+        await this.canGet;
+        const returned = this._queue.pop();
+        this.resolvePush(true);
+        this.canGet = new Promise((resolve) => {
+            this.resolveGet = resolve;
+        });
+        return returned;
+    }
+}
+exports.AsyncQueue = AsyncQueue;

package/extensions/BinaryReader.d.ts

@@ -0,0 +1,99 @@
+export declare class BinaryReader {
+    private readonly stream;
+    private _last?;
+    offset: number;
+    /**
+     * Small utility class to read binary data.
+     * @param data {Buffer}
+     */
+    constructor(data: Buffer);
+    /**
+     * Reads a single byte value.
+     */
+    readByte(): number;
+    /**
+     * Reads an integer (4 bytes or 32 bits) value.
+     * @param signed {Boolean}
+     */
+    readInt(signed?: boolean): number;
+    /**
+     * Reads a long integer (8 bytes or 64 bits) value.
+     * @param signed
+     * @returns {BigInteger}
+     */
+    readLong(signed?: boolean): import("big-integer").BigInteger;
+    /**
+     * Reads a real floating point (4 bytes) value.
+     * @returns {number}
+     */
+    readFloat(): number;
+    /**
+     * Reads a real floating point (8 bytes) value.
+     * @returns {BigInteger}
+     */
+    readDouble(): number;
+    /**
+     * Reads a n-bits long integer value.
+     * @param bits
+     * @param signed {Boolean}
+     */
+    readLargeInt(bits: number, signed?: boolean): import("big-integer").BigInteger;
+    /**
+     * Read the given amount of bytes, or -1 to read all remaining.
+     * @param length {number}
+     * @param checkLength {boolean} whether to check if the length overflows or not.
+     */
+    read(length?: number, checkLength?: boolean): Buffer<ArrayBuffer>;
+    /**
+     * Gets the byte array representing the current buffer as a whole.
+     * @returns {Buffer}
+     */
+    getBuffer(): Buffer<ArrayBufferLike>;
+    /**
+     * Reads a Telegram-encoded byte array, without the need of
+     * specifying its length.
+     * @returns {Buffer}
+     */
+    tgReadBytes(): Buffer<ArrayBuffer>;
+    /**
+     * Reads a Telegram-encoded string.
+     * @returns {string}
+     */
+    tgReadString(): string;
+    /**
+     * Reads a Telegram boolean value.
+     * @returns {boolean}
+     */
+    tgReadBool(): boolean;
+    /**
+     * Reads and converts Unix time (used by Telegram)
+     * into a Javascript {Date} object.
+     * @returns {Date}
+     */
+    tgReadDate(): Date;
+    /**
+     * Reads a Telegram object.
+     */
+    tgReadObject(): any;
+    /**
+     * Reads a vector (a list) of Telegram objects.
+     * @returns {[Buffer]}
+     */
+    tgReadVector(): any[];
+    /**
+     * Tells the current position on the stream.
+     * @returns {number}
+     */
+    tellPosition(): number;
+    /**
+     * Sets the current position on the stream.
+     * @param position
+     */
+    setPosition(position: number): void;
+    /**
+     * Seeks the stream position given an offset from the current position.
+     * The offset may be negative.
+     * @param offset
+     */
+    seek(offset: number): void;
+}