@bongos/core 1.21.112 → 1.21.114

package/modules/hall-ui/public/gov-feeds.js

@@ -0,0 +1,141 @@
+// modules/hall-ui/public/gov-feeds.js — the governor's reads, ONCE per page view,
+// and the counts every surface prints (task 1004685, the living-city prototype).
+//
+// WHY. The city, the street, the decision deck and the shell's Governing tally
+// each read the governor feeds, and each used to read its own subset and count
+// for itself: the city said 24 on you, the street 37, the deck 38 and the shell
+// 9. Now there is one reader with one memo per page. city.js and street.js ask it
+// for the feeds they draw; the deck draws from the street's own living model, so
+// it reads nothing; the shell's tally asks for COUNT_FEEDS alone, which
+// tests/hall_gov_counts.mjs proves give the same counts as every feed. Every
+// number comes from GovLiving.countsOf (gov-living.js), with one plain label.
+//
+// THE PAGE'S OWN ANSWERS. An answer given on this page (a city card, the deck)
+// leaves every count at once: the page registers its session with useSession(),
+// and changed() tells every listener (the shell's tally, the page itself) to
+// count again. After an act that WRITES, refresh() drops the reads an act can
+// change (AFTER_ACT), so the next read of each is fresh: the living model is read
+// again once, and every surface follows it.
+//
+// A feed that fails resolves to null and leaves its part of the model out; it is
+// memoised like any other answer, so a failing feed costs one request per page.
+// Browser code; node can require it (the pure half: FEEDS, COUNT_FEEDS, AFTER_ACT,
+// inputOf) with no window, and its reader then answers null.
+
+(function (root) {
+  'use strict';
+
+  const API = '/api/bongos';
+  // every read the living model takes, by the name livingModel() gives its input
+  const FEEDS = Object.freeze({
+    docket: '/government/docket',
+    // the counts every surface prints, answered once by the server (task 1004716)
+    counts: '/government/counts',
+    constitution: '/government/constitution',
+    // the project's laws in force (task 1004706)
+    laws: '/government/laws',
+    // who leads each building, and the owner seat an unseated one falls to (task 1004709)
+    leads: '/government/leads',
+    // the pots each goal draws from, the reserve, the spend cap (task 1004712)
+    treasury: '/government/treasury',
+    // the strictness presets, and which one the laws in force amount to (task 1004715)
+    presets: '/government/presets',
+    goals: '/goals',
+    rollups: '/goals/rollups',
+    // the active claims ride on the claimable feed; one claimable row is plenty
+    claims: '/tasks/claimable?limit=1',
+    tasks: '/tasks?status=active&limit=200',
+    cost: '/public/cost-summary',
+    roster: '/builders/roster',
+    me: '/me',
+    blockers: '/blockers?limit=100',
+    fence: '/autonomy/fence',
+    moving: '/moving',
+  });
+  // what the counts stand on, and no more: GET /government/counts, the server's one
+  // read of all five (task 1004716), and /me (the shell's read, shared).
+  const COUNT_FEEDS = Object.freeze(['counts', 'me']);
+  // what an act can change: these are read fresh after one
+  const AFTER_ACT = Object.freeze(['docket', 'counts', 'blockers', 'claims', 'tasks', 'moving', 'rollups', 'treasury']);
+
+  const memo = {};
+  const listeners = [];
+  let session = null;
+
+  // a body, or false for a refusal (403: the shell reads that as "not yours"), or null
+  function getJson(url) {
+    if (typeof root.fetch !== 'function') return Promise.resolve(null);
+    return root.fetch(url, { credentials: 'same-origin', headers: { accept: 'application/json' } })
+      .then((r) => (r && r.ok ? r.json() : r && r.status === 403 ? false : null))
+      .catch(() => null);
+  }
+  // One feed's body (or null), read once per page view until refresh() drops it.
+  // THE SHELL'S READS ARE SHARED: shell.js leaves the reads it already made (/me)
+  // on window.__hallReads, and
+  // the first ask here adopts one instead of asking again; the shell, in turn,
+  // takes this memo's read when the page made it first (byPath).
+  function get(key) {
+    if (!Object.prototype.hasOwnProperty.call(FEEDS, key)) return Promise.resolve(null);
+    if (!memo[key]) {
+      const shared = root.__hallReads && root.__hallReads[FEEDS[key]];
+      if (shared) delete root.__hallReads[FEEDS[key]];
+      memo[key] = shared ? Promise.resolve(shared).catch(() => null) : getJson(API + FEEDS[key]);
+    }
+    return memo[key];
+  }
+  // the memoised read of the feed served at this path ('/me'), or null for another path
+  function byPath(path) {
+    const key = Object.keys(FEEDS).find((k) => FEEDS[k] === path);
+    return key ? get(key) : null;
+  }
+  // several feeds as { key: body }; every feed when keys is omitted
+  function read(keys) {
+    const ks = Array.isArray(keys) ? keys : Object.keys(FEEDS);
+    return Promise.all(ks.map(get)).then((res) => {
+      const out = {};
+      ks.forEach((k, i) => { out[k] = res[i]; });
+      return out;
+    });
+  }
+  function refresh(keys) {
+    (Array.isArray(keys) ? keys : AFTER_ACT).forEach((k) => { delete memo[k]; });
+    changed();
+  }
+
+  // the living model's input: livingModel() takes each route's own body
+  function inputOf(raw, now) { return Object.assign({}, raw || {}, { now: now }); }
+  function model(raw, now) {
+    const L = root.GovLiving;
+    if (!L || typeof L.livingModel !== 'function') return null;
+    try { return L.livingModel(inputOf(raw, now == null ? Date.now() : now)); } catch (_) { return null; }
+  }
+
+  // the page's own answers this visit: fn() → { answered: [ids], extra: [asks] }
+  function useSession(fn) { session = typeof fn === 'function' ? fn : null; }
+  function sessionNow() {
+    try { return session ? session() || null : null; } catch (_) { return null; }
+  }
+  // the counts over a model the page already holds (null without GovLiving)
+  function countsFrom(m) {
+    const L = root.GovLiving;
+    return L && m && typeof L.countsOf === 'function' ? L.countsOf(m, sessionNow()) : null;
+  }
+  // the counts from COUNT_FEEDS (the shell's tally): the same numbers the page prints.
+  // Every feed the page has already read is in the memo and costs nothing, so it
+  // rides along (the city and the street — the tally's two pages — read them all).
+  function counts() {
+    const keys = COUNT_FEEDS.concat(Object.keys(memo).filter((k) => COUNT_FEEDS.indexOf(k) < 0));
+    return read(keys).then((raw) => countsFrom(model(raw)));
+  }
+
+  function onChange(fn) { if (typeof fn === 'function') listeners.push(fn); }
+  function changed() { listeners.slice().forEach((fn) => { try { fn(); } catch (_) { /* a listener never blocks */ } }); }
+
+  const api = {
+    FEEDS: FEEDS, COUNT_FEEDS: COUNT_FEEDS, AFTER_ACT: AFTER_ACT, API: API,
+    get: get, byPath: byPath, read: read, refresh: refresh, inputOf: inputOf, model: model,
+    useSession: useSession, countsFrom: countsFrom, counts: counts, onChange: onChange, changed: changed,
+  };
+  root.GovFeeds = api;
+  if (typeof module !== 'undefined' && module.exports) module.exports = api;
+}(typeof window !== 'undefined' ? window : globalThis));