Design a Deck of Cards, Blackjack and a Chat Server (Class Models)

export const SUITS = ["hearts", "diamonds", "clubs", "spades"] as const;export const RANKS = ["A", "2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K"] as const;export type Suit = (typeof SUITS)[number];export type Rank = (typeof RANKS)[number];export interface Card {  readonly rank: Rank;  readonly suit: Suit;}export const show = (c: Card) => c.rank + c.suit[0].toUpperCase();export class Deck {  private cards: Card[];  private next = 0; // index of the next card to deal  constructor(cards?: Card[]) {    this.cards = cards ?? SUITS.flatMap((suit) => RANKS.map((rank) => ({ rank, suit })));  }  get remaining(): number {    return this.cards.length - this.next;  }  // Fisher-Yates. The random source is injected, so tests can control it.  shuffle(rand: () => number = Math.random): void {    for (let i = this.cards.length - 1; i > 0; i--) {      const j = Math.floor(rand() * (i + 1));      [this.cards[i], this.cards[j]] = [this.cards[j], this.cards[i]];    }    this.next = 0;  }  deal(): Card {    if (this.next >= this.cards.length) throw new Error("deck is empty");    return this.cards[this.next++];  }}export class Hand {  readonly cards: Card[] = [];  add(c: Card): void {    this.cards.push(c);  }}// Blackjack rules live in a subclass, so Hand stays usable for poker.export class BlackjackHand extends Hand {  // Count every ace as 1, then upgrade ONE ace to 11 if that does not bust.  get score(): number {    let total = 0;    let aces = 0;    for (const c of this.cards) {      if (c.rank === "A") { aces++; total += 1; }      else if (c.rank === "J" || c.rank === "Q" || c.rank === "K") total += 10;      else total += Number(c.rank);    }    return aces > 0 && total + 10 <= 21 ? total + 10 : total;  }  get isBust(): boolean { return this.score > 21; }  get isBlackjack(): boolean { return this.cards.length === 2 && this.score === 21; }}// ---- A round of blackjack. No bets, splits or doubling. ----export type Move = "hit" | "stand";export type PlayerStrategy = (hand: BlackjackHand, dealerUp: Card) => Move;export type Outcome = "player blackjack" | "player wins" | "dealer wins" | "push";export const standOn17: PlayerStrategy = (h) => (h.score >= 17 ? "stand" : "hit");export const standOn12: PlayerStrategy = (h) => (h.score >= 12 ? "stand" : "hit");export function playRound(deck: Deck, player: PlayerStrategy): { outcome: Outcome; player: BlackjackHand; dealer: BlackjackHand } {  const p = new BlackjackHand();  const d = new BlackjackHand();  p.add(deck.deal()); d.add(deck.deal()); p.add(deck.deal()); d.add(deck.deal());  const finish = (outcome: Outcome) => ({ outcome, player: p, dealer: d });  if (p.isBlackjack || d.isBlackjack) {    if (p.isBlackjack && d.isBlackjack) return finish("push");    return finish(p.isBlackjack ? "player blackjack" : "dealer wins");  }  while (!p.isBust && player(p, d.cards[0]) === "hit") p.add(deck.deal());  if (p.isBust) return finish("dealer wins");  while (d.score < 17) d.add(deck.deal()); // house rule used here: dealer stands on all 17s  if (d.isBust || p.score > d.score) return finish("player wins");  return finish(p.score === d.score ? "push" : "dealer wins");}

import { BlackjackHand, Deck, playRound, show, standOn12, standOn17, type Card, type Rank, type Suit } from "./cards.ts";import { ChatServer } from "./chat.ts";const c = (rank: Rank, suit: Suit = "spades"): Card => ({ rank, suit });const hand = (...r: Rank[]) => { const h = new BlackjackHand(); r.forEach((x) => h.add(c(x))); return h.score; };console.log("A+K =", hand("A", "K"), "| A+A+9 =", hand("A", "A", "9"), "| A+6+10 =", hand("A", "6", "10"), "| K+Q+5 =", hand("K", "Q", "5"));// mulberry32: a tiny seeded random generator, so the output is the same every runfunction seeded(a: number) {  return () => { a = (a + 0x6d2b79f5) | 0; let t = Math.imul(a ^ (a >>> 15), 1 | a); t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t; return ((t ^ (t >>> 14)) >>> 0) / 4294967296; };}const deck = new Deck();deck.shuffle(seeded(7));console.log("first five after shuffle:", [deck.deal(), deck.deal(), deck.deal(), deck.deal(), deck.deal()].map(show).join(" "), "| remaining", deck.remaining);const tally = (s: typeof standOn17) => {  const rand = seeded(2026), t: Record<string, number> = {};  for (let i = 0; i < 20000; i++) { const d = new Deck(); d.shuffle(rand); const o = playRound(d, s).outcome; t[o] = (t[o] ?? 0) + 1; }  return t;};console.log("stand on 17:", JSON.stringify(tally(standOn17)));console.log("stand on 12:", JSON.stringify(tally(standOn12)));const s = new ChatServer(() => 0);for (const n of ["ann", "bob", "cy"]) s.addUser(n, n);s.subscribe("bob", (m) => console.log(`  bob's screen <- [${m.chatId}] ${m.from}: ${m.text}`));const r1 = s.sendFriendRequest("ann", "bob"); s.respond(r1.id, "bob", true);const r2 = s.sendFriendRequest("ann", "cy"); s.respond(r2.id, "cy", true);s.messageUser("ann", "bob", "hi bob");const g = s.createGroup("ann", "trip", ["bob", "cy"]);s.post(g, "cy", "who is driving?");console.log("bob unread in group:", s.unread("bob", g)); s.markRead("bob", g);console.log("after markRead     :", s.unread("bob", g));try { s.messageUser("bob", "cy", "psst"); } catch (e) { console.log("bob -> cy:", (e as Error).message); }

$ node demo.tsA+K = 21 | A+A+9 = 21 | A+6+10 = 17 | K+Q+5 = 25first five after shuffle: JD 10H QS 5D 7S | remaining 47stand on 17: {"player wins":7427,"dealer wins":9807,"push":1832,"player blackjack":934}stand on 12: {"player wins":7501,"dealer wins":10386,"push":1179,"player blackjack":934}  bob's screen <- [dm:ann|bob] ann: hi bob  bob's screen <- [group:trip] cy: who is driving?bob unread in group: 1after markRead     : 0bob -> cy: you can only message friends

test("blackjack scoring: aces count as 11 only when that does not bust", () => {  assert.equal(score("A", "K").score, 21);  assert.equal(score("A", "A", "9").score, 21); // 11 + 1 + 9  assert.equal(score("A", "6", "10").score, 17); // the ace had to drop to 1  assert.equal(score("A", "A", "A", "A").score, 14);  assert.equal(score("K", "Q", "5").isBust, true);  assert.equal(score("A", "5", "5").isBlackjack, false); // 21 with three cards is not a natural});// deal order: player, dealer, player, dealer, then drawstest("round: natural blackjack, both naturals, dealer natural", () => {  assert.equal(playRound(stack("A", "5", "K", "6"), standOn17).outcome, "player blackjack");  assert.equal(playRound(stack("A", "A", "K", "K"), standOn17).outcome, "push");  assert.equal(playRound(stack("9", "A", "8", "K"), standOn17).outcome, "dealer wins");});test("round: player bust loses and the dealer does not draw", () => {  const r = playRound(stack("10", "2", "6", "3", "K"), standOn17);  assert.equal(r.outcome, "dealer wins");  assert.equal(r.dealer.cards.length, 2);});test("round: dealer draws to 17, busts, or pushes", () => {  const draws = playRound(stack("10", "5", "8", "2", "4", "6"), standOn17);  assert.equal(draws.dealer.score, 17);  assert.equal(draws.outcome, "player wins");  assert.equal(playRound(stack("10", "10", "8", "6", "9"), standOn17).outcome, "player wins"); // dealer bust  assert.equal(playRound(stack("10", "10", "8", "8"), standOn17).outcome, "push");});

export type Status = "pending" | "accepted" | "rejected";export interface Message { id: number; chatId: string; from: string; text: string; at: number }export interface FriendRequest { id: number; from: string; to: string; status: Status }type Listener = (m: Message) => void;class User {  readonly friends = new Set<string>();  listener: Listener | null = null; // set while the user is online  readonly id: string;  readonly name: string;  constructor(id: string, name: string) { this.id = id; this.name = name; }}// One conversation. Private chats have 2 members; group chats have an owner and can grow.class Chat {  readonly messages: Message[] = [];  readonly members: Set<string>;  readonly id: string;  readonly owner: string | null;  constructor(id: string, members: string[], owner: string | null) {    this.id = id; this.members = new Set(members); this.owner = owner;  }}export class ChatServer {  private readonly users = new Map<string, User>();  private readonly chats = new Map<string, Chat>();  private readonly requests: FriendRequest[] = [];  private readonly readUpTo = new Map<string, number>(); // "user|chat" -> last message id seen  private nextId = 1;  private readonly now: () => number;  constructor(now: () => number = Date.now) { this.now = now; }  private user(id: string): User {    const u = this.users.get(id);    if (!u) throw new Error(`no such user: ${id}`);    return u;  }  addUser(id: string, name: string): void {    if (this.users.has(id)) throw new Error(`user exists: ${id}`);    this.users.set(id, new User(id, name));  }  // Observer: the user's connection registers a callback and gets messages pushed.  subscribe(id: string, fn: Listener | null): void { this.user(id).listener = fn; }  sendFriendRequest(from: string, to: string): FriendRequest {    this.user(from); this.user(to);    if (from === to) throw new Error("cannot befriend yourself");    if (this.user(from).friends.has(to)) throw new Error("already friends");    if (this.requests.some((r) => r.status === "pending" && ((r.from === from && r.to === to) || (r.from === to && r.to === from)))) throw new Error("request already pending");    const r: FriendRequest = { id: this.nextId++, from, to, status: "pending" };    this.requests.push(r);    return r;  }  respond(requestId: number, by: string, accept: boolean): void {    const r = this.requests.find((x) => x.id === requestId);    if (!r || r.to !== by) throw new Error("no such request for this user");    if (r.status !== "pending") throw new Error(`request already ${r.status}`); // invalid transition    r.status = accept ? "accepted" : "rejected";    if (accept) { this.user(r.from).friends.add(r.to); this.user(r.to).friends.add(r.from); }  }  messageUser(from: string, to: string, text: string): Message {    if (!this.user(from).friends.has(to)) throw new Error("you can only message friends");    const id = "dm:" + [from, to].sort().join("|"); // one private chat per pair, either direction    if (!this.chats.has(id)) this.chats.set(id, new Chat(id, [from, to], null));    return this.post(id, from, text);  }  createGroup(owner: string, name: string, memberIds: string[]): string {    for (const m of memberIds) if (!this.user(owner).friends.has(m)) throw new Error(`${m} is not your friend`);    const id = "group:" + name;    if (this.chats.has(id)) throw new Error("group exists");    this.chats.set(id, new Chat(id, [owner, ...memberIds], owner));    return id;  }  invite(by: string, chatId: string, who: string): void {    const c = this.chat(chatId);    if (c.owner === null) throw new Error("cannot invite to a private chat");    if (!c.members.has(by)) throw new Error("only members can invite");    if (!this.user(by).friends.has(who)) throw new Error(`${who} is not your friend`);    c.members.add(who);  }  private chat(id: string): Chat {    const c = this.chats.get(id);    if (!c) throw new Error(`no such chat: ${id}`);    return c;  }  post(chatId: string, from: string, text: string): Message {    const c = this.chat(chatId);    if (!c.members.has(from)) throw new Error("not a member of this chat");    const m: Message = { id: this.nextId++, chatId, from, text, at: this.now() };    c.messages.push(m);    for (const uid of c.members) if (uid !== from) this.users.get(uid)!.listener?.(m); // push to online users    return m;  }  unread(userId: string, chatId: string): number {    const seen = this.readUpTo.get(userId + "|" + chatId) ?? 0;    return this.chat(chatId).messages.filter((m) => m.id > seen && m.from !== userId).length;  }  markRead(userId: string, chatId: string): void {    const ms = this.chat(chatId).messages;    if (ms.length > 0) this.readUpTo.set(userId + "|" + chatId, ms[ms.length - 1].id);  }}

test("chat: only members post, only online members get pushes", () => {  const { s } = setup();  const got: string[] = [];  s.subscribe("bob", (m) => got.push(`bob:${m.text}`));  s.subscribe("cy", (m) => got.push(`cy:${m.text}`));  const g = s.createGroup("ann", "trip", ["bob"]);  assert.throws(() => s.post(g, "cy", "let me in"), /not a member/);  s.post(g, "ann", "hello");  assert.deepEqual(got, ["bob:hello"]); // cy is not in the group  s.invite("ann", g, "cy");  s.post(g, "bob", "welcome");  assert.deepEqual(got, ["bob:hello", "cy:welcome"]); // the sender gets no echo  assert.throws(() => s.createGroup("ann", "x", ["dee"]), /not your friend/);});

$ node --test --test-reporter=spec cards.test.ts | LC_ALL=C sed 's/\xE2\x9C\x94/pass/; s/\xE2\x84\xB9/#/'pass deck: 52 different cards, shuffle keeps them all, empty deck throws (2.133057ms)pass deck: same random source gives the same order (1.744312ms)pass blackjack scoring: aces count as 11 only when that does not bust (0.43314ms)pass round: natural blackjack, both naturals, dealer natural (0.426751ms)pass round: player bust loses and the dealer does not draw (0.241605ms)pass round: dealer draws to 17, busts, or pushes (0.26378ms)pass chat: friend request rules (2.589508ms)pass chat: one private chat per pair, in either direction (0.332719ms)pass chat: only members post, only online members get pushes (0.761834ms)pass chat: unread counts go down after markRead (0.69821ms)# tests 10# suites 0# pass 10# fail 0# cancelled 0# skipped 0# todo 0# duration_ms 237.781813