Typisierter Ausgabenteiler

// Typed expense splitter: who owes whom after a shared trip.
// Money is kept in whole cents (integers), so every sum is exact.
import {trip} from './trip.ts';

/** Someone paid an expense that the people in sharedBy split equally. */
export type Paid = {
  readonly kind: 'paid';
  readonly payer: string;
  readonly cents: number;
  readonly sharedBy: readonly string[];
  readonly note: string;
};

// Milestone 2: write Owed (from owes to: from, to, cents, note) and
// Settled (from paid back to: from, to, cents), each with its own kind,
// and make Entry the union of all three.
export type Entry = Paid;

/** Each person's balance in cents: above 0 gets money back, below 0 owes. */
export type Balances = {[person: string]: number};

/** One payment that settles a debt. */
export type Transfer = {readonly from: string; readonly to: string; readonly cents: number};

export function assertNever(value: never): never {
  throw new Error(`Unexpected entry: ${JSON.stringify(value)}`);
}

/** 1250 is "12.50", 5 is "0.05". */
export function formatCents(cents: number): string {
  // Milestone 1: Math.floor(cents / 100), then cents % 100 with padStart.
  return String(cents);
}

/** Split cents equally between people; the first people in the list take the extra cents. */
export function splitCents(cents: number, people: readonly string[]): number[] {
  // Milestone 1: throw a RangeError for no people, or cents that are not a whole number above 0.
  return [];
}

/** One line for one entry. */
export function describeEntry(entry: Entry): string {
  // Milestone 2: switch on entry.kind, one case per kind, and return assertNever(entry) in default.
  return '';
}

/** Add up every entry into one balance per person. */
export function balances(entries: readonly Entry[]): Balances {
  // Milestone 3: start from {} and add or subtract each entry's cents.
  return {};
}

/** One line per person, in alphabetical order. */
export function balanceLines(totals: Balances): string[] {
  // Milestone 4: "Ana gets back 58.66", "Ben owes 0.83" or "Dev is even".
  return [];
}

/** The largest debt is paid to the largest creditor first, until everyone is even. */
export function settleUp(totals: Balances): Transfer[] {
  // Milestone 4: two lists, debtors and creditors, each sorted largest first.
  return [];
}

/** Everything the program prints for a list of entries. */
export function report(entries: readonly Entry[]): string[] {
  const totals = balances(entries);
  return [
    'Entries:',
    ...entries.map((entry) => `  ${describeEntry(entry)}`),
    'Balances:',
    ...balanceLines(totals).map((line) => `  ${line}`),
    'To settle up:',
    ...settleUp(totals).map((t) => `  ${t.from} pays ${t.to} ${formatCents(t.cents)}`)
  ];
}

for (const line of report(trip)) console.log(line);

// The fixture: a weekend trip of three friends, in whole cents.
import type {Entry} from './main.ts';

export const trip: readonly Entry[] = [
  {kind: 'paid', payer: 'Ana', cents: 9000, sharedBy: ['Ana', 'Ben', 'Cleo'], note: 'dinner'},
  {kind: 'paid', payer: 'Ben', cents: 4500, sharedBy: ['Ben', 'Cleo'], note: 'museum tickets'},
  {kind: 'paid', payer: 'Cleo', cents: 1000, sharedBy: ['Ana', 'Ben', 'Cleo'], note: 'coffee'},
  {kind: 'owed', from: 'Cleo', to: 'Ana', cents: 1200, note: 'the train'},
  {kind: 'settled', from: 'Ben', to: 'Ana', cents: 1000}
];

// Compile-time checks: tsc type-checks this file, nothing runs it.
import type {Entry} from './main.ts';
import {assertNever, describeEntry} from './main.ts';

// 1. A kind that is not part of Entry is rejected.
// @ts-expect-error: 'refunded' is not a kind of Entry
const unknownKind: Entry = {kind: 'refunded', from: 'Ana', to: 'Ben', cents: 500};

// 2. A new variant that a switch does not handle fails to compile.
type Refunded = {readonly kind: 'refunded'; readonly from: string; readonly to: string; readonly cents: number};

export function describeWithRefunds(entry: Entry | Refunded): string {
  switch (entry.kind) {
    case 'paid':
    case 'owed':
    case 'settled':
      return describeEntry(entry);
    default:
      // @ts-expect-error: 'refunded' is not handled, so entry is a Refunded here, not never
      return assertNever(entry);
  }
}

export {unknownKind};

{
  "type": "module"
}

{
  "compilerOptions": {
    "target": "esnext",
    "module": "nodenext",
    "lib": [
      "esnext",
      "dom"
    ],
    "types": [],
    "strict": true,
    "noEmit": true,
    "erasableSyntaxOnly": true,
    "verbatimModuleSyntax": true,
    "allowImportingTsExtensions": true
  },
  "include": [
    "**/*.ts"
  ],
  "exclude": [
    "**/*.test.ts"
  ]
}

import {test} from 'node:test';
import assert from 'node:assert/strict';
import {runMain} from './learnrun.js';
import {balanceLines, balances, describeEntry, formatCents, settleUp, splitCents} from './main.ts';
import type {Entry} from './main.ts';
import {trip} from './trip.ts';

const lunch: Entry[] = [
  {kind: 'paid', payer: 'Ana', cents: 3000, sharedBy: ['Ana', 'Ben'], note: 'lunch'},
  {kind: 'owed', from: 'Ana', to: 'Dev', cents: 400, note: 'a coffee'},
  {kind: 'settled', from: 'Ben', to: 'Ana', cents: 500}
];

test('formatCents schreibt ganze Cent als Euro und Cent', () => {
  assert.equal(formatCents(1250), '12.50', 'formatCents(1250)');
  assert.equal(formatCents(5), '0.05', 'formatCents(5)');
  assert.equal(formatCents(80000), '800.00', 'formatCents(80000)');
});

test('splitCents teilt einen Betrag exakt, die ersten Personen übernehmen die übrigen Cent', () => {
  assert.deepEqual(splitCents(1000, ['Ana', 'Ben', 'Cleo']), [334, 333, 333], 'splitCents(1000, drei Personen)');
  assert.deepEqual(splitCents(4500, ['Ben', 'Cleo']), [2250, 2250], 'splitCents(4500, zwei Personen)');
  assert.deepEqual(splitCents(2, ['Ana', 'Ben', 'Cleo']), [1, 1, 0], 'splitCents(2, drei Personen)');
});

test('splitCents lehnt eine leere Personenliste und Beträge ab, die keine ganzen Cent über 0 sind', () => {
  assert.throws(() => splitCents(1000, []), RangeError, 'splitCents(1000, []) sollte einen RangeError werfen');
  assert.throws(() => splitCents(0, ['Ana']), RangeError, 'splitCents(0, ...) sollte einen RangeError werfen');
  assert.throws(() => splitCents(12.5, ['Ana']), RangeError, 'splitCents(12.5, ...) sollte einen RangeError werfen');
});

test('describeEntry schreibt für jede Art von Eintrag eine Zeile', () => {
  assert.equal(describeEntry(lunch[0]), 'Ana paid 30.00 for lunch, shared by Ana, Ben', 'der Eintrag paid');
  assert.equal(describeEntry(lunch[1]), 'Ana owes Dev 4.00 for a coffee', 'der Eintrag owed');
  assert.equal(describeEntry(lunch[2]), 'Ben paid Ana back 5.00', 'der Eintrag settled');
});

test('balances verrechnet Einträge paid, owed und settled', () => {
  assert.deepEqual(balances(lunch), {Ana: 600, Ben: -1000, Dev: 400}, 'Salden der Einträge von lunch');
  assert.deepEqual(balances([]), {}, 'Salden ohne Einträge');
});

test('Die Salden der Reise ergeben zusammen null', () => {
  const totals = balances(trip);
  assert.deepEqual(totals, {Ana: 5866, Ben: -83, Cleo: -5783}, 'Salden der Reise');
  const sum = Object.values(totals).reduce((a, b) => a + b, 0);
  assert.equal(sum, 0, 'die Salden jeder Gruppe müssen zusammen 0 Cent ergeben');
});

test('balanceLines sagt, wer Geld zurückbekommt, wer schuldet und wer ausgeglichen ist', () => {
  assert.deepEqual(
    balanceLines({Cleo: -5783, Ana: 5866, Dev: 0, Ben: -83}),
    ['Ana gets back 58.66', 'Ben owes 0.83', 'Cleo owes 57.83', 'Dev is even'],
    'eine Zeile pro Person, alphabetisch geordnet'
  );
});

test('settleUp zahlt die größte Schuld zuerst an den größten Gläubiger', () => {
  assert.deepEqual(
    settleUp({Ana: 5866, Ben: -83, Cleo: -5783}),
    [
      {from: 'Cleo', to: 'Ana', cents: 5783},
      {from: 'Ben', to: 'Ana', cents: 83}
    ],
    'die Überweisungen für die Reise'
  );
  assert.deepEqual(
    settleUp({Ana: -700, Ben: 300, Cleo: 400}),
    [
      {from: 'Ana', to: 'Cleo', cents: 400},
      {from: 'Ana', to: 'Ben', cents: 300}
    ],
    'ein Schuldner und zwei Gläubiger'
  );
  assert.deepEqual(settleUp({Ana: 0, Ben: 0}), [], 'eine schon ausgeglichene Gruppe braucht keine Überweisungen');
});

test('Das Programm gibt die Einträge, Salden und Überweisungen der Reise aus', async () => {
  const printed = (await runMain()).trimEnd().split('\n');
  const expected = [
    'Entries:',
    '  Ana paid 90.00 for dinner, shared by Ana, Ben, Cleo',
    '  Ben paid 45.00 for museum tickets, shared by Ben, Cleo',
    '  Cleo paid 10.00 for coffee, shared by Ana, Ben, Cleo',
    '  Cleo owes Ana 12.00 for the train',
    '  Ben paid Ana back 10.00',
    'Balances:',
    '  Ana gets back 58.66',
    '  Ben owes 0.83',
    '  Cleo owes 57.83',
    'To settle up:',
    '  Cleo pays Ana 57.83',
    '  Ben pays Ana 0.83'
  ];
  assert.deepEqual(printed, expected, `das Programm gab aus:\n${printed.join('\n')}`);
});