SHA256
2385 lines
109 KiB
JavaScript
2385 lines
109 KiB
JavaScript
// Экран «Связи»: люди вокруг выбранного человека – картой или списком.
|
||
// Данные – 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 { getConnectionsGraphCached as loadSharedGraph, cachedConnectionsGraph as getCachedSharedGraph, CONNECTIONS_GRAPH_CHANGED, CONNECTIONS_GRAPH_TTL_MS } from '../services/connections-graph-cache.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 { 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, peopleDataGeneration, 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 outCloseFriends = toSet(graph?.outCloseFriends);
|
||
const inFriends = toSet(graph?.inFriends);
|
||
const inCloseFriends = toSet(graph?.inCloseFriends);
|
||
const allMarks = getMarkByLogin(graph?.allUsers);
|
||
|
||
// Граф показывает только тех, кого владелец сам выбрал другом.
|
||
// Входящие друзья нужны лишь для проверки взаимности, контакты и подписки исключены.
|
||
const allLogins = uniqueLogins([
|
||
...(graph?.outCloseFriends || []),
|
||
...(graph?.outFriends || []),
|
||
]).filter((entry) => normKey(entry) !== normKey(login));
|
||
|
||
const relations = allLogins.map((targetLogin) => ({
|
||
login: targetLogin,
|
||
key: normKey(targetLogin),
|
||
role: 'friend',
|
||
relationType: hasLogin(outCloseFriends, targetLogin) ? 'close_friend' : 'friend',
|
||
isRelative: false,
|
||
forward: true,
|
||
backward: hasLogin(inCloseFriends, targetLogin) || hasLogin(inFriends, targetLogin),
|
||
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 cachedGraph = (login) => getCachedSharedGraph(authService, login);
|
||
const getConnectionsGraphCached = (login, options) => loadSharedGraph(authService, login, options);
|
||
|
||
// Поиск без учёта регистра и «ё».
|
||
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) {
|
||
return node.direction === 'out' ? 'без ответа' : 'взаимно';
|
||
}
|
||
|
||
// Переживает уход с экрана: возврат по «Связям» из профиля показывает ту же карту.
|
||
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: 'shining', label: 'Сияющие', pred: (node) => Boolean(node.shining) },
|
||
];
|
||
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, ties = null) {
|
||
const centerKey = normKey(centerLogin);
|
||
const centerModel = graphs.get(centerKey);
|
||
if (!centerModel) return null;
|
||
const byId = new Map();
|
||
const edges = [];
|
||
const add = (node) => {
|
||
byId.set(node.id, { ...node, 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';
|
||
const graphs = new Map();
|
||
const expanding = new Set();
|
||
let map = null;
|
||
let selectedId = '';
|
||
let disposed = false;
|
||
let loadSeq = 0;
|
||
let loadError = null;
|
||
let legendSheet = null;
|
||
let search = null; // { query, topbar, layer, remote: { seq, query, items, loading, failed } }
|
||
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, 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 ? ', сияющий' : ''}`;
|
||
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);
|
||
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 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)}`)));
|
||
}
|
||
card.append(actions);
|
||
if (node.hiddenCount > 0) {
|
||
const more = document.createElement('p');
|
||
more.className = 'net-card__hint';
|
||
more.textContent = `Ещё ${node.hiddenCount} – все видны на его карте («В центр»).`;
|
||
card.append(more);
|
||
}
|
||
}
|
||
placeOverlays();
|
||
}
|
||
|
||
|
||
// --- обозначения ---
|
||
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', 'Друг'],
|
||
['dash', 'friend', 'Пунктир → точки – вы добавили друга, ответа пока нет'],
|
||
['aura', '', 'Свечение вокруг – сияющий'],
|
||
['badge', '', 'Синяя галочка – официальный аккаунт'],
|
||
];
|
||
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 generationAtStart = peopleDataGeneration();
|
||
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;
|
||
if (relation.forward) near.set(relation.key, { type: relationTypeFromRelation(relation), mutual: 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();
|
||
});
|
||
if (lensLoads.get(jobKey) === job) lensLoads.delete(jobKey);
|
||
// Прежняя пачка данных могла закончиться уже после изменения дружбы.
|
||
if (disposed || generationAtStart !== peopleDataGeneration()) return false;
|
||
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();
|
||
}
|
||
|
||
// Состав по близости: здесь считаются только друзья.
|
||
function compositionText(members) {
|
||
const counts = { close: 0, friend: 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;
|
||
});
|
||
const parts = [];
|
||
if (counts.close) parts.push(`${counts.close} ${pluralRu(counts.close, 'близкий', 'близких', 'близких')}`);
|
||
if (counts.friend) parts.push(`${counts.friend} ${pluralRu(counts.friend, 'друг', 'друга', 'друзей')}`);
|
||
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'];
|
||
const EXTRA_FILTERS = [
|
||
{ id: 'shining', short: 'Сияющие', icon: 'sparkle' },
|
||
];
|
||
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('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 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(' · '),
|
||
ring: node.shining ? 'shining' : (node.relationType === 'close_friend' && node.tier === 1 ? 'close' : ''),
|
||
tag: '',
|
||
onClick: onOpen || (() => {
|
||
if (search) closeSearch();
|
||
navigate(profileRoute(node.login));
|
||
}),
|
||
actions: [
|
||
{ icon: 'message', label: 'Написать', onClick: () => navigate(`chat/${encodeURIComponent(node.login)}`) },
|
||
{ icon: 'more', label: 'Ещё', onClick: (event, button) => openRowMenu(node, button) },
|
||
],
|
||
});
|
||
}
|
||
|
||
function matchesQuery(node, query) {
|
||
if (!query) return true;
|
||
return 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 rest = direct;
|
||
return [
|
||
{ 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: 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);
|
||
group.items.forEach((node) => frag.append(personRow(node, { withType })));
|
||
}
|
||
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(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);
|
||
|
||
function refreshConnectionsView() {
|
||
if (disposed || !centerLogin) return;
|
||
// Полный сброс отображаемых графов; запросы заново заполняют общий кэш.
|
||
graphs.clear();
|
||
lensLoads.clear();
|
||
lensBlockedUntil.clear();
|
||
groupsModel = null;
|
||
if (map) restoreView = engine.getView();
|
||
void load(centerLogin);
|
||
}
|
||
window.addEventListener(CONNECTIONS_GRAPH_CHANGED, refreshConnectionsView);
|
||
const graphRefreshTimer = window.setInterval(() => {
|
||
// TTL сам по себе не перерисовывает уже открытую карту — обновляем её при активности вкладки.
|
||
if (!disposed && !document.hidden) refreshConnectionsView();
|
||
}, CONNECTIONS_GRAPH_TTL_MS);
|
||
|
||
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(CONNECTIONS_GRAPH_CHANGED, refreshConnectionsView);
|
||
window.clearInterval(graphRefreshTimer);
|
||
document.removeEventListener('keydown', onKeydown);
|
||
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;
|
||
}
|