190 lines
9.1 KiB
TypeScript
190 lines
9.1 KiB
TypeScript
// 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<string, number>]));
|
||
|
|
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<string, number>();
|
||
|
|
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<string, number>();
|
||
|
|
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) };
|
||
|
|
}
|