@emaxe/tuigram 1.4.0 → 1.5.1

package/src/state.js

@@ -45,7 +45,7 @@ class AppState extends EventEmitter {
      * @returns {Array<object>}
      */
     getVisibleDialogs() {
-        const tabFiltered = filterDialogsByTab(this.dialogs, this.currentFilterTab);
+        const tabFiltered = filterDialogsByTab(this.dialogs, this.currentFilterTab, this.activeChat?.id);
         if (!this.searchQuery) return tabFiltered;
         return searchDialogs(tabFiltered, this.searchQuery);
     }
@@ -97,13 +97,34 @@ class AppState extends EventEmitter {
         this.replyTarget = null;
         this.editTarget = null;
         this.selectedMessageIndex = -1;
-        if (dialog) {
-            dialog.unreadCount = 0;
-            dialog.unreadMentionsCount = 0;
-        }
         this.emit("active_chat_changed", dialog);
     }
 
+    /**
+     * Обновляет счётчик непрочитанных сообщений и максимальный прочитанный ID диалога.
+     * @param {string} chatId
+     * @param {number} unreadCount
+     * @param {number} [readInboxMaxId]
+     */
+    updateDialogUnread(chatId, unreadCount, readInboxMaxId) {
+        const dialog = this.dialogs.find((d) => d.id === chatId);
+        if (!dialog) return;
+
+        const countChanged = dialog.unreadCount !== unreadCount;
+        const idChanged = typeof readInboxMaxId === "number" && readInboxMaxId > (dialog.readInboxMaxId || 0);
+
+        if (countChanged || idChanged) {
+            dialog.unreadCount = Math.max(0, unreadCount);
+            if (dialog.unreadCount === 0) {
+                dialog.unreadMentionsCount = 0;
+            }
+            if (idChanged) {
+                dialog.readInboxMaxId = readInboxMaxId;
+            }
+            this.emit("dialogs_updated", this.getVisibleDialogs());
+        }
+    }
+
     /**
      * Получает список сообщений для указанного чата.
      * @param {string} chatId
@@ -117,9 +138,11 @@ class AppState extends EventEmitter {
      * Устанавливает или дополняет список сообщений для чата.
      * @param {string} chatId
      * @param {Array<object>} newMessages
-     * @param {boolean} [prepend=false] Если true — добавляет старые сообщения в начало
+     * @param {boolean|object} [options=false] Если true — добавляет старые сообщения в начало
      */
-    setMessages(chatId, newMessages, prepend = false) {
+    setMessages(chatId, newMessages, options = false) {
+        const prepend = typeof options === "boolean" ? options : Boolean(options?.prepend);
+        const firstUnreadId = typeof options === "object" ? (options?.firstUnreadId || null) : null;
         const existing = this.messagesByChat.get(chatId) || [];
         let combined = [];
 
@@ -140,7 +163,7 @@ class AppState extends EventEmitter {
         combined.sort((a, b) => (a.date || 0) - (b.date || 0) || (a.id - b.id));
 
         this.messagesByChat.set(chatId, combined);
-        this.emit("messages_updated", { chatId, messages: combined, isPrepend: prepend, isUpdate: false });
+        this.emit("messages_updated", { chatId, messages: combined, isPrepend: prepend, isUpdate: false, firstUnreadId });
     }
 
     /**

package/src/telegram/dialogs.js

@@ -37,6 +37,9 @@ export function normalizeDialog(dialog) {
         archived: Boolean(dialog.archived),
         unreadCount: dialog.unreadCount || 0,
         unreadMentionsCount: dialog.unreadMentionsCount || 0,
+        readInboxMaxId: dialog.dialog?.readInboxMaxId || dialog.readInboxMaxId || 0,
+        readOutboxMaxId: dialog.dialog?.readOutboxMaxId || dialog.readOutboxMaxId || 0,
+        topMessage: dialog.dialog?.topMessage || message?.id || 0,
         folderId: dialog.folderId || 0,
         date: dialog.date ? dialog.date * 1000 : (message?.date ? message.date * 1000 : Date.now()),
         isMuted: Boolean(dialog.dialog?.notifySettings?.muteUntil > 0),
@@ -86,9 +89,10 @@ export async function fetchDialogs(client, { limit = 100, archived } = {}) {
  * Фильтрует список диалогов по выбранной категории.
  * @param {Array<object>} dialogs
  * @param {"all"|"users"|"groups"|"channels"|"bots"|"unread"|"archived"} filterTab
+ * @param {string|null} [activeChatId=null] ID активного чата (не исключается из вкладки непрочитанных)
  * @returns {Array<object>}
  */
-export function filterDialogsByTab(dialogs, filterTab = "all") {
+export function filterDialogsByTab(dialogs, filterTab = "all", activeChatId = null) {
     if (!dialogs) return [];
 
     switch (filterTab) {
@@ -101,7 +105,7 @@ export function filterDialogsByTab(dialogs, filterTab = "all") {
         case "bots":
             return dialogs.filter((d) => !d.archived && d.type === "bot");
         case "unread":
-            return dialogs.filter((d) => !d.archived && (d.unreadCount > 0 || d.unreadMentionsCount > 0));
+            return dialogs.filter((d) => !d.archived && (d.unreadCount > 0 || d.unreadMentionsCount > 0 || (activeChatId && d.id === activeChatId)));
         case "archived":
             return dialogs.filter((d) => d.archived);
         case "all":

package/src/telegram/entities.js

@@ -49,6 +49,12 @@ export function toMarkedId(peer) {
  * @returns {string|bigint}
  */
 export function parsePeer(raw) {
+    if (raw && typeof raw === "object") {
+        const marked = toMarkedId(raw);
+        if (marked && marked !== "[object Object]") {
+            return parsePeer(marked);
+        }
+    }
     const value = String(raw || "").trim();
     if (!value) throw new Error("Не указан идентификатор чата (peer)");
     if (value === "me" || value === "self") return "me";
@@ -106,18 +112,67 @@ class EntityCache {
     }
 
     set(id, entity) {
-        if (!id || !entity) return;
-        const key = idToString(id);
-        this.cache.set(key, entity);
+        if (!entity) return;
+        if (id !== null && id !== undefined) {
+            const key = idToString(id).trim().toLowerCase();
+            if (key) this.cache.set(key, entity);
+        }
+        if (entity.id !== null && entity.id !== undefined) {
+            const rawId = idToString(entity.id).trim().toLowerCase();
+            if (rawId) {
+                this.cache.set(rawId, entity);
+                if (entity.className === "Channel" || entity.broadcast || entity.megagroup) {
+                    this.cache.set(`-100${rawId}`, entity);
+                } else if (entity.className === "Chat") {
+                    this.cache.set(`-${rawId}`, entity);
+                }
+            }
+        }
+        const marked = toMarkedId(entity);
+        if (marked && marked !== "[object Object]") {
+            this.cache.set(marked.toLowerCase(), entity);
+        }
         if (entity.username) {
-            this.cache.set(`@${entity.username.toLowerCase()}`, entity);
+            const u = entity.username.toLowerCase();
+            this.cache.set(`@${u}`, entity);
+            this.cache.set(u, entity);
         }
     }
 
     get(idOrUsername) {
-        if (!idOrUsername) return null;
-        const key = String(idOrUsername).toLowerCase();
-        return this.cache.get(key) || this.cache.get(idToString(idOrUsername)) || null;
+        if (idOrUsername === null || idOrUsername === undefined) return null;
+        let key = "";
+        if (typeof idOrUsername === "object") {
+            const marked = toMarkedId(idOrUsername);
+            key = (marked && marked !== "[object Object]" ? marked : idToString(idOrUsername)).trim().toLowerCase();
+        } else {
+            key = String(idOrUsername).trim().toLowerCase();
+        }
+        if (!key) return null;
+
+        let found = this.cache.get(key);
+        if (found) return found;
+
+        if (key.startsWith("-100")) {
+            found = this.cache.get(key.slice(4));
+            if (found) return found;
+        } else if (key.startsWith("-")) {
+            found = this.cache.get(key.slice(1));
+            if (found) return found;
+        } else if (/^\d+$/.test(key)) {
+            found = this.cache.get(`-100${key}`) || this.cache.get(`-${key}`);
+            if (found) return found;
+        }
+
+        if (key.startsWith("@")) {
+            found = this.cache.get(key.slice(1));
+            if (found) return found;
+        } else {
+            found = this.cache.get(`@${key}`);
+            if (found) return found;
+        }
+
+        return null;
     }
 
     has(idOrUsername) {

package/src/telegram/formatter.js

@@ -70,7 +70,7 @@ export function setMessagePalette(theme) {
  */
 export function escapeBlessed(text) {
     if (!text) return "";
-    return String(text).replace(/\{/g, "\\{").replace(/\}/g, "\\}");
+    return String(text).replace(/[{}]/g, (ch) => (ch === "{" ? "{open}" : "{close}"));
 }
 
 /**

package/src/telegram/listener.js

@@ -2,7 +2,7 @@ import { EventEmitter } from "node:events";
 import { Api } from "teleproto";
 import { NewMessage, EditedMessage, DeletedMessage, Raw } from "teleproto/events/index.js";
 import { normalizeMessage } from "./messages.js";
-import { idToString, toMarkedId, entityCache } from "./entities.js";
+import { idToString, toMarkedId, entityCache, getEntityDisplayName } from "./entities.js";
 
 /**
  * Приводит идентификатор чата из сырого апдейта к маркированному виду (как dialog.id).
@@ -36,21 +36,39 @@ export function startTelegramListener(client) {
         try {
             const msg = event.message;
             if (!msg) return;
-            const normalized = normalizeMessage(msg);
-            const peerId = normalized.peerId;
-            const fromId = normalized.fromId;
 
-            // Кэшируем информацию об авторе сообщения, если доступна
-            try {
-                const sender = await event.getSender?.();
-                if (sender) {
-                    entityCache.set(sender.id, sender);
-                    normalized.senderName = sender.title || [sender.firstName, sender.lastName].filter(Boolean).join(" ") || normalized.senderName;
+            // Кэшируем сущности события, если они пришли в апдейте
+            if (event.originalUpdate?._entities && typeof event.originalUpdate._entities.values === "function") {
+                for (const ent of event.originalUpdate._entities.values()) {
+                    if (ent?.id) entityCache.set(ent.id, ent);
                 }
+            }
+
+            let sender = null;
+            try {
+                sender = await event.getSender?.();
+                if (sender) entityCache.set(sender.id, sender);
+            } catch {
+                // Игнорируем
+            }
+
+            let chat = null;
+            try {
+                chat = await event.getChat?.();
+                if (chat) entityCache.set(chat.id, chat);
             } catch {
                 // Игнорируем
             }
 
+            const normalized = normalizeMessage(msg, chat || sender);
+            if (sender && (!normalized.senderName || normalized.senderName === "Собеседник")) {
+                const baseName = getEntityDisplayName(sender);
+                normalized.senderName = msg.postAuthor ? `${baseName} (${msg.postAuthor})` : baseName;
+            }
+
+            const peerId = normalized.peerId;
+            const fromId = normalized.fromId;
+
             bus.emit("new_message", {
                 peerId,
                 fromId,
@@ -67,7 +85,35 @@ export function startTelegramListener(client) {
         try {
             const msg = event.message;
             if (!msg) return;
-            const normalized = normalizeMessage(msg);
+
+            if (event.originalUpdate?._entities && typeof event.originalUpdate._entities.values === "function") {
+                for (const ent of event.originalUpdate._entities.values()) {
+                    if (ent?.id) entityCache.set(ent.id, ent);
+                }
+            }
+
+            let sender = null;
+            try {
+                sender = await event.getSender?.();
+                if (sender) entityCache.set(sender.id, sender);
+            } catch {
+                // Игнорируем
+            }
+
+            let chat = null;
+            try {
+                chat = await event.getChat?.();
+                if (chat) entityCache.set(chat.id, chat);
+            } catch {
+                // Игнорируем
+            }
+
+            const normalized = normalizeMessage(msg, chat || sender);
+            if (sender && (!normalized.senderName || normalized.senderName === "Собеседник")) {
+                const baseName = getEntityDisplayName(sender);
+                normalized.senderName = msg.postAuthor ? `${baseName} (${msg.postAuthor})` : baseName;
+            }
+
             bus.emit("edited_message", {
                 peerId: normalized.peerId,
                 message: normalized,

package/src/telegram/messages.js

@@ -1,8 +1,8 @@
 import { Api, errors } from "teleproto";
-import { idToString, toMarkedId, getEntityDisplayName, entityCache, resolveEntity } from "./entities.js";
+import { idToString, toMarkedId, detectChatType, getEntityDisplayName, entityCache, resolveEntity } from "./entities.js";
 import { describeMedia } from "./formatter.js";
 import { config } from "../config.js";
-import { renderStrippedThumbnail, renderImageBuffer } from "../utils/image.js";
+import { renderStrippedThumbnail, renderImageBuffer, renderMediaPreloader, getCachedImagePreview, isPreviewableMedia } from "../utils/image.js";
 
 const { FloodWaitError } = errors;
 
@@ -33,31 +33,77 @@ export function renderMessageThumbnail(rawMessage, {
 
     // Полноэкранные рендеры не кэшируем: одна такая строка весит сотни килобайт
     const cacheKey = useCache
-        ? (photo?.id ? `photo_${photo.id}` : (doc?.id ? `doc_${doc.id}` : `msg_${rawMessage.id}`))
-        : undefined;
+        ? (rawMessage.id ? `thumb_${rawMessage.id}@${maxWidth}x${maxHeight}` : null)
+        : null;
 
-    return renderStrippedThumbnail(stripped.bytes, { maxWidth, maxHeight, cacheKey }) || "";
+    return renderStrippedThumbnail(stripped.bytes, { maxWidth, maxHeight, cacheKey });
 }
 
 /**
  * Преобразует объект Message из MTProto в нормализованный объект для TUI.
  * @param {object} message
+ * @param {object|null} [chatEntity=null] сущность чата (канал, пользователь, группа)
  * @returns {object}
  */
-export function normalizeMessage(message) {
+export function normalizeMessage(message, chatEntity = null) {
     if (!message) return null;
 
     // fromId остаётся немаркированным: по нему ищется сущность в entityCache,
     // куда объекты кладутся по entity.id (тоже без маркера).
-    const fromId = idToString(message.fromId?.userId || message.fromId?.channelId || message.fromId?.chatId);
+    const fromId = idToString(message.fromId?.userId || message.fromId?.channelId || message.fromId?.chatId || message.senderId);
     // peerId маркируется, чтобы совпадать с dialog.id (см. toMarkedId).
     const peerId = toMarkedId(message.peerId);
 
-    // Извлекаем имя отправителя из кэша сущностей, если доступно
-    let senderName = message.out ? "Вы" : "Собеседник";
-    const cachedSender = entityCache.get(fromId);
-    if (cachedSender) {
-        senderName = getEntityDisplayName(cachedSender);
+    const postAuthor = message.postAuthor ? String(message.postAuthor).trim() : null;
+    const isPost = Boolean(
+        message.post ||
+        chatEntity?.broadcast ||
+        (chatEntity && detectChatType({ entity: chatEntity }) === "channel")
+    );
+
+    // Ищем сущность отправителя:
+    // 1. Уже прикреплённый teleproto sender
+    // 2. Вложенный кэш сущностей сообщения message._entities
+    // 3. Глобальный entityCache
+    let senderEntity = message.sender || null;
+    if (!senderEntity && message._entities && typeof message._entities.get === "function") {
+        senderEntity = (fromId && message._entities.get(fromId)) ||
+            (message.senderId && message._entities.get(idToString(message.senderId))) ||
+            (message.fromId && message._entities.get(toMarkedId(message.fromId))) ||
+            null;
+    }
+    if (!senderEntity) {
+        senderEntity = (fromId && entityCache.get(fromId)) ||
+            (message.senderId && entityCache.get(message.senderId)) ||
+            (message.fromId && entityCache.get(message.fromId)) ||
+            null;
+    }
+    if (senderEntity && senderEntity.id) {
+        entityCache.set(senderEntity.id, senderEntity);
+    }
+
+    let senderName = "";
+    if (isPost) {
+        // В вещательных каналах автор — сам канал (или подпись автора)
+        const channelEntity = senderEntity || chatEntity || message.chat || entityCache.get(peerId) || null;
+        const channelTitle = channelEntity ? getEntityDisplayName(channelEntity) : (chatEntity?.title || "");
+        if (postAuthor) {
+            senderName = channelTitle ? `${channelTitle} (${postAuthor})` : postAuthor;
+        } else {
+            senderName = channelTitle || "Канал";
+        }
+    } else if (message.out) {
+        senderName = "Вы";
+    } else if (senderEntity) {
+        const baseName = getEntityDisplayName(senderEntity);
+        senderName = postAuthor ? `${baseName} (${postAuthor})` : baseName;
+    } else if (chatEntity && (chatEntity.className === "User" || detectChatType({ entity: chatEntity }) === "user")) {
+        // В личном диалоге (1-на-1) входящее сообщение всегда от собеседника чата
+        senderName = getEntityDisplayName(chatEntity);
+    } else if (postAuthor) {
+        senderName = postAuthor;
+    } else {
+        senderName = "Собеседник";
     }
 
     // Реакции
@@ -73,16 +119,40 @@ export function normalizeMessage(message) {
         }
     }
 
-    // Извлечение и рендеринг PhotoStrippedSize в псевдографику
-    const imagePreview = config.showImages
-        ? (renderMessageThumbnail(message) || null)
-        : null;
+    // Извлечение и рендеринг PhotoStrippedSize в псевдографику или прелоадера
+    let imagePreview = null;
+    let isPreviewLoading = false;
+
+    if (config.showImages && isPreviewableMedia(message)) {
+        const cached = getCachedImagePreview(message, {
+            maxWidth: config.imageMaxWidth,
+            maxHeight: config.imageMaxHeight,
+        });
+        if (cached) {
+            imagePreview = cached;
+            isPreviewLoading = false;
+        } else {
+            const strippedThumb = renderMessageThumbnail(message);
+            if (strippedThumb) {
+                imagePreview = strippedThumb;
+                isPreviewLoading = false;
+            } else {
+                imagePreview = renderMediaPreloader(message, {
+                    maxWidth: config.imageMaxWidth,
+                    maxHeight: config.imageMaxHeight,
+                });
+                isPreviewLoading = true;
+            }
+        }
+    }
 
     return {
         id: message.id,
         date: message.date ? message.date * 1000 : Date.now(),
         editDate: message.editDate ? message.editDate * 1000 : null,
         out: Boolean(message.out),
+        post: isPost,
+        postAuthor,
         text: message.message || "",
         fromId,
         senderName,
@@ -94,6 +164,7 @@ export function normalizeMessage(message) {
         media: message.media || null,
         mediaDescription: describeMedia(message.media),
         imagePreview,
+        isPreviewLoading,
         entities: message.entities || [],
         reactions,
         rawMessage: message,
@@ -117,9 +188,20 @@ export async function fetchHistory(client, rawPeer, { limit = 40, offsetId = 0,
     const load = async () => {
         for await (const msg of client.iterMessages(entity, { limit, offsetId, reverse })) {
             if (msg && msg.className !== "MessageEmpty") {
-                messages.push(normalizeMessage(msg));
+                // Сохраняем сущности, которые Telegram прислал вместе с сообщениями
+                if (msg._entities && typeof msg._entities.values === "function") {
+                    for (const ent of msg._entities.values()) {
+                        if (ent?.id) {
+                            entityCache.set(ent.id, ent);
+                        }
+                    }
+                }
+                messages.push(normalizeMessage(msg, entity));
             }
         }
+        if (!reverse) {
+            messages.reverse();
+        }
     };
 
     try {
@@ -135,6 +217,41 @@ export async function fetchHistory(client, rawPeer, { limit = 40, offsetId = 0,
         }
     }
 
+    // Резолвим отправителей, которых ещё нет в кэше сущностей,
+    // чтобы в диалоге отображались реальные имена, а не «Собеседник».
+    for (const msg of messages) {
+        if (!msg.out && (!msg.senderName || msg.senderName === "Собеседник")) {
+            // 1. Попытка через rawMessage.getSender()
+            if (msg.rawMessage?.getSender) {
+                try {
+                    const sender = await msg.rawMessage.getSender();
+                    if (sender) {
+                        entityCache.set(sender.id, sender);
+                        const baseName = getEntityDisplayName(sender);
+                        msg.senderName = msg.postAuthor ? `${baseName} (${msg.postAuthor})` : baseName;
+                        continue;
+                    }
+                } catch {
+                    // Игнорируем
+                }
+            }
+
+            // 2. Попытка через resolveEntity по targetPeer
+            const targetPeer = msg.rawMessage?.fromId || msg.fromId || msg.rawMessage?.peerId || msg.peerId;
+            if (targetPeer) {
+                try {
+                    const sender = await resolveEntity(client, targetPeer);
+                    if (sender) {
+                        const baseName = getEntityDisplayName(sender);
+                        msg.senderName = msg.postAuthor ? `${baseName} (${msg.postAuthor})` : baseName;
+                    }
+                } catch {
+                    // Имя не резолвится — останется fallback
+                }
+            }
+        }
+    }
+
     return {
         peer: entity,
         messages,
@@ -286,6 +403,61 @@ export async function sendReaction(client, rawPeer, messageId, emoji = "👍") {
     );
 }
 
+/**
+ * Находит первое непрочитанное входящее сообщение в хронологическом списке сообщений.
+ * @param {Array<object>} messages
+ * @param {object} [options]
+ * @param {number} [options.readInboxMaxId=0]
+ * @param {number} [options.unreadCount=0]
+ * @returns {object|null}
+ */
+export function findFirstUnreadMessage(messages, { readInboxMaxId = 0, unreadCount = 0 } = {}) {
+    if (!Array.isArray(messages) || messages.length === 0 || unreadCount === 0) {
+        return null;
+    }
+
+    // Всегда сортируем сообщения по возрастанию ID/даты перед поиском
+    const sorted = [...messages].sort((a, b) => (a.date || 0) - (b.date || 0) || (a.id - b.id));
+
+    if (readInboxMaxId > 0) {
+        const first = sorted.find((m) => !m.out && m.id > readInboxMaxId);
+        if (first) return first;
+    }
+
+    if (unreadCount > 0) {
+        const incoming = sorted.filter((m) => !m.out);
+        if (incoming.length > 0) {
+            const unreadIncoming = incoming.slice(-unreadCount);
+            return unreadIncoming[0] || null;
+        }
+    }
+
+    return null;
+}
+
+/**
+ * Вычисляет количество оставшихся непрочитанных сообщений в чате на основе прочитанного maxId.
+ * @param {Array<object>} messages
+ * @param {number} maxReadId
+ * @param {number} [totalUnreadCount]
+ * @returns {number}
+ */
+export function calculateRemainingUnreadCount(messages, maxReadId = 0, totalUnreadCount) {
+    if (!Array.isArray(messages) || messages.length === 0) return 0;
+
+    const unreadInLoaded = messages.filter((m) => !m.out && m.id > maxReadId).length;
+
+    if (typeof totalUnreadCount === "number" && totalUnreadCount > 0) {
+        const incomingInLoaded = messages.filter((m) => !m.out).length;
+        if (totalUnreadCount > incomingInLoaded) {
+            const notLoadedCount = totalUnreadCount - incomingInLoaded;
+            return notLoadedCount + unreadInLoaded;
+        }
+    }
+
+    return unreadInLoaded;
+}
+
 /**
  * Отмечает сообщения в чате прочитанными.
  * @param {import("teleproto").TelegramClient} client
@@ -296,7 +468,7 @@ export async function markAsRead(client, rawPeer, maxId = 0) {
     const entity = await resolveEntity(client, rawPeer);
     try {
         if (maxId > 0) {
-            await client.sendReadAcknowledge(entity, { maxId });
+            await client.markAsRead(entity, maxId);
         } else {
             await client.markAsRead(entity);
         }
@@ -383,6 +555,9 @@ export async function loadMessageImagePreview(client, rawMessage, { maxWidth = c
     const isDoc = media.className === "MessageMediaDocument";
     if (!isPhoto && !isDoc) return "";
 
+    const cached = getCachedImagePreview(rawMessage, { maxWidth, maxHeight });
+    if (cached) return cached;
+
     const cacheKey = isPhoto
         ? `photo_full_${media.photo?.id || rawMessage.id}`
         : `doc_full_${media.document?.id || rawMessage.id}`;