Files
SHiNE-server/shine-UI/js/pages/network-view.js
T
q 835109c81a Связи: доводка – «По группам», клавиши, значки в чипах
- «По группам»: маленькой группе – не меньше десятой части круга (10 близких больше
  не вытягиваются в одну линию), подписи секторов не уходят за край экрана;
- клавиши на компьютере: «/» – поиск, «+»/«−» – масштаб, «0» – вся карта;
- значок в чипе всегда размером с текст (без этого «Друзья друзей» раздувал весь ряд);
- в «Как читать карту» – «официальный аккаунт», как в профиле.
2026-10-13 03:55:11 +03:00

1392 lines
60 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.
// Экран «Связи»: люди вокруг выбранного человека – картой или списком.
// Данные – GetUserConnectionsGraph (только чтение). Карту рисует graph-canvas.js, здесь –
// состав (центр, раскрытые связи), фильтры, поиск, список, карточка человека и заметки.
import { createSearchTopBar, createTopBar } from '../components/topbar.js';
import { createOverflowDots } from '../components/overflow-dots.js';
import { createDropdownMenu } from '../components/dropdown-menu.js';
import { iconHtml } from '../components/ui-icon.js';
import { openSheet } from '../components/sheet.js';
import { renderUserAvatar } from '../components/avatar-image.js';
import { createErrorState, createSpinner, createStateMessage } from '../components/feedback.js';
import { createListSection, createPersonRow } from '../components/person-row.js';
import { authService, state } from '../state.js';
import { openHistoryLayer } from '../router.js';
import { makeProfileRoute, makeProfileLinksRoute } from '../services/shine-routes.js';
import { userDisplayName } from '../services/user-display.js';
import { showToast } from '../services/channels-ux.js';
import { toUserMessage } from '../services/ui-error-texts.js';
import { PEOPLE_NOTES_EVENT, getAllPersonNotes } from '../services/people-notes.js';
import { createPersonNotePreview, openPersonNoteSheet } from '../components/person-note-sheet.js';
import { createGraphCanvas } from './network/graph-canvas.js';
import { peopleFromGraphModel } from './network/adapter.js';
import {
clearManualLayout, getLayoutMode, getManualLayout, getViewSetting, setLayoutMode, setManualPoint, setViewSetting,
} from './network/layout-store.js';
export const pageMeta = {
id: 'network-view',
title: 'Связи',
shellMode: {
topFade: true,
bottomFade: true,
bottomFadeAnchor: 'toolbar',
fadeProfile: 'edge',
contentUnderTopbar: true,
scrollContainer: 'locked',
},
};
function normalizeLogin(value) {
return String(value || '').trim();
}
function normKey(value) {
return normalizeLogin(value).toLowerCase();
}
function uniqueLogins(list) {
const out = [];
const seen = new Set();
(Array.isArray(list) ? list : []).forEach((item) => {
const login = normalizeLogin(item);
if (!login) return;
const key = normKey(login);
if (seen.has(key)) return;
seen.add(key);
out.push(login);
});
return out;
}
function toSet(list) {
return new Set(uniqueLogins(list).map((value) => normKey(value)));
}
function hasLogin(setObj, login) {
return setObj.has(normKey(login));
}
function getMarkByLogin(allUsers) {
const map = new Map();
(Array.isArray(allUsers) ? allUsers : []).forEach((row) => {
const login = normalizeLogin(row?.login);
if (!login) return;
map.set(normKey(login), {
login,
firstName: String(row?.firstName || '').trim(),
lastName: String(row?.lastName || '').trim(),
displayName: userDisplayName({ login, firstName: row?.firstName, lastName: row?.lastName }),
relationType: String(row?.relationType || '').trim().toLowerCase(),
primaryConfirmed: Boolean(row?.primaryConfirmed),
shineConfirmed: Boolean(row?.shineConfirmed),
// Основной источник — server official. accountRole оставляем как совместимый fallback,
// чтобы badge не пропадал на серверах/ответах переходного периода.
official: row?.official === true
|| String(row?.official || '').trim().toLowerCase() === 'true'
|| String(row?.accountRole || '').trim().toLowerCase() === 'primary',
shine: row?.shine === true
|| String(row?.shine || '').trim().toLowerCase() === 'true'
|| String(row?.shineStatus || '').trim().toLowerCase() === 'shining',
avatar: normalizeAvatar(row),
});
});
return map;
}
function normalizeAvatar(row) {
const txFromAvatar = String(row?.avatar?.ar || '').trim();
const shaFromAvatar = String(row?.avatar?.sha256Hex || row?.avatar?.sha256 || '').trim().toLowerCase();
if (txFromAvatar || shaFromAvatar) return { ar: txFromAvatar, sha256Hex: shaFromAvatar };
const txFallback = String(row?.avatarTxId || '').trim();
if (txFallback) return { ar: txFallback };
return null;
}
function buildGraphModel(graph, centerLogin) {
const login = normalizeLogin(graph?.login || centerLogin || state.session.login);
const outFriends = toSet(graph?.outFriends);
const inFriends = toSet(graph?.inFriends);
const outCloseFriends = toSet(graph?.outCloseFriends);
const inCloseFriends = toSet(graph?.inCloseFriends);
const outContacts = toSet(graph?.outContacts);
const inContacts = toSet(graph?.inContacts);
const outFollows = toSet(graph?.outFollows);
const inFollows = toSet(graph?.inFollows);
const outOfficial = toSet(graph?.outOfficialAccounts);
const inOfficial = toSet(graph?.inOfficialAccounts);
const allMarks = getMarkByLogin(graph?.allUsers);
// Родственные связи сервер хранит, но в интерфейсе они пока скрыты.
const allLogins = uniqueLogins([
...(graph?.outFriends || []),
...(graph?.inFriends || []),
...(graph?.outCloseFriends || []),
...(graph?.inCloseFriends || []),
...(graph?.outContacts || []),
...(graph?.inContacts || []),
...(graph?.outFollows || []),
...(graph?.inFollows || []),
...(graph?.outOfficialAccounts || []),
...(graph?.inOfficialAccounts || []),
]).filter((entry) => normKey(entry) !== normKey(login));
const relations = allLogins.map((targetLogin) => {
const friendOut = hasLogin(outFriends, targetLogin);
const friendIn = hasLogin(inFriends, targetLogin);
const closeFriendOut = hasLogin(outCloseFriends, targetLogin);
const closeFriendIn = hasLogin(inCloseFriends, targetLogin);
const contactOut = hasLogin(outContacts, targetLogin) || hasLogin(outFollows, targetLogin) || hasLogin(outOfficial, targetLogin);
const contactIn = hasLogin(inContacts, targetLogin) || hasLogin(inFollows, targetLogin) || hasLogin(inOfficial, targetLogin);
const role = closeFriendOut || closeFriendIn || friendOut || friendIn ? 'friend' : 'contact';
// Взаимность – по любой связи с той стороны: «друг» в ответ на «контакт» – тоже ответ.
const forward = closeFriendOut || friendOut || contactOut;
const backward = closeFriendIn || friendIn || contactIn;
return {
login: targetLogin,
key: normKey(targetLogin),
role,
isRelative: false,
forward,
backward,
mark: allMarks.get(normKey(targetLogin)) || null,
};
});
return {
centerLogin: login,
centerMark: allMarks.get(normKey(login)) || null,
relations,
};
}
async function mapWithConcurrency(items, concurrency, worker) {
const list = Array.isArray(items) ? items : [];
const out = new Array(list.length);
let cursor = 0;
const runners = new Array(Math.min(Math.max(1, concurrency), list.length)).fill(0).map(async () => {
while (cursor < list.length) {
const index = cursor++;
try { out[index] = await worker(list[index], index); }
catch (error) { out[index] = { error }; }
}
});
await Promise.all(runners);
return out;
}
const NETWORK_GRAPH_CACHE_TTL_MS = 2 * 60 * 1000;
const NETWORK_GRAPH_CACHE_MAX = 240;
const networkGraphCache = new Map();
const networkGraphInflight = new Map();
function cachedGraph(login) {
const cached = networkGraphCache.get(normKey(login));
return cached && Date.now() - cached.savedAt < NETWORK_GRAPH_CACHE_TTL_MS ? cached.graph : null;
}
async function getConnectionsGraphCached(login, { force = false, retries = 0 } = {}) {
const clean = normalizeLogin(login);
const key = normKey(clean);
if (!key) throw new Error('LOGIN_REQUIRED');
const fresh = force ? null : cachedGraph(clean);
if (fresh) return fresh;
if (!force && networkGraphInflight.has(key)) return networkGraphInflight.get(key);
const request = (async () => {
let lastError = null;
for (let attempt = 0; attempt <= Math.max(0, retries); attempt += 1) {
try {
const graph = await authService.getUserConnectionsGraph(clean);
networkGraphCache.delete(key);
networkGraphCache.set(key, { graph, savedAt: Date.now() });
while (networkGraphCache.size > NETWORK_GRAPH_CACHE_MAX) {
const oldestKey = networkGraphCache.keys().next().value;
if (!oldestKey) break;
networkGraphCache.delete(oldestKey);
}
return graph;
} catch (error) {
lastError = error;
if (attempt < retries) await new Promise((resolve) => window.setTimeout(resolve, 120 * (attempt + 1)));
}
}
throw lastError || new Error('GRAPH_LOAD_FAILED');
})();
networkGraphInflight.set(key, request);
try {
return await request;
} finally {
if (networkGraphInflight.get(key) === request) networkGraphInflight.delete(key);
}
}
// Поиск без учёта регистра и «ё».
function searchText(value) {
return String(value || '').toLowerCase().replaceAll('ё', 'е').trim();
}
// --- Состав карты ---------------------------------------------------------------------------
const EXPAND_LIMIT = 40; // сколько новых людей добавляет раскрытие одного человека
const MAX_NODES = 400; // предел карты: дальше раскрытие показывает только уже знакомых
const RELATION_RANK = { close_friend: 0, family: 1, friend: 2, contact: 3 };
const FRIEND_TYPES = new Set(['close_friend', 'friend', 'family']);
const RELATION_LABEL = { close_friend: 'Близкий друг', friend: 'Друг', family: 'Семья', contact: 'Контакт' };
// Связь только с той стороны: другу – «хочет дружить», контакту – «вас добавили».
function directionLabel(node) {
if (node.direction === 'out') return 'без ответа';
if (node.direction === 'in') return FRIEND_TYPES.has(node.relationType) ? 'хочет дружить' : 'вас добавили';
return 'взаимно';
}
// Переживает уход с экрана: возврат по «Связям» из профиля показывает ту же карту.
const persisted = { centerLogin: '', expanded: [], filter: 'all', friendsOfFriends: false };
// Фильтр – один выбранный чип. Тип связи и «добавили вас» – только про прямые связи центра,
// «сияющие» и «с заметкой» – про всех на карте.
const FILTERS = [
{ id: 'all', label: 'Все', pred: null },
{ id: 'close', label: 'Близкие', direct: true, pred: (node) => node.relationType === 'close_friend' || node.relationType === 'family' },
{ id: 'friends', label: 'Друзья', direct: true, pred: (node) => node.relationType === 'friend' },
{ id: 'contacts', label: 'Контакты', direct: true, pred: (node) => node.relationType === 'contact' },
{ id: 'incoming', label: 'Добавили вас', direct: true, selfOnly: true, pred: (node) => node.direction === 'in' },
{ id: 'shining', label: 'Сияющие', pred: (node) => Boolean(node.shining) },
{ id: 'notes', label: 'С заметкой', pred: (node) => Boolean(node.mark || node.hasNote) },
];
const FILTER_BY_ID = new Map(FILTERS.map((filter) => [filter.id, filter]));
function composeMap(centerLogin, graphs, expanded, notes) {
const centerKey = normKey(centerLogin);
const centerModel = graphs.get(centerKey);
if (!centerModel) return null;
const byId = new Map();
const edges = [];
const add = (node) => {
const note = notes.get(node.id);
byId.set(node.id, { ...node, mark: note?.mark || '', hasNote: Boolean(note?.text?.trim()), hiddenCount: 0 });
};
const { center, peers } = peopleFromGraphModel(centerModel);
add({ ...center, relationType: 'self', tier: 1, parentId: '', direction: '' });
for (const peer of peers) {
add({ ...peer.person, relationType: peer.relationType, mutual: peer.mutual, direction: peer.direction, tier: 1, parentId: center.id });
edges.push({ a: center.id, b: peer.person.id, type: peer.relationType, mutual: peer.mutual });
}
for (const key of expanded) {
const owner = byId.get(key);
const model = graphs.get(key);
if (!owner || !model) continue;
const tier = Math.min(3, (owner.id === center.id ? 0 : owner.tier) + 1);
const ordered = [...peopleFromGraphModel(model).peers]
.sort((a, b) => (RELATION_RANK[a.relationType] ?? 9) - (RELATION_RANK[b.relationType] ?? 9));
let added = 0;
for (const peer of ordered) {
const id = peer.person.id;
if (byId.has(id)) {
edges.push({ a: key, b: id, type: peer.relationType, mutual: peer.mutual });
continue;
}
if (added >= EXPAND_LIMIT || byId.size >= MAX_NODES) {
owner.hiddenCount += 1;
continue;
}
add({ ...peer.person, relationType: peer.relationType, mutual: peer.mutual, direction: peer.direction, tier, parentId: key });
edges.push({ a: key, b: id, type: peer.relationType, mutual: peer.mutual });
added += 1;
}
}
byId.forEach((node) => { node.expanded = expanded.has(node.id); });
return { focusId: center.id, nodes: [...byId.values()], edges, byId };
}
// --- Страница -------------------------------------------------------------------------------
export function render({ navigate, route, chrome } = {}) {
const keepHistory = String(route?.params?.mode || '').trim().toLowerCase() === 'keep-history';
const routeLogin = normalizeLogin(route?.params?.login || '');
const selfLogin = normalizeLogin(state.session.login || '');
const selfKey = normKey(selfLogin);
let centerLogin = routeLogin || (keepHistory && persisted.centerLogin) || selfLogin;
const restore = keepHistory && normKey(persisted.centerLogin) === normKey(centerLogin);
const expanded = new Set(restore ? persisted.expanded : []);
let filterId = keepHistory && FILTER_BY_ID.has(persisted.filter) ? persisted.filter : 'all';
let friendsOfFriends = restore && persisted.friendsOfFriends;
let layoutMode = getLayoutMode();
let viewMode = getViewSetting('view', 'map') === 'list' ? 'list' : 'map';
let listSort = getViewSetting('listSort', 'closeness') === 'name' ? 'name' : 'closeness';
let notes = getAllPersonNotes();
const graphs = new Map();
const expanding = new Set();
let map = null;
let selectedId = '';
let disposed = false;
let loadSeq = 0;
let loadError = null;
let noteSheet = null;
let legendSheet = null;
let search = null; // { query, topbar, layer, remote: { seq, query, items, loading, failed } }
let waitingExpanded = false; // «Добавили вас» в списке: сначала несколько, по кнопке – все
const screen = document.createElement('section');
screen.className = 'network-screen';
screen.dataset.view = viewMode;
const stage = document.createElement('div');
stage.className = 'network-stage';
const board = document.createElement('div');
board.className = 'network-board network-board--full net-board';
const list = document.createElement('div');
list.className = 'net-list';
list.hidden = viewMode !== 'list';
const overlay = document.createElement('div');
overlay.className = 'net-overlay';
overlay.hidden = true;
const busyPill = document.createElement('div');
busyPill.className = 'net-busy';
busyPill.hidden = true;
busyPill.append(createSpinner({ size: 'sm', label: 'Загружаю связи' }));
const searchPanel = document.createElement('div');
searchPanel.className = 'net-search-panel';
searchPanel.hidden = true;
const a11yList = document.createElement('ul');
a11yList.className = 'sr-only';
a11yList.setAttribute('aria-label', 'Люди на карте');
function persist() {
persisted.centerLogin = centerLogin;
persisted.expanded = [...expanded];
persisted.filter = filterId;
persisted.friendsOfFriends = friendsOfFriends;
}
const isSelfCenter = () => normKey(centerLogin) === selfKey;
function profileRoute(login) {
const clean = normalizeLogin(login);
if (!clean) return '';
return normKey(clean) === selfKey ? 'profile-view' : makeProfileRoute(clean);
}
function syncLinksUrl(login, { push = false } = {}) {
const clean = normalizeLogin(login);
if (!clean) return;
const nextPath = `/${makeProfileLinksRoute(clean)}`;
if (window.location.pathname === nextPath) return;
if (push) window.history.pushState({}, '', nextPath);
else window.history.replaceState({}, '', nextPath);
}
function activeFilter() {
const filter = FILTER_BY_ID.get(filterId);
if (!filter?.pred || (filter.selfOnly && !isSelfCenter())) return null;
return filter;
}
function filterPredicate() {
const filter = activeFilter();
if (!filter) return null;
return (node) => (filter.direct ? Number(node.tier) <= 1 : true) && filter.pred(node);
}
// Поля, занятые панелями поверх карты: чипы сверху, нижнее меню и карточка снизу.
function toolbarOverlap() {
const toolbar = document.getElementById('toolbar-slot');
if (!toolbar) return 0;
const t = toolbar.getBoundingClientRect();
const s = stage.getBoundingClientRect();
return t.height > 0 ? Math.max(0, s.bottom - t.top) : 0;
}
function insets() {
const s = stage.getBoundingClientRect();
const f = chipsBar.getBoundingClientRect();
const top = f.height ? f.bottom - s.top + 8 : 8;
const bottom = toolbarOverlap() + (card.hidden ? 56 : card.offsetHeight + 12) + 8;
return { top, bottom };
}
function placeOverlays() {
const overlap = toolbarOverlap();
card.style.bottom = `${overlap + 12}px`;
modePill.style.bottom = `${overlap + 14}px`;
zoomBar.style.bottom = `${overlap + 12 + (card.hidden ? 0 : card.offsetHeight + 10)}px`;
list.style.paddingBottom = `${overlap + 76}px`;
const stageTop = stage.getBoundingClientRect().top;
const chipsRect = chipsBar.getBoundingClientRect();
list.style.paddingTop = `${Math.max(0, chipsRect.bottom - stageTop + 4)}px`;
searchPanel.style.top = `${Math.max(0, chipsRect.top - stageTop)}px`;
searchPanel.style.bottom = `${overlap}px`;
}
const engine = createGraphCanvas({
stage: board,
getInsets: insets,
onSelect: (node) => selectNode(node ? node.id : ''),
onNodeMoved: (node, point) => {
setManualPoint(normKey(centerLogin), node.id, point);
},
});
let listFrame = 0;
function renderMap({ fit = false, relayout = false } = {}) {
if (disposed) return;
map = composeMap(centerLogin, graphs, expanded, notes);
if (!map) return;
// Чипы должны быть на месте до вписывания карты: от них зависит свободная часть экрана.
screen.classList.toggle('is-blank', map.nodes.length <= 1);
engine.setGraph(map, { manual: getManualLayout(normKey(centerLogin)), mode: layoutMode, relayout, fit });
engine.setFilter(filterPredicate());
renderA11y();
syncChips();
syncHeader();
syncStateMessage();
if (selectedId && !map.byId.has(selectedId)) selectNode('');
else if (selectedId) renderCard();
if (viewMode === 'list' && !listFrame) {
listFrame = window.requestAnimationFrame(() => { listFrame = 0; renderList(); });
}
if (search) renderSearchResults();
persist();
}
function renderA11y() {
a11yList.replaceChildren();
if (!map) return;
for (const node of map.nodes) {
const li = document.createElement('li');
const button = document.createElement('button');
button.type = 'button';
const relation = node.id === map.focusId ? 'в центре карты' : (RELATION_LABEL[node.relationType] || 'Связь').toLowerCase();
button.textContent = `${node.name}, ${relation}${node.shining ? ', сияющий' : ''}${node.mark || node.hasNote ? ', есть заметка' : ''}`;
button.addEventListener('click', () => selectNode(node.id, { reveal: true }));
li.append(button);
a11yList.append(li);
}
}
// Индикатор подгрузки поверх уже показанной карты (появляется с задержкой, без мелькания).
let busyCount = 0;
function setBusy(on) {
busyCount = Math.max(0, busyCount + (on ? 1 : -1));
busyPill.hidden = busyCount === 0;
}
// Что показать вместо карты: загрузка, ошибка, «пока нет связей» или «никого не нашлось».
function syncStateMessage() {
overlay.replaceChildren();
let content = null;
if (!map) {
if (loadError) {
content = createErrorState({
title: 'Не удалось загрузить связи',
text: toUserMessage(loadError, 'Проверьте соединение и попробуйте ещё раз.'),
onRetry: () => { void load(centerLogin); },
});
} else {
content = document.createElement('div');
content.className = 'loading-state';
content.style.setProperty('--loading-delay', '300ms');
content.append(createSpinner({ label: 'Загружаю связи' }));
}
} else if (map.nodes.length <= 1) {
const self = isSelfCenter();
const center = map.byId.get(map.focusId);
content = createStateMessage({
icon: 'network',
title: self ? 'Пока нет связей' : `У ${center?.name || centerLogin} пока нет связей`,
text: self
? 'Отмечайте друзей и знакомых в их профилях – они появятся здесь, на карте и в списке.'
: 'Когда этот человек отметит друзей или знакомых, они появятся здесь.',
actionLabel: self ? 'Найти людей' : 'К моим связям',
onAction: self ? () => openSearch() : () => recenter(selfLogin),
});
} else if (viewMode === 'map' && activeFilter() && engine.visibleCount() === 0) {
content = createStateMessage({
icon: 'search',
title: 'Никого не нашлось',
text: 'Под этот фильтр сейчас никто не подходит.',
actionLabel: 'Показать всех',
onAction: () => setFilter('all'),
});
}
overlay.hidden = !content;
if (content) overlay.append(content);
// Пока показывать нечего, фильтры, масштаб и «Списком» не нужны; в пустой карте
// сообщение стоит под точкой человека в центре.
const blank = !map || map.nodes.length <= 1;
screen.classList.toggle('is-blank', blank);
overlay.classList.toggle('net-overlay--below-center', Boolean(map) && map.nodes.length <= 1);
}
async function load(login, { push = false } = {}) {
const clean = normalizeLogin(login);
if (!clean) return;
const seq = ++loadSeq;
const known = Boolean(graphs.has(normKey(clean)) || cachedGraph(clean));
const busy = Boolean(map) && !known;
if (busy) setBusy(true);
if (!map) { loadError = null; syncStateMessage(); }
try {
const graph = await getConnectionsGraphCached(clean);
if (disposed || seq !== loadSeq) return;
graphs.set(normKey(clean), buildGraphModel(graph, clean));
if (normKey(clean) !== normKey(centerLogin)) {
expanded.clear();
friendsOfFriends = false;
if (FILTER_BY_ID.get(filterId)?.selfOnly && normKey(clean) !== selfKey) filterId = 'all';
selectNode('');
}
centerLogin = normalizeLogin(graph?.login || clean);
loadError = null;
syncLinksUrl(centerLogin, { push });
renderMap({ fit: true });
if (friendsOfFriends) void expandFriends();
} catch (error) {
if (disposed || seq !== loadSeq) return;
if (map) showToast(`Не удалось загрузить связи. ${toUserMessage(error, 'Попробуйте ещё раз.')}`, { kind: 'error', timeoutMs: 3200 });
else {
loadError = error;
syncStateMessage();
}
} finally {
if (busy && !disposed) setBusy(false);
}
}
async function fetchGraphs(logins) {
const missing = logins.filter((login) => !graphs.has(normKey(login)));
const results = await mapWithConcurrency(missing, 4, async (login) => {
const graph = await getConnectionsGraphCached(login, { retries: 1 });
return { login, graph };
});
let failed = 0;
results.forEach((row) => {
if (!row || row.error) { failed += 1; return; }
graphs.set(normKey(row.login), buildGraphModel(row.graph, row.login));
});
return failed;
}
async function expandNode(id) {
const node = map?.byId.get(id);
if (!node || expanding.has(id)) return;
const centerAtStart = normKey(centerLogin);
expanding.add(id);
renderCard();
const failed = await fetchGraphs([node.login]);
expanding.delete(id);
if (disposed || normKey(centerLogin) !== centerAtStart) return;
if (failed) {
renderCard();
showToast('Не удалось загрузить связи этого человека. Попробуйте ещё раз.', { kind: 'error', timeoutMs: 2600 });
return;
}
expanded.add(id);
renderMap({ fit: true });
}
// Свернуть: убираем и тех, кто держался на карте только через свёрнутого.
function collapseNode(id) {
expanded.delete(id);
for (;;) {
const next = composeMap(centerLogin, graphs, expanded, notes);
const orphan = [...expanded].find((key) => !next?.byId.has(key));
if (!orphan) break;
expanded.delete(orphan);
}
renderMap({ fit: true });
}
async function expandFriends() {
const centerAtStart = normKey(centerLogin);
const friends = (map?.nodes || []).filter((node) => node.tier === 1 && node.id !== map.focusId && FRIEND_TYPES.has(node.relationType));
if (!friends.length) {
friendsOfFriends = false;
syncChips();
showToast(isSelfCenter() ? 'Пока нет друзей – раскрывать нечего' : 'У этого человека пока нет друзей на карте', { kind: 'info', timeoutMs: 2200 });
return;
}
setBusy(true);
const failed = await fetchGraphs(friends.map((node) => node.login));
setBusy(false);
if (disposed || normKey(centerLogin) !== centerAtStart || !friendsOfFriends) return;
friends.forEach((node) => { if (graphs.has(node.id)) expanded.add(node.id); });
// Полная перестройка: теперь известно, кто с кем знаком, – знакомые встанут рядом.
renderMap({ fit: true, relayout: true });
if (failed) showToast(`Не удалось загрузить связи ${failed} из ${friends.length} друзей`, { kind: 'error', timeoutMs: 2600 });
}
function toggleFriendsOfFriends() {
friendsOfFriends = !friendsOfFriends;
syncChips();
if (friendsOfFriends) {
void expandFriends();
} else {
expanded.clear();
renderMap({ fit: true, relayout: true });
}
persist();
}
function recenter(login) {
selectNode('');
if (search) closeSearch();
void load(login, { push: true });
}
// --- карточка выбранного человека ---
const card = document.createElement('div');
card.className = 'net-card';
card.hidden = true;
card.setAttribute('role', 'region');
card.addEventListener('pointerdown', (event) => event.stopPropagation());
function selectNode(id, { reveal = false } = {}) {
selectedId = id && map?.byId.has(id) ? id : '';
engine.select(selectedId, { reveal });
renderCard();
// Выбранный не должен прятаться под карточкой.
if (selectedId && !reveal) engine.ensureVisible(selectedId);
}
function cardAction(icon, label, onClick, { disabled = false, pressed = null, busy = false } = {}) {
const button = document.createElement('button');
button.type = 'button';
button.className = 'ui-button net-card__action';
if (busy) button.append(createSpinner({ size: 'sm', label }));
else button.innerHTML = iconHtml(icon);
const text = document.createElement('span');
text.textContent = label;
button.append(text);
button.disabled = disabled;
if (pressed !== null) button.setAttribute('aria-pressed', pressed ? 'true' : 'false');
button.addEventListener('click', onClick);
return button;
}
function relationText(node) {
if (node.tier > 1) {
const via = map.byId.get(node.parentId);
return via ? `${(RELATION_LABEL[node.relationType] || 'связь').toLowerCase()} у ${via.name}` : 'друг друга';
}
return `${RELATION_LABEL[node.relationType] || 'Связь'} · ${directionLabel(node)}`;
}
function renderCard() {
const node = selectedId ? map?.byId.get(selectedId) : null;
card.replaceChildren();
card.hidden = !node || viewMode !== 'map';
modePill.hidden = !card.hidden;
if (node && viewMode === 'map') {
const isCenter = node.id === map.focusId;
const isSelf = node.id === selfKey;
card.setAttribute('aria-label', node.name);
const head = document.createElement('div');
head.className = 'net-card__head';
const avatarWrap = document.createElement('span');
avatarWrap.className = `net-card__avatar${node.shining ? ' is-shining' : ''}`;
avatarWrap.append(renderUserAvatar({
login: node.login, firstName: node.firstName, lastName: node.lastName, avatar: node.avatar, size: 'md', official: node.official,
}));
const titles = document.createElement('div');
titles.className = 'net-card__titles';
const name = document.createElement('div');
name.className = 'net-card__name';
name.textContent = node.name;
const meta = document.createElement('div');
meta.className = 'net-card__meta';
const parts = [];
if (normKey(node.name) !== node.id) parts.push(`@${node.login}`);
if (isCenter) parts.push(isSelf ? 'это вы' : 'в центре карты');
else parts.push(relationText(node));
if (node.shining) parts.push('сияющий');
meta.textContent = parts.join(' · ');
titles.append(name, meta);
const close = document.createElement('button');
close.type = 'button';
close.className = 'icon-btn net-card__close';
close.setAttribute('aria-label', 'Закрыть карточку');
close.innerHTML = iconHtml('close');
close.addEventListener('click', () => selectNode(''));
head.append(avatarWrap, titles, close);
card.append(head);
const note = isSelf ? null : notes.get(node.id);
const notePreview = createPersonNotePreview(note, { className: 'net-card__note', onClick: () => openNoteEditor(node) });
if (notePreview) card.append(notePreview);
const actions = document.createElement('div');
actions.className = 'net-card__actions';
if (!isCenter) {
const busy = expanding.has(node.id);
actions.append(cardAction('network', node.expanded ? 'Скрыть' : 'Связи', () => {
if (node.expanded) collapseNode(node.id);
else void expandNode(node.id);
}, { disabled: busy, pressed: node.expanded, busy }));
actions.append(cardAction('focus', 'В центр', () => recenter(node.login)));
}
actions.append(cardAction('profile', 'Профиль', () => {
const target = profileRoute(node.login);
if (target) navigate(target);
}));
if (!isSelf) {
actions.append(cardAction('message', 'Написать', () => navigate(`chat/${encodeURIComponent(node.login)}`)));
actions.append(cardAction('edit', 'Заметка', () => openNoteEditor(node)));
}
card.append(actions);
if (!isCenter && node.tier === 1 && node.direction === 'in' && isSelfCenter()) {
const answer = document.createElement('button');
answer.type = 'button';
answer.className = 'primary-btn net-card__answer';
answer.textContent = FRIEND_TYPES.has(node.relationType) ? 'Дружить в ответ' : 'Добавить в ответ';
answer.addEventListener('click', () => navigate(`${makeProfileRoute(node.login)}/manage`));
card.append(answer);
}
if (node.hiddenCount > 0) {
const more = document.createElement('p');
more.className = 'net-card__hint';
more.textContent = `Ещё ${node.hiddenCount} – все видны на его карте («В центр»).`;
card.append(more);
}
}
placeOverlays();
}
// --- заметка ---
function openNoteEditor(node) {
noteSheet?.close();
noteSheet = openPersonNoteSheet({ login: node.id, name: node.name, onClose: () => { noteSheet = null; } });
}
function onNotesChanged() {
notes = getAllPersonNotes();
renderMap();
}
window.addEventListener(PEOPLE_NOTES_EVENT, onNotesChanged);
// --- обозначения ---
function openLegend() {
legendSheet?.close();
legendSheet = openSheet({
title: 'Как читать карту',
className: 'net-legend-sheet',
onClose: () => { legendSheet = null; },
content: () => {
const legend = document.createElement('ul');
legend.className = 'net-legend';
const rows = [
['line', 'close_friend', 'Близкий друг'],
['line', 'friend', 'Друг'],
['line', 'contact', 'Контакт'],
['dash', 'friend', 'Пунктир – связь только с одной стороны'],
['aura', '', 'Свечение вокруг – сияющий'],
['badge', '', 'Синяя галочка – официальный аккаунт'],
['mark', '', 'Цветная точка – ваша заметка или метка'],
];
for (const [kind, type, text] of rows) {
const li = document.createElement('li');
li.className = 'net-legend__row';
const sample = document.createElement('span');
sample.className = `net-legend__sample net-legend__sample--${kind}`;
if (type) sample.dataset.type = type;
sample.setAttribute('aria-hidden', 'true');
const label = document.createElement('span');
label.textContent = text;
li.append(sample, label);
legend.append(li);
}
const tips = document.createElement('ul');
tips.className = 'net-legend__tips';
for (const tip of [
'«По близости»: ближе к центру – близкие, дальше – друзья, снаружи – контакты. Знакомые между собой стоят рядом.',
'«Друзья друзей» встают на внешнее кольцо, рядом с теми, через кого вы знакомы.',
'Нажмите на человека – откроется карточка. Двойное нажатие по пустому месту – вся карта.',
'Человека можно переставить: задержите на нём палец (мышью – просто тащите). Раскладка запомнится на этом устройстве.',
]) {
const li = document.createElement('li');
li.textContent = tip;
tips.append(li);
}
const box = document.createElement('div');
box.className = 'stack';
box.append(legend, tips);
return box;
},
});
}
// --- шапка ---
function menuItems() {
const items = [];
if (!isSelfCenter()) {
items.push({ label: 'Мои связи', iconHtml: iconHtml('focus'), action: () => recenter(selfLogin) }, { divider: true });
}
if (viewMode === 'list') {
items.push(
{ label: 'По близости', selected: listSort === 'closeness', iconHtml: iconHtml(listSort === 'closeness' ? 'check' : 'network'), action: () => changeListSort('closeness') },
{ label: 'По имени', selected: listSort === 'name', iconHtml: iconHtml(listSort === 'name' ? 'check' : 'list'), action: () => changeListSort('name') },
);
return items;
}
const hasManual = getManualLayout(normKey(centerLogin)).size > 0;
items.push(
{ label: 'По близости', selected: layoutMode === 'rings', iconHtml: iconHtml(layoutMode === 'rings' ? 'check' : 'network'), action: () => changeLayoutMode('rings') },
{ label: 'По группам', selected: layoutMode === 'groups', iconHtml: iconHtml(layoutMode === 'groups' ? 'check' : 'list'), action: () => changeLayoutMode('groups') },
{ divider: true },
{ label: 'Показать всю карту', iconHtml: iconHtml('fit'), action: () => engine.fit() },
{
label: 'Вернуть раскладку',
iconHtml: iconHtml('refresh'),
disabled: !hasManual,
action: () => {
clearManualLayout(normKey(centerLogin));
renderMap({ relayout: true, fit: true });
},
},
{ divider: true },
{ label: 'Как читать карту', iconHtml: iconHtml('info'), action: openLegend },
);
return items;
}
const headerActions = () => [
{
icon: 'search',
title: 'Найти человека',
ariaLabel: 'Найти человека',
className: 'network-search-btn',
onClick: () => openSearch(),
},
{
iconNode: createOverflowDots(),
title: viewMode === 'list' ? 'Порядок списка' : 'Настройки карты',
ariaLabel: viewMode === 'list' ? 'Порядок списка' : 'Настройки карты',
className: 'topbar-overflow-action--raised',
menu: { minWidth: 240, items: menuItems },
},
];
let headerKey = '';
function syncHeader({ force = false } = {}) {
if (search || disposed) return;
const center = map?.byId.get(map.focusId);
const self = isSelfCenter();
const count = map ? map.nodes.filter((node) => node.tier === 1 && node.id !== map.focusId).length : -1;
const key = `${self ? 'self' : normKey(centerLogin)}|${center?.name || ''}|${viewMode}|${count}`;
if (!force && key === headerKey) return;
headerKey = key;
if (self) {
chrome?.setTopbar(createTopBar({ title: 'Связи', className: 'topbar--root', actions: headerActions() }));
return;
}
// Чужая карта: кто в центре и сколько у него связей; стрелка – к своей карте.
const identity = document.createElement('button');
identity.type = 'button';
identity.className = 'topbar-identity';
identity.title = 'Открыть профиль';
identity.append(renderUserAvatar({
login: centerLogin, firstName: center?.firstName, lastName: center?.lastName, avatar: center?.avatar, size: 'sm',
}));
const text = document.createElement('span');
text.className = 'topbar-identity__text';
const title = document.createElement('span');
title.className = 'topbar-identity__title';
title.textContent = center?.name || centerLogin;
const sub = document.createElement('span');
sub.className = 'topbar-identity__sub';
sub.textContent = count >= 0 ? `Связи · ${count}` : 'Связи';
text.append(title, sub);
identity.append(text);
identity.addEventListener('click', () => navigate(profileRoute(centerLogin)));
chrome?.setTopbar(createTopBar({
className: 'topbar--identity',
back: { onClick: () => recenter(selfLogin), ariaLabel: 'К моим связям', title: 'К моим связям' },
center: identity,
actions: headerActions(),
}));
}
function changeLayoutMode(mode) {
if (mode === layoutMode) return;
layoutMode = mode;
setLayoutMode(mode);
renderMap({ relayout: true, fit: true });
}
function changeListSort(sort) {
if (sort === listSort) return;
listSort = sort;
setViewSetting('listSort', sort);
renderList();
list.scrollTop = 0;
}
// --- фильтры: один выбранный чип, у каждого – сколько людей ---
const chipsBar = document.createElement('div');
chipsBar.className = 'net-chips';
chipsBar.addEventListener('pointerdown', (event) => event.stopPropagation());
const chipRow = document.createElement('div');
chipRow.className = 'chip-row chip-row--bleed net-chips__row';
chipRow.setAttribute('role', 'radiogroup');
chipRow.setAttribute('aria-label', 'Кого показывать');
chipsBar.append(chipRow);
const chips = new Map();
for (const filter of FILTERS) {
const chip = document.createElement('button');
chip.type = 'button';
chip.className = 'chip';
chip.setAttribute('role', 'radio');
const label = document.createElement('span');
label.textContent = filter.label;
const count = document.createElement('span');
count.className = 'chip__count';
chip.append(label, count);
chip.addEventListener('click', () => setFilter(filter.id));
chips.set(filter.id, { chip, count });
chipRow.append(chip);
}
const fofChip = document.createElement('button');
fofChip.type = 'button';
fofChip.className = 'chip chip--toggle net-chips__fof';
fofChip.innerHTML = `${iconHtml('network')}<span>Друзья друзей</span>`;
fofChip.addEventListener('click', toggleFriendsOfFriends);
chipRow.append(fofChip);
function setFilter(id) {
filterId = FILTER_BY_ID.has(id) ? id : 'all';
engine.setFilter(filterPredicate());
engine.fit();
const selected = selectedId ? map?.byId.get(selectedId) : null;
if (selected && selectedId !== map.focusId && filterPredicate() && !filterPredicate()(selected)) selectNode('');
syncChips();
syncStateMessage();
if (viewMode === 'list') {
renderList();
list.scrollTop = 0;
}
persist();
}
function syncChips() {
const direct = (map?.nodes || []).filter((node) => node.tier === 1 && node.id !== map.focusId);
const everyone = (map?.nodes || []).filter((node) => node.id !== map?.focusId);
for (const filter of FILTERS) {
const { chip, count } = chips.get(filter.id);
const pool = filter.direct ? direct : everyone;
const n = filter.pred ? pool.filter(filter.pred).length : direct.length;
const selected = filter.id === filterId;
// Пустые фильтры не показываем (кроме выбранного), «добавили вас» – только на своей карте.
chip.hidden = (filter.selfOnly && !isSelfCenter()) || (!selected && filter.id !== 'all' && n === 0);
count.textContent = map ? String(n) : '';
chip.setAttribute('aria-checked', selected ? 'true' : 'false');
chip.classList.toggle('is-active', selected);
}
fofChip.setAttribute('aria-pressed', friendsOfFriends ? 'true' : 'false');
fofChip.classList.toggle('is-active', friendsOfFriends);
}
// --- масштаб ---
const zoomBar = document.createElement('div');
zoomBar.className = 'net-zoom';
zoomBar.addEventListener('pointerdown', (event) => event.stopPropagation());
for (const [icon, label, onClick] of [
['plus', 'Приблизить', () => engine.zoomBy(1.35)],
['minus', 'Отдалить', () => engine.zoomBy(1 / 1.35)],
['fit', 'Показать всю карту', () => engine.fit()],
]) {
const button = document.createElement('button');
button.type = 'button';
button.className = 'icon-btn net-zoom__btn';
button.innerHTML = iconHtml(icon);
button.setAttribute('aria-label', label);
button.title = label;
button.addEventListener('click', onClick);
zoomBar.append(button);
}
// --- карта / список ---
const modePill = document.createElement('button');
modePill.type = 'button';
modePill.className = 'net-mode-pill';
modePill.addEventListener('pointerdown', (event) => event.stopPropagation());
modePill.addEventListener('click', () => setViewMode(viewMode === 'map' ? 'list' : 'map'));
function syncModePill() {
const toList = viewMode === 'map';
modePill.innerHTML = `${iconHtml(toList ? 'list' : 'network')}<span>${toList ? 'Списком' : 'На карте'}</span>`;
modePill.setAttribute('aria-label', toList ? 'Показать списком' : 'Показать на карте');
}
function setViewMode(mode) {
viewMode = mode === 'list' ? 'list' : 'map';
setViewSetting('view', viewMode);
screen.dataset.view = viewMode;
list.hidden = viewMode !== 'list';
board.hidden = viewMode !== 'map';
zoomBar.hidden = viewMode !== 'map';
if (viewMode === 'list') {
renderList();
list.scrollTop = 0;
}
syncModePill();
renderCard();
syncStateMessage();
syncHeader({ force: true });
if (search) renderSearchResults();
}
// --- список ---
const rowMenuAnchor = document.createElement('span');
rowMenuAnchor.className = 'net-row-menu-anchor';
rowMenuAnchor.setAttribute('aria-hidden', 'true');
let rowMenuNode = null;
const rowMenu = createDropdownMenu({
anchorEl: rowMenuAnchor,
minWidth: 220,
transparent: true,
items: () => {
const node = rowMenuNode;
if (!node) return [];
return [
{ label: 'Профиль', iconHtml: iconHtml('profile'), action: () => navigate(profileRoute(node.login)) },
{ label: 'Заметка', iconHtml: iconHtml('edit'), action: () => openNoteEditor(node) },
{ label: 'Показать на карте', iconHtml: iconHtml('network'), action: () => showOnMap(node.id) },
{ label: 'Его связи', iconHtml: iconHtml('focus'), action: () => recenter(node.login) },
];
},
});
function openRowMenu(node, button) {
rowMenuNode = node;
const rect = button.getBoundingClientRect();
const host = stage.getBoundingClientRect();
rowMenuAnchor.style.top = `${rect.bottom - host.top - 6}px`;
rowMenuAnchor.style.left = `${rect.right - host.left - 8}px`;
rowMenu.open();
}
function showOnMap(id) {
if (search) closeSearch();
setViewMode('map');
// Карта только что стала видимой – камера двигается после того, как узнает размер.
window.requestAnimationFrame(() => {
if (disposed) return;
engine.reveal(id);
selectNode(id);
});
}
// Вторая строка – только то, чего не видно из раздела: тип связи нужен, когда список
// не разбит по типам, «взаимно» – обычный случай и не пишется.
function personRow(node, { onOpen = null, withType = false } = {}) {
const note = notes.get(node.id);
const sub = [];
if (normKey(node.name) !== node.id) sub.push(`@${node.login}`);
if (node.tier > 1) {
const via = map.byId.get(node.parentId);
if (via) sub.push(`через ${via.name}`);
} else {
if (withType) sub.push((RELATION_LABEL[node.relationType] || 'связь').toLowerCase());
if (node.direction === 'out') sub.push('без ответа');
}
if (node.shining) sub.push('сияющий');
return createPersonRow({
login: node.login,
name: node.name,
firstName: node.firstName,
lastName: node.lastName,
avatar: node.avatar,
official: node.official,
sub: sub.join(' · '),
note: note?.text?.trim() ? note.text.trim().split('\n')[0] : '',
markColor: note?.mark || (note?.text?.trim() ? 'note' : ''),
ring: node.shining ? 'shining' : (node.relationType === 'close_friend' && node.tier === 1 ? 'close' : ''),
tag: node.tier === 1 && node.direction === 'in' && isSelfCenter() ? directionLabel(node) : '',
onClick: onOpen || (() => {
if (search) closeSearch();
navigate(profileRoute(node.login));
}),
actions: [
{ icon: 'message', label: 'Написать', onClick: () => navigate(`chat/${encodeURIComponent(node.login)}`) },
{ icon: 'more', label: 'Ещё', onClick: (event, button) => openRowMenu(node, button) },
],
});
}
function matchesQuery(node, query) {
if (!query) return true;
return searchText(`${node.name} ${node.login} ${node.firstName || ''} ${node.lastName || ''}`).includes(query);
}
function listGroups(people) {
const byName = (a, b) => a.name.localeCompare(b.name, 'ru');
if (listSort === 'name') {
const groups = new Map();
[...people].sort(byName).forEach((node) => {
const first = node.name.trim()[0]?.toUpperCase() || '#';
const letter = /\p{L}/u.test(first) ? first.replace('Ё', 'Е') : '#';
if (!groups.has(letter)) groups.set(letter, []);
groups.get(letter).push(node);
});
return [...groups.entries()].map(([title, items]) => ({ title, items, letter: true }));
}
const direct = people.filter((node) => node.tier === 1);
const waiting = isSelfCenter() ? direct.filter((node) => node.direction === 'in') : [];
const rest = direct.filter((node) => !waiting.includes(node));
return [
{ title: 'Добавили вас', items: waiting.sort(byName), waiting: true },
{ title: 'Близкие', items: rest.filter((node) => node.relationType === 'close_friend' || node.relationType === 'family').sort(byName) },
{ title: 'Друзья', items: rest.filter((node) => node.relationType === 'friend').sort(byName) },
{ title: 'Контакты', items: rest.filter((node) => node.relationType === 'contact').sort(byName) },
{ title: 'Друзья друзей', items: people.filter((node) => node.tier > 1).sort(byName) },
].filter((group) => group.items.length);
}
function renderList() {
if (disposed || viewMode !== 'list') return;
const scrollTop = list.scrollTop;
list.replaceChildren();
if (!map) return;
const pred = filterPredicate();
const query = searchText(search?.query || '');
const people = map.nodes.filter((node) => node.id !== map.focusId && (!pred || pred(node)) && matchesQuery(node, query));
const frag = document.createDocumentFragment();
const withType = listSort === 'name' || Boolean(query);
for (const group of listGroups(people)) {
frag.append(createListSection(group.letter ? group.title : `${group.title} · ${group.items.length}`));
// Длинный «Добавили вас» не должен закрывать собой весь список: сначала трое.
const collapsed = group.waiting && !waitingExpanded && !query && group.items.length > 4;
const shown = collapsed ? group.items.slice(0, 3) : group.items;
shown.forEach((node) => frag.append(personRow(node, { withType })));
if (collapsed) {
const more = document.createElement('button');
more.type = 'button';
more.className = 'list-more';
more.innerHTML = `${iconHtml('chevron-down')}<span>Показать всех · ${group.items.length}</span>`;
more.addEventListener('click', () => { waitingExpanded = true; renderList(); });
frag.append(more);
}
}
if (query) appendRemoteResults(frag, new Set(people.map((node) => node.id)));
if (!people.length && map.nodes.length > 1 && !(query && search?.remote?.items?.length)) {
frag.append(createStateMessage(query
? { icon: 'search', title: 'Никого не нашлось', text: 'Проверьте имя или логин.' }
: { icon: 'search', title: 'Никого не нашлось', text: 'Под этот фильтр сейчас никто не подходит.', actionLabel: 'Показать всех', onAction: () => setFilter('all') }));
}
list.append(frag);
list.scrollTop = scrollTop;
}
// --- поиск ---
let remoteTimer = 0;
function openSearch() {
if (search) {
search.topbar.searchInput?.focus();
return;
}
selectNode('');
const topbar = createSearchTopBar({
placeholder: 'Имя или логин',
onInput: (value) => {
search.query = value;
scheduleRemoteSearch();
renderSearchResults();
},
onSubmit: () => {
const host = viewMode === 'list' ? list : searchPanel;
const first = host.querySelector('.person-row__main');
if (first instanceof HTMLElement) first.click();
},
onClose: () => closeSearch(),
});
search = {
query: '',
topbar,
layer: openHistoryLayer(() => closeSearch({ fromHistory: true })),
remote: { seq: 0, query: '', items: [], loading: false, failed: false },
};
chrome?.setTopbar(topbar);
topbar.searchInput?.focus();
renderSearchResults();
// На телефоне клавиатура может не открыться без повторного фокуса после отрисовки.
window.requestAnimationFrame(() => { if (search?.topbar === topbar) topbar.searchInput?.focus(); });
}
function closeSearch({ fromHistory = false } = {}) {
if (!search) return;
const { layer } = search;
window.clearTimeout(remoteTimer);
search = null;
if (!fromHistory) layer?.close();
searchPanel.hidden = true;
searchPanel.replaceChildren();
if (!disposed) {
syncHeader({ force: true });
if (viewMode === 'list') renderList();
}
}
function scheduleRemoteSearch() {
window.clearTimeout(remoteTimer);
const query = searchText(search?.query).replace(/^@/, '');
const remote = search.remote;
remote.seq += 1;
remote.items = [];
remote.failed = false;
remote.loading = query.length >= 2;
remote.query = query;
if (!remote.loading) return;
const seq = remote.seq;
remoteTimer = window.setTimeout(async () => {
try {
const users = await authService.searchPeople(query, { limit: 12 });
if (disposed || !search || search.remote.seq !== seq) return;
remote.items = Array.isArray(users) ? users : [];
} catch {
if (disposed || !search || search.remote.seq !== seq) return;
remote.failed = true;
}
remote.loading = false;
renderSearchResults();
}, 320);
}
// Люди со всей сети, которых нет на карте: выбранный становится её центром.
function appendRemoteResults(target, shownIds) {
const remote = search?.remote;
if (!remote || !remote.query) return;
const items = remote.items.filter((user) => {
const key = normKey(user?.login);
return key && !shownIds.has(key) && !map?.byId.has(key);
});
if (!remote.loading && !remote.failed && !items.length) return;
target.append(createListSection('Во всей сети'));
if (remote.loading) {
const loading = document.createElement('div');
loading.className = 'loading-state net-search-loading';
loading.style.setProperty('--loading-delay', '150ms');
loading.append(createSpinner({ size: 'sm', label: 'Ищу' }));
target.append(loading);
return;
}
if (remote.failed) {
const fail = document.createElement('p');
fail.className = 'net-search-note';
fail.textContent = 'Поиск по всей сети сейчас недоступен. Проверьте соединение.';
target.append(fail);
return;
}
for (const user of items) {
const login = normalizeLogin(user.login);
const name = String(user.displayName || '').trim();
target.append(createPersonRow({
login,
name: name || login,
avatar: user.avatarAr ? { ar: user.avatarAr } : null,
sub: name && normKey(name) !== normKey(login) ? `@${login} · показать его связи` : 'показать его связи',
onClick: () => recenter(login),
actions: [{ icon: 'profile', label: 'Профиль', onClick: () => { closeSearch(); navigate(profileRoute(login)); } }],
}));
}
}
function renderSearchResults() {
if (!search) return;
if (viewMode === 'list') {
searchPanel.hidden = true;
renderList();
return;
}
searchPanel.replaceChildren();
searchPanel.hidden = false;
const query = searchText(search.query);
const frag = document.createDocumentFragment();
if (!query) {
const hint = document.createElement('p');
hint.className = 'net-search-note';
hint.textContent = 'Найдите человека на этой карте или во всей сети.';
frag.append(hint);
searchPanel.append(frag);
return;
}
const found = (map?.nodes || [])
.filter((node) => node.id !== map.focusId && matchesQuery(node, query))
.sort((a, b) => {
const aStarts = searchText(a.name).startsWith(query) || a.id.startsWith(query) ? 0 : 1;
const bStarts = searchText(b.name).startsWith(query) || b.id.startsWith(query) ? 0 : 1;
return aStarts - bStarts || a.tier - b.tier || a.name.localeCompare(b.name, 'ru');
});
if (found.length) {
frag.append(createListSection(`На карте · ${found.length}`));
// На карте выбор – показать человека, а не уйти в профиль.
found.slice(0, 30).forEach((node) => frag.append(personRow(node, { onOpen: () => showOnMap(node.id), withType: true })));
}
appendRemoteResults(frag, new Set(found.map((node) => node.id)));
if (!found.length && !search.remote.loading && !search.remote.items.length) {
frag.append(createStateMessage({ icon: 'search', title: 'Никого не нашлось', text: 'Проверьте имя или логин.' }));
}
searchPanel.append(frag);
}
function onKeydown(event) {
const typing = event.target instanceof HTMLElement && event.target.closest('input, textarea, [contenteditable="true"]');
const overlayOpen = Boolean(noteSheet || legendSheet || document.querySelector('.dropdown-portal, .modal'));
if (event.key === 'Escape') {
if (!selectedId || overlayOpen || search) return;
selectNode('');
return;
}
// Клавиши для компьютера: «/» – поиск, «+»/«−» – масштаб, «0» – вся карта.
if (typing || overlayOpen || event.ctrlKey || event.metaKey || event.altKey) return;
if (event.key === '/') {
event.preventDefault();
openSearch();
} else if (viewMode === 'map' && (event.key === '+' || event.key === '=')) {
engine.zoomBy(1.35);
} else if (viewMode === 'map' && (event.key === '-' || event.key === '_')) {
engine.zoomBy(1 / 1.35);
} else if (viewMode === 'map' && event.key === '0') {
engine.fit();
}
}
document.addEventListener('keydown', onKeydown);
const overlayObserver = typeof ResizeObserver === 'function' ? new ResizeObserver(() => placeOverlays()) : null;
overlayObserver?.observe(stage);
overlayObserver?.observe(chipsBar);
screen.cleanup = () => {
if (disposed) return;
disposed = true;
engine.destroy();
overlayObserver?.disconnect();
rowMenu.destroy();
window.cancelAnimationFrame(listFrame);
window.clearTimeout(remoteTimer);
window.removeEventListener(PEOPLE_NOTES_EVENT, onNotesChanged);
document.removeEventListener('keydown', onKeydown);
noteSheet?.close();
legendSheet?.close();
if (search) {
const { layer } = search;
search = null;
layer?.close();
}
};
syncModePill();
board.hidden = viewMode !== 'map';
zoomBar.hidden = viewMode !== 'map';
syncChips();
syncHeader({ force: true });
stage.append(board, list, chipsBar, overlay, busyPill, zoomBar, modePill, card, searchPanel, rowMenuAnchor, a11yList);
screen.append(stage);
persist();
if (centerLogin) void load(centerLogin);
else syncStateMessage();
return screen;
}