@@ -126,6 +137,12 @@ function SelectionList({ slices, currentTotals, onRemove, onClear }) { return (
| + {seg.name} + + final + + | + {measures.map(m => ( ++ {m.key === 'price' ? fmtNum(priceOf(seg), m.dp) : fmtNum(seg[m.key], m.dp)} + | + ))} +||||||||||
| )} | |||||||||||
| - {exclName} · fixed - | - {measures.map(m => ( -- {m.key === 'price' ? fmtNum(priceOf(excl), m.dp) : fmtNum(excl[m.key], m.dp)} - | - ))} -||||||||||
| + Nothing in this selection can be adjusted — all of it is {exclName}, + loaded as {(currentTotals?.excludedIters || []).join(' / ') || 'reference'}. + | +|||||||||||
| )} |
| # | -seq | -note | -counts toward | +kind | +label | +note | +counts toward | rows | {log[0]?.value_col || 'value'} | by | @@ -473,11 +477,11 @@ export default function Baseline({ sources = [], sourceId, versions = [], versio|
|---|---|---|---|---|---|---|---|---|---|---|---|
| No segments loaded yet | |||||||||||
| No segments loaded yet | |||||||||||
| + | |||||||||||
| + |
-
- setDescription(e.target.value)} placeholder="e.g. FY25 actuals +1yr" className="border border-gray-200 rounded px-2 py-1.5 text-sm flex-1 max-w-sm" />
-
- )}
-
{/* Filters */}
@@ -830,8 +843,24 @@ function SegmentForm({
)}
- {/* Note + submit */}
-
+ {/* Label, bucket, note + submit.
+ Label and bucket are presentation: the label is what the pivot shows for
+ this segment, the bucket is what it counts toward. Both are free text and
+ both sort by what is typed, so a leading "01 - " is how ordering is set —
+ which is why they belong here, at the point the segment is defined, as
+ well as being editable in the list afterwards. */}
+
+
+
+ setSegLabel(e.target.value)}
+ placeholder="defaults to the note" className={`${baseInp} text-sm py-1.5`} />
+
+
+
+ setSegBucket(e.target.value)}
+ list="pf-bucket-options" placeholder="e.g. 02 - Forecast"
+ className={`${baseInp} text-sm py-1.5`} />
+
setSegNote(e.target.value)} placeholder="optional" className={`${baseInp} text-sm py-1.5`} />
diff --git a/ui/src/views/Forecast.jsx b/ui/src/views/Forecast.jsx
index b85d8fc..3618c8f 100644
--- a/ui/src/views/Forecast.jsx
+++ b/ui/src/views/Forecast.jsx
@@ -12,13 +12,24 @@ import '@perspective-dev/viewer/inline'
import '@perspective-dev/viewer-datagrid'
import '@perspective-dev/viewer/themes'
+// Slice keys that are not col_meta columns: computed from pf.log when the rows are
+// served, so they are real columns in the loaded table but have to be resolved back
+// to log ids server-side. Mirrors COMPUTED_SLICE_COLS in lib/sql_generator.js.
+const COMPUTED_SLICE_COLS = new Set(['pf_segment', 'pf_bucket'])
+
const LAYOUT_KEY = (vid) => `pf_layout_v${vid}` // last-used layout (auto restore)
const LAYOUTS_KEY = (vid) => `pf_layouts_v${vid}` // named layout list
function cleanLayout(cfg, validCols) {
if (!cfg) return cfg
const c = { ...cfg }
- const exprNames = new Set(Object.keys(cfg.expressions || {}))
+ // Dead expressions go before the axis filter, not after: dropping them from
+ // `expressions` is what makes `ok()` reject them everywhere else.
+ if (DEAD_ORDER_EXPRS.some(n => c.expressions?.[n] !== undefined)) {
+ c.expressions = { ...c.expressions }
+ for (const name of DEAD_ORDER_EXPRS) delete c.expressions[name]
+ }
+ const exprNames = new Set(Object.keys(c.expressions || {}))
const ok = (col) => validCols.has(col) || exprNames.has(col)
if (c.columns) c.columns = c.columns.filter(col => col == null || ok(col))
if (c.group_by) c.group_by = c.group_by.filter(ok)
@@ -30,111 +41,40 @@ function cleanLayout(cfg, validCols) {
return c
}
-// Ordering for the pf_bucket and pf_segment column groups, as Perspective
-// expression columns.
+// Expression columns this view used to manage, back when the pf_bucket and
+// pf_segment ordering prefix was computed in the pivot rather than stored in
+// pf.log.label.
//
-// Perspective orders column groups by the value string, and SortDir's `col asc` /
-// `col desc` only reverses that — so Prior Year → Plan → Actual → Forecast is
-// expressible as neither, being alphabetical in neither direction. The order has
-// to be part of the value, as a "01 · " prefix.
-//
-// Done as expressions rather than in SQL. The prefix is a pivot-ordering concern,
-// and computing it server-side put it in every other reader too: the change log
-// and the bridge's basis list would both show "04 · Forecast". As expressions it
-// stays in the pivot, lives in ViewConfig so it travels with saved layouts, and
-// reordering takes effect immediately instead of needing a reload.
-//
-// Syntax per rust/perspective-client/src/rust/config/expressions.rs: columns in
-// double quotes, string literals in single, if/else with braces. The ordered
-// label is emitted as a literal rather than built with concat() — fewer moving
-// parts, and the mapping is known here anyway.
-// pf_ prefixed like every other column the server synthesises, so they sort
-// beside pf_bucket and pf_segment in the column list and cannot be mistaken for
-// source data. "Bucket" and "Segment" were the first choice and are too close to
-// the real thing -- segment_new is an actual column on this source -- and an
-// expression named after an existing column would shadow or reject rather than
-// merely confuse.
-const ORDER_EXPR_NAMES = { bucket: 'pf_bucket_ord', segment: 'pf_segment_ord' }
-
-// Removed from any config that still carries them. They are no longer managed
-// names, so without this they would sit in saved layouts forever, ordering by a
-// rule nothing updates.
-const LEGACY_ORDER_EXPR_NAMES = ['Bucket', 'Segment']
-
-// ASCII only, and " - " specifically because the source data already reads
-// "07 - Dec". A middle dot was the first choice and ExprTK rejects it: its string
-// scanner tests each *byte* with
-//
-// is_valid_string_char(c) = isprint((unsigned char) c) || is_whitespace(c)
-//
-// and "·" is U+00B7, two bytes 0xC2 0xB7 in UTF-8, of which isprint(0xC2) is
-// false in the C locale. The literal fails at that byte and the parser reports
-// from the start of it — "Invalid string token: 01".
-const ORDER_SEP = ' - '
-
-function orderedLabel(ord, label) {
- return `${String(ord).padStart(2, '0')}${ORDER_SEP}${label}`
-}
-
-// Same byte rule applies to the label being matched, so a bucket named with
-// anything outside printable ASCII cannot appear in an expression at all. Such a
-// label is left unordered rather than emitted into an expression that will not
-// parse and take the whole column with it.
-function isExprSafe(v) {
- return /^[\x20-\x7e]*$/.test(String(v))
-}
-
-function sqlSafe(v) {
- return String(v).replace(/'/g, "''")
-}
-
-// Anything unlisted falls through to the raw column.\n// pairs: [[rawValue, ordinal], ...] or [[rawValue, ordinal, displayAs], ...] where
-// the third element renames the value as well as ordering it.
-function buildOrderExpression(sourceCol, pairs, extra = []) {
- const cases = [...pairs, ...extra]
- .filter(([label, ord]) => label && ord > 0 && isExprSafe(label))
- .sort((a, b) => a[1] - b[1])
- .map(([label, ord, displayAs]) =>
- `if ("${sourceCol}" == '${sqlSafe(label)}') { '${sqlSafe(orderedLabel(ord, displayAs || label))}' }`)
- if (cases.length === 0) return null
- return `${cases.join('\nelse ')}\nelse { "${sourceCol}" }`
-}
-
-// The server's synthetic segment labels. Unordered they sort *first*, not last:
-// '(' is 0x28 and digits begin at 0x30, so '(adjustment)' precedes '01 - ...'.
-// They get high ordinals instead, and lose the parentheses — those marked the
-// value as not-a-real-segment, which the ordinal now does.
-const SYNTHETIC_SEGMENTS = [
- ['(unlabeled load)', 98, 'Unlabeled'],
- ['(adjustment)', 99, 'Adjustments'],
-]
-
-// Build both expressions from the version's bucket_order and the log's seq values.
-function buildOrderExpressions(bucketOrder, logMeta) {
- const out = {}
-
- const buckets = (Array.isArray(bucketOrder) ? bucketOrder : [])
- .map((label, i) => [label, i + 1])
- const bucketExpr = buildOrderExpression('pf_bucket', buckets)
- if (bucketExpr) out[ORDER_EXPR_NAMES.bucket] = bucketExpr
-
- // Segments are ordered by pf.log.seq, keyed on the label the pivot shows —
- // which is the tag if there is one, else the note, the same precedence the
- // server uses to build pf_segment.
- const segs = Object.values(logMeta || {})
- .filter(m => m.seq != null && ['baseline', 'reference'].includes(m.operation))
- .map(m => [(m.tag || m.note || '').trim(), m.seq])
- const segExpr = buildOrderExpression('pf_segment', segs, SYNTHETIC_SEGMENTS)
- if (segExpr) out[ORDER_EXPR_NAMES.segment] = segExpr
-
- return out
-}
+// Stripped by cleanLayout, never created: a layout saved under that scheme still
+// names them, and without this they would sit there forever, ordering by a rule
+// nothing updates. They have to leave the axes at the same time as the
+// expressions themselves -- restore() rejects a config whose group_by or sort
+// names a column that no longer exists.
+const DEAD_ORDER_EXPRS = ['pf_bucket_ord', 'pf_segment_ord', 'Bucket', 'Segment']
export default function Forecast({ sources = [], sourceId, versions = [], versionId, refreshSources }) {
const { dark } = useTheme()
const [loading, setLoading] = useState(false)
const [largeDataset, setLargeDataset] = useState(false)
+ // The pivot's own filter, refreshed whenever the ledger recomputes. A ref
+ // rather than state: it is read at dispatch and at totals time, never
+ // rendered from directly, and making it state would re-run the totals effect
+ // that sets it.
+ const viewFilterRef = useRef([])
const [loadProgress, setLoadProgress] = useState(null) // { received, total }
+ // Rows the load is waiting on, so the wait can say what it is waiting for --
+ // on this data the row count is the wait (see CLAUDE.md, "Load time is
+ // dominated by row count").
+ //
+ // Filled twice. X-Row-Count is exact but arrives with the response headers,
+ // and in grain mode the server aggregates before sending any: the number
+ // turned up just as the wait ended. So the forecast table's own count goes in
+ // first, from the same table-info the status bar reads, and the exact figure
+ // replaces it when the headers land.
+ const [loadRows, setLoadRows] = useState(null)
+ // the same filter, for display: the panel has to show the scope it is acting
+ // inside or the slice it prints is not the slice that gets written
+ const [viewScope, setViewScope] = useState([])
const [msg, setMsg] = useState(null)
// layouts
@@ -401,13 +341,23 @@ export default function Forecast({ sources = [], sourceId, versions = [], versio
for (let c = c0; c < c1; c++) {
const key = userKeys[c]
if (!key) continue
+ // A column name is dimension values joined by | with the measure last, and
+ // only as many values as the axis currently shows -- collapse the column
+ // hierarchy and the deeper levels are simply absent. Mapping split_by
+ // positionally over every segment therefore read the measure as a value
+ // for the first collapsed dimension: a bucket subtotal came back as
+ // smon_e = 'sales_usd', which matches no row, so the operation silently
+ // had nothing to act on. Drop the measure, then map over what is left.
+ const segs = key.split('|').slice(0, -1)
const colFilters = splitBy
+ .slice(0, segs.length)
.map((col, ix) => {
- const v = key.split('|')[ix]
+ const v = segs[ix]
return (v && !META_COL_RE.test(v)) ? [col, '==', v] : null
})
.filter(Boolean)
- const slice = sliceFromFilters([...base, ...rowFilters, ...colFilters])
+ const slice = sliceFromFilters([...base, ...rowFilters, ...colFilters],
+ (cfg.columns || []).filter(Boolean))
if (!Object.keys(slice).length) continue
const y = win.start_row + i
out.push({ slice, area: { x0: c, x1: c, y0: y, y1: y } })
@@ -487,14 +437,54 @@ export default function Forecast({ sources = [], sourceId, versions = [], versio
const dateNames = new Set(colMetaRef.current.filter(c => c.role === 'date').map(c => c.cname))
const ITER_ORDER = ['baseline', 'scale', 'recode', 'clone']
+ // A slice carries every value as a string -- it is built from filters the
+ // grid reports and from a payload that has to survive JSON. Perspective
+ // matches on type, so a string '2027' against an integer column does not
+ // filter to nothing, it is dropped: the ledger then totalled rows the pivot
+ // was hiding, which is how a season filter on sseas_e went unnoticed while
+ // the numbers disagreed by exactly the out-of-season rows.
+ // The pivot's own filter is not part of a clicked slice -- perspective-click
+ // reports only the cell's own dimensions -- so the ledger has to read it off
+ // the viewer and apply it alongside. Without this the ledger totals rows the
+ // grid is hiding, and the operation writes them: a grid scoped to
+ // sseas_e = 2027 gave a cell of 921,225.71 against a ledger of 956,485.13.
+ //
+ // Taken from viewer.save(), so the values are already in the table's own
+ // types and the operators are whatever the user set -- ranges and in-lists
+ // included, which a slice cannot express.
+ const viewFilter = await (async () => {
+ try {
+ const cfg = await viewerRef.current?.save()
+ return (cfg?.filter || []).filter(f => Array.isArray(f) && f.length >= 2)
+ } catch { return [] }
+ })()
+ viewFilterRef.current = viewFilter
+ setViewScope(viewFilter)
+
+ const schema = await tableRef.current.schema()
+ const typed = (col, val) => {
+ switch (schema[col]) {
+ case 'integer': case 'float': return Number(val)
+ case 'boolean': return val === true || val === 'true'
+ case 'date': case 'datetime': return Number(val)
+ default: return String(val)
+ }
+ }
+
async function totalsFor(sliceObj) {
+ // pf_segment and pf_bucket are computed server-side but are ordinary
+ // columns in the loaded table, so here they filter directly. They have to
+ // be applied, or the ledger totals a wider selection than the operation
+ // will write.
const filters = [
+ ...viewFilter,
...Object.entries(sliceObj)
- .filter(([col]) => dimNames.has(col))
- .map(([col, val]) => [col, '==', val]),
- ...Object.entries(sliceObj)
- .filter(([col]) => dateNames.has(col))
- .map(([col, val]) => [col, '==', Number(val)]),
+ .filter(([col]) => COMPUTED_SLICE_COLS.has(col) || dimNames.has(col) || dateNames.has(col)
+ || schema[col] !== undefined)
+ // a cell inside the filtered view cannot contradict it, so a repeated
+ // column is the same predicate twice and harmless
+ .filter(([col]) => !viewFilter.some(f => f[0] === col))
+ .map(([col, val]) => [col, '==', typed(col, val)]),
]
const view = await tableRef.current.view({ filter: filters })
const rows = await view.to_json()
@@ -507,7 +497,10 @@ export default function Forecast({ sources = [], sourceId, versions = [], versio
// rows the pivot shows but operations cannot write (usually 'reference').
// Kept separate rather than filtered away: the grid total includes them,
// so the panel has to account for them or the two disagree.
- const excluded = { value: 0, units: 0, rows: 0 }
+ // Per segment, not one lump: YTD Sales and Open Orders are different
+ // things, and a single "final" line hides which part of the number is
+ // which.
+ const excluded = { value: 0, units: 0, rows: 0, names: new Set(), bySegment: new Map() }
for (const r of rows) {
const k = r.pf_iter || '?'
const val = valueCol ? (parseFloat(r[valueCol]) || 0) : 0
@@ -517,6 +510,16 @@ export default function Forecast({ sources = [], sourceId, versions = [], versio
excluded.value += val
excluded.units += uni
excluded.rows += 1
+ // Name them by what they are, not by the iter band that happens to
+ // exclude them: "02 - Prior Year" means something to a forecaster,
+ // "reference" is the mechanism.
+ const name = String(r.pf_segment || 'excluded')
+ excluded.names.add(name)
+ const seg = excluded.bySegment.get(name) || { name, value: 0, units: 0, rows: 0 }
+ seg.value += val
+ seg.units += uni
+ seg.rows += 1
+ excluded.bySegment.set(name, seg)
continue
}
@@ -588,10 +591,25 @@ export default function Forecast({ sources = [], sourceId, versions = [], versio
value: acc.value + (ps.excluded?.value || 0),
units: acc.units + (ps.excluded?.units || 0),
rows: acc.rows + (ps.excluded?.rows || 0),
- }), { value: 0, units: 0, rows: 0 })
+ names: new Set([...acc.names, ...(ps.excluded?.names || [])]),
+ bySegment: (() => {
+ const m = acc.bySegment
+ for (const seg of (ps.excluded?.bySegment?.values?.() || [])) {
+ const t = m.get(seg.name) || { name: seg.name, value: 0, units: 0, rows: 0 }
+ t.value += seg.value; t.units += seg.units; t.rows += seg.rows
+ m.set(seg.name, t)
+ }
+ return m
+ })(),
+ }), { value: 0, units: 0, rows: 0, names: new Set(), bySegment: new Map() })
setCurrentTotals({
- byIter, byEntry, total, excluded, valueCol, unitsCol, perSlice,
+ byIter, byEntry, total, valueCol, unitsCol, perSlice,
+ excluded: {
+ ...excluded,
+ names: [...excluded.names].sort(),
+ bySegment: [...excluded.bySegment.values()].sort((a, b) => a.name.localeCompare(b.name)),
+ },
excludedIters: [...excludeIters],
})
} catch {
@@ -607,8 +625,9 @@ export default function Forecast({ sources = [], sourceId, versions = [], versio
const entries = await fetch(`/api/versions/${vid}/log`).then(r => r.json())
const map = {}
for (const e of entries) map[e.id] = {
+ label: e.label || null,
tag: e.tag || null, note: e.note || null, operation: e.operation,
- bucket: e.bucket || null, seq: e.seq ?? null,
+ bucket: e.bucket || null,
}
setLogMeta(map)
} catch { setLogMeta({}) }
@@ -653,11 +672,8 @@ export default function Forecast({ sources = [], sourceId, versions = [], versio
}, [sourceId, versionId])
useEffect(() => { refreshLogMeta(versionId) }, [versionId])
- // Reordering on the Baseline page takes effect here without a reload: the
- // expressions are rebuilt and the pivot re-renders.
- // Re-run when the ordering could have changed on the Baseline page. logMeta is
- // the signal, not the source: the function reads the ordering itself.
- useEffect(() => { if (tableRef.current) syncOrderExpressions() }, [logMeta, versionId])
+ // Relabelling on the Baseline page needs a reload to show here: the label is
+ // part of the aggregated row, so the pivot cannot re-derive it in place.
useEffect(() => { refreshTags(sourceId) }, [sourceId])
// Stream an Arrow IPC endpoint into one buffer, reporting download progress.
@@ -668,6 +684,7 @@ export default function Forecast({ sources = [], sourceId, versions = [], versio
if (!r.ok) { const { error } = await r.json(); throw new Error(error || 'Failed to load data') }
const rowCount = parseInt(r.headers.get('X-Row-Count') || '0')
const total = parseInt(r.headers.get('Content-Length') || '0') || null
+ if (rowCount) setLoadRows(rowCount)
const reader = r.body.getReader()
const chunks = []
let received = 0
@@ -704,6 +721,13 @@ export default function Forecast({ sources = [], sourceId, versions = [], versio
setLoading(true)
setLargeDataset(false)
setLoadProgress(null)
+ setLoadRows(null)
+ // deliberately not awaited: it is a count over the whole forecast table and
+ // the load must not wait on it
+ fetch(`/api/versions/${vid}/table-info`)
+ .then(r => r.ok ? r.json() : null)
+ .then(info => { if (info?.rows && initIdRef.current === myId) setLoadRows(n => n ?? info.rows) })
+ .catch(() => {})
setSlices([])
setExpandDepth(null)
adoptSplit([], 0)
@@ -804,19 +828,12 @@ export default function Forecast({ sources = [], sourceId, versions = [], versio
adoptSplit(cfg.split_full?.length ? cfg.split_full : cfg.split_by, (cfg.split_by || []).length)
}
- // auto-persist viewer state (formatting, columns, etc.) to the last-used cache
- // After the layout, not before: restoring a saved config replaces
- // `expressions` wholesale, so expressions applied earlier were being wiped
- // by the very next line and the ordering columns never appeared in the
- // column list.
+ // Its own try: the restore above has one, but this sits outside it, and a
+ // throw here would abort the rest of initViewer silently.
try {
- await syncOrderExpressions()
await ensureRowLabelWidth()
} catch (err) {
- // Its own try covers only restore(); save() and the builders sit outside
- // it, and a throw there would abort the rest of initViewer silently.
- console.error('[pf-order] threw', err)
- flash(`Column ordering failed: ${err.message || err}`, 'error')
+ console.error('[pf-layout] threw', err)
}
if (viewer._pspUpdate) viewer.removeEventListener('perspective-config-update', viewer._pspUpdate)
@@ -845,7 +862,8 @@ export default function Forecast({ sources = [], sourceId, versions = [], versio
if (!detail.row) return
const config = await viewer.save()
if (!(config.group_by || []).length) return
- const s = sliceFromFilters((detail.config || {}).filter || [])
+ const s = sliceFromFilters((detail.config || {}).filter || [],
+ (config.columns || []).filter(Boolean))
if (!Object.keys(s).length) return
// the CustomEvent carries no modifier flags, so read them off the
// mousedown that produced it (captured on window below)
@@ -871,6 +889,7 @@ export default function Forecast({ sources = [], sourceId, versions = [], versio
viewer.addEventListener('perspective-select', viewer._pspSelect)
gridRef.current = await viewer.getPlugin()
+ applyGroupRules()
setLargeDataset(false)
} catch (err) {
@@ -934,102 +953,75 @@ export default function Forecast({ sources = [], sourceId, versions = [], versio
}
}
- // Keep the ordering expressions in step with the version's bucket_order and the
- // log's seq values. Merged into the live config rather than replacing
- // expressions, so anything the user defined themselves survives.
+ // Rule off the column groups, and mark each group's subtotal.
//
- // Removing an ordering removes its column: leaving a stale Bucket expression
- // behind would keep ordering by an order that no longer exists.
- // Silent unless localStorage.pf_debug is set, like the rest of the tracing.
- // Kept rather than removed: it took several rounds to work out that this ran
- // before its inputs existed, and it will be wanted again.
- function dbgOrder(msg, extra) {
- try { if (!localStorage.getItem('pf_debug')) return } catch { return }
- if (extra === undefined) console.log(`[pf-order] ${msg}`)
- else console.log(`[pf-order] ${msg}`, extra)
- }
-
- // Fetches its own inputs rather than reading the `versions` prop and the
- // `logMeta` state.
+ // Scanning across "prior · plan · forecast, each with twelve months and a
+ // total" is twelve columns of identical-looking numbers with nothing to say
+ // where one domain ends and the next begins. The annual figures and the
+ // monthly ones read as one run.
//
- // Those are populated asynchronously, and this runs from initViewer — which
- // finishes well before them on a large load. It was therefore called with
- // versionFound: false and logMetaCount: 0 every time, could never build
- // anything, and the effect meant to re-run it once the data arrived never
- // fired. Two small queries are worth more than the right timing.
- async function syncOrderExpressions() {
- const viewer = viewerRef.current
- if (!viewer) return
+ // Done through regular_table's style listener rather than CSS: which column
+ // starts a group, and which one is a group's subtotal, are facts about the
+ // data that only the cell metadata knows. The listener runs on every draw, so
+ // it survives scrolling and virtualisation -- a stylesheet cannot, since the
+ // DOM cells are recycled across columns as you scroll.
+ // Blank for this purpose means "no value at this level", which Perspective
+ // writes as a zero-width space rather than an empty string.
+ const notBlank = (v) =>
+ v != null && String(v).replace(/[\s\u200b-\u200d\ufeff]/g, '') !== ''
- let bucketOrder = null
- let entries = []
- try {
- const [vers, log] = await Promise.all([
- fetch(`/api/sources/${sourceId}/versions`).then(r => r.ok ? r.json() : []),
- fetch(`/api/versions/${versionId}/log`).then(r => r.ok ? r.json() : []),
- ])
- bucketOrder = (Array.isArray(vers) ? vers : [])
- .find(v => String(v.id) === String(versionId))?.bucket_order ?? null
- entries = Array.isArray(log) ? log : []
- } catch (err) {
- console.error('[pf-order] could not read the ordering', err)
- return
+ function applyGroupRules() {
+ const grid = gridRef.current
+ const table = grid?.regular_table
+ if (!table || table._pfGroupRules) return
+ table._pfGroupRules = true
+
+ // The grid lives in a shadow root, so a stylesheet on the page cannot reach
+ // these cells. Inject into whichever root actually contains the table.
+ // currentColor rather than a fixed grey, so the rule follows the theme
+ // instead of vanishing against Pro Dark.
+ const root = table.getRootNode() || document
+ if (!root.querySelector('#pf-group-rules')) {
+ const style = document.createElement('style')
+ style.id = 'pf-group-rules'
+ style.textContent = `
+ td.pf-group-start { border-left: 2px solid currentColor; opacity: 1; }
+ td.pf-subtotal { font-weight: 600; background: color-mix(in srgb, currentColor 7%, transparent); }
+ `
+ ;(root.head || root).appendChild(style)
}
- const byId = Object.fromEntries(entries.map(e => [e.id, e]))
- const wanted = buildOrderExpressions(bucketOrder, byId)
- dbgOrder('inputs', {
- bucket_order: bucketOrder,
- seqs: entries.filter(e => e.seq != null).map(e => `${e.tag || e.note}=${e.seq}`),
- wanted: Object.keys(wanted),
- })
-
- const { table: _t, ...cfg } = await viewer.save()
- dbgOrder('saved config read', { existing: Object.keys(cfg.expressions || {}) })
- const current = cfg.expressions || {}
- const managed = [...Object.values(ORDER_EXPR_NAMES), ...LEGACY_ORDER_EXPR_NAMES]
-
- const next = { ...current }
- for (const name of managed) delete next[name]
- Object.assign(next, wanted)
-
- const same = JSON.stringify(next) === JSON.stringify(current)
- if (same) {
- // Nothing to do is a legitimate outcome, but "nothing was ordered" and
- // "the ordering is already applied" look identical from the outside.
- if (Object.keys(wanted).length === 0) {
- dbgOrder('no ordering to apply', {
- bucket_order: version?.bucket_order,
- seqs: Object.entries(logMeta || {})
- .filter(([, m]) => m.seq != null)
- .map(([id, m]) => `${id}:${m.tag || m.note}=${m.seq}`),
- })
+ table.addStyleListener(() => {
+ const body = table.querySelectorAll('tbody td')
+ // The deepest column path is a leaf; anything shorter is an aggregate of
+ // the levels below it, which is what makes a subtotal a subtotal.
+ //
+ // The empty levels are not empty strings. Perspective pads a subtotal's
+ // path with zero-width spaces -- ['04 - Forecast', '\u200b', 'sales_usd']
+ // -- so every path is the same length and a naive `!== ''` test finds no
+ // subtotals at all.
+ let depth = 0
+ const metas = []
+ for (const td of body) {
+ let meta
+ try { meta = table.getMeta(td) } catch { meta = null }
+ metas.push([td, meta])
+ const path = meta?.column_header
+ if (Array.isArray(path)) depth = Math.max(depth, path.filter(notBlank).length)
}
- else dbgOrder('exit: already applied', Object.keys(next))
- return
- }
- dbgOrder('applying', Object.keys(next))
- // An expression the pivot is using cannot simply vanish; drop it from the
- // axes first or restore() rejects the config.
- const stillValid = (col) => next[col] !== undefined || !managed.includes(col)
- try {
- await viewer.restore({
- ...cfg,
- expressions: next,
- columns: (cfg.columns || []).filter(c => c == null || stillValid(c)),
- group_by: (cfg.group_by || []).filter(stillValid),
- split_by: (cfg.split_by || []).filter(stillValid),
- sort: (cfg.sort || []).filter(([c]) => stillValid(c)),
- })
- dbgOrder('applied', Object.keys(next))
- } catch (err) {
- // Surfaced rather than logged: this failing silently is what made the
- // missing Bucket and Segment columns so hard to pin down -- the columns
- // simply were not there, with nothing to say why.
- console.error('[syncOrderExpressions]', err, { wanted, next })
- flash(`Column ordering failed: ${err.message || err}`, 'error')
- }
+ let prevGroup = null
+ for (const [td, meta] of metas) {
+ td.classList.remove('pf-group-start', 'pf-subtotal')
+ const path = meta?.column_header
+ if (!Array.isArray(path) || !path.length) { prevGroup = null; continue }
+ const named = path.filter(notBlank)
+ const group = named[0]
+ if (group !== prevGroup) { td.classList.add('pf-group-start'); prevGroup = group }
+ if (named.length < depth) td.classList.add('pf-subtotal')
+ }
+ })
+ table.draw()
}
// Size every column to its contents.
@@ -1378,15 +1370,11 @@ export default function Forecast({ sources = [], sourceId, versions = [], versio
if (cfg.group_by_depth != null) setExpandDepth(cfg.group_by_depth - 1)
else if (cfg.expand_depth != null) await applyDepth(cfg.expand_depth)
- // restore() replaces `expressions` wholesale, so loading a layout drops the
- // ordering columns — and a layout saved before they existed has none to put
- // back. Re-applied after every restore that comes from a saved config, which
- // is the general form of the fix initViewer already needed.
- await syncOrderExpressions()
await ensureRowLabelWidth()
setActiveLayoutId(layout.id)
- // After the sync, so the persisted copy carries the expressions too.
+ // The persisted copy is taken after the restore, so it carries whatever
+ // cleanLayout dropped on the way in rather than the stale original.
const merged = await captureConfig()
await persistLayout(versionId, merged || cfg)
}
@@ -1409,6 +1397,11 @@ export default function Forecast({ sources = [], sourceId, versions = [], versio
async function submitOp(op) {
if (!slices.length) { flash('Select a slice first', 'error'); return }
+ // The pivot's filter scopes what the ledger counted, so it has to scope what
+ // gets written too -- otherwise the panel shows one number and the operation
+ // changes a larger set. It travels as [col, op, value] rather than folded
+ // into the slices, because a slice is {col: value} and can only mean
+ // equality: a view filtered to sseas_e <= 2027 has no slice form at all.
const body = buildPayload(op)
if (!body) return
if (body.slices.some(sl => !Object.keys(sl).length)) {
@@ -1516,7 +1509,7 @@ export default function Forecast({ sources = [], sourceId, versions = [], versio
.map(([id, m]) => ({
id: Number(id),
operation: m.operation,
- label: (m.tag || m.note || '').trim(),
+ label: (m.label || m.tag || m.note || '').trim(),
}))
.sort((a, b) => a.id - b.id)
@@ -1525,6 +1518,10 @@ export default function Forecast({ sources = [], sourceId, versions = [], versio
const dateCols = new Set(colMetaRef.current.filter(c => c.role === 'date').map(c => c.cname))
const out = {}
for (const [k, v] of Object.entries(raw)) {
+ // Not col_meta columns, but real ones here and resolvable server-side to the
+ // set of pf.log ids that carry the name. Dropping them is what let a click on
+ // one bucket's cell scale every bucket at that intersection.
+ if (COMPUTED_SLICE_COLS.has(k)) { out[k] = v; continue }
if (dimCols.has(k)) { out[k] = v; continue }
if (dateCols.has(k)) {
const ms = Number(v)
@@ -1534,7 +1531,11 @@ export default function Forecast({ sources = [], sourceId, versions = [], versio
return out
}
+ // The scope is read from the ref rather than passed in: the request preview in
+ // the panel calls this too, and when it was a parameter the preview defaulted
+ // it away -- showing a payload with no scope for a write that had one.
function buildPayload(op) {
+ const viewFilter = viewFilterRef.current || []
if (!slices.length) return null
// Two clicked cells can differ only by a column the operation cannot filter on
// (pf_iter, say, which is not in col_meta and so is dropped here). Those become
@@ -1553,6 +1554,7 @@ export default function Forecast({ sources = [], sourceId, versions = [], versio
let body = {
tag: opTag.trim() || undefined,
slices: effectiveSlices,
+ ...(viewFilter.length ? { scope: viewFilter } : {}),
...(effectiveSlices.length > 1 ? { apply_mode: applyMode } : {}),
}
if (op === 'scale') {
@@ -1702,6 +1704,7 @@ export default function Forecast({ sources = [], sourceId, versions = [], versio
distinctSlices,
dock,
slices, setSlices,
+ viewScope,
applyMode, setApplyMode,
currentTotals,
activeOp, setActiveOp,
@@ -1973,7 +1976,9 @@ export default function Forecast({ sources = [], sourceId, versions = [], versio
{loading && (
- Loading…
+
+ {loadRows ? `Loading ${loadRows.toLocaleString()} rows…` : 'Loading…'}
+
{loadProgress && (
<>
@@ -2121,12 +2126,22 @@ function LogCell({ entry, field, placeholder, editing, setEditing, onSave, listI
const META_COL_RE = /^__(?:ROW_PATH(?:_\d+)?|ID|GROUPING_ID)__$/
// Perspective encodes a clicked/selected row position as [col, '==', value] triples
-function sliceFromFilters(filters) {
+// `measures` is the view's `columns` list. Clicking a cell whose column axis is
+// collapsed makes Perspective emit the measure name as the value of the first
+// hidden split_by dimension -- a bucket subtotal arrives as
+// ["smon_e", "==", "sales_usd"] -- because the engine maps split_by positionally
+// over a column name that no longer has that many segments. Left in, the slice
+// asks for a month equal to a measure, matches nothing, and the operation
+// silently has no rows to act on.
+function sliceFromFilters(filters, measures = []) {
+ const measureSet = new Set(measures)
const s = {}
for (const f of filters) {
if (!Array.isArray(f)) continue
const [col, op, val] = f
- if (op === '==' && val != null) s[col] = String(val)
+ if (op !== '==' || val == null) continue
+ if (measureSet.has(String(val))) continue
+ s[col] = String(val)
}
return s
}
|