Files
SHiNE-server/shine-UI/js/app.js
T
q b9cbbb857b UI: личные чаты (поиск, медиа, «без звука», закреп) и новая карта связей
Личные сообщения:
- поиск по переписке с подсветкой, переход к дате по календарю;
- экран «Медиа и файлы» (/chat/<login>/media);
- «без звука» и закрепление чатов (на устройстве), push от заглушённых не показывается;
- новая нижняя панель ввода, круглый спиннер истории, медиа-карусель;
- история загружается в ~16 раз быстрее: ключ расшифровки достаётся один раз на страницу;
- исправлены прозрачные окна подтверждения в чате.

Связи:
- карта переписана на canvas (graph-canvas.js вместо force-graph.js): плавная анимация
  без дёрганья, панорама, масштаб щипком/колесом/кнопками, перетаскивание людей;
- ручная раскладка и режимы «По близости»/«По группам» запоминаются на устройстве;
- цвет нити – тип связи, пунктир – связь с одной стороны, аура только у сияющих;
- карточка человека: раскрыть связи на месте, в центр, профиль, написать, заметка;
- «Недавние» заменены раскрытием связей; фильтр «Заметки».

Личные заметки о людях (текст и цветная метка, только на устройстве) – на карте и в профиле.
2026-10-12 23:27:14 +03:00

2056 lines
73 KiB
JavaScript
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
import {
navigate,
getRoute,
PRE_AUTH_PAGES,
syncTrackedRouteHistory,
consumeHistoryLayerPop,
} from './router.js';
import { renderToolbar } from './components/toolbar.js';
import {
captureClientError,
getLastClientErrorPayload,
setClientErrorSentNotifier,
setClientErrorTransport,
} from './services/client-error-reporter.js';
import { attachScrollToBottomButton } from './components/scroll-to-bottom-button.js';
import { initPwaInstallPromptHandling } from './services/pwa-install-service.js';
import { initPwaPush } from './services/pwa-push-service.js';
import { initCallUiOverlay } from './services/call-ui-service.js';
import { showToast } from './services/channels-ux.js';
import { KeyRotationClient } from './services/key-rotation-service.js';
import {
handleCallPushAction,
handleIncomingCallInvite,
handleIncomingCallPush,
handleIncomingCallSignal,
handleIncomingCallSignalViaSendSignal,
handleStopCallPush,
setCallDebugReporter,
startDebugConnectionAsInitiator,
startDebugConnectionAsResponder,
} from './services/call-service.js';
import { parseDmTechBlocks } from './services/dm-tech-blocks.js';
import {
authService,
addAppLogEntry,
authorizeSession,
hydrateMessagesFromStore,
getSavedProfiles,
closeSavedProfile,
switchToSavedProfile,
isSessionInvalidError,
refreshSessions,
setSessionAuthorizedHandler,
setSessionResetHandler,
state,
terminateCurrentSession,
addSignedMessageToChat,
deleteConversationMessagesBefore,
deleteSignedMessageByBaseKey,
markIncomingReadByBaseKey,
markOutgoingDeliveryState,
markOutgoingReadByBaseKey,
normalizeDmChatId,
applyUrlServerLoginOverrideIfNeeded,
hasUrlEntrySettingsOverride,
setContacts,
} from './state.js';
import * as startView from './pages/start-view.js?v=202610072303';
import * as entrySettingsView from './pages/entry-settings-view.js?v=202609260900';
import * as registerView from './pages/register-view.js?v=202609260900';
import * as registrationFaqView from './pages/registration-faq-view.js?v=202610072303';
import * as registrationPaymentView from './pages/registration-payment-view.js?v=202606180940';
import * as registrationDraftKeysView from './pages/registration-draft-keys-view.js';
import * as topupView from './pages/topup-view.js';
import * as devnetTopupView from './pages/devnet-topup-view.js';
import * as loginView from './pages/login-view.js?v=202609260900';
import * as loginCameraView from './pages/login-camera-view.js';
import * as loginOtherDeviceView from './pages/login-other-device-view.js?v=202610072303';
import * as loginPasswordView from './pages/login-password-view.js?v=202606201650';
import * as publicSupportQueueView from './pages/public-support-queue-view.js';
import * as profileView from './pages/profile-view.js?v=202609260900';
import * as profileEditView from './pages/profile-edit-view.js';
import * as profilesView from './pages/profiles-view.js';
import * as walletView from './pages/wallet-view.js?v=202609260900';
import * as settingsView from './pages/settings-view.js';
import * as accessKeysView from './pages/access-keys-view.js';
import * as myBlockchainView from './pages/my-blockchain-view.js';
import * as myBlockchainHistoryView from './pages/my-blockchain-history-view.js';
import * as keyRotationView from './pages/key-rotation-view.js';
import * as accessServersView from './pages/access-servers-view.js';
import * as settingsServersView from './pages/settings-servers-view.js';
import * as developerSettingsView from './pages/developer-settings-view.js';
import * as advancedSettingsView from './pages/advanced-settings-view.js';
import * as serverSettingsView from './pages/server-settings-view.js?v=202609260900';
import * as arweaveUploadsView from './pages/arweave-uploads-view.js';
import * as remoteAddBlockSessionView from './pages/remote-addblock-session-view.js?v=202606281300';
import * as deviceView from './pages/device-view.js?v=202610072303';
import * as connectDeviceView from './pages/connect-device-view.js?v=202610072303';
import * as clientPairingView from './pages/device-pairing-view.js?v=202610072303';
import * as trustedDeviceLoginSettingsView from './pages/trusted-device-login-settings-view.js?v=202610072303';
import { applyThemeMode, watchSystemTheme } from './services/theme-service.js';
import * as deviceQrView from './pages/device-qr-view.js';
import * as deviceCameraView from './pages/device-camera-view.js';
import * as showKeysView from './pages/show-keys-view.js';
import * as clientSessionView from './pages/device-session-view.js?v=202606131435';
import * as languageView from './pages/language-view.js';
import * as appLogView from './pages/app-log-view.js';
import * as pwaDiagnosticsView from './pages/pwa-diagnostics-view.js';
import * as solanaUsersInitView from './pages/solana-users-init-view.js';
import * as solanaRpcCheckView from './pages/solana-rpc-check-view.js';
import * as messagesList from './pages/messages-list.js?v=202609260900';
import * as contactSearchView from './pages/contact-search-view.js';
import * as chatView from './pages/chat-view.js?v=202609260900';
import * as chatMediaView from './pages/chat-media-view.js';
import { isDmChatMuted } from './services/dm-chat-prefs.js';
import * as userProfileView from './pages/user-profile-view.js';
import * as userProfileListView from './pages/user-profile-list-view.js';
import * as userRelationManageView from './pages/user-relation-manage-view.js';
import * as channelsList from './pages/channels-list.js?v=20261011-search';
import * as searchView from './pages/search-view.js';
import * as channelView from './pages/channel-view.js';
import * as channelAboutView from './pages/channel-about-view.js';
import * as channelDonateView from './pages/channel-donate-view.js';
import * as channelThreadView from './pages/channel-thread-view.js';
import * as addChannelView from './pages/add-channel-view.js';
import * as addPersonalPublicChatView from './pages/add-personal-public-chat-view.js';
import * as networkView from './pages/network-view.js?v=202609260900';
import * as notificationsView from './pages/notifications-view.js?v=202609260900';
const CONVERSATION_CLEAR_NOTICE_TEXT = 'История переписки очищена с этого места';
const DM_UNSUPPORTED_FORMAT_TEXT = 'Формат сообщения не поддерживается';
const DM_DECRYPT_FAILED_TEXT = 'Не удалось расшифровать сообщение';
const DM_CORRUPTED_TEXT = 'Сообщение повреждено';
function dmDecryptFallbackText(error) {
const kind = authService.classifyDmDecryptFailure(error);
if (kind === 'unsupported_format') return DM_UNSUPPORTED_FORMAT_TEXT;
if (kind === 'corrupted') return DM_CORRUPTED_TEXT;
return DM_DECRYPT_FAILED_TEXT;
}
const routes = {
'start-view': startView,
'entry-settings-view': entrySettingsView,
'register-view': registerView,
'registration-faq-view': registrationFaqView,
'registration-payment-view': registrationPaymentView,
'registration-draft-keys-view': registrationDraftKeysView,
'topup-view': topupView,
'devnet-topup-view': devnetTopupView,
'login-view': loginView,
'login-camera-view': loginCameraView,
'login-other-device-view': loginOtherDeviceView,
'login-password-view': loginPasswordView,
queue: publicSupportQueueView,
'profile-view': profileView,
'profile-edit-view': profileEditView,
'profiles-view': profilesView,
'wallet-view': walletView,
'settings-view': settingsView,
'access-keys-view': accessKeysView,
'my-blockchain-view': myBlockchainView,
'my-blockchain-history-view': myBlockchainHistoryView,
'key-rotation-view': keyRotationView,
'access-servers-view': accessServersView,
'settings-servers-view': settingsServersView,
'developer-settings-view': developerSettingsView,
'advanced-settings-view': advancedSettingsView,
'server-settings-view': serverSettingsView,
'arweave-uploads-view': arweaveUploadsView,
'remote-addblock-session-view': remoteAddBlockSessionView,
'device-view': deviceView,
'connect-device-view': connectDeviceView,
'device-pairing-view': clientPairingView,
'trusted-device-login-settings-view': trustedDeviceLoginSettingsView,
'device-qr-view': deviceQrView,
'device-camera-view': deviceCameraView,
'show-keys-view': showKeysView,
'device-session-view': clientSessionView,
'language-view': languageView,
'app-log-view': appLogView,
'pwa-diagnostics-view': pwaDiagnosticsView,
'solana-users-init-view': solanaUsersInitView,
'solana-rpc-check-view': solanaRpcCheckView,
'messages-list': messagesList,
'contact-search-view': contactSearchView,
'chat-view': chatView,
'chat-media-view': chatMediaView,
user: userProfileView,
'user-profile-list-view': userProfileListView,
'user-relation-manage-view': userRelationManageView,
'channels-list': channelsList,
'search-view': searchView,
'channel-view': channelView,
'channel-about-view': channelAboutView,
'channel-donate-view': channelDonateView,
'channel-thread-view': channelThreadView,
'add-channel-view': addChannelView,
'add-personal-public-chat-view': addPersonalPublicChatView,
'network-view': networkView,
'notifications-view': notificationsView,
};
const screenEl = document.getElementById('app-screen');
const topbarEl = document.getElementById('topbar-slot');
const composerEl = document.getElementById('composer-slot');
const toolbarEl = document.getElementById('toolbar-slot');
const appShellEl = document.querySelector('.app-shell');
const initialSplashEl = document.getElementById('initial-splash');
const CONNECTION_CHECK_INTERVAL_MS = 20 * 1000;
const SIGNED_DM_DECRYPT_CONTEXT_WAIT_MS = 2000;
const SIGNED_DM_DECRYPT_CONTEXT_POLL_MS = 50;
const UI_VERSION_PERIODIC_CHECK_MS = 5 * 60 * 1000;
const CURRENT_BUILD_HASH = String(window.__SHINE_BUILD_HASH__ || '').trim();
const UI_BUILD_HASH_PATTERN = /window\.__SHINE_BUILD_HASH__\s*=\s*'([^']+)'/;
let currentCleanup = null;
let pingIntervalId = null;
let reconnectIntervalId = null;
let channelsPrefetchTimerId = null;
let channelsPrefetchEpoch = 0;
const CHANNELS_PREFETCH_INTERVAL_MS = 60_000;
// Раз в минуту, пока вкладка на экране, подтягиваем каналы в память, чтобы они открывались сразу.
function startChannelsPrefetch() {
stopChannelsPrefetch();
const epoch = ++channelsPrefetchEpoch;
let running = false;
const tick = async () => {
if (running || document.visibilityState !== 'visible' || !wsIsOpen()) return;
running = true;
try {
await channelsList.refreshChannelsInBackground({ isCurrent: () => epoch === channelsPrefetchEpoch });
} catch {
// Сеть недоступна – попробуем на следующем круге.
} finally {
running = false;
}
};
channelsPrefetchTimerId = window.setInterval(() => void tick(), CHANNELS_PREFETCH_INTERVAL_MS);
window.setTimeout(() => { if (epoch === channelsPrefetchEpoch) void tick(); }, 3_000);
}
function stopChannelsPrefetch() {
channelsPrefetchEpoch += 1;
if (channelsPrefetchTimerId) window.clearInterval(channelsPrefetchTimerId);
channelsPrefetchTimerId = null;
}
let sessionRuntimeStarted = false;
let connectionState = '';
let connectionStatusText = '';
let connectionRetryBannerEl = null;
let connectionStatusCountdownId = null;
let connectionNextRetryAtMs = 0;
let connectionCheckInFlight = false;
let wsSessionRestoreInFlight = null;
let uiUpdateReloadScheduled = false;
let pwaUpdateCheckAttempted = false;
let uiVersionCheckInFlight = false;
let uiVersionPeriodicIntervalId = null;
let hiddenDmAudioContext = null;
let hiddenDmAudioUnlocked = false;
let initialConnectionCompleted = false;
let orientationLockInFlight = false;
let currentChromeCleanup = null;
const CALL_PUSH_PENDING_ACTION_KEY = 'shine-ui-call-push-pending-action-v1';
const SCROLL_TO_BOTTOM_PAGE_IDS = new Set([
'chat-view',
'channel-view',
'channel-thread-view',
]);
function isLocalPreviewHost() {
const host = String(window.location.hostname || '').toLowerCase();
return host === 'localhost' || host === '127.0.0.1' || host === '::1';
}
const FILLED_ACTION_BUTTON_PAGE_IDS = new Set([
...PRE_AUTH_PAGES.filter((pageId) => pageId !== 'entry-settings-view'),
'settings-view',
'profiles-view',
]);
const SETTINGS_BORDERED_ACTION_PAGE_IDS = new Set([
'access-servers-view',
'settings-servers-view',
'server-settings-view',
'arweave-uploads-view',
'developer-settings-view',
'advanced-settings-view',
'trusted-device-login-settings-view',
'device-view',
'device-session-view',
'connect-device-view',
'device-pairing-view',
'device-qr-view',
'device-camera-view',
'show-keys-view',
'remote-addblock-session-view',
'app-log-view',
'pwa-diagnostics-view',
'solana-users-init-view',
'solana-rpc-check-view',
]);
const GUEST_ALLOWED_PAGES = new Set([
'start-view',
'entry-settings-view',
'language-view',
'network-view',
'channels-list',
'search-view',
'channel-view',
'channel-about-view',
'channel-thread-view',
'user',
'contact-search-view',
'queue',
]);
setClientErrorTransport((payload) => authService.reportClientUiError(payload));
setClientErrorSentNotifier((payload) => {
const login = String(state.session.login || 'guest').trim();
const isoTs = new Date(Number(payload?.clientTs || Date.now())).toISOString();
showToast(`Ошибка отправлена на сервер · ${login} · ${isoTs}`);
});
window.__SHINE_SEND_CLIENT_ERROR_TO_SERVER__ = (payload) => authService.reportClientError(payload);
window.__SHINE_SEND_CLIENT_ERROR__ = window.__SHINE_SEND_CLIENT_ERROR_TO_SERVER__;
window.__SHINE_GET_LAST_CLIENT_ERROR__ = () => getLastClientErrorPayload();
window.__SHINE_SHOW_TOAST__ = (message, kind = 'success') => showToast(message, { kind });
initPwaInstallPromptHandling();
initCallUiOverlay();
setCallDebugReporter((payload) => authService.reportClientDebug(payload));
function setShellMetricVar(name, valuePx) {
if (!appShellEl) return;
appShellEl.style.setProperty(name, `${Math.max(0, Math.ceil(Number(valuePx || 0)))}px`);
}
function setKeyboardOffsetPx(valuePx = 0) {
setShellMetricVar('--keyboard-offset', valuePx);
}
let stableViewportHeightPx = Math.max(
1,
Math.round(window.innerHeight || document.documentElement?.clientHeight || window.visualViewport?.height || 0),
);
function isTextEntryFocused() {
const active = document.activeElement;
return active instanceof HTMLTextAreaElement
|| (active instanceof HTMLInputElement && !['button', 'checkbox', 'radio', 'range', 'file', 'submit', 'reset'].includes(active.type));
}
function syncViewportMetrics() {
if (!appShellEl) return;
const viewport = window.visualViewport || null;
const currentLayoutHeightPx = Math.max(
1,
Math.round(window.innerHeight || document.documentElement?.clientHeight || viewport?.height || 0),
);
const widthPx = Math.max(1, Math.round(window.innerWidth || viewport?.width || 0));
const offsetLeftPx = Math.max(0, Math.round(viewport?.offsetLeft || 0));
const textEntryFocused = isTextEntryFocused();
// Android Chrome/Firefox могут уменьшать и visualViewport, и innerHeight.
// Поэтому высоту экрана до открытия клавиатуры запоминаем отдельно и во
// время ввода НЕ переписываем ею app-shell. Иначе toolbar тоже поднимется.
if (!textEntryFocused) {
stableViewportHeightPx = Math.max(stableViewportHeightPx, currentLayoutHeightPx);
// После поворота/реального resize разрешаем уменьшить базу, но только
// когда никакое текстовое поле не держит экранную клавиатуру.
if (Math.abs(stableViewportHeightPx - currentLayoutHeightPx) > 220) {
stableViewportHeightPx = currentLayoutHeightPx;
}
} else if (currentLayoutHeightPx > stableViewportHeightPx) {
stableViewportHeightPx = currentLayoutHeightPx;
}
const visualBottomPx = viewport
? Math.round((viewport.offsetTop || 0) + viewport.height)
: currentLayoutHeightPx;
const rawKeyboardOffsetPx = Math.max(
0,
stableViewportHeightPx - Math.min(currentLayoutHeightPx, visualBottomPx),
);
// Address bar Android обычно даёт небольшую дельту; клавиатура – заметно больше.
const keyboardOffsetPx = textEntryFocused && rawKeyboardOffsetPx >= 100
? rawKeyboardOffsetPx
: 0;
setShellMetricVar('--app-viewport-width', widthPx);
setShellMetricVar('--app-viewport-height', keyboardOffsetPx > 0 ? stableViewportHeightPx : currentLayoutHeightPx);
setShellMetricVar('--app-viewport-offset-top', 0);
setShellMetricVar('--app-viewport-offset-left', offsetLeftPx);
setKeyboardOffsetPx(keyboardOffsetPx);
appShellEl.classList.toggle('keyboard-open', keyboardOffsetPx > 0);
}
function attachSlotHeightObserver(slotEl, cssVarName) {
if (!slotEl || typeof ResizeObserver !== 'function') return null;
const sync = () => {
const visible = !slotEl.hidden && slotEl.childElementCount > 0;
setShellMetricVar(cssVarName, visible ? slotEl.offsetHeight : 0);
};
const observer = new ResizeObserver(sync);
observer.observe(slotEl);
sync();
return { observer, sync };
}
const topbarHeightObserver = attachSlotHeightObserver(topbarEl, '--topbar-height');
const composerHeightObserver = attachSlotHeightObserver(composerEl, '--composer-height');
const toolbarHeightObserver = attachSlotHeightObserver(toolbarEl, '--toolbar-height');
syncViewportMetrics();
window.visualViewport?.addEventListener('resize', syncViewportMetrics);
window.visualViewport?.addEventListener('scroll', syncViewportMetrics);
window.addEventListener('resize', syncViewportMetrics);
document.addEventListener('focusin', () => {
requestAnimationFrame(syncViewportMetrics);
// Samsung One UI / Firefox can finish the OSK viewport transition several
// frames after focus. Re-sample through the animation instead of trusting
// the first resize event.
window.setTimeout(syncViewportMetrics, 80);
window.setTimeout(syncViewportMetrics, 180);
window.setTimeout(syncViewportMetrics, 320);
});
document.addEventListener('focusout', () => {
window.setTimeout(syncViewportMetrics, 80);
window.setTimeout(syncViewportMetrics, 220);
});
// Optional on-device viewport diagnostics: append ?keyboard-debug=1 to the URL.
if (new URLSearchParams(window.location.search).get('keyboard-debug') === '1') {
const debugEl = document.createElement('pre');
debugEl.id = 'keyboard-viewport-debug';
Object.assign(debugEl.style, {
position: 'fixed', top: '4px', right: '4px', zIndex: '999999', margin: '0',
maxWidth: '94vw', padding: '6px 8px', fontSize: '10px', lineHeight: '1.25',
color: '#fff', background: 'rgba(0,0,0,.82)', pointerEvents: 'none',
whiteSpace: 'pre-wrap',
});
document.body.append(debugEl);
const syncDebug = () => {
const vv = window.visualViewport;
debugEl.textContent = [
`innerHeight=${window.innerHeight}`,
`clientHeight=${document.documentElement.clientHeight}`,
`vv.height=${vv ? Math.round(vv.height) : 'n/a'}`,
`vv.offsetTop=${vv ? Math.round(vv.offsetTop) : 'n/a'}`,
`stable=${stableViewportHeightPx}`,
`keyboard=${getComputedStyle(appShellEl).getPropertyValue('--keyboard-offset').trim()}`,
`focused=${isTextEntryFocused()}`,
].join(' | ');
};
window.visualViewport?.addEventListener('resize', syncDebug);
window.visualViewport?.addEventListener('scroll', syncDebug);
window.addEventListener('resize', syncDebug);
document.addEventListener('focusin', () => window.setTimeout(syncDebug, 330));
document.addEventListener('focusout', () => window.setTimeout(syncDebug, 230));
syncDebug();
}
const MANAGED_SHELL_CLASSES = [
'app-shell--wide',
'app-shell--top-fade',
'app-shell--bottom-fade',
'app-shell--bottom-fade-composer',
'app-shell--bottom-fade-toolbar',
'app-shell--fade-edge',
'app-shell--content-under-topbar',
'app-shell--content-under-bottom',
'app-shell--scroll-nested',
'app-shell--scroll-locked',
'app-shell--scrollbar-hidden',
];
const MANAGED_SCREEN_CLASSES = [
'no-app-chrome',
'preauth-flow',
'filled-action-buttons',
'settings-bordered-actions',
];
const DEFAULT_SHELL_MODE = Object.freeze({
topFade: true,
bottomFade: false,
bottomFadeAnchor: 'composer',
fadeProfile: 'standard',
contentUnderTopbar: true,
contentUnderBottom: false,
scrollContainer: 'screen',
scrollbar: 'hidden', // как в мобильных приложениях: прокрутка есть, полосы нет и контент не прыгает
});
function normalizeShellMode(mode = {}, showAppChrome = true) {
const source = mode && typeof mode === 'object' ? mode : {};
const normalized = { ...DEFAULT_SHELL_MODE, ...source };
if (!showAppChrome) {
normalized.topFade = false;
normalized.bottomFade = false;
normalized.contentUnderTopbar = false;
normalized.contentUnderBottom = false;
}
normalized.bottomFadeAnchor = normalized.bottomFadeAnchor === 'toolbar' ? 'toolbar' : 'composer';
normalized.fadeProfile = normalized.fadeProfile === 'edge' ? 'edge' : 'standard';
normalized.scrollContainer = ['screen', 'nested', 'locked'].includes(normalized.scrollContainer)
? normalized.scrollContainer
: 'screen';
normalized.scrollbar = normalized.scrollbar === 'hidden' ? 'hidden' : 'auto';
return normalized;
}
function applyShellMode(mode, showAppChrome = true) {
if (!appShellEl) return normalizeShellMode(mode, showAppChrome);
const normalized = normalizeShellMode(mode, showAppChrome);
appShellEl.classList.toggle('app-shell--wide', normalized.contentWidth === 'wide');
appShellEl.classList.toggle('app-shell--top-fade', Boolean(normalized.topFade));
appShellEl.classList.toggle('app-shell--bottom-fade', Boolean(normalized.bottomFade));
appShellEl.classList.toggle('app-shell--bottom-fade-composer', Boolean(normalized.bottomFade) && normalized.bottomFadeAnchor === 'composer');
appShellEl.classList.toggle('app-shell--bottom-fade-toolbar', Boolean(normalized.bottomFade) && normalized.bottomFadeAnchor === 'toolbar');
appShellEl.classList.toggle('app-shell--fade-edge', normalized.fadeProfile === 'edge');
appShellEl.classList.toggle('app-shell--content-under-topbar', Boolean(normalized.contentUnderTopbar));
appShellEl.classList.toggle('app-shell--content-under-bottom', Boolean(normalized.contentUnderBottom));
appShellEl.classList.toggle('app-shell--scroll-nested', normalized.scrollContainer === 'nested');
appShellEl.classList.toggle('app-shell--scroll-locked', normalized.scrollContainer === 'locked');
appShellEl.classList.toggle('app-shell--scrollbar-hidden', normalized.scrollbar === 'hidden');
return normalized;
}
function resetShellMode() {
appShellEl?.classList.remove(...MANAGED_SHELL_CLASSES);
}
function resetManagedScreenClasses() {
screenEl?.classList.remove(...MANAGED_SCREEN_CLASSES);
}
function clearSlot(slotEl, cssVarName, presenceClass = '') {
if (!slotEl) return;
slotEl.innerHTML = '';
slotEl.hidden = true;
if (presenceClass) appShellEl?.classList.remove(presenceClass);
setShellMetricVar(cssVarName, 0);
}
function mountSlot(slotEl, cssVarName, node, presenceClass = '') {
if (!slotEl) return;
slotEl.innerHTML = '';
if (node instanceof Node) {
slotEl.append(node);
slotEl.hidden = false;
} else {
slotEl.hidden = true;
}
if (presenceClass) appShellEl?.classList.toggle(presenceClass, !slotEl.hidden);
setShellMetricVar(cssVarName, !slotEl.hidden ? slotEl.offsetHeight : 0);
}
function createChromeController(showAppChrome, initialShellMode = {}) {
let topbarNode = null;
let composerNode = null;
const cleanupOwnedNode = (node) => {
if (node && typeof node.cleanup === 'function') node.cleanup();
};
let shellMode = normalizeShellMode(initialShellMode, showAppChrome);
let disposed = false;
const apply = () => {
if (disposed) return;
applyShellMode(shellMode, showAppChrome);
if (!showAppChrome) {
clearSlot(topbarEl, '--topbar-height', 'app-shell--has-topbar');
clearSlot(composerEl, '--composer-height', 'app-shell--has-composer');
return;
}
mountSlot(topbarEl, '--topbar-height', topbarNode, 'app-shell--has-topbar');
mountSlot(composerEl, '--composer-height', composerNode, 'app-shell--has-composer');
topbarHeightObserver?.sync?.();
composerHeightObserver?.sync?.();
};
apply();
return {
setTopbar(node = null) {
const nextTopbar = node instanceof Node ? node : null;
if (topbarNode && topbarNode !== nextTopbar) cleanupOwnedNode(topbarNode);
topbarNode = nextTopbar;
apply();
},
setComposer(node = null) {
const nextComposer = node instanceof Node ? node : null;
if (composerNode && composerNode !== nextComposer) cleanupOwnedNode(composerNode);
composerNode = nextComposer;
apply();
},
setShellMode(nextMode = {}) {
shellMode = normalizeShellMode({ ...shellMode, ...(nextMode || {}) }, showAppChrome);
apply();
},
clear() {
cleanupOwnedNode(topbarNode);
cleanupOwnedNode(composerNode);
topbarNode = null;
composerNode = null;
apply();
},
suspend() {
clearSlot(topbarEl, '--topbar-height', 'app-shell--has-topbar');
clearSlot(composerEl, '--composer-height', 'app-shell--has-composer');
},
resume() {
apply();
},
dispose() {
cleanupOwnedNode(topbarNode);
cleanupOwnedNode(composerNode);
topbarNode = null;
composerNode = null;
disposed = true;
clearSlot(topbarEl, '--topbar-height', 'app-shell--has-topbar');
clearSlot(composerEl, '--composer-height', 'app-shell--has-composer');
resetShellMode();
},
};
}
function clearKeepAliveEntries() {
if (typeof currentCleanup === 'function') {
currentCleanup();
currentCleanup = null;
}
if (typeof currentChromeCleanup === 'function') {
currentChromeCleanup();
currentChromeCleanup = null;
}
}
async function unlockHiddenDmAudio() {
try {
const Ctx = window.AudioContext || window.webkitAudioContext;
if (!Ctx) return false;
if (!hiddenDmAudioContext) {
hiddenDmAudioContext = new Ctx();
}
if (hiddenDmAudioContext.state === 'suspended') {
await hiddenDmAudioContext.resume();
}
hiddenDmAudioUnlocked = hiddenDmAudioContext.state === 'running';
return hiddenDmAudioUnlocked;
} catch {
return false;
}
}
async function playDmSignal({ extended = false } = {}) {
try {
if (!hiddenDmAudioUnlocked || !hiddenDmAudioContext) return false;
if (hiddenDmAudioContext.state === 'suspended') {
await hiddenDmAudioContext.resume();
}
if (hiddenDmAudioContext.state !== 'running') return false;
const now = hiddenDmAudioContext.currentTime;
const gain = hiddenDmAudioContext.createGain();
gain.connect(hiddenDmAudioContext.destination);
gain.gain.setValueAtTime(0.0001, now);
const pulse = (offsetSec, freqHz, durationSec, peakGain) => {
const osc = hiddenDmAudioContext.createOscillator();
osc.type = 'sine';
osc.frequency.setValueAtTime(freqHz, now + offsetSec);
osc.connect(gain);
gain.gain.exponentialRampToValueAtTime(peakGain, now + offsetSec + 0.01);
gain.gain.exponentialRampToValueAtTime(0.0001, now + offsetSec + durationSec);
osc.start(now + offsetSec);
osc.stop(now + offsetSec + durationSec + 0.02);
};
if (extended) {
pulse(0, 880, 0.18, 0.032);
pulse(0.24, 1174, 0.2, 0.026);
pulse(0.52, 1567, 0.24, 0.02);
} else {
pulse(0, 1046, 0.12, 0.028);
pulse(0.17, 1318, 0.14, 0.022);
}
return true;
} catch {
return false;
}
}
async function tryLockPortraitOrientation() {
if (orientationLockInFlight) return false;
const orientationApi = window.screen?.orientation;
if (!orientationApi?.lock) return false;
orientationLockInFlight = true;
try {
await orientationApi.lock('portrait');
return true;
} catch {
return false;
} finally {
orientationLockInFlight = false;
}
}
async function notifyHiddenIncomingMessage(fromLogin, text) {
const body = String(text || '').trim() || `Вам пришло сообщение от ${fromLogin}`;
const title = `Сообщение от ${fromLogin}`;
try {
const registration = await navigator.serviceWorker?.getRegistration?.();
if (registration?.showNotification) {
await registration.showNotification(title, {
body,
tag: `shine-hidden-dm-${String(fromLogin || '').trim().toLowerCase() || 'unknown'}`,
renotify: true,
data: {
kind: 'new_message',
fromLogin,
},
});
} else {
new Notification(title, { body });
}
} catch {
// ignore notification errors
}
try {
if (typeof navigator.vibrate === 'function') {
navigator.vibrate([140, 80, 220, 90, 180]);
}
} catch {
// ignore vibration errors
}
void playDmSignal({ extended: true });
}
function ensureConnectionIndicatorEl() {
return document.getElementById('toolbar-connection-indicator');
}
function ensureConnectionRetryBannerEl() {
if (connectionRetryBannerEl) return connectionRetryBannerEl;
if (!appShellEl) return null;
const el = document.createElement('div');
el.id = 'connection-retry-banner';
el.className = 'connection-retry-banner is-connecting';
el.textContent = 'Соединяюсь…';
el.addEventListener('click', () => {
void triggerImmediateConnectionRetry();
});
appShellEl.append(el);
connectionRetryBannerEl = el;
return el;
}
function stopConnectionCountdown() {
if (connectionStatusCountdownId) {
window.clearInterval(connectionStatusCountdownId);
connectionStatusCountdownId = null;
}
}
function getConnectionRetrySecondsLeft() {
const leftMs = Math.max(0, Number(connectionNextRetryAtMs || 0) - Date.now());
return Math.ceil(leftMs / 1000);
}
function refreshConnectionUi() {
const state = String(connectionState || 'connecting').trim();
const indicatorEl = ensureConnectionIndicatorEl();
if (indicatorEl) {
indicatorEl.classList.remove('is-connected', 'is-disconnected', 'is-connecting', 'is-updating', 'is-unknown');
indicatorEl.classList.add(`is-${state || 'unknown'}`);
}
const bannerEl = ensureConnectionRetryBannerEl();
if (!bannerEl) return;
if (!initialConnectionCompleted) {
bannerEl.hidden = true;
return;
}
if (state === 'connected' || state === 'updating') {
bannerEl.hidden = true;
stopConnectionCountdown();
return;
}
bannerEl.hidden = false;
bannerEl.classList.remove('is-connected', 'is-disconnected', 'is-connecting', 'is-updating');
bannerEl.classList.add(`is-${state}`);
if (connectionStatusText) {
bannerEl.textContent = connectionStatusText;
return;
}
if (state === 'connecting') {
bannerEl.textContent = 'Соединяюсь… Нажмите, чтобы попробовать сразу';
return;
}
if (state === 'disconnected') {
const secs = getConnectionRetrySecondsLeft();
bannerEl.textContent = `Нет соединения. Повтор через ${secs}с. Нажмите для попытки сейчас`;
return;
}
bannerEl.textContent = 'Проблема с соединением. Нажмите для повтора';
}
function finishInitialConnectionSplash() {
if (initialConnectionCompleted) return;
initialConnectionCompleted = true;
if (!initialSplashEl) {
refreshConnectionUi();
return;
}
initialSplashEl.classList.add('is-leaving');
const removeSplash = () => initialSplashEl.remove();
initialSplashEl.addEventListener('transitionend', removeSplash, { once: true });
window.setTimeout(removeSplash, 700);
refreshConnectionUi();
}
function startConnectionCountdown() {
if (connectionStatusCountdownId) return;
connectionStatusCountdownId = window.setInterval(() => {
if (connectionState !== 'disconnected') return;
const secs = getConnectionRetrySecondsLeft();
if (secs <= 0 && !connectionCheckInFlight) {
connectionStatusText = '';
setConnectionStatus('connecting', 'Соединяюсь…');
void checkConnectionHealth();
return;
}
refreshConnectionUi();
}, 1000);
}
function savePendingCallPushAction(action, payload = {}) {
try {
const item = {
action: String(action || '').trim().toLowerCase(),
payload: payload || {},
savedAtMs: Date.now(),
};
localStorage.setItem(CALL_PUSH_PENDING_ACTION_KEY, JSON.stringify(item));
} catch {
// ignore localStorage errors
}
}
function isCallPushTargetForCurrentSession(payload = {}) {
const targetSessionId = String(payload?.targetSessionId || '').trim();
if (!targetSessionId) return true;
const currentSessionId = String(state?.session?.sessionId || '').trim();
return Boolean(currentSessionId) && currentSessionId === targetSessionId;
}
function loadPendingCallPushAction() {
try {
const raw = localStorage.getItem(CALL_PUSH_PENDING_ACTION_KEY);
if (!raw) return null;
const parsed = JSON.parse(raw);
const action = String(parsed?.action || '').trim().toLowerCase();
if (action !== 'accept' && action !== 'decline') return null;
return {
action,
payload: parsed?.payload || {},
};
} catch {
return null;
}
}
function clearPendingCallPushAction() {
try {
localStorage.removeItem(CALL_PUSH_PENDING_ACTION_KEY);
} catch {
// ignore localStorage errors
}
}
function consumeCallPushActionFromUrlIfAny() {
try {
const params = new URLSearchParams(window.location.search || '');
const action = String(params.get('callPushAction') || '').trim().toLowerCase();
const rawPayload = String(params.get('callPushPayload') || '');
if (action !== 'accept' && action !== 'decline') return;
let payload = {};
if (rawPayload) {
try {
payload = JSON.parse(decodeURIComponent(rawPayload));
} catch {
payload = {};
}
}
savePendingCallPushAction(action, payload);
params.delete('callPushAction');
params.delete('callPushPayload');
const nextQuery = params.toString();
const nextUrl = `${window.location.pathname}${nextQuery ? `?${nextQuery}` : ''}`;
window.history.replaceState({}, '', nextUrl);
} catch {
// ignore URL parsing errors
}
}
function pushTargetLogin(payload = {}) {
return String(payload?.toLogin || '').trim();
}
function pushTargetPath(payload = {}) {
const kind = String(payload?.kind || '').trim();
const fromLogin = String(payload?.fromLogin || '').trim();
if (kind === 'new_message' && fromLogin) return `/chat/${encodeURIComponent(fromLogin)}`;
return '/profile';
}
function savedProfileExists(login) {
const normalized = String(login || '').trim().toLowerCase();
if (!normalized) return false;
return getSavedProfiles().some((item) => String(item.login || '').trim().toLowerCase() === normalized);
}
async function ensurePushTargetProfile(payload = {}, { action = '' } = {}) {
const targetLogin = pushTargetLogin(payload);
const currentLogin = String(state.session.login || '').trim();
if (!targetLogin || targetLogin.toLowerCase() === currentLogin.toLowerCase()) return true;
if (!savedProfileExists(targetLogin)) {
showToast(`Уведомление пришло профилю ${targetLogin}, который не сохранён на этом устройстве.`);
return false;
}
const kind = String(payload?.kind || '').trim();
const question = kind === 'incoming_call'
? `Входящий звонок для профиля «${targetLogin}». Переключиться на этот профиль?`
: `Это сообщение пришло профилю «${targetLogin}». Переключиться, чтобы открыть его?`;
if (!window.confirm(question)) return false;
try {
await switchToSavedProfile(targetLogin);
if (action === 'accept' || action === 'decline') {
savePendingCallPushAction(action, payload);
window.location.assign(pushTargetPath(payload));
} else {
window.location.assign(pushTargetPath(payload));
}
return false;
} catch (error) {
showToast(`Не удалось переключить профиль: ${error?.message || 'unknown'}`);
return false;
}
}
async function handleNotificationClick(payload = {}) {
const canOpen = await ensurePushTargetProfile(payload);
if (!canOpen) return;
const path = pushTargetPath(payload);
navigate(path.replace(/^\//, ''));
}
function consumeNotificationOpenFromUrlIfAny() {
try {
const params = new URLSearchParams(window.location.search || '');
const rawPayload = String(params.get('pushOpenPayload') || '');
if (!rawPayload) return null;
let payload = {};
try { payload = JSON.parse(decodeURIComponent(rawPayload)); } catch {}
params.delete('pushOpenPayload');
const nextQuery = params.toString();
window.history.replaceState({}, '', `${window.location.pathname}${nextQuery ? `?${nextQuery}` : ''}`);
return payload;
} catch {
return null;
}
}
async function processPendingCallPushActionIfPossible() {
if (!state.session.isAuthorized) return;
const pending = loadPendingCallPushAction();
if (!pending) return;
if (!isCallPushTargetForCurrentSession(pending.payload || {})) return;
clearPendingCallPushAction();
try {
await handleCallPushAction(pending.action, pending.payload || {});
} catch (error) {
addAppLogEntry({
level: 'warn',
source: 'web-push',
message: 'Не удалось выполнить действие звонка из push',
details: { action: pending.action, error: error?.message || 'unknown' },
});
}
}
function setConnectionStatus(nextState, text = '') {
const state = String(nextState || '').trim();
if (!state) return;
connectionState = state;
connectionStatusText = String(text || '').trim();
if (state === 'connected') {
finishInitialConnectionSplash();
}
if (state === 'disconnected') {
if (!connectionNextRetryAtMs || connectionNextRetryAtMs <= Date.now()) {
connectionNextRetryAtMs = Date.now() + CONNECTION_CHECK_INTERVAL_MS;
}
startConnectionCountdown();
} else {
stopConnectionCountdown();
}
refreshConnectionUi();
}
async function triggerImmediateConnectionRetry() {
if (connectionCheckInFlight) return;
connectionNextRetryAtMs = Date.now() + CONNECTION_CHECK_INTERVAL_MS;
setConnectionStatus('connecting', 'Соединяюсь…');
await checkConnectionHealth();
}
function extractBuildHashFromHtml(htmlText) {
const html = String(htmlText || '');
if (!html) return '';
const match = html.match(UI_BUILD_HASH_PATTERN);
return String(match?.[1] || '').trim();
}
async function fetchCurrentHostUiBuildHash() {
try {
const url = `./index.html?build_probe=${Date.now()}`;
const response = await fetch(url, { cache: 'no-store' });
if (!response?.ok) return '';
const html = await response.text();
return extractBuildHashFromHtml(html);
} catch {
return '';
}
}
async function checkAndReloadIfUiUpdated(remoteHashRaw) {
const remoteHash = String(remoteHashRaw || '').trim();
if (!remoteHash || !CURRENT_BUILD_HASH || remoteHash === CURRENT_BUILD_HASH) return;
if (uiVersionCheckInFlight) return;
uiVersionCheckInFlight = true;
try {
const latestHostHash = await fetchCurrentHostUiBuildHash();
if (!latestHostHash || latestHostHash === CURRENT_BUILD_HASH) {
addAppLogEntry({
level: 'info',
source: 'version-check',
message: `Ping сообщил другую версию UI (${remoteHash}), но текущий хост всё ещё отдаёт ${CURRENT_BUILD_HASH}. Reload пропущен, чтобы избежать цикла.`,
});
return;
}
scheduleUiReload({
source: 'version-check',
message: `Обнаружена новая версия UI: ${CURRENT_BUILD_HASH} -> ${latestHostHash} (ping: ${remoteHash})`,
delayMs: 600,
activateWaitingWorker: true,
});
} finally {
uiVersionCheckInFlight = false;
}
}
async function refreshServiceWorkers({ activateWaitingWorker = false } = {}) {
if (!('serviceWorker' in navigator)) return;
try {
const registrations = await navigator.serviceWorker.getRegistrations();
await Promise.all(registrations.map(async (registration) => {
try {
await registration.update();
} catch {}
if (activateWaitingWorker && registration.waiting) {
try {
registration.waiting.postMessage({ type: 'SKIP_WAITING' });
} catch {}
}
}));
} catch {
// ignore service worker update failures
}
}
function scheduleUiReload({
source = 'ui-update',
message = 'Запрошено обновление интерфейса',
delayMs = 700,
activateWaitingWorker = true,
} = {}) {
if (uiUpdateReloadScheduled) return;
uiUpdateReloadScheduled = true;
addAppLogEntry({
level: 'info',
source,
message,
});
setConnectionStatus('updating');
void refreshServiceWorkers({ activateWaitingWorker });
const ms = Math.min(15_000, Math.max(200, Number(delayMs || 700)));
window.setTimeout(() => {
window.location.reload();
}, ms);
}
async function tryUpdatePwaOnFirstConnectedPing() {
if (pwaUpdateCheckAttempted) return;
pwaUpdateCheckAttempted = true;
await refreshServiceWorkers({ activateWaitingWorker: false });
}
async function runPeriodicUiVersionCheck() {
if (uiUpdateReloadScheduled) return;
if (uiVersionCheckInFlight) return;
try {
const latestHostHash = await fetchCurrentHostUiBuildHash();
if (!latestHostHash || !CURRENT_BUILD_HASH || latestHostHash === CURRENT_BUILD_HASH) return;
scheduleUiReload({
source: 'ui-periodic-version-check',
message: `Найдена новая версия UI: ${CURRENT_BUILD_HASH} -> ${latestHostHash}`,
delayMs: 600,
activateWaitingWorker: true,
});
} catch {
// ignore periodic check errors
}
}
function startPeriodicUiVersionCheck() {
if (uiVersionPeriodicIntervalId) return;
// ВРЕМЕННО: частая проверка обновления UI (каждые 5 минут) для диагностики проблем с обновлением клиента.
// Позже интервал нужно увеличить или вернуть проверку только по ручному действию.
uiVersionPeriodicIntervalId = window.setInterval(() => {
void runPeriodicUiVersionCheck();
}, UI_VERSION_PERIODIC_CHECK_MS);
}
async function checkConnectionHealth() {
if (state.session.isLocalDemo) {
setConnectionStatus('connected');
return;
}
if (connectionCheckInFlight) return;
connectionCheckInFlight = true;
if (connectionState !== 'connected') {
setConnectionStatus('connecting');
}
try {
const wasOpen = wsIsOpen();
if (!wasOpen) {
await authService.ws.open();
const restored = await ensureSessionAfterWsReconnect();
if (!restored) {
connectionStatusText = '';
setConnectionStatus('disconnected');
return;
}
}
const pingResp = await authService.ws.request('Ping', { ts: Date.now() }, 7000);
const remoteUiBuildHash = pingResp?.payload?.uiBuildHash || pingResp?.uiBuildHash || '';
void checkAndReloadIfUiUpdated(remoteUiBuildHash);
await tryUpdatePwaOnFirstConnectedPing();
setConnectionStatus('connected');
} catch {
connectionStatusText = '';
setConnectionStatus('disconnected');
} finally {
connectionCheckInFlight = false;
}
}
function startConnectionMonitor() {
if (state.session.isLocalDemo) {
setConnectionStatus('connected');
return;
}
if (pingIntervalId) {
window.clearInterval(pingIntervalId);
pingIntervalId = null;
}
connectionNextRetryAtMs = Date.now() + CONNECTION_CHECK_INTERVAL_MS;
void checkConnectionHealth();
pingIntervalId = window.setInterval(() => {
connectionNextRetryAtMs = Date.now() + CONNECTION_CHECK_INTERVAL_MS;
if (connectionState === 'disconnected') {
refreshConnectionUi();
}
void checkConnectionHealth();
}, CONNECTION_CHECK_INTERVAL_MS);
}
function isReconnectAllowedNow() {
const pageId = getRoute().pageId || '';
return !PRE_AUTH_PAGES.includes(pageId);
}
function wsIsOpen() {
const ws = authService?.ws?.ws;
return !!(ws && ws.readyState === WebSocket.OPEN);
}
function sleep(ms) {
return new Promise((resolve) => {
window.setTimeout(resolve, ms);
});
}
async function waitForSignedDmDecryptContext(timeoutMs = SIGNED_DM_DECRYPT_CONTEXT_WAIT_MS) {
const startedAtMs = Date.now();
while ((Date.now() - startedAtMs) < timeoutMs) {
const login = String(state.session?.login || '').trim();
const storagePwd = String(state.session?.storagePwdInMemory || '').trim();
if (login && storagePwd) {
return { login, storagePwd };
}
await sleep(SIGNED_DM_DECRYPT_CONTEXT_POLL_MS);
}
return {
login: String(state.session?.login || '').trim(),
storagePwd: String(state.session?.storagePwdInMemory || '').trim(),
};
}
function resolveSignedDmChatId({ parsed, login }) {
const parsedBlock = parsed || {};
const messageType = Number(parsedBlock.messageType || 0);
const fromLogin = String(parsedBlock.fromLogin || '').trim();
const toLogin = String(parsedBlock.toLogin || '').trim();
const currentLogin = String(login || '').trim().toLowerCase();
if (messageType === 1) return normalizeDmChatId(fromLogin);
if (messageType === 2) return normalizeDmChatId(toLogin);
if (currentLogin && currentLogin === fromLogin.toLowerCase()) {
return normalizeDmChatId(toLogin);
}
return normalizeDmChatId(fromLogin);
}
async function ensureSessionAfterWsReconnect() {
if (!state.session.isAuthorized) return true;
if (wsSessionRestoreInFlight) return wsSessionRestoreInFlight;
wsSessionRestoreInFlight = (async () => {
try {
const resumed = await authService.resumeSession(state.session.login, state.session.sessionId);
authorizeSession({
login: resumed.login || state.session.login,
sessionId: resumed.sessionId || state.session.sessionId,
storagePwd: resumed.storagePwd || state.session.storagePwdInMemory,
});
addAppLogEntry({
level: 'info',
source: 'ws-reconnect',
message: 'Сессия восстановлена после переподключения WS',
});
return true;
} catch (error) {
if (isSessionInvalidError(error)) {
await terminateCurrentSession({
infoMessage: 'Ваша сессия устарела. Авторизируйтесь заново.',
});
return false;
}
throw error;
}
})().finally(() => {
wsSessionRestoreInFlight = null;
});
return wsSessionRestoreInFlight;
}
function showGlobalErrorAlert(title, details = {}) {
const lines = [title];
if (details.message) lines.push(`Сообщение: ${details.message}`);
if (details.pageId) lines.push(`Экран: ${details.pageId}`);
if (details.sourceUrl) lines.push(`Источник: ${details.sourceUrl}`);
if (Number.isFinite(details.lineNumber)) lines.push(`Строка: ${details.lineNumber}`);
if (Number.isFinite(details.columnNumber)) lines.push(`Колонка: ${details.columnNumber}`);
if (details.reasonType) lines.push(`Тип: ${details.reasonType}`);
if (details.stack) lines.push(`Stack:\n${details.stack}`);
window.alert(lines.join('\n'));
}
window.addEventListener('error', (event) => {
const pageId = getRoute().pageId || '';
addAppLogEntry({
level: 'error',
source: 'global_error',
message: event.message || 'Global JS error',
details: {
pageId,
sourceUrl: event.filename || '',
line: event.lineno,
column: event.colno,
stack: event.error?.stack || '',
},
});
captureClientError({
kind: 'global_error',
message: event.message || 'Global JS error',
stack: event.error?.stack || '',
sourceUrl: event.filename || '',
lineNumber: event.lineno,
columnNumber: event.colno,
context: {
pageId,
},
});
// Кросс-ориджин ошибки приходят как «Script error.» без файла/строки/стека –
// алертом такие не показываем (в лог и captureClientError выше уже записаны).
const isOpaqueCrossOriginError = String(event.message || '') === 'Script error.'
&& !event.filename && !(event.error?.stack);
if (isOpaqueCrossOriginError) return;
showGlobalErrorAlert('Поймана глобальная ошибка UI', {
message: event.message || 'Global JS error',
stack: event.error?.stack || '',
sourceUrl: event.filename || '',
lineNumber: event.lineno,
columnNumber: event.colno,
pageId,
});
});
window.addEventListener('unhandledrejection', (event) => {
const reason = event.reason;
const pageId = getRoute().pageId || '';
addAppLogEntry({
level: 'error',
source: 'unhandled_rejection',
message: reason?.message || String(reason || 'Unhandled promise rejection'),
details: {
pageId,
reasonType: reason?.constructor?.name || typeof reason,
stack: reason?.stack || '',
},
});
captureClientError({
kind: 'unhandled_rejection',
message: reason?.message || String(reason || 'Unhandled promise rejection'),
stack: reason?.stack || '',
context: {
pageId,
reasonType: reason?.constructor?.name || typeof reason,
},
});
showGlobalErrorAlert('Пойман необработанный Promise reject', {
message: reason?.message || String(reason || 'Unhandled promise rejection'),
stack: reason?.stack || '',
pageId,
reasonType: reason?.constructor?.name || typeof reason,
});
});
function renderPageFailureFallback(pageId, error) {
captureClientError({
kind: 'page_render_failure',
message: error?.message || 'Page render failed',
stack: error?.stack || '',
context: {
pageId,
routeHash: window.location.pathname || '',
},
});
screenEl.innerHTML = '';
const wrap = document.createElement('section');
wrap.className = 'stack';
const card = document.createElement('div');
card.className = 'card stack channels-status';
const title = document.createElement('strong');
title.textContent = 'Не удалось отрисовать экран';
const details = document.createElement('p');
details.className = 'meta-muted';
details.textContent = `Экран: ${pageId || 'неизвестно'}. Попробуйте повторить.`;
const retry = document.createElement('button');
retry.type = 'button';
retry.className = 'primary-btn';
retry.textContent = 'Повторить';
retry.addEventListener('click', () => renderApp());
card.append(title, details, retry);
wrap.append(card);
screenEl.append(wrap);
resetManagedScreenClasses();
screenEl.classList.toggle('no-app-chrome', false);
if (typeof currentChromeCleanup === 'function') {
currentChromeCleanup();
currentChromeCleanup = null;
}
clearSlot(topbarEl, '--topbar-height', 'app-shell--has-topbar');
clearSlot(composerEl, '--composer-height', 'app-shell--has-composer');
clearSlot(toolbarEl, '--toolbar-height');
toolbarHeightObserver?.sync?.();
refreshConnectionUi();
}
function attachPageScrollToBottom(pageId, screen) {
if (!SCROLL_TO_BOTTOM_PAGE_IDS.has(pageId)) return null;
return attachScrollToBottomButton({
scrollContainer: () => screen.querySelector('.dm-chat-wrap') || screenEl,
});
}
async function redirectToActiveKeyRotationIfNeeded() {
if (!state.session.isAuthorized || state.session.isLocalDemo) return false;
try {
const rotation = await new KeyRotationClient(authService).status();
const status = String(rotation?.rotationStatus || 'NONE');
if (status !== 'NONE' && getRoute().pageId !== 'key-rotation-view') {
navigate('key-rotation-view');
return true;
}
} catch (error) {
console.warn('[key-rotation] status check failed', error);
}
return false;
}
function renderApp() {
syncTrackedRouteHistory(window.location.pathname || '/');
const route = getRoute();
if (state.session.isAuthorized) {
const returnPath = window.sessionStorage.getItem('shine-public-return-path');
if (returnPath && returnPath.startsWith('/SHiNE/')) {
window.sessionStorage.removeItem('shine-public-return-path');
navigate(returnPath);
return;
}
}
const pageId = route.pageId || (state.session.isAuthorized ? 'messages-list' : 'start-view');
if (!state.session.isAuthorized && !PRE_AUTH_PAGES.includes(pageId) && !GUEST_ALLOWED_PAGES.has(pageId)) {
navigate('start-view');
return;
}
const addingProfile = state.session.isAuthorized && String(state.authReturnHash || '').trim() === '/profiles';
if (state.session.isAuthorized && PRE_AUTH_PAGES.includes(pageId) && !addingProfile) {
navigate('messages-list');
return;
}
const page = routes[pageId] || routes['start-view'];
const showAppChrome = page.pageMeta?.showAppChrome !== false
&& !(pageId === 'language-view' && !state.session.isAuthorized);
if (typeof currentCleanup === 'function') {
currentCleanup();
currentCleanup = null;
}
if (typeof currentChromeCleanup === 'function') {
currentChromeCleanup();
currentChromeCleanup = null;
}
// Сначала полностью очищаем page-owned UI предыдущего маршрута, затем
// применяем новый shell mode и только после этого монтируем следующий экран.
screenEl.innerHTML = '';
resetManagedScreenClasses();
clearSlot(toolbarEl, '--toolbar-height');
screenEl.classList.toggle('no-app-chrome', !showAppChrome);
screenEl.classList.toggle('preauth-flow', PRE_AUTH_PAGES.includes(pageId));
screenEl.classList.toggle('filled-action-buttons', FILLED_ACTION_BUTTON_PAGE_IDS.has(pageId));
screenEl.classList.toggle('settings-bordered-actions', SETTINGS_BORDERED_ACTION_PAGE_IDS.has(pageId));
try {
const chrome = createChromeController(showAppChrome, page.pageMeta?.shellMode);
currentChromeCleanup = () => chrome.dispose();
// Нижняя панель видна везде, кроме экранов с pageMeta.hideToolbar (например, смена ключей).
if (showAppChrome && !page.pageMeta?.hideToolbar) {
mountSlot(toolbarEl, '--toolbar-height', renderToolbar(page.pageMeta.id, navigate));
toolbarHeightObserver?.sync?.();
}
const screen = page.render({ route, navigate, chrome });
if (!(screen instanceof Node)) {
throw new Error('Page render returned invalid node');
}
screenEl.append(screen);
const pageCleanup = typeof screen.cleanup === 'function' ? screen.cleanup : null;
const scrollToBottomControl = attachPageScrollToBottom(pageId, screen);
currentCleanup = () => {
pageCleanup?.();
scrollToBottomControl?.cleanup();
};
refreshConnectionUi();
} catch (error) {
console.error('[renderApp] controlled fallback', error);
renderPageFailureFallback(pageId, error);
}
}
function refreshToolbarOnly() {
const route = getRoute();
const pageId = route.pageId || (state.session.isAuthorized ? 'messages-list' : 'start-view');
const page = routes[pageId] || routes['start-view'];
const showAppChrome = page.pageMeta?.showAppChrome !== false
&& !(pageId === 'language-view' && !state.session.isAuthorized);
clearSlot(toolbarEl, '--toolbar-height');
if (showAppChrome && !page.pageMeta?.hideToolbar) {
mountSlot(toolbarEl, '--toolbar-height', renderToolbar(page.pageMeta.id, navigate));
}
toolbarHeightObserver?.sync?.();
refreshConnectionUi();
}
function refreshUnreadUi() {
const pageId = getRoute().pageId || '';
if (pageId === 'messages-list') {
renderApp();
return;
}
refreshToolbarOnly();
}
async function tryAutoLogin() {
if (state.session.isLocalDemo) return;
if (!state.session.login || !state.session.sessionId) return;
try {
await authService.reconnect(state.entrySettings.shineServer);
const resumed = await authService.resumeSession(state.session.login, state.session.sessionId);
authorizeSession(resumed);
await refreshSessions();
try {
const contacts = await authService.listContacts();
setContacts(contacts.contacts || []);
} catch {}
} catch (error) {
if (isSessionInvalidError(error)) {
const result = await closeSavedProfile(state.session.login);
if (result?.nextProfile) {
window.location.assign('/profile');
return;
}
await terminateCurrentSession({
infoMessage: 'Сессия на этом устройстве уже завершена. Выполните вход заново.',
});
}
}
}
async function ensureSessionRuntimeStarted() {
if (state.session.isLocalDemo) return;
if (!state.session.isAuthorized || sessionRuntimeStarted) return;
sessionRuntimeStarted = true;
if (!isLocalPreviewHost()) {
await initPwaPush({
authService,
onLog: (entry) => addAppLogEntry(entry),
});
}
startConnectionMonitor();
startChannelsPrefetch();
if (reconnectIntervalId) {
window.clearInterval(reconnectIntervalId);
reconnectIntervalId = null;
}
reconnectIntervalId = window.setInterval(async () => {
if (!state.session.isAuthorized) return;
if (!isReconnectAllowedNow()) return;
if (wsIsOpen()) return;
try {
await authService.ws.open();
const restored = await ensureSessionAfterWsReconnect();
if (!restored) return;
addAppLogEntry({
level: 'info',
source: 'ws-reconnect',
message: 'WS переподключен автоматически',
});
} catch (error) {
addAppLogEntry({
level: 'warn',
source: 'ws-reconnect',
message: 'Попытка автопереподключения не удалась',
details: { error: error?.message || 'unknown' },
});
}
}, 15_000);
await processPendingCallPushActionIfPossible();
}
async function init() {
applyThemeMode();
watchSystemTheme();
consumeCallPushActionFromUrlIfAny();
const initialNotificationOpenPayload = consumeNotificationOpenFromUrlIfAny();
void tryLockPortraitOrientation();
if (state.session.isLocalDemo) {
setConnectionStatus('connected');
}
addAppLogEntry({
level: 'info',
source: 'app',
message: 'Инициализация UI запущена',
});
setSessionResetHandler(() => {
sessionRuntimeStarted = false;
stopChannelsPrefetch();
startConnectionMonitor();
clearKeepAliveEntries();
if (reconnectIntervalId) {
window.clearInterval(reconnectIntervalId);
reconnectIntervalId = null;
}
navigate('start-view');
});
setSessionAuthorizedHandler(() => {
void ensureSessionRuntimeStarted();
void processPendingCallPushActionIfPossible();
void redirectToActiveKeyRotationIfNeeded();
});
if ('serviceWorker' in navigator) {
navigator.serviceWorker.addEventListener('message', (event) => {
const data = event?.data || {};
if (data.type === 'SHINE_CALL_PUSH_ACTION') {
const action = String(data.action || '').trim().toLowerCase();
const payload = data.payload || {};
if (action === 'accept' || action === 'decline') {
void (async () => {
const canHandle = await ensurePushTargetProfile(payload, { action });
if (!canHandle) return;
if (!isCallPushTargetForCurrentSession(payload)) return;
savePendingCallPushAction(action, payload);
await processPendingCallPushActionIfPossible();
})();
}
return;
}
if (data.type === 'SHINE_NOTIFICATION_CLICK') {
void handleNotificationClick(data.payload || {});
return;
}
if (data.type !== 'SHINE_WEB_PUSH_EVENT') return;
const payload = data.payload || {};
if (!isCallPushTargetForCurrentSession(payload)) return;
const kind = String(payload.kind || '').trim();
const now = Date.now();
try {
localStorage.setItem('shine-ui-last-push-at-v1', String(now));
localStorage.setItem('shine-ui-last-push-payload-v1', JSON.stringify(payload || {}));
if (kind === 'test_push') {
localStorage.setItem('shine-ui-last-test-push-status-v1', 'доставлен');
localStorage.setItem('shine-ui-last-test-push-at-v1', String(now));
}
} catch {
// ignore localStorage errors
}
addAppLogEntry({
level: 'info',
source: 'web-push',
message: 'Получено push-событие в service worker',
details: payload,
});
if (kind === 'incoming_call' && !payload.stale && state.session.isAuthorized) {
void handleIncomingCallPush(payload);
} else if (kind === 'stop_call' && state.session.isAuthorized) {
void handleStopCallPush(payload);
}
window.dispatchEvent(new CustomEvent('shine-push-diagnostics-update', { detail: payload }));
});
}
authService.onEvent('SessionRevoked', async () => {
const result = await closeSavedProfile(state.session.login);
window.location.assign(result?.nextProfile ? '/profile' : '/start');
});
authService.onEvent('ForceUiReload', async (evt) => {
const payload = evt?.payload || {};
const reason = String(payload.reason || 'server_debug_api').trim() || 'server_debug_api';
const reloadAfterMs = Number(payload.reloadAfterMs || 700);
scheduleUiReload({
source: 'server-ui-reload',
message: `Сервер запросил обновление UI (${reason})`,
delayMs: reloadAfterMs,
activateWaitingWorker: true,
});
});
authService.onEvent('DmDeliveryStateChanged', (evt) => {
const payload = evt?.payload || {};
const changed = markOutgoingDeliveryState({
outgoingKey: payload.outgoingKey,
baseKey: payload.baseKey,
deliveryState: payload.deliveryState,
});
if (!changed) return;
window.dispatchEvent(new CustomEvent('shine-dm-delivery-updated', { detail: payload }));
});
authService.onEvent('SignedMessageArrived', async (evt) => {
const payload = evt?.payload || {};
const messageKey = String(payload.messageKey || '').trim();
const blobB64 = String(payload.blobB64 || '').trim();
if (!messageKey || !blobB64) return;
let parsed;
try {
parsed = authService.parseSignedMessageBlob(blobB64);
} catch (error) {
addAppLogEntry({
level: 'warn',
source: 'signed-dm',
message: 'Не удалось распарсить входящий signed message',
details: { messageKey, error: error?.message || 'unknown' },
});
return;
}
const fromLogin = parsed.fromLogin || '';
const toLogin = parsed.toLogin || '';
const messageType = Number(parsed.messageType || 0);
let shouldAckSessionDelivery = true;
let text = '';
let sessionLoginForRouting = String(state.session?.login || '').trim();
if (messageType === 1 || messageType === 2) {
const decryptContext = await waitForSignedDmDecryptContext();
if (!decryptContext.login || !decryptContext.storagePwd) {
shouldAckSessionDelivery = false;
addAppLogEntry({
level: 'warn',
source: 'signed-dm',
message: 'Отложена обработка DM: decrypt-контекст сессии ещё не готов',
details: { messageKey, baseKey: parsed.baseKey, messageType },
});
return;
}
sessionLoginForRouting = decryptContext.login;
try {
const decrypted = await authService.decryptSignedMessageContent({
parsed,
login: decryptContext.login,
storagePwd: decryptContext.storagePwd,
});
text = String(decrypted?.text || '');
} catch (error) {
text = dmDecryptFallbackText(error);
addAppLogEntry({
level: 'warn',
source: 'signed-dm',
message: 'Не удалось расшифровать DM',
details: {
messageKey,
baseKey: parsed.baseKey,
error: error?.message || 'unknown',
fallbackText: text,
},
});
}
}
const chatId = resolveSignedDmChatId({
parsed,
login: sessionLoginForRouting,
});
let shouldRefreshToolbarUnread = false;
if (messageType === 1 || messageType === 2) {
const isIncomingForCurrent = messageType === 1;
const added = addSignedMessageToChat({
chatId,
messageKey,
baseKey: parsed.baseKey,
from: isIncomingForCurrent ? 'in' : 'out',
text,
messageType,
unread: isIncomingForCurrent,
rawBlobB64: blobB64,
revisionTimeMs: Number(parsed.revisionTimeMs || 0),
deleted: Boolean(parsed.deleted),
});
if (added) {
addAppLogEntry({
level: 'info',
source: 'signed-dm',
message: isIncomingForCurrent
? `Обновлено входящее сообщение от ${fromLogin}`
: `Синхронизирована исходящая копия в чате ${chatId}`,
details: { messageKey, baseKey: parsed.baseKey, messageType, revisionTimeMs: parsed.revisionTimeMs || 0, deleted: !!parsed.deleted },
});
}
if (added && isIncomingForCurrent) {
shouldRefreshToolbarUnread = true;
}
// Чат «без звука»: сообщение и счётчик непрочитанных приходят как обычно, но без сигнала и уведомления.
if (added && isIncomingForCurrent && !payload.backlog && !isDmChatMuted(chatId)) {
const parsedText = parseDmTechBlocks(text);
const displayText = String(parsedText.displayText || '');
const suppressHiddenNotification = parsedText.callSummary?.status === 'completed';
if (document.visibilityState === 'visible') {
void playDmSignal({ extended: false });
} else if (Notification.permission === 'granted' && !suppressHiddenNotification) {
try {
void notifyHiddenIncomingMessage(fromLogin, displayText || '');
} catch {}
} else if (!suppressHiddenNotification) {
void playDmSignal({ extended: true });
}
}
} else if (messageType === 3 || messageType === 4) {
let refBaseKey = String(payload.receiptRefBaseKey || '').trim();
if (!refBaseKey) {
try {
const ref = parsed.readReceiptPayload || authService.parseReadReceiptPayload(parsed.payloadBytes);
refBaseKey = `${ref.refFromLogin}|${ref.refToLogin}|${ref.refTimeMs}|${ref.refNonce}`;
} catch {}
}
if (refBaseKey) {
if (messageType === 3) {
markOutgoingReadByBaseKey(refBaseKey, Number(parsed.timeMs || 0));
} else {
if (markIncomingReadByBaseKey(refBaseKey)) {
shouldRefreshToolbarUnread = true;
}
}
}
addAppLogEntry({
level: 'info',
source: 'signed-dm',
message: 'Получено подтверждение прочтения',
details: { messageKey, baseKey: parsed.baseKey, messageType },
});
} else if (messageType === 5 || messageType === 6) {
const changed = deleteSignedMessageByBaseKey(chatId, parsed.baseKey);
if (changed) shouldRefreshToolbarUnread = true;
addAppLogEntry({
level: 'info',
source: 'signed-dm',
message: 'Получено удаление сообщения',
details: { messageKey, baseKey: parsed.baseKey, messageType, changed },
});
} else if (messageType === 7 || messageType === 8) {
const removed = deleteConversationMessagesBefore(chatId, Number(parsed.timeMs || 0));
addSignedMessageToChat({
chatId,
messageKey,
baseKey: parsed.baseKey,
from: messageType === 8 ? 'out' : 'in',
text: CONVERSATION_CLEAR_NOTICE_TEXT,
messageType,
unread: false,
rawBlobB64: blobB64,
});
if (removed > 0) shouldRefreshToolbarUnread = true;
addAppLogEntry({
level: 'info',
source: 'signed-dm',
message: 'Получено удаление истории переписки',
details: { messageKey, baseKey: parsed.baseKey, messageType, removed, boundaryTimeMs: Number(parsed.timeMs || 0) },
});
}
if (shouldAckSessionDelivery) {
try {
await authService.ackSessionDelivery(messageKey);
} catch (error) {
addAppLogEntry({
level: 'warn',
source: 'signed-dm',
message: 'Не удалось отправить ACK доставки по сессии',
details: { messageKey, error: error?.message || 'unknown' },
});
}
}
const pageId = getRoute().pageId || '';
if (pageId === 'chat-view') {
window.dispatchEvent(new CustomEvent('shine-chat-messages-updated', {
detail: {
chatId,
messageType,
messageKey,
},
}));
if (shouldRefreshToolbarUnread) {
refreshToolbarOnly();
}
} else if (pageId === 'messages-list' || shouldRefreshToolbarUnread) {
renderApp();
}
});
authService.onEvent('IncomingCallInvite', async (evt) => {
try { await handleIncomingCallInvite(evt); } catch {}
});
window.addEventListener('shine-unread-state-updated', refreshUnreadUi);
authService.onEvent('IncomingCallSignal', async (evt) => {
try { await handleIncomingCallSignal(evt); } catch {}
});
authService.onEvent('IncomingSignal', async (evt) => {
try { await handleIncomingCallSignalViaSendSignal(evt); } catch {}
});
authService.onEvent('DebugConnectPrepareResponder', async (evt) => {
try {
const p = evt?.payload || {};
await startDebugConnectionAsResponder({
runId: p.runId,
callId: p.callId,
peerLogin: p.peerLogin,
peerSessionId: p.peerSessionId,
});
addAppLogEntry({
level: 'info',
source: 'debug-connect',
message: 'Получена команда debug responder',
details: p,
});
} catch (error) {
addAppLogEntry({
level: 'error',
source: 'debug-connect',
message: 'Ошибка запуска debug responder',
details: { error: error?.message || 'unknown' },
});
await authService.reportClientDebug({
runId: evt?.payload?.runId || '',
level: 'error',
message: 'debug_responder_failed',
details: error?.message || 'unknown',
});
}
});
authService.onEvent('DebugConnectStartInitiator', async (evt) => {
try {
const p = evt?.payload || {};
await startDebugConnectionAsInitiator({
runId: p.runId,
callId: p.callId,
peerLogin: p.peerLogin,
peerSessionId: p.peerSessionId,
});
addAppLogEntry({
level: 'info',
source: 'debug-connect',
message: 'Получена команда debug initiator',
details: p,
});
} catch (error) {
addAppLogEntry({
level: 'error',
source: 'debug-connect',
message: 'Ошибка запуска debug initiator',
details: { error: error?.message || 'unknown' },
});
await authService.reportClientDebug({
runId: evt?.payload?.runId || '',
level: 'error',
message: 'debug_initiator_failed',
details: error?.message || 'unknown',
});
}
});
// Важно: сначала всегда отрисовываем UI (чтобы не было "чёрного экрана"),
// а сетевые/авторизационные шаги выполняем фоном.
if (!window.location.pathname || window.location.pathname === '/' || window.location.pathname === '/index.html') {
navigate(state.session.isAuthorized ? 'messages-list' : 'start-view');
}
renderApp();
void (async () => {
try {
let urlEntrySettingsReady = true;
try {
await applyUrlServerLoginOverrideIfNeeded();
} catch (error) {
urlEntrySettingsReady = false;
addAppLogEntry({
level: 'warn',
source: 'entry-settings',
message: 'Не удалось применить сервер из URL',
details: { error: error?.message || 'unknown' },
});
}
if (hasUrlEntrySettingsOverride() && !urlEntrySettingsReady) return;
await tryAutoLogin();
if (initialNotificationOpenPayload) {
await handleNotificationClick(initialNotificationOpenPayload);
}
await hydrateMessagesFromStore();
if (!state.session.isLocalDemo) {
startConnectionMonitor();
startPeriodicUiVersionCheck();
}
await ensureSessionRuntimeStarted();
} finally {
renderApp();
}
})();
window.addEventListener('popstate', (event) => {
if (event.isTrusted && consumeHistoryLayerPop()) return;
renderApp();
});
document.addEventListener('pointerdown', () => {
void unlockHiddenDmAudio();
}, { passive: true });
document.addEventListener('keydown', () => {
void unlockHiddenDmAudio();
}, { passive: true });
document.addEventListener('visibilitychange', () => {
if (document.visibilityState !== 'visible') return;
void tryLockPortraitOrientation();
void checkConnectionHealth();
});
window.addEventListener('orientationchange', () => {
void tryLockPortraitOrientation();
});
}
init();