// Numbers for the Charts page (app/(app)/charts). Pure: `node src/lib/charts.test.ts` runs it. // Amounts use the app's sign: positive = money out. Rows arrive already filtered and already split into spend and // income by the same rule as everywhere else (isSpend / isIncome in lib/data.ts), so transfers never count. export type Group = "day" | "week" | "month"; export type Row = { date: string; // YYYY-MM-DD amount: number; spend: boolean; income: boolean; categoryId: string | null; merchant: string; accountId: string | null; }; export type Period = { key: string; label: string; from: string; to: string }; const DAY = 864e5; const iso = (t: number) => new Date(t).toISOString().slice(0, 10); const at = (d: string) => Date.parse(`${d}T00:00:00Z`); const MONTHS = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"]; const round2 = (n: number) => Math.round(n * 100) / 100; /** The period a day falls in: the day itself, the Monday of its week, or its month. */ export function periodKey(d: string, g: Group) { if (g === "day") return d; if (g === "month") return d.slice(0, 7); const t = at(d), wd = (new Date(t).getUTCDay() + 6) % 7; // Monday = 0 return iso(t - wd * DAY); } /** Every period from `from` to `to` (inclusive), so empty ones still show as zero. */ export function periods(from: string, to: string, g: Group): Period[] { const out: Period[] = []; let key = periodKey(from, g); const last = periodKey(to, g); for (let guard = 0; key <= last && guard < 4000; guard++) { if (g === "month") { const [y, m] = key.split("-").map(Number); const next = m === 12 ? `${y + 1}-01` : `${y}-${String(m + 1).padStart(2, "0")}`; out.push({ key, label: `${MONTHS[m - 1]}${m === 1 || !out.length ? ` '${String(y).slice(2)}` : ""}`, from: `${key}-01`, to: iso(at(`${next}-01`) - DAY) }); key = next; } else { const span = g === "day" ? 1 : 7, d = new Date(at(key)); out.push({ key, label: `${d.getUTCDate()} ${MONTHS[d.getUTCMonth()]}`, from: key, to: iso(at(key) + (span - 1) * DAY) }); key = iso(at(key) + span * DAY); } } return out; } /** The same length of time just before [from, to]: what "compare with previous period" compares with. */ export function previousRange(from: string, to: string) { const len = at(to) - at(from) + DAY; return { from: iso(at(from) - len), to: iso(at(from) - DAY) }; } export type Flow = { key: string; income: number; spend: number; net: number }; export function cashFlow(rows: Row[], ps: Period[], g: Group): Flow[] { const by = new Map(ps.map((p) => [p.key, { key: p.key, income: 0, spend: 0, net: 0 }])); for (const r of rows) { const f = by.get(periodKey(r.date, g)); if (!f) continue; if (r.spend) f.spend += r.amount; else if (r.income) f.income -= r.amount; // money in is negative in the app's sign } return [...by.values()].map((f) => ({ key: f.key, income: round2(f.income), spend: round2(f.spend), net: round2(f.income - f.spend) })); } /** Share of income kept, per period. null where nothing came in (a rate of nothing isn't 0%). */ export const savingsRate = (flows: Flow[]) => flows.map((f) => ({ key: f.key, rate: f.income > 0 ? Math.round(((f.income - f.spend) / f.income) * 1000) / 10 : null })); /** Spending per period per category: the `keep` categories by name, everything else summed as "other". */ export function categoriesOver(rows: Row[], ps: Period[], g: Group, keep: string[]) { const by = new Map(ps.map((p) => [p.key, Object.fromEntries([...keep, "other"].map((k) => [k, 0])) as Record])); for (const r of rows) { if (!r.spend) continue; const b = by.get(periodKey(r.date, g)); if (!b) continue; const k = r.categoryId && keep.includes(r.categoryId) ? r.categoryId : "other"; b[k] = round2(b[k] + r.amount); } return ps.map((p) => ({ key: p.key, values: by.get(p.key)! })); } /** Biggest first, by money spent: the stable order categories and merchants take their colors from. */ export function rankBySpend(rows: Row[], of: (r: Row) => string | null) { const sum = new Map(); for (const r of rows) { const k = of(r); if (r.spend && k) sum.set(k, (sum.get(k) ?? 0) + r.amount); } return [...sum.entries()].sort((a, b) => b[1] - a[1]).map(([k]) => k); } /** Running total of spending day by day through a month, for this month, last month and the average of the three before. */ export function monthToDate(rows: Row[], today: string) { const month = (offset: number) => { const [y, m] = today.slice(0, 7).split("-").map(Number); const d = new Date(Date.UTC(y, m - 1 + offset, 1)); return iso(d.getTime()).slice(0, 7); }; const days = (key: string) => new Date(Date.UTC(Number(key.slice(0, 4)), Number(key.slice(5, 7)), 0)).getUTCDate(); const daily = (key: string) => { const out = new Array(days(key)).fill(0) as number[]; for (const r of rows) if (r.spend && r.date.startsWith(key)) out[Number(r.date.slice(8, 10)) - 1] += r.amount; let run = 0; return out.map((v) => (run = round2(run + v))); }; const thisKey = month(0), lastKey = month(-1); const upTo = Number(today.slice(8, 10)); const avgOf = [month(-1), month(-2), month(-3)].map(daily); const avg = Array.from({ length: 31 }, (_, i) => round2(avgOf.reduce((s, m) => s + (m[Math.min(i, m.length - 1)] ?? 0), 0) / avgOf.length)); return { thisMonth: thisKey, lastMonth: lastKey, current: daily(thisKey).slice(0, upTo), last: daily(lastKey), average: avg.slice(0, days(thisKey)), }; } export type Balance = { id: string; name: string; balance: number; owed: boolean }; /** Each account's balance at the end of every day in [from, to], worked back from today's balance: a day's balance is * today's plus what went out since (minus what came in). A card or loan counts what's owed; the total subtracts it. */ export function balances(accounts: Balance[], rows: Row[], from: string, to: string, step: Group) { const ds: string[] = []; for (let t = at(from); t <= at(to); t += DAY) ds.push(iso(t)); const marks = step === "day" ? ds : ds.filter((d, i) => i === ds.length - 1 || periodKey(ds[i + 1], step) !== periodKey(d, step)); // last day of each period const series = accounts.map((a) => { const mine = rows.filter((r) => r.accountId === a.id).sort((x, y) => y.date.localeCompare(x.date)); let i = 0, after = 0; // sum of amounts dated after the mark const values = [...marks].reverse().map((d) => { while (i < mine.length && mine[i].date > d) after += mine[i++].amount; return round2(a.owed ? a.balance - after : a.balance + after); }).reverse(); return { id: a.id, name: a.name, owed: a.owed, values }; }); const total = marks.map((_, j) => round2(series.reduce((s, x) => s + (x.owed ? -x.values[j] : x.values[j]), 0))); return { days: marks, series, total }; } /** Average spent on each weekday (Monday first): total spent on those days over how many of them the range holds. */ export function byWeekday(rows: Row[], from: string, to: string) { const sum = new Array(7).fill(0) as number[], count = new Array(7).fill(0) as number[]; for (let t = at(from); t <= at(to); t += DAY) count[(new Date(t).getUTCDay() + 6) % 7]++; for (const r of rows) if (r.spend && r.date >= from && r.date <= to) sum[(new Date(at(r.date)).getUTCDay() + 6) % 7] += r.amount; return sum.map((s, i) => round2(count[i] ? s / count[i] : 0)); } /** Spending per period for each of the given merchants. */ export function merchantsOver(rows: Row[], ps: Period[], g: Group, names: string[]) { const by = new Map(names.map((n) => [n, new Map(ps.map((p) => [p.key, 0]))])); for (const r of rows) { const m = r.spend ? by.get(r.merchant) : undefined; const k = periodKey(r.date, g); if (m?.has(k)) m.set(k, round2(m.get(k)! + r.amount)); } return names.map((n) => ({ name: n, values: ps.map((p) => by.get(n)!.get(p.key)!) })); } export type Change = { id: string; now: number; before: number; delta: number }; /** What went up and down most between two periods, by category and by merchant. Spending only. */ export function biggestChanges(now: Row[], before: Row[], of: (r: Row) => string | null, n = 5) { const sum = (rows: Row[]) => { const m = new Map(); for (const r of rows) { const k = of(r); if (r.spend && k) m.set(k, (m.get(k) ?? 0) + r.amount); } return m; }; const a = sum(now), b = sum(before); const all = [...new Set([...a.keys(), ...b.keys()])].map((id) => { const x = round2(a.get(id) ?? 0), y = round2(b.get(id) ?? 0); return { id, now: x, before: y, delta: round2(x - y) }; }).filter((c) => Math.abs(c.delta) >= 1); return { up: all.filter((c) => c.delta > 0).sort((p, q) => q.delta - p.delta).slice(0, n), down: all.filter((c) => c.delta < 0).sort((p, q) => p.delta - q.delta).slice(0, n), }; } /** Totals for the header: spent, earned and kept. */ export function totals(rows: Row[]) { let spend = 0, income = 0; for (const r of rows) { if (r.spend) spend += r.amount; else if (r.income) income -= r.amount; } return { spend: round2(spend), income: round2(income), net: round2(income - spend) }; }