@emaxe/tuigram 1.4.0 → 1.5.0

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/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/messages.js

@@ -2,7 +2,7 @@ import { Api, errors } from "teleproto";
 import { idToString, toMarkedId, 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;
 
@@ -73,10 +73,32 @@ 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,
@@ -94,6 +116,7 @@ export function normalizeMessage(message) {
         media: message.media || null,
         mediaDescription: describeMedia(message.media),
         imagePreview,
+        isPreviewLoading,
         entities: message.entities || [],
         reactions,
         rawMessage: message,
@@ -120,6 +143,9 @@ export async function fetchHistory(client, rawPeer, { limit = 40, offsetId = 0,
                 messages.push(normalizeMessage(msg));
             }
         }
+        if (!reverse) {
+            messages.reverse();
+        }
     };
 
     try {
@@ -286,6 +312,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 +377,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 +464,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}`;

package/src/ui/app.js

@@ -13,17 +13,19 @@ import { createActionModal } from "./components/modals/actionModal.js";
 import { createFileModal } from "./components/modals/fileModal.js";
 import { createConfirmModal } from "./components/modals/confirmModal.js";
 import { createImageViewerModal } from "./components/modals/imageViewerModal.js";
+import { createVideoPlayerModal } from "./components/modals/videoPlayerModal.js";
 import { state } from "../state.js";
 import { config } from "../config.js";
 import { fetchDialogs } from "../telegram/dialogs.js";
 import { setMessagePalette } from "../telegram/formatter.js";
-import { fetchHistory, sendMessage, editMessage, deleteMessages, sendFiles, downloadMedia, sendReaction, markAsRead, loadMessageImagePreview, downloadImageBuffer, renderMessageThumbnail } from "../telegram/messages.js";
+import { fetchHistory, sendMessage, editMessage, deleteMessages, sendFiles, downloadMedia, sendReaction, markAsRead, loadMessageImagePreview, downloadImageBuffer, renderMessageThumbnail, findFirstUnreadMessage, calculateRemainingUnreadCount } from "../telegram/messages.js";
 import { startTelegramListener } from "../telegram/listener.js";
 import { logout } from "../telegram/auth.js";
 import { ensureDir, inspectLocalFile } from "../utils/storage.js";
 import { formatFileSize } from "../utils/time.js";
 import { parseSendFileArgs } from "../utils/commands.js";
 import { isRightClick } from "../utils/mouse.js";
+import { renderMediaPreloader } from "../utils/image.js";
 
 /**
  * Запускает полноэкранный TUI-клиент Telegram.
@@ -38,7 +40,10 @@ export async function startTui(client, me) {
     let listener = null;
     const screen = createScreen({
         theme,
-        onExit: () => listener?.stop(),
+        onExit: () => {
+            flushPendingMarkAsRead();
+            listener?.stop();
+        },
     });
 
     state.me = me;
@@ -112,6 +117,7 @@ export async function startTui(client, me) {
         onQuit: () => {
             releaseInputs();
             confirmModal.ask("Выйти из TuiGram?", () => {
+                flushPendingMarkAsRead();
                 listener?.stop();
                 screen.destroy();
                 process.exit(0);
@@ -129,11 +135,62 @@ export async function startTui(client, me) {
 
     const imageViewerModal = createImageViewerModal(screen, theme, {
         onLoadFullImage: (msg) => downloadImageBuffer(client, msg.rawMessage),
-        // Пока качается оригинал, показываем встроенную в сообщение миниатюру
+        // Пока качается оригинал, показываем встроенную в сообщение миниатюру или прелоадер
+        onRenderPlaceholder: (msg, size) => renderMessageThumbnail(msg.rawMessage, {
+            maxWidth: size.maxWidth,
+            maxHeight: size.maxHeight,
+            useCache: false,
+        }) || renderMediaPreloader(msg.rawMessage, {
+            maxWidth: size.maxWidth,
+            maxHeight: size.maxHeight,
+            palette: {
+                bg: theme.surface,
+                border: theme.borders.fg,
+                fg: theme.fg,
+                accent: theme.accent,
+                dim: theme.dim,
+            },
+        }),
+    });
+
+    const videoPlayerModal = createVideoPlayerModal(screen, theme, {
+        onLoadVideoFile: async (msg, progressCallback) => {
+            const downloadsDir = config.downloadsDir;
+            ensureDir(downloadsDir);
+            let fileName = `video_${msg.id}.mp4`;
+            const doc = msg.rawMessage?.media?.document;
+            if (doc?.attributes) {
+                for (const attr of doc.attributes) {
+                    if (attr.className === "DocumentAttributeFilename" && attr.fileName) {
+                        fileName = `msg_${msg.id}_${attr.fileName}`;
+                        break;
+                    }
+                }
+            }
+            const targetPath = path.join(downloadsDir, fileName);
+            if (fs.existsSync(targetPath) && fs.statSync(targetPath).size > 0) {
+                return targetPath;
+            }
+            const res = await downloadMedia(client, msg.rawMessage, {
+                outputFile: targetPath,
+                progressCallback,
+            });
+            return typeof res === "string" ? res : targetPath;
+        },
         onRenderPlaceholder: (msg, size) => renderMessageThumbnail(msg.rawMessage, {
             maxWidth: size.maxWidth,
             maxHeight: size.maxHeight,
             useCache: false,
+        }) || renderMediaPreloader(msg.rawMessage, {
+            maxWidth: size.maxWidth,
+            maxHeight: size.maxHeight,
+            palette: {
+                bg: theme.surface,
+                border: theme.borders.fg,
+                fg: theme.fg,
+                accent: theme.accent,
+                dim: theme.dim,
+            },
         }),
     });
 
@@ -143,6 +200,10 @@ export async function startTui(client, me) {
             const peerId = state.activeChat.peerId;
 
             switch (actionId) {
+                case "play_video":
+                    releaseInputs();
+                    videoPlayerModal.play(msg);
+                    break;
                 case "reply":
                     inputBox.setContext("reply", msg);
                     break;
@@ -200,20 +261,62 @@ export async function startTui(client, me) {
         },
     });
 
+    let readDebounceTimer = null;
+    let pendingReadMaxId = 0;
+    let pendingReadPeerId = null;
+
+    /**
+     * Отправляет подтверждение прочтения на сервер с дебаунсом, чтобы не спамить сеть при скролле.
+     * @param {string|number|bigint} peerId
+     * @param {number} maxId
+     */
+    function debouncedMarkAsRead(peerId, maxId) {
+        pendingReadPeerId = peerId;
+        if (maxId > pendingReadMaxId) {
+            pendingReadMaxId = maxId;
+        }
+        if (readDebounceTimer) clearTimeout(readDebounceTimer);
+        readDebounceTimer = setTimeout(() => {
+            flushPendingMarkAsRead();
+        }, 300);
+    }
+
+    /** Сбрасывает накопленный маркер прочтения на сервер без задержки. */
+    function flushPendingMarkAsRead() {
+        if (readDebounceTimer) {
+            clearTimeout(readDebounceTimer);
+            readDebounceTimer = null;
+        }
+        if (pendingReadPeerId && pendingReadMaxId > 0) {
+            const peer = pendingReadPeerId;
+            const id = pendingReadMaxId;
+            pendingReadPeerId = null;
+            pendingReadMaxId = 0;
+            markAsRead(client, peer, id).catch(() => {});
+        }
+    }
+
     // 2. Список диалогов (левая панель)
     const chatList = createChatList(screen, theme, {
         onSelectDialog: async (dialog) => {
+            flushPendingMarkAsRead();
             state.setActiveChat(dialog);
+            chatView.resetReadState(dialog.readInboxMaxId || 0);
             statusBar.showMessage(`Загрузка сообщений: ${dialog.title}...`, "info");
 
             try {
-                const history = await fetchHistory(client, dialog.peerId, { limit: 50 });
-                state.setMessages(dialog.id, history.messages);
-                markAsRead(client, dialog.peerId).catch(() => {});
+                // Загружаем всю пачку непрочитанных сообщений + запас из 20 прочитанных
+                // для контекста и правильного позиционирования разделителя
+                const limit = Math.max(50, Math.min(1000, (dialog.unreadCount || 0) + 20));
+                const history = await fetchHistory(client, dialog.peerId, { limit });
+                if (state.activeChat?.id !== dialog.id) return;
+                const firstUnread = findFirstUnreadMessage(history.messages, dialog);
+                state.setMessages(dialog.id, history.messages, { firstUnreadId: firstUnread?.id || null });
                 statusBar.showMessage(`Чат: ${dialog.title}`, "info");
-                fetchMissingImagePreviews(history.messages, dialog.id);
             } catch (err) {
-                statusBar.showMessage(`Ошибка загрузки: ${err.message}`, "error");
+                if (state.activeChat?.id === dialog.id) {
+                    statusBar.showMessage(`Ошибка загрузки: ${err.message}`, "error");
+                }
             }
         },
         onTabChange: (tab) => {
@@ -241,7 +344,6 @@ export async function startTui(client, me) {
                 if (older.messages.length > 0) {
                     state.setMessages(state.activeChat.id, older.messages, true);
                     statusBar.showMessage(`Загружено ${older.messages.length} предыдущих сообщений`, "info");
-                    fetchMissingImagePreviews(older.messages, state.activeChat.id);
                 }
             } catch (err) {
                 statusBar.showMessage(`Ошибка пагинации: ${err.message}`, "error");
@@ -263,7 +365,24 @@ export async function startTui(client, me) {
             releaseInputs();
             imageViewerModal.show(msg);
         },
+        onPlayVideo: (msg) => {
+            releaseInputs();
+            videoPlayerModal.play(msg);
+        },
         onFocusRequest: () => releaseInputs(),
+        onMessagesRead: (maxVisibleId) => {
+            if (!state.activeChat) return;
+            const chatId = state.activeChat.id;
+            const dialog = state.dialogs.find((d) => d.id === chatId);
+            const messages = state.getMessages(chatId);
+            const remainingCount = calculateRemainingUnreadCount(messages, maxVisibleId, dialog?.unreadCount);
+            state.updateDialogUnread(chatId, remainingCount, maxVisibleId);
+            debouncedMarkAsRead(state.activeChat.peerId, maxVisibleId);
+        },
+        onVisibleMessagesChanged: (visibleMsgs) => {
+            if (!state.activeChat) return;
+            fetchMissingImagePreviews(visibleMsgs, state.activeChat.id);
+        },
     });
 
     // 4. Поле ввода (нижняя панель)
@@ -411,6 +530,7 @@ export async function startTui(client, me) {
     });
 
     state.on("active_chat_changed", (chat) => {
+        activePreviewLoads.clear();
         header.updateInfo({
             me: state.me,
             status: state.connectionStatus,
@@ -419,16 +539,29 @@ export async function startTui(client, me) {
         });
         const msgs = chat ? state.getMessages(chat.id) : [];
         chatView.setSelected(null);
-        chatView.setMessages(msgs);
+        if (chat && msgs.length > 0) {
+            const firstUnread = findFirstUnreadMessage(msgs, chat);
+            if (firstUnread) {
+                chatView.setMessages(msgs, { firstUnreadId: firstUnread.id, autoScrollToBottom: false });
+            } else {
+                chatView.setMessages(msgs, true);
+            }
+        } else {
+            chatView.setMessages([], false);
+        }
     });
 
-    state.on("messages_updated", ({ chatId, messages, isPrepend, isUpdate, isNewMessage }) => {
+    state.on("messages_updated", ({ chatId, messages, isPrepend, isUpdate, isNewMessage, firstUnreadId }) => {
         if (state.activeChat?.id === chatId) {
-            // Скроллим в самый низ только если это новое сообщение или первая загрузка чата.
-            // При подгрузке старых сообщений (isPrepend) или фоновых обновлениях (isUpdate)
-            // позиция скролла сохраняется!
-            const shouldScrollToBottom = isNewMessage ? config.autoScroll : (!isPrepend && !isUpdate);
-            chatView.setMessages(messages, shouldScrollToBottom);
+            if (firstUnreadId) {
+                chatView.setMessages(messages, { firstUnreadId, autoScrollToBottom: false });
+            } else {
+                // Скроллим в самый низ только если это новое сообщение или первая загрузка чата.
+                // При подгрузке старых сообщений (isPrepend) или фоновых обновлениях (isUpdate)
+                // позиция скролла сохраняется!
+                const shouldScrollToBottom = isNewMessage ? config.autoScroll : (!isPrepend && !isUpdate);
+                chatView.setMessages(messages, shouldScrollToBottom);
+            }
         }
     });
 
@@ -451,30 +584,63 @@ export async function startTui(client, me) {
         }
     });
 
+    let previewBatchTimer = null;
+    let pendingBatchChatId = null;
+
+    /**
+     * Планирует пакетное обновление интерфейса после догрузки группы превью.
+     * @param {string} chatId
+     */
+    function scheduleBatchPreviewUpdate(chatId) {
+        if (state.activeChat?.id !== chatId) return;
+        pendingBatchChatId = chatId;
+        if (previewBatchTimer) return;
+        previewBatchTimer = setTimeout(() => {
+            previewBatchTimer = null;
+            if (state.activeChat?.id === pendingBatchChatId) {
+                const current = state.getMessages(pendingBatchChatId);
+                state.emit("messages_updated", {
+                    chatId: pendingBatchChatId,
+                    messages: current,
+                    isPrepend: false,
+                    isUpdate: true,
+                });
+            }
+            pendingBatchChatId = null;
+        }, 150);
+    }
+
+    /** Множество ID сообщений, для которых прямо сейчас выполняется загрузка превью. */
+    const activePreviewLoads = new Set();
+
     /**
-     * Фоново догружает превью изображений для сообщений, не имевших встроенного PhotoStrippedSize.
+     * Фоново догружает превью изображений только для тех сообщений, которые видны на экране (Lazy Loading).
+     * Обновления группируются пакетами, предотвращая фризы и блокировку основного потока.
      * @param {Array<object>} messages
      * @param {string} chatId
      */
     async function fetchMissingImagePreviews(messages, chatId) {
         if (!config.showImages || !messages || messages.length === 0) return;
-        for (const msg of messages) {
+        const toFetch = messages.filter((m) => m.isPreviewLoading && m.rawMessage && !activePreviewLoads.has(m.id));
+        if (toFetch.length === 0) return;
+
+        for (const msg of toFetch) {
             if (state.activeChat?.id !== chatId) break;
-            if (msg.media && !msg.imagePreview && msg.rawMessage) {
-                const isPhoto = msg.media.className === "MessageMediaPhoto";
-                const isDoc = msg.media.className === "MessageMediaDocument";
-                if (isPhoto || isDoc) {
-                    try {
-                        const preview = await loadMessageImagePreview(client, msg.rawMessage);
-                        if (preview && state.activeChat?.id === chatId) {
-                            msg.imagePreview = preview;
-                            state.updateMessage(chatId, msg);
-                        }
-                    } catch {
-                        // Игнорируем сетевые ошибки фоновой загрузки превью
-                    }
+            activePreviewLoads.add(msg.id);
+            try {
+                const preview = await loadMessageImagePreview(client, msg.rawMessage);
+                if (preview && state.activeChat?.id === chatId) {
+                    msg.imagePreview = preview;
+                    msg.isPreviewLoading = false;
+                    scheduleBatchPreviewUpdate(chatId);
                 }
+            } catch {
+                // Игнорируем сетевые ошибки фоновой загрузки превью
+            } finally {
+                activePreviewLoads.delete(msg.id);
             }
+            // Даём event loop обработать пользовательский ввод и скролл
+            await new Promise((resolve) => setImmediate(resolve));
         }
     }
 
@@ -483,13 +649,11 @@ export async function startTui(client, me) {
 
     listener.on("new_message", ({ peerId, message }) => {
         state.addMessage(peerId, message);
-        if (!message.imagePreview && (message.media?.className === "MessageMediaPhoto" || message.media?.className === "MessageMediaDocument")) {
+        if (message.isPreviewLoading) {
             fetchMissingImagePreviews([message], peerId);
         }
 
-        if (state.activeChat?.id === peerId) {
-            markAsRead(client, state.activeChat.peerId).catch(() => {});
-        } else if (!message.out) {
+        if (state.activeChat?.id !== peerId && !message.out) {
             const sender = message.senderName || "Новое сообщение";
             const preview = (message.text || "Вложение").slice(0, 30);
             statusBar.showMessage(`💬 ${sender}: "${preview}"`, "info", 5000);
@@ -730,6 +894,7 @@ export async function startTui(client, me) {
     screen.key(["C-q"], () => {
         releaseInputs();
         confirmModal.ask("Выйти из TuiGram?", () => {
+            flushPendingMarkAsRead();
             listener?.stop();
             screen.destroy();
             process.exit(0);