P1-1 an open workflow editor, a dirty autonomy form and a pack's picked project keep their node, draft and focus across the 10-second poll and an org-changed repaint. P1-2 decision-http names the refused field and keeps the bus code and detail. P1-3 long editors span the full width below the org page split. P2-1 workflow roles resolve as definitions, templates and human; P2-2 a pack apply re-reads workflows, autonomy and board and keeps its receipt; P2-3 pack preview fits its column; P2-4 unknown project, agent or harness say so instead of outcome-unknown; P2-6 a stopped bus reads "bus stopped"; P2-8 Queue says why it is unavailable; P2-9 pane settings values are not clipped; P2-10 spend wording; P2-11 project header stays in its column; P2-12 project tabs fade at the edge until scrolled to the end; P2-13 Restart bus and Stop bus line up in panes; P2-15 backticks in chat text render as code. Minor: Same-as commands wrap between words; harness checkboxes share a row. Tests: org-live-edit-browser, e2e6-layout-browser, chat-replies and decision-http additions.
485 lines
29 KiB
JavaScript
485 lines
29 KiB
JavaScript
// Side by side (U5, sample 07): two panes, each showing one page of any organization. A pane holds
|
||
// the organization dashboard, the Agents levels or a project page (overview, conversations, tasks,
|
||
// requirements, files), drawn by the same modules as the full view (workspace.js, projects.js) into
|
||
// the pane instead of #bus-view. Every read names the pane's organization, so the panes never share
|
||
// state. Pages that keep one global form, dialog or editor (a conversation, the room, settings, the
|
||
// queue, docs, the inbox) are not offered in a pane; their links open the full view.
|
||
//
|
||
// The panes' routes, the divider and the phone's shown pane live in the URL
|
||
// (#/orgs/<page>/side-by-side?a=<org>/<route>&b=<org>/<route>&w=<percent>&show=a|b), updated with
|
||
// replaceState so nothing reloads, and the last layout is remembered in this browser.
|
||
(() => {
|
||
'use strict';
|
||
if (!document.documentElement.hasAttribute('data-organizations')) return;
|
||
const data = window.MosaicWorkspaceData, ws = () => window.MosaicWorkspace;
|
||
const esc = value => String(value ?? '').replace(/[&<>"']/g, c => ({ '&': '&', '<': '<', '>': '>', '"': '"', "'": ''' }[c]));
|
||
const enc = encodeURIComponent;
|
||
const STORE = 'mosaic-side-by-side-v1', POLL = 10000, LIST_TTL = 3000, PROJECTS_TTL = 30000;
|
||
const MIN = 25, MAX = 75, STEP = 5;
|
||
const ORG = /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/;
|
||
const PROJECT = /^\/projects\/([A-Za-z0-9][A-Za-z0-9._-]{0,159})(?:\/(conversations|tasks|requirements|files))?$/;
|
||
const SECTIONS = { overview: 'Overview', conversations: 'Conversations', tasks: 'Tasks', requirements: 'Requirements', files: 'Files' };
|
||
const FOCUSABLE = 'a[href],button:not([disabled]),select,textarea,input,summary,[tabindex]:not([tabindex="-1"])';
|
||
const NAMES = { a: 'left', b: 'right' };
|
||
const load = () => { try { return localStorage.getItem(STORE); } catch { return null; } };
|
||
const save = value => { try { localStorage.setItem(STORE, value); } catch {} };
|
||
const paused = () => document.getElementById('pause')?.getAttribute('aria-pressed') === 'true';
|
||
const svg = d => `<svg class="i sm" viewBox="0 0 24 24" aria-hidden="true" focusable="false">${d}</svg>`;
|
||
const FULL = svg('<rect x="3.5" y="4.5" width="17" height="15" rx="1.5"/><path d="M12 4.5v15"/>');
|
||
const CLOSE = svg('<path d="M6 6l12 12M18 6 6 18"/>');
|
||
const PLUS = svg('<path d="M12 5v14M5 12h14"/>');
|
||
|
||
// A pane's page: the routes a pane can draw. Anything else is not pane-safe.
|
||
function page(route) {
|
||
if (route === '/organization') return { kind: 'dashboard' };
|
||
if (route === '/agents') return { kind: 'agents' };
|
||
const m = PROJECT.exec(route);
|
||
if (m && m[1] !== 'threads' && m[1] !== 'rooms') return { kind: 'project', id: m[1], section: m[2] || 'overview' };
|
||
return null;
|
||
}
|
||
// "<org>/<route>" from the URL; null when either part is not one a pane draws.
|
||
function parsePane(value) {
|
||
if (typeof value !== 'string') return null;
|
||
const cut = value.indexOf('/');
|
||
if (cut < 1) return null;
|
||
const org = value.slice(0, cut), route = value.slice(cut);
|
||
return ORG.test(org) && page(route) ? { org, route } : null;
|
||
}
|
||
const paneValue = p => `${p.org}${p.route}`;
|
||
const clampW = n => Math.min(MAX, Math.max(MIN, Math.round(n)));
|
||
|
||
// ---------- shared reads (one organization list and project lists for both panes) ----------
|
||
let listAt = 0, listPromise = null, projectReads = new Map();
|
||
function orgList(fresh = false) {
|
||
if (!listPromise || fresh || Date.now() - listAt > LIST_TTL) {
|
||
listAt = Date.now();
|
||
listPromise = Promise.all([data.organizations(), ws()?.themes?.()]).then(([rows]) => (Array.isArray(rows) ? rows : null)).catch(() => null);
|
||
}
|
||
return listPromise;
|
||
}
|
||
function projectsOf(org, fresh = false) {
|
||
const hit = projectReads.get(org);
|
||
if (hit && !fresh && Date.now() - hit.at < PROJECTS_TTL) return hit.promise;
|
||
const promise = data.projects(org).then(b => (Array.isArray(b?.rows) ? b.rows.filter(p => p && typeof p.id === 'string') : null)).catch(() => null);
|
||
projectReads.set(org, { at: Date.now(), promise });
|
||
return promise;
|
||
}
|
||
|
||
// ---------- state ----------
|
||
let mounted = null; // { root, panes: [pane], w, show, gen }
|
||
let mountGen = 0;
|
||
let listCache = null; // the last organization list read, for the shown-pane tabs
|
||
|
||
function readQuery(query) {
|
||
const q = new URLSearchParams(query || '');
|
||
return { a: parsePane(q.get('a')), b: parsePane(q.get('b')), w: Number(q.get('w')), show: q.get('show'), named: q.has('a') || q.has('b') };
|
||
}
|
||
function queryOf(state) {
|
||
const q = new URLSearchParams();
|
||
state.panes.forEach((p, i) => q.set(i ? 'b' : 'a', paneValue(p)));
|
||
q.set('w', String(state.w));
|
||
q.set('show', state.show);
|
||
return q.toString().replace(/%2F/g, '/');
|
||
}
|
||
function writeUrl() {
|
||
if (!mounted) return;
|
||
const qs = queryOf(mounted);
|
||
save(qs);
|
||
const next = `#/orgs/${enc(window.MosaicOrg.id)}/side-by-side?${qs}`;
|
||
if (location.hash !== next) history.replaceState(null, '', next);
|
||
}
|
||
// The first pane is this page's organization; the second is the next organization on the list,
|
||
// or this one's Agents when there is no other.
|
||
async function defaults() {
|
||
const here = window.MosaicOrg.id, list = await orgList();
|
||
const other = (list || []).find(o => o && !o.invalid && o.id !== here && ORG.test(o.id));
|
||
return [{ org: here, route: '/organization' }, other ? { org: other.id, route: '/organization' } : { org: here, route: '/agents' }];
|
||
}
|
||
|
||
// ---------- markup ----------
|
||
function paneShell(key) {
|
||
const name = NAMES[key];
|
||
return `<section class="pane" id="pane-${key}" data-pane="${key}" aria-label="${name[0].toUpperCase()}${name.slice(1)} pane">
|
||
<div class="pane-h ws-o" data-pane-head>
|
||
<span data-pane-av></span><span class="ttl" data-pane-ttl></span><span data-pane-state></span>
|
||
<label class="ws-sr" for="pane-${key}-pick">Page in the ${name} pane</label>
|
||
<select id="pane-${key}-pick" class="pane-pick" data-pane-pick></select>
|
||
<span class="tools"><a class="pane-tool" data-pane-full href="#" title="Open in full view"><span class="ws-sr" data-pane-full-label>Open in full view</span>${FULL}</a><button type="button" class="pane-tool" data-pane-close title="Close pane" aria-label="Close the ${name} pane">${CLOSE}</button></span>
|
||
</div>
|
||
<p class="pane-line" data-pane-line role="status"></p>
|
||
<div class="pane-body" data-pane-body tabindex="0" aria-label="${name[0].toUpperCase()}${name.slice(1)} pane content"></div>
|
||
</section>`;
|
||
}
|
||
function frame() {
|
||
return `<section class="sbs" data-side-by-side aria-labelledby="sbs-title">
|
||
<div class="panebar"><h1 id="sbs-title" tabindex="-1">Side by side</h1><span class="note" data-sbs-note></span>
|
||
<span class="ws-seg pane-tabs" role="group" aria-label="Shown pane" data-sbs-tabs></span>
|
||
<button type="button" class="ws-btn hide-m" data-pane-add>${PLUS}Add pane</button></div>
|
||
<div class="panes" data-sbs-panes>${paneShell('a')}<div class="pane-div" role="separator" tabindex="0" aria-orientation="vertical" aria-label="Resize panes" aria-controls="pane-a pane-b" aria-valuemin="${MIN}" aria-valuemax="${MAX}" data-sbs-divider></div>${paneShell('b')}</div>
|
||
</section>`;
|
||
}
|
||
|
||
// Orgs in the picker: every organization on the list. A pane draws a valid one's dashboard, Agents or
|
||
// any project the organization's project read lists; an invalid one is listed and cannot be chosen.
|
||
async function pickerHtml(p, list) {
|
||
const groups = await Promise.all((list || []).filter(o => o && ORG.test(o.id)).map(async org => {
|
||
const name = ws().label(org);
|
||
if (org.invalid) return `<optgroup label="${esc(name)} · invalid"><option disabled value="">Organization invalid</option></optgroup>`;
|
||
const rows = await projectsOf(org.id);
|
||
const opt = (route, text) => `<option value="${esc(`${org.id}${route}`)}">${esc(text)}</option>`;
|
||
const projects = rows === null ? '<option disabled value="">Projects unavailable</option>' : rows.filter(r => !r.archived && PROJECT.test(`/projects/${r.id}`)).map(r => opt(`/projects/${r.id}`, `Project: ${r.name || r.id}`)).join('');
|
||
return `<optgroup label="${esc(name)}${org.busHealthy ? '' : ' · bus unavailable'}">${opt('/organization', 'Dashboard')}${opt('/agents', 'Agents')}${projects}</optgroup>`;
|
||
}));
|
||
let html = groups.join('');
|
||
const value = paneValue(p);
|
||
// A project section, or a page the list no longer names, is still the pane's page: keep it selectable.
|
||
if (!html.includes(`value="${esc(value)}"`)) html = `<option value="${esc(value)}">${esc(p.title || value)}</option>${html}`;
|
||
return html;
|
||
}
|
||
|
||
// ---------- drawing one pane ----------
|
||
const els = p => ({
|
||
head: p.el.querySelector('[data-pane-head]'), av: p.el.querySelector('[data-pane-av]'), ttl: p.el.querySelector('[data-pane-ttl]'),
|
||
state: p.el.querySelector('[data-pane-state]'), pick: p.el.querySelector('[data-pane-pick]'), full: p.el.querySelector('[data-pane-full]'),
|
||
fullLabel: p.el.querySelector('[data-pane-full-label]'), close: p.el.querySelector('[data-pane-close]'), line: p.el.querySelector('[data-pane-line]'), body: p.el.querySelector('[data-pane-body]'),
|
||
});
|
||
const setHtml = (el, html) => { if (el && el.innerHTML !== html) el.innerHTML = html; };
|
||
const setText = (el, text) => { if (el && el.textContent !== text) el.textContent = text; };
|
||
|
||
// Links a page draws are relative to the page's organization. In a pane they name the pane's
|
||
// organization; reads the page links to (/api/...) name it too.
|
||
function rewrite(p, root) {
|
||
const prefix = `#/orgs/${enc(p.org)}`;
|
||
for (const a of root.querySelectorAll('a[href^="#/"]')) if (!a.getAttribute('href').startsWith('#/orgs/')) a.setAttribute('href', prefix + a.getAttribute('href').slice(1));
|
||
for (const a of root.querySelectorAll('a[href^="/api/"]')) if (!a.getAttribute('href').startsWith('/api/orgs/')) a.setAttribute('href', `/api/orgs/${enc(p.org)}/${a.getAttribute('href').slice(5)}`);
|
||
// The pane's title is the page's heading; the side-by-side page keeps the one level-1 heading.
|
||
for (const h of root.querySelectorAll('h1:not([aria-level])')) h.setAttribute('aria-level', '2');
|
||
}
|
||
// Focus and scroll survive a repaint of this pane only. Focus in the other pane is never taken.
|
||
function capture(p, root) {
|
||
const a = document.activeElement, inside = !!a && a !== root && root.contains(a);
|
||
return {
|
||
top: root.scrollTop,
|
||
focus: inside ? { key: a.dataset?.focusKey || null, href: a.getAttribute('href'), index: [...root.querySelectorAll(FOCUSABLE)].indexOf(a), h1: a.tagName === 'H1' } : null,
|
||
};
|
||
}
|
||
function restore(p, root, kept) {
|
||
root.scrollTop = kept.top;
|
||
const f = kept.focus, a = document.activeElement;
|
||
if (!f || (a && a !== document.body && !root.contains(a))) return;
|
||
const target = (f.key && root.querySelector(`[data-focus-key="${CSS.escape(f.key)}"]`))
|
||
|| (f.href && [...root.querySelectorAll('a[href]')].find(x => x.getAttribute('href') === f.href))
|
||
|| (f.h1 && root.querySelector('h1'))
|
||
|| root.querySelectorAll(FOCUSABLE)[f.index];
|
||
(target || root).focus({ preventScroll: true });
|
||
}
|
||
function paintBody(p, html) {
|
||
const { body } = els(p);
|
||
if (p.html === html && body.childElementCount) return;
|
||
const kept = capture(p, body), live = window.MosaicWorkspace?.holdLive?.(body);
|
||
body.innerHTML = html; p.html = html; p.project = null;
|
||
rewrite(p, body);
|
||
// E2E6 P1-1: an editor in use keeps its node, draft and focus; its ids were rewritten when first painted.
|
||
if (live && window.MosaicWorkspace.graftLive(body, live)) kept.focus = null;
|
||
restore(p, body, kept);
|
||
}
|
||
|
||
// A focus move that finishes after an asynchronous read happens only if the viewer has not
|
||
// moved on: focus is still where it was when the action started, nowhere, or inside this pane.
|
||
function mayFocus(p, before) {
|
||
const a = document.activeElement;
|
||
return !a || a === document.body || a === before || p.el.contains(a);
|
||
}
|
||
async function drawPane(p, { fresh = false, focusHead = false } = {}) {
|
||
if (!mounted || !p.el.isConnected) return;
|
||
const before = document.activeElement;
|
||
const turn = ++p.turn, gen = mountGen, live = () => mounted && gen === mountGen && turn === p.turn && p.el.isConnected;
|
||
clearTimeout(p.timer);
|
||
const e = els(p), what = page(p.route);
|
||
const list = await orgList(fresh);
|
||
if (!live()) return;
|
||
if (list) listCache = list;
|
||
const org = list?.find(o => o?.id === p.org) || null;
|
||
const name = org ? ws().label(org) : p.org;
|
||
// Header: the organization's mark, the page's title, its state, the picker and the tools.
|
||
if (org) e.head.setAttribute('style', ws().colours(org)); else e.head.removeAttribute('style');
|
||
setHtml(e.av, org ? ws().av(org, 'md') : '<span class="ws-av md" aria-hidden="true">?</span>');
|
||
const [scls, sglyph, sword] = org ? ws().state(org) : ['s-unknown', '?', 'not on your list'];
|
||
setHtml(e.state, org?.busHealthy && !org.invalid ? '' : ws().dot(scls, sglyph, sword, true));
|
||
const fullHref = `#/orgs/${enc(p.org)}${p.route}`;
|
||
if (e.full.getAttribute('href') !== fullHref) e.full.setAttribute('href', fullHref);
|
||
|
||
let line = '', html = null;
|
||
if (!list) line = 'The organization list could not be read. This pane shows what its own reads return.';
|
||
else if (!org) { line = `${p.org} is not on your organization list.`; html = '<p class="ws-line">Nothing is read for an organization that is not on your list.</p>'; }
|
||
else if (org.invalid) { line = `${name}: organization invalid${org.reason ? ` (${org.reason})` : ''}.`; html = '<p class="ws-line">Nothing is read from an invalid organization. Fix its file under Settings, Organizations.</p>'; }
|
||
else if (!org.busHealthy) line = `${name}: bus unavailable. Reads from this organization may fail; the other pane is not affected.`;
|
||
setText(e.line, line); e.line.hidden = !line;
|
||
|
||
let title = what?.kind === 'agents' ? 'Agents' : 'Dashboard';
|
||
if (html === null && what?.kind === 'dashboard') html = await ws().dashboard(p.org, { pane: true, idPrefix: `pane-${p.key}-` }).catch(() => '<p class="ws-line">Dashboard unavailable.</p>');
|
||
else if (html === null && what?.kind === 'agents') html = await ws().agentGrid('', p.org).catch(() => '<p class="ws-line">Agents unavailable.</p>');
|
||
if (!live()) return;
|
||
if (html === null && what?.kind === 'project') {
|
||
title = await drawProject(p, e, what, fresh, live);
|
||
if (title === null || !live()) return;
|
||
} else if (html !== null) paintBody(p, html);
|
||
p.title = title;
|
||
setHtml(e.ttl, `${esc(title)}<small>${esc(name)}</small>`);
|
||
p.el.setAttribute('aria-label', `${NAMES[p.key][0].toUpperCase()}${NAMES[p.key].slice(1)} pane: ${title}, ${name}`);
|
||
setText(e.fullLabel, `Open ${title}, ${name}, in full view`);
|
||
// The picker is rebuilt only while it is closed and unfocused, so a choice in progress stays.
|
||
if (document.activeElement !== e.pick) {
|
||
const options = await pickerHtml(p, list);
|
||
if (!live()) return;
|
||
if (document.activeElement !== e.pick) { setHtml(e.pick, options); e.pick.value = paneValue(p); }
|
||
}
|
||
paintBar(); fit();
|
||
if (focusHead && mayFocus(p, before)) (e.body.querySelector('h1') || e.body).focus({ preventScroll: true });
|
||
p.timer = setTimeout(() => tick(p), POLL);
|
||
}
|
||
function tick(p) {
|
||
if (!mounted || !p.el.isConnected) return;
|
||
if (paused()) { p.timer = setTimeout(() => tick(p), POLL); return; }
|
||
void drawPane(p);
|
||
}
|
||
|
||
// A project page: projects.js's header and content, mounted into the pane with the pane's
|
||
// organization, read-only (a pane never sends).
|
||
// Every write below happens only while this draw is still the pane's current one (live()), so a
|
||
// slow read never paints an old page or organization over the one the viewer has since chosen.
|
||
async function drawProject(p, e, what, fresh, live) {
|
||
const org = p.org;
|
||
const [projects, threadsRead] = await Promise.all([projectsOf(org, fresh), data.threads(org).catch(() => null)]);
|
||
if (!live() || p.org !== org) return null;
|
||
const project = projects?.find(r => r.id === what.id);
|
||
const sectionName = SECTIONS[what.section];
|
||
if (!project) {
|
||
paintBody(p, projects === null ? '<p class="ws-line">Projects unavailable. The organization did not answer the project read.</p>' : '<p class="ws-line">This project is not in the organization\'s project list.</p>');
|
||
return what.id;
|
||
}
|
||
const threads = Array.isArray(threadsRead?.rows) ? threadsRead.rows : [];
|
||
const head = window.MosaicProjects.header(project, what.section, threads);
|
||
const conv = what.section === 'conversations' ? conversations(project, threads, threadsRead) : null;
|
||
const key = JSON.stringify([org, project.id, what.section, head, conv]);
|
||
const { body } = e;
|
||
if (p.project?.key !== key) {
|
||
const kept = capture(p, body);
|
||
body.innerHTML = `<div class="chat-area pane-project">${head}${conv ?? '<div data-project-content>Reading…</div>'}</div>`;
|
||
p.html = null; p.project = { key };
|
||
rewrite(p, body);
|
||
restore(p, body, kept);
|
||
}
|
||
const content = body.querySelector('[data-project-content]');
|
||
if (content) await window.MosaicProjects.mountContent({ container: content, project, threads, section: what.section, canSend: false, org, pane: true, views: viewsOf(p, org), idPrefix: `pane-${p.key}-` });
|
||
return what.section === 'overview' ? project.name || project.id : `${project.name || project.id} · ${sectionName}`;
|
||
}
|
||
// A pane's request choice and PRD disclosure, per organization, kept on the pane so a repaint
|
||
// that replaces the project content keeps them.
|
||
function viewsOf(p, org) {
|
||
if (!p.views.has(org)) p.views.set(org, { selected: new Map(), expanded: new Set() });
|
||
return p.views.get(org);
|
||
}
|
||
function conversations(project, threads, read) {
|
||
if (!read) return '<p class="ws-line">Conversations unavailable.</p>';
|
||
const own = threads.filter(t => t && !t.shared && t.project === project.id && typeof t.id === 'string');
|
||
const rows = own.map(t => `<a class="project-conversation-row" href="#/projects/threads/${enc(t.id)}" data-focus-key="${esc(`conv:${t.id}`)}"><span class="project-conversation-icon" aria-hidden="true">◌</span><span><strong>${esc(t.name || t.id)}</strong><small>With ${esc(t.instance || 'no agent recorded')}</small></span><span aria-hidden="true">›</span></a>`).join('');
|
||
return `<div class="project-section-title"><h2>Conversations</h2></div><div data-project-conversations>${rows || '<p>No conversations yet.</p>'}</div><p class="ws-line">A conversation opens in its full view.</p>`;
|
||
}
|
||
|
||
// ---------- the bar, tabs, divider and layout ----------
|
||
function paintBar() {
|
||
if (!mounted) return;
|
||
const { root, panes, show } = mounted, two = panes.length === 2;
|
||
setText(root.querySelector('[data-sbs-note]'), `${panes.length} ${panes.length === 1 ? 'pane' : 'panes'} · each pane reads its own organization's bus and keeps its own state`);
|
||
const tabs = root.querySelector('[data-sbs-tabs]'), focusedTab = tabs.contains(document.activeElement) ? document.activeElement.dataset.paneShow : null;
|
||
const list = listCache;
|
||
const html = panes.map(p => {
|
||
const org = list?.find(o => o?.id === p.org);
|
||
return `<button type="button" data-pane-show="${p.key}" aria-pressed="${show === p.key}" aria-controls="pane-${p.key}">${org ? ws().av(org, 'xs') : ''}<span>${esc(p.title || 'Reading…')}</span></button>`;
|
||
}).join('');
|
||
if (tabs.innerHTML !== html) { tabs.innerHTML = html; if (focusedTab) tabs.querySelector(`[data-pane-show="${focusedTab}"]`)?.focus({ preventScroll: true }); }
|
||
const add = root.querySelector('[data-pane-add]');
|
||
add.disabled = two; add.title = two ? 'Side by side holds two panes. Close one to choose another.' : 'Open a second pane';
|
||
for (const p of panes) { const c = p.el.querySelector('[data-pane-close]'); c.hidden = !two; }
|
||
}
|
||
function layout() {
|
||
if (!mounted) return;
|
||
const { root, panes, w, show } = mounted, two = panes.length === 2;
|
||
const box = root.querySelector('[data-sbs-panes]'), divider = root.querySelector('[data-sbs-divider]');
|
||
box.classList.toggle('two', two);
|
||
box.style.setProperty('--sbs-a', `${w}fr`); box.style.setProperty('--sbs-b', `${100 - w}fr`);
|
||
divider.hidden = !two;
|
||
divider.setAttribute('aria-valuenow', String(w));
|
||
divider.setAttribute('aria-valuetext', `Left pane ${w} percent, right pane ${100 - w} percent`);
|
||
root.querySelector('#pane-b').hidden = !two;
|
||
for (const p of panes) p.el.classList.toggle('alt', show !== p.key);
|
||
fit();
|
||
}
|
||
// Wide screens: the panes fill the window below the bar and each scrolls on its own.
|
||
const wide = window.matchMedia('(min-width: 761px)');
|
||
function fit() {
|
||
if (!mounted) return;
|
||
const { root } = mounted;
|
||
if (!wide.matches) { root.style.height = ''; return; }
|
||
const foot = document.querySelector('body > .foot, .foot')?.getBoundingClientRect().height || 0;
|
||
const top = root.getBoundingClientRect().top;
|
||
root.style.height = `${Math.max(360, Math.floor(window.innerHeight - Math.max(top, 0) - foot))}px`;
|
||
}
|
||
function setWidth(w, persist = true) {
|
||
if (!mounted) return;
|
||
const next = clampW(w);
|
||
if (next === mounted.w) return;
|
||
mounted.w = next; layout(); if (persist) writeUrl();
|
||
}
|
||
|
||
// ---------- events (bound once to the mount root) ----------
|
||
function bind(root) {
|
||
const divider = root.querySelector('[data-sbs-divider]');
|
||
divider.addEventListener('keydown', e => {
|
||
const w = mounted?.w; if (w === undefined) return;
|
||
const next = { ArrowLeft: w - STEP, ArrowDown: w - STEP, ArrowRight: w + STEP, ArrowUp: w + STEP, PageDown: w - 10, PageUp: w + 10, Home: MIN, End: MAX }[e.key];
|
||
if (next === undefined) return;
|
||
e.preventDefault(); setWidth(next);
|
||
});
|
||
divider.addEventListener('pointerdown', e => {
|
||
if (e.button !== 0) return;
|
||
e.preventDefault(); divider.focus({ preventScroll: true }); divider.setPointerCapture(e.pointerId); divider.classList.add('dragging');
|
||
const box = root.querySelector('[data-sbs-panes]').getBoundingClientRect();
|
||
const move = ev => setWidth(((ev.clientX - box.left) / box.width) * 100, false);
|
||
const up = () => { divider.removeEventListener('pointermove', move); divider.removeEventListener('pointerup', up); divider.removeEventListener('pointercancel', up); divider.classList.remove('dragging'); writeUrl(); };
|
||
divider.addEventListener('pointermove', move); divider.addEventListener('pointerup', up); divider.addEventListener('pointercancel', up);
|
||
});
|
||
root.addEventListener('change', e => {
|
||
const pick = e.target.closest?.('[data-pane-pick]'); if (!pick || !mounted) return;
|
||
const p = mounted.panes.find(x => x.el.contains(pick)), next = parsePane(pick.value);
|
||
if (!p || !next) return;
|
||
go(p, next, false);
|
||
});
|
||
root.addEventListener('click', e => {
|
||
if (!mounted) return;
|
||
const show = e.target.closest?.('[data-pane-show]');
|
||
if (show) { mounted.show = show.dataset.paneShow === 'b' && mounted.panes.length === 2 ? 'b' : 'a'; layout(); paintBar(); writeUrl(); return; }
|
||
if (e.target.closest?.('[data-pane-add]')) { void addPane(); return; }
|
||
const close = e.target.closest?.('[data-pane-close]');
|
||
if (close) { closePane(mounted.panes.find(x => x.el.contains(close))); return; }
|
||
// A plain click on a link to a page a pane draws, in the pane's own organization, opens it in
|
||
// the pane. Anything else (another organization, a page a pane does not draw, a new tab) is
|
||
// an ordinary link to the full view.
|
||
const a = e.target.closest?.('a[href^="#/orgs/"]');
|
||
if (!a || a.hasAttribute('data-pane-full') || e.defaultPrevented || e.button !== 0 || e.metaKey || e.ctrlKey || e.shiftKey || e.altKey) return;
|
||
const p = mounted.panes.find(x => x.el.contains(a)); if (!p) return;
|
||
const m = /^#\/orgs\/([^/?#]+)(\/[^?#]*)$/.exec(a.getAttribute('href'));
|
||
let org, route;
|
||
try { org = decodeURIComponent(m?.[1] ?? ''); route = decodeURIComponent(m?.[2] ?? ''); } catch { return; }
|
||
if (org !== p.org || !page(route)) return;
|
||
e.preventDefault();
|
||
go(p, { org, route }, true);
|
||
});
|
||
}
|
||
function go(p, next, focusHead) {
|
||
p.org = next.org; p.route = next.route; p.html = null; p.project = null; p.title = null;
|
||
els(p).body.scrollTop = 0;
|
||
writeUrl();
|
||
void drawPane(p, { focusHead });
|
||
}
|
||
async function addPane() {
|
||
if (!mounted || mounted.panes.length !== 1) return;
|
||
const before = document.activeElement;
|
||
const [a] = mounted.panes, list = await orgList();
|
||
if (!mounted || mounted.panes.length !== 1) return;
|
||
const other = (list || []).find(o => o && !o.invalid && o.id !== a.org && ORG.test(o.id));
|
||
const b = makePane('b', other ? { org: other.id, route: '/organization' } : { org: a.org, route: a.route === '/agents' ? '/organization' : '/agents' });
|
||
mounted.panes.push(b); mounted.show = 'b';
|
||
layout(); paintBar(); writeUrl();
|
||
await drawPane(b);
|
||
if (mounted?.panes.includes(b) && mayFocus(b, before)) els(b).pick.focus({ preventScroll: true });
|
||
}
|
||
function closePane(p) {
|
||
if (!mounted || !p || mounted.panes.length !== 2) return;
|
||
clearTimeout(p.timer); p.turn++;
|
||
const keep = mounted.panes.find(x => x !== p);
|
||
// The remaining pane becomes the first: its page moves into pane a's element.
|
||
const a = mounted.panes[0];
|
||
if (keep !== a) {
|
||
const b = mounted.panes[1];
|
||
clearTimeout(b.timer); b.turn++;
|
||
a.org = keep.org; a.route = keep.route; a.html = null; a.project = null; a.title = keep.title; a.views = keep.views;
|
||
}
|
||
setHtml(els(mounted.panes[1]).body, ''); mounted.panes[1].html = null; mounted.panes[1].project = null;
|
||
mounted.panes = [a]; mounted.show = 'a';
|
||
layout(); paintBar(); writeUrl();
|
||
// The close button just left the page; focus goes to the remaining pane's picker now, and again
|
||
// after its draw only if the viewer has not moved elsewhere meanwhile.
|
||
els(a).pick.focus({ preventScroll: true });
|
||
const before = document.activeElement;
|
||
void drawPane(a).then(() => { if (mounted?.panes[0] === a && mayFocus(a, before)) els(a).pick.focus({ preventScroll: true }); });
|
||
}
|
||
function makePane(key, at) {
|
||
const el = mounted.root.querySelector(`#pane-${key}`);
|
||
return { key, el, org: at.org, route: at.route, turn: 0, timer: null, html: null, project: null, title: null, views: new Map() };
|
||
}
|
||
|
||
// ---------- public ----------
|
||
async function mount(container, query, { navigated = false } = {}) {
|
||
unmount();
|
||
const gen = ++mountGen;
|
||
container.innerHTML = frame();
|
||
const root = container.querySelector('[data-side-by-side]');
|
||
mounted = { root, panes: [], w: 50, show: 'a', gen, observers: [] };
|
||
// projects.js paints a project's content after its own reads; its links are rewritten as they
|
||
// land. One observer per pane element for the life of the mount, applying whichever pane object
|
||
// holds that element now, so a closed and re-added pane never runs an old organization's rewrite.
|
||
const m = mounted;
|
||
for (const key of ['a', 'b']) {
|
||
const body = root.querySelector(`#pane-${key} [data-pane-body]`);
|
||
const observer = new MutationObserver(() => {
|
||
if (mounted !== m) return;
|
||
const p = m.panes.find(x => x.key === key);
|
||
if (p) rewrite(p, body);
|
||
});
|
||
observer.observe(body, { childList: true, subtree: true });
|
||
m.observers.push(observer);
|
||
}
|
||
bind(root);
|
||
window.addEventListener('resize', fit);
|
||
document.title = 'Side by side · Mosaic Console';
|
||
if (navigated) root.querySelector('h1').focus({ preventScroll: true });
|
||
let wanted = readQuery(query);
|
||
if (!wanted.named) { const kept = readQuery(load() || ''); if (kept.a) wanted = { ...kept, named: true }; }
|
||
let at = [wanted.a, wanted.b].filter(Boolean);
|
||
if (!at.length) at = await defaults();
|
||
if (!mounted || gen !== mountGen) return;
|
||
listCache = await orgList();
|
||
if (!mounted || gen !== mountGen) return;
|
||
mounted.panes = at.slice(0, 2).map((x, i) => makePane(i ? 'b' : 'a', x));
|
||
mounted.w = Number.isFinite(wanted.w) && wanted.w ? clampW(wanted.w) : 50;
|
||
mounted.show = wanted.show === 'b' && mounted.panes.length === 2 ? 'b' : 'a';
|
||
layout(); paintBar(); writeUrl();
|
||
await Promise.all(mounted.panes.map(p => drawPane(p)));
|
||
}
|
||
function unmount() {
|
||
if (!mounted) return;
|
||
for (const p of mounted.panes) { clearTimeout(p.timer); p.turn++; }
|
||
for (const o of mounted.observers) o.disconnect();
|
||
window.removeEventListener('resize', fit);
|
||
mounted = null; mountGen++;
|
||
}
|
||
// The Console's Refresh: both panes read again now, each keeping its own focus and scroll.
|
||
function refresh() {
|
||
if (!mounted) return;
|
||
projectReads = new Map();
|
||
void orgList(true).then(rows => { if (rows) listCache = rows; });
|
||
for (const p of mounted.panes) void drawPane(p, { fresh: true });
|
||
}
|
||
// E2E6 P2-2: a pane showing the organization a write changed reads it again.
|
||
document.addEventListener('mosaic-org-changed', e => {
|
||
if (!mounted) return;
|
||
for (const p of mounted.panes) if (p.org === e.detail?.org) void drawPane(p, { fresh: true });
|
||
});
|
||
// The list the tabs draw from follows each fresh read of the organization list.
|
||
document.addEventListener('mosaic-org-list', e => { if (Array.isArray(e.detail?.rows)) listCache = e.detail.rows; });
|
||
|
||
window.MosaicPanes = Object.freeze({ mount, unmount, refresh, page });
|
||
})();
|