SHA256
1180 lines
45 KiB
JavaScript
1180 lines
45 KiB
JavaScript
import { iconHtml } from '../components/ui-icon.js';
|
||
import { channels as mockChannels } from '../mock-data.js';
|
||
import { authService, setChannelsFeed, state } from '../state.js';
|
||
import { toUserMessage } from '../services/ui-error-texts.js';
|
||
import { parseMessageAttachments } from '../services/attachment-format.js';
|
||
import {
|
||
animatePress,
|
||
createLoadErrorCard,
|
||
createSkeletonRows,
|
||
SKELETON_DELAY_MS,
|
||
formatListTime,
|
||
readChannelNotificationsState,
|
||
showToast,
|
||
softHaptic,
|
||
writeChannelNotificationsState,
|
||
} from '../services/channels-ux.js';
|
||
import { formatChannelAddress, makeShineChannelRoute, makeShineChannelShortRoute } from '../services/shine-routes.js';
|
||
import { renderAvatar } from '../components/avatar-image.js';
|
||
import { createTopBar } from '../components/topbar.js';
|
||
import { createTopBarFilterTitle } from '../components/topbar-filter-title.js';
|
||
import { parseDmTechBlocks } from '../services/dm-tech-blocks.js';
|
||
import { rememberChannelPosition, readChannelPosition, restoreChannelPosition } from '../services/channel-view-state.js';
|
||
import { pageDataAge } from '../services/page-data-cache.js';
|
||
import { toPrettyPath } from '../router.js';
|
||
import { prefetchChannelPage } from './channel-view.js';
|
||
|
||
export const pageMeta = { id: 'channels-list', title: 'Каналы', shellMode: { scrollbar: 'hidden', topFade: false, contentUnderTopbar: false, contentWidth: 'wide' } };
|
||
|
||
const CREATE_CHANNEL_FLASH_KEY = 'shine-channels-create-success';
|
||
const CHANNEL_TYPE_STORIES = 0;
|
||
const CHANNEL_TYPE_PERSONAL = 100;
|
||
const DIARY_CHANNEL_NAME = 'diary';
|
||
const DIARY_DISPLAY_NAME = 'Дневник';
|
||
|
||
const CHANNELS_VIEW_ALL = 'all';
|
||
const CHANNELS_VIEW_OWNED = 'owned';
|
||
const CHANNELS_VIEW_FOLLOWING = 'following';
|
||
const CHANNELS_VIEW_DELETED = 'deleted';
|
||
const listQueries = new Map();
|
||
|
||
function channelMenuIcon(name) {
|
||
const paths = {
|
||
search: '<circle cx="11" cy="11" r="6.5"/><path d="m16 16 4 4"/>',
|
||
add: '<path d="M12 5v14M5 12h14"/>',
|
||
all: '<rect x="4" y="4" width="6" height="6" rx="1"/><rect x="14" y="4" width="6" height="6" rx="1"/><rect x="4" y="14" width="6" height="6" rx="1"/><rect x="14" y="14" width="6" height="6" rx="1"/>',
|
||
mine: '<circle cx="12" cy="8" r="4"/><path d="M5 21a7 7 0 0 1 14 0"/>',
|
||
following: '<path d="M12 21s-7-4.4-7-10a4 4 0 0 1 7-2.6A4 4 0 0 1 19 11c0 5.6-7 10-7 10Z"/>',
|
||
subscribe: '<path d="M12 3a6 6 0 0 0-6 6c0 7-3 7-3 9h18c0-2-3-2-3-9a6 6 0 0 0-6-6Z"/><path d="M10 21h4"/>',
|
||
notifications: '<path d="M12 3a6 6 0 0 0-6 6c0 7-3 7-3 9h18c0-2-3-2-3-9a6 6 0 0 0-6-6Z"/><path d="M10 21h4"/>',
|
||
};
|
||
return `<svg class="channel-menu-icon" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true">${paths[name] || ''}</svg>`;
|
||
}
|
||
|
||
function cleanChannelMessagePreview(text) {
|
||
const parsed = parseMessageAttachments(text);
|
||
const dmParsed = parseDmTechBlocks(String(parsed.text || ''));
|
||
return String(dmParsed.displayText || dmParsed.visibleText || '').trim()
|
||
|| (parsed.attachments.length ? 'Вложение' : 'Ждем ваших начинаний');
|
||
}
|
||
|
||
// Keep the channel-list preview tolerant to small API naming changes. The current
|
||
// server uses lastMessage.text/createdAtMs; legacy/alternate payloads are accepted
|
||
// so the third line (last message + time) does not silently disappear.
|
||
function resolveChannelLastMessage(summary) {
|
||
const row = summary?.lastMessage || summary?.latestMessage || summary?.last_message || null;
|
||
if (!row || typeof row !== 'object') return { text: '', createdAtMs: 0 };
|
||
return {
|
||
text: String(row.text ?? row.messageText ?? row.preview ?? row.body ?? '').trim(),
|
||
createdAtMs: Number(row.createdAtMs ?? row.timeMs ?? row.created_at_ms ?? 0),
|
||
};
|
||
}
|
||
|
||
function isChannelsDemoMode() {
|
||
try {
|
||
const qs = new URLSearchParams(window.location.search);
|
||
if (qs.get('channelsDemo') === '1') return true;
|
||
return localStorage.getItem('shine-channels-demo') === '1';
|
||
} catch {
|
||
return false;
|
||
}
|
||
}
|
||
|
||
function normalizeHash(hash) {
|
||
const normalized = String(hash || '').trim().toLowerCase();
|
||
return normalized || '0';
|
||
}
|
||
|
||
function encodeRoutePart(value = '') {
|
||
return encodeURIComponent(String(value));
|
||
}
|
||
|
||
function normalizeLoginInput(value) {
|
||
return String(value || '').trim().replace(/^@+/, '');
|
||
}
|
||
|
||
function buildChannelRouteFromSummary(summary, fallbackId) {
|
||
const ownerBch = String(summary?.channel?.ownerBlockchainName || '').trim();
|
||
const ownerLogin = String(summary?.channel?.ownerLogin || '').trim();
|
||
const channelName = String(summary?.channel?.channelName || '').trim();
|
||
return makeShineChannelShortRoute({
|
||
ownerLogin,
|
||
ownerBlockchainName: ownerBch,
|
||
channelName: channelName || fallbackId || ownerLogin,
|
||
});
|
||
}
|
||
|
||
function isStoriesChannel(summaryOrChannel = null) {
|
||
const typeCode = Number(summaryOrChannel?.channel?.channelTypeCode ?? summaryOrChannel?.channelTypeCode ?? 1);
|
||
const channelName = String(summaryOrChannel?.channel?.channelName || summaryOrChannel?.channelName || '').trim().toLowerCase();
|
||
return typeCode === CHANNEL_TYPE_STORIES || channelName === 'stories';
|
||
}
|
||
|
||
function isVisibleChannelSummary(summary) {
|
||
if (!summary?.channel) return false;
|
||
if (isStoriesChannel(summary)) return false;
|
||
if (summary?.channel?.deleted) return false;
|
||
const ownerLogin = String(summary.channel.ownerLogin || '').trim();
|
||
const channelName = String(summary.channel.channelName || '').trim();
|
||
return !!ownerLogin && !!channelName;
|
||
}
|
||
|
||
function avatarLetterFromName(name = '') {
|
||
const first = Array.from(String(name || '').trim())[0] || '#';
|
||
return first.toUpperCase();
|
||
}
|
||
|
||
function createChannelAvatar(channel = {}) {
|
||
return renderAvatar({
|
||
initials: channel.avatar || channel.initials || avatarLetterFromName(channel.displayTitle || channel.title || channel.name),
|
||
avatar: (channel.avaAr || channel.avaSha256) ? { ar: String(channel.avaAr || '').trim(), sha256Hex: String(channel.avaSha256 || '').trim().toLowerCase() } : null,
|
||
authorLogin: String(channel.ownerName || channel.ownerLogin || '').trim(),
|
||
size: 'lg',
|
||
className: 'avatar-plain',
|
||
title: channel.displayTitle || channel.title || channel.name || 'Канал',
|
||
alt: 'Аватар канала',
|
||
});
|
||
}
|
||
|
||
function allFeedSummaries() {
|
||
const feed = state.channelsFeed || {};
|
||
return [
|
||
...(feed.ownedChannels || []),
|
||
...(feed.followedUsersChannels || []),
|
||
...(feed.followedChannels || []),
|
||
].filter(isVisibleChannelSummary);
|
||
}
|
||
|
||
function uniqueBy(items, keySelector) {
|
||
const seen = new Set();
|
||
const out = [];
|
||
for (const item of items) {
|
||
const key = keySelector(item);
|
||
if (!key || seen.has(key)) continue;
|
||
seen.add(key);
|
||
out.push(item);
|
||
}
|
||
return out;
|
||
}
|
||
|
||
function createDebounced(fn, delayMs = 250) {
|
||
let timer = null;
|
||
return (...args) => {
|
||
if (timer) clearTimeout(timer);
|
||
timer = setTimeout(() => {
|
||
timer = null;
|
||
fn(...args);
|
||
}, delayMs);
|
||
};
|
||
}
|
||
|
||
async function resolveChannelTargetFromInput(rawInput) {
|
||
const input = String(rawInput || '').trim();
|
||
if (!input) throw new Error('Введите канал.');
|
||
|
||
const byOwnerAndName = input.match(/^@?([^/#\s]+)\s*\/\s*#?(.+)$/);
|
||
if (byOwnerAndName) {
|
||
const ownerLogin = normalizeLoginInput(byOwnerAndName[1]);
|
||
const channelName = String(byOwnerAndName[2] || '').trim().toLowerCase();
|
||
if (!ownerLogin || !channelName) {
|
||
throw new Error('Укажите канал в формате user/channel.');
|
||
}
|
||
|
||
const user = await authService.getUser(ownerLogin);
|
||
if (!user?.exists || !user?.blockchainName) {
|
||
throw new Error('Пользователь не найден.');
|
||
}
|
||
|
||
const ownerFeed = await authService.listSubscriptionsFeed(ownerLogin, 500);
|
||
const ownChannels = Array.isArray(ownerFeed?.ownedChannels) ? ownerFeed.ownedChannels.filter(isVisibleChannelSummary) : [];
|
||
const matches = ownChannels.filter((item) => (
|
||
String(item?.channel?.channelName || '').trim().toLowerCase() === channelName
|
||
));
|
||
|
||
if (!matches.length) {
|
||
throw new Error('Канал не найден у указанного автора.');
|
||
}
|
||
|
||
const primaryMatches = matches.filter((item) => (
|
||
String(item?.channel?.ownerBlockchainName || '') === String(user.blockchainName || '')
|
||
));
|
||
const pool = primaryMatches.length ? primaryMatches : matches;
|
||
const match = [...pool].sort((a, b) => (
|
||
Number(b?.channel?.channelRoot?.blockNumber || -1) - Number(a?.channel?.channelRoot?.blockNumber || -1)
|
||
))[0];
|
||
|
||
return {
|
||
ownerBlockchainName: String(match?.channel?.ownerBlockchainName || user.blockchainName),
|
||
rootBlockNumber: Number(match?.channel?.channelRoot?.blockNumber),
|
||
rootBlockHash: normalizeHash(match?.channel?.channelRoot?.blockHash),
|
||
};
|
||
}
|
||
|
||
const byNameOnly = input.replace(/^#/, '').trim().toLowerCase();
|
||
const summaries = allFeedSummaries();
|
||
const matches = summaries.filter((summary) => (
|
||
String(summary?.channel?.channelName || '').trim().toLowerCase() === byNameOnly
|
||
));
|
||
|
||
if (!matches.length) {
|
||
throw new Error('Канал не найден. Укажите user/channel или выберите из списка.');
|
||
}
|
||
if (matches.length > 1) {
|
||
throw new Error('Найдено несколько каналов с таким именем. Уточните в формате user/channel.');
|
||
}
|
||
|
||
const one = matches[0];
|
||
return {
|
||
ownerBlockchainName: String(one?.channel?.ownerBlockchainName || ''),
|
||
rootBlockNumber: Number(one?.channel?.channelRoot?.blockNumber),
|
||
rootBlockHash: normalizeHash(one?.channel?.channelRoot?.blockHash),
|
||
};
|
||
}
|
||
|
||
function channelSuggestionsByInput(rawInput) {
|
||
const q = String(rawInput || '').trim().toLowerCase();
|
||
if (q.length < 1) return [];
|
||
|
||
const rows = allFeedSummaries().map((summary) => {
|
||
const owner = String(summary?.channel?.ownerLogin || '').trim();
|
||
const channel = String(summary?.channel?.channelName || '').trim();
|
||
if (!owner || !channel) return null;
|
||
return {
|
||
key: `${owner.toLowerCase()}/${channel.toLowerCase()}`,
|
||
label: formatChannelAddress({ ownerLogin: owner, channelName: channel }),
|
||
owner,
|
||
channel,
|
||
};
|
||
}).filter(Boolean);
|
||
|
||
return uniqueBy(rows, (it) => it.key)
|
||
.filter((it) => (
|
||
it.channel.toLowerCase().includes(q) ||
|
||
formatChannelAddress({ ownerLogin: it.owner.toLowerCase(), channelName: it.channel.toLowerCase() }).includes(normalizeLoginInput(q))
|
||
))
|
||
.slice(0, 7)
|
||
.map((it) => it.label);
|
||
}
|
||
|
||
function renderSuggestions(container, values, onPick) {
|
||
container.innerHTML = '';
|
||
if (!values.length) {
|
||
container.style.display = 'none';
|
||
return;
|
||
}
|
||
|
||
container.style.display = '';
|
||
values.forEach((value) => {
|
||
const btn = document.createElement('button');
|
||
btn.type = 'button';
|
||
btn.className = 'ui-button channel-search-item';
|
||
btn.textContent = value;
|
||
btn.addEventListener('click', () => onPick(value));
|
||
container.append(btn);
|
||
});
|
||
}
|
||
|
||
function normalizeComparableLogin(value) {
|
||
return normalizeLoginInput(value).toLowerCase();
|
||
}
|
||
|
||
function normalizeChannelsViewMode(route = null) {
|
||
const mode = String(route?.params?.mode || '').trim().toLowerCase();
|
||
const scope = String(route?.params?.scope || '').trim().toLowerCase();
|
||
if (mode === 'my' || scope === 'owned') return CHANNELS_VIEW_OWNED;
|
||
if (mode === 'following' || scope === 'following') return CHANNELS_VIEW_FOLLOWING;
|
||
if (mode === 'deleted' || scope === 'deleted') return CHANNELS_VIEW_DELETED;
|
||
return CHANNELS_VIEW_ALL;
|
||
}
|
||
|
||
function buildChannelsViewRoute(mode) {
|
||
if (mode === CHANNELS_VIEW_OWNED) return 'channels/my';
|
||
if (mode === CHANNELS_VIEW_FOLLOWING) return 'channels/following';
|
||
if (mode === CHANNELS_VIEW_DELETED) return 'channels/deleted';
|
||
return 'channels';
|
||
}
|
||
|
||
const CHANNEL_FILTERS = [
|
||
[CHANNELS_VIEW_ALL, 'Все'],
|
||
[CHANNELS_VIEW_FOLLOWING, 'Подписки'],
|
||
[CHANNELS_VIEW_OWNED, 'Мои'],
|
||
[CHANNELS_VIEW_DELETED, 'Мои удалённые'],
|
||
];
|
||
|
||
function isFollowedUserVisible(targetLogin) {
|
||
const expected = normalizeComparableLogin(targetLogin);
|
||
if (!expected) return false;
|
||
const rows = Array.isArray(state.channelsFeed?.followedUsersChannels)
|
||
? state.channelsFeed.followedUsersChannels
|
||
: [];
|
||
return rows
|
||
.filter(isVisibleChannelSummary)
|
||
.some((row) => normalizeComparableLogin(row?.channel?.ownerLogin) === expected);
|
||
}
|
||
|
||
function isFollowedChannelVisible(target) {
|
||
const rows = Array.isArray(state.channelsFeed?.followedChannels)
|
||
? state.channelsFeed.followedChannels
|
||
: [];
|
||
const expectedBch = String(target?.ownerBlockchainName || '');
|
||
const expectedNo = Number(target?.rootBlockNumber);
|
||
const expectedHash = normalizeHash(target?.rootBlockHash);
|
||
if (!expectedBch || !Number.isFinite(expectedNo)) return false;
|
||
|
||
return rows.filter(isVisibleChannelSummary).some((row) => {
|
||
const rowBch = String(row?.channel?.ownerBlockchainName || '');
|
||
const rowNo = Number(row?.channel?.channelRoot?.blockNumber);
|
||
const rowHash = normalizeHash(row?.channel?.channelRoot?.blockHash);
|
||
return rowBch === expectedBch && rowNo === expectedNo && rowHash === expectedHash;
|
||
});
|
||
}
|
||
|
||
function openSimpleSubscribeModal({ kind, kindLabel, submitLabel, unfollow = false, onSuccess }) {
|
||
const targetHint = kind === 'channel'
|
||
? '<p class="meta-muted">Канал: Alice@free/channel или имя канала.</p>'
|
||
: '<p class="meta-muted">Автор: Alice@free (старый ввод с @ тоже принимается).</p>';
|
||
const submitText = submitLabel || (unfollow ? 'Отписаться' : 'Подписаться');
|
||
const placeholder = kind === 'channel' ? 'Alice@free/channel' : 'Alice@free';
|
||
|
||
const root = document.getElementById('modal-root');
|
||
root.innerHTML = `
|
||
<div class="modal" id="channels-subscribe-modal">
|
||
<div class="modal-card stack">
|
||
<h3 class="modal-title">${kindLabel}</h3>
|
||
${targetHint}
|
||
<label class="meta-muted" for="subscribe-input">Поиск</label>
|
||
<input id="subscribe-input" class="input" placeholder="${placeholder}" autocomplete="off" />
|
||
<div id="subscribe-suggest" class="channels-search-suggest" style="display:none"></div>
|
||
<div id="subscribe-error" class="meta-muted inline-error"></div>
|
||
<div class="form-actions-grid">
|
||
<button class="secondary-btn" id="sub-cancel" type="button">Отмена</button>
|
||
<button class="primary-btn" id="sub-submit" type="button">${submitText}</button>
|
||
</div>
|
||
</div>
|
||
</div>
|
||
`;
|
||
|
||
const inputEl = root.querySelector('#subscribe-input');
|
||
const suggestEl = root.querySelector('#subscribe-suggest');
|
||
const errorEl = root.querySelector('#subscribe-error');
|
||
const submitEl = root.querySelector('#sub-submit');
|
||
|
||
let inFlight = false;
|
||
|
||
const setBusy = (busy) => {
|
||
inFlight = !!busy;
|
||
submitEl.disabled = inFlight;
|
||
if (inputEl) inputEl.disabled = inFlight;
|
||
submitEl.textContent = inFlight ? 'Выполняем...' : submitText;
|
||
};
|
||
|
||
const close = () => {
|
||
root.innerHTML = '';
|
||
};
|
||
|
||
const applySuggestion = (value) => {
|
||
if (!inputEl) return;
|
||
inputEl.value = value;
|
||
if (suggestEl) suggestEl.style.display = 'none';
|
||
inputEl.focus();
|
||
};
|
||
|
||
const refreshSuggestions = createDebounced(async () => {
|
||
if (!inputEl || !suggestEl || inFlight) return;
|
||
|
||
const raw = String(inputEl.value || '').trim();
|
||
if (!raw) {
|
||
suggestEl.style.display = 'none';
|
||
suggestEl.innerHTML = '';
|
||
return;
|
||
}
|
||
|
||
try {
|
||
if (kind === 'user') {
|
||
const prefix = normalizeLoginInput(raw);
|
||
if (prefix.length < 2) {
|
||
suggestEl.style.display = 'none';
|
||
suggestEl.innerHTML = '';
|
||
return;
|
||
}
|
||
const logins = await authService.searchUsers(prefix);
|
||
const suggestions = (Array.isArray(logins) ? logins : []).slice(0, 8).map((login) => normalizeLoginInput(login));
|
||
renderSuggestions(suggestEl, suggestions, applySuggestion);
|
||
return;
|
||
}
|
||
|
||
const suggestions = channelSuggestionsByInput(raw);
|
||
renderSuggestions(suggestEl, suggestions, applySuggestion);
|
||
} catch {
|
||
suggestEl.style.display = 'none';
|
||
suggestEl.innerHTML = '';
|
||
}
|
||
}, 240);
|
||
|
||
root.querySelector('#sub-cancel')?.addEventListener('click', close);
|
||
|
||
inputEl?.addEventListener('input', () => {
|
||
if (!errorEl) return;
|
||
errorEl.textContent = '';
|
||
refreshSuggestions();
|
||
});
|
||
|
||
submitEl?.addEventListener('click', async () => {
|
||
if (inFlight) return;
|
||
|
||
const login = state.session.login;
|
||
const storagePwd = state.session.storagePwdInMemory;
|
||
const value = String(inputEl?.value || '').trim();
|
||
|
||
if (!login || !storagePwd) {
|
||
errorEl.textContent = 'Сессия недействительна. Выполните вход заново.';
|
||
return;
|
||
}
|
||
|
||
if (!value) {
|
||
errorEl.textContent = 'Введите идентификатор.';
|
||
return;
|
||
}
|
||
|
||
setBusy(true);
|
||
errorEl.textContent = '';
|
||
|
||
try {
|
||
let channelTarget = null;
|
||
let userTargetLogin = '';
|
||
|
||
if (kind === 'user') {
|
||
userTargetLogin = normalizeLoginInput(value);
|
||
await authService.addBlockFollowUser({
|
||
login,
|
||
targetLogin: userTargetLogin,
|
||
storagePwd,
|
||
unfollow,
|
||
});
|
||
} else if (kind === 'channel') {
|
||
channelTarget = await resolveChannelTargetFromInput(value);
|
||
if (!channelTarget?.ownerBlockchainName || !Number.isFinite(channelTarget.rootBlockNumber)) {
|
||
throw new Error('Канал не найден.');
|
||
}
|
||
|
||
await authService.addBlockFollowChannel({
|
||
login,
|
||
storagePwd,
|
||
targetBlockchainName: channelTarget.ownerBlockchainName,
|
||
targetBlockNumber: channelTarget.rootBlockNumber,
|
||
targetBlockHashHex: channelTarget.rootBlockHash,
|
||
unfollow,
|
||
});
|
||
} else {
|
||
throw new Error('Неподдерживаемый тип подписки');
|
||
}
|
||
|
||
if (typeof onSuccess === 'function') {
|
||
await onSuccess();
|
||
}
|
||
|
||
if (kind === 'user') {
|
||
const visible = isFollowedUserVisible(userTargetLogin);
|
||
if (!unfollow && !visible) {
|
||
throw new Error('Подписка не подтвердилась после обновления списка.');
|
||
}
|
||
if (unfollow && visible) {
|
||
throw new Error('Отписка не подтвердилась после обновления списка.');
|
||
}
|
||
}
|
||
|
||
if (kind === 'channel') {
|
||
const visible = isFollowedChannelVisible(channelTarget);
|
||
if (!unfollow && !visible) {
|
||
throw new Error('Подписка на канал не подтвердилась после обновления списка.');
|
||
}
|
||
if (unfollow && visible) {
|
||
throw new Error('Отписка от канала не подтвердилась после обновления списка.');
|
||
}
|
||
}
|
||
|
||
softHaptic(15);
|
||
showToast(unfollow ? 'Отписка выполнена' : 'Подписка выполнена');
|
||
close();
|
||
} catch (error) {
|
||
errorEl.textContent = toUserMessage(error, `${submitText} не удалось.`);
|
||
setBusy(false);
|
||
}
|
||
});
|
||
|
||
if (inputEl) inputEl.focus();
|
||
}
|
||
|
||
|
||
function mapMockGroups() {
|
||
const mapRow = (channel) => ({
|
||
...channel,
|
||
sourceBucket: channel.kind === 'subscribed'
|
||
? 'followedChannels'
|
||
: channel.kind === 'followed-user-channel'
|
||
? 'followedUsers'
|
||
: 'own',
|
||
route: makeShineChannelRoute({
|
||
ownerLogin: String(channel.ownerName || 'channel'),
|
||
ownerBlockchainName: String(channel.ownerName || ''),
|
||
channelName: String(channel.channelName || channel.title || channel.id),
|
||
}),
|
||
messagePreview: cleanChannelMessagePreview(channel.lastMessage),
|
||
isSubscribed: channel.kind !== 'own' && channel.kind !== 'own-personal',
|
||
isOwnChannel: channel.kind === 'own' || channel.kind === 'own-personal',
|
||
notificationsEnabled: false,
|
||
messagesCount: Number(channel.messagesCount || 0),
|
||
unreadCount: 0,
|
||
lastMessageAt: 0,
|
||
ownerName: String(channel.ownerName || 'неизвестно'),
|
||
channelName: String(channel.channelName || channel.title || ''),
|
||
title: String(channel.title || channel.channelName || ''),
|
||
});
|
||
|
||
const ownChannels = mockChannels
|
||
.filter((channel) => channel.kind === 'own-personal' || channel.kind === 'own')
|
||
.map((item) => mapRow(item))
|
||
.filter((item) => !isStoriesChannel(item));
|
||
|
||
const followedUserChannels = mockChannels
|
||
.filter((channel) => channel.kind === 'followed-user-channel')
|
||
.map((item) => mapRow(item))
|
||
.filter((item) => !isStoriesChannel(item));
|
||
|
||
const subscribedChannels = mockChannels
|
||
.filter((channel) => channel.kind === 'subscribed')
|
||
.map((item) => mapRow(item))
|
||
.filter((item) => !isStoriesChannel(item));
|
||
|
||
return { ownChannels, followedUserChannels, subscribedChannels, index: {} };
|
||
}
|
||
|
||
function mapApiChannelRow(summary, bucketKey, idx, index, notificationsState) {
|
||
const rowId = `${bucketKey}-${idx}`;
|
||
index[rowId] = summary;
|
||
|
||
const ownerLogin = summary?.channel?.ownerLogin || 'неизвестно';
|
||
const channelName = summary?.channel?.channelName || '(без названия)';
|
||
const displayTitle = String(summary?.channel?.displayName || channelName).trim();
|
||
const channelDescription = String(summary?.channel?.channelDescription || '').trim();
|
||
const channelTypeCode = Number(summary?.channel?.channelTypeCode ?? 1);
|
||
const channelTypeVersion = Number(summary?.channel?.channelTypeVersion ?? 1);
|
||
const isOwn = bucketKey === 'own';
|
||
const title = displayTitle || channelName;
|
||
const technicalLabel = formatChannelAddress({ ownerLogin, channelName });
|
||
const lastMessage = resolveChannelLastMessage(summary);
|
||
|
||
return {
|
||
id: rowId,
|
||
sourceBucket: bucketKey,
|
||
route: buildChannelRouteFromSummary(summary, rowId),
|
||
ownerName: ownerLogin,
|
||
ownerBlockchainName: summary?.channel?.ownerBlockchainName || '',
|
||
channelRootBlockNumber: Number(summary?.channel?.channelRoot?.blockNumber),
|
||
channelRootBlockHash: normalizeHash(summary?.channel?.channelRoot?.blockHash),
|
||
avatar: avatarLetterFromName(displayTitle || channelName),
|
||
avaAr: String(summary?.channel?.avaAr || '').trim(),
|
||
avaSha256: String(summary?.channel?.avaSha256 || '').trim().toLowerCase(),
|
||
title,
|
||
technicalLabel,
|
||
channelName,
|
||
displayTitle,
|
||
channelDescription,
|
||
channelTypeCode,
|
||
channelTypeVersion,
|
||
messagePreview: cleanChannelMessagePreview(lastMessage.text),
|
||
messagesCount: Number(summary?.messagesCount || 0),
|
||
unreadCount: Number(summary?.unreadCount || 0),
|
||
lastMessageAt: Number(lastMessage.createdAtMs || summary?.channel?.metaUpdatedAtMs || 0),
|
||
isOwnChannel: isOwn,
|
||
isSubscribed: !isOwn,
|
||
notificationsEnabled: notificationsState[rowId] === true,
|
||
pending: false,
|
||
};
|
||
}
|
||
|
||
function mapDeletedOwnedChannels(payload, notificationsState = {}) {
|
||
const rows = Array.isArray(payload?.channels) ? payload.channels : [];
|
||
return rows.filter((item) => item?.deleted === true).map((item, idx) => {
|
||
const rowId = `own-deleted-${idx}`;
|
||
const ownerLogin = String(item?.ownerLogin || state.session.login || '').trim();
|
||
const channelName = String(item?.slug || '').trim();
|
||
const displayTitle = String(item?.displayName || channelName || 'Канал').trim();
|
||
return {
|
||
id: rowId,
|
||
sourceBucket: 'ownDeleted',
|
||
route: makeShineChannelShortRoute({
|
||
ownerLogin,
|
||
ownerBlockchainName: String(item?.ownerBlockchainName || '').trim(),
|
||
channelName,
|
||
}),
|
||
ownerName: ownerLogin,
|
||
ownerBlockchainName: String(item?.ownerBlockchainName || '').trim(),
|
||
channelRootBlockNumber: Number(item?.rootBlockNumber),
|
||
channelRootBlockHash: normalizeHash(item?.rootBlockHashHex),
|
||
avatar: avatarLetterFromName(displayTitle),
|
||
avaAr: String(item?.avatarAr || '').trim(),
|
||
avaSha256: String(item?.avatarSha256 || '').trim().toLowerCase(),
|
||
title: displayTitle,
|
||
technicalLabel: formatChannelAddress({ ownerLogin, channelName }),
|
||
channelName,
|
||
displayTitle,
|
||
channelDescription: '',
|
||
channelTypeCode: 1,
|
||
channelTypeVersion: 1,
|
||
messagePreview: 'Канал помечен как удалённый',
|
||
messagesCount: 0,
|
||
unreadCount: 0,
|
||
lastMessageAt: Number(item?.deletedAtMs || 0),
|
||
isOwnChannel: true,
|
||
isDeleted: true,
|
||
isSubscribed: false,
|
||
notificationsEnabled: notificationsState[rowId] === true,
|
||
pending: false,
|
||
};
|
||
});
|
||
}
|
||
|
||
function pullCreateSuccessFlash() {
|
||
try {
|
||
const value = String(sessionStorage.getItem(CREATE_CHANNEL_FLASH_KEY) || '').trim();
|
||
if (value) sessionStorage.removeItem(CREATE_CHANNEL_FLASH_KEY);
|
||
return value;
|
||
} catch {
|
||
return '';
|
||
}
|
||
}
|
||
|
||
function buildDiaryChannelRow(diaryPayload, ownRows = [], notificationsState = {}, index = {}) {
|
||
const messages = Array.isArray(diaryPayload?.messages) ? diaryPayload.messages : [];
|
||
if (!messages.length) return null;
|
||
|
||
const ownerBlockchainName = String(
|
||
diaryPayload?.channel?.ownerBlockchainName
|
||
|| ownRows[0]?.channel?.ownerBlockchainName
|
||
|| ''
|
||
).trim();
|
||
if (!ownerBlockchainName) return null;
|
||
|
||
const ownerLogin = String(diaryPayload?.channel?.ownerLogin || state.session.login || '').trim();
|
||
const lastMessage = messages[messages.length - 1] || null;
|
||
const rowId = 'own-diary';
|
||
index[rowId] = { diary: true, payload: diaryPayload };
|
||
|
||
return {
|
||
id: rowId,
|
||
sourceBucket: 'own',
|
||
route: makeShineChannelRoute({
|
||
ownerLogin,
|
||
ownerBlockchainName,
|
||
channelName: DIARY_CHANNEL_NAME,
|
||
}),
|
||
ownerName: ownerLogin || 'я',
|
||
ownerBlockchainName,
|
||
channelRootBlockNumber: 0,
|
||
channelRootBlockHash: '0',
|
||
avatar: 'Д',
|
||
avaAr: '',
|
||
title: DIARY_DISPLAY_NAME,
|
||
technicalLabel: 'Виртуальная лента Дневника',
|
||
channelName: DIARY_CHANNEL_NAME,
|
||
displayTitle: DIARY_DISPLAY_NAME,
|
||
channelDescription: 'История действий по упражнениям, услугам и курсам',
|
||
channelTypeCode: 900,
|
||
channelTypeVersion: 1,
|
||
messagePreview: String(lastMessage?.text || '').trim()
|
||
? cleanChannelMessagePreview(lastMessage?.text)
|
||
: 'Новая запись в Дневнике',
|
||
messagesCount: messages.length,
|
||
unreadCount: 0,
|
||
lastMessageAt: Number(lastMessage?.createdAtMs || 0),
|
||
isOwnChannel: true,
|
||
isSubscribed: false,
|
||
notificationsEnabled: notificationsState[rowId] === true,
|
||
pending: false,
|
||
};
|
||
}
|
||
|
||
function mapApiFeed(feed, notificationsState, diaryPayload = null) {
|
||
const index = {};
|
||
const ownChannels = (feed?.ownedChannels || [])
|
||
.filter(isVisibleChannelSummary)
|
||
.map((it, idx) => mapApiChannelRow(it, 'own', idx, index, notificationsState));
|
||
const diaryChannel = diaryPayload
|
||
? buildDiaryChannelRow(diaryPayload, feed?.ownedChannels || [], notificationsState, index)
|
||
: null;
|
||
if (diaryChannel) ownChannels.unshift(diaryChannel);
|
||
const followedUserChannels = (feed?.followedUsersChannels || [])
|
||
.filter(isVisibleChannelSummary)
|
||
.map((it, idx) => mapApiChannelRow(it, 'followedUsers', idx, index, notificationsState));
|
||
const subscribedChannels = (feed?.followedChannels || [])
|
||
.filter(isVisibleChannelSummary)
|
||
.map((it, idx) => mapApiChannelRow(it, 'followedChannels', idx, index, notificationsState));
|
||
|
||
return { ownChannels, followedUserChannels, subscribedChannels, index };
|
||
}
|
||
|
||
const PREFETCH_CHANNELS = 6;
|
||
const PREFETCH_FRESH_MS = 50_000;
|
||
|
||
// Фоновое обновление ленты каналов и самых активных каналов: экран «Каналы» и сами каналы
|
||
// открываются сразу из памяти. Запросы идут по одному, чтобы не нагружать сервер.
|
||
export async function refreshChannelsInBackground({ isCurrent = () => true } = {}) {
|
||
if (!state.session.isAuthorized || state.session.isLocalDemo) return;
|
||
const login = state.session.login;
|
||
const feed = await authService.listSubscriptionsFeed(login, 200);
|
||
if (!isCurrent() || state.session.login !== login) return;
|
||
const groups = mapApiFeed(feed, {}, null);
|
||
setChannelsFeed(feed, groups.index);
|
||
const routes = toListModel(groups)
|
||
.filter((row) => row.route)
|
||
.sort((a, b) => Number(b.lastMessageAt || 0) - Number(a.lastMessageAt || 0))
|
||
.slice(0, PREFETCH_CHANNELS)
|
||
.map((row) => `/${toPrettyPath(row.route)}`);
|
||
for (const route of routes) {
|
||
if (!isCurrent() || state.session.login !== login) return;
|
||
const pathname = new URL(route, window.location.origin).pathname;
|
||
if (pathname === window.location.pathname || pageDataAge('channel', pathname) < PREFETCH_FRESH_MS) continue;
|
||
try {
|
||
await prefetchChannelPage(pathname);
|
||
} catch {
|
||
// Фоновая подгрузка не должна мешать: канал загрузится обычным путём при открытии.
|
||
}
|
||
}
|
||
}
|
||
|
||
function toListModel(groups) {
|
||
return [
|
||
...(groups.ownChannels || []),
|
||
...(groups.followedUserChannels || []),
|
||
...(groups.subscribedChannels || []),
|
||
];
|
||
}
|
||
|
||
function renderEmptyState(listState, navigate) {
|
||
const wrap = document.createElement('div');
|
||
wrap.className = 'channels-empty-state channels-empty-state--compact channels-empty-state--silent';
|
||
const heading = document.createElement('strong');
|
||
heading.textContent = listState.query ? 'Ничего не найдено' : listState.viewMode === CHANNELS_VIEW_DELETED ? 'Удалённых каналов нет' : listState.viewMode === CHANNELS_VIEW_FOLLOWING ? 'Пока нет подписок' : listState.viewMode === CHANNELS_VIEW_OWNED ? 'Здесь будут ваши каналы' : 'Откройте свой первый канал';
|
||
const text = document.createElement('p');
|
||
text.className = 'meta-muted';
|
||
text.textContent = listState.viewMode === CHANNELS_VIEW_DELETED ? 'Здесь появятся только ваши каналы, помеченные как удалённые.' : state.session.isAuthorized ? 'Найдите канал по названию, адресу или автору – либо создайте свой.' : 'Войдите, чтобы видеть свои каналы и подписки.';
|
||
const action = document.createElement('button');
|
||
action.type = 'button';
|
||
action.className = 'primary-btn';
|
||
action.textContent = 'Найти каналы';
|
||
action.addEventListener('click', () => navigate('search-view'));
|
||
wrap.append(heading, text, action);
|
||
|
||
return wrap;
|
||
}
|
||
|
||
function renderSkeletonList(container, count = 4) {
|
||
container.replaceChildren(createSkeletonRows('list', count));
|
||
}
|
||
|
||
function renderErrorState(container, error, onRetry) {
|
||
container.append(createLoadErrorCard({
|
||
title: 'Не удалось загрузить каналы',
|
||
message: toUserMessage(error, 'Проверьте подключение и повторите попытку.'),
|
||
onRetry,
|
||
}));
|
||
}
|
||
|
||
function renderDemoFallback(container, navigate, error, onRetry, { localOnly = false } = {}) {
|
||
const info = document.createElement('div');
|
||
info.className = 'card stack';
|
||
info.innerHTML = `
|
||
<strong>${localOnly ? 'Локальный тестовый режим' : 'Включен демо-режим'}</strong>
|
||
<p class="meta-muted">${localOnly
|
||
? 'Показаны мок-каналы. Подключение к серверу отключено.'
|
||
: 'Данные сервера недоступны. Показаны мок-каналы, потому что включен channelsDemo.'}</p>
|
||
${localOnly ? '' : `<p class="meta-muted">${toUserMessage(error, 'Ошибка API/WS')}</p>`}
|
||
`;
|
||
|
||
if (!localOnly && typeof onRetry === 'function') {
|
||
const retry = document.createElement('button');
|
||
retry.className = 'secondary-btn';
|
||
retry.type = 'button';
|
||
retry.textContent = 'Повторить запрос к серверу';
|
||
retry.addEventListener('click', onRetry);
|
||
info.append(retry);
|
||
}
|
||
container.append(info);
|
||
|
||
const groups = mapMockGroups();
|
||
const list = document.createElement('div');
|
||
list.className = 'stack';
|
||
|
||
toListModel(groups).forEach((channel) => {
|
||
const row = document.createElement('article');
|
||
row.className = 'channel-row';
|
||
row.innerHTML = `
|
||
<div class="channel-row-main">
|
||
<strong class="channel-row-title">${channel.title || channel.displayName || channel.name}</strong>
|
||
<p class="channel-row-message">${channel.messagePreview || 'Ждем ваших начинаний'}</p>
|
||
</div>
|
||
<div class="channel-row-controls">
|
||
<span class="channel-row-time">–</span>
|
||
</div>
|
||
`;
|
||
row.prepend(createChannelAvatar(channel));
|
||
row.addEventListener('click', () => {
|
||
const route = channel.route || makeShineChannelRoute({
|
||
ownerLogin: String(channel.ownerName || 'channel'),
|
||
ownerBlockchainName: String(channel.ownerName || ''),
|
||
channelName: String(channel.channelName || channel.id),
|
||
});
|
||
if (route) navigate(route);
|
||
});
|
||
list.append(row);
|
||
});
|
||
|
||
container.append(list);
|
||
}
|
||
|
||
function renderChannelMain(channel) {
|
||
const main = document.createElement('div');
|
||
main.className = 'channel-row-main';
|
||
|
||
const titleLine = document.createElement('div');
|
||
titleLine.className = 'channel-row-title-line';
|
||
|
||
const title = document.createElement('strong');
|
||
title.className = 'channel-row-title';
|
||
title.textContent = channel.title;
|
||
|
||
const time = document.createElement('span');
|
||
time.className = 'channel-row-time';
|
||
time.textContent = channel.lastMessageAt ? formatListTime(channel.lastMessageAt) : '';
|
||
titleLine.append(title, time);
|
||
|
||
const technical = document.createElement('p');
|
||
technical.className = 'channel-row-technical';
|
||
technical.textContent = channel.technicalLabel || formatChannelAddress({ ownerLogin: channel.ownerName || 'автор', channelName: channel.channelName });
|
||
// Системный адрес одинаково виден в собственных и чужих каналах.
|
||
|
||
if (channel.channelDescription) {
|
||
const desc = document.createElement('p');
|
||
desc.className = 'channel-row-description';
|
||
desc.textContent = channel.channelDescription;
|
||
main.append(desc);
|
||
}
|
||
|
||
const previewLine = document.createElement('div');
|
||
previewLine.className = 'channel-row-preview-line';
|
||
|
||
const preview = document.createElement('p');
|
||
preview.className = 'channel-row-message';
|
||
preview.textContent = channel.messagePreview || 'Пока нет сообщений';
|
||
if (!channel.messagePreview) preview.classList.add('is-empty');
|
||
|
||
previewLine.append(preview);
|
||
|
||
const meta = document.createElement('p');
|
||
meta.className = 'channel-row-owner channel-counter-meta';
|
||
meta.textContent = `Сообщений: ${channel.messagesCount || 0}`;
|
||
|
||
main.prepend(titleLine, technical);
|
||
main.append(previewLine, meta);
|
||
return main;
|
||
}
|
||
|
||
function renderListContent({ screen, container, listState, navigate, refreshFeed }) {
|
||
container.innerHTML = '';
|
||
|
||
const allChannels = listState.channels || [];
|
||
const filtered = allChannels.filter((channel) => {
|
||
if (listState.viewMode === CHANNELS_VIEW_OWNED) return channel.isOwnChannel === true && channel.isDeleted !== true;
|
||
if (listState.viewMode === CHANNELS_VIEW_FOLLOWING) return channel.sourceBucket === 'followedChannels';
|
||
if (listState.viewMode === CHANNELS_VIEW_DELETED) return channel.isDeleted === true;
|
||
return channel.isDeleted !== true;
|
||
}).filter((channel) => {
|
||
const query = String(listState.query || '').trim().toLowerCase();
|
||
if (!query) return true;
|
||
return [channel.title, channel.ownerName, channel.channelName, channel.technicalLabel]
|
||
.some((value) => String(value || '').toLowerCase().includes(query));
|
||
});
|
||
|
||
if (!filtered.length) {
|
||
container.append(renderEmptyState(listState, navigate));
|
||
return;
|
||
}
|
||
|
||
const list = document.createElement('div');
|
||
list.className = 'stack channels-groups';
|
||
|
||
const rerenderList = () => renderListContent({ screen, container, listState, navigate, refreshFeed });
|
||
|
||
filtered.forEach((channel) => {
|
||
const row = document.createElement('button');
|
||
row.type = 'button';
|
||
row.className = 'channel-row';
|
||
const countersVisible = listState.revealedCounters.has(channel.id);
|
||
row.classList.toggle('is-counters-visible', countersVisible);
|
||
row.classList.toggle('has-unread', Number(channel.unreadCount || 0) > 0);
|
||
|
||
const avatar = createChannelAvatar(channel);
|
||
|
||
const main = renderChannelMain(channel);
|
||
|
||
const controls = document.createElement('div');
|
||
controls.className = 'channel-row-controls';
|
||
|
||
const count = document.createElement('span');
|
||
count.className = 'unread channel-row-count';
|
||
const unreadCount = Number(channel.unreadCount || 0);
|
||
count.hidden = unreadCount <= 0;
|
||
count.textContent = unreadCount > 0 ? String(unreadCount) : '';
|
||
count.classList.toggle('is-empty', unreadCount <= 0);
|
||
|
||
controls.append(count);
|
||
|
||
row.append(avatar, main, controls);
|
||
row.addEventListener('click', () => {
|
||
const route = channel.route || makeShineChannelRoute({
|
||
ownerLogin: String(channel.ownerName || 'channel'),
|
||
ownerBlockchainName: String(channel.ownerName || ''),
|
||
channelName: String(channel.channelName || channel.id),
|
||
});
|
||
if (route) navigate(route);
|
||
});
|
||
list.append(row);
|
||
});
|
||
|
||
container.append(list);
|
||
}
|
||
|
||
async function loadFeedAndRender({ screen, listState, contentEl, navigate, silent = false }) {
|
||
if (listState.disposed) return;
|
||
const seq = ++listState.loadSeq;
|
||
// Уже загруженный список показываем сразу и тихо обновляем; заглушка – только при долгой первой загрузке.
|
||
if (!silent && state.session.isAuthorized && state.channelsFeed && listState.viewMode !== CHANNELS_VIEW_DELETED) {
|
||
listState.channels = toListModel(mapApiFeed(state.channelsFeed, listState.notificationsState, null));
|
||
renderListContent({
|
||
screen,
|
||
container: contentEl,
|
||
listState,
|
||
navigate,
|
||
refreshFeed: async () => loadFeedAndRender({ screen, listState, contentEl, navigate }),
|
||
});
|
||
silent = true;
|
||
}
|
||
if (!silent) {
|
||
window.setTimeout(() => {
|
||
if (!listState.disposed && seq === listState.loadSeq && !contentEl.hasChildNodes()) renderSkeletonList(contentEl, 5);
|
||
}, SKELETON_DELAY_MS);
|
||
contentEl.replaceChildren();
|
||
}
|
||
|
||
if (!state.session.isAuthorized) {
|
||
setChannelsFeed(null, {});
|
||
listState.channels = [];
|
||
renderListContent({
|
||
screen,
|
||
container: contentEl,
|
||
listState,
|
||
navigate,
|
||
refreshFeed: async () => loadFeedAndRender({ screen, listState, contentEl, navigate }),
|
||
});
|
||
return;
|
||
}
|
||
|
||
if (state.session.isLocalDemo) {
|
||
setChannelsFeed(null, {});
|
||
listState.channels = [];
|
||
contentEl.innerHTML = '';
|
||
renderDemoFallback(contentEl, navigate, null, null, { localOnly: true });
|
||
return;
|
||
}
|
||
|
||
try {
|
||
if (listState.viewMode === CHANNELS_VIEW_DELETED) {
|
||
const payload = await authService.listUserProfileChannels(state.session.login, 'owned', 500, 0, true);
|
||
if (listState.disposed || seq !== listState.loadSeq) return;
|
||
listState.channels = mapDeletedOwnedChannels(payload, listState.notificationsState);
|
||
renderListContent({
|
||
screen,
|
||
container: contentEl,
|
||
listState,
|
||
navigate,
|
||
refreshFeed: async () => loadFeedAndRender({ screen, listState, contentEl, navigate }),
|
||
});
|
||
return;
|
||
}
|
||
|
||
const feed = await authService.listSubscriptionsFeed(state.session.login, 200);
|
||
if (listState.disposed || seq !== listState.loadSeq) return;
|
||
|
||
// FEATURE DISABLED: personal Diary is intentionally hidden from the Channels UI.
|
||
// The server/API implementation is preserved so the feature can be restored later.
|
||
// See: docs/закомментировано/Личный_дневник.md
|
||
// let diaryPayload = null;
|
||
// try {
|
||
// diaryPayload = await authService.getPersonalDiary(state.session.login, 200, 'asc');
|
||
// } catch {
|
||
// diaryPayload = null;
|
||
// }
|
||
const diaryPayload = null;
|
||
|
||
const groups = mapApiFeed(feed, listState.notificationsState, diaryPayload);
|
||
|
||
listState.channels = toListModel(groups);
|
||
setChannelsFeed(feed, groups.index);
|
||
|
||
renderListContent({
|
||
screen,
|
||
container: contentEl,
|
||
listState,
|
||
navigate,
|
||
refreshFeed: async () => loadFeedAndRender({ screen, listState, contentEl, navigate }),
|
||
});
|
||
if (Number.isFinite(listState.restorePosition)) {
|
||
restoreChannelPosition(listState.restorePosition);
|
||
listState.restorePosition = undefined;
|
||
}
|
||
} catch (error) {
|
||
if (listState.disposed || seq !== listState.loadSeq) return;
|
||
if (silent) return;
|
||
setChannelsFeed(null, {});
|
||
contentEl.innerHTML = '';
|
||
|
||
if (isChannelsDemoMode()) {
|
||
renderDemoFallback(contentEl, navigate, error, () => loadFeedAndRender({ screen, listState, contentEl, navigate }));
|
||
return;
|
||
}
|
||
|
||
renderErrorState(contentEl, error, () => loadFeedAndRender({ screen, listState, contentEl, navigate }));
|
||
}
|
||
}
|
||
|
||
export function render({ navigate, route, chrome }) {
|
||
const screen = document.createElement('section');
|
||
screen.className = 'stack channels-screen channels-screen--list';
|
||
|
||
const createSuccessFlash = pullCreateSuccessFlash();
|
||
const notificationsState = readChannelNotificationsState();
|
||
|
||
const isGuest = !state.session.isAuthorized;
|
||
const positionKey = `${state.session.login}:channels:${normalizeChannelsViewMode(route)}`;
|
||
const listState = {
|
||
restorePosition: readChannelPosition(positionKey),
|
||
disposed: false,
|
||
loadSeq: 0,
|
||
notificationsState,
|
||
revealedCounters: new Set(),
|
||
channels: [],
|
||
viewMode: normalizeChannelsViewMode(route),
|
||
query: listQueries.get(positionKey) || '',
|
||
};
|
||
|
||
const contentEl = document.createElement('div');
|
||
contentEl.className = 'channels-list-content';
|
||
|
||
const filterTitle = createTopBarFilterTitle({
|
||
section: 'Каналы',
|
||
choices: CHANNEL_FILTERS,
|
||
value: listState.viewMode,
|
||
minWidth: 240,
|
||
onSelect: (mode) => {
|
||
if (mode !== listState.viewMode) navigate(buildChannelsViewRoute(mode));
|
||
},
|
||
});
|
||
const topBarEl = createTopBar({
|
||
center: filterTitle.element,
|
||
className: 'topbar--root topbar--section-filter',
|
||
actions: [
|
||
{
|
||
icon: 'moreVertical',
|
||
title: 'Меню каналов',
|
||
ariaLabel: 'Открыть меню каналов',
|
||
className: 'channels-menu-btn',
|
||
menu: {
|
||
minWidth: 210,
|
||
items: () => [
|
||
{ label: 'Создать канал', iconHtml: channelMenuIcon('add'), action: () => navigate('add-channel-view') },
|
||
],
|
||
},
|
||
},
|
||
],
|
||
});
|
||
topBarEl.addCleanup(() => filterTitle.destroy());
|
||
|
||
const controls = document.createElement('div');
|
||
controls.className = 'channels-list-controls';
|
||
const searchWrap = document.createElement('div');
|
||
searchWrap.className = 'channels-inline-search';
|
||
searchWrap.innerHTML = `<span class="channels-inline-search__icon" aria-hidden="true">${iconHtml('search')}</span><span class="sr-only">Поиск каналов</span>`;
|
||
const searchInput = document.createElement('input');
|
||
searchInput.type = 'search';
|
||
searchInput.value = listState.query;
|
||
searchInput.placeholder = 'В вашем списке';
|
||
searchInput.setAttribute('aria-label', 'Найти канал или автора');
|
||
const serverSearchButton = document.createElement('button');
|
||
serverSearchButton.type = 'button';
|
||
serverSearchButton.className = 'text-btn channels-server-search';
|
||
serverSearchButton.textContent = 'Поиск в SHiNE';
|
||
serverSearchButton.addEventListener('click', () => navigate('search-view'));
|
||
searchWrap.append(searchInput, serverSearchButton);
|
||
|
||
controls.append(searchWrap);
|
||
|
||
const reloadFeed = async () => loadFeedAndRender({ screen, listState, contentEl, navigate });
|
||
|
||
let countersRefreshTimer = null;
|
||
let lastChannelsUnreadCount = Math.max(0, Number(state.userCounters?.channelsUnreadCount || 0) || 0);
|
||
const unsubscribeCountersChanged = authService.onEvent('UserCountersChanged', (event) => {
|
||
const nextChannelsUnreadCount = Math.max(0, Number(event?.payload?.channelsUnreadCount || 0) || 0);
|
||
if (nextChannelsUnreadCount === lastChannelsUnreadCount) return;
|
||
lastChannelsUnreadCount = nextChannelsUnreadCount;
|
||
|
||
if (countersRefreshTimer) window.clearTimeout(countersRefreshTimer);
|
||
countersRefreshTimer = window.setTimeout(() => {
|
||
countersRefreshTimer = null;
|
||
void loadFeedAndRender({ screen, listState, contentEl, navigate, silent: true });
|
||
}, 120);
|
||
});
|
||
|
||
const rerenderList = () => {
|
||
listState.viewMode = normalizeChannelsViewMode({ params: route?.params || {} });
|
||
|
||
renderListContent({
|
||
screen,
|
||
container: contentEl,
|
||
listState,
|
||
navigate,
|
||
refreshFeed: reloadFeed,
|
||
});
|
||
|
||
};
|
||
|
||
searchInput.addEventListener('input', () => {
|
||
listState.restorePosition = undefined;
|
||
listState.query = searchInput.value;
|
||
rerenderList();
|
||
});
|
||
|
||
chrome?.setTopbar(topBarEl);
|
||
screen.append(controls, contentEl);
|
||
|
||
if (createSuccessFlash) {
|
||
showToast(createSuccessFlash);
|
||
}
|
||
|
||
// Применяем корректное состояние хедера сразу на первом рендере,
|
||
// чтобы не показывать лишние кнопки до первой перерисовки.
|
||
rerenderList();
|
||
loadFeedAndRender({ screen, listState, contentEl, navigate });
|
||
|
||
screen.cleanup = () => {
|
||
if (listState.disposed) return;
|
||
rememberChannelPosition(positionKey);
|
||
listQueries.set(positionKey, listState.query);
|
||
listState.disposed = true;
|
||
if (countersRefreshTimer) window.clearTimeout(countersRefreshTimer);
|
||
unsubscribeCountersChanged();
|
||
};
|
||
|
||
return screen;
|
||
}
|