Literaltypen und as const; Projekt: ein typisiertes Adressbuch

export function shippingCost(speed: string): number {
  return speed === "express" ? 9.9 : 4.9;
}

console.log("Express: " + shippingCost("expres").toFixed(2) + " EUR");
console.log("Standard: " + shippingCost("standard").toFixed(2) + " EUR");

import {test} from 'node:test';
import assert from 'node:assert/strict';
import {runMain} from './learnrun.js';
import {shippingCost} from './main.ts';

test('shippingCost("express") ist 9.9', () => {
  assert.equal(shippingCost('express'), 9.9, 'shippingCost("express") sollte 9.9 sein');
});

test('shippingCost("standard") ist 4.9', () => {
  assert.equal(shippingCost('standard'), 4.9, 'shippingCost("standard") sollte 4.9 sein');
});

test('das Programm gibt beide Preise aus', async () => {
  const out = (await runMain()).trimEnd();
  assert.equal(out, 'Express: 9.90 EUR\nStandard: 4.90 EUR', `das Programm gab ${JSON.stringify(out)} aus`);
});

{
  "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"
  ]
}

export function request(url: string, method: "GET" | "POST"): string {
  return method + " " + url;
}

const home = { url: "/home", method: "GET" };
const login = { url: "/login", method: "POST" };
console.log(request(home.url, home.method));
console.log(request(login.url, login.method));

import {test} from 'node:test';
import assert from 'node:assert/strict';
import {runMain} from './learnrun.js';
import {request} from './main.ts';

test('request verbindet Methode und URL', () => {
  assert.equal(request('/cart', 'POST'), 'POST /cart', 'request("/cart", "POST") sollte POST /cart sein');
});

test('das Programm gibt beide Anfragen aus', async () => {
  const out = (await runMain()).trimEnd();
  assert.equal(out, 'GET /home\nPOST /login', `das Programm gab ${JSON.stringify(out)} aus`);
});

{
  "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"
  ]
}

// A typed contact book. Declare the types, then finish the functions.

// 1. Kind: "friend", "work" or "family".
// 2. Contact: name and email (text), phone (optional text), kind (a Kind),
//    favorite (true or false).

export const KINDS = ["friend", "work", "family"];

export function formatContact(contact: Contact): string {
  // "* Ada Lovelace <ada@example.com> (work, no phone)"; only favorites start with "* "
  return "";
}

export function byKind(book: Contact[], kind: Kind): Contact[] {
  return [];
}

export function favorites(book: Contact[]): string[] {
  // the names of every favorite, in book order
  return [];
}

export function summary(book: Contact[]): string {
  // "friend: 1, work: 2, family: 0", in the order of KINDS
  const parts: string[] = [];
  for (const kind of KINDS) {
    parts.push(kind + ": " + byKind(book, kind).length);
  }
  return parts.join(", ");
}

const ada = { name: "Ada Lovelace", email: "ada@example.com", kind: "work", favorite: true };

const book: Contact[] = [
  ada,
  { name: "Grace Hopper", email: "grace@example.com", phone: "+49 30 1234567", kind: "work", favorite: false },
  { name: "Linus Torvalds", email: "linus@example.com", kind: "friend", favorite: true },
];

for (const contact of book) {
  console.log(formatContact(contact));
}
console.log(summary(book));
console.log("Favorites: " + favorites(book).join(", "));

import {test} from 'node:test';
import assert from 'node:assert/strict';
import {runMain} from './learnrun.js';
import {formatContact, byKind, favorites, summary} from './main.ts';

const ada = {name: 'Ada', email: 'ada@example.com', kind: 'work', favorite: true};
const bob = {name: 'Bob', email: 'bob@example.com', phone: '555-0100', kind: 'family', favorite: false};
const cy = {name: 'Cy', email: 'cy@example.com', kind: 'work', favorite: false};
const book = [ada, bob, cy];

test('formatContact markiert einen Favoriten ohne Telefon', () => {
  const line = formatContact(ada);
  assert.equal(line, '* Ada <ada@example.com> (work, no phone)', `formatContact(ada) lieferte ${JSON.stringify(line)}`);
});

test('formatContact zeigt das Telefon eines Kontakts, der kein Favorit ist', () => {
  const line = formatContact(bob);
  assert.equal(line, 'Bob <bob@example.com> (family, 555-0100)', `formatContact(bob) lieferte ${JSON.stringify(line)}`);
});

test('byKind behält nur die Kontakte dieser Art', () => {
  const names = byKind(book, 'work').map((contact) => contact.name);
  assert.deepEqual(names, ['Ada', 'Cy'], `byKind(book, 'work') lieferte ${JSON.stringify(names)}`);
  assert.equal(byKind(book, 'friend').length, 0, 'byKind(book, "friend") sollte leer sein');
});

test('favorites liefert die Namen der Favoriten', () => {
  const names = favorites(book);
  assert.deepEqual(names, ['Ada'], `favorites(book) lieferte ${JSON.stringify(names)}`);
});

test('summary zählt jede Art', () => {
  const text = summary(book);
  assert.equal(text, 'friend: 0, work: 2, family: 1', `summary(book) lieferte ${JSON.stringify(text)}`);
});

test('das Programm gibt das ganze Adressbuch aus', async () => {
  const out = (await runMain()).trimEnd();
  assert.equal(
    out,
    '* Ada Lovelace <ada@example.com> (work, no phone)\nGrace Hopper <grace@example.com> (work, +49 30 1234567)\n* Linus Torvalds <linus@example.com> (friend, no phone)\nfriend: 1, work: 2, family: 0\nFavorites: Ada Lovelace, Linus Torvalds',
    `das Programm gab ${JSON.stringify(out)} aus`
  );
});

{
  "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"
  ]
}