((acc, p) => [...acc, (acc.length ? acc[acc.length - 1] : opening) + p.debit - p.credit], []);
const dr = postings.reduce((s, p) => s + p.debit, 0);
const cr = postings.reduce((s, p) => s + p.credit, 0);
const cell = "px-3 py-2";
return (
Statement for {account.code} {account.name}, {from} to {to}
{["Date", "Reference", "Details", "Debit", "Credit", "Balance"].map((h, i) => (
| = 3 && "text-right")}>
{h}
|
))}
| {from} |
Opening balance
|
|
{postings.map((p, i) => {
return (
| {formatDate(p.date)} |
{p.ref} |
{p.details} |
{p.debit ? fmt.format(p.debit) : ""} |
{p.credit ? fmt.format(p.credit) : ""} |
|
);
})}
|
Closing balance, {to}
|
{fmt.format(dr)} |
{fmt.format(cr)} |
|
);
}
/* ----------------------------------- Trial balance ----------------------------------- */
/**
* Trial balance (AC-05): every account with a balance, in a debit or credit column, totals, and whether
* they agree. Each account's own balance, parents included (a parent such as 4000 Sales has postings of its own);
* nothing is counted twice because no balance includes another account's.
*/
export function TrialBalance({ accounts, asAt }: { accounts: LedgerAccount[]; asAt: string }) {
const leaves = accounts.filter((a) => a.balance !== 0).sort((x, y) => x.code.localeCompare(y.code));
const dr = leaves.reduce((s, a) => s + Math.max(0, a.balance), 0);
const cr = leaves.reduce((s, a) => s + Math.max(0, -a.balance), 0);
const diff = Math.round((dr - cr) * 100) / 100;
const cell = "px-3 py-1.5";
return (
{diff === 0 ? : }
{diff === 0 ? `Balanced as at ${asAt}: debits and credits are both KES ${fmt.format(dr)}.` : `Out of balance by KES ${fmt.format(Math.abs(diff))}. Every posting balances, so this means data was changed outside Medora: report it.`}
Trial balance as at {asAt}
|
Number
|
Account
|
Debit
|
Credit
|
{leaves.map((a) => (
| {a.code} |
{a.name}
{a.branch ? {a.branch} : null}
|
{a.balance > 0 ? fmt.format(a.balance) : ""} |
{a.balance < 0 ? fmt.format(-a.balance) : ""} |
))}
|
Totals, {leaves.length} accounts
|
{fmt.format(dr)} |
{fmt.format(cr)} |
);
}
/* ------------------------------- P&L and balance sheet ------------------------------- */
/** One account's figure per period, shown the natural way round (income and expenses both positive). */
export type StatementRow = { code: string; name: string; amounts: number[] };
const pctChange = (now: number, before?: number) => (before ? ((now - before) / Math.abs(before)) * 100 : undefined);
function YearCells({ values, strong = false, negativeBad = false }: { values: number[]; strong?: boolean; negativeBad?: boolean }) {
const ch = pctChange(values[0], values[1]);
return (
<>
{values.map((v, i) => (
0 && "text-muted-foreground", negativeBad && v < 0 && "text-status-error-text")}>
{v < 0 ? `(${fmt.format(-v)})` : fmt.format(v)}
|
))}
{ch === undefined ? "–" : `${ch > 0 ? "+" : "−"}${Math.abs(ch).toFixed(1)}%`} |
);
}
const sumCols = (rows: StatementRow[], n: number) => Array.from({ length: n }, (_, i) => rows.reduce((s, r) => s + (r.amounts[i] ?? 0), 0));
/**
* Profit & loss (AC-05) with up to three years side by side and the change on the latest. Net revenue
* excludes VAT; cost of sales (5xxx) gives gross profit; operating expenses (6xxx) give net profit. Losses
* show in brackets.
*/
export function ProfitAndLoss({ periods, income, costOfSales, expenses }: { periods: string[]; income: StatementRow[]; costOfSales: StatementRow[]; expenses: StatementRow[] }) {
const n = periods.length;
const inc = sumCols(income, n);
const cos = sumCols(costOfSales, n);
const gp = inc.map((v, i) => v - cos[i]);
const ex = sumCols(expenses, n);
const np = gp.map((v, i) => v - ex[i]);
const block = (title: string, rows: StatementRow[], total: number[], totalLabel: string) => (
<>
|
{title}
|
{rows.map((r) => (
|
{r.code}
{r.name}
|
))}
|
{totalLabel}
|
);
return (
Profit and loss
|
KES
|
{periods.map((p) => (
{p}
|
))}
Change
|
{block("Income (excluding VAT)", income, inc, "Net revenue")}
{block("Cost of sales", costOfSales, cos, "Total cost of sales")}
|
Gross profit
Margin {inc[0] ? ((gp[0] / inc[0]) * 100).toFixed(1) : "0"}%
|
{block("Operating expenses", expenses, ex, "Total expenses")}
|
Net profit
|
);
}
/**
* Balance sheet (AC-05) at each year end: assets against liabilities and equity, where equity includes the
* year's profit. The two sides must agree; if they don't, the check says so rather than hiding it.
*/
export function BalanceSheet({ periods, assets, liabilities, equity }: { periods: string[]; assets: StatementRow[]; liabilities: StatementRow[]; equity: StatementRow[] }) {
const n = periods.length;
const a = sumCols(assets, n);
const l = sumCols(liabilities, n);
const e = sumCols(equity, n);
const gap = a.map((v, i) => Math.round((v - l[i] - e[i]) * 100) / 100);
const ok = gap.every((g) => g === 0);
const block = (title: string, rows: StatementRow[], total: number[]) => (
<>
|
{title}
|
{rows.map((r) => (
|
{r.code}
{r.name}
|
))}
|
Total {title.toLowerCase()}
|
);
return (
{ok ? : }
{ok ? "Assets equal liabilities plus equity in every year." : `Out by ${periods.map((p, i) => (gap[i] ? `${fmt.format(Math.abs(gap[i]))} in ${p}` : null)).filter(Boolean).join(", ")}. Report it: every posting balances, so this means data changed outside Medora.`}
Balance sheet
|
KES, at year end
|
{periods.map((p) => (
{p}
|
))}
Change
|
{block("Assets", assets, a)}
{block("Liabilities", liabilities, l)}
{block("Equity", equity, e)}
|
Liabilities and equity
|
v + e[i])} strong />
);
}
/* --------------------------------- Opening balances --------------------------------- */
export type OpeningLine = { code: string; debit: string; credit: string };
/**
* Opening balances (AC-06): the balance of each account on the day Medora starts, from the old books.
* Entered on screen or imported from CSV. They post as one journal and must balance; the difference is
* shown until they do, and an account can't have both a debit and a credit.
*/
export function OpeningBalances({ accounts, lines, onChange }: { accounts: LedgerAccount[]; lines: Record; onChange: (code: string, l: OpeningLine) => void }) {
const leaves = accounts.filter((a) => !accounts.some((k) => k.parent === a.code) && a.active);
const num = (s: string) => Number(s.replace(/,/g, "")) || 0;
const dr = Object.values(lines).reduce((s, l) => s + num(l.debit), 0);
const cr = Object.values(lines).reduce((s, l) => s + num(l.credit), 0);
const diff = Math.round((dr - cr) * 100) / 100;
const both = Object.values(lines).filter((l) => num(l.debit) && num(l.credit)).map((l) => l.code);
return (
0 && !both.length ? TONE_BOX.success : TONE_BOX.warning)}>
{diff === 0 && dr > 0 && !both.length ? : }
{dr === 0 && cr === 0
? "Enter each account's balance from the old books, or import them."
: diff === 0 && !both.length
? `Balanced at KES ${fmt.format(dr)}. Ready to post as the opening journal.`
: diff !== 0
? `Debits are KES ${fmt.format(Math.abs(diff))} ${diff > 0 ? "more" : "less"} than credits. Check the old trial balance; the difference can't be posted.`
: "Fix the accounts that have both a debit and a credit."}
);
}