@bongos/core 1.19.1051 → 1.19.1052

package/tests/hall_fullscreen.mjs

@@ -0,0 +1,196 @@
+// tests/hall_fullscreen.mjs — the hall's shared full-screen switch (task 1004327,
+// BV2.TW20, goal 1000095; owner decision 2026-09-27).
+//
+// The studio and Your thinking sit in the hall chrome, and each carries ONE
+// switch that hides the sidebar and the top bar so the page fills the window.
+// The switch is the shell's, not a page's: a page opts in with
+// <body data-fullscreen-switch>, and the shell renders the button, keeps the
+// state on html[data-fullscreen="on"], remembers it PER PAGE in localStorage and
+// lets Escape leave. These cases boot the REAL shell.js in a DOM stub and drive
+// it the way a reader does — press the button, reload, press Escape — so a
+// switch that renders but does not remember, or an Escape that fights the sky's
+// own use of the key, fails here. The two source assertions at the end are
+// labelled as such: the CSS half (what "hidden" means) is proven by the kit
+// renders in the ship notes, not by a regex.
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+import fs from 'node:fs';
+import path from 'node:path';
+import vm from 'node:vm';
+import { fileURLToPath } from 'node:url';
+
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const HALL = path.join(ROOT, 'modules/hall-ui/public');
+const SHELL = fs.readFileSync(path.join(HALL, 'shell.js'), 'utf8');
+const read = (f) => fs.readFileSync(path.join(HALL, f), 'utf8');
+
+// Boot the shell once — one page load. `store` is the browser's localStorage and
+// is SHARED across boots on purpose: a second boot over the same store is a reload.
+function boot({ page = 'thinking', optIn = true, store = {}, storageThrows = false } = {}) {
+  const els = new Map();
+  const windowListeners = {};
+  const timers = [];
+  const makeEl = (id) => {
+    const attrs = {};
+    return {
+      id, dataset: {}, style: {}, textContent: '', hidden: false, _html: '', title: '',
+      classList: { add() {}, remove() {}, toggle() { return false; }, contains() { return false; } },
+      setAttribute(k, v) { attrs[k] = String(v); }, getAttribute(k) { return k in attrs ? attrs[k] : null; }, removeAttribute(k) { delete attrs[k]; },
+      addEventListener(ev, fn) { (this._on ||= {})[ev] = fn; },
+      querySelector() { return null; }, querySelectorAll() { return []; },
+      appendChild() {}, focus() {}, click() { if (this._on && this._on.click) this._on.click({ target: this }); },
+      insertAdjacentElement() {}, remove() {},
+      set innerHTML(v) { this._html = String(v); }, get innerHTML() { return this._html; },
+    };
+  };
+  // The topbar's innerHTML is the shell's own markup; an id the shell rendered
+  // into it resolves only if that markup really carries it, so a button the
+  // shell forgot to render cannot be clicked into existence by the stub.
+  const topbar = makeEl('app-topbar');
+  const getElementById = (id) => {
+    if (id === 'app-topbar') return topbar;
+    if (/^(fullscreen-toggle|theme-toggle|zoom-toggle|topbar-menu|topbar-title|topbar-jump)$/.test(id)
+      && !topbar._html.includes(`id="${id}"`)) return null;
+    if (!els.has(id)) els.set(id, makeEl(id));
+    return els.get(id);
+  };
+  const body = {
+    dataset: { page },
+    hasAttribute: (k) => optIn && k === 'data-fullscreen-switch',
+  };
+  const documentObj = {
+    body,
+    documentElement: { dataset: {}, style: {}, classList: { add() {}, remove() {}, toggle() { return false; }, contains() { return false; } } },
+    getElementById,
+    querySelectorAll() { return []; },
+    createElement() { return makeEl(null); },
+    addEventListener() {}, dispatchEvent() {},
+    get cookie() { return ''; }, set cookie(_v) {},
+  };
+  const location = { hostname: 'h', origin: 'https://h', pathname: '/' + page, hash: '', search: '', assign() {}, replace() {} };
+  const localStorage = {
+    getItem: (k) => { if (storageThrows) throw new Error('SecurityError'); return k in store ? store[k] : null; },
+    setItem: (k, v) => { if (storageThrows) throw new Error('SecurityError'); store[k] = String(v); },
+  };
+  let resizes = 0;
+  const windowObj = {
+    __BRANDING__: {}, __MODULES__: { enabled: {} },
+    BongosClient: { createClient: () => ({ request: () => new Promise(() => {}) }) },
+    matchMedia: () => ({ matches: false, addEventListener() {} }),
+    localStorage, location,
+    requestAnimationFrame() {}, scrollTo() {},
+    addEventListener(type, fn) { (windowListeners[type] ||= []).push(fn); },
+    dispatchEvent(ev) { if (ev && ev.type === 'resize') resizes += 1; return true; },
+    setTimeout: (fn) => { timers.push(fn); return timers.length; },
+  };
+  const sandbox = {
+    window: windowObj, document: documentObj, location, console, clearTimeout() {}, queueMicrotask,
+    setTimeout: windowObj.setTimeout,
+    Event: class { constructor(t) { this.type = t; } },
+    CustomEvent: class { constructor(t, i) { this.type = t; Object.assign(this, i); } },
+  };
+  sandbox.globalThis = sandbox;
+  vm.createContext(sandbox);
+  vm.runInContext(SHELL, sandbox, { filename: 'shell.js' });
+  const root = documentObj.documentElement;
+  return {
+    store,
+    button: () => getElementById('fullscreen-toggle'),
+    on: () => root.dataset.fullscreen === 'on',
+    resizes: () => resizes,
+    // Press a key the way the browser dispatches it: every window listener,
+    // then the page may mark the press used, then the queued timers run.
+    press(key, { target = { tagName: 'CANVAS' }, pageUses = false } = {}) {
+      const ev = { key, target, defaultPrevented: false, preventDefault() { this.defaultPrevented = true; } };
+      for (const fn of windowListeners.keydown || []) fn(ev);
+      if (pageUses) ev.preventDefault();
+      while (timers.length) timers.shift()();
+    },
+  };
+}
+
+test('a page that does not opt in gets no switch, and never goes full screen', () => {
+  const store = { 'hall-fullscreen:work': 'on' };
+  const p = boot({ page: 'work', optIn: false, store });
+  assert.equal(p.button(), null, 'no button rendered');
+  assert.equal(p.on(), false, 'a stored value for a page with no switch is ignored');
+});
+
+test('an opted-in page renders ONE switch in the top bar, off by default', () => {
+  const p = boot();
+  const btn = p.button();
+  assert.ok(btn, 'the switch is in the top bar');
+  assert.equal(p.on(), false);
+  assert.equal(btn.getAttribute('aria-pressed'), 'false');
+  assert.equal(btn.getAttribute('aria-label'), 'Full screen');
+});
+
+test('the switch hides the chrome, the same button brings it back', () => {
+  const p = boot();
+  p.button().click();
+  assert.equal(p.on(), true, 'html[data-fullscreen="on"]');
+  assert.equal(p.button().getAttribute('aria-pressed'), 'true');
+  assert.equal(p.button().getAttribute('aria-label'), 'Leave full screen');
+  assert.ok(p.resizes() >= 1, 'a page that sizes to its box is told to re-measure');
+  p.button().click();
+  assert.equal(p.on(), false, 'and back');
+});
+
+test('THE CHOICE SURVIVES A RELOAD — and it is remembered per page', () => {
+  const store = {};
+  boot({ page: 'thinking', store }).button().click();
+  assert.equal(store['hall-fullscreen:thinking'], 'on');
+  assert.equal(boot({ page: 'thinking', store }).on(), true, 'the reload opens in full screen');
+  assert.equal(boot({ page: 'studio', store }).on(), false, 'the studio did not follow the sky');
+  boot({ page: 'thinking', store }).button().click();
+  assert.equal(boot({ page: 'thinking', store }).on(), false, 'leaving is remembered too');
+});
+
+test('Escape leaves full screen', () => {
+  const p = boot({ store: { 'hall-fullscreen:thinking': 'on' } });
+  assert.equal(p.on(), true);
+  p.press('Escape');
+  assert.equal(p.on(), false);
+});
+
+test('an Escape the PAGE used (the sky\'s tour, menu or pick) does not also leave', () => {
+  const p = boot({ store: { 'hall-fullscreen:thinking': 'on' } });
+  p.press('Escape', { pageUses: true });
+  assert.equal(p.on(), true, 'the page marked the press used, after the shell heard it');
+});
+
+test('an Escape inside a text field belongs to the field', () => {
+  const p = boot({ store: { 'hall-fullscreen:thinking': 'on' } });
+  p.press('Escape', { target: { tagName: 'INPUT' } });
+  assert.equal(p.on(), true);
+  p.press('x');
+  assert.equal(p.on(), true, 'other keys are not the switch\'s');
+});
+
+test('storage that throws (a private window) leaves the chrome showing and the switch working', () => {
+  const p = boot({ storageThrows: true });
+  assert.equal(p.on(), false);
+  p.button().click();
+  assert.equal(p.on(), true, 'the switch still works for this page load');
+});
+
+test('the studio and Your thinking opt in, inside the hall chrome; the project sky does not (yet)', () => {
+  for (const f of ['studio.html', 'thinking.html']) {
+    const html = read(f);
+    assert.match(html, /<body[^>]*\bdata-fullscreen-switch\b/, `${f} opts in`);
+    for (const id of ['app-sidebar', 'app-topbar']) assert.match(html, new RegExp(`id="${id}"`), `${f} carries #${id}`);
+    assert.match(html, /<main id="hall-main"/, `${f}: the skip link's target`);
+    assert.equal((html.replace(/<!--[\s\S]*?-->/g, '').match(/<header\b/g) || []).length, 1, `${f}: the top bar is the one <header>`);
+  }
+  assert.doesNotMatch(read('goal-map.html'), /data-fullscreen-switch|shell\.js/, '/goal-map keeps its standalone form');
+});
+
+// SOURCE ASSERTION (the CSS half): full screen hides the sidebar and the foot
+// but keeps the top bar IN the document, collapsed to its switch — so the page
+// keeps one <header> and the way back is where the way in was.
+test('source: full screen hides the sidebar and foot, and collapses the top bar rather than removing it', () => {
+  const css = read('style.css');
+  assert.match(css, /html\[data-fullscreen="on"\] \.app-sidebar,\s*html\[data-fullscreen="on"\] \.app-scrim,\s*html\[data-fullscreen="on"\] \.app-foot \{ display: none; \}/);
+  assert.match(css, /html\[data-fullscreen="on"\] \.topbar-side > :not\(\.fullscreen-toggle\)/);
+  assert.doesNotMatch(css, /html\[data-fullscreen="on"\] \.app-topbar \{ display: none/);
+});

package/tests/nav_permission_atoms.mjs

@@ -87,7 +87,7 @@ test('the hall-preview fixture carries every atom /me resolves', () => {
 // the file and left the query alone, so a returning browser kept the cached copy —
 // a fix that reaches nobody looks identical to a fix that does not work.
 
-const SHELL_SHA = '6b28297270d1e1f0';
+const SHELL_SHA = '7f66604d74d544e8';
 
 test('shell.js has not changed without its cache-bust being bumped', () => {
   const actual = crypto.createHash('sha256').update(SHELL).digest('hex').slice(0, 16);