diff --git a/.woodpecker.yml b/.woodpecker.yml index 9ffd29e..6e284d8 100644 --- a/.woodpecker.yml +++ b/.woodpecker.yml @@ -31,6 +31,10 @@ steps: - name: tests image: bash commands: + # Sync pins: the app copies of the shared modules are byte-identical to + # the canonical revisions in ops-docs (any hand edit goes red here). + - python3 tests/test_oidc_sync.py + - python3 tests/test_chart_sync.py - python3 tests/test_guest_guard.py # Run every harness even when one fails, then fail the step — a plain # command chain would hide all failures after the first. diff --git a/app/coop_chart.js b/app/coop_chart.js new file mode 100644 index 0000000..d1a4953 --- /dev/null +++ b/app/coop_chart.js @@ -0,0 +1,261 @@ +/* Inference Cooperative — shared hand-rolled chart module. + * + * Canonical copy: co-op/ops-docs repo, scripts/shared/coop_chart.js. + * Byte-identical copies ship in admin-panel/app/ and member-dashboard/app/ + * (each repo's tests/test_chart_sync.py pins its copy to this revision — CI + * has no ops-docs checkout). Editing a copy by hand is a dead end: edit the + * canonical file and run ops-docs/scripts/sync-chart-module.sh, which + * re-copies and re-pins both repos in one step. + * + * No chart library, no CDN (the co-op's no-external-dependency rule applies + * to charts like everything else). Colors come from each app's CSS vars, so a + * chart matches the tables around it. The module exposes ONE global, + * CoOpChart; each app's page JS destructures the pieces it needs, so call + * sites keep their bare function names. + * + * Tooltips — exact values on hover (the panel's registerChartTips contract): + * 1. At render time, stamp each hoverable data element with + * data-tip-host="" and data-tip-i="" + * 2. registerChartTips("", points) with one point per index: + * { label: "2026-11-07", series: [["Spend", "$12.34"], ...] } + * Values MUST come from the chart's own data arrays (exact), never + * pixel-estimated, and `series` carries EVERY series at that x. + * One delegated listener set on document serves every chart, so innerHTML + * re-renders need no re-binding and new charts join chart-by-chart as they + * render. The box is a fixed-position div with pointer-events:none, clamped + * inside the viewport. NULL points get no stamp and no tooltip (the gap + * rule). Styling lives in each app's .chart-tip CSS block. + * + * Drawing helpers — extracted from the admin panel's chart code so both apps + * produce the same shapes from the same code: + * niceStep(raw, continuous) axis step. continuous=true: the 1/2/5 x 10^k + * rule (money, energy, carbon — ticks read $10, + * not $4.92). false: whole counts rounded up to + * a half power of ten, never below 1 (a + * 2,900-request day reads 3,000; a near-empty + * series still gets an integer axis). + * measuredRuns(vals) contiguous non-null index runs. A NULL metric + * renders as a GAP, never a zero, and the line + * is never drawn through unmeasured history. + * chartFrame(cfg) opens the SVG, draws gridlines + y labels + * (top = one round step x 4 ticks, so labels + * land on round numbers by construction). + * dateMarks(fr, days) 3 x-axis date labels (start/mid/end). + * drawBars(fr, vals, opts) bars; NULLs skipped (no zero bars). + * drawLineRuns(fr, vals, opts) lines broken into measured runs. + * hoverTargets(fr, vals, host) transparent hover circles on measured points. + */ +(function (global) { + "use strict"; + + // HTML escaping, self-contained: identical mapping to both apps' esc() / + // escapeHtml(), so tooltip output bytes match what each app rendered before. + function esc(s) { + return String(s).replace(/[&<>"']/g, c => ({'&':'&','<':'<','>':'>','"':'"',"'":'''}[c])); + } + + // ---- Chart tooltips: exact values on hover ---- + const chartTipData = {}; // hostId -> [{ label, series: [[name, value], ...] }] + let chartTipBox = null; // the singleton tooltip div, created on first use + let chartTipCur = null; // { host, idx } the point currently shown + + function registerChartTips(hostId, points) { chartTipData[hostId] = points; } + + function chartTipTarget(el) { + return el && el.closest ? el.closest("[data-tip-host]") : null; + } + + function hideChartTip() { + chartTipCur = null; + if (chartTipBox) chartTipBox.style.display = "none"; + } + + function showChartTip(hostId, idx, cx, cy) { + const p = (chartTipData[hostId] || [])[idx]; + if (!p) { hideChartTip(); return; } + if (!chartTipBox) { + chartTipBox = global.document.createElement("div"); + chartTipBox.className = "chart-tip"; + global.document.body.appendChild(chartTipBox); + } + const same = chartTipCur && chartTipCur.host === hostId && chartTipCur.idx === idx; + if (!same) { + let html = '
' + esc(p.label) + "
"; + for (let s = 0; s < p.series.length; s++) { + html += '
' + esc(p.series[s][0]) + "" + esc(p.series[s][1]) + "
"; + } + chartTipBox.innerHTML = html; + chartTipCur = { host: hostId, idx: idx }; + } + chartTipBox.style.display = "block"; + moveChartTip(cx, cy); + } + + // Position beside the pointer, flipped/clamped so the box stays fully inside + // the viewport at chart edges. + function moveChartTip(cx, cy) { + if (!chartTipBox || chartTipBox.style.display === "none") return; + const pad = 12, m = 4; + const w = chartTipBox.offsetWidth, h = chartTipBox.offsetHeight; + let x = cx + pad, y = cy + pad; + if (x + w > window.innerWidth - m) x = cx - pad - w; + if (x < m) x = m; + if (y + h > window.innerHeight - m) y = cy - pad - h; + if (y < m) y = m; + chartTipBox.style.left = x + "px"; + chartTipBox.style.top = y + "px"; + } + + document.addEventListener("pointerover", (e) => { + const t = chartTipTarget(e.target); + if (!t) return; + showChartTip(t.getAttribute("data-tip-host"), parseInt(t.getAttribute("data-tip-i"), 10), e.clientX, e.clientY); + }); + document.addEventListener("pointermove", (e) => { + const t = chartTipTarget(e.target); + if (!t) return; + const host = t.getAttribute("data-tip-host"); + const idx = parseInt(t.getAttribute("data-tip-i"), 10); + const cur = chartTipCur; + if (!cur || cur.host !== host || cur.idx !== idx) showChartTip(host, idx, e.clientX, e.clientY); + else moveChartTip(e.clientX, e.clientY); + }); + document.addEventListener("pointerout", (e) => { + const from = chartTipTarget(e.target); + if (!from) return; + const to = e.relatedTarget ? chartTipTarget(e.relatedTarget) : null; + if (!to || to.getAttribute("data-tip-host") !== from.getAttribute("data-tip-host")) hideChartTip(); + }); + // Basic touch: tap/drag shows and follows, release hides it after a beat. + document.addEventListener("pointerup", (e) => { + if (e.pointerType === "touch") setTimeout(hideChartTip, 1600); + }); + document.addEventListener("pointercancel", hideChartTip); + // Scrolling or resizing moves the chart under a fixed-position box - hide + // rather than show a tooltip for the wrong point. + window.addEventListener("scroll", hideChartTip, { passive: true }); + window.addEventListener("resize", hideChartTip); + + // ---- Axis step (see header: continuous vs count rule) ---- + function niceStep(raw, continuous) { + if (continuous) { + const mag = Math.pow(10, Math.floor(Math.log10(Math.max(raw, 1e-9)))); + const norm = raw / mag; + const nice = norm <= 1 ? 1 : (norm <= 2 ? 2 : (norm <= 5 ? 5 : 10)); + return nice * mag; + } + const p = Math.pow(10, Math.floor(Math.log10(Math.max(raw, 1)))); + return Math.max(1, Math.ceil(raw / (p / 2)) * (p / 2)); + } + + // ---- Contiguous measured runs: a NULL day stays a gap ---- + function measuredRuns(vals) { + const runs = []; + let run = []; + for (let i = 0; i < vals.length; i++) { + if (vals[i] === null || vals[i] === undefined) { if (run.length) runs.push(run); run = []; } + else run.push(i); + } + if (run.length) runs.push(run); + return runs; + } + + // ---- Frame: opens the SVG, draws gridlines + y-tick labels ---- + // cfg: { n, top, step, tickLabel(v)->string, aria, W, H, padL, padR, padT, + // padB, gridStroke }. Defaults match the panel's chart geometry + // (W 1000, H 250, padL 62, padR 14, padT 14, padB 30). + // Axis top = one round step times four ticks: labels land on round numbers + // and the peak still clears the frame. + function chartFrame(cfg) { + const W = cfg.W || 1000, H = cfg.H || 250; + const padL = cfg.padL === undefined ? 62 : cfg.padL; + const padR = cfg.padR === undefined ? 14 : cfg.padR; + const padT = cfg.padT === undefined ? 14 : cfg.padT; + const padB = cfg.padB === undefined ? 30 : cfg.padB; + const plotW = W - padL - padR, plotH = H - padT - padB; + const baseY = padT + plotH; + const n = cfg.n; + const xAt = i => padL + (n <= 1 ? plotW / 2 : (plotW * i) / (n - 1)); + const yAt = v => baseY - (plotH * v) / cfg.top; + const parts = []; + parts.push(''); + for (let g = 0; g <= 4; g++) { + const yy = baseY - (plotH * g) / 4; + parts.push(''); + parts.push('' + cfg.tickLabel(cfg.step * g) + ''); + } + return { W, H, padL, padR, baseY, n, xAt, yAt, parts }; + } + + // ---- X-axis date marks: start / middle / end, day strings YYYY-MM-DD ---- + function dateMarks(fr, days) { + const marks = fr.n > 2 ? [0, Math.floor((fr.n - 1) / 2), fr.n - 1] : [0, fr.n - 1]; + for (let mi = 0; mi < marks.length; mi++) { + const i = marks[mi]; + const anchor = mi === 0 ? "start" : (mi === marks.length - 1 ? "end" : "middle"); + fr.parts.push('' + String(days[i]).slice(5) + ''); + } + } + + // ---- Bars. opts: { color, host } — host stamps the elements for tooltips. + // NULL values are skipped (no zero bars, no tooltip on an unmeasured day). + function drawBars(fr, vals, opts) { + const bw = Math.max(1, (fr.W - fr.padL - fr.padR) / fr.n - 1); + for (let i = 0; i < fr.n; i++) { + const v = vals[i]; + if (v === null || v === undefined) continue; + const yy = fr.yAt(v); + fr.parts.push('"); + } + } + + // ---- Lines broken into contiguous measured runs. opts: + // color stroke (and default fill for single-point dots) + // area draw the fill-under-line area path (panel Trends style) + // areaColor / areaOpacity area fill override (defaults: color / 0.10) + // dotSingle draw a dot (r = dotR, default 3) for a 1-point run instead of + // nothing — a single measured day still shows (money style) + function drawLineRuns(fr, vals, opts) { + const runs = measuredRuns(vals); + for (let s = 0; s < runs.length; s++) { + const r0 = runs[s]; + if (opts.area) { + fr.parts.push(' fr.xAt(i) + "," + fr.yAt(vals[i])).join(" L") + " L" + fr.xAt(r0[r0.length - 1]) + "," + fr.baseY + ' Z" fill="' + (opts.areaColor || opts.color) + '" fill-opacity="' + (opts.areaOpacity === undefined ? "0.10" : opts.areaOpacity) + '"/>'); + } + if (r0.length > 1 || opts.area) { + fr.parts.push(''); + } else if (opts.dotSingle) { + // A single measured day (e.g. the first balance snapshot) still shows. + fr.parts.push(''); + } + } + } + + // ---- Hover targets: one transparent circle per measured point; the + // tooltip lists every series at that x. NULL points get no stamp. + function hoverTargets(fr, vals, host) { + for (let i = 0; i < fr.n; i++) { + const v = vals[i]; + if (v === null || v === undefined) continue; + fr.parts.push(''); + } + } + + // chartTipData is exported for inspection (harnesses assert on the exact + // registered points); treat it as read-only in page code. + global.CoOpChart = { + chartTipData, + registerChartTips, + chartTipTarget, + hideChartTip, + showChartTip, + moveChartTip, + niceStep, + measuredRuns, + chartFrame, + dateMarks, + drawBars, + drawLineRuns, + hoverTargets + }; +})(typeof globalThis !== "undefined" ? globalThis : window); diff --git a/app/main.py b/app/main.py index 2d29404..7a3c5c6 100644 --- a/app/main.py +++ b/app/main.py @@ -18,6 +18,7 @@ Environment (Cloudron env vars): import os import logging +from pathlib import Path import httpx from fastapi import FastAPI, Request, HTTPException @@ -347,6 +348,12 @@ def render_page() -> str: return PAGE_HTML +# The shared chart module (canonical: ops-docs scripts/shared/coop_chart.js, +# byte-identical copy at app/coop_chart.js — tests/test_chart_sync.py pins it) +# is spliced into the page's single @@ -643,6 +650,7 @@ PAGE_HTML = """ ", html, re.S) if len(blocks) != 1: sys.exit(f"expected exactly 1