@mtkruto/node 0.1.132 → 0.1.134

package/esm/types/{3_message.js → 4_message.js}

@@ -2,7 +2,6 @@ import { debug } from "../0_deps.js";
 import { cleanObject, UNREACHABLE, ZERO_CHANNEL_ID } from "../1_utilities.js";
 import { as, types } from "../2_tl.js";
 import { FileID, FileType, FileUniqueID, FileUniqueType } from "./0__file_id.js";
-import { constructAudio } from "./0_audio.js";
 import { constructContact } from "./0_contact.js";
 import { constructDice } from "./0_dice.js";
 import { constructForceReply } from "./0_force_reply.js";
@@ -12,11 +11,14 @@ import { constructReplyKeyboardRemove } from "./0_reply_keyboard_remove.js";
 import { constructVenue } from "./0_venue.js";
 import { constructVoice } from "./0_voice.js";
 import { constructAnimation } from "./1_animation.js";
-import { constructReplyQuote } from "./1_reply_quote.js";
+import { constructAudio } from "./1_audio.js";
 import { constructChatP } from "./1_chat_p.js";
 import { constructDocument } from "./1_document.js";
+import { constructGiveaway } from "./1_giveaway.js";
+import { constructMessageReaction } from "./1_message_reaction.js";
 import { constructPhoto } from "./1_photo.js";
 import { constructPoll } from "./1_poll.js";
+import { constructReplyQuote } from "./1_reply_quote.js";
 import { constructSticker } from "./1_sticker.js";
 import { constructUser } from "./1_user.js";
 import { constructVideoNote } from "./1_video_note.js";
@@ -25,6 +27,54 @@ import { constructGame } from "./2_game.js";
 import { constructReplyKeyboardMarkup } from "./2_reply_keyboard_markup.js";
 import { constructInlineKeyboardMarkup } from "./3_inline_keyboard_markup.js";
 const d = debug("types/Message");
+const keys = {
+    text: ["text"],
+    photo: ["photo"],
+    document: ["document"],
+    video: ["video"],
+    sticker: ["sticker"],
+    animation: ["animation"],
+    voice: ["voice"],
+    audio: ["audio"],
+    dice: ["dice"],
+    videoNote: ["videoNote"],
+    contact: ["contact"],
+    game: ["game"],
+    poll: ["poll"],
+    venue: ["venue"],
+    location: ["location"],
+    newChatMembers: ["newChatMembers"],
+    leftChatMember: ["leftChatMember"],
+    newChatTitle: ["newChatTitle"],
+    newChatPhoto: ["newChatPhoto"],
+    deletedChatPhoto: ["deletedChatPhoto"],
+    groupCreated: ["groupCreated", "newChatMembers"],
+    supergroupCreated: ["supergroupCreated"],
+    channelCreated: ["channelCreated"],
+    newAutoDeleteTime: ["newAutoDeleteTime"],
+    chatMigratedTo: ["chatMigratedTo"],
+    chatMigratedFrom: ["chatMigratedFrom"],
+    pinnedMessage: ["pinnedMessage"],
+    userShared: ["userShared"],
+    writeAccessAllowed: ["writeAccessAllowed"],
+    forumTopicCreated: ["forumTopicCreated"],
+    forumTopicEdited: ["forumTopicEdited"],
+    forumTopicClosed: ["forumTopicClosed"],
+    forumTopicReopened: ["forumTopicReopened"],
+    videoChatScheduled: ["videoChatScheduled"],
+    videoChatStarted: ["videoChatStarted"],
+    videoChatEnded: ["videoChatEnded"],
+    giveaway: ["giveaway"],
+    unsupported: ["unsupported"],
+};
+export function assertMessageType(message, type) {
+    for (const key of keys[type]) {
+        if (!(key in message) || message[key] === undefined) {
+            UNREACHABLE();
+        }
+    }
+    return message;
+}
 async function getSender(message_, getEntity) {
     if (message_.from_id instanceof types.PeerUser) {
         const entity = await getEntity(message_.from_id);
@@ -71,116 +121,133 @@ async function constructServiceMessage(message_, chat, getEntity, getMessage) {
     };
     Object.assign(message, await getSender(message_, getEntity));
     if (message_.action instanceof types.MessageActionChatAddUser) {
-        message.newChatMembers = [];
+        const newChatMembers = new Array();
         for (const user_ of message_.action.users) {
             const entity = await getEntity(new types.PeerUser({ user_id: user_ }));
             if (entity) {
                 const user = constructUser(entity);
-                message.newChatMembers.push(user);
+                newChatMembers.push(user);
             }
             else {
                 UNREACHABLE();
             }
         }
+        return { ...message, newChatMembers };
     }
     else if (message_.action instanceof types.MessageActionChatDeleteUser) {
         const entity = await getEntity(new types.PeerUser({ user_id: message_.action.user_id }));
         if (entity) {
             const user = constructUser(entity);
-            message.leftChatMember = user;
-        }
-        else {
-            UNREACHABLE();
+            const leftChatMember = user;
+            return { ...message, leftChatMember };
         }
     }
     else if (message_.action instanceof types.MessageActionChatEditTitle) {
-        message.newChatTitle = message_.action.title;
+        const newChatTitle = message_.action.title;
+        return { ...message, newChatTitle };
     }
     else if (message_.action instanceof types.MessageActionChatEditPhoto) {
-        message.newChatPhoto = constructPhoto(message_.action.photo[as](types.Photo));
+        const newChatPhoto = constructPhoto(message_.action.photo[as](types.Photo));
+        return { ...message, newChatPhoto };
     }
     else if (message_.action instanceof types.MessageActionChatDeletePhoto) {
-        message.deletedChatPhoto = true;
+        const deletedChatPhoto = true;
+        return { ...message, deletedChatPhoto };
     }
     else if (message_.action instanceof types.MessageActionChatCreate) {
-        message.groupCreated = true;
-        message.newChatMembers = [];
+        const groupCreated = true;
+        const newChatMembers = new Array();
         for (const user_ of message_.action.users) {
             const entity = await getEntity(new types.PeerUser({ user_id: user_ }));
             if (entity) {
                 const user = constructUser(entity);
-                message.newChatMembers.push(user);
-            }
-            else {
-                UNREACHABLE();
+                newChatMembers.push(user);
             }
         }
+        return { ...message, groupCreated, newChatMembers };
     }
     else if (message_.action instanceof types.MessageActionChannelCreate) {
         if (message.chat.type == "channel") {
-            message.channelCreated = true;
+            const channelCreated = true;
+            return { ...message, channelCreated };
         }
         else if (message.chat.type == "supergroup") {
-            message.supergroupCreated = true;
+            const supergroupCreated = true;
+            return { ...message, supergroupCreated };
         }
         else {
-            UNREACHABLE();
+            // UNREACHABLE();
         }
     }
     else if (message_.action instanceof types.MessageActionChatMigrateTo) {
-        message.chatMigratedTo = ZERO_CHANNEL_ID + Number(-message_.action.channel_id);
+        const chatMigratedTo = ZERO_CHANNEL_ID + Number(-message_.action.channel_id);
+        return { ...message, chatMigratedTo };
     }
     else if (message_.action instanceof types.MessageActionChannelMigrateFrom) {
-        message.chatMigratedFrom = Number(-message_.action.chat_id);
+        const chatMigratedFrom = Number(-message_.action.chat_id);
+        return { ...message, chatMigratedFrom };
     }
     else if (message_.action instanceof types.MessageActionPinMessage) {
         const { replyToMessage } = await getReply(message_, chat, getMessage);
-        message.pinnedMessage = replyToMessage;
+        if (replyToMessage) {
+            const pinnedMessage = replyToMessage;
+            return { ...message, pinnedMessage };
+        }
     }
     else if (message_.action instanceof types.MessageActionRequestedPeer) {
-        const user = message_.action.peer[as](types.PeerUser);
-        message.userShared = { requestId: message_.action.button_id, userId: Number(user.user_id) };
+        const user = message_.action.peers[0][as](types.PeerUser);
+        const userShared = { requestId: message_.action.button_id, userId: Number(user.user_id) };
+        return { ...message, userShared };
     }
     else if (message_.action instanceof types.MessageActionBotAllowed) {
         const webAppName = message_.action.app ? message_.action.app[as](types.BotApp).title : undefined;
-        message.writeAccessAllowed = { webAppName };
+        const writeAccessAllowed = { webAppName };
+        return { ...message, writeAccessAllowed };
     }
     else if (message_.action instanceof types.MessageActionTopicCreate) {
-        message.forumTopicCreated = {
+        const forumTopicCreated = {
             name: message_.action.title,
             iconColor: "#" + message_.action.icon_color.toString(16).padStart(6, "0"),
             iconCutsomEmojiId: message_.action.icon_emoji_id ? String(message_.action.icon_emoji_id) : undefined,
         };
+        return { ...message, forumTopicCreated };
     }
     else if (message_.action instanceof types.MessageActionTopicEdit) {
         if (message_.action.closed) {
-            message.forumTopicClosed = {};
+            const forumTopicClosed = true;
+            return { ...message, forumTopicClosed };
         }
         else if (message_.action.title || message_.action.icon_emoji_id) {
-            message.forumTopicEdited = {
-                name: message_.action.title,
+            const forumTopicEdited = {
+                name: message_.action.title ?? "",
                 iconCutsomEmojiId: message_.action.icon_emoji_id ? String(message_.action.icon_emoji_id) : undefined,
             };
+            return { ...message, forumTopicEdited };
         }
         else {
-            message.forumTopicReopened = {};
+            const forumTopicReopened = true;
+            return { ...message, forumTopicReopened };
         }
     }
     else if (message_.action instanceof types.MessageActionGroupCallScheduled) {
-        message.videoChatScheduled = { startDate: new Date(message_.action.schedule_date * 1000) };
+        const videoChatScheduled = { startDate: new Date(message_.action.schedule_date * 1000) };
+        return { ...message, videoChatScheduled };
     }
     else if (message_.action instanceof types.MessageActionGroupCall) {
         if (message_.action.duration) {
-            message.videoChatEnded = { duration: message_.action.duration };
+            const videoChatEnded = { duration: message_.action.duration };
+            return { ...message, videoChatEnded };
         }
         else {
-            message.videoChatStarted = {};
+            const videoChatStarted = true;
+            return { ...message, videoChatStarted };
         }
     }
     else if (message_.action instanceof types.MessageActionSetMessagesTTL) {
-        message.messageAutoDeleteTimerChanged = { messageAutoDeleteTime: message_.action.period || 0 };
+        const newAutoDeleteTime = message_.action.period || 0;
+        return { ...message, newAutoDeleteTime };
     }
-    return cleanObject(message);
+    return { ...message, unsupported: true };
 }
 export async function constructMessage(message_, getEntity, getMessage, getStickerSetName, getReply_ = true) {
     if (!(message_ instanceof types.Message) && !(message_ instanceof types.MessageService)) {
@@ -229,9 +296,14 @@ export async function constructMessage(message_, getEntity, getMessage, getStick
         link,
         date: new Date(message_.date * 1000),
         views: message_.views,
+        forwards: message_.forwards,
         isTopicMessage: false,
         hasProtectedContent: message_.noforwards || false,
     };
+    if (message_.reactions) {
+        const recentReactions = message_.reactions.recent_reactions ?? [];
+        message.reactions = message_.reactions.results.map((v) => constructMessageReaction(v, recentReactions));
+    }
     if (message_.reply_to instanceof types.MessageReplyHeader && message_.reply_to.reply_to_msg_id) {
         if (message_.reply_to.quote) {
             message.replyQuote = constructReplyQuote(message_.reply_to.quote_text, message_.reply_to.quote_offset, message_.reply_to.quote_entities);
@@ -242,31 +314,6 @@ export async function constructMessage(message_, getEntity, getMessage, getStick
         Object.assign(message, await getReply(message_, chat_, getMessage));
     }
     Object.assign(message, await getSender(message_, getEntity));
-    if (message_.media instanceof types.MessageMediaPhoto || message_.media instanceof types.MessageMediaDocument) {
-        message.hasMediaSpoiler = message_.media.spoiler || false;
-    }
-    if (message_.grouped_id != undefined) {
-        message.mediaGroupId = String(message_.grouped_id);
-    }
-    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);
-        }
-    }
-    if (message_.edit_date != undefined) {
-        message.editDate = new Date(message_.edit_date * 1000);
-    }
     if (message_.reply_markup) {
         if (message_.reply_markup instanceof types.ReplyKeyboardMarkup) {
             message.replyMarkup = constructReplyKeyboardMarkup(message_.reply_markup);
@@ -321,81 +368,121 @@ export async function constructMessage(message_, getEntity, getMessage, getStick
             }
         }
     }
-    if (message_.media) {
-        if (message_.media instanceof types.MessageMediaPhoto) {
-            if (message_.media.photo instanceof types.Photo) {
-                message.photo = constructPhoto(message_.media.photo);
-            }
+    if (message_.grouped_id != undefined) {
+        message.mediaGroupId = String(message_.grouped_id);
+    }
+    if (message_.edit_date != undefined) {
+        message.editDate = new Date(message_.edit_date * 1000);
+    }
+    if (message_.message && message_.media === undefined) {
+        return {
+            ...message,
+            text: message_.message,
+            entities: message_.entities?.map(constructMessageEntity).filter((v) => !!v) ?? [],
+        };
+    }
+    const messageMedia = {
+        ...message,
+        caption: message_.message,
+        captionEntities: message_.entities?.map(constructMessageEntity).filter((v) => !!v) ?? [],
+    };
+    if (message_.media instanceof types.MessageMediaPhoto || message_.media instanceof types.MessageMediaDocument) {
+        messageMedia.hasMediaSpoiler = message_.media.spoiler || false;
+    }
+    let m = null;
+    if (message_.media instanceof types.MessageMediaPhoto) {
+        if (!message_.media.photo) {
+            UNREACHABLE();
         }
-        else if (message_.media instanceof types.MessageMediaDice) {
-            message.dice = constructDice(message_.media);
-        }
-        else if (message_.media instanceof types.MessageMediaDocument) {
-            const { document } = message_.media;
-            if (document instanceof types.Document) {
-                const getFileId = (type) => new FileID(null, null, type, document.dc_id, {
-                    mediaId: document.id,
-                    accessHash: document.access_hash,
-                    fileReference: document.file_reference,
-                }).encode();
-                const fileUniqueId = new FileUniqueID(FileUniqueType.Document, { mediaId: document.id }).encode();
-                const animated = document.attributes.find((v) => v instanceof types.DocumentAttributeAnimated);
-                const audio = document.attributes.find((v) => v instanceof types.DocumentAttributeAudio);
-                const fileName = document.attributes.find((v) => v instanceof types.DocumentAttributeFilename);
-                const sticker = document.attributes.find((v) => v instanceof types.DocumentAttributeSticker);
-                const video = document.attributes.find((v) => v instanceof types.DocumentAttributeVideo);
-                if (animated) {
-                    message.animation = constructAnimation(document, video, fileName, getFileId(FileType.Animation), fileUniqueId);
-                }
-                else if (video) {
-                    if (video.round_message) {
-                        message.videoNote = constructVideoNote(document, video, getFileId(FileType.VideoNote), fileUniqueId);
-                    }
-                    else {
-                        message.video = constructVideo(document, video, fileName?.file_name, getFileId(FileType.Video), fileUniqueId);
-                    }
-                }
-                else if (audio) {
-                    if (audio.voice) {
-                        message.voice = constructVoice(document, audio, getFileId(FileType.Voice), fileUniqueId);
-                    }
-                    else {
-                        message.audio = constructAudio(document, audio, getFileId(FileType.Audio), fileUniqueId);
-                    }
+        const photo = constructPhoto(message_.media.photo[as](types.Photo));
+        m = { ...messageMedia, photo };
+    }
+    else if (message_.media instanceof types.MessageMediaDice) {
+        const dice = constructDice(message_.media);
+        m = { ...message, dice };
+    }
+    else if (message_.media instanceof types.MessageMediaDocument) {
+        const { document } = message_.media;
+        if (document instanceof types.Document) {
+            const getFileId = (type) => new FileID(null, null, type, document.dc_id, {
+                mediaId: document.id,
+                accessHash: document.access_hash,
+                fileReference: document.file_reference,
+            }).encode();
+            const fileUniqueId = new FileUniqueID(FileUniqueType.Document, { mediaId: document.id }).encode();
+            const animated = document.attributes.find((v) => v instanceof types.DocumentAttributeAnimated);
+            const audio = document.attributes.find((v) => v instanceof types.DocumentAttributeAudio);
+            const fileName = document.attributes.find((v) => v instanceof types.DocumentAttributeFilename);
+            const sticker = document.attributes.find((v) => v instanceof types.DocumentAttributeSticker);
+            const video = document.attributes.find((v) => v instanceof types.DocumentAttributeVideo);
+            if (animated) {
+                const animation = constructAnimation(document, video, fileName, getFileId(FileType.Animation), fileUniqueId);
+                m = { ...messageMedia, animation };
+            }
+            else if (video) {
+                if (video.round_message) {
+                    const videoNote = constructVideoNote(document, video, getFileId(FileType.VideoNote), fileUniqueId);
+                    m = { ...message, videoNote };
                 }
-                else if (sticker) {
-                    message.sticker = await constructSticker(document, getFileId(FileType.Sticker), fileUniqueId, getStickerSetName);
+                else {
+                    const video_ = constructVideo(document, video, fileName?.file_name, getFileId(FileType.Video), fileUniqueId);
+                    m = { ...messageMedia, video: video_ };
                 }
-                else if (fileName) {
-                    message.document = constructDocument(document, fileName, getFileId(FileType.Document), fileUniqueId);
+            }
+            else if (audio) {
+                if (audio.voice) {
+                    const voice = constructVoice(document, audio, getFileId(FileType.Voice), fileUniqueId);
+                    m = { ...messageMedia, voice };
                 }
                 else {
-                    message.document = constructDocument(document, new types.DocumentAttributeFilename({ file_name: "Unknown" }), getFileId(FileType.Document), fileUniqueId);
+                    const audio_ = constructAudio(document, audio, getFileId(FileType.Audio), fileUniqueId);
+                    m = { ...messageMedia, audio: audio_ };
                 }
             }
+            else if (sticker) {
+                const sticker = await constructSticker(document, getFileId(FileType.Sticker), fileUniqueId, getStickerSetName);
+                m = { ...message, sticker };
+            }
+            else if (fileName) {
+                const document_ = constructDocument(document, fileName, getFileId(FileType.Document), fileUniqueId);
+                m = { ...messageMedia, document: document_ };
+            }
+            else {
+                const document_ = constructDocument(document, new types.DocumentAttributeFilename({ file_name: "Unknown" }), getFileId(FileType.Document), fileUniqueId);
+                m = { ...messageMedia, document: document_ };
+            }
         }
-        else if (message_.media instanceof types.MessageMediaContact) {
-            message.contact = constructContact(message_.media);
-        }
-        else if (message_.media instanceof types.MessageMediaGame) {
-            message.game = constructGame(message_.media);
-        }
-        else if (message_.media instanceof types.MessageMediaPoll) {
-            message.poll = constructPoll(message_.media);
-        }
-        else if (message_.media instanceof types.MessageMediaVenue) {
-            message.venue = constructVenue(message_.media);
-        }
-        else if (message_.media instanceof types.MessageMediaGeo || message_.media instanceof types.MessageMediaGeoLive) {
-            message.location = constructLocation(message_.media);
-        }
-        else if (message_.media instanceof types.MessageMediaWebPage) {
-            //
-        }
-        else {
-            // not implemented
-            UNREACHABLE();
-        }
     }
-    return cleanObject(message);
+    else if (message_.media instanceof types.MessageMediaContact) {
+        const contact = constructContact(message_.media);
+        m = { ...messageMedia, contact };
+    }
+    else if (message_.media instanceof types.MessageMediaGame) {
+        const game = constructGame(message_.media);
+        m = { ...message, game };
+    }
+    else if (message_.media instanceof types.MessageMediaPoll) {
+        const poll = constructPoll(message_.media);
+        m = { ...message, poll };
+    }
+    else if (message_.media instanceof types.MessageMediaVenue) {
+        const venue = constructVenue(message_.media);
+        m = { ...message, venue };
+    }
+    else if (message_.media instanceof types.MessageMediaGeo || message_.media instanceof types.MessageMediaGeoLive) {
+        const location = constructLocation(message_.media);
+        m = { ...message, location };
+    }
+    else if (message_.media instanceof types.MessageMediaWebPage) {
+        // TODO: implement
+    }
+    else if (message_.media instanceof types.MessageMediaGiveaway) {
+        const giveaway = constructGiveaway(message_.media);
+        m = { ...message, giveaway };
+    }
+    if (m == null) {
+        const unsupported = true;
+        m = { ...message, unsupported };
+    }
+    return cleanObject(m);
 }

package/{script/types/4_callback_query.d.ts → esm/types/5_callback_query.d.ts}

@@ -1,7 +1,7 @@
 import { types } from "../2_tl.js";
 import { EntityGetter } from "./1__getters.js";
 import { User } from "./1_user.js";
-import { Message, MessageGetter } from "./3_message.js";
+import { Message, MessageGetter } from "./4_message.js";
 export interface CallbackQuery {
     id: string;
     from: User;

package/esm/types/5_chat.d.ts

@@ -0,0 +1,37 @@
+import { enums, types } from "../2_tl.js";
+import { ChatPhotoChat, ChatPhotoUser } from "./0_chat_photo.js";
+import { EntityGetter } from "./1__getters.js";
+import { ChatPChannel, ChatPGroup, ChatPPrivate, ChatPSupergroup } from "./1_chat_p.js";
+import { StickerSetNameGetter } from "./1_sticker.js";
+import { Message, MessageGetter } from "./4_message.js";
+/** @unlisted */
+export interface ChatBase {
+    order: string;
+    lastMessage?: Omit<Message, "replyToMessage">;
+    pinned: number;
+}
+/** @unlisted */
+export interface ChatChannel extends ChatBase, ChatPChannel {
+    also?: string[];
+    photo?: ChatPhotoChat;
+}
+/** @unlisted */
+export interface ChatSupergroup extends ChatBase, ChatPSupergroup {
+    also?: string[];
+    photo?: ChatPhotoChat;
+}
+/** @unlisted */
+export interface ChatGroup extends ChatBase, ChatPGroup {
+    photo?: ChatPhotoChat;
+}
+/** @unlisted */
+export interface ChatPrivate extends ChatBase, ChatPPrivate {
+    also?: string[];
+    photo?: ChatPhotoUser;
+}
+export type Chat = ChatChannel | ChatSupergroup | ChatGroup | ChatPrivate;
+export declare function getChatOrder(lastMessage: Omit<Message, "replyToMessage"> | undefined, pinned: number): string;
+export declare function constructChat(dialog: enums.Dialog, dialogs: types.messages.Dialogs | types.messages.DialogsSlice, pinnedChats: number[], getEntity: EntityGetter, getMessage: MessageGetter, getStickerSetName: StickerSetNameGetter): Promise<Chat>;
+export declare function constructChat2(entity: types.User | types.Chat | types.ChatForbidden | types.Channel | types.ChannelForbidden, pinned: number, lastMessage: Omit<Message, "replyToMessage"> | undefined): Chat;
+export declare function constructChat3(chatId: number, pinned: number, lastMessage: Omit<Message, "replyToMessage"> | undefined, getEntity: EntityGetter): Promise<Chat | null>;
+export declare function constructChat4(chatId: number, pinned: number, lastMessageId: number, getEntity: EntityGetter, getMessage: MessageGetter): Promise<Chat | null>;

package/esm/types/{4_chat.js → 5_chat.js}

@@ -1,8 +1,8 @@
 import { cleanObject, UNREACHABLE } from "../1_utilities.js";
 import { chatIdToPeer, peerToChatId, types } from "../2_tl.js";
-import { constructChatP } from "./1_chat_p.js";
 import { constructChatPhoto } from "./0_chat_photo.js";
-import { constructMessage } from "./3_message.js";
+import { constructChatP } from "./1_chat_p.js";
+import { constructMessage } from "./4_message.js";
 function getChatPAlsoPhoto(entity) {
     let chatP;
     let also = undefined;