SHA256
205 lines
9.6 KiB
JavaScript
205 lines
9.6 KiB
JavaScript
// V3: исследованный (не ограниченный историей центров) граф и видимый BFS-срез.
|
|
// Храним исходящие дружеские связи с направлением; расстояние для карты считаем
|
|
// по неориентированному представлению только уже обнаруженных рёбер.
|
|
export const EXPLORER_MAX_DEPTH = 4;
|
|
export const EXPLORER_DEFAULT_DEPTH = 1;
|
|
export const keyOf = (value) => String(value || '').trim().toLowerCase();
|
|
|
|
const isFriend = (type) => type === 'friend' || type === 'close_friend';
|
|
|
|
function decorate(row, fallback) {
|
|
const login = String(row?.login || fallback || '').trim();
|
|
const avatar = row?.avatar?.ar || row?.avatar?.sha256Hex
|
|
? { ar: String(row.avatar.ar || ''), sha256Hex: String(row.avatar.sha256Hex || row.avatar.sha256 || '') }
|
|
: (row?.avatarTxId ? { ar: String(row.avatarTxId) } : null);
|
|
return {
|
|
login,
|
|
name: [row?.firstName, row?.lastName].filter(Boolean).join(' ').trim() || login,
|
|
avatar,
|
|
shining: row?.shine === true || row?.shine === 'true' || row?.shineStatus === 'shining',
|
|
official: row?.official === true || row?.official === 'true' || row?.accountRole === 'primary',
|
|
shineKnown: row?.shine !== undefined || row?.shineStatus !== undefined,
|
|
officialKnown: row?.official !== undefined || row?.accountRole !== undefined,
|
|
};
|
|
}
|
|
|
|
export function createExplorerGraph() {
|
|
const graphs = new Map(); // известные полные исходящие списки
|
|
const people = new Map();
|
|
const edges = new Map(); // owner -> friend (направленные)
|
|
const updatedAt = new Map();
|
|
|
|
function remember(row, fallback) {
|
|
const data = decorate(row, fallback);
|
|
const id = keyOf(data.login);
|
|
if (!id) return;
|
|
const previous = people.get(id);
|
|
if (!previous) people.set(id, data);
|
|
else people.set(id, {
|
|
login: previous.login || data.login,
|
|
name: data.name && data.name !== data.login ? data.name : previous.name,
|
|
avatar: data.avatar || previous.avatar,
|
|
shining: data.shineKnown ? data.shining : previous.shining,
|
|
official: data.officialKnown ? data.official : previous.official,
|
|
shineKnown: previous.shineKnown || data.shineKnown,
|
|
officialKnown: previous.officialKnown || data.officialKnown,
|
|
});
|
|
}
|
|
|
|
function add(graph, fallbackLogin, savedAt = Date.now()) {
|
|
const login = String(graph?.login || fallbackLogin || '').trim();
|
|
const owner = keyOf(login);
|
|
if (!owner) return;
|
|
remember({ login }, login);
|
|
(Array.isArray(graph?.allUsers) ? graph.allUsers : []).forEach((row) => remember(row));
|
|
// Если граф обновился, старые исходящие рёбра этого владельца больше не действуют.
|
|
for (const edgeKey of edges.keys()) if (edgeKey.startsWith(`${owner}\u0000`)) edges.delete(edgeKey);
|
|
const close = new Set((graph?.outCloseFriends || []).map(keyOf));
|
|
const inboundClose = new Set((graph?.inCloseFriends || []).map(keyOf));
|
|
const inbound = new Set([...(graph?.inFriends || []), ...inboundClose].map(keyOf));
|
|
// Сохраняем оригинальный регистр логина для серверного API (ключи графа
|
|
// нормализуем независимо, только для сопоставления вершин).
|
|
const friendNames = new Map();
|
|
for (const raw of [...(graph?.outFriends || []), ...(graph?.outCloseFriends || [])]) {
|
|
const id = keyOf(raw);
|
|
if (id && id !== owner && !friendNames.has(id)) friendNames.set(id, String(raw).trim());
|
|
}
|
|
const friends = new Set(friendNames.keys());
|
|
for (const id of friends) {
|
|
remember({ login: friendNames.get(id) }, id);
|
|
edges.set(`${owner}\u0000${id}`, {
|
|
from: owner, to: id, type: close.has(id) ? 'close_friend' : 'friend',
|
|
reverseType: inboundClose.has(id) ? 'close_friend' : (inbound.has(id) ? 'friend' : null),
|
|
mutual: inbound.has(id),
|
|
});
|
|
}
|
|
graphs.set(owner, { login, friends, friendLogins: [...friendNames.values()] });
|
|
updatedAt.set(owner, savedAt);
|
|
}
|
|
|
|
function clear() {
|
|
graphs.clear(); people.clear(); edges.clear(); updatedAt.clear();
|
|
}
|
|
|
|
function getFriends(login) {
|
|
return graphs.get(keyOf(login))?.friendLogins || null;
|
|
}
|
|
|
|
function pruneExpired(now = Date.now()) {
|
|
for (const [id, savedAt] of updatedAt) {
|
|
if (savedAt <= now && now - savedAt < 24 * 60 * 60 * 1000) continue;
|
|
graphs.delete(id);
|
|
updatedAt.delete(id);
|
|
for (const edgeKey of edges.keys()) {
|
|
if (edgeKey.startsWith(`${id}\u0000`)) edges.delete(edgeKey);
|
|
}
|
|
}
|
|
}
|
|
|
|
function snapshot(centerLogin, { depth = EXPLORER_DEFAULT_DEPTH, x2 = false, close = false, shining = false } = {}) {
|
|
pruneExpired();
|
|
const center = keyOf(centerLogin);
|
|
if (!center) return { focusId: '', nodes: [], preserveHistory: true };
|
|
const radius = Math.max(0, Math.min(EXPLORER_MAX_DEPTH, Number(depth) || 0)) + (x2 ? 2 : 1);
|
|
const allowed = (id) => id === center || !shining || Boolean(people.get(id)?.shining);
|
|
const neighbors = new Map();
|
|
const eligibleEdges = [];
|
|
for (const edge of edges.values()) {
|
|
if (!isFriend(edge.type) || (close && edge.type !== 'close_friend')) continue;
|
|
if (!allowed(edge.from) || !allowed(edge.to)) continue;
|
|
eligibleEdges.push(edge);
|
|
if (!neighbors.has(edge.from)) neighbors.set(edge.from, new Set());
|
|
if (!neighbors.has(edge.to)) neighbors.set(edge.to, new Set());
|
|
neighbors.get(edge.from).add(edge.to);
|
|
neighbors.get(edge.to).add(edge.from);
|
|
}
|
|
const distances = new Map([[center, 0]]);
|
|
const queue = [center];
|
|
for (let i = 0; i < queue.length; i += 1) {
|
|
const from = queue[i];
|
|
const d = distances.get(from);
|
|
if (d >= radius) continue;
|
|
for (const to of neighbors.get(from) || []) {
|
|
if (distances.has(to)) continue;
|
|
distances.set(to, d + 1);
|
|
queue.push(to);
|
|
}
|
|
}
|
|
|
|
// Полностью раскрыт = его исходящий список известен, и ВСЕ разрешённые фильтрами
|
|
// друзья сейчас видимы. За границей глубины большой аватар становится маленьким.
|
|
const expanded = new Map();
|
|
const isExpanded = (id) => {
|
|
if (expanded.has(id)) return expanded.get(id);
|
|
const own = graphs.get(id);
|
|
if (!own) { expanded.set(id, false); return false; }
|
|
let complete = true;
|
|
for (const friend of own.friends) {
|
|
if (!allowed(friend)) continue;
|
|
if (close && edges.get(`${id}\u0000${friend}`)?.type !== 'close_friend') continue;
|
|
if (!distances.has(friend)) { complete = false; break; }
|
|
}
|
|
expanded.set(id, complete);
|
|
return complete;
|
|
};
|
|
|
|
const refs = new Map();
|
|
const edgePairs = new Set();
|
|
const immediateEdges = new Map();
|
|
for (const edge of eligibleEdges) {
|
|
if (!distances.has(edge.from) || !distances.has(edge.to)) continue;
|
|
if (!immediateEdges.has(edge.from)) immediateEdges.set(edge.from, edge);
|
|
if (!immediateEdges.has(edge.to)) immediateEdges.set(edge.to, edge);
|
|
const pair = [edge.from, edge.to].sort();
|
|
const pairKey = pair.join('\u0000');
|
|
if (edgePairs.has(pairKey)) continue;
|
|
edgePairs.add(pairKey);
|
|
// Линия одна на пару, направленность сохранена в исходном графе.
|
|
// Направленное ребро оставляем owner -> friend (не алфавитный порядок).
|
|
const child = edge.to;
|
|
const parent = edge.from;
|
|
const reverse = edges.get(`${edge.to}\u0000${edge.from}`);
|
|
// Периферийные маленькие пользователи не раскрывают собственные связи.
|
|
// Если оба конца сжаты из-за глубины, линия между ними не рисуется.
|
|
if (!isExpanded(edge.from) && !isExpanded(edge.to)) continue;
|
|
const detail = {
|
|
id: parent,
|
|
relationType: edge.type,
|
|
reverseRelationType: reverse?.type || edge.reverseType || null,
|
|
mutual: Boolean(edge.mutual || reverse),
|
|
strength: edge.type === 'close_friend' ? 0.9 : 0.55,
|
|
};
|
|
if (!refs.has(child)) refs.set(child, []);
|
|
refs.get(child).push(detail);
|
|
}
|
|
const nodes = [...distances].map(([id, d]) => {
|
|
const person = people.get(id) || { login: id, name: id };
|
|
const ownEdge = immediateEdges.get(id);
|
|
return {
|
|
id,
|
|
login: person.login,
|
|
name: person.name,
|
|
avatar: person.avatar || null,
|
|
shining: Boolean(person.shining),
|
|
official: Boolean(person.official),
|
|
relationType: id === center ? 'self' : (ownEdge?.type || 'friend'),
|
|
mutual: Boolean(ownEdge?.mutual),
|
|
strength: ownEdge?.type === 'close_friend' ? 0.9 : 0.55,
|
|
distance: d,
|
|
tier: 1, // фиксированная карта; размер определяется visualSmall, НЕ tier.
|
|
visualSmall: !isExpanded(id),
|
|
edgeParents: refs.get(id) || [],
|
|
keepVisible: id === center,
|
|
};
|
|
});
|
|
return { focusId: center, nodes, preserveHistory: true, radius };
|
|
}
|
|
|
|
return { add, clear, snapshot, getFriends, has: (login) => graphs.has(keyOf(login)),
|
|
isFresh: (login, now = Date.now()) => {
|
|
const saved = updatedAt.get(keyOf(login));
|
|
return saved != null && saved <= now && now - saved < 24 * 60 * 60 * 1000;
|
|
},
|
|
size: () => graphs.size };
|
|
}
|