Live arrivals on the sky da8f7826a645

 * New activity, as the page polled it (§5, "Live"): `{events: [[repo

 * name, kind, at_ms, n]]}`. Each joins its cluster with an arrival ring;

 * a scene other than the sky ignores it.

 * @param {any} data

 */

export function arrive(data) {

    wasm.arrive(data);

}

/**

        self.field.easing()

thread_local! {

    /// The running backdrop, for `arrive`.

    static RUNNING: RefCell<Option<(Rc<RefCell<Engine>>, Frame)>> = const { RefCell::new(None) };

}

}

/// New activity, as the page polled it (§5, "Live"): `{events: [[repo

/// name, kind, at_ms, n]]}`. Each joins its cluster with an arrival ring;

/// a scene other than the sky ignores it.

#[wasm_bindgen]

pub fn arrive(data: JsValue) {

    let Some((engine, frame)) = RUNNING.with(|r| r.borrow().clone()) else {

        return;

    };

    let mut any = false;

    // Oldest first, so the newest ends up newest.

    for v in js_sys::Array::from(&get(&data, "events")).iter().rev() {

        let e = js_sys::Array::from(&v);

        let (Some(repo), Some(kind)) = (e.get(0).as_string(), e.get(1).as_f64()) else {

            continue;

        };

        let n = e.get(3).as_f64().unwrap_or(1.0).max(1.0) as u32;

        engine.borrow_mut().scene.arrive(&repo, Kind::from_code(kind as u32), n);

        any = true;

    }

    if any {

        wake(&engine, &frame);

    }

    RUNNING.with(|r| *r.borrow_mut() = Some((engine.clone(), frame.clone())));

        self.field.easing()

        self.field.easing()

use crate::sky::{Colours, Kind};

    /// New activity in repository `repo` (§5, "Live"); only the sky shows it.

    fn arrive(&mut self, _repo: &str, _kind: Kind, _n: u32) {}

    /// Whether a frame would show anything new besides the drift, which

    /// the engine stops drawing a while after the last input (§6).

    fn arrive(&mut self, repo: &str, kind: Kind, n: u32) {

        crate::sky::Sky::arrive(self, repo, kind, n)

    }

/// An arrival's ring (§4): seconds it lasts, and its radius from first to

/// last, in CSS pixels before the zoom.

const RING_S: f32 = 1.2;

const RING_FROM: f32 = 6.0;

const RING_TO: f32 = 46.0;

/// A widening ring at a cluster's core: something just arrived there.

#[derive(Clone, Copy, Debug)]

pub struct Ring {

    pub cluster: usize,

    /// Seconds since it began.

    pub age: f32,

}

    /// Arrivals' rings, while they widen.

    pub rings: Vec<Ring>,

    /// Marks added since the page loaded, for their places in the lanes.

    arrived: u32,

        let mut sky = Sky {

            clusters,

            marks,

            w,

            h,

            cursor: None,

            rested: 0.0,

            still,

            avoid: None,

            parallax: [(0.0, 0.0); 3],

            link_fade: 0.0,

            rings: Vec::new(),

            arrived: 0,

        };

    }

    /// New activity in the repository `name` (§5, "Live"): its marks join

    /// its cluster as the newest, and one ring widens from its core. A

    /// repository the sky does not draw is ignored; a still sky adds the

    /// marks without the ring.

    pub fn arrive(&mut self, name: &str, kind: Kind, n: u32) {

        let Some(c) = self.clusters.iter().position(|cl| cl.name == name) else {

            return;

        };

        let add = if kind == Kind::Push { n.clamp(1, PER_PUSH) } else { 1 };

        for m in self.marks.iter_mut().filter(|m| m.cluster == c && m.kind != Kind::Repo) {

            m.order += add;

        }

        let have = self.marks.iter().filter(|m| m.cluster == c && m.kind != Kind::Repo).count() as u32;

        let lanes = (6 + (have + add) / 30).min(14);

        let dir = if hash(name) & 1 == 0 { 1.0 } else { -1.0 };

        for i in 0..add {

            let h = hash(&format!("{name}+{}", self.arrived));

            self.arrived += 1;

            let radius = (16.0 + ((have + i) % lanes) as f32 * 6.5 + unit(h, 0) * 4.0) * ZOOM;

            let speed = dir * (MAX_SPEED / radius).min(0.25) * (0.5 + 0.5 * unit(h, 16));

            self.marks.push(Mark { cluster: c, kind, order: add - 1 - i, radius, angle: unit(h, 32) * TAU, speed, bright: 1.0, lit: 0.0 });

        }

        // Over the limit, the cluster's oldest marks make room.

        while self.marks.len() > MAX_MARKS {

            let Some(oldest) = self

                .marks

                .iter()

                .enumerate()

                .filter(|(_, m)| m.cluster == c && m.kind != Kind::Repo)

                .max_by_key(|(_, m)| m.order)

                .map(|(i, _)| i)

            else {

                break;

            };

            self.marks.swap_remove(oldest);

        }

        if !self.still {

            self.rings.retain(|r| r.cluster != c);

            self.rings.push(Ring { cluster: c, age: 0.0 });

        }

        for r in &mut self.rings {

            r.age += dt;

        }

        self.rings.retain(|r| r.age < RING_S);

    /// Whether anything besides the drift is still changing: lighting,

    /// links or a ring. The engine keeps drawing a moving sky for a while

    /// after the last input anyway (§6), then stops until something is.

        !self.rings.is_empty() || self.marks.iter().any(|m| m.lit > 0.0 && m.lit < 1.0) || (self.link_fade > 0.0 && self.link_fade < 1.0)

        // Arrivals: a thin ring in the lit colour, widening as it fades.

        for r in &self.rings {

            let t = (r.age / RING_S).clamp(0.0, 1.0);

            let (x, y) = self.core(r.cluster);

            let size = (RING_FROM + (RING_TO - RING_FROM) * (1.0 - (1.0 - t) * (1.0 - t))) * ZOOM;

            let a = c.lit[3] * (1.0 - t) * 0.8;

            out.extend_from_slice(&[x, y, size, Kind::Repo.shape(), c.lit[0] * a, c.lit[1] * a, c.lit[2] * a, a]);

        }

    }

    #[test]

    fn an_arrival_joins_its_cluster_with_one_ring() {

        let mut s = sky(false);

        let before = s.marks.iter().filter(|m| m.cluster == 1).count();

        s.arrive("andy/oxygen", Kind::Push, 2);

        s.arrive("someone/else", Kind::Issue, 1);

        let marks: Vec<&Mark> = s.marks.iter().filter(|m| m.cluster == 1).collect();

        assert_eq!(marks.len(), before + 2, "a dot for each change pushed; an unknown repository adds nothing");

        let newest: Vec<&&Mark> = marks.iter().filter(|m| m.kind == Kind::Push).collect();

        assert!(newest.iter().all(|m| m.order < 2 && m.bright == 1.0), "the newest, at full brightness");

        assert!(marks.iter().any(|m| m.kind == Kind::Release && m.order == 2), "older marks move back");

        assert_eq!(s.rings.len(), 1);

        assert!(s.busy(), "a ring is drawn while it widens");

        let colours = Colours { lit: [0.0, 0.4, 0.9, 0.7], ..Default::default() };

        let mut inst = Vec::new();

        s.instances(&colours, &mut inst);

        assert_eq!(inst.len(), (s.marks.len() + 1) * 8, "the ring is one more instance");

        for _ in 0..80 {

            s.step(1.0 / 60.0);

        }

        assert!(s.rings.is_empty() && !s.busy(), "gone after 1.2 s, and nothing left to draw but the drift");

        // A still sky takes the marks without the ring.

        let mut still = sky(true);

        still.arrive("andy/hub", Kind::Release, 1);

        assert!(still.rings.is_empty());

        assert_eq!(still.marks.iter().filter(|m| m.kind == Kind::Release).count(), 2);

        self.field.easing()

fn sky_json(mine: &[db::repos::RepoRow], events: &[db::activity::SkyEvent], now: i64, live: &str) -> String {

    serde_json::json!({ "now": now, "repos": slugs, "events": evs, "live": live }).to_string().replace('<', "\\u003c")

/// The repositories a sky draws: `mine`, the viewer's own (member) ones,

/// as the dashboard's; `hub`, the public ones the viewer may see, as

/// Explore's. Never a private repository in the hub's sky.

async fn sky_repos(app: &Shared, shell: &Shell, viewer: &Viewer, scene: &str) -> Result<Vec<db::repos::RepoRow>, Error> {

    let db_err = |e| Error::from_db(shell.clone(), e);

    let seen = visible(app, shell, viewer, db::repos::list(&app.db).await.map_err(db_err)?).await?;

    match (scene, viewer.account()) {

        ("mine", Some(account)) => {

            let member: Vec<i64> = db::accounts::visible_repo_ids(&app.db, account.id).await.map_err(db_err)?;

            Ok(seen.into_iter().filter(|r| member.contains(&r.id)).collect())

        }

        ("hub", _) => {

            let mut public: Vec<db::repos::RepoRow> = seen.into_iter().filter(|r| r.visibility == "public").collect();

            public.sort_by_key(|r| std::cmp::Reverse(r.updated_ms));

            public.truncate(SKY_REPOS);

            Ok(public)

        }

        _ => Ok(Vec::new()),

    }

}

#[derive(Deserialize)]

pub struct ArrivalsQuery {

    #[serde(default)]

    scene: String,

    #[serde(default)]

    since: i64,

}

/// `GET /sky/arrivals?scene=mine|hub&since=MS` (docs/backgrounds.md §4,

/// "Arrivals"): what happened in a sky's repositories since `since`, by

/// repository name, for the page to add without reloading. The same

/// repositories as the sky it feeds, never more.

pub async fn arrivals(State(app): State<Shared>, viewer: Viewer, Query(q): Query<ArrivalsQuery>) -> Result<Response, Error> {

    let shell = Shell::new(&app, "/sky/arrivals", &viewer);

    let repos = sky_repos(&app, &shell, &viewer, &q.scene).await?;

    let now = db::now_ms();

    // At most a day back: a page left open longer starts again.

    let since = q.since.clamp(now - 86_400_000, now);

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

    let events = if ids.is_empty() {

        Vec::new()

    } else {

        db::activity::sky(&app.db, &ids, since + 1, 200).await.map_err(|e| Error::from_db(shell.clone(), e))?

    };

    let evs: Vec<serde_json::Value> = events

        .iter()

        .filter_map(|e| {

            let r = repos.iter().find(|r| r.id == e.repo_id)?;

            Some(serde_json::json!([format!("{}/{}", r.owner, r.name), e.kind, e.at_ms, e.n]))

        })

        .collect();

    let body = serde_json::json!({ "now": now, "events": evs });

    Ok(([(axum::http::header::CACHE_CONTROL, "private, no-store")], axum::Json(body)).into_response())

}

    let backdrop = sky_json(&mine, &sky, now, "mine");

    let backdrop = sky_json(&public, &sky, now, "hub");

        .route("/sky/arrivals", get(home::arrivals))

    // Live arrivals (#172): what happened since, by the sky's own rule.

    assert!(sky_of(&page.body).contains(r#""live":"mine""#) && hub_sky.contains(r#""live":"hub""#));

    let since = db::now_ms() - 3_600_000;

    let arrivals = |res: Res| -> Vec<String> {

        assert_eq!(res.status, StatusCode::OK, "{}", res.body);

        let v: serde_json::Value = serde_json::from_str(&res.body).unwrap();

        v["events"].as_array().unwrap().iter().map(|e| e[0].as_str().unwrap().to_string()).collect()

    };

    let mine = arrivals(get(app, &format!("/sky/arrivals?scene=mine&since={since}"), Some(&andy)).await);

    assert!(mine.iter().any(|r| r == "andy/demo") && mine.iter().any(|r| r == "andy/secret"), "{mine:?}");

    let hub = arrivals(get(app, &format!("/sky/arrivals?scene=hub&since={since}"), Some(&andy)).await);

    assert!(hub.iter().any(|r| r == "andy/demo") && !hub.iter().any(|r| r == "andy/secret"), "the hub's sky is public only: {hub:?}");

    let anon_hub = arrivals(get(app, &format!("/sky/arrivals?scene=hub&since={since}"), None).await);

    assert!(!anon_hub.iter().any(|r| r == "andy/secret"), "{anon_hub:?}");

    assert!(arrivals(get(app, &format!("/sky/arrivals?scene=mine&since={since}"), None).await).is_empty(), "signed out has no `mine`");

    assert!(

        arrivals(get(app, &format!("/sky/arrivals?scene=mine&since={since}"), Some(&bob)).await).is_empty(),

        "Bob's sky has none of Andy's"

    );

    assert!(

        arrivals(get(app, &format!("/sky/arrivals?scene=mine&since={}", db::now_ms()), Some(&andy)).await).is_empty(),

        "nothing since now"

    );

**Live.** Built (#172). The page's data names its sky (`"live": "mine"`

on the dashboard, `"hub"` on Explore and the signed-out home), and every

30 s while the page is shown it asks `GET /sky/arrivals?scene=…&since=MS`

what happened since (at most a day back). The answer is the same query

over the same repositories as the sky it feeds: the viewer's member

repositories for `mine` (nothing signed out), the public ones for `hub`,

never a private repository in the hub's sky; it is `private, no-store`.

Each event joins its cluster as the newest marks with an arrival ring

(§4), a thin ring in the lit colour widening from 6 to 46 px (times the

zoom) and fading over 1.2 s; a repository the sky does not draw is

ignored, and a still sky adds the marks without the ring. Nothing

reloads.

  the next movement or arrival (a scene's drift alone never keeps it

  running; lighting, links and rings do, while they change).

   leaves no backdrop and nothing else changed. A sky with `live` polls

   `/sky/arrivals` for what happened since and adds it. #}

    const data = JSON.parse(document.getElementById("backdrop-data").textContent);

    bd.start(canvas, data, pick === "still");

    // Live (§5): a sky that names its repositories (`mine` or `hub`) asks

    // every 30 s, while the page is shown, what happened since.

    if (data.live) {

      let since = data.now;

      const poll = async () => {

        if (document.hidden) return;

        try {

          const r = await fetch(`/sky/arrivals?scene=${data.live}&since=${since}`, { headers: { accept: "application/json" } });

          if (!r.ok) return;

          const got = await r.json();

          since = got.now;

          if (got.events.length) bd.arrive(got);

        } catch (e) {}

      };

      setInterval(poll, 30000);

      document.addEventListener("visibilitychange", poll);

    }