@mtkruto/node 0.0.834 → 0.0.900

package/esm/types/2_reply_keyboard_markup.js

@@ -0,0 +1,37 @@
+import { as } from "../tl/1_tl_object.js";
+import * as types from "../tl/2_types.js";
+import { constructKeyboardButton, keyboardButtonToTlObject } from "./1_keyboard_button.js";
+export function constructReplyKeyboardMarkup(keyboard_) {
+    const rows = new Array();
+    for (const row_ of keyboard_.rows.map((v) => v[as](types.KeyboardButtonRow))) {
+        const row = new Array();
+        for (const button_ of row_.buttons) {
+            row.push(constructKeyboardButton(button_));
+        }
+        rows.push(row);
+    }
+    return {
+        resizeKeyboard: keyboard_.resize || false,
+        oneTimeKeyboard: keyboard_.singleUse || false,
+        selective: keyboard_.selective || false,
+        isPersistent: keyboard_.persistent || false,
+        keyboard: rows,
+    };
+}
+export function replyKeyboardMarkupToTlObject(replyMarkup) {
+    const rows_ = new Array();
+    for (const row of replyMarkup.keyboard) {
+        const row_ = new Array();
+        for (const button of row) {
+            row_.push(keyboardButtonToTlObject(button));
+        }
+        rows_.push(new types.KeyboardButtonRow({ buttons: row_ }));
+    }
+    return new types.ReplyKeyboardMarkup({
+        resize: replyMarkup.resizeKeyboard || undefined,
+        singleUse: replyMarkup.oneTimeKeyboard || undefined,
+        selective: replyMarkup.selective || undefined,
+        persistent: replyMarkup.isPersistent || undefined,
+        rows: rows_,
+    });
+}

package/esm/types/3_message.d.ts

@@ -0,0 +1,26 @@
+import * as types from "../tl/2_types.js";
+import { ForceReply } from "./0_force_reply.js";
+import { MessageEntity } from "./0_message_entity.js";
+import { ReplyKeyboardRemove } from "./0_reply_keyboard_remove.js";
+import { Chat } from "./1_chat.js";
+import { User } from "./1_user.js";
+import { InlineKeyboardMarkup } from "./2_inline_keyboard_markup.js";
+import { ReplyKeyboardMarkup } from "./2_reply_keyboard_markup.js";
+export interface Message {
+    id: number;
+    from?: User;
+    chat: Chat;
+    text?: string;
+    caption?: string;
+    entities?: MessageEntity[];
+    captionEntities?: MessageEntity[];
+    date?: Date;
+    editDate?: Date;
+    views?: number;
+    replyMarkup?: InlineKeyboardMarkup | ReplyKeyboardMarkup | ReplyKeyboardRemove | ForceReply;
+}
+export declare function constructMessage(message_: types.Message, getEntity: {
+    (peer: types.PeerUser): Promise<types.User | null>;
+    (peer: types.PeerChat): Promise<types.Chat | null>;
+    (peer: types.PeerChannel): Promise<types.Channel | null>;
+}): Promise<Message>;

package/esm/types/3_message.js

@@ -0,0 +1,91 @@
+import { UNREACHABLE } from "../utilities/0_control.js";
+import { cleanObject } from "../utilities/0_object.js";
+import * as types from "../tl/2_types.js";
+import { constructForceReply } from "./0_force_reply.js";
+import { constructMessageEntity } from "./0_message_entity.js";
+import { constructReplyKeyboardRemove } from "./0_reply_keyboard_remove.js";
+import { constructChat } from "./1_chat.js";
+import { constructUser } from "./1_user.js";
+import { constructInlineKeyboardMarkup } from "./2_inline_keyboard_markup.js";
+import { constructReplyKeyboardMarkup } from "./2_reply_keyboard_markup.js";
+export async function constructMessage(message_, getEntity) {
+    let chat_ = null;
+    if (message_.peerId instanceof types.PeerUser) {
+        const entity = await getEntity(message_.peerId);
+        if (entity) {
+            chat_ = constructChat(entity);
+        }
+        else {
+            UNREACHABLE();
+        }
+    }
+    else if (message_.peerId instanceof types.PeerChat) {
+        const entity = await getEntity(message_.peerId);
+        if (entity) {
+            chat_ = constructChat(entity);
+        }
+        else {
+            UNREACHABLE();
+        }
+    }
+    else if (message_.peerId instanceof types.PeerChannel) {
+        const entity = await getEntity(message_.peerId);
+        if (entity) {
+            chat_ = constructChat(entity);
+        }
+        else {
+            UNREACHABLE();
+        }
+    }
+    else {
+        UNREACHABLE();
+    }
+    const message = { id: message_.id, chat: chat_, views: message_.views };
+    if (message_.fromId instanceof types.PeerUser) {
+        const entity = await getEntity(message_.fromId);
+        if (entity) {
+            message.from = constructUser(entity);
+        }
+        else {
+            UNREACHABLE();
+        }
+    }
+    if (message_.message) {
+        if (message_.media == undefined) {
+            message.text = message_.message;
+        }
+        else {
+            message.caption = message_.message;
+        }
+    }
+    if (message_.entities != undefined) {
+        if (message_.media == undefined) {
+            message.entities = message_.entities.map(constructMessageEntity).filter((v) => v);
+        }
+        else {
+            message.captionEntities = message_.entities.map(constructMessageEntity).filter((v) => v);
+        }
+    }
+    message.date = new Date(message_.date * 1000);
+    if (message_.editDate != undefined) {
+        message.editDate = new Date(message_.editDate * 1000);
+    }
+    if (message_.replyMarkup) {
+        if (message_.replyMarkup instanceof types.ReplyKeyboardMarkup) {
+            message.replyMarkup = constructReplyKeyboardMarkup(message_.replyMarkup);
+        }
+        else if (message_.replyMarkup instanceof types.ReplyInlineMarkup) {
+            message.replyMarkup = constructInlineKeyboardMarkup(message_.replyMarkup);
+        }
+        else if (message_.replyMarkup instanceof types.ReplyKeyboardHide) {
+            message.replyMarkup = constructReplyKeyboardRemove(message_.replyMarkup);
+        }
+        else if (message_.replyMarkup instanceof types.ReplyKeyboardForceReply) {
+            message.replyMarkup = constructForceReply(message_.replyMarkup);
+        }
+        else {
+            UNREACHABLE();
+        }
+    }
+    return cleanObject(message);
+}

package/esm/utilities/0_control.d.ts

@@ -0,0 +1 @@
+export declare function UNREACHABLE(): never;

package/esm/utilities/0_control.js

@@ -0,0 +1,3 @@
+export function UNREACHABLE() {
+    throw new Error("Unreachable");
+}

package/esm/utilities/0_object.d.ts

@@ -0,0 +1 @@
+export declare function cleanObject<T extends Record<string, any>>(object: T): T;

package/esm/utilities/0_object.js

@@ -0,0 +1,14 @@
+// deno-lint-ignore no-explicit-any
+export function cleanObject(object) {
+    for (const [k, v] of Object.entries(object)) {
+        switch (typeof v) {
+            case "undefined":
+                delete object[k];
+                break;
+            case "object":
+                // @ts-ignore: this works, no idea why it complains
+                object[k] = cleanObject(v);
+        }
+    }
+    return object;
+}

package/esm/utilities/0_types.js

@@ -0,0 +1 @@
+export {};

package/esm/utilities/1_message.d.ts

@@ -1,5 +1,5 @@
-import { Message } from "../tl/5_message.js";
-import { MessageContainer } from "../tl/6_message_container.js";
+import { Message } from "../tl/6_message.js";
+import { MessageContainer } from "../tl/7_message_container.js";
 export declare function getMessageId(): bigint;
 export declare function packUnencryptedMessage(data: Uint8Array): Uint8Array;
 export declare function unpackUnencryptedMessage(buffer: Uint8Array): {

package/esm/utilities/1_message.js

@@ -3,9 +3,9 @@ import { TLRawReader } from "../tl/0_tl_raw_reader.js";
 import { TLRawWriter } from "../tl/0_tl_raw_writer.js";
 import { id, serialize } from "../tl/1_tl_object.js";
 import { TLReader } from "../tl/3_tl_reader.js";
-import { RPCResult } from "../tl/4_rpc_result.js";
-import { Message } from "../tl/5_message.js";
-import { MessageContainer } from "../tl/6_message_container.js";
+import { RPCResult } from "../tl/5_rpc_result.js";
+import { Message } from "../tl/6_message.js";
+import { MessageContainer } from "../tl/7_message_container.js";
 import { bufferFromBigInt, concat } from "./0_buffer.js";
 import { sha256 } from "./0_hash.js";
 let lastMsgId = 0n;

package/esm/utilities/1_password.js

@@ -30,7 +30,7 @@ export function isSafePrime(primeBytes, g) {
         0xB9, 0x2F, 0xCC, 0x5B,
     ]);
     if (goodPrime.every((v, i) => v == primeBytes[i])) {
-        if ([3, 4, 5, 7].includes(g)) { // It's good
+        if ([3, 4, 5, 7].includes(g)) {
             return true;
         }
     }

package/package.json

@@ -2,7 +2,7 @@
   "module": "./esm/mod.js",
   "main": "./script/mod.js",
   "name": "@mtkruto/node",
-  "version": "0.0.834",
+  "version": "0.0.900",
   "description": "MTKruto for Node.js",
   "author": "Roj <rojvv@icloud.com>",
   "license": "LGPL-3.0-or-later",

package/script/client/client.d.ts

@@ -1,10 +1,17 @@
-import { MaybePromise } from "../types.js";
+import { MaybePromise } from "../utilities/0_types.js";
 import * as types from "../tl/2_types.js";
 import * as functions from "../tl/3_functions.js";
+import { ReadObject } from "../tl/3_tl_reader.js";
 import { ClientAbstract } from "./client_abstract.js";
 import { Storage } from "../storage/storage.js";
 import { DC, TransportProvider } from "../transport/transport_provider.js";
 import { MessageEntity } from "../types/0_message_entity.js";
+import { ReplyKeyboardRemove } from "../types/0_reply_keyboard_remove.js";
+import { ForceReply } from "../types/0_force_reply.js";
+import { ReplyKeyboardMarkup } from "../types/2_reply_keyboard_markup.js";
+import { InlineKeyboardMarkup } from "../types/2_inline_keyboard_markup.js";
+import { Message } from "../types/3_message.js";
+export declare const getEntity: unique symbol;
 export declare const restartAuth: unique symbol;
 export declare enum ParseMode {
     None = "none",
@@ -15,7 +22,7 @@ export interface AuthorizeUserParams<S = string> {
     code: S | (() => MaybePromise<S>);
     password: S | (() => MaybePromise<S>);
 }
-export type UpdatesHandler = null | ((client: Client, update: types.Updates) => MaybePromise<void>);
+export type UpdateHandler = null | ((client: Client, update: types.TypeUpdate) => MaybePromise<void>);
 export interface ClientParams {
     /**
      * Default parse mode. Defauls to `ParseMode.None`.
@@ -59,7 +66,8 @@ export declare class Client extends ClientAbstract {
     private state;
     private promises;
     private toAcknowledge;
-    updatesHandler: UpdatesHandler;
+    private updateState?;
+    updateHandler: UpdateHandler;
     readonly parseMode: ParseMode;
     readonly appVersion: string;
     readonly deviceModel: string;
@@ -91,6 +99,7 @@ export declare class Client extends ClientAbstract {
      * Before establishing the connection, the session is saved.
      */
     connect(): Promise<void>;
+    private fetchState;
     /**
      * Calls [initConnection](1) and authorizes the client with one of the following:
      *
@@ -109,6 +118,7 @@ export declare class Client extends ClientAbstract {
      * [2]: https://core.telegram.org/method/updates.getState
      */
     authorize(params: string | types.AuthExportedAuthorization | AuthorizeUserParams): Promise<void>;
+    private messageProcessQueue;
     private receiveLoop;
     private pingLoop;
     /**
@@ -125,8 +135,20 @@ export declare class Client extends ClientAbstract {
     send<T extends (functions.Function<unknown> | types.Type) = functions.Function<unknown>>(function_: T): Promise<void>;
     private processChats;
     private processUsers;
+    private updateApplicationMutex;
+    private applyUpdateNoGap;
+    private applyUpdate;
     private processUpdates;
+    private setUpdateStateDate;
+    private getLocalState;
+    private updateGapRecoveryMutex;
+    private recoverUpdateGap;
+    private recoverChannelUpdateGap;
     getInputPeer(id: string | number): Promise<types.InputPeerChat | types.InputPeerUser | types.InputPeerChannel>;
+    [getEntity](peer: types.PeerUser): Promise<types.User | null>;
+    [getEntity](peer: types.PeerChat): Promise<types.Chat | null>;
+    [getEntity](peer: types.PeerChannel): Promise<types.Channel | null>;
+    processResult(result: ReadObject): Promise<void>;
     sendMessage(chatId: number | string, text: string, params?: {
         parseMode?: ParseMode;
         entities?: MessageEntity[];
@@ -136,5 +158,8 @@ export declare class Client extends ClientAbstract {
         replyToMessageId?: number;
         messageThreadId?: number;
         sendAs?: number | string;
-    }): Promise<types.TypeUpdates>;
+        replyMarkup?: InlineKeyboardMarkup | ReplyKeyboardMarkup | ReplyKeyboardRemove | ForceReply;
+    }): Promise<Message>;
+    getMessages(chatId: number | string, messageIds: number[]): Promise<Message[]>;
+    getMessage(chatId: number | string, messageId: number): Promise<Message | null>;
 }