community: Discover ranks the shelves it already has into one, and every card still says where it came from

src/lib/discover.js

@@ -0,0 +1,165 @@
+// Discover's ranked shelf: one list across the signals the page already
+// draws in silos — the room you are in, the people your transfers touched,
+// the server's similar-interests answer, the library overlaps computed on
+// this device, the roster of the Space you have open. Nothing here reads
+// the network; every input is a store the page holds already.
+//
+// The page's rule holds: every shelf says where its people came from. A
+// ranked card is not exempt — its `reasons` are the shelves it drew from,
+// strongest first, and the template names each one. Contacts and friends
+// are left out: this is for people you have not sorted yet.
+//
+// The weights are the whole opinion, in one place so they can be argued
+// with. Each signal is capped so one huge browse cannot bury everything.
+
+export const WEIGHTS = {
+    /** Per album you both own (overlap), up to `CAPS.albums`. */
+    albumInCommon: 3,
+    /** Per album of theirs by an artist you follow that you lack. */
+    gap: 1,
+    /** Per artist in common, only when no album is (a weaker overlap). */
+    artistInCommon: 0.5,
+    /** Per declared like the server says you share. */
+    like: 2,
+    /** In the room you are looking at right now. */
+    activeRoom: 2,
+    /** Per other joined room they are in. */
+    room: 1,
+    /** Per file, either direction, this session. */
+    transfer: 1,
+    /** A seat beside yours in the open Space. */
+    spaceMember: 3,
+};
+export const CAPS = { albums: 10, gaps: 10, artists: 10, rooms: 3, transfers: 5 };
+
+const cap = (n, max) => Math.min(Math.max(n ?? 0, 0), max);
+
+/**
+ * @param {object} input
+ * @param {string} input.me            our own username (never listed)
+ * @param {(u: string) => boolean} [input.skip]  contacts, friends — people already sorted
+ * @param {Record<string, {users: {username: string}[]}>} [input.rooms]  joined rooms by name
+ * @param {string|null} [input.activeRoom]
+ * @param {{username?: string}[]} [input.downloads]   this session's downloads
+ * @param {{username?: string}[]} [input.uploads]     this session's uploads
+ * @param {{username: string, rating: number}[]} [input.similar]
+ * @param {{username: string, albums_in_common_count?: number, gaps_count?: number, artists_in_common_count?: number}[]} [input.overlap]
+ * @param {{name: string, members: {username?: string|null, is_me?: boolean}[]}|null} [input.space]  the open Space
+ * @param {number} [input.limit]
+ * @returns {{username: string, score: number, reasons: object[]}[]} best first
+ */
+export function rankPeople(input) {
+    const { me = "", skip = () => false, limit = 12 } = input;
+    const people = new Map();
+    const at = (u) => {
+        if (!u || u === me || skip(u)) return null;
+        let p = people.get(u);
+        if (!p) people.set(u, (p = { username: u, score: 0, reasons: [] }));
+        return p;
+    };
+    const add = (u, points, reason) => {
+        const p = at(u);
+        if (!p || points <= 0) return;
+        p.score += points;
+        p.reasons.push({ ...reason, points });
+    };
+
+    for (const o of input.overlap ?? []) {
+        const albums = cap(o.albums_in_common_count, CAPS.albums);
+        const gaps = cap(o.gaps_count, CAPS.gaps);
+        const artists = albums ? 0 : cap(o.artists_in_common_count, CAPS.artists);
+        const points = albums * WEIGHTS.albumInCommon + gaps * WEIGHTS.gap + artists * WEIGHTS.artistInCommon;
+        add(o.username, points, {
+            kind: "overlap",
+            albums: o.albums_in_common_count ?? 0,
+            gaps: o.gaps_count ?? 0,
+            artists: o.artists_in_common_count ?? 0,
+        });
+    }
+
+    for (const su of input.similar ?? []) {
+        add(su.username, (su.rating ?? 0) * WEIGHTS.like, { kind: "likes", n: su.rating ?? 0 });
+    }
+
+    // Rooms: the one on screen counts most; the rest count once each.
+    const roomsOf = new Map();
+    for (const [name, room] of Object.entries(input.rooms ?? {})) {
+        for (const u of room?.users ?? []) {
+            if (!u?.username) continue;
+            if (!roomsOf.has(u.username)) roomsOf.set(u.username, []);
+            roomsOf.get(u.username).push(name);
+        }
+    }
+    for (const [u, names] of roomsOf) {
+        const active = input.activeRoom && names.includes(input.activeRoom) ? input.activeRoom : null;
+        const others = names.filter((n) => n !== active);
+        const points = (active ? WEIGHTS.activeRoom : 0) + cap(others.length, CAPS.rooms) * WEIGHTS.room;
+        add(u, points, { kind: "rooms", active, others });
+    }
+
+    const tally = new Map();
+    const count = (u, side) => {
+        if (!u) return;
+        if (!tally.has(u)) tally.set(u, { from: 0, to: 0 });
+        tally.get(u)[side] += 1;
+    };
+    for (const d of input.downloads ?? []) count(d?.username, "from");
+    for (const x of input.uploads ?? []) count(x?.username, "to");
+    for (const [u, t] of tally) {
+        add(u, cap(t.from + t.to, CAPS.transfers) * WEIGHTS.transfer, { kind: "transfers", from: t.from, to: t.to });
+    }
+
+    const space = input.space;
+    for (const m of space?.members ?? []) {
+        if (!m?.username || m.is_me) continue;
+        add(m.username, WEIGHTS.spaceMember, { kind: "space", name: space.name });
+    }
+
+    const out = [...people.values()].filter((p) => p.score > 0);
+    // Reasons strongest first; a tie keeps the order the signals were read
+    // in above, which is the order of how much each one says about taste.
+    for (const p of out) p.reasons.sort((a, b) => b.points - a.points);
+    out.sort((a, b) => b.score - a.score || a.reasons.length - b.reasons.length || a.username.localeCompare(b.username));
+    return out.slice(0, limit);
+}
+
+/** A reason as the card draws it: segments, the numbers and names bold.
+ *  The wording is each source shelf's own, so a reason reads the same here
+ *  as where it came from. */
+export function reasonParts(r) {
+    const b = (t) => ({ t: String(t), b: true });
+    const t = (s) => ({ t: s, b: false });
+    const n = (k, one, many) => [b(k), t(` ${k === 1 ? one : many}`)];
+    switch (r.kind) {
+        case "overlap":
+            if (r.albums) return [t("shares "), ...n(r.albums, "album", "albums"), t(" you own"), ...(r.gaps ? [t(" · "), b(r.gaps), t(" you lack")] : [])];
+            if (r.artists) return [...n(r.artists, "artist", "artists"), t(" in common"), ...(r.gaps ? [t(" · "), b(r.gaps), t(" albums you lack")] : [])];
+            return [t("browsed, nothing in common")];
+        case "likes":
+            return [t("shares "), b(r.n), t(" of your declared likes")];
+        case "rooms": {
+            const parts = [];
+            if (r.active) parts.push(t("in "), b(`#${r.active}`), t(" now"));
+            if (r.others.length) {
+                if (parts.length) parts.push(t(" · "));
+                if (r.others.length === 1) parts.push(t("also in "), b(`#${r.others[0]}`));
+                else parts.push(t("in "), b(r.others.length), t(" rooms with you"));
+            }
+            return parts;
+        }
+        case "transfers": {
+            const parts = [];
+            if (r.from) parts.push(t("sent you "), ...n(r.from, "file", "files"));
+            if (r.from && r.to) parts.push(t(" · "));
+            if (r.to) parts.push(t("you sent them "), b(r.to));
+            return parts;
+        }
+        case "space":
+            return [t("with you in "), b(r.name)];
+        default:
+            return [];
+    }
+}
+
+/** A reason in words — what a test reads, and what the card says. */
+export const reasonText = (r) => reasonParts(r).map((s) => s.t).join("");