Profile pulse: the account's own span, fewer labels, neat chips a2fbad481dd7

/// last year, in repositories the viewer may see, with the share pushed

/// through agent tokens, per repository, and its releases to label peaks.

/// `{"start": MS, "repos": [NAME], "days": [[TOTAL, VIA, [[REPO, N]..]]..],

async fn pulse_json(app: &Shared, account: &db::accounts::Account, seen: &[db::repos::RepoRow]) -> sqlx::Result<(String, i64)> {

    let today = db::now_ms() / DAY_MS;

    let ids: Vec<i64> = seen.iter().map(|r| r.id).collect();

    let rows = db::activity::pulse(&app.db, account.id, &ids, first * DAY_MS).await?;

    let mut value = pulse;

    let mut peaks = Vec::new();

    for (repo_id, tag, at) in db::activity::releases_by(&app.db, account.id, &ids, first * DAY_MS).await? {

/// The days of a pulse from push rows `(repo_id, at_ms, changes, via)`:

/// repositories ordered by how much went to them, most first.

    let mut per_repo: std::collections::BTreeMap<i64, i64> = std::collections::BTreeMap::new();

    for (repo, _, n, _) in rows {

        *per_repo.entry(*repo).or_default() += n;

        .map(|(id, _)| seen.iter().find(|r| r.id == *id).map(|r| format!("{}/{}", r.owner, r.name)).unwrap_or_default())

        .collect();

    let slot = |id: i64| order.iter().position(|(r, _)| *r == id).unwrap_or(0);

    let mut total = 0;

    for (repo, at, n, via) in rows {

        let d = at / DAY_MS - first;

            continue;

        }

        let day = &mut days[d as usize];

    let app = &h.app;

    register(app, "andy", "").await;

    let andy = db::accounts::account_by_name(&app.db, "andy").await.unwrap().unwrap();

    let game = db::repos::create(&app.db, "andy", "game", "", hub_api::Visibility::Public).await.unwrap();

    let secret = db::repos::create(&app.db, "andy", "secret", "", hub_api::Visibility::Private).await.unwrap();

    let now = db::now_ms();

    assert_eq!((total, via), (11, 2), "5 + 2 + 4 changes, 2 via an agent; the landing and the private push left out");

    assert_eq!(days[361], serde_json::json!([7, 2, [[0, 7]]]), "three days ago");

    assert_eq!(json["peaks"][0], serde_json::json!([361, "game v1.0"]));

    assert!(

        page.contains("data-total=\"11\"") && page.find("pulse-box").unwrap() < page.find("<h2>Repositories</h2>").unwrap(),

        "above the repositories"

const el = (t, a, p) => { const e = document.createElementNS(NS, t); for (const k in a) e.setAttribute(k, a[k]); if (p) p.appendChild(e); return e; };

const PAL = 7, col = r => r < PAL ? `var(--pu${r + 1})` : "var(--pu8)";

const days = data.days.map((d, i) => ({ t: d[0], via: d[1], by: d[2], date: new Date(data.start + i * 864e5) }));

const s = el("svg", { viewBox: `0 0 ${W} ${H}`, role: "img", "aria-label": "Changes pushed each day over the last year" });

stage.prepend(s);

const defs = el("defs", {}, s);

const clip = el("clipPath", { id: "pu-clip" }, defs), clipRect = el("rect", { width: reduce ? W : 0, height: H }, clip);

const grid = el("g", {}, s), ylab = [];

for (let k = 0; k <= 4; k++) { const y = T + (base - T) * k / 4; el("line", { x1: L, x2: W - R, y1: y, y2: y, stroke: "var(--line)", "stroke-opacity": ".5" }, grid); ylab.push(el("text", { x: L - 6, y: y + 4, "text-anchor": "end", class: "pu-axis" }, grid)); }

const plot = el("g", { mask: "url(#pu-sm)", "clip-path": "url(#pu-clip)" }, s);

const area = el("path", { fill: "url(#pu-grad)", mask: "url(#pu-fm)" }, plot);

const line = el("path", { fill: "none", stroke: "url(#pu-grad)", "stroke-width": 2.2, "stroke-linejoin": "round", filter: "url(#pu-glow)" }, plot);

  const v = days.map(val), max = Math.max(1, ...v);

  ys = v.map(n => base - (base - T) * n / max);

  const d = smooth(ys.map((y, i) => [X(i), y]));

  viaLine.setAttribute("d", smooth(days.map((x, i) => [X(i), base - (base - T) * (only < 0 ? x.via : Math.round(val(x) * x.via / (x.t || 1))) / max])));

  grad.textContent = "";

  strip.textContent = "";

  days.forEach((x, i) => { if (!val(x)) return; el("rect", { x: X(i) - .9, y: base + 28, width: 1.8, height: 9, rx: .9, style: `fill:${col(only < 0 ? top(x) : only)}` }, strip); });

  ylab.forEach((t, k) => { t.textContent = Math.round(max * (4 - k) / 4); });

  peakG.textContent = "";

}

build();

// Legend: a repository's own year.

}

if (!reduce) {

  const t0 = performance.now();

  requestAnimationFrame(reveal);

}

// Pointer: spotlight, scan line and the day's card.

const fmt = d => d.toLocaleDateString("en-GB", { weekday: "short", day: "numeric", month: "short", year: "numeric", timeZone: "UTC" });

s.addEventListener("pointermove", e => {

  idle = false; beat.setAttribute("opacity", "0");

  const r = s.getBoundingClientRect(), x = (e.clientX - r.left) * (W / r.width);

  spotRect.setAttribute("fill", "url(#pu-spot)"); spot.setAttribute("gradientTransform", `translate(${X(i)} ${ys[i]}) scale(160 240)`);

  scan.setAttribute("x1", X(i)); scan.setAttribute("x2", X(i)); scan.setAttribute("opacity", ".45");

  dot.setAttribute("cx", X(i)); dot.setAttribute("cy", ys[i]); dot.style.stroke = col(only < 0 ? top(d) : only); dot.setAttribute("opacity", "1");

.pulse-box .card-head { flex-wrap: wrap; row-gap: 6px; }

.pulse-total { font-weight: 700; font-variant-numeric: tabular-nums; }

.pulse-legend { display: flex; flex-wrap: wrap; gap: 4px; }

.pulse-stage { position: relative; padding: 8px 12px 4px; }

.pulse-stage svg { width: 100%; height: auto; display: block; touch-action: pan-y; }

.pulse-stage .pu-axis { font: 10px var(--mono, ui-monospace, monospace); fill: var(--mute); }