Files
SHiNE-server/shine-UI/js/pages/network-view.js
T
q 68eec2b28b Связи: подписи островов по месту, карта остаётся вписанной
- Подписи групп: на общем виде (людей не различить) – прямо на острове, как название
  района; когда люди видны – рядом с островом, чтобы их не закрывать.
- Пока карту не трогали, она остаётся вписанной целиком: догрузились знакомства, подписи
  или открылась чужая карта по ссылке – вписывается заново. Первое касание, масштаб или
  выбор человека это выключают. Раньше на чужой карте крайний остров уезжал за край экрана.
- Если групп нет совсем (связи не знакомы между собой, общих подписок нет, город никто не
  указал) – одна подсказка, почему доска пустая.
2026-10-13 14:16:44 +03:00

2532 lines
116 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, здесь –
// состав (центр, раскрытые связи), фильтры, поиск, список, карточка человека и заметки.
// «Компании», «Интересы» и «Города»: знакомства, подписки и города людей первого круга
// собираются по одному запросу на человека (network/people-data-store.js), группы считает
// network/communities.js, свои названия компаний и ручные переносы – network/companies-store.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, makeShineChannelRootRoute } from '../services/shine-routes.js';
import { userDisplayName } from '../services/user-display.js';
import { showToast } from '../services/channels-ux.js';
import { actionErrorText, toUserMessage } from '../services/ui-error-texts.js';
import { matchesPeopleQuery } from '../services/people-search.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, relationTypeFromRelation } from './network/adapter.js';
import { REST_GROUP, buildCityGroups, buildCompanies, buildInterestGroups, tieWeight } from './network/communities.js';
import { CITY_PARAM, cityKey, cityLabel } from '../services/cities.js';
import {
assignToCompany, createCompany, getCompanySettings, restoreCompanySettings, setCompanyName, snapshotCompanySettings,
updateCompanySnapshots,
} from './network/companies-store.js';
import {
PEOPLE_DATA_FRESH_MS, channelInfo, channelKey, getCities, getSubs, getTies, saveCities, saveSubs, saveTies,
} from './network/people-data-store.js';
import {
clearManualLayout, getAutoLayoutMode, getLayoutMode, getManualBase, getManualLayout, getViewSetting, hasManualLayout,
restoreManualLayout, saveManualLayout, 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, interest: '', view: null, listScroll: 0 };
// Фильтр – один выбранный. Тип связи и «добавили вас» – только про прямые связи центра,
// «сияющие» и «с заметкой» – про всех на карте.
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]));
// Раскладки-группы: люди собираются островами (communities.js).
const LENS_MODES = new Set(['companies', 'interests', 'cities']);
// Что нужно раскладке: главное (без него групп нет) и дополнительное (подписи, нити, «Читают»).
const LENS_DATA = { companies: ['ties', 'subs'], interests: ['subs', 'ties'], cities: ['cities', 'ties'] };
const PEOPLE_DATA_LIMIT = 500; // столько людей первого круга опрашивается (сначала близкие и друзья)
const PEOPLE_DATA_CONCURRENCY = 6;
function pluralRu(n, one, few, many) {
const mod10 = n % 10;
const mod100 = n % 100;
if (mod10 === 1 && mod100 !== 11) return one;
if (mod10 >= 2 && mod10 <= 4 && (mod100 < 12 || mod100 > 14)) return few;
return many;
}
// Веса знакомств для поиска компаний: только между людьми ids.
function tieWeights(ties, ids) {
const weights = new Map();
ties?.people?.forEach((near, a) => {
if (!ids.has(a)) return;
near.forEach((tie, b) => {
if (a === b || !ids.has(b)) return;
const w = tieWeight(tie.type, tie.mutual);
for (const [x, y] of [[a, b], [b, a]]) {
if (!weights.has(x)) weights.set(x, new Map());
weights.get(x).set(y, Math.max(weights.get(x).get(y) || 0, w));
}
});
});
return weights;
}
function composeMap(centerLogin, graphs, expanded, notes, ties = null) {
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;
}
}
// Кто из первого круга знаком между собой (если уже узнавали): острова «Компаний» рисуют
// эти нити, а кольца «по близости» ставят знакомых рядом.
if (ties?.people?.size) {
const keys = new Set(edges.map((edge) => (edge.a < edge.b ? `${edge.a}|${edge.b}` : `${edge.b}|${edge.a}`)));
const direct = (id) => id !== center.id && byId.get(id)?.tier === 1;
ties.people.forEach((near, a) => {
if (!direct(a)) return;
near.forEach((tie, b) => {
if (a === b || !direct(b)) return;
const key = a < b ? `${a}|${b}` : `${b}|${a}`;
if (keys.has(key)) return;
keys.add(key);
edges.push({ a, b, type: tie.type, mutual: tie.mutual, tie: true });
});
});
}
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 selectedInterest = restore ? persisted.interest || '' : '';
// «Назад» из профиля – карта и список там же, где были.
let restoreView = restore ? persisted.view : null;
let restoreListScroll = restore ? persisted.listScroll : 0;
let layoutMode = getLayoutMode();
let viewMode = getViewSetting('view', 'map') === 'list' ? 'list' : 'map';
const LIST_SORTS = ['closeness', 'companies', 'interests', 'cities', 'name'];
let listSort = LIST_SORTS.includes(getViewSetting('listSort', 'closeness')) ? getViewSetting('listSort', 'closeness') : '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; // «Добавили вас» в списке: сначала несколько, по кнопке – все
let groupsModel = null; // острова «Компаний» / «Интересов»: { lens, groups, byId, byPerson }
let selectedGroupId = '';
let groupSheet = null;
const lensLoads = new Map(); // `${вид}|${центр}` → { kind, centerKey, done, total, foreground }
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;
const busyText = document.createElement('span');
busyText.className = 'net-busy__text';
busyPill.append(createSpinner({ size: 'sm', label: 'Загружаю связи' }), busyText);
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;
persisted.interest = selectedInterest;
}
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 = filterBar.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 = filterBar.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`;
}
// Что лежит поверх карты справа и внизу: подписи на карте туда не ставятся.
function obstacles() {
const s = stage.getBoundingClientRect();
return [zoomBar, modePill].filter((el) => !el.hidden).map((el) => {
const r = el.getBoundingClientRect();
return { x: r.left - s.left - 4, y: r.top - s.top - 4, w: r.width + 8, h: r.height + 8 };
});
}
const engine = createGraphCanvas({
stage: board,
getInsets: insets,
getObstacles: obstacles,
onSelect: (node) => selectNode(node ? node.id : ''),
onNodeMoved: (node, point, info) => onNodeMoved(node, point, info),
onGroupSelect: (id) => selectGroup(id, { reveal: true }),
});
let listFrame = 0;
function renderMap({ fit = false, relayout = false } = {}) {
if (disposed) return;
map = composeMap(centerLogin, graphs, expanded, notes, getTies(normKey(centerLogin)));
if (!map) return;
// Фильтры должны быть на месте до вписывания карты: от них зависит свободная часть экрана.
screen.classList.toggle('is-blank', map.nodes.length <= 1);
const layout = currentLayout();
// Пока знакомства или подписки не собраны, «Компании» и «Интересы» показывают кольца.
const previousGroups = groupsModel;
groupsModel = computeGroups(layout.mode);
if (selectedGroupId && !groupsModel?.byId.has(selectedGroupId)) selectedGroupId = '';
// Состав групп поменялся (освежились данные, перенесли человека) – острова перестраиваются;
// своя раскладка не трогается.
const regroup = Boolean(groupsModel && previousGroups && !sameGrouping(previousGroups, groupsModel)) && layout.id !== 'manual';
hintEmptyLens(groupsModel);
engine.setGraph(map, {
manual: layout.manual, mode: layout.mode, relayout: relayout || regroup, fit, groups: groupsModel?.groups || null,
});
applySelectionHighlight();
engine.setFilter(filterPredicate());
renderA11y();
syncFilters();
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();
ensureLensData();
}
function renderA11y() {
a11yList.replaceChildren();
if (!map) return;
for (const group of groupsModel?.groups || []) {
const li = document.createElement('li');
const button = document.createElement('button');
button.type = 'button';
const n = group.members.length;
const kindName = { companies: 'Компания', interests: 'Интерес', cities: 'Город' }[groupsModel.lens] || 'Группа';
button.textContent = `${kindName} «${group.label}», ${n} ${pluralRu(n, 'человек', 'человека', 'человек')}`;
button.addEventListener('click', () => selectGroup(group.id, { reveal: true }));
li.append(button);
a11yList.append(li);
}
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));
syncLensProgress();
}
function syncLensProgress() {
const centerKey = normKey(centerLogin);
const job = [...lensLoads.values()].find((row) => row.foreground && row.centerKey === centerKey);
busyPill.classList.toggle('net-busy--text', Boolean(job));
const what = { ties: 'Узнаю знакомства', subs: 'Узнаю подписки', cities: 'Узнаю города' };
busyText.textContent = job ? `${what[job.kind]} · ${job.done} из ${job.total}` : '';
busyPill.hidden = busyCount === 0 && !job;
}
// Что показать вместо карты: загрузка, ошибка, «пока нет связей» или «никого не нашлось».
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 });
const restoring = Boolean(restoreView) && !restoreView.auto;
renderMap({ fit: !restoring });
if (restoring) engine.setView(restoreView);
restoreView = null;
if (friendsOfFriends) void expandFriends({ fit: !restoring });
else if (expanded.size) void restoreExpanded();
} 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 restoreExpanded() {
const centerAtStart = normKey(centerLogin);
const logins = [...expanded].filter((key) => !graphs.has(key));
if (!logins.length) return;
await fetchGraphs(logins);
if (disposed || normKey(centerLogin) !== centerAtStart) return;
renderMap();
}
async function expandFriends({ fit = true } = {}) {
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;
syncFilters();
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, relayout: true });
if (failed) showToast(`Не удалось загрузить связи ${failed} из ${friends.length} друзей`, { kind: 'error', timeoutMs: 2600 });
}
function toggleFriendsOfFriends() {
friendsOfFriends = !friendsOfFriends;
syncFilters();
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 : '';
// Человек выбран поверх подсвеченного интереса – подсветка остаётся (видно, кого из
// читателей смотришь); нажатие мимо снимает и её.
if (!selectedId && selectedInterest) {
selectedInterest = '';
syncFilters();
if (viewMode === 'list') renderList();
persist();
}
if (selectedGroupId || !selectedId) {
selectedGroupId = '';
applySelectionHighlight();
}
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;
const interest = !node && selectedInterest ? selectedInterest : '';
const group = !node && !interest && selectedGroupId ? groupsModel?.byId.get(selectedGroupId) : null;
card.replaceChildren();
card.classList.toggle('net-card--group', Boolean(group || interest));
card.hidden = !(node || group || interest) || viewMode !== 'map';
modePill.hidden = !card.hidden;
if (interest && viewMode === 'map') renderInterestCard(interest);
else if (group && viewMode === 'map') renderGroupCard(group);
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 groupId = !isCenter && node.tier === 1 ? groupsModel?.byPerson.get(node.id) : '';
const ownGroup = groupId ? groupsModel.byId.get(groupId) : null;
if (ownGroup) {
const row = document.createElement('div');
row.className = 'net-card__group-row';
row.append(groupChip(ownGroup, ownGroup.label, () => selectGroup(ownGroup.id, { reveal: true })));
if (groupsModel.lens === 'companies') {
const move = document.createElement('button');
move.type = 'button';
move.className = 'net-card__move';
move.textContent = 'Перенести…';
move.addEventListener('click', () => openMoveMenu(node, move));
row.append(move);
}
card.append(row);
}
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 (canAnswerBack(node)) {
const answer = document.createElement('button');
answer.type = 'button';
answer.className = 'primary-btn net-card__answer';
const busy = answering.has(node.id);
answer.disabled = busy;
answer.textContent = busy ? 'Сохраняю…' : answerBackLabel(node);
answer.addEventListener('click', () => { void answerBack(node); });
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();
}
// --- ответ взаимностью ---
// «Добавили вас»: ответить в одно касание – другом на дружбу, контактом на контакт
// (другой вид связи можно выбрать в профиле человека).
const answering = new Set();
function canAnswerBack(node) {
return Boolean(node) && node.id !== map?.focusId && node.tier === 1 && node.direction === 'in' && isSelfCenter();
}
function answerBackLabel(node) {
return FRIEND_TYPES.has(node.relationType) ? 'Дружить в ответ' : 'Добавить в ответ';
}
async function answerBack(node) {
if (!node || answering.has(node.id)) return;
const kind = FRIEND_TYPES.has(node.relationType) ? 'friend' : 'contact';
answering.add(node.id);
renderCard();
if (viewMode === 'list') renderList();
let done = false;
try {
await authService.setUserRelation({
login: state.session.login, toLogin: node.login, kind, enabled: true, storagePwd: state.session.storagePwdInMemory,
});
done = true;
if (!disposed) showToast(kind === 'friend' ? 'Теперь вы друзья' : 'Добавлено в контакты');
const graph = await getConnectionsGraphCached(selfLogin, { force: true });
if (!disposed) graphs.set(selfKey, buildGraphModel(graph, selfLogin));
} catch (error) {
// Связь сохранена, но карта не перечиталась – она обновится при следующем открытии.
if (!done && !disposed) showToast(actionErrorText('Не удалось ответить', error), { kind: 'error' });
} finally {
answering.delete(node.id);
if (!disposed) renderMap();
}
}
// --- заметка ---
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') {
const sortItem = (id, label, icon, hint) => ({
label, hint, selected: listSort === id, iconHtml: iconHtml(listSort === id ? 'check' : icon), action: () => changeListSort(id),
});
items.push(
sortItem('closeness', 'По близости', 'rings', 'Близкие, друзья, контакты'),
sortItem('companies', 'Компании', 'groups', 'Кто с кем знаком'),
sortItem('interests', 'Интересы', 'channels', 'Кто что читает'),
sortItem('cities', 'Города', 'place', 'Кто где живёт'),
sortItem('name', 'По имени', 'list', ''),
);
return items;
}
const hasManual = hasManualLayout(normKey(centerLogin));
const active = currentLayout().id;
const layoutItem = (id, label, icon, extra = {}) => ({
label, selected: active === id, iconHtml: iconHtml(active === id ? 'check' : icon), action: () => changeLayoutMode(id), ...extra,
});
// Раскладки – разные способы разобрать людей по группам, а не разные формы одной картины.
items.push(
layoutItem('rings', 'По близости', 'rings', { hint: 'Близкие, друзья, контакты' }),
layoutItem('companies', 'Компании', 'groups', { hint: 'Кто с кем знаком' }),
layoutItem('interests', 'Интересы', 'channels', { hint: 'Кто что читает' }),
layoutItem('cities', 'Города', 'place', { hint: 'Кто где живёт' }),
hasManual
? layoutItem('manual', 'Своя раскладка', 'edit')
: { label: 'Своя раскладка', hint: 'Перетащите кого-нибудь на карте', disabled: true, iconHtml: iconHtml('edit') },
{ divider: true },
{ label: 'Показать всю карту', iconHtml: iconHtml('fit'), action: () => engine.fit() },
hasManual ? { label: 'Удалить свою раскладку', iconHtml: iconHtml('trash'), action: () => deleteManualLayout() } : null,
{ 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(),
}));
}
// --- компании и интересы ---
// Люди первого круга без центра – сначала близкие и друзья: у очень большого круга
// опрашиваются первые PEOPLE_DATA_LIMIT.
function directPeople() {
if (!map) return [];
return map.nodes
.filter((node) => node.tier === 1 && node.id !== map.focusId)
.sort((a, b) => (RELATION_RANK[a.relationType] ?? 9) - (RELATION_RANK[b.relationType] ?? 9) || a.name.localeCompare(b.name, 'ru'));
}
const PEOPLE_DATA = {
ties: { get: getTies, save: saveTies, empty: () => ({ at: 0, people: new Map() }), has: (entry, id) => entry.people.has(id) },
subs: { get: getSubs, save: saveSubs, empty: () => ({ at: 0, of: new Map(), info: new Map() }), has: (entry, id) => entry.of.has(id) },
cities: { get: getCities, save: saveCities, empty: () => ({ at: 0, of: new Map() }), has: (entry, id) => entry.of.has(id) },
};
function coverage(kind, entry, people) {
if (!entry || !people.length) return 0;
const known = people.filter((node) => PEOPLE_DATA[kind].has(entry, node.id)).length;
return known / people.length;
}
// Группы для раскладки (или порядка списка) mode; null – данных пока нет.
function computeGroups(mode) {
if (!map || !LENS_MODES.has(mode)) return null;
const people = directPeople();
if (people.length < 2) return null;
const centerKey = normKey(centerLogin);
const asked = people.slice(0, PEOPLE_DATA_LIMIT);
const ties = getTies(centerKey);
const subs = getSubs(centerKey);
const ready = (kind, entry) => coverage(kind, entry, asked) >= 0.8;
let model;
if (mode === 'companies') {
if (!ready('ties', ties)) return null;
model = buildCompanies({
people,
weights: tieWeights(ties, new Set(people.map((node) => node.id))),
saved: getCompanySettings(centerKey),
subs: ready('subs', subs) ? subs : null,
});
if (model.snapshots.length) updateCompanySnapshots(centerKey, model.snapshots);
} else if (mode === 'cities') {
const cities = getCities(centerKey);
if (!ready('cities', cities)) return null;
model = buildCityGroups({ people, cities, cityKey, cityLabel });
} else {
if (!ready('subs', subs)) return null;
model = buildInterestGroups({ people, subs });
}
model.groups.forEach((group) => {
group.caption = `${group.label} · ${group.members.length}`;
group.short = group.shortLabel || group.label;
});
return { ...model, lens: mode, byId: new Map(model.groups.map((group) => [group.id, group])) };
}
// Групп нет совсем (все в «Без компании» / «Без общих подписок» / «Город не указан») – один
// раз на карту объясняем почему, иначе пустая доска выглядит как поломка.
const emptyLensHinted = new Set();
function hintEmptyLens(model) {
if (!model || viewMode !== 'map' || model.groups.some((group) => group.kind !== 'rest')) return;
const key = `${model.lens}|${normKey(centerLogin)}`;
if (emptyLensHinted.has(key)) return;
emptyLensHinted.add(key);
const self = isSelfCenter();
const text = {
companies: self ? 'Компаний пока нет: ваши связи не знакомы между собой' : 'Компаний пока нет: связи этого человека не знакомы между собой',
interests: 'Общих подписок пока нет: никакой канал не читают хотя бы двое',
cities: self ? 'Никто из ваших связей пока не указал город в профиле' : 'Никто из связей этого человека пока не указал город',
}[model.lens];
if (text) showToast(text, { kind: 'info', timeoutMs: 4500 });
}
// Тот же ли состав групп (без учёта их id: компания, получившая название, – та же компания).
function sameGrouping(a, b) {
if (!a || !b || a.lens !== b.lens || a.byPerson.size !== b.byPerson.size) return false;
const signature = (model) => new Set(model.groups.map((group) => [...group.members].sort().join('|')));
const left = signature(a);
const right = signature(b);
if (left.size !== right.size) return false;
for (const key of left) if (!right.has(key)) return false;
return true;
}
// Что нужно собрать сейчас: для раскладки карты или для порядка списка.
function ensureLensData() {
if (!map || disposed || map.nodes.length <= 2) return;
const lens = viewMode === 'list' ? listSort : currentLayout().mode;
if (!LENS_MODES.has(lens)) return;
const [primary, secondary] = LENS_DATA[lens];
void loadPeopleData(primary).then(() => loadPeopleData(secondary, { quiet: true }));
}
// Не повторять неудачный сбор при каждой перерисовке: следующая попытка – через минуту
// (или сразу по «Повторить»).
const lensBlockedUntil = new Map();
// Возвращает true, если теперь известно почти обо всех (можно строить группы).
async function loadPeopleData(kind, { quiet = false, force = false } = {}) {
if (disposed || !map) return false;
const centerKey = normKey(centerLogin);
const jobKey = `${kind}|${centerKey}`;
if (lensLoads.has(jobKey) || (!force && (lensBlockedUntil.get(jobKey) || 0) > Date.now())) return false;
const people = directPeople().slice(0, PEOPLE_DATA_LIMIT);
if (!people.length) return false;
const store = PEOPLE_DATA[kind];
const stored = store.get(centerKey);
// Копия: пока идёт сбор, раскладка пользуется прежними данными.
const entry = store.empty();
if (stored) {
entry.at = stored.at;
if (entry.people) entry.people = new Map(stored.people);
if (entry.of) entry.of = new Map(stored.of);
if (entry.info) entry.info = new Map(stored.info);
}
const missing = people.filter((node) => !store.has(entry, node.id));
const stale = Date.now() - entry.at > PEOPLE_DATA_FRESH_MS;
const targets = stale ? people : missing;
if (!targets.length) return true;
// Первый сбор – с прогрессом поверх карты; дособрать пару новых людей или освежить
// старое – молча, картина уже есть.
const foreground = !quiet && coverage(kind, entry, people) < 0.8;
const job = { kind, centerKey, done: 0, total: targets.length, foreground };
lensLoads.set(jobKey, job);
syncLensProgress();
const directIds = new Set(people.map((node) => node.id));
let failed = 0;
await mapWithConcurrency(targets, PEOPLE_DATA_CONCURRENCY, async (node) => {
try {
if (kind === 'ties') {
const graph = await getConnectionsGraphCached(node.login, { retries: 1 });
const near = new Map();
for (const relation of buildGraphModel(graph, node.login).relations) {
if (relation.key === node.id || !directIds.has(relation.key)) continue;
near.set(relation.key, { type: relationTypeFromRelation(relation), mutual: relation.forward && relation.backward });
}
entry.people.set(node.id, near);
} else if (kind === 'subs') {
const payload = await authService.listUserProfileChannels(node.login, 'following', 200, 0);
const rows = (Array.isArray(payload?.channels) ? payload.channels : []).filter((row) => row && !row.deleted);
entry.of.set(node.id, [...new Set(rows.map(channelKey))]);
rows.forEach((row) => entry.info.set(channelKey(row), channelInfo(row)));
} else {
const payload = await authService.getUserParam(node.login, CITY_PARAM);
entry.of.set(node.id, String(payload?.value || '').trim());
}
} catch {
failed += 1;
}
job.done += 1;
if (job.foreground && !disposed) syncLensProgress();
});
lensLoads.delete(jobKey);
if (failed) lensBlockedUntil.set(jobKey, Date.now() + 60 * 1000);
else lensBlockedUntil.delete(jobKey);
// Освежили всех – отметка времени; если большинство не ответило, попробуем в следующий раз.
if (stale && failed < targets.length / 2) entry.at = Date.now();
store.save(centerKey, entry);
if (disposed) return false;
syncLensProgress();
if (normKey(centerLogin) !== centerKey) return false;
if (failed && job.foreground) {
const what = { ties: 'знакомства', subs: 'подписки', cities: 'города' }[kind];
const rest = { ties: 'Без компании', subs: 'Без общих подписок', cities: 'Город не указан' }[kind];
const ok = coverage(kind, entry, people) >= 0.8;
showToast(ok
? `Не удалось узнать ${what} ${failed} ${pluralRu(failed, 'человека', 'человек', 'человек')} – они пока в «${rest}»`
: `Не удалось узнать ${what}. Проверьте соединение.`, {
kind: 'error',
timeoutMs: 5000,
action: { label: 'Повторить', onClick: () => { if (!disposed) void loadPeopleData(kind, { force: true }); } },
});
}
renderMap({ fit: job.foreground });
return coverage(kind, entry, people) >= 0.8;
}
// --- карточка группы и подсветка интереса ---
function selectGroup(id, { reveal = false } = {}) {
const group = id ? groupsModel?.byId.get(id) : null;
// Остров канала в «Интересах» – это подсветка всех читателей канала, а не только острова.
if (group?.kind === 'interest' && group.channel) {
selectInterest(group.channel, { reveal });
return;
}
selectedGroupId = group ? id : '';
if (selectedGroupId) {
selectedId = '';
engine.select('');
}
if (selectedInterest) {
selectedInterest = '';
syncFilters();
if (viewMode === 'list') renderList();
}
// Сначала карточка: камера вписывает остров в то, что карточка оставила свободным.
renderCard();
applySelectionHighlight({ reveal });
persist();
}
// Читатели канала среди людей первого круга (чьи подписки уже известны).
function channelReaders(key) {
const subs = getSubs(normKey(centerLogin));
if (!subs || !map || !key) return [];
return map.nodes
.filter((node) => node.tier === 1 && node.id !== map.focusId && subs.of.get(node.id)?.includes(key))
.map((node) => node.id);
}
// «Нажал по кулинарии – подсветились все кулинары»: читатели канала ярче остальных, где бы
// они ни стояли (в любой раскладке), внизу – карточка канала.
function selectInterest(key, { reveal = true } = {}) {
const readers = channelReaders(key);
selectedInterest = readers.length ? key : '';
const islandId = selectedInterest ? `c:${selectedInterest}` : '';
selectedGroupId = groupsModel?.lens === 'interests' && groupsModel.byId.has(islandId) ? islandId : '';
if (selectedInterest) {
selectedId = '';
engine.select('');
}
syncFilters();
renderCard();
applySelectionHighlight({ reveal });
if (viewMode === 'list') {
renderList();
list.scrollTop = 0;
}
persist();
}
// Подсветка на карте – по тому, что сейчас выбрано: интерес (все читатели) или остров.
function applySelectionHighlight({ reveal = false } = {}) {
if (selectedInterest) {
const readers = channelReaders(selectedInterest);
if (!readers.length) selectedInterest = '';
else {
engine.selectGroup(selectedGroupId, { reveal, members: readers });
return;
}
}
engine.selectGroup(selectedGroupId, { reveal });
}
// Какие каналы читают люди группы (members) – по числу читателей.
function topChannels(members, { except = '', limit = 3, min = 2 } = {}) {
const subs = getSubs(normKey(centerLogin));
if (!subs) return [];
const counts = new Map();
members.forEach((id) => subs.of.get(id)?.forEach((key) => {
if (key !== except) counts.set(key, (counts.get(key) || 0) + 1);
}));
return [...counts.entries()]
.filter(([, count]) => count >= min)
.sort((a, b) => b[1] - a[1] || (a[0] < b[0] ? -1 : 1))
.slice(0, limit)
.map(([key, count]) => ({ key, count, name: subs.info.get(key)?.name || key }));
}
function interestChip(item) {
const chip = document.createElement('button');
chip.type = 'button';
chip.className = 'net-group-chip net-group-chip--interest';
chip.innerHTML = iconHtml('channels');
const label = document.createElement('span');
label.textContent = `${item.name} · ${item.count}`;
chip.append(label);
chip.addEventListener('click', () => selectInterest(item.key));
return chip;
}
function relatedRow(labelText, nodesList) {
const row = document.createElement('div');
row.className = 'net-card__related';
const label = document.createElement('span');
label.className = 'net-card__related-label';
label.textContent = labelText;
row.append(label, ...nodesList);
return row;
}
function cardFaces(ids, group = null) {
const faces = document.createElement('span');
faces.className = 'net-card__faces';
if (group && group.kind !== 'rest' && group.color >= 0) faces.style.setProperty('--group-color', `var(--net-island-${group.color})`);
ids.slice(0, 3).forEach((id) => {
const node = map.byId.get(id);
if (!node) return;
faces.append(renderUserAvatar({
login: node.login, firstName: node.firstName, lastName: node.lastName, avatar: node.avatar, size: 'sm', official: node.official,
}));
});
return faces;
}
function cardHead(faces, title, metaText, onClose) {
const head = document.createElement('div');
head.className = 'net-card__head';
const titles = document.createElement('div');
titles.className = 'net-card__titles';
const name = document.createElement('div');
name.className = 'net-card__name';
name.textContent = title;
const meta = document.createElement('div');
meta.className = 'net-card__meta';
meta.textContent = metaText;
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', onClose);
head.append(faces, titles, close);
return head;
}
function channelRoute(key) {
const info = getSubs(normKey(centerLogin))?.info.get(key);
const route = info ? makeShineChannelRootRoute({ ownerBlockchainName: info.bch, channelRootBlockNumber: info.root, channelRootBlockHash: info.hash }) : '';
return route ? `${route}/about` : '';
}
function renderInterestCard(key) {
const subs = getSubs(normKey(centerLogin));
const name = subs?.info.get(key)?.name || key;
const readers = channelReaders(key);
const byCloseness = [...readers].sort((a, b) => (RELATION_RANK[map.byId.get(a)?.relationType] ?? 9) - (RELATION_RANK[map.byId.get(b)?.relationType] ?? 9));
const n = readers.length;
card.setAttribute('aria-label', name);
card.append(cardHead(
cardFaces(byCloseness),
name,
`${n} ${pluralRu(n, 'читатель', 'читателя', 'читателей')} · ${compositionText(readers)}`,
() => clearInterest(),
));
const hint = document.createElement('p');
hint.className = 'net-card__hint';
hint.textContent = 'Подсвечены все ваши связи, кто читает этот канал.';
card.append(hint);
const also = topChannels(readers, { except: key });
if (also.length) card.append(relatedRow('Ещё читают:', also.map(interestChip)));
const actions = document.createElement('div');
actions.className = 'net-card__actions';
const route = channelRoute(key);
actions.append(cardAction('channels', 'Канал', () => { if (route) navigate(route); }, { disabled: !route }));
actions.append(cardAction('list', 'Списком', () => setViewMode('list')));
card.append(actions);
}
function clearInterest() {
if (!selectedInterest && !selectedGroupId) return;
selectedInterest = '';
selectedGroupId = '';
syncFilters();
renderCard();
applySelectionHighlight();
if (viewMode === 'list') renderList();
persist();
}
// Состав по близости: «3 близких, 8 друзей, 15 контактов».
function compositionText(members) {
const counts = { close: 0, friend: 0, contact: 0 };
members.forEach((id) => {
const type = map?.byId.get(id)?.relationType;
if (type === 'close_friend' || type === 'family') counts.close += 1;
else if (type === 'friend') counts.friend += 1;
else counts.contact += 1;
});
const parts = [];
if (counts.close) parts.push(`${counts.close} ${pluralRu(counts.close, 'близкий', 'близких', 'близких')}`);
if (counts.friend) parts.push(`${counts.friend} ${pluralRu(counts.friend, 'друг', 'друга', 'друзей')}`);
if (counts.contact) parts.push(`${counts.contact} ${pluralRu(counts.contact, 'контакт', 'контакта', 'контактов')}`);
return parts.join(', ');
}
// С какими группами связана: по числу знакомств между ними (у компаний – мостики).
function relatedGroups(group) {
if (!groupsModel || !map) return [];
const inside = new Set(group.members);
const counts = new Map();
for (const edge of map.edges) {
const a = inside.has(edge.a);
const b = inside.has(edge.b);
if (a === b) continue;
const other = groupsModel.byPerson.get(a ? edge.b : edge.a);
if (!other || other === group.id) continue;
counts.set(other, (counts.get(other) || 0) + 1);
}
return [...counts.entries()]
.map(([id, count]) => ({ group: groupsModel.byId.get(id), count }))
.filter((row) => row.group && row.group.kind !== 'rest')
.sort((x, y) => y.count - x.count)
.slice(0, 3);
}
function groupDot(group) {
const dot = document.createElement('span');
dot.className = 'net-group-dot';
if (group.kind === 'rest' || !(group.color >= 0)) dot.classList.add('net-group-dot--rest');
else dot.style.setProperty('--group-color', `var(--net-island-${group.color})`);
dot.setAttribute('aria-hidden', 'true');
return dot;
}
function groupChip(group, text, onClick) {
const chip = document.createElement('button');
chip.type = 'button';
chip.className = 'net-group-chip';
chip.append(groupDot(group));
const label = document.createElement('span');
label.textContent = text;
chip.append(label);
chip.addEventListener('click', onClick);
return chip;
}
function renderGroupCard(group) {
card.setAttribute('aria-label', group.label);
const head = document.createElement('div');
head.className = 'net-card__head';
// Лица группы: самые связанные (или первые по алфавиту) – по ним её проще узнать.
const faces = document.createElement('span');
faces.className = 'net-card__faces';
if (!(group.kind === 'rest' || !(group.color >= 0))) faces.style.setProperty('--group-color', `var(--net-island-${group.color})`);
const ordered = group.hubId ? [group.hubId, ...group.members.filter((id) => id !== group.hubId)] : group.members;
ordered.slice(0, 3).forEach((id) => {
const node = map.byId.get(id);
if (!node) return;
faces.append(renderUserAvatar({
login: node.login, firstName: node.firstName, lastName: node.lastName, avatar: node.avatar, size: 'sm', 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 = group.label;
const meta = document.createElement('div');
meta.className = 'net-card__meta';
const n = group.members.length;
meta.textContent = `${n} ${pluralRu(n, 'человек', 'человека', 'человек')} · ${compositionText(group.members)}`;
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', () => selectGroup(''));
head.append(faces, titles, close);
card.append(head);
// Пояснение – только там, где без него непонятно, откуда группа или её название.
const about = document.createElement('p');
about.className = 'net-card__hint';
if (group.kind === 'rest') {
about.textContent = {
companies: 'Не знакомы ни с кем из остальных ваших связей.',
interests: 'Не читают каналов, которые читают ещё хотя бы двое из ваших связей.',
cities: 'Не указали город в профиле.',
}[groupsModel.lens] || '';
} else if (group.id === 'city:*') {
about.textContent = 'По одному человеку в городе.';
} else if (groupsModel.lens === 'interests') {
about.textContent = 'Подписаны на этот канал.';
} else if (!group.name && group.channel) {
about.textContent = 'Название – по каналу, который читают многие из них.';
}
if (about.textContent) card.append(about);
// Компания или город: что там читают – нажатие подсвечивает читателей канала по всей карте.
if ((groupsModel.lens === 'companies' || groupsModel.lens === 'cities') && group.kind !== 'rest') {
const reads = topChannels(group.members, { limit: 2 });
if (reads.length) card.append(relatedRow('Читают:', reads.map(interestChip)));
}
const related = groupsModel.lens === 'interests' ? (group.alsoRead || []) : relatedGroups(group).slice(0, 2);
if (related.length) {
const row = document.createElement('div');
row.className = 'net-card__related';
const label = document.createElement('span');
label.className = 'net-card__related-label';
label.textContent = groupsModel.lens === 'interests' ? 'Ещё читают:' : 'Знакомы с:';
row.append(label);
related.forEach((item) => {
if (groupsModel.lens === 'interests') {
const target = groupsModel.byId.get(`c:${item.key}`);
if (target) row.append(groupChip(target, `${item.name} · ${item.count}`, () => selectGroup(target.id, { reveal: true })));
else {
const text = document.createElement('span');
text.className = 'net-card__related-text';
text.textContent = `${item.name} · ${item.count}`;
row.append(text);
}
} else {
row.append(groupChip(item.group, `${item.group.label} · ${item.count}`, () => selectGroup(item.group.id, { reveal: true })));
}
});
card.append(row);
}
const actions = document.createElement('div');
actions.className = 'net-card__actions';
if (groupsModel.lens === 'companies' && group.kind !== 'rest') {
actions.append(cardAction('edit', group.name ? 'Название' : 'Назвать', () => openGroupNameSheet(group)));
}
if (groupsModel.lens === 'interests' && group.channel) {
const info = getSubs(normKey(centerLogin))?.info.get(group.channel);
const route = info ? makeShineChannelRootRoute({ ownerBlockchainName: info.bch, channelRootBlockNumber: info.root, channelRootBlockHash: info.hash }) : '';
actions.append(cardAction('channels', 'Канал', () => { if (route) navigate(`${route}/about`); }, { disabled: !route }));
}
actions.append(cardAction('list', 'Списком', () => showGroupInList(group)));
card.append(actions);
}
function openGroupNameSheet(group) {
groupSheet?.close();
const centerKey = normKey(centerLogin);
groupSheet = openSheet({
title: group.name ? 'Название компании' : 'Назвать компанию',
className: 'net-group-sheet',
onClose: () => { groupSheet = null; },
content: (sheet) => {
const wrap = document.createElement('div');
wrap.className = 'stack';
const hint = document.createElement('p');
hint.className = 'meta-muted';
hint.textContent = 'Видно только вам, хранится на этом устройстве.';
const input = document.createElement('input');
input.className = 'input';
input.type = 'text';
input.maxLength = 40;
input.value = group.name;
input.placeholder = 'Например, «Кунг-фу» или «Работа»';
input.setAttribute('aria-label', 'Название компании');
input.autofocus = true;
input.enterKeyHint = 'done';
const commit = (value) => {
const id = setCompanyName(centerKey, group, value);
sheet.close();
if (disposed || normKey(centerLogin) !== centerKey) return;
renderMap();
if (groupsModel?.byId.has(id)) selectGroup(id);
};
input.addEventListener('keydown', (event) => {
if (event.key === 'Enter') { event.preventDefault(); commit(input.value); }
});
wrap.append(hint, input);
if (group.name) {
const reset = document.createElement('button');
reset.type = 'button';
reset.className = 'ghost-btn';
reset.textContent = 'Убрать название';
reset.addEventListener('click', () => commit(''));
sheet.footer.append(reset);
}
const save = document.createElement('button');
save.type = 'button';
save.className = 'primary-btn';
save.textContent = 'Сохранить';
save.addEventListener('click', () => commit(input.value));
sheet.footer.append(save);
return wrap;
},
});
}
function showGroupInList(group) {
if (LENS_MODES.has(groupsModel?.lens) && listSort !== groupsModel.lens) {
listSort = groupsModel.lens;
setViewSetting('listSort', listSort);
}
setViewMode('list');
window.requestAnimationFrame(() => {
if (disposed) return;
const section = list.querySelector(`[data-group="${CSS.escape(group.id)}"]`);
if (section) list.scrollTop = Math.max(0, section.offsetTop - parseFloat(list.style.paddingTop || '0'));
});
}
// Перенести человека в другую компанию (или убрать из компаний). Своя раскладка остаётся
// как есть – человек там, куда его положили; автоматическая перестраивается.
function moveToCompany(node, target, { point = null } = {}) {
const centerKey = normKey(centerLogin);
const before = snapshotCompanySettings(centerKey);
assignToCompany(centerKey, node.id, target);
const layout = currentLayout();
if (layout.id === 'manual' && point) setManualPoint(centerKey, node.id, point);
renderMap({ relayout: layout.id !== 'manual' });
// Человек уезжает в другой остров – камера за ним, если его карточка открыта.
if (selectedId === node.id) engine.ensureVisible(node.id);
showToast(`Перенесено в «${target.label}»`, {
kind: 'info',
timeoutMs: 5000,
action: {
label: 'Отменить',
onClick: () => {
if (disposed || normKey(centerLogin) !== centerKey) return;
restoreCompanySettings(centerKey, before);
renderMap({ relayout: currentLayout().id !== 'manual' });
},
},
});
}
function openNewCompanySheet(node) {
groupSheet?.close();
const centerKey = normKey(centerLogin);
groupSheet = openSheet({
title: 'Новая компания',
className: 'net-group-sheet',
onClose: () => { groupSheet = null; },
content: (sheet) => {
const wrap = document.createElement('div');
wrap.className = 'stack';
const hint = document.createElement('p');
hint.className = 'meta-muted';
hint.textContent = `${node.name} будет в ней первым. Остальных можно перетащить на карте или перенести из их карточек.`;
const input = document.createElement('input');
input.className = 'input';
input.type = 'text';
input.maxLength = 40;
input.placeholder = 'Например, «Шаманы»';
input.setAttribute('aria-label', 'Название компании');
input.autofocus = true;
input.enterKeyHint = 'done';
const commit = () => {
const name = input.value.trim();
if (!name) { input.focus(); return; }
const before = snapshotCompanySettings(centerKey);
const id = createCompany(centerKey, name, node.id);
sheet.close();
if (disposed || normKey(centerLogin) !== centerKey) return;
renderMap({ relayout: currentLayout().id !== 'manual' });
if (groupsModel?.byId.has(id)) selectGroup(id, { reveal: true });
showToast(`Компания «${name}» создана`, {
kind: 'info',
timeoutMs: 5000,
action: {
label: 'Отменить',
onClick: () => {
if (disposed || normKey(centerLogin) !== centerKey) return;
restoreCompanySettings(centerKey, before);
selectGroup('');
renderMap({ relayout: currentLayout().id !== 'manual' });
},
},
});
};
input.addEventListener('keydown', (event) => {
if (event.key === 'Enter') { event.preventDefault(); commit(); }
});
wrap.append(hint, input);
const save = document.createElement('button');
save.type = 'button';
save.className = 'primary-btn';
save.textContent = 'Создать';
save.addEventListener('click', commit);
sheet.footer.append(save);
return wrap;
},
});
}
// Куда перенести человека: меню у кнопки в его карточке.
const moveMenuAnchor = document.createElement('span');
moveMenuAnchor.className = 'net-row-menu-anchor';
moveMenuAnchor.setAttribute('aria-hidden', 'true');
let moveMenuNode = null;
const moveMenu = createDropdownMenu({
anchorEl: moveMenuAnchor,
minWidth: 230,
transparent: true,
className: 'net-group-menu',
items: () => {
const node = moveMenuNode;
if (!node || groupsModel?.lens !== 'companies') return [];
const current = groupsModel.byPerson.get(node.id);
const items = groupsModel.groups.filter((group) => group.kind !== 'rest').map((group) => ({
label: group.caption,
selected: group.id === current,
disabled: group.id === current,
iconHtml: `<span class="net-group-dot" style="--group-color: var(--net-island-${group.color})"></span>`,
action: () => moveToCompany(node, group),
}));
items.push({
label: 'Без компании',
selected: current === REST_GROUP,
disabled: current === REST_GROUP,
iconHtml: '<span class="net-group-dot net-group-dot--rest"></span>',
action: () => moveToCompany(node, groupsModel.byId.get(REST_GROUP) || { id: REST_GROUP, label: 'Без компании', members: [] }),
}, { divider: true }, {
label: 'Новая компания…',
iconHtml: iconHtml('plus'),
action: () => openNewCompanySheet(node),
});
return items;
},
});
function openMoveMenu(node, button) {
moveMenuNode = node;
const rect = button.getBoundingClientRect();
const host = stage.getBoundingClientRect();
moveMenuAnchor.style.top = `${rect.top - host.top}px`;
moveMenuAnchor.style.left = `${rect.right - host.left}px`;
moveMenu.open();
}
// --- раскладки ---
// Своя раскладка – у каждой карты своя; если у этой карты её нет, видна последняя
// выбранная автоматическая.
function currentLayout() {
const key = normKey(centerLogin);
if (layoutMode === 'manual' && hasManualLayout(key)) {
return { id: 'manual', mode: getManualBase(key), manual: getManualLayout(key) };
}
const mode = layoutMode === 'manual' ? getAutoLayoutMode() : layoutMode;
return { id: mode, mode, manual: new Map() };
}
function changeLayoutMode(mode) {
if (mode === currentLayout().id) return;
layoutMode = mode;
setLayoutMode(mode);
if (selectedGroupId && !selectedInterest) selectGroup('');
selectedGroupId = '';
renderMap({ relayout: true, fit: true });
}
// Человека перетащили. Над другой компанией – он переходит в неё. Иначе в своей раскладке
// запоминаем его место, а в автоматической вся картина становится своей раскладкой этой
// карты (прежнюю можно вернуть «Отменить»).
function onNodeMoved(node, point, { group = '' } = {}) {
const key = normKey(centerLogin);
const layout = currentLayout();
const target = group && groupsModel?.lens === 'companies' ? groupsModel.byId.get(group) : null;
if (target) {
moveToCompany(node, target, { point });
return;
}
if (layout.id === 'manual') {
setManualPoint(key, node.id, point);
return;
}
const points = engine.getPositions();
points.set(node.id, point);
const previousMode = layoutMode;
const previous = saveManualLayout(key, points, layout.mode);
layoutMode = 'manual';
setLayoutMode('manual');
renderMap();
showToast(previous ? 'Своя раскладка заменена этой' : 'Сохранено как своя раскладка', {
kind: 'info',
timeoutMs: 5000,
action: {
label: 'Отменить',
onClick: () => {
if (disposed || normKey(centerLogin) !== key) return;
restoreManualLayout(key, previous);
layoutMode = previousMode;
setLayoutMode(previousMode);
renderMap({ relayout: true });
},
},
});
}
function deleteManualLayout() {
const key = normKey(centerLogin);
const removed = clearManualLayout(key);
renderMap({ relayout: true, fit: true });
showToast('Своя раскладка удалена', {
kind: 'info',
timeoutMs: 5000,
action: {
label: 'Вернуть',
onClick: () => {
if (disposed || normKey(centerLogin) !== key) return;
restoreManualLayout(key, removed);
layoutMode = 'manual';
setLayoutMode('manual');
renderMap({ relayout: true, fit: true });
},
},
});
}
function changeListSort(sort) {
if (sort === listSort) return;
listSort = sort;
setViewSetting('listSort', sort);
renderList();
list.scrollTop = 0;
ensureLensData();
}
// --- фильтры: «Все / Близкие / Друзья / Контакты» – тем же переключателем, что в чатах;
// реже нужное («Добавили вас», «Сияющие», «С заметкой», «Друзья друзей») – в «Ещё».
const PRIMARY_FILTERS = ['all', 'close', 'friends', 'contacts'];
const EXTRA_FILTERS = [
{ id: 'incoming', short: 'Добавили', icon: 'user-plus' },
{ id: 'shining', short: 'Сияющие', icon: 'sparkle' },
{ id: 'notes', short: 'С заметкой', icon: 'edit' },
];
const filterBar = document.createElement('div');
filterBar.className = 'net-filters';
filterBar.addEventListener('pointerdown', (event) => event.stopPropagation());
const filterTabs = document.createElement('div');
filterTabs.className = 'tabs tabs--auto tabs--dense net-filters__tabs';
filterTabs.setAttribute('role', 'radiogroup');
filterTabs.setAttribute('aria-label', 'Кого показывать');
filterBar.append(filterTabs);
const filterButtons = new Map();
for (const id of PRIMARY_FILTERS) {
const button = document.createElement('button');
button.type = 'button';
button.className = 'tab-btn';
button.dataset.filter = id;
button.setAttribute('role', 'radio');
button.textContent = FILTER_BY_ID.get(id).label;
button.addEventListener('click', () => setFilter(id));
filterButtons.set(id, button);
filterTabs.append(button);
}
const moreFilter = document.createElement('button');
moreFilter.type = 'button';
moreFilter.className = 'tab-btn net-filters__more';
filterTabs.append(moreFilter);
filterTabs.addEventListener('keydown', (event) => {
if (event.key !== 'ArrowLeft' && event.key !== 'ArrowRight') return;
const visible = PRIMARY_FILTERS.filter((id) => !filterButtons.get(id).hidden);
const index = Math.max(0, visible.indexOf(filterId));
const next = visible[(index + (event.key === 'ArrowRight' ? 1 : -1) + visible.length) % visible.length];
setFilter(next);
filterButtons.get(next)?.focus();
event.preventDefault();
});
function filterCounts() {
const direct = (map?.nodes || []).filter((node) => node.tier === 1 && node.id !== map.focusId);
const everyone = (map?.nodes || []).filter((node) => node.id !== map?.focusId);
const counts = new Map();
for (const filter of FILTERS) {
const pool = filter.direct ? direct : everyone;
counts.set(filter.id, filter.pred ? pool.filter(filter.pred).length : direct.length);
}
return counts;
}
const moreMenu = createDropdownMenu({
anchorEl: moreFilter,
minWidth: 236,
placement: 'bottom-end',
items: () => {
const counts = filterCounts();
const items = EXTRA_FILTERS
.filter(({ id }) => !(FILTER_BY_ID.get(id).selfOnly && !isSelfCenter()))
.map(({ id, icon }) => {
const selected = filterId === id;
const n = counts.get(id) || 0;
return {
label: `${FILTER_BY_ID.get(id).label} · ${n}`,
selected,
disabled: !n && !selected,
iconHtml: iconHtml(selected ? 'check' : icon),
action: () => setFilter(selected ? 'all' : id),
};
});
items.push({ divider: true }, interestMenuItem(), {
label: 'Друзья друзей',
hint: friendsOfFriends ? 'Показаны – нажмите, чтобы скрыть' : 'Кто дружит с вашими друзьями',
selected: friendsOfFriends,
iconHtml: iconHtml(friendsOfFriends ? 'check' : 'network'),
action: toggleFriendsOfFriends,
});
return items.filter(Boolean);
},
});
// «Читают канал ›»: подсветить читателей любого канала, который читают хотя бы двое.
// Подписки ещё не узнавали – пункт запускает их сбор.
function interestMenuItem() {
if (!map || map.nodes.length <= 2) return null;
const subs = getSubs(normKey(centerLogin));
const people = directPeople();
if (!subs || coverage('subs', subs, people.slice(0, PEOPLE_DATA_LIMIT)) < 0.8) {
const loading = lensLoads.has(`subs|${normKey(centerLogin)}`);
return {
label: 'Читают канал',
hint: loading ? 'Узнаю подписки…' : 'Узнать, кто что читает',
disabled: loading,
iconHtml: iconHtml('channels'),
action: () => {
void loadPeopleData('subs', { force: true }).then((ok) => {
if (!ok || disposed) return;
showToast('Подписки узнаны', { kind: 'info', timeoutMs: 5000, action: { label: 'Выбрать канал', onClick: () => { if (!disposed) moreMenu.open(); } } });
});
},
};
}
const channels = topChannels(people.map((node) => node.id), { limit: 40 });
if (!channels.length) return null;
return {
label: 'Читают канал',
hint: selectedInterest ? (subs.info.get(selectedInterest)?.name || '') : 'Подсветить читателей',
iconHtml: iconHtml(selectedInterest ? 'check' : 'channels'),
submenu: channels.map((item) => ({
label: `${item.name} · ${item.count}`,
selected: item.key === selectedInterest,
iconHtml: iconHtml(item.key === selectedInterest ? 'check' : 'channels'),
action: () => (item.key === selectedInterest ? clearInterest() : selectInterest(item.key)),
})),
};
}
function setFilter(id) {
filterId = FILTER_BY_ID.has(id) ? id : 'all';
// «Все» – и без подсветки интереса.
if (filterId === 'all' && selectedInterest) {
selectedInterest = '';
selectedGroupId = '';
renderCard();
applySelectionHighlight();
}
engine.setFilter(filterPredicate());
engine.fit();
const selected = selectedId ? map?.byId.get(selectedId) : null;
if (selected && selectedId !== map.focusId && filterPredicate() && !filterPredicate()(selected)) selectNode('');
syncFilters();
syncStateMessage();
if (viewMode === 'list') {
renderList();
list.scrollTop = 0;
}
persist();
}
function syncFilters() {
const counts = filterCounts();
for (const id of PRIMARY_FILTERS) {
const button = filterButtons.get(id);
const selected = id === filterId;
// Пустую группу не показываем (кроме выбранной и «Все»).
button.hidden = !selected && id !== 'all' && Boolean(map) && !counts.get(id);
button.setAttribute('aria-checked', selected ? 'true' : 'false');
}
const extra = EXTRA_FILTERS.find(({ id }) => id === filterId);
// Подсвеченный интерес – тоже на «Ещё» (название канала): видно, что подсветка включена.
const interestName = selectedInterest ? (getSubs(normKey(centerLogin))?.info.get(selectedInterest)?.name || '') : '';
moreFilter.classList.toggle('active', Boolean(extra || interestName));
// Точка на «Ещё» – включено что-то из меню (друзья друзей), а на самой кнопке этого не видно.
moreFilter.classList.toggle('has-dot', !extra && !interestName && friendsOfFriends);
moreFilter.innerHTML = `<span class="net-filters__more-label"></span>${iconHtml('chevron-down')}`;
moreFilter.querySelector('.net-filters__more-label').textContent = interestName || (extra ? extra.short : 'Ещё');
moreFilter.setAttribute('aria-label', interestName
? `Подсвечены читатели канала «${interestName}». Другие фильтры`
: extra
? `${FILTER_BY_ID.get(extra.id).label}. Другие фильтры`
: `Другие фильтры${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;
}
ensureLensData();
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: [
canAnswerBack(node)
? { icon: 'user-plus', label: answerBackLabel(node), primary: true, busy: answering.has(node.id), onClick: () => { void answerBack(node); } }
: null,
{ 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 matchesPeopleQuery(`${node.name} ${node.login} ${node.firstName || ''} ${node.lastName || ''}`, query);
}
function listGroups(people) {
const byName = (a, b) => a.name.localeCompare(b.name, 'ru');
if (selectedInterest) {
const name = getSubs(normKey(centerLogin))?.info.get(selectedInterest)?.name || '';
const byCloseness = (a, b) => (RELATION_RANK[a.relationType] ?? 9) - (RELATION_RANK[b.relationType] ?? 9) || byName(a, b);
return [{ title: `Читают «${name}»`, items: [...people].sort(byCloseness), interest: true }];
}
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 model = LENS_MODES.has(listSort) ? (groupsModel?.lens === listSort ? groupsModel : computeGroups(listSort)) : null;
if (model) {
const byCloseness = (a, b) => (RELATION_RANK[a.relationType] ?? 9) - (RELATION_RANK[b.relationType] ?? 9) || byName(a, b);
const shown = new Map(people.map((node) => [node.id, node]));
return [
...model.groups.map((group) => ({
title: group.label, group, items: group.members.map((id) => shown.get(id)).filter(Boolean).sort(byCloseness),
})),
{ title: 'Друзья друзей', items: people.filter((node) => node.tier > 1).sort(byName) },
].filter((section) => section.items.length);
}
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 readers = selectedInterest ? new Set(channelReaders(selectedInterest)) : null;
const people = map.nodes.filter((node) => node.id !== map.focusId && (!pred || pred(node)) && (!readers || readers.has(node.id)) && matchesQuery(node, query));
const frag = document.createDocumentFragment();
const withType = listSort === 'name' || Boolean(query);
for (const group of listGroups(people)) {
const section = createListSection(group.letter ? group.title : `${group.title} · ${group.items.length}`);
if (group.group) {
section.dataset.group = group.group.id;
section.classList.add('net-list-section');
section.prepend(groupDot(group.group));
}
frag.append(section);
// Длинный «Добавили вас» не должен закрывать собой весь список: сначала трое.
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 = restoreListScroll || scrollTop;
restoreListScroll = 0;
}
// --- поиск ---
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 || groupSheet || document.querySelector('.dropdown-portal, .modal'));
if (event.key === 'Escape') {
if (overlayOpen || search) return;
if (selectedId) selectNode('');
else if (selectedGroupId || selectedInterest) clearInterest();
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();
engine.refitIfAuto();
}) : null;
overlayObserver?.observe(stage);
overlayObserver?.observe(filterBar);
screen.cleanup = () => {
if (disposed) return;
disposed = true;
if (map) {
persisted.view = engine.getView();
persisted.listScroll = viewMode === 'list' ? list.scrollTop : 0;
}
engine.destroy();
overlayObserver?.disconnect();
rowMenu.destroy();
moveMenu.destroy();
moreMenu.destroy();
window.cancelAnimationFrame(listFrame);
window.clearTimeout(remoteTimer);
window.removeEventListener(PEOPLE_NOTES_EVENT, onNotesChanged);
document.removeEventListener('keydown', onKeydown);
noteSheet?.close();
legendSheet?.close();
groupSheet?.close();
if (search) {
const { layer } = search;
search = null;
layer?.close();
}
};
syncModePill();
board.hidden = viewMode !== 'map';
zoomBar.hidden = viewMode !== 'map';
syncFilters();
syncHeader({ force: true });
stage.append(board, list, filterBar, overlay, busyPill, zoomBar, modePill, card, searchPanel, rowMenuAnchor, moveMenuAnchor, a11yList);
screen.append(stage);
persist();
if (centerLogin) void load(centerLogin);
else syncStateMessage();
return screen;
}