@bongos/core 1.19.781 → 1.19.782

package/tests/collab_page.mjs

@@ -167,6 +167,125 @@ test('context links to the task or goal, and to neither when absent', () => {
   assert.equal(L.contextOf({}), null, 'no context means no element, not an empty one');
 });
 
+// ── A ROOM OF PEOPLE (task 1003942, owner report) ───────────────────────────
+//
+// "Way too text heavy, and doesn't feel collaborative at all." The page now
+// leads with faces and figures; the rules that decide WHOSE face and WHAT number
+// are pure in collab-lib.js, so they run here rather than being grepped.
+
+test('an incoming row leads with the ASKER, an outgoing one with who you asked', () => {
+  const L = lib();
+  const inc = L.faceOf({ requested_by: 92, requested_by_name: 'Preview Gamma', requested_by_avatar_url: 'https://x/a.png' }, 'in');
+  assert.equal(inc.kind, 'person');
+  assert.equal(inc.id, 92);
+  assert.equal(inc.name, 'Preview Gamma');
+  assert.equal(inc.avatar, 'https://x/a.png');
+  const out = L.faceOf({ needs_builder_id: 90, needs_builder_name: 'Preview Alpha', needs_builder_avatar_url: 'https://x/b.png' }, 'out');
+  assert.equal(out.id, 90);
+  assert.equal(out.name, 'Preview Alpha');
+  assert.equal(out.avatar, 'https://x/b.png');
+});
+
+test('a craft ask wears the craft\'s letter, never a person\'s face', () => {
+  const L = lib();
+  const f = L.faceOf({ needs_craft: 'artist' }, 'out');
+  assert.equal(f.kind, 'craft');
+  assert.equal(f.initial, 'A');
+  assert.equal(f.avatar, null);
+  assert.equal(f.name, 'artists');
+  const css = read('modules', 'hall-ui', 'public', 'collab.css');
+  assert.match(css, /\.cb-face--craft\s*\{[^}]*font-family: var\(--label-face\)/, 'drawn in the label face, so it cannot pass for a person');
+});
+
+test('no picture means the INITIAL — and a src the page did not vouch for is dropped', () => {
+  const L = lib();
+  assert.equal(L.initialOf('preview-gamma'), 'P');
+  assert.equal(L.initialOf('@lyra'), 'L', 'a leading @ is not a letter');
+  assert.equal(L.initialOf(''), '?', 'never empty');
+  assert.equal(L.httpUrl('javascript:alert(1)'), null, 'roster.js\'s allowlist rule, kept');
+  assert.equal(L.httpUrl('https://avatars.githubusercontent.com/u/1?v=4'), 'https://avatars.githubusercontent.com/u/1?v=4');
+  const f = L.faceOf({ requested_by: 5, requested_by_login: 'gamma', requested_by_avatar_url: 'data:image/png;base64,AAAA' }, 'in');
+  assert.equal(f.avatar, null);
+  assert.equal(f.initial, 'G');
+});
+
+test('the face stack shows each PERSON once, however many times they asked', () => {
+  const L = lib();
+  const rows = [
+    { requested_by: 92, requested_by_name: 'Gamma' },
+    { requested_by: 90, requested_by_name: 'Alpha' },
+    { requested_by: 92, requested_by_name: 'Gamma' },
+  ];
+  assert.deepEqual(L.askers(rows).map((f) => f.name), ['Gamma', 'Alpha']);
+});
+
+test('THREE BLOCKS: the newest three show, the rest wait behind one door', () => {
+  // The owner's direction: asked of you left, your asks right, every open ask
+  // below, each condensed to the three most recent and expandable. The split
+  // and the order are pure, so the button's number and the rows it reveals
+  // come from one place.
+  const L = lib();
+  const rows = [{ id: 1, created_at: daysAgo(9) }, { id: 2, created_at: daysAgo(0) }, { id: 3, created_at: daysAgo(4) }, { id: 4, created_at: daysAgo(1) }];
+  const newest = rows.slice().sort(L.byNewestFirst).map((r) => r.id);
+  assert.deepEqual(newest, [2, 4, 3, 1], 'newest first is the display order');
+  const { shown, hidden } = L.splitShown(rows.slice().sort(L.byNewestFirst), 3);
+  assert.deepEqual(shown.map((r) => r.id), [2, 4, 3]);
+  assert.deepEqual(hidden.map((r) => r.id), [1], 'the fourth waits behind "show all"');
+  assert.equal(L.splitShown(rows.slice(0, 2), 3).hidden.length, 0, 'two rows need no door');
+  // The ageing band still marks every row whatever the order — the criterion
+  // is met by the pill, not by the sort.
+  assert.equal(L.ageBand(rows[0].created_at, NOW).id, 'stale');
+});
+
+test('the board of everyone\'s asks speaks in the third person', () => {
+  const L = lib();
+  assert.equal(L.boardLine({ requested_by_name: 'Alpha', needs_builder_id: 9, needs_builder_name: 'Beta' }), 'Alpha asked Beta by name');
+  assert.equal(L.boardLine({ requested_by_name: 'Gamma', needs_craft: 'builder' }), 'Gamma asked builders');
+  assert.equal(L.boardLine({ requested_by: 5, needs_builder_id: 9 }), 'builder 5 asked one person', 'an older server still names both ends');
+  assert.ok(!/\byou\b/i.test(L.boardLine({ requested_by_name: 'Alpha', needs_builder_id: 9, needs_builder_name: 'Beta' })), 'never "you" on the board');
+});
+
+test('the page is the three blocks, led by faces, with the ledes gone', () => {
+  const js = read('modules', 'hall-ui', 'public', 'collab.js');
+  const html = read('modules', 'hall-ui', 'public', 'collab.html');
+  assert.match(js, /L\.faceOf\(req, 'in'\)/, 'the incoming row asks the lib whose face');
+  assert.match(js, /L\.faceOf\(req, 'out'\)/, 'and so does the outgoing one');
+  assert.match(js, /paintBlock\('for-me'/); assert.match(js, /paintBlock\('mine'/); assert.match(js, /paintBlock\('all'/);
+  assert.match(js, /L\.splitShown\(list, SHOWN\)/, 'the condensing is the lib\'s split');
+  assert.match(js, /const SHOWN = 3;/, 'three, as asked');
+  assert.match(js, /api\.request\('GET', '\/help-requests'\)/, 'the third block reads the whole board');
+  assert.match(html, /class="view-zone view-zone--band cb-band"/, 'the top two ride the shell\'s two-up');
+  assert.match(html, /id="cb-all"/, 'and the board is the wide block under them');
+  for (const k of ['for-me', 'mine', 'all']) assert.match(html, new RegExp(`id="cb-${k}-more"[^>]*aria-expanded="false"`), `${k} has its door`);
+  // Prose budget: no block opens with a lede except the social one, which
+  // keeps ONE line; the rules sentence is said once, at the foot.
+  assert.equal((html.match(/class="scroll__lede"/g) || []).length, 1, 'one lede on the whole page');
+  assert.equal((html.match(/declining costs nothing/g) || []).length, 1, 'the rule is said once');
+  assert.match(html, /class="cb-foot"/, 'and it is the foot, not the opener');
+});
+
+test('the by-name ask is the one LIT thing — the accent goes on the personal call', () => {
+  const js = read('modules', 'hall-ui', 'public', 'collab.js');
+  const css = read('modules', 'hall-ui', 'public', 'collab.css');
+  assert.match(js, /req\.needs_builder_id != null \? ' cb-row--live' : ''/, 'only a by-name ask takes the class');
+  assert.match(css, /\.cb-row--live \.ov-row__facts > \.ov-fact \{ color: var\(--accent-ink\); \}/);
+  assert.ok(!/var\(--accent\)/.test(css), 'nothing in the sheet spends the accent FILL');
+});
+
+test('every colour in the sheet is a token — no literal, both modes for free', () => {
+  const css = read('modules', 'hall-ui', 'public', 'collab.css').replace(/\/\*[\s\S]*?\*\//g, '');
+  assert.deepEqual(css.match(/#[0-9a-f]{3,8}\b|rgba?\(/gi) || [], [], 'the Fifteen Rule');
+});
+
+test('the SIDEBAR badge: the Collab item declares the help_requests count', () => {
+  const shell = read('modules', 'hall-ui', 'public', 'shell.js');
+  assert.match(shell, /id: 'collab',[^}]*count: 'help_requests'/, 'the same field the Board Room item carries');
+  const needsSrc = read('modules', 'builder-settings', 'builder-needs.js');
+  const fn = needsSrc.slice(needsSrc.indexOf('function helpRequestsNeed'), needsSrc.indexOf('function taskRecommendationsNeed'));
+  assert.match(fn, /count: n,/, 'and the need states its number for the badge to read');
+  assert.match(fn, /href: '\/collab'/, 'pointing at the page, not the retired hash view');
+});
+
 // ---- THE ANSWERABLE CLAUSE ------------------------------------------------
 test('the asker can settle in place, with both outcomes', () => {
   const js = read('modules', 'hall-ui', 'public', 'collab.js');

package/tests/hall_collab_world.mjs

@@ -66,7 +66,8 @@ test('every list is the family\'s row, and the card-in-a-card is gone', () => {
   for (const old of ['cd-card', 'cd-stat', 'cd-tag', 'cd-filters__select', 'cd-browse', 'cd-empty']) {
     assert.ok(gone(read('copy-desk.js'), old) && gone(read('copy-desk.css'), `\\.${old}`), `copy desk no longer emits ${old}`);
   }
-  for (const p of PAGES) assert.match(read(`${p}.html`), /class="empty-state"/, `${p}.html empties with the kit's own state`);
+  // The kit's class, whole or with a page modifier beside it (collab's .cb-empty).
+  for (const p of PAGES) assert.match(read(`${p}.html`), /class="empty-state( [a-z-]+)*"/, `${p}.html empties with the kit's own state`);
 });
 
 // ---- collab: the facts the audit found thrown away ---------------------------
@@ -135,9 +136,12 @@ test('"asked of you" reads in runs — by name first, then each craft', () => {
   // task 1003274: the naming moved to directionLine, which also says WHICH WAY
   // the ask points — the half the owner's report was actually about.
   assert.match(L.directionLine({ needs_builder_id: 7, needs_builder_name: 'Preview Alpha' }, 'out'), /Preview Alpha by name/, 'a named addressee is named');
+  // task 1003942 (owner direction): the block is CONDENSED to the newest three,
+  // so the runs and their group heads are gone from the page; the personal ask
+  // is still told apart, as the lit row rather than a run of its own.
   const js = read('collab.js');
-  assert.match(js, /ov-group__head/, 'each run has the family\'s group head');
-  assert.match(js, /Number\(b\.id === 'you'\) - Number\(a\.id === 'you'\)/, 'and the personal run sorts first');
+  assert.match(js, /req\.needs_builder_id != null \? ' cb-row--live' : ''/, 'a by-name ask is the lit row');
+  assert.match(js, /sort\(L\.byNewestFirst\)/, 'the block reads newest first');
 });
 
 test('the age is a state pill in the row\'s right column, and every band has its own colour', () => {

package/tests/hall_nav.mjs

@@ -562,6 +562,53 @@ test('a big count is capped rather than allowed to stretch the rail', () => {
   assert.equal(b.navBadge('board-room').text, '99+');
 });
 
+// ── the SECOND consumer: open help requests on the Collab item (task 1003942) ──
+//
+// The owner's ask: a notification badge on the Collab link like the Board Room's.
+// Exactly the adoption the mechanism above promised — one field on the nav item,
+// one field on the need — so these pin that it landed and inherits every rule.
+
+const helpNeeds = (count, extra = {}) => ({
+  items: [{
+    id: 'help_requests', state: 'action_needed', count,
+    title: 'People asked for your help', ...extra,
+  }],
+});
+const signedIn = { authed: true, rank: 'xenos', permissions: {} };
+
+test('COLLAB: open help requests put a count on the Collab item', () => {
+  const b = boot();
+  b.shell.applyAccess({ ...signedIn, needs: helpNeeds(4) });
+  assert.deepEqual(b.navBadge('collab'), { text: '4', label: 'People asked for your help' });
+});
+
+test('COLLAB: zero, no count, or a covered need is silent', () => {
+  for (const needs of [helpNeeds(0), { items: [{ id: 'help_requests', state: 'action_needed' }] }, helpNeeds(3, { state: 'covered' })]) {
+    const b = boot();
+    b.shell.applyAccess({ ...signedIn, needs });
+    assert.equal(b.navBadge('collab'), null);
+  }
+});
+
+test('COLLAB: the badge never out-runs the gate — signed out, no count', () => {
+  const b = boot();
+  b.shell.applyAccess({ ...signedIn, needs: helpNeeds(2) });
+  assert.ok(b.navBadge('collab'), 'precondition: it showed');
+  b.shell.applyAccess({ authed: false, needs: helpNeeds(2) });
+  assert.equal(b.navHidden('collab'), true, 'precondition: Collab needs a session');
+  assert.equal(b.navBadge('collab'), null, 'a hidden item carries no count');
+});
+
+test('COLLAB and the Board Room each read their OWN need — the counts do not bleed', () => {
+  const b = boot();
+  b.shell.applyAccess({
+    authed: true, rank: 'xenos', permissions: { 'board.vote.cast': true },
+    needs: { items: [...helpNeeds(4).items, ...boardNeeds(2).items] },
+  });
+  assert.equal(b.navBadge('collab').text, '4');
+  assert.equal(b.navBadge('board-room').text, '2');
+});
+
 test('the count reaches a screen reader as WORDS, not a floating numeral', () => {
   // The numeral is aria-hidden decoration; the need's own sentence rides beside
   // it in an sr-only span. "3" alone inside a link named Board Room says nothing.

package/tests/help_requests.mjs

@@ -231,6 +231,37 @@ test('both reads are capped', () => {
   }
 });
 
+// ── the BOARD read (task 1003942, owner direction) ─────────────────────────
+//
+// The Collab page's third block is every open ask in the project. A fourth
+// read beside the addressed one and the asker's own, and the one that could
+// reopen C01's privacy hole if it took a craft or a builder from the caller —
+// so these pin that it takes nothing, stays open-only, and is capped like the
+// other two.
+test('the board read lists every OPEN ask, newest first, and takes nothing from the caller', async () => {
+  const calls = [];
+  const pool = { query: async (sql, params) => { calls.push({ sql, params }); return { rows: [{ id: 1 }] }; } };
+  const rows = await help.listOpenAll({}, { pool });
+  assert.deepEqual(rows, [{ id: 1 }]);
+  assert.equal(calls.length, 1);
+  assert.match(calls[0].sql, /WHERE h\.status = 'open'/, 'open only — a settled ask leaves the board');
+  assert.match(calls[0].sql, /ORDER BY h\.created_at DESC/, 'newest first is the board\'s order');
+  assert.ok(!/needs_craft\s*=|requested_by\s*=|needs_builder_id\s*=/.test(calls[0].sql), 'no craft or builder narrows it — nothing for a ?craft= hole to widen');
+  assert.deepEqual(calls[0].params, [help.MAX_ROWS], 'capped, and the cap is the only parameter');
+  assert.match(calls[0].sql, /requested_by_avatar_url/, 'it carries the faces the page leads with');
+});
+
+test('the board route is signed-in only and reads no query', () => {
+  const routes = read('modules', 'lifecycle', 'routes', 'help-requests.js');
+  const idx = routes.indexOf("'GET /help-requests'");
+  assert.ok(idx > 0, 'the route exists');
+  const line = routes.slice(routes.lastIndexOf('router.get', idx), idx);
+  assert.match(line, /api\.requireBuilder/, 'any builder, no stranger');
+  const body = routes.slice(idx, routes.indexOf('errorCode', idx));
+  assert.ok(!/req\.query|req\.body/.test(body), 'nothing from the caller reaches the read');
+  assert.match(body, /help\.listOpenAll\(\)/);
+});
+
 test('core reaches the count through the PORT, never by importing lifecycle', () => {
   const me = read('src', 'bongos', 'routes', 'me.js');
   assert.match(me, /openHelpRequestsFor/);

package/tests/social_mode.mjs

@@ -120,7 +120,9 @@ test('HOME changes: an introduction becomes a need in the roster', () => {
   const row = roster.find((n) => n.id === 'mingle_introductions');
   assert.ok(row, 'the need is produced');
   assert.equal(row.state, 'action_needed');
-  assert.match(row.action.href, /\/#\/collab/, 'it points at an EXISTING surface, not a new one');
+  // Collab has been its own page since task 1003172; the '/#/collab' hash form
+  // this used to pin pointed at a view the index no longer routes (task 1003942).
+  assert.match(row.action.href, /^\/collab$/, 'it points at an EXISTING surface, not a new one');
 });
 
 test('no introductions means no row — the roster is not padded', () => {